diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 00000000000..53b4cc20e5d
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,3 @@
+[[profile.default.overrides]]
+filter = 'test(compress_large_int)'
+priority = 100
diff --git a/.github/actions/check-rebuild/action.yml b/.github/actions/check-rebuild/action.yml
new file mode 100644
index 00000000000..c9fc5ddd23f
--- /dev/null
+++ b/.github/actions/check-rebuild/action.yml
@@ -0,0 +1,23 @@
+name: "Build and verify rebuild is a no-op"
+description: "Run a cargo command, then re-run it to verify all artifacts are cached"
+inputs:
+  command:
+    description: "The cargo build command to run and verify (--message-format json is appended on the verification run)"
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - name: "Build"
+      shell: bash
+      run: ${{ inputs.command }}
+    - name: "Verify rebuild is a no-op"
+      shell: bash
+      run: |
+        stale=$(${{ inputs.command }} \
+          --message-format json 2>/dev/null \
+          | jq -r 'select(.reason == "compiler-artifact" and .fresh == false) | .target.name')
+        if [ -n "$stale" ]; then
+          echo "ERROR: Rebuild recompiled crates that should have been cached:"
+          echo "$stale"
+          exit 1
+        fi
diff --git a/.github/actions/setup-prebuild/action.yml b/.github/actions/setup-prebuild/action.yml
new file mode 100644
index 00000000000..9cfc837b680
--- /dev/null
+++ b/.github/actions/setup-prebuild/action.yml
@@ -0,0 +1,49 @@
+name: "Setup Prebuild"
+description: "Prebuild AMIs — uses pre-installed tools, falls back to full setup-rust for forks"
+
+inputs:
+  repo-token:
+    description: "GitHub token for accessing the repository (typically secrets.GITHUB_TOKEN)"
+    required: false
+    default: "${{ github.token }}"
+  toolchain:
+    description: "optional override for the toolchain version (e.g. nightly)"
+    required: false
+  components:
+    description: "optional override for the components to install for the step (e.g. clippy, rustfmt, miri)"
+    default: "clippy, rustfmt"
+    required: false
+  targets:
+    description: "optional targets override (e.g. wasm32-unknown-unknown)"
+    required: false
+  enable-sccache:
+    description: "Should sccache be enabled, true by default."
+    required: false
+    default: "true"
+
+runs:
+  using: "composite"
+  steps:
+    # Prebuild path: tools already installed, just configure sccache
+    - name: Configure sccache timeout
+      if: github.repository == 'vortex-data/vortex' && inputs.enable-sccache == 'true'
+      shell: bash
+      run: |
+        mkdir -p ~/.config/sccache
+        echo 'server_startup_timeout_ms = 60000' > ~/.config/sccache/config
+
+    - name: Pre-start sccache server
+      if: github.repository == 'vortex-data/vortex' && inputs.enable-sccache == 'true'
+      shell: bash
+      run: sccache --start-server
+
+    # Fallback path: full setup for forks
+    - name: Full Rust setup
+      if: github.repository != 'vortex-data/vortex'
+      uses: ./.github/actions/setup-rust
+      with:
+        repo-token: ${{ inputs.repo-token }}
+        toolchain: ${{ inputs.toolchain }}
+        components: ${{ inputs.components }}
+        targets: ${{ inputs.targets }}
+        enable-sccache: ${{ inputs.enable-sccache }}
diff --git a/.github/actions/setup-rust/action.yml b/.github/actions/setup-rust/action.yml
index d8698b7bac8..5fea9acaa53 100644
--- a/.github/actions/setup-rust/action.yml
+++ b/.github/actions/setup-rust/action.yml
@@ -3,9 +3,9 @@ description: "Toolchain setup and Initial compilation"
 
 inputs:
   repo-token:
-    description: "Deprecated: no longer used. Protoc is now downloaded directly from GitHub releases CDN."
+    description: "GitHub token for accessing the repository (typically secrets.GITHUB_TOKEN)"
     required: false
-    default: ""
+    default: "${{ github.token }}"
   toolchain:
     description: "optional override for the toolchain version (e.g. nightly)"
     required: false
@@ -38,21 +38,58 @@ runs:
       if: runner.os == 'Linux'
       uses: rui314/setup-mold@v1
 
+    - name: Check for rustup
+      id: check-rustup
+      shell: bash
+      run: echo "exists=$(command -v rustup &> /dev/null && echo 'true' || echo 'false')" >> $GITHUB_OUTPUT
+
     - name: Rust Toolchain
       id: rust-toolchain
       uses: dtolnay/rust-toolchain@stable
-      if: steps.rustup-cache.outputs.cache-hit != 'true'
+      if: steps.check-rustup.outputs.exists != 'true'
       with:
         toolchain: "${{ steps.toolchain-config.outputs.toolchain }}"
         targets: "${{ inputs.targets }}"
         components: "${{ inputs.components }}"
 
+    - name: Install additional targets and components
+      if: steps.check-rustup.outputs.exists == 'true'
+      shell: bash
+      run: |
+        rustup toolchain install "$TOOLCHAIN"
+        [[ -n "$TARGETS" ]] && rustup target add --toolchain "$TOOLCHAIN" ${TARGETS//,/ }
+        [[ -n "$COMPONENTS" ]] && rustup component add --toolchain "$TOOLCHAIN" ${COMPONENTS//,/ }
+      env:
+        TOOLCHAIN: ${{ steps.toolchain-config.outputs.toolchain }}
+        TARGETS: ${{ inputs.targets }}
+        COMPONENTS: ${{ inputs.components }}
+
+    - name: Configure sccache timeout
+      if: inputs.enable-sccache == 'true'
+      shell: bash
+      run: |
+        mkdir -p ~/.config/sccache
+        echo 'server_startup_timeout_ms = 60000' > ~/.config/sccache/config
+
     - name: Rust Compile Cache
       if: inputs.enable-sccache == 'true'
       uses: mozilla-actions/sccache-action@v0.0.9
-      with:
-        version: "v0.14.0"
+
+    - name: Pre-start sccache server
+      if: inputs.enable-sccache == 'true'
+      shell: bash
+      run: sccache --start-server
 
     - name: Install Protoc (for lance-encoding build step)
       if: runner.os != 'Windows'
       uses: ./.github/actions/setup-protoc
+
+    - name: Install Sweep
+      shell: bash
+      if: ${{ inputs.timestamp == 'true' && github.ref_name == 'develop' }}
+      run: cargo install cargo-sweep
+
+    - name: Timestamp Cache
+      shell: bash
+      if: ${{ inputs.timestamp == 'true' && github.ref_name == 'develop' }}
+      run: cargo sweep --stamp
diff --git a/.github/runs-on.yml b/.github/runs-on.yml
index 7970bf75e17..b1bfde5c961 100644
--- a/.github/runs-on.yml
+++ b/.github/runs-on.yml
@@ -1,11 +1 @@
-images:
-  vortex-ci-amd64:
-    platform: "linux"
-    arch: "x64"
-    name: "vortex-ci-*"
-    owner: "375504701696"
-  vortex-ci-arm64:
-    platform: "linux"
-    arch: "arm64"
-    name: "vortex-ci-*"
-    owner: "375504701696"
+_extends: .github-private
diff --git a/.github/scripts/fuzz_report/cli.py b/.github/scripts/fuzz_report/cli.py
index a14f69dfc60..2bab8494872 100644
--- a/.github/scripts/fuzz_report/cli.py
+++ b/.github/scripts/fuzz_report/cli.py
@@ -363,8 +363,9 @@ def cmd_report(args: argparse.Namespace) -> int:
         print(f"Commented on #{existing_issue}", file=sys.stderr)
         _write_github_output("issue_number", str(existing_issue))
     else:
-        fuzz_target = variables.get("FUZZ_TARGET", "unknown")
-        title = f"Fuzzing Crash: {crash_info.error_variant} in {fuzz_target}"
+        # Use FUZZ_NAME for the title (descriptive name), fall back to FUZZ_TARGET
+        fuzz_name = variables.get("FUZZ_NAME") or variables.get("FUZZ_TARGET", "unknown")
+        title = f"Fuzzing Crash: {crash_info.error_variant} in {fuzz_name}"
 
         body = render_template(str(TEMPLATES_DIR / "new_issue.md"), variables, use_env=False)
         body_file = Path("issue_body.md")
diff --git a/.github/scripts/fuzz_report/templates/new_issue.md b/.github/scripts/fuzz_report/templates/new_issue.md
index 3535804da2d..45f0c7ae458 100644
--- a/.github/scripts/fuzz_report/templates/new_issue.md
+++ b/.github/scripts/fuzz_report/templates/new_issue.md
@@ -5,6 +5,7 @@
 **Crash Location**: `{{CRASH_LOCATION}}`
 
 **Error Message**:
+
 ```
 {{PANIC_MESSAGE}}
 ```
@@ -15,6 +16,7 @@
 ```
 {{STACK_TRACE_RAW}}
 ```
+
 </details>
 {% if CLAUDE_ANALYSIS %}
 
@@ -31,23 +33,66 @@
 - **Commit**: {{COMMIT}}
 - **Crash Artifact**: {{ARTIFACT_URL}}
 
-### Reproduction
+### Reproduce
+
+```bash
+cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} ./fuzz/artifacts/{{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+```
+
+<details>
+<summary>Reproduction Steps</summary>
+
+1. Download the crash artifact: {{ARTIFACT_URL}}
 
-1. Download the crash artifact:
-   - **Direct download**: {{ARTIFACT_URL}}
-   - Extract the zip file
+2. Assuming you download the zipfile to `~/Downloads`, and your working directory is the repository root:
 
-2. Reproduce locally:
 ```bash
-cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} {{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+# Create the artifacts directory if you haven't already.
+mkdir -p ./fuzz/artifacts
+
+# Move the zipfile.
+mv ~/Downloads/{{FUZZ_TARGET}}-crash-artifacts.zip ./fuzz/artifacts/
+
+# Unzip the zipfile.
+unzip ./fuzz/artifacts/{{FUZZ_TARGET}}-crash-artifacts.zip -d ./fuzz/artifacts/
+
+# You can remove the zipfile now if you want to.
+rm ./fuzz/artifacts/{{FUZZ_TARGET}}-crash-artifacts.zip
 ```
 
-3. Get full backtrace:
+3. Reproduce the crash:
+
 ```bash
-RUST_BACKTRACE=full cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} {{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} ./fuzz/artifacts/{{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
 ```
 
+If you want a backtrace:
+
+```bash
+RUST_BACKTRACE=1 cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} ./fuzz/artifacts/{{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+```
+
+```bash
+RUST_BACKTRACE=full cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} ./fuzz/artifacts/{{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+```
+
+</details>
+
+<details>
+<summary>Single command to get a backtrace</summary>
+
+```bash
+mkdir -p ./fuzz/artifacts
+mv ~/Downloads/{{FUZZ_TARGET}}-crash-artifacts.zip ./fuzz/artifacts/
+unzip ./fuzz/artifacts/{{FUZZ_TARGET}}-crash-artifacts.zip -d ./fuzz/artifacts/
+rm ./fuzz/artifacts/{{FUZZ_TARGET}}-crash-artifacts.zip
+RUST_BACKTRACE=1 cargo +nightly fuzz run -D --sanitizer=none {{FUZZ_TARGET}} ./fuzz/artifacts/{{FUZZ_TARGET}}/{{CRASH_FILE}} -- -rss_limit_mb=0
+```
+
+</details>
+
 <!-- seed_hash:{{SEED_HASH}} stack_hash:{{STACK_TRACE_HASH}} message_hash:{{MESSAGE_HASH}} -->
 
 ---
-*Auto-created by fuzzing workflow*
+
+_Auto-created by fuzzing workflow_
diff --git a/.github/scripts/run-sql-bench.sh b/.github/scripts/run-sql-bench.sh
index 93e96cb89dd..96c2e2f19dc 100755
--- a/.github/scripts/run-sql-bench.sh
+++ b/.github/scripts/run-sql-bench.sh
@@ -15,6 +15,7 @@
 #
 # Options:
 #   --scale-factor <sf>       Scale factor for the benchmark (e.g., 1.0, 10.0)
+#   --iterations <n>          Number of iterations to pass to each benchmark binary
 #   --remote-storage <url>    Remote storage URL (e.g., s3://bucket/path/)
 #                             If provided, runs in remote mode (no lance support).
 #   --benchmark-id <id>       Benchmark ID for error messages (e.g., tpch-s3)
@@ -26,6 +27,7 @@ targets="$2"
 shift 2
 
 scale_factor=""
+iterations=""
 remote_storage=""
 benchmark_id=""
 
@@ -35,6 +37,10 @@ while [[ $# -gt 0 ]]; do
             scale_factor="$2"
             shift 2
             ;;
+        --iterations)
+            iterations="$2"
+            shift 2
+            ;;
         --remote-storage)
             remote_storage="$2"
             shift 2
@@ -91,6 +97,9 @@ if [[ -n "$scale_factor" ]]; then
         opts="--opt scale-factor=$scale_factor"
     fi
 fi
+if [[ -n "$iterations" ]]; then
+    opts="-i $iterations $opts"
+fi
 
 touch results.json
 
diff --git a/.github/workflows/approvals.yml b/.github/workflows/approvals.yml
new file mode 100644
index 00000000000..8939e8dec66
--- /dev/null
+++ b/.github/workflows/approvals.yml
@@ -0,0 +1,46 @@
+name: PR Approval Check
+
+on:
+  pull_request_review:
+    types: [submitted, dismissed]
+
+jobs:
+  check-approvals:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check required approvals
+        uses: actions/github-script@450193c5abd4cdb17ba9f3ffcfe8f635c4bb6c2a
+        with:
+          script: |
+            const pr = context.payload.pull_request;
+            const reviews = await github.rest.pulls.listReviews({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: pr.number,
+            });
+
+            // Count unique human approvals (latest review per user)
+            const latestByUser = {};
+            for (const review of reviews.data) {
+              if (review.user.type === 'Bot') continue;
+              latestByUser[review.user.login] = review.state;
+            }
+            const approvalCount = Object.values(latestByUser)
+              .filter(state => state === 'APPROVED').length;
+
+            // Determine if PR author is a bot/GitHub Actions
+            const authorType = pr.user.type;        // 'Bot' vs 'User'
+            const authorLogin = pr.user.login;       // e.g. 'github-actions[bot]'
+            const isBot = authorType === 'Bot' || authorLogin.endsWith('[bot]');
+
+            const required = isBot ? 2 : 1;
+
+            console.log(`PR author: ${authorLogin} (${authorType}), isBot: ${isBot}`);
+            console.log(`Approvals: ${approvalCount} / ${required} required`);
+
+            if (approvalCount < required) {
+              core.setFailed(
+                `This PR needs ${required} human approval(s) but has ${approvalCount}. ` +
+                `(Author is ${isBot ? 'a bot' : 'human'})`
+              );
+            }
diff --git a/.github/workflows/bench-dispatch.yml b/.github/workflows/bench-dispatch.yml
new file mode 100644
index 00000000000..264dfaf94e8
--- /dev/null
+++ b/.github/workflows/bench-dispatch.yml
@@ -0,0 +1,49 @@
+# Dispatches benchmark workflows when benchmark labels are added to pull requests.
+# This is a separate workflow so that non-benchmark label events don't create
+# phantom check suites that obscure in-progress benchmark runs on the PR.
+
+name: Benchmark Dispatch
+
+on:
+  pull_request:
+    types: [labeled]
+    branches: ["develop"]
+
+permissions:
+  actions: write
+  contents: read
+  pull-requests: write  # for label removal and PR comments
+  id-token: write  # enables AWS-GitHub OIDC
+
+jobs:
+  remove-bench-label:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    if: github.event.label.name == 'action/benchmark'
+    steps:
+      - uses: actions-ecosystem/action-remove-labels@v1
+        if: github.event.pull_request.head.repo.full_name == 'vortex-data/vortex'
+        with:
+          labels: action/benchmark
+          fail_on_error: true
+
+  bench:
+    needs: remove-bench-label
+    uses: ./.github/workflows/bench-pr.yml
+    secrets: inherit
+
+  remove-sql-label:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    if: github.event.label.name == 'action/benchmark-sql'
+    steps:
+      - uses: actions-ecosystem/action-remove-labels@v1
+        if: github.event.pull_request.head.repo.full_name == 'vortex-data/vortex'
+        with:
+          labels: action/benchmark-sql
+          fail_on_error: true
+
+  sql-bench:
+    needs: remove-sql-label
+    uses: ./.github/workflows/sql-pr.yml
+    secrets: inherit
diff --git a/.github/workflows/bench-pr.yml b/.github/workflows/bench-pr.yml
index 7e6cd69b4aa..f392f1a6e45 100644
--- a/.github/workflows/bench-pr.yml
+++ b/.github/workflows/bench-pr.yml
@@ -1,4 +1,5 @@
-# Runs all benchmarks once when we add the `action/benchmark` tag to a pull request.
+# Runs all benchmarks once for a pull request.
+# Called from bench-dispatch.yml when the `action/benchmark` label is added.
 
 name: PR Benchmarks
 
@@ -9,34 +10,21 @@ concurrency:
   cancel-in-progress: false
 
 on:
-  pull_request:
-    types: [labeled, synchronize]
-    branches: ["develop"]
+  workflow_call: { }
   workflow_dispatch: { }
 
 permissions:
-  actions: write  # for removing labels
   contents: read
   pull-requests: write  # for commenting on PRs
   id-token: write  # enables AWS-GitHub OIDC
 
 jobs:
-  label_trigger:
-    runs-on: ubuntu-latest
-    timeout-minutes: 120
-    if: ${{ contains(github.event.head_commit.message, '[benchmark]') || github.event.label.name == 'action/benchmark' && github.event_name == 'pull_request' }}
-    steps:
-      # We remove the benchmark label first so that the workflow can be re-triggered.
-      - uses: actions-ecosystem/action-remove-labels@v1
-        if: ${{ github.event.pull_request.head.repo.full_name == 'vortex-data/vortex' }}
-        with:
-          labels: action/benchmark
-          fail_on_error: true
-
   bench:
-    needs: label_trigger
     timeout-minutes: 120
-    runs-on: runs-on=${{ github.run_id }}/family=c6id.8xlarge/image=ubuntu24-full-x64/spot=false/tag=${{ matrix.benchmark.id }}${{ github.event.pull_request.head.repo.fork == false && '/extras=s3-cache' || '' }}
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=bench-dedicated/tag={1}{2}', github.run_id, matrix.benchmark.id, github.event.pull_request.head.repo.fork == false && '/extras=s3-cache' || '')
+          || 'ubuntu-latest' }}
     strategy:
       matrix:
         benchmark:
@@ -45,7 +33,6 @@ jobs:
             build_args: "--features lance"
           - id: compress-bench
             name: Compression
-    if: ${{ contains(github.event.head_commit.message, '[benchmark]') || github.event.label.name == 'action/benchmark' && github.event_name == 'pull_request' }}
     steps:
       - uses: runs-on/action@v2
         if: github.event.pull_request.head.repo.fork == false
@@ -54,6 +41,8 @@ jobs:
       - uses: actions/checkout@v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
+      - name: Setup benchmark environment
+        run: sudo bash scripts/setup-benchmark.sh
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -69,7 +58,7 @@ jobs:
       - name: Build binary
         shell: bash
         env:
-          RUSTFLAGS: "-C target-cpu=native -C force-frame-pointers=yes"
+          RUSTFLAGS: "-C target-cpu=native"
         run: |
           cargo build --package ${{ matrix.benchmark.id }} --profile release_debug ${{ matrix.benchmark.build_args }}
 
@@ -88,13 +77,13 @@ jobs:
         env:
           RUST_BACKTRACE: full
         run: |
-          target/release_debug/${{ matrix.benchmark.id }} -d gh-json -o results.json
+          bash scripts/bench-taskset.sh target/release_debug/${{ matrix.benchmark.id }} -d gh-json -o results.json
 
       - name: Setup AWS CLI
         if: github.event.pull_request.head.repo.fork == false
-        uses: aws-actions/configure-aws-credentials@v5
+        uses: aws-actions/configure-aws-credentials@v6
         with:
-          role-to-assume: arn:aws:iam::375504701696:role/GitHubBenchmarkRole
+          role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
 
       - name: Install uv
@@ -115,7 +104,7 @@ jobs:
             | jq -r '.workflow_runs[].head_sha' \
           )
 
-          python3 scripts/s3-download.py s3://vortex-benchmark-results-database/data.json.gz data.json.gz --no-sign-request
+          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
 
           echo '# Benchmarks: ${{ matrix.benchmark.name }}' > comment.md
@@ -132,18 +121,96 @@ jobs:
           comment-tag: bench-pr-comment-${{ matrix.benchmark.id }}
 
       - name: Comment PR on failure
-        if: failure() && inputs.mode == 'pr' && github.event.pull_request.head.repo.fork == false
+        if: failure() && github.event.pull_request.head.repo.fork == false
         uses: thollander/actions-comment-pull-request@v3
         with:
           message: |
-            # 🚨🚨🚨❌❌❌ BENCHMARK FAILED ❌❌❌🚨🚨🚨
+            # BENCHMARK FAILED
 
             Benchmark `${{ matrix.benchmark.name }}` failed! Check the [workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.
           comment-tag: bench-pr-comment-${{ matrix.benchmark.id }}
 
   sql:
-    needs: label_trigger
     uses: ./.github/workflows/sql-benchmarks.yml
     secrets: inherit
     with:
       mode: "pr"
+      benchmark_matrix: |
+        [
+          {
+            "id": "clickbench-nvme",
+            "subcommand": "clickbench",
+            "name": "Clickbench on NVME",
+            "targets": "datafusion:parquet,datafusion:vortex,duckdb:parquet,duckdb:vortex,duckdb:duckdb",
+            "extra_data_formats": "vortex-compact"
+          },
+          {
+            "id": "tpch-nvme",
+            "subcommand": "tpch",
+            "name": "TPC-H SF=1 on NVME",
+            "targets": "datafusion:arrow,datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact,duckdb:duckdb",
+            "scale_factor": "1.0"
+          },
+          {
+            "id": "tpch-s3",
+            "subcommand": "tpch",
+            "name": "TPC-H SF=1 on S3",
+            "local_dir": "vortex-bench/data/tpch/1.0",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/1.0/",
+            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
+            "scale_factor": "1.0"
+          },
+          {
+            "id": "tpch-nvme-10",
+            "subcommand": "tpch",
+            "name": "TPC-H SF=10 on NVME",
+            "targets": "datafusion:arrow,datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact,duckdb:duckdb",
+            "scale_factor": "10.0"
+          },
+          {
+            "id": "tpch-s3-10",
+            "subcommand": "tpch",
+            "name": "TPC-H SF=10 on S3",
+            "local_dir": "vortex-bench/data/tpch/10.0",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
+            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
+            "scale_factor": "10.0"
+          },
+          {
+            "id": "tpcds-nvme",
+            "subcommand": "tpcds",
+            "name": "TPC-DS SF=1 on NVME",
+            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact,duckdb:duckdb",
+            "scale_factor": "1.0"
+          },
+          {
+            "id": "statpopgen",
+            "subcommand": "statpopgen",
+            "name": "Statistical and Population Genetics",
+            "targets": "duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
+            "scale_factor": "100"
+          },
+          {
+            "id": "fineweb",
+            "subcommand": "fineweb",
+            "name": "FineWeb NVMe",
+            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
+            "scale_factor": "100"
+          },
+          {
+            "id": "fineweb-s3",
+            "subcommand": "fineweb",
+            "name": "FineWeb S3",
+            "local_dir": "vortex-bench/data/fineweb",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/fineweb/",
+            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
+            "scale_factor": "100"
+          },
+          {
+            "id": "polarsignals",
+            "subcommand": "polarsignals",
+            "name": "PolarSignals Profiling",
+            "targets": "datafusion:vortex",
+            "scale_factor": "1"
+          },
+        ]
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 9743a554eae..7be829d80bd 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -18,9 +18,9 @@ jobs:
     steps:
       - uses: actions/checkout@v6
       - name: Setup AWS CLI
-        uses: aws-actions/configure-aws-credentials@v5
+        uses: aws-actions/configure-aws-credentials@v6
         with:
-          role-to-assume: arn:aws:iam::375504701696:role/GitHubBenchmarkRole
+          role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
       - name: Upload Commit Metadata
         shell: bash
@@ -29,17 +29,14 @@ jobs:
 
           sudo apt-get update && sudo apt-get install -y jq
           bash scripts/commit-json.sh > new-commit.json
-          bash scripts/cat-s3.sh vortex-benchmark-results-database commits.json new-commit.json
+          bash scripts/cat-s3.sh vortex-ci-benchmark-results commits.json new-commit.json
 
   bench:
     timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=c6id.8xlarge
-      - image=ubuntu24-full-x64
-      - spot=false
-      - extras=s3-cache
-      - tag=${{ matrix.benchmark.id }}
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=bench-dedicated/extras=s3-cache/tag={1}', github.run_id, matrix.benchmark.id)
+          || 'ubuntu-latest' }}
     strategy:
       matrix:
         benchmark:
@@ -53,9 +50,12 @@ jobs:
             formats: "parquet,lance,vortex"
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
+      - name: Setup benchmark environment
+        run: sudo bash scripts/setup-benchmark.sh
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -71,7 +71,7 @@ jobs:
       - name: Build binary
         shell: bash
         env:
-          RUSTFLAGS: "-C target-cpu=native -C force-frame-pointers=yes"
+          RUSTFLAGS: "-C target-cpu=native"
         run: |
           cargo build --bin ${{ matrix.benchmark.id }} --profile release_debug ${{ matrix.benchmark.build_args }}
 
@@ -89,18 +89,18 @@ jobs:
         env:
           RUST_BACKTRACE: full
         run: |
-          target/release_debug/${{ matrix.benchmark.id }} --formats ${{ matrix.benchmark.formats }} -d gh-json -o results.json
+          bash scripts/bench-taskset.sh target/release_debug/${{ matrix.benchmark.id }} --formats ${{ matrix.benchmark.formats }} -d gh-json -o results.json
 
       - name: Setup AWS CLI
-        uses: aws-actions/configure-aws-credentials@v5
+        uses: aws-actions/configure-aws-credentials@v6
         with:
-          role-to-assume: arn:aws:iam::375504701696:role/GitHubBenchmarkRole
+          role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
 
       - name: Upload Benchmark Results
         shell: bash
         run: |
-          bash scripts/cat-s3.sh vortex-benchmark-results-database data.json.gz results.json
+          bash scripts/cat-s3.sh vortex-ci-benchmark-results data.json.gz results.json
 
       - name: Alert incident.io
         if: failure()
@@ -137,7 +137,7 @@ jobs:
             "subcommand": "tpch",
             "name": "TPC-H SF=1 on S3",
             "local_dir": "vortex-bench/data/tpch/1.0",
-            "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/1.0/",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/1.0/",
             "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
             "scale_factor": "1.0"
           },
@@ -154,7 +154,7 @@ jobs:
             "subcommand": "tpch",
             "name": "TPC-H SF=10 on S3",
             "local_dir": "vortex-bench/data/tpch/10.0",
-            "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
             "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
             "scale_factor": "10.0"
           },
@@ -184,7 +184,7 @@ jobs:
             "subcommand": "fineweb",
             "name": "FineWeb S3",
             "local_dir": "vortex-bench/data/fineweb",
-            "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/fineweb/",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/fineweb/",
             "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact"
           },
           {
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c3d4b3e81b0..e706b15b99f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,14 +28,14 @@ env:
 jobs:
   lint-toml:
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - uses: spiraldb/actions/.github/actions/lint-toml@0.18.5
 
   validate-workflow-yaml:
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - name: Validate YAML file
@@ -48,75 +48,66 @@ jobs:
 
   python-lint:
     name: "Python (lint)"
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=python-lint
-    timeout-minutes: 120
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=python-lint', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Install uv
+        if: github.repository != 'vortex-data/vortex'
         uses: spiraldb/actions/.github/actions/setup-uv@0.18.5
         with:
           sync: false
           prune-cache: false
-      # Use uvx for ruff to avoid building the Rust extension (saves ~4.5 min)
+      # Use uv tool run for ruff to avoid building the Rust extension (saves ~4.5 min)
       - name: Python Lint - Format
-        run: uvx ruff format --check .
+        run: uv tool run ruff format --check .
       - name: Python Lint - Ruff
-        run: uvx ruff check .
+        run: uv tool run ruff check .
       # PyRight needs the project for type information, so use uv run
       - name: Python Lint - PyRight
         env:
-          MATURIN_PEP517_ARGS: "--profile dev"
-        run: uv run basedpyright vortex-python
+          MATURIN_PEP517_ARGS: "--profile ci"
+        run: |
+          uv sync --all-packages
+          uv run basedpyright vortex-python
 
   python-test:
     name: "Python (test)"
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=python-test
-    timeout-minutes: 120
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-large/image=ubuntu24-full-x64-pre-v2/tag=python-test', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     env:
-      RUST_LOG: "info,uv=debug"
-      MATURIN_PEP517_ARGS: "--profile dev"
+      RUST_LOG: "info,maturin=off,uv=debug"
+      MATURIN_PEP517_ARGS: "--profile ci"
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install uv
-        uses: spiraldb/actions/.github/actions/setup-uv@0.18.5
-        with:
-          sync: false
-          prune-cache: false
-      - name: Install Doxygen
-        uses: ssciwr/doxygen-install@v1
+      - uses: ./.github/actions/setup-prebuild
 
       - name: Pytest - Vortex
         run: |
           uv run --all-packages pytest --benchmark-disable -n auto test/
         working-directory: vortex-python/
 
+      - name: Setup benchmark environment
+        run: sudo bash scripts/setup-benchmark.sh
+
       - name: Pytest Benchmarks - Vortex
         run: |
-          uv run --all-packages pytest --benchmark-only benchmark/
+          bash ../scripts/bench-taskset.sh uv run --all-packages pytest --benchmark-only benchmark/
         working-directory: vortex-python/
 
       - name: Doctest - PyVortex
@@ -132,7 +123,7 @@ jobs:
   python-wheel-build:
     name: "Python (wheel build)"
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - name: Rust Dependency Cache
@@ -143,7 +134,7 @@ jobs:
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           enable-sccache: "false"
-      - uses: mlugg/setup-zig@v2
+      - uses: mlugg/setup-zig@v2.2.1
       - name: Install uv
         uses: spiraldb/actions/.github/actions/setup-uv@0.18.5
         with:
@@ -172,38 +163,31 @@ jobs:
 
   rust-docs:
     name: "Rust (docs)"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-docs
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-small/image=ubuntu24-full-x64-pre-v2/tag=rust-docs', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Docs
         run: |
-          RUSTDOCFLAGS="-D warnings" cargo doc --no-deps
+          RUSTDOCFLAGS="-D warnings" cargo doc --profile ci --no-deps
           # nextest doesn't support doc tests, so we run it here
-          cargo test --doc --workspace --all-features --exclude vortex-cxx --exclude vortex-jni --exclude vortex-ffi --exclude xtask --no-fail-fast
+          cargo test --profile ci --doc --workspace --all-features --exclude vortex-cxx --exclude vortex-jni --exclude vortex-ffi --exclude xtask --no-fail-fast
 
   build-rust:
     name: "Rust build (${{matrix.config.name}})"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=${{ matrix.config.name }}
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner={1}/image=ubuntu24-full-x64-pre-v2/tag={2}', github.run_id, matrix.config.runner, matrix.config.name)
+          || 'ubuntu-latest' }}
     env:
       # disable lints for build, they will be caught in Rust lint job.
       RUSTFLAGS: "-A warnings"
@@ -212,33 +196,34 @@ jobs:
       matrix:
         config:
           - name: "all-features"
+            runner: amd64-large
             args: "--all-features --all-targets"
           - name: "default features"
+            runner: amd64-large
             args: "--all-targets"
           - name: "with tokio dispatcher"
+            runner: amd64-small
             # Only build the crates that have the tokio features, not re-building other crates with no-default-features
             args: "--no-default-features --features tokio --all-targets -p vortex -p vortex-io -p vortex-file -p vortex-layout"
           - name: "wasm32 with default features"
+            runner: amd64-medium
             target: wasm32-unknown-unknown
             env:
-              rustflags: "RUSTFLAGS='-A warnings --cfg getrandom_backend=\"wasm_js\"'"
+              rustflags: "RUSTFLAGS='-A warnings'"
             args: "--target wasm32-unknown-unknown --exclude vortex --exclude vortex-cuda --exclude vortex-cub --exclude vortex-nvcomp --exclude vortex-datafusion --exclude vortex-duckdb --exclude vortex-tui --exclude vortex-zstd --exclude vortex-test-e2e-cuda --exclude vortex-sqllogictest"
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Install wasm32 target
         if: ${{ matrix.config.target == 'wasm32-unknown-unknown' }}
         run: rustup target add wasm32-unknown-unknown
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
-      - name: Rust Build (${{matrix.config.name}})
-        run: ${{matrix.config.env.rustflags}} cargo hack build --locked ${{matrix.config.args}} --ignore-private
+      - uses: ./.github/actions/check-rebuild
+        with:
+          command: "${{matrix.config.env.rustflags}} cargo hack build --profile ci --locked ${{matrix.config.args}} --ignore-private"
       - name: "Make sure no files changed after build"
         run: |
           git status --porcelain
@@ -246,57 +231,46 @@ jobs:
 
   check-min-deps:
     name: "Check build with minimal dependencies"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-min-deps
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=rust-min-deps', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: taiki-e/install-action@cargo-hack
-      - uses: taiki-e/install-action@cargo-minimal-versions
+      - uses: ./.github/actions/setup-prebuild
       - run: cargo minimal-versions check --direct --workspace --ignore-private
 
   rust-lint:
     name: "Rust (lint)"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-lint
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-large/image=ubuntu24-full-x64-pre-v2/tag=rust-lint', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Install nightly for fmt
         run: rustup toolchain install $NIGHTLY_TOOLCHAIN --component rustfmt
       - name: Rust Lint - Format
         run: cargo +$NIGHTLY_TOOLCHAIN fmt --all --check
       - name: Rustc check
-        run: RUSTFLAGS="-D warnings" cargo check --locked --all-features --all-targets
+        run: RUSTFLAGS="-D warnings" cargo check --profile ci --locked --all-features --all-targets
       - name: Rustc check (release)
         run: RUSTFLAGS="-D warnings" cargo check --locked --all-features --all-targets --release
       - name: Rust Lint - Clippy All Features
-        run: cargo clippy --locked --all-features --all-targets -- -D warnings
+        run: cargo clippy --profile ci --locked --all-features --all-targets -- -D warnings
       - name: Rust Lint - Clippy Default Features
-        run: cargo clippy --locked --all-targets -- -D warnings
+        run: cargo clippy --profile ci --locked --all-targets -- -D warnings
 
   cpp-lint:
     name: "C/C++ (lint)"
@@ -313,51 +287,45 @@ jobs:
 
   rust-lint-no-default:
     name: "Rust (lint, no default)"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-lint-no-default
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=rust-lint-no-default', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Install cargo-hack
-        uses: taiki-e/install-action@cargo-hack
+        if: github.repository != 'vortex-data/vortex'
+        shell: bash
+        run: command -v cargo-hack >/dev/null || cargo install --locked cargo-hack
       - name: Rust Lint - Clippy No Default Features
         shell: bash
         run: |
-          cargo hack --no-dev-deps --ignore-private clippy --no-default-features -- -D warnings
+          cargo hack --ignore-private clippy --profile ci --no-default-features -- -D warnings
 
   public-api:
     name: "Public API lock files"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=public-api
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-xsmall/image=ubuntu24-full-x64-pre-v2/tag=public-api', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          toolchain: ${{ env.NIGHTLY_TOOLCHAIN }}
+      - uses: ./.github/actions/setup-prebuild
+      - name: Install nightly for public-api
+        run: rustup toolchain install $NIGHTLY_TOOLCHAIN
       - name: Regenerate public API lock files
-        run: cargo +$NIGHTLY_TOOLCHAIN xtask public-api
+        run: cargo +$NIGHTLY_TOOLCHAIN run --profile ci -p xtask -- public-api
       - name: Verify lock files are up to date
         run: |
           if ! git diff --quiet '**/public-api.lock'; then
@@ -376,22 +344,17 @@ jobs:
 
   rust-coverage:
     name: "Rust tests (coverage) (${{ matrix.suite }})"
-    timeout-minutes: 120
+    timeout-minutes: 40
     permissions:
       id-token: write
     strategy:
       matrix:
         include:
           - suite: tests
-            cpu: 32
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=${{ matrix.cpu }}
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-coverage
-      - tag=suite-${{ matrix.suite }}
+    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)
+          || 'ubuntu-latest' }}
     env:
       RUSTFLAGS: "-Cinstrument-coverage -A warnings"
       CARGO_INCREMENTAL: 0  # Disable incremental compilation to get accurate coverage
@@ -399,25 +362,15 @@ jobs:
       GRCOV_OUTPUT_FILE: "target/coverage/vortex.lcov"
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install grcov
-        uses: taiki-e/install-action@grcov
-      - name: Install nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: nextest
+      - uses: ./.github/actions/setup-prebuild
       - name: Rust Tests
         if: ${{ matrix.suite == 'tests' }}
         run: |
           cargo nextest run --locked --workspace --all-features --no-fail-fast
-      - name: Install llvm-tools-preview
-        run: rustup component add llvm-tools-preview
       - name: Generate coverage report
         run: |
           grcov . --binary-path target/debug/ -s . -t lcov --llvm --ignore-not-existing \
@@ -438,82 +391,167 @@ jobs:
           flags: ${{ matrix.suite }}
           use_oidc: true
 
-  rust-test:
-    name: "Rust tests (sanitizer)"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-test-sanitizer
+  rust-test-sanitizer:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # We don't run memory sanitizer as it provides many false positives
+          # for std
+          - sanitizer: asan
+            sanitizer_flags: "-Zsanitizer=address,leak"
+          - sanitizer: tsan
+            sanitizer_flags: "-Zsanitizer=thread"
+    name: "Rust tests (${{ matrix.sanitizer }})"
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/pool=amd64-medium-pre-v2/tag=rust-test-sanitizer', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     env:
-      # Add debug symbols and enable ASAN/LSAN with better output
-      ASAN_OPTIONS: "symbolize=1:print_stats=1:check_initialization_order=1:detect_leaks=1:halt_on_error=0:verbosity=1:leak_check_at_exit=1"
-      LSAN_OPTIONS: "verbosity=1:report_objects=1"
+      ASAN_OPTIONS: "symbolize=1:check_initialization_order=1:detect_leaks=1:leak_check_at_exit=1"
+      LSAN_OPTIONS: "report_objects=1"
       ASAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
-      # Link against DuckDB debug build
-      VX_DUCKDB_DEBUG: "1"
-      # Keep frame pointers for better stack traces
-      CARGO_PROFILE_DEV_DEBUG: "true"
-      CARGO_PROFILE_TEST_DEBUG: "true"
-      # Skip slow tests that are too expensive under sanitizer
+      MSAN_OPTIONS: "symbolize=1"
+      MSAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
+      TSAN_OPTIONS: "symbolize=1:suppressions=${{ github.workspace }}/vortex-ffi/tsan_suppressions.txt"
+      TSAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
       VORTEX_SKIP_SLOW_TESTS: "1"
+      # -Cunsafe-allow-abi-mismatch=sanitizer: libraries like compiler_builtins
+      # unset -Zsanitizer flag and we should allow that.
+      RUSTFLAGS: "-A warnings -Cunsafe-allow-abi-mismatch=sanitizer --cfg disable_loom --cfg vortex_nightly -C debuginfo=2 -C opt-level=0 -C strip=none"
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - name: Install llvm
-        uses: aminya/setup-cpp@v1
+      - uses: ./.github/actions/setup-prebuild
+      - name: Install Rust nightly toolchain
+        run: |
+          rustup toolchain install $NIGHTLY_TOOLCHAIN
+          rustup component add --toolchain $NIGHTLY_TOOLCHAIN rust-src rustfmt clippy llvm-tools-preview
+      - name: Build tests with sanitizer
+        run: |
+          RUSTFLAGS="${RUSTFLAGS} ${{ matrix.sanitizer_flags }}" \
+          cargo +$NIGHTLY_TOOLCHAIN build --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 \
+            -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
+      - 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
+
+  rust-ffi-test-sanitizer:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # We don't run memory sanitizer as it's clang-only and provides many
+          # false positives for Catch2
+          - sanitizer: asan
+            sanitizer_flags: "-Zsanitizer=address,leak"
+          - sanitizer: tsan
+            sanitizer_flags: "-Zsanitizer=thread"
+    name: "Rust/C++ FFI tests (${{ matrix.sanitizer }})"
+    timeout-minutes: 40
+    env:
+      ASAN_OPTIONS: "symbolize=1:check_initialization_order=1:detect_leaks=1:leak_check_at_exit=1"
+      LSAN_OPTIONS: "report_objects=1"
+      ASAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
+      MSAN_OPTIONS: "symbolize=1"
+      MSAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
+      TSAN_OPTIONS: "symbolize=1"
+      TSAN_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer"
+      VORTEX_SKIP_SLOW_TESTS: "1"
+      # -Cunsafe-allow-abi-mismatch=sanitizer: libraries like compiler_builtins
+      # unset -Zsanitizer flag and we should allow that.
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=rust-ffi-test-sanitizer', github.run_id)
+          || 'ubuntu-latest' }}
+    steps:
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-prebuild
+      - name: Install rustfilt
+        run: |
+          cargo install rustfilt
+      - name: Install Rust nightly toolchain
+        run: |
+          rustup toolchain install $NIGHTLY_TOOLCHAIN
+          rustup component add --toolchain $NIGHTLY_TOOLCHAIN rust-src rustfmt clippy llvm-tools-preview
+      - name: Build FFI library
+        run: |
+          # TODO(myrrc): remove --no-default-features
+          RUSTFLAGS="-A warnings -Cunsafe-allow-abi-mismatch=sanitizer \
+                --cfg disable_loom --cfg vortex_nightly -C debuginfo=2 \
+                -C opt-level=0 -C strip=none -Zexternal-clangrt \
+                ${{ matrix.sanitizer_flags }}" \
+          cargo +$NIGHTLY_TOOLCHAIN build --locked --no-default-features \
+            --target x86_64-unknown-linux-gnu -Zbuild-std \
+            -p vortex-ffi
+      - name: Build FFI library tests
+        run: |
+          cd vortex-ffi
+          cmake -Bbuild -DBUILD_TESTS=1 -DSANITIZER=${{ matrix.sanitizer }} -DTARGET_TRIPLE="x86_64-unknown-linux-gnu"
+          cmake --build build -j
+      - name: Run tests
+        run: |
+          set -o pipefail
+          ./vortex-ffi/build/test/vortex_ffi_test 2>&1 | rustfilt -i-
+
+  cuda-build-lint:
+    if: github.repository == 'vortex-data/vortex'
+    name: "CUDA build & lint"
+    timeout-minutes: 40
+    runs-on: runs-on=${{ github.run_id }}/runner=gpu/tag=cuda-build
+    steps:
+      - uses: runs-on/action@v2
         with:
-          compiler: llvm
-          cache-tools: true
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-          toolchain: ${{ env.NIGHTLY_TOOLCHAIN }}
-          components: "rust-src, rustfmt, clippy, llvm-tools-preview"
-      - name: Install build dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ninja-build cmake
-      - name: Install nextest
-        uses: taiki-e/install-action@v2
+      - uses: ./.github/actions/check-rebuild
         with:
-          tool: nextest
-      - name: Rust Tests
-        env:
-          RUSTFLAGS: "-A warnings -Zsanitizer=address -Zsanitizer=leak --cfg disable_loom --cfg vortex_nightly -C debuginfo=2 -C opt-level=0 -C strip=none"
+          command: >-
+            cargo build --profile ci --locked --all-features --all-targets
+            -p vortex-cuda -p vortex-cub -p vortex-nvcomp
+            -p gpu-scan-cli -p vortex-test-e2e-cuda
+      - name: Clippy CUDA crates
         run: |
-          # Build with full debug info first (helps with caching)
-          cargo +$NIGHTLY_TOOLCHAIN build --locked --all-features  \
-            --target x86_64-unknown-linux-gnu \
-            -p vortex-buffer -p vortex-ffi -p vortex-fastlanes -p vortex-fsst -p vortex-alp -p vortex-array
-          # Run tests with sanitizers and debug output
-          cargo +$NIGHTLY_TOOLCHAIN nextest run \
-            --locked \
-            --all-features \
-            --no-fail-fast \
-            --target x86_64-unknown-linux-gnu \
-            -p vortex-buffer -p vortex-ffi -p vortex-fastlanes -p vortex-fsst -p vortex-alp -p vortex-array
+          cargo clippy --profile ci --locked --all-features --all-targets \
+            -p vortex-cuda \
+            -p vortex-cub \
+            -p vortex-nvcomp \
+            -p gpu-scan-cli \
+            -p vortex-test-e2e-cuda \
+            -- -D warnings
 
   cuda-test:
+    if: github.repository == 'vortex-data/vortex'
     name: "CUDA tests"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=g5+g4dn+g6
-      - cpu=8
-      - image=ubuntu24-gpu-x64
-      - extras=s3-cache
-      - tag=cuda-tests
-    env:
-      # Keep frame pointers for better stack traces
-      CARGO_PROFILE_DEV_DEBUG: "true"
-      CARGO_PROFILE_TEST_DEBUG: "true"
+    timeout-minutes: 30
+    runs-on: runs-on=${{ github.run_id }}/runner=gpu/tag=cuda-tests
     steps:
       - uses: runs-on/action@v2
         with:
@@ -533,90 +571,116 @@ jobs:
           tool: nextest
       - name: Rust Tests
         env:
-          # Outline flat layouts for cuda scan.
           FLAT_LAYOUT_INLINE_ARRAY_NODE: true
         run: |
           cargo nextest run \
+            --cargo-profile ci \
             --locked \
             -p vortex-file \
             -p vortex-cuda \
+            -p vortex-cub \
+            -p vortex-nvcomp \
             -p vortex-test-e2e-cuda \
             --all-features \
             --no-fail-fast \
             --target x86_64-unknown-linux-gnu \
             --verbose
-      - name: CUDA - memcheck
-        env:
-          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: compute-sanitizer --tool memcheck --leak-check=full --error-exitcode 1
-        run: cargo test --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu
-        # TODO(joe): try to re-enable, This is hanging in CI.
-        #      - name: CUDA - racecheck
-        #        env:
-        #          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: compute-sanitizer --tool racecheck --error-exitcode 1
-        #        run: cargo test --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu
-      - name: CUDA - synccheck
-        env:
-          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: compute-sanitizer --tool synccheck --error-exitcode 1
-        run: cargo test --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu
-      - name: CUDA - initcheck
+
+  cuda-test-sanitizer:
+    if: github.repository == 'vortex-data/vortex'
+    name: "CUDA tests (${{ matrix.sanitizer }})"
+    timeout-minutes: 30
+    runs-on: runs-on=${{ github.run_id }}/runner=gpu/tag=cuda-test-sanitizer
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - sanitizer: memcheck
+            runner_flags: "--tool memcheck --leak-check=full --error-exitcode 1"
+          # TODO(joe): try to re-enable racecheck, it is hanging in CI.
+          # - sanitizer: racecheck
+          #   runner_flags: "--tool racecheck --error-exitcode 1"
+          - sanitizer: synccheck
+            runner_flags: "--tool synccheck --error-exitcode 1"
+          - sanitizer: initcheck
+            runner_flags: "--tool initcheck --error-exitcode 1"
+    steps:
+      - uses: runs-on/action@v2
+        with:
+          sccache: s3
+      - name: Display NVIDIA SMI details
+        run: |
+          nvidia-smi
+          nvidia-smi -L
+          nvidia-smi -q -d Memory
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build tests
+        run: cargo test --profile ci --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu --no-run
+      - name: "CUDA - ${{ matrix.sanitizer }}"
         env:
-          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: compute-sanitizer --tool initcheck --error-exitcode 1
-        run: cargo test --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu
+          CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: "compute-sanitizer ${{ matrix.runner_flags }}"
+        run: cargo test --profile ci --locked -p vortex-cuda --all-features --target x86_64-unknown-linux-gnu
+
+  cuda-test-cudf:
+    if: github.repository == 'vortex-data/vortex'
+    name: "CUDA tests (cudf)"
+    timeout-minutes: 30
+    runs-on: runs-on=${{ github.run_id }}/runner=gpu/tag=cuda-test-cudf
+    steps:
+      - uses: runs-on/action@v2
+        with:
+          sccache: s3
+      - name: Display NVIDIA SMI details
+        run: |
+          nvidia-smi
+          nvidia-smi -L
+          nvidia-smi -q -d Memory
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Build cudf test library
-        run: cargo build --locked -p vortex-test-e2e-cuda --target x86_64-unknown-linux-gnu
+        run: cargo build --profile ci --locked -p vortex-test-e2e-cuda --target x86_64-unknown-linux-gnu
       - name: Download and run cudf-test-harness
         run: |
           curl -fsSL https://github.com/vortex-data/cudf-test-harness/releases/latest/download/cudf-test-harness-x86_64.tar.gz | tar -xz
           cd cudf-test-harness-x86_64
-          compute-sanitizer --tool memcheck --error-exitcode 1 ./cudf-test-harness check $GITHUB_WORKSPACE/target/x86_64-unknown-linux-gnu/debug/libvortex_test_e2e_cuda.so
+          compute-sanitizer --tool memcheck --error-exitcode 1 ./cudf-test-harness check $GITHUB_WORKSPACE/target/x86_64-unknown-linux-gnu/ci/libvortex_test_e2e_cuda.so
 
   rust-test-other:
     name: "Rust tests (${{ matrix.os }})"
-    timeout-minutes: 120
+    timeout-minutes: 40
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: windows-x64
-            runner: runs-on=${{ github.run_id }}/pool=windows-x64/extras=s3-cache
+            runner: runs-on=${{ github.run_id }}/pool=windows-x64-pre
+            fallback_runner: windows-latest
           - os: linux-arm64
-            runner:
-              - runs-on=${{ github.run_id }}
-              - family=m7g
-              - cpu=8
-              - image=ubuntu24-full-arm64
-              - extras=s3-cache
-              - tag=rust-test-linux-arm64
-    runs-on: ${{ matrix.runner }}
+            runner: runs-on=${{ github.run_id }}/runner=arm64-medium/image=ubuntu24-full-arm64-pre-v2/tag=rust-test-linux-arm64
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && matrix.runner
+          || matrix.fallback_runner }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@v5
-      - name: Install Visual Studio Build Tools (Windows)
+      - uses: actions/checkout@v6
+      - name: Setup (Windows)
         if: matrix.os == 'windows-x64'
         run: |
-          $flags = '-C debuginfo=0'
-          echo "RUSTFLAGS=$flags" >> $env:GITHUB_ENV
-          choco install visualstudio2022buildtools --package-parameters `
-            "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 --add Microsoft.VisualStudio.Component.Windows11SDK.26100 --passive" -y
-      - name: Setup Python (Windows)
-        if: matrix.os == 'windows-x64'
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install nextest
-        uses: taiki-e/install-action@v2
-        with:
-          tool: nextest
+          echo "C:\rust\cargo\bin" >> $env:GITHUB_PATH
+      - uses: ./.github/actions/setup-prebuild
       - name: Rust Tests (Windows)
         if: matrix.os == 'windows-x64'
         run: |
-          cargo nextest run --locked --workspace --all-features --no-fail-fast `
+          cargo nextest run --cargo-profile ci --locked --workspace --all-features --no-fail-fast `
             --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 `
@@ -626,7 +690,11 @@ jobs:
       - name: Rust Tests (Other)
         if: matrix.os != 'windows-x64'
         run: |
-          cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude vortex-bench --exclude xtask --exclude vortex-sqllogictest
+          cargo nextest run --cargo-profile ci --locked --workspace --all-features --no-fail-fast --exclude vortex-bench --exclude xtask --exclude vortex-sqllogictest
+      - uses: ./.github/actions/check-rebuild
+        if: matrix.os != 'windows-x64'
+        with:
+          command: "cargo test --profile ci --locked --workspace --all-features --no-run --exclude vortex-bench --exclude xtask --exclude vortex-sqllogictest"
 
       - name: Alert incident.io
         if: failure() && github.event_name == 'push' && github.ref == 'refs/heads/develop'
@@ -638,26 +706,18 @@ jobs:
 
   build-java:
     name: "Java"
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=16
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=java
-    timeout-minutes: 120
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/pool=amd64-medium-pre-v2/tag=java', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: actions/setup-java@v5
-        with:
-          distribution: "corretto"
-          java-version: "17"
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - run: ./gradlew test --parallel
         working-directory: ./java
 
@@ -674,41 +734,40 @@ jobs:
           - { shard: 7, name: "Encodings 4", packages: "vortex-sparse vortex-zigzag vortex-zstd" }
           - { shard: 8, name: "Storage formats", packages: "vortex-flatbuffers vortex-proto vortex-btrblocks" }
     name: "Benchmark with Codspeed (Shard #${{ matrix.shard }})"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=c7i.8xlarge
-      - extras=s3-cache
-      - image=ubuntu24-full-x64
-      - tag=bench-codspeed-${{ matrix.shard }}
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=bench-codspeed-{1}', github.run_id, matrix.shard)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Setup benchmark environment
+        run: sudo bash scripts/setup-benchmark.sh
+      - uses: ./.github/actions/setup-prebuild
       - uses: ./.github/actions/system-info
       - name: Install Codspeed
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-codspeed
       - name: Build benchmarks
         env:
-          RUSTFLAGS: "-C target-feature=+avx2 -C debug-assertions=yes"
+          RUSTFLAGS: "-C target-feature=+avx2"
         run: cargo codspeed build ${{ matrix.features }} $(printf -- '-p %s ' ${{ matrix.packages }}) --profile bench
       - name: Run benchmarks
-        uses: CodSpeedHQ/action@2ac572851726409c88c02a307f1ea2632a9ea59b
+        uses: CodSpeedHQ/action@d872884a306dd4853acf0f584f4b706cf0cc72a2
         with:
-          run: cargo codspeed run
+          run: bash scripts/bench-taskset.sh cargo codspeed run
           token: ${{ secrets.CODSPEED_TOKEN }}
           mode: "simulation"
 
   license-check-and-audit-check:
     name: License Check and Audit Check
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 40
     strategy:
       matrix:
         checks:
@@ -724,62 +783,58 @@ jobs:
 
   cxx-test:
     name: "C++ build"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=cxx-build
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=cxx-build', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Build and run C++ unit tests
         run: |
           mkdir -p vortex-cxx/build
           cmake -S vortex-cxx -B vortex-cxx/build -DVORTEX_ENABLE_TESTING=ON -DVORTEX_ENABLE_ASAN=ON
           cmake --build vortex-cxx/build --parallel $(nproc)
-          ctest --test-dir vortex-cxx/build -V
+          ctest --test-dir vortex-cxx/build -j $(nproc) -V
       - name: Build and run the example in release mode
         run: |
           cmake -S vortex-cxx/examples -B vortex-cxx/examples/build -DCMAKE_BUILD_TYPE=Release
           cmake --build vortex-cxx/examples/build --parallel $(nproc)
           vortex-cxx/examples/build/hello-vortex vortex-cxx/examples/goldenfiles/example.vortex
+      - uses: ./.github/actions/check-rebuild
+        with:
+          command: "cargo build --profile ci --locked -p vortex-cxx --lib"
 
   sqllogic-test:
     name: "SQL logic tests"
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=sql-logic-test
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=sql-logic-test', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Run sqllogictest tests
         run: |
-          cargo test -p vortex-sqllogictest --test sqllogictests
-
+          ./vortex-sqllogictest/slt/tpch/generate_data.sh
+          cargo test --profile ci -p vortex-sqllogictest --test sqllogictests
+      - uses: ./.github/actions/check-rebuild
+        with:
+          command: "cargo test --profile ci -p vortex-sqllogictest --test sqllogictests --no-run"
 
   wasm-integration:
-    name: "wasm-integration"
+    name: "WASM integration smoke test"
     runs-on: ubuntu-latest
-    timeout-minutes: 120
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - uses: ./.github/actions/setup-rust
@@ -787,52 +842,61 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           targets: "wasm32-wasip1"
       - name: Setup Wasmer
-        uses: wasmerio/setup-wasmer@v3.1
-      - run: cargo build --target wasm32-wasip1
+        shell: bash
+        run: |
+          curl https://get.wasmer.io -sSfL | sh
+          echo "$HOME/.wasmer/bin" >> $GITHUB_PATH
+      - run: cargo build --profile ci --target wasm32-wasip1
         working-directory: ./wasm-test
-      - run: wasmer run ./target/wasm32-wasip1/debug/wasm-test.wasm
+      - run: wasmer run ./target/wasm32-wasip1/ci/wasm-test.wasm
         working-directory: ./wasm-test
 
   miri:
     name: "Rust tests (miri)"
-    runs-on: ubuntu-latest
-    timeout-minutes: 120
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=rust-miri', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     env:
       MIRIFLAGS: -Zmiri-strict-provenance -Zmiri-symbolic-alignment-check -Zmiri-disable-isolation -Zmiri-env-forward=RUST_BACKTRACE
       RUSTFLAGS: "-A warnings --cfg vortex_nightly"
       RUST_BACKTRACE: full
     steps:
-      - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          toolchain: ${{ env.NIGHTLY_TOOLCHAIN }}
-          components: "rust-src, rustfmt, clippy, miri"
-      - uses: taiki-e/install-action@v2
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
-          tool: nextest
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-prebuild
+      - name: Install nightly with miri
+        run: rustup toolchain install $NIGHTLY_TOOLCHAIN --component rust-src,rustfmt,clippy,miri
       - name: Run Miri
         run: cargo +$NIGHTLY_TOOLCHAIN miri nextest run --no-fail-fast -p vortex-buffer -p vortex-ffi
 
   generated-files:
     name: "Check generated source files are up to date"
-    runs-on: ubuntu-latest
-    timeout-minutes: 120
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=generated-files', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 40
     steps:
-      - uses: actions/checkout@v6
-      - uses: ./.github/actions/setup-rust
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-prebuild
       - name: Install nightly for cbindgen macro expansion
         run: rustup toolchain install $NIGHTLY_TOOLCHAIN
-      - uses: ./.github/actions/setup-flatc
       - name: "regenerate all .fbs/.proto Rust code"
         run: |
-          cargo xtask generate-fbs
-          cargo xtask generate-proto
+          cargo run --profile ci -p xtask -- generate-fbs
+          cargo run --profile ci -p xtask -- generate-proto
       - name: "regenerate FFI header file"
         run: |
-          cargo +$NIGHTLY_TOOLCHAIN build -p vortex-ffi
+          cargo +$NIGHTLY_TOOLCHAIN build --profile ci -p vortex-ffi
       - name: "Make sure no files changed after regenerating"
         run: |
           git status --porcelain
@@ -849,11 +913,36 @@ jobs:
         run: |
           find flatbuffers/ -type f -name "*.fbs" | sed 's/^flatbuffers\///' | xargs -I{} -n1 flatc -I flatbuffers.HEAD --conform-includes flatbuffers --conform flatbuffers/{} flatbuffers.HEAD/{}
 
+  ffi-c-test:
+    name: "C API test build"
+    timeout-minutes: 10
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=cxx-build', github.run_id)
+          || 'ubuntu-latest' }}
+    steps:
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-prebuild
+      - name: "regenerate FFI header file"
+        run: |
+          cargo +$NIGHTLY_TOOLCHAIN build --profile ci -p vortex-ffi
+      - name: Build and run C++ unit tests
+        run: |
+          cd vortex-ffi
+          mkdir build
+          cmake -Bbuild -DRUST_BUILD_PROFILE=ci
+          cmake --build build -j $(nproc)
+          ctest --test-dir build -j $(nproc)
+
   check-java-publish-build:
     runs-on: ${{ matrix.target.runs-on }}
     container:
       image: "ubuntu:20.04"
-    timeout-minutes: 120
+    timeout-minutes: 40
     strategy:
       fail-fast: false
       matrix:
@@ -874,29 +963,30 @@ jobs:
           targets: ${{ matrix.target.target }}
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           enable-sccache: "false"
-      - run: cargo build --package vortex-jni
+      - run: cargo build --profile ci --package vortex-jni
+
+  compat-check:
+    name: "Compat check"
+    uses: ./.github/workflows/compat-validation.yml
+    with:
+      mode: last
 
   rust-publish-dry-run:
     name: "Rust publish dry-run"
-    timeout-minutes: 120
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m7i+m7i-flex+m7a
-      - cpu=8
-      - image=ubuntu24-full-x64
-      - extras=s3-cache
-      - tag=rust-publish-dry-run
+    timeout-minutes: 40
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-xsmall/image=ubuntu24-full-x64-pre-v2/tag=rust-publish-dry-run', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
       - uses: actions/checkout@v6
-      - id: setup-rust
-        uses: ./.github/actions/setup-rust
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: ./.github/actions/setup-prebuild
       - name: Install cargo-edit
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-edit
       - name: Set Version
diff --git a/.github/workflows/close-fixed-fuzzer-issues.yml b/.github/workflows/close-fixed-fuzzer-issues.yml
index 31e84815747..44d51663bb5 100644
--- a/.github/workflows/close-fixed-fuzzer-issues.yml
+++ b/.github/workflows/close-fixed-fuzzer-issues.yml
@@ -2,7 +2,7 @@ name: Close Fixed Fuzzer Issues
 
 on:
   schedule:
-    - cron: "0 0 * * 0"  # every Sunday at midnight UTC
+    - cron: "0 0 * * *"  # every night at midnight UTC
   workflow_dispatch:
     inputs:
       dry_run:
@@ -25,16 +25,14 @@ jobs:
       fail-fast: false
       matrix:
         target: [file_io, array_ops, compress_roundtrip]
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m8g.large
-      - image=ubuntu24-full-arm64
-      - disk=large
-      - extras=s3-cache
-      - tag=fuzzer-cleanup-${{ matrix.target }}
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=arm64-medium/disk=large/tag=fuzzer-cleanup-{1}', github.run_id, matrix.target)
+          || 'ubuntu-latest' }}
     timeout-minutes: 60
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
 
@@ -51,7 +49,7 @@ jobs:
           compiler: llvm
 
       - name: Install cargo-fuzz
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-fuzz
 
diff --git a/.github/workflows/compat-gen-upload.yml b/.github/workflows/compat-gen-upload.yml
new file mode 100644
index 00000000000..da17ec9a28c
--- /dev/null
+++ b/.github/workflows/compat-gen-upload.yml
@@ -0,0 +1,107 @@
+name: Compat Fixture Upload
+
+on:
+  workflow_call:
+    inputs:
+      git_ref:
+        description: "Git ref for version detection (e.g. v0.62.0). Defaults to HEAD."
+        required: false
+        type: string
+      confirm_upload:
+        description: "Set to 'yes' to confirm upload."
+        required: true
+        type: string
+  workflow_dispatch:
+    inputs:
+      git_ref:
+        description: "Git ref for version detection (e.g. v0.62.0). Defaults to HEAD."
+        required: false
+      confirm_upload:
+        description: "Type 'yes' to confirm upload after reviewing the dry-run output."
+        required: true
+        default: "no"
+
+jobs:
+  dry-run:
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=compat-gen-dry-run', github.run_id)
+          || 'ubuntu-latest' }}
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.detect.outputs.version }}
+    steps:
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/setup-prebuild
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v6
+        with:
+          role-to-assume: "arn:aws:iam::245040174862:role/GitHubCompatUploadRole"
+          aws-region: us-east-1
+
+      - name: Detect version
+        id: detect
+        run: |
+          GIT_REF="${{ inputs.git_ref }}"
+          if [ -n "$GIT_REF" ]; then
+            TAG=$(git describe --tags --abbrev=0 "$GIT_REF")
+          else
+            TAG=$(git describe --tags --abbrev=0)
+          fi
+          VERSION="${TAG#v}"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Detected version: $VERSION (from tag: $TAG)"
+
+      - name: Dry run publish
+        run: |
+          GIT_REF="${{ inputs.git_ref }}"
+          CMD="uv run vortex-test/compat-gen/scripts/compat.py publish --dry-run"
+          if [ -n "$GIT_REF" ]; then
+            CMD="$CMD --git-ref $GIT_REF"
+          fi
+          $CMD
+
+  upload:
+    needs: dry-run
+    if: inputs.confirm_upload == 'yes'
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=compat-gen-upload', github.run_id)
+          || 'ubuntu-latest' }}
+    environment: compat-upload
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/setup-prebuild
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v6
+        with:
+          role-to-assume: "arn:aws:iam::245040174862:role/GitHubCompatUploadRole"
+          aws-region: us-east-1
+
+      - name: Upload fixtures for v${{ needs.dry-run.outputs.version }}
+        run: |
+          GIT_REF="${{ inputs.git_ref }}"
+          CMD="uv run vortex-test/compat-gen/scripts/compat.py publish --yes"
+          if [ -n "$GIT_REF" ]; then
+            CMD="$CMD --git-ref $GIT_REF"
+          fi
+          $CMD
diff --git a/.github/workflows/compat-validation.yml b/.github/workflows/compat-validation.yml
new file mode 100644
index 00000000000..f479420cd48
--- /dev/null
+++ b/.github/workflows/compat-validation.yml
@@ -0,0 +1,42 @@
+name: Compat Validation
+
+on:
+  schedule:
+    - cron: "0 6 * * 1"  # Monday 6am UTC
+  workflow_call:
+    inputs:
+      mode:
+        description: "Validation mode"
+        required: true
+        default: "all"
+        type: string
+  workflow_dispatch:
+    inputs:
+      mode:
+        description: "Validation mode"
+        required: true
+        default: "last"
+        type: choice
+        options:
+          - last
+          - all
+
+jobs:
+  compat-test:
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=amd64-medium/image=ubuntu24-full-x64-pre-v2/tag=compat-validation', github.run_id)
+          || 'ubuntu-latest' }}
+    timeout-minutes: 120
+    steps:
+      - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
+        with:
+          sccache: s3
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-prebuild
+      - name: Run compat tests
+        run: |
+          MODE="${{ inputs.mode || 'last' }}"
+          uv run vortex-test/compat-gen/scripts/compat.py check \
+            --mode "$MODE"
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 35d43f6330f..6a7b6c47f4f 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -39,7 +39,7 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Install Doxygen
-        uses: ssciwr/doxygen-install@v1
+        uses: ssciwr/doxygen-install@v2
       - name: Generate Javadoc for Java projects
         run: |
           cd java
@@ -49,7 +49,7 @@ jobs:
           mkdir -p docs/_static/vortex-jni
           mkdir -p docs/_static/vortex-spark
           cp -r java/vortex-jni/build/docs/javadoc/* docs/_static/vortex-jni/
-          cp -r java/vortex-spark/build/docs/javadoc/* docs/_static/vortex-spark/
+          cp -r java/vortex-spark/build/vortex-spark_2.13/docs/javadoc/* docs/_static/vortex-spark/
       - name: build Python and Rust docs
         run: |
           uv run --all-packages make -C docs html
@@ -71,7 +71,7 @@ jobs:
     steps:
       # Note, since we provide the job with a CloudFlare scoped API token, we run it in a separate job that doesn't
       # execute any repository code.
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
         with:
           name: github-pages
       - name: Extract Pages Artifact
diff --git a/.github/workflows/fuzz-coverage.yml b/.github/workflows/fuzz-coverage.yml
index ef5db9ddab2..8db58c1a5f6 100644
--- a/.github/workflows/fuzz-coverage.yml
+++ b/.github/workflows/fuzz-coverage.yml
@@ -16,14 +16,13 @@ jobs:
       matrix:
         fuzz_target: [array_ops, file_io, compress_roundtrip]
     timeout-minutes: 60
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=m8g.large
-      - image=ubuntu24-full-arm64
-      - disk=large
-      - extras=s3-cache
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=arm64-medium/disk=large', github.run_id)
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
 
@@ -51,7 +50,7 @@ jobs:
           echo "Found llvm-profdata at $LLVM_PROFDATA"
 
       - name: Install cargo-fuzz
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-fuzz
 
@@ -116,7 +115,7 @@ jobs:
             --ignore-filename-regex='(\.cargo|rustc|registry)'
 
       - name: Upload coverage report
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.fuzz_target }}-coverage
           path: coverage_html/
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
index 45a8d95563c..5cc84a4a361 100644
--- a/.github/workflows/fuzz.yml
+++ b/.github/workflows/fuzz.yml
@@ -9,7 +9,7 @@ concurrency:
 
 on:
   schedule:
-    - cron: "0 */4 * * *"  # every 4 hours
+    - cron: "0 * * * *"  # every hour
   workflow_dispatch: { }
 
 jobs:
@@ -21,8 +21,7 @@ jobs:
     uses: ./.github/workflows/run-fuzzer.yml
     with:
       fuzz_target: file_io
-      family: "m8g.large"
-      image: "ubuntu24-full-arm64"
+      jobs: 16
     secrets:
       R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
       R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
@@ -72,8 +71,7 @@ jobs:
     uses: ./.github/workflows/run-fuzzer.yml
     with:
       fuzz_target: array_ops
-      family: "m8g.large"
-      image: "ubuntu24-full-arm64"
+      jobs: 16
     secrets:
       R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
       R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
@@ -101,6 +99,82 @@ jobs:
       gh_token: ${{ secrets.GITHUB_TOKEN }}
       incident_io_alert_token: ${{ secrets.INCIDENT_IO_ALERT_TOKEN }}
 
+  # ============================================================================
+  # Array Operations Fuzzer (unstable encodings)
+  # ============================================================================
+  ops_fuzz_unstable:
+    name: "Array Operations Fuzz (unstable)"
+    uses: ./.github/workflows/run-fuzzer.yml
+    with:
+      fuzz_target: array_ops
+      fuzz_name: array_ops_unstable_encodings
+      extra_features: "vortex/unstable_encodings"
+      extra_env: "VORTEX_EXPERIMENTAL_PATCHED_ARRAY=1"
+      jobs: 16
+    secrets:
+      R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
+      R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
+
+  report-ops-unstable-fuzz-failures:
+    name: "Report Array Ops (unstable) Fuzz Failures"
+    needs: ops_fuzz_unstable
+    if: always() && needs.ops_fuzz_unstable.outputs.crashes_found == 'true'
+    permissions:
+      issues: write
+      contents: read
+      id-token: write
+      pull-requests: read
+    uses: ./.github/workflows/report-fuzz-crash.yml
+    with:
+      fuzz_target: array_ops
+      fuzz_name: array_ops_unstable_encodings
+      crash_file: ${{ needs.ops_fuzz_unstable.outputs.first_crash_name }}
+      artifact_url: ${{ needs.ops_fuzz_unstable.outputs.artifact_url }}
+      artifact_name: array_ops_unstable_encodings-crash-artifacts
+      logs_artifact_name: array_ops_unstable_encodings-logs
+      branch: ${{ github.ref_name }}
+      commit: ${{ github.sha }}
+    secrets:
+      claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
+      incident_io_alert_token: ${{ secrets.INCIDENT_IO_ALERT_TOKEN }}
+
+  # ============================================================================
+  # FSST LIKE Fuzzer
+  # ============================================================================
+  fsst_like_fuzz:
+    name: "FSST LIKE Fuzz"
+    uses: ./.github/workflows/run-fuzzer.yml
+    with:
+      fuzz_target: fsst_like
+      jobs: 16
+    secrets:
+      R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
+      R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
+
+  report-fsst-like-fuzz-failures:
+    name: "Report FSST LIKE Fuzz Failures"
+    needs: fsst_like_fuzz
+    if: always() && needs.fsst_like_fuzz.outputs.crashes_found == 'true'
+    permissions:
+      issues: write
+      contents: read
+      id-token: write
+      pull-requests: read
+    uses: ./.github/workflows/report-fuzz-crash.yml
+    with:
+      fuzz_target: fsst_like
+      crash_file: ${{ needs.fsst_like_fuzz.outputs.first_crash_name }}
+      artifact_url: ${{ needs.fsst_like_fuzz.outputs.artifact_url }}
+      artifact_name: fsst_like-crash-artifacts
+      logs_artifact_name: fsst_like-logs
+      branch: ${{ github.ref_name }}
+      commit: ${{ github.sha }}
+    secrets:
+      claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+      gh_token: ${{ secrets.GITHUB_TOKEN }}
+      incident_io_alert_token: ${{ secrets.INCIDENT_IO_ALERT_TOKEN }}
+
   # ============================================================================
   # Compress Roundtrip Fuzzer
   # ============================================================================
@@ -109,8 +183,7 @@ jobs:
     uses: ./.github/workflows/run-fuzzer.yml
     with:
       fuzz_target: compress_roundtrip
-      family: "m8g.large"
-      image: "ubuntu24-full-arm64"
+      jobs: 16
     secrets:
       R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
       R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
@@ -123,9 +196,9 @@ jobs:
     uses: ./.github/workflows/run-fuzzer.yml
     with:
       fuzz_target: compress_gpu
-      family: "g4dn"
-      image: "ubuntu24-gpu-x64"
+      runner: gpu
       extra_features: "cuda"
+      jobs: 8
     secrets:
       R2_FUZZ_ACCESS_KEY_ID: ${{ secrets.R2_FUZZ_ACCESS_KEY_ID }}
       R2_FUZZ_SECRET_ACCESS_KEY: ${{ secrets.R2_FUZZ_SECRET_ACCESS_KEY }}
diff --git a/.github/workflows/fuzzer-fix-automation.yml b/.github/workflows/fuzzer-fix-automation.yml
index b7a91b4463b..08618237c95 100644
--- a/.github/workflows/fuzzer-fix-automation.yml
+++ b/.github/workflows/fuzzer-fix-automation.yml
@@ -69,7 +69,7 @@ jobs:
           compiler: llvm
 
       - name: Install cargo-fuzz
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-fuzz
 
diff --git a/.github/workflows/minimize_fuzz_corpus_workflow.yml b/.github/workflows/minimize_fuzz_corpus_workflow.yml
index 4e826be2ace..f4fcdbc39cb 100644
--- a/.github/workflows/minimize_fuzz_corpus_workflow.yml
+++ b/.github/workflows/minimize_fuzz_corpus_workflow.yml
@@ -34,13 +34,10 @@ env:
 jobs:
   minimize:
     name: "Minimize ${{ inputs.fuzz_target }}"
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=${{ inputs.family }}
-      - image=${{ inputs.image }}
-      - disk=large
-      - extras=s3-cache
-      - tag=${{ inputs.fuzz_target }}-minimize
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=arm64-medium/disk=large/tag={1}-minimize', github.run_id, inputs.fuzz_target)
+          || 'ubuntu-latest' }}
     steps:
       - name: Bail if not on develop
         if: github.ref != 'refs/heads/develop'
@@ -49,6 +46,7 @@ jobs:
           exit 1
 
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
 
@@ -60,7 +58,7 @@ jobs:
           toolchain: ${{ env.NIGHTLY_TOOLCHAIN }}
 
       - name: Install cargo-fuzz
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-fuzz
 
diff --git a/.github/workflows/nightly-bench.yml b/.github/workflows/nightly-bench.yml
index adfb94cbce4..fa8e46cb6b9 100644
--- a/.github/workflows/nightly-bench.yml
+++ b/.github/workflows/nightly-bench.yml
@@ -23,38 +23,13 @@ jobs:
     with:
       mode: "develop"
       machine_type: ${{ matrix.machine_type.instance_name }}
-      # datafusion:vortex uses a lot of memory
       benchmark_matrix: |
         [
-          {
-            "id": "clickbench-nvme",
-            "subcommand": "clickbench",
-            "name": "Clickbench on NVME",
-            "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,datafusion:lance,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact,duckdb:duckdb",
-            "build_lance": true
-          },
           {
             "id": "tpch-nvme",
             "subcommand": "tpch",
             "name": "TPC-H on NVME",
-            "targets": "datafusion:parquet,datafusion:vortex,datafusion:lance,duckdb:parquet,duckdb:vortex,duckdb:duckdb",
-            "scale_factor": "10.0",
-            "build_lance": true
-          },
-          {
-            "id": "tpch-s3",
-            "subcommand": "tpch",
-            "name": "TPC-H on S3",
-            "local_dir": "vortex-bench/data/tpch/10.0",
-            "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
             "targets": "datafusion:parquet,datafusion:vortex,duckdb:parquet,duckdb:vortex",
-            "scale_factor": "10.0"
-          },
-          {
-            "id": "tpch-nvme",
-            "subcommand": "tpch",
-            "name": "TPC-H on NVME",
-            "targets": "datafusion:parquet,duckdb:parquet,duckdb:vortex",
             "scale_factor": "100"
           },
           {
@@ -62,8 +37,8 @@ jobs:
             "subcommand": "tpch",
             "name": "TPC-H on S3",
             "local_dir": "vortex-bench/data/tpch/100.0",
-            "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/100.0/",
-            "targets": "datafusion:parquet,duckdb:parquet,duckdb:vortex",
+            "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/100.0/",
+            "targets": "datafusion:parquet,datafusion:vortex,duckdb:parquet,duckdb:vortex",
             "scale_factor": "100.0"
           },
         ]
@@ -74,6 +49,3 @@ jobs:
         machine_type:
           - id: x86
             instance_name: c6id.8xlarge
-# TODO(joe): support other arch
-#          - id: arm64
-#            instance_name: c6gd.8xlarge
diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml
index a59dfeacaf7..fbaca0f8407 100644
--- a/.github/workflows/package.yml
+++ b/.github/workflows/package.yml
@@ -42,7 +42,7 @@ jobs:
           enable-sccache: "false"
 
       - name: Install cargo-edit
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-edit
 
@@ -76,7 +76,7 @@ jobs:
           PYO3_ENVIRONMENT_SIGNATURE: "cpython3"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
         with:
           name: "wheels-${{ matrix.target.target }}.zip"
           path: dist/
@@ -97,7 +97,7 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           enable-sccache: "false"
       - run: cargo build --release --package vortex-jni
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v7
         with:
           name: "libvortex_jni_aarch64-apple-darwin.zip"
           path: "target/release/libvortex_jni.dylib"
@@ -130,7 +130,7 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           enable-sccache: "false"
       - run: cargo build --release --package vortex-jni
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v7
         with:
           name: "libvortex_jni_${{ matrix.target.target }}.zip"
           path: "target/release/libvortex_jni.so"
diff --git a/.github/workflows/publish-benchmarks-website.yml b/.github/workflows/publish-benchmarks-website.yml
index cc6b23c14fa..824ff80e6a8 100644
--- a/.github/workflows/publish-benchmarks-website.yml
+++ b/.github/workflows/publish-benchmarks-website.yml
@@ -4,7 +4,7 @@ on:
   push:
     branches: [develop]
     paths:
-      - "benchmarks-website-v2/**"
+      - "benchmarks-website/**"
 
 jobs:
   publish:
@@ -13,25 +13,25 @@ jobs:
       contents: read
       packages: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Log in to GHCR
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v4
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
-          context: ./benchmarks-website-v2
+          context: ./benchmarks-website
           platforms: linux/arm64
           push: true
           tags: ghcr.io/${{ github.repository }}/benchmarks-website:latest
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 1eaa5c91010..2d3e2388922 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -31,7 +31,7 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           enable-sccache: "false"
       - name: Install cargo-edit
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-edit
 
@@ -57,7 +57,7 @@ jobs:
       name: push-to-pypi
       url: https://pypi.org/p/vortex-data
     steps:
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
         with:
           pattern: wheels-*.zip
           # https://github.com/actions/download-artifact?tab=readme-ov-file#download-all-artifacts
@@ -90,7 +90,7 @@ jobs:
           distribution: "corretto"
           java-version: "17"
       - uses: gradle/actions/setup-gradle@v5
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
         with:
           pattern: libvortex_jni_*.zip
       - name: Copy native JNI libs
@@ -110,3 +110,13 @@ jobs:
           ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.ORG_GRADLE_PROJECT_SIGNINGINMEMORYKEYPASSWORD }}
           ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.ORG_GRADLE_PROJECT_MAVENCENTRALUSERNAME }}
           ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.ORG_GRADLE_PROJECT_MAVENCENTRALPASSWORD }}
+
+  compat-upload:
+    uses: ./.github/workflows/compat-gen-upload.yml
+    with:
+      git_ref: ${{ github.event.release.tag_name }}
+      confirm_upload: "yes"
+    secrets: inherit
+    permissions:
+      id-token: write
+      contents: read
diff --git a/.github/workflows/release-drafter.yml b/.github/workflows/release-drafter.yml
index 727c62880d1..df9bc92e455 100644
--- a/.github/workflows/release-drafter.yml
+++ b/.github/workflows/release-drafter.yml
@@ -26,9 +26,7 @@ jobs:
       contents: write
     runs-on: ubuntu-latest
     steps:
-      - uses: release-drafter/release-drafter@v6.1.0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: release-drafter/release-drafter@v7.1.1
         with:
           commitish: ${{ github.ref_name }}
           prerelease: ${{ github.event_name == 'workflow_dispatch' }}
diff --git a/.github/workflows/report-fuzz-crash.yml b/.github/workflows/report-fuzz-crash.yml
index f8d1e5b9345..dd4026641f6 100644
--- a/.github/workflows/report-fuzz-crash.yml
+++ b/.github/workflows/report-fuzz-crash.yml
@@ -6,6 +6,9 @@ on:
       fuzz_target:
         required: true
         type: string
+      fuzz_name:
+        required: false
+        type: string
       crash_file:
         required: true
         type: string
@@ -49,13 +52,13 @@ jobs:
         uses: actions/checkout@v6
 
       - name: Download fuzzer logs
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
         with:
           name: ${{ inputs.logs_artifact_name }}
           path: ./logs
 
       - name: Download crash artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
         with:
           name: ${{ inputs.artifact_name }}
           path: ./crash_artifacts
@@ -148,6 +151,7 @@ jobs:
             --dedup-result dedup_result.json \
             --claude-analysis claude_analysis.txt \
             -v "FUZZ_TARGET=${{ inputs.fuzz_target }}" \
+            -v "FUZZ_NAME=${{ inputs.fuzz_name || inputs.fuzz_target }}" \
             -v "CRASH_FILE=${{ inputs.crash_file }}" \
             -v "BRANCH=${{ inputs.branch }}" \
             -v "COMMIT=${{ inputs.commit }}" \
diff --git a/.github/workflows/run-fuzzer.yml b/.github/workflows/run-fuzzer.yml
index 1d6c7526d61..251ee31a5b7 100644
--- a/.github/workflows/run-fuzzer.yml
+++ b/.github/workflows/run-fuzzer.yml
@@ -4,29 +4,39 @@ on:
   workflow_call:
     inputs:
       fuzz_target:
-        description: "The cargo fuzz target name (e.g., file_io, array_ops, compress_roundtrip)"
+        description: "The cargo fuzz binary target name (e.g., file_io, array_ops)"
         required: true
         type: string
+      fuzz_name:
+        description: "Display/storage name for this fuzz run. Defaults to fuzz_target if not set."
+        required: false
+        type: string
+        default: ""
       max_time:
         description: "Maximum fuzzing time in seconds"
         required: false
         type: number
-        default: 7200
-      family:
-        description: "Runner family (e.g., m8g.large for CPU, g5+g4dn+g6 for GPU)"
+        default: 2700
+      runner:
+        description: "Runner name from .github-private runs-on.yml (e.g., arm64-medium, gpu)"
         required: false
         type: string
-        default: "m8g.large"
-      image:
-        description: "Runner image (e.g., ubuntu24-full-arm64, ubuntu24-gpu-x64)"
-        required: false
-        type: string
-        default: "ubuntu24-full-arm64"
+        default: "arm64-medium"
       extra_features:
         description: "Extra cargo features to enable (e.g., cuda)"
         required: false
         type: string
         default: ""
+      extra_env:
+        description: "Extra environment variables to set (space-separated KEY=VALUE pairs)"
+        required: false
+        type: string
+        default: ""
+      jobs:
+        description: "Number of parallel fuzzing jobs (libfuzzer -fork=N). Set to match available vCPUs."
+        required: false
+        type: number
+        default: 1
     outputs:
       crashes_found:
         description: "Whether crashes were found"
@@ -48,21 +58,21 @@ env:
 
 jobs:
   fuzz:
-    name: "Run ${{ inputs.fuzz_target }}"
+    name: "Run ${{ inputs.fuzz_name || inputs.fuzz_target }}"
+    env:
+      FUZZ_NAME: ${{ inputs.fuzz_name || inputs.fuzz_target }}
     timeout-minutes: 230  # almost 4 hours
-    runs-on:
-      - runs-on=${{ github.run_id }}
-      - family=${{ inputs.family }}
-      - image=${{ inputs.image }}
-      - disk=large
-      - extras=s3-cache
-      - tag=${{ inputs.fuzz_target }}-fuzz
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner={1}/disk=large/tag={2}-fuzz', github.run_id, inputs.runner, inputs.fuzz_name || inputs.fuzz_target)
+          || 'ubuntu-latest' }}
     outputs:
       crashes_found: ${{ steps.check.outputs.crashes_found }}
       first_crash_name: ${{ steps.check.outputs.first_crash_name }}
       artifact_url: ${{ steps.upload_artifacts.outputs.artifact-url }}
     steps:
       - uses: runs-on/action@v2
+        if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
 
@@ -79,7 +89,7 @@ jobs:
           compiler: llvm
 
       - name: Install cargo-fuzz
-        uses: taiki-e/cache-cargo-install-action@2bfc3cedaf2ee5e7fa5d0ae034ccd5fb50cf8e1f
+        uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
           tool: cargo-fuzz
 
@@ -91,8 +101,8 @@ jobs:
           AWS_REGION: "us-east-1"
           AWS_ENDPOINT_URL: "https://01e9655179bbec953276890b183039bc.r2.cloudflarestorage.com"
         run: |
-          CORPUS_KEY="${{ inputs.fuzz_target }}_corpus.tar.zst"
-          CORPUS_DIR="fuzz/corpus/${{ inputs.fuzz_target }}"
+          CORPUS_KEY="${FUZZ_NAME}_corpus.tar.zst"
+          CORPUS_DIR="fuzz/corpus/${FUZZ_NAME}-${{ inputs.extra_features }}"
 
           # Try to download corpus
           if python3 scripts/s3-download.py "s3://vortex-fuzz-corpus/$CORPUS_KEY" "$CORPUS_KEY"; then
@@ -110,52 +120,70 @@ jobs:
           if [ -n "${{ inputs.extra_features }}" ]; then
             FEATURES_FLAG="--features ${{ inputs.extra_features }}"
           fi
-          RUSTFLAGS="--cfg vortex_nightly" RUST_BACKTRACE=1 \
+          FORK_FLAG=""
+          if [ "${{ inputs.jobs }}" -gt 1 ]; then
+            FORK_FLAG="-fork=${{ inputs.jobs }}"
+          fi
+          ${{ inputs.extra_env }} RUSTFLAGS="--cfg vortex_nightly" RUST_BACKTRACE=1 \
             cargo +$NIGHTLY_TOOLCHAIN fuzz run --release --debug-assertions \
             $FEATURES_FLAG \
             ${{ inputs.fuzz_target }} -- \
-            -max_total_time=${{ inputs.max_time }} -rss_limit_mb=0 \
+            $FORK_FLAG -max_total_time=${{ inputs.max_time }} -rss_limit_mb=0 \
             2>&1 | tee fuzz_output.log
         continue-on-error: true
 
       - name: Check for crashes
         id: check
         run: |
-          if [ -d "fuzz/artifacts" ] && [ "$(ls -A fuzz/artifacts 2>/dev/null)" ]; then
-            echo "crashes_found=true" >> $GITHUB_OUTPUT
-
-            # Get the first crash file only
-            FIRST_CRASH=$(find fuzz/artifacts -type f \( -name "crash-*" -o -name "leak-*" -o -name "timeout-*" -o -name "oom-*" \) | head -1)
+          # Find actual crash files, not just the directory structure
+          FIRST_CRASH=$(find fuzz/artifacts -type f \( -name "crash-*" -o -name "leak-*" -o -name "timeout-*" -o -name "oom-*" \) 2>/dev/null | head -1 || true)
 
-            if [ -n "$FIRST_CRASH" ]; then
-              echo "first_crash=$FIRST_CRASH" >> $GITHUB_OUTPUT
-              echo "first_crash_name=$(basename $FIRST_CRASH)" >> $GITHUB_OUTPUT
+          if [ -n "$FIRST_CRASH" ]; then
+            echo "crashes_found=true" >> $GITHUB_OUTPUT
+            echo "first_crash=$FIRST_CRASH" >> $GITHUB_OUTPUT
+            echo "first_crash_name=$(basename $FIRST_CRASH)" >> $GITHUB_OUTPUT
 
-              # Count all crashes for reporting
-              CRASH_COUNT=$(find fuzz/artifacts -type f \( -name "crash-*" -o -name "leak-*" -o -name "timeout-*" -o -name "oom-*" \) | wc -l)
-              echo "crash_count=$CRASH_COUNT" >> $GITHUB_OUTPUT
-              echo "Found $CRASH_COUNT crash(es), will process first: $(basename $FIRST_CRASH)"
-            fi
+            # Count all crashes for reporting
+            CRASH_COUNT=$(find fuzz/artifacts -type f \( -name "crash-*" -o -name "leak-*" -o -name "timeout-*" -o -name "oom-*" \) | wc -l)
+            echo "crash_count=$CRASH_COUNT" >> $GITHUB_OUTPUT
+            echo "Found $CRASH_COUNT crash(es), will process first: $(basename $FIRST_CRASH)"
           else
             echo "crashes_found=false" >> $GITHUB_OUTPUT
             echo "crash_count=0" >> $GITHUB_OUTPUT
             echo "No crashes found"
           fi
 
+      - name: Reproduce crash for full output
+        if: steps.check.outputs.crashes_found == 'true' && inputs.jobs > 1
+        run: |
+          # In fork mode, child output (backtrace, panic message) is not captured in
+          # fuzz_output.log. Replay the crashing input in single-process mode to get
+          # the full output for the crash reporting pipeline.
+          FEATURES_FLAG=""
+          if [ -n "${{ inputs.extra_features }}" ]; then
+            FEATURES_FLAG="--features ${{ inputs.extra_features }}"
+          fi
+          RUSTFLAGS="--cfg vortex_nightly" RUST_BACKTRACE=1 \
+            cargo +$NIGHTLY_TOOLCHAIN fuzz run --release --debug-assertions \
+            $FEATURES_FLAG \
+            ${{ inputs.fuzz_target }} \
+            "${{ steps.check.outputs.first_crash }}" \
+            2>&1 | tee fuzz_output.log || true
+
       - name: Archive crash artifacts
         id: upload_artifacts
         if: steps.check.outputs.crashes_found == 'true'
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
         with:
-          name: ${{ inputs.fuzz_target }}-crash-artifacts
+          name: ${{ env.FUZZ_NAME }}-crash-artifacts
           path: fuzz/artifacts
           retention-days: 180
 
       - name: Archive fuzzer output log
         if: steps.check.outputs.crashes_found == 'true'
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
         with:
-          name: ${{ inputs.fuzz_target }}-logs
+          name: ${{ env.FUZZ_NAME }}-logs
           path: fuzz_output.log
           retention-days: 90
 
@@ -167,8 +195,8 @@ jobs:
           AWS_REGION: "us-east-1"
           AWS_ENDPOINT_URL: "https://01e9655179bbec953276890b183039bc.r2.cloudflarestorage.com"
         run: |
-          CORPUS_KEY="${{ inputs.fuzz_target }}_corpus.tar.zst"
-          CORPUS_DIR="fuzz/corpus/${{ inputs.fuzz_target }}"
+          CORPUS_KEY="${FUZZ_NAME}_corpus.tar.zst"
+          CORPUS_DIR="fuzz/corpus/${FUZZ_NAME}"
 
           tar -acf "$CORPUS_KEY" "$CORPUS_DIR"
 
diff --git a/.github/workflows/sql-benchmarks.yml b/.github/workflows/sql-benchmarks.yml
index f98e7ef87d4..4c114f00bda 100644
--- a/.github/workflows/sql-benchmarks.yml
+++ b/.github/workflows/sql-benchmarks.yml
@@ -21,7 +21,7 @@ on:
               "id": "clickbench-nvme",
               "subcommand": "clickbench",
               "name": "Clickbench on NVME",
-              "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact,duckdb:duckdb"
+              "targets": "datafusion:parquet,datafusion:vortex,duckdb:parquet,duckdb:vortex,duckdb:duckdb"
             },
             {
               "id": "tpch-nvme",
@@ -35,9 +35,10 @@ on:
               "subcommand": "tpch",
               "name": "TPC-H SF=1 on S3",
               "local_dir": "vortex-bench/data/tpch/1.0",
-              "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/1.0/",
+              "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/1.0/",
               "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
-              "scale_factor": "1.0"
+              "scale_factor": "1.0",
+              "iterations": "10"
             },
             {
               "id": "tpch-nvme-10",
@@ -51,9 +52,10 @@ on:
               "subcommand": "tpch",
               "name": "TPC-H SF=10 on S3",
               "local_dir": "vortex-bench/data/tpch/10.0",
-              "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
+              "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/tpch/10.0/",
               "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
-              "scale_factor": "10.0"
+              "scale_factor": "10.0",
+              "iterations": "10"
             },
             {
               "id": "tpcds-nvme",
@@ -81,9 +83,10 @@ on:
               "subcommand": "fineweb",
               "name": "FineWeb S3",
               "local_dir": "vortex-bench/data/fineweb",
-              "remote_storage": "s3://vortex-bench-dev-eu/${{github.ref_name}}/${{github.run_id}}/fineweb/",
+              "remote_storage": "s3://vortex-ci-benchmark-datasets/${{github.ref_name}}/${{github.run_id}}/fineweb/",
               "targets": "datafusion:parquet,datafusion:vortex,datafusion:vortex-compact,duckdb:parquet,duckdb:vortex,duckdb:vortex-compact",
-              "scale_factor": "100"
+              "scale_factor": "100",
+              "iterations": "10"
             },
             {
               "id": "polarsignals",
@@ -102,7 +105,10 @@ jobs:
       matrix:
         include: ${{ fromJSON(inputs.benchmark_matrix) }}
 
-    runs-on: runs-on=${{ github.run_id }}/family=${{ inputs.machine_type }}/image=ubuntu24-full-x64/spot=false/tag=${{ matrix.id }}${{ (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false) && '/extras=s3-cache' || '' }}
+    runs-on: >-
+      ${{ github.repository == 'vortex-data/vortex'
+          && format('runs-on={0}/runner=bench-dedicated/tag={1}{2}', github.run_id, matrix.id, (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false) && '/extras=s3-cache' || '')
+          || 'ubuntu-latest' }}
     steps:
       - uses: runs-on/action@v2
         if: inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false
@@ -115,6 +121,8 @@ jobs:
 
       - uses: actions/checkout@v6
         if: inputs.mode != 'pr'
+      - name: Setup benchmark environment
+        run: sudo bash scripts/setup-benchmark.sh
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -130,7 +138,7 @@ jobs:
       - name: Build binaries
         shell: bash
         env:
-          RUSTFLAGS: "-C target-cpu=native -C force-frame-pointers=yes"
+          RUSTFLAGS: "-C target-cpu=native"
         run: |
           packages="--bin data-gen --bin datafusion-bench --bin duckdb-bench"
           if [ "${{ matrix.build_lance }}" = "true" ]; then
@@ -146,6 +154,11 @@ jobs:
           # Extract all unique formats from targets (e.g., "datafusion:parquet,duckdb:vortex" -> "parquet,vortex")
           all_formats=$(echo "${{ matrix.targets }}" | tr ',' '\n' | sed 's/^[^:]*://' | sort -u | tr '\n' ',' | sed 's/,$//')
 
+          # Append extra data formats if specified (for file size tracking without benchmarking)
+          if [ -n "${{ matrix.extra_data_formats }}" ]; then
+            all_formats="$all_formats,${{ matrix.extra_data_formats }}"
+          fi
+
           # Build options string if scale_factor is set
           opts=""
           if [ -n "${{ matrix.scale_factor }}" ]; then
@@ -159,16 +172,16 @@ jobs:
 
       - name: Setup AWS CLI
         if: inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false
-        uses: aws-actions/configure-aws-credentials@v5
+        uses: aws-actions/configure-aws-credentials@v6
         with:
-          role-to-assume: arn:aws:iam::375504701696:role/GitHubBenchmarkRole
+          role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
 
       - name: Upload data
         if: matrix.remote_storage != null && (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false)
         shell: bash
         env:
-          AWS_REGION: "eu-west-1"
+          AWS_REGION: "us-east-1"
         run: |
           aws s3 rm --recursive ${{ matrix.remote_storage }}
           aws s3 cp --recursive ${{matrix.local_dir}} ${{ matrix.remote_storage }}
@@ -193,27 +206,28 @@ jobs:
           OTEL_EXPORTER_OTLP_HEADERS: "${{ (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false) && secrets.OTEL_EXPORTER_OTLP_HEADERS || '' }}"
           OTEL_RESOURCE_ATTRIBUTES: "bench-name=${{ matrix.id }}"
         run: |
-          .github/scripts/run-sql-bench.sh "${{ matrix.subcommand }}" "${{ matrix.targets }}" \
+          bash scripts/bench-taskset.sh .github/scripts/run-sql-bench.sh "${{ matrix.subcommand }}" "${{ matrix.targets }}" \
+            ${{ matrix.iterations && format('--iterations {0}', matrix.iterations) || '' }} \
             ${{ matrix.scale_factor && format('--scale-factor {0}', matrix.scale_factor) || '' }}
 
       - name: Run ${{ matrix.name }} benchmark (remote)
         if: matrix.remote_storage != null && (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false)
         shell: bash
         env:
-          AWS_REGION: "eu-west-1"
+          AWS_REGION: "us-east-1"
           OTEL_SERVICE_NAME: "vortex-bench"
           OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf"
           OTEL_EXPORTER_OTLP_ENDPOINT: "${{ (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false) && secrets.OTEL_EXPORTER_OTLP_ENDPOINT || '' }}"
           OTEL_EXPORTER_OTLP_HEADERS: "${{ (inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false) && secrets.OTEL_EXPORTER_OTLP_HEADERS || '' }}"
           OTEL_RESOURCE_ATTRIBUTES: "bench-name=${{ matrix.id }}"
         run: |
-          .github/scripts/run-sql-bench.sh "${{ matrix.subcommand }}" "${{ matrix.targets }}" \
+          bash scripts/bench-taskset.sh .github/scripts/run-sql-bench.sh "${{ matrix.subcommand }}" "${{ matrix.targets }}" \
+            ${{ matrix.iterations && format('--iterations {0}', matrix.iterations) || '' }} \
             --remote-storage "${{ matrix.remote_storage }}" \
             --benchmark-id "${{ matrix.id }}" \
             ${{ matrix.scale_factor && format('--scale-factor {0}', matrix.scale_factor) || '' }}
 
       - name: Install uv
-        if: inputs.mode == 'pr'
         uses: spiraldb/actions/.github/actions/setup-uv@0.18.5
         with:
           sync: false
@@ -231,7 +245,7 @@ jobs:
             | jq -r '.workflow_runs[].head_sha' \
           )
 
-          python3 scripts/s3-download.py s3://vortex-benchmark-results-database/data.json.gz data.json.gz --no-sign-request
+          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
 
           echo '# Benchmarks: ${{ matrix.name }}' > comment.md
@@ -250,6 +264,56 @@ jobs:
           # unique benchmark configuration must have a unique comment-tag.
           comment-tag: bench-pr-comment-${{ matrix.id }}
 
+      - name: Compare file sizes
+        if: inputs.mode == 'pr' && matrix.remote_storage == null
+        shell: bash
+        run: |
+          set -Eeu -o pipefail -x
+
+          # Capture HEAD file sizes (vortex formats only)
+          uv run --no-project scripts/capture-file-sizes.py \
+            vortex-bench/data \
+            --benchmark ${{ matrix.subcommand }} \
+            --commit ${{ github.event.pull_request.head.sha }} \
+            -o head-sizes.json
+
+          # Get base commit SHA (same as benchmark comparison)
+          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' \
+          )
+
+          # Download file sizes baseline (per-benchmark file)
+          python3 scripts/s3-download.py s3://vortex-ci-benchmark-results/file-sizes-${{ matrix.id }}.json.gz file-sizes.json.gz --no-sign-request || true
+
+          # Generate comparison report
+          echo '# File Sizes: ${{ matrix.name }}' > sizes-comment.md
+          echo '' >> sizes-comment.md
+
+          if [ -f file-sizes.json.gz ]; then
+            gzip -d -c file-sizes.json.gz | grep $base_commit_sha > base-sizes.json || true
+            if [ -s base-sizes.json ]; then
+              uv run --no-project scripts/compare-file-sizes.py base-sizes.json head-sizes.json \
+                >> sizes-comment.md
+            else
+              echo '_No baseline file sizes found for base commit._' >> sizes-comment.md
+            fi
+          else
+            echo '_No baseline file sizes available yet._' >> sizes-comment.md
+          fi
+
+          cat sizes-comment.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Comment PR with file sizes
+        if: inputs.mode == 'pr' && matrix.remote_storage == null && github.event.pull_request.head.repo.fork == false
+        uses: thollander/actions-comment-pull-request@v3
+        with:
+          file-path: sizes-comment.md
+          comment-tag: file-sizes-${{ matrix.id }}
+
       - name: Comment PR on failure
         if: failure() && inputs.mode == 'pr' && github.event.pull_request.head.repo.fork == false
         uses: thollander/actions-comment-pull-request@v3
@@ -264,7 +328,18 @@ jobs:
         if: inputs.mode == 'develop'
         shell: bash
         run: |
-          bash scripts/cat-s3.sh vortex-benchmark-results-database data.json.gz results.json
+          bash scripts/cat-s3.sh vortex-ci-benchmark-results data.json.gz results.json
+
+      - name: Upload File Sizes
+        if: inputs.mode == 'develop' && matrix.remote_storage == null
+        shell: bash
+        run: |
+          uv run --no-project scripts/capture-file-sizes.py \
+            vortex-bench/data \
+            --benchmark ${{ matrix.subcommand }} \
+            --commit ${{ github.sha }} \
+            -o sizes.json
+          bash scripts/cat-s3.sh vortex-ci-benchmark-results file-sizes-${{ matrix.id }}.json.gz sizes.json
 
       - name: Alert incident.io
         if: failure() && inputs.mode == 'develop'
diff --git a/.github/workflows/sql-pr.yml b/.github/workflows/sql-pr.yml
index a46a7891c38..420425a4321 100644
--- a/.github/workflows/sql-pr.yml
+++ b/.github/workflows/sql-pr.yml
@@ -1,4 +1,5 @@
-# Runs once when we add the `benchmark-sql` tag to a pull request.
+# Runs SQL benchmarks once for a pull request.
+# Called from bench-dispatch.yml when the `action/benchmark-sql` label is added.
 
 name: PR SQL Benchmarks
 
@@ -7,32 +8,16 @@ concurrency:
   cancel-in-progress: true
 
 on:
-  pull_request:
-    types: [labeled, synchronize]
-    branches: ["develop"]
+  workflow_call: { }
   workflow_dispatch: { }
 
 permissions:
-  actions: write  # for removing labels
   contents: read
   pull-requests: write  # for commenting on PRs
   id-token: write  # enables AWS-GitHub OIDC
 
 jobs:
-  label_trigger:
-    runs-on: ubuntu-latest
-    timeout-minutes: 2
-    if: ${{ contains(github.event.head_commit.message, '[benchmark-sql]') || github.event.label.name == 'action/benchmark-sql' && github.event_name == 'pull_request' }}
-    steps:
-      # We remove the benchmark label first so that the workflow can be re-triggered.
-      - uses: actions-ecosystem/action-remove-labels@v1
-        if: ${{ github.event.pull_request.head.repo.full_name == 'vortex-data/vortex' }}
-        with:
-          labels: action/benchmark-sql
-          fail_on_error: true
-
   sql:
-    needs: label_trigger
     uses: ./.github/workflows/sql-benchmarks.yml
     secrets: inherit
     with:
diff --git a/.github/workflows/typos.yml b/.github/workflows/typos.yml
index 1d55f7c1d11..6f51e873c61 100644
--- a/.github/workflows/typos.yml
+++ b/.github/workflows/typos.yml
@@ -20,4 +20,4 @@ jobs:
       - name: Checkout Actions Repository
         uses: actions/checkout@v6
       - name: Spell Check Repo
-        uses: crate-ci/typos@v1.41.0
+        uses: crate-ci/typos@v1.44.0
diff --git a/.github/workflows/wasm-fuzz.yml b/.github/workflows/wasm-fuzz.yml
index d4694c60d2c..4ff51ee78f3 100644
--- a/.github/workflows/wasm-fuzz.yml
+++ b/.github/workflows/wasm-fuzz.yml
@@ -85,7 +85,7 @@ jobs:
 
       - name: Upload corpus
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: corpus-wasm
           path: corpus-wasm/
diff --git a/.github/workflows/web.yml b/.github/workflows/web.yml
new file mode 100644
index 00000000000..6fd0a72ea83
--- /dev/null
+++ b/.github/workflows/web.yml
@@ -0,0 +1,115 @@
+---
+
+name: Vortex Web
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+on:
+  pull_request:
+  push:
+    branches: [develop]
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    working-directory: vortex-web
+
+jobs:
+  changes:
+    name: Detect Changes
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    outputs:
+      web: ${{ steps.filter.outputs.web }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            web:
+              - "vortex-web/**"
+              - ".github/workflows/web.yml"
+
+  check:
+    name: Check & Lint
+    needs: [changes]
+    if: needs.changes.outputs.web == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          enable-sccache: "false"
+      - name: Install wasm-pack
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+        working-directory: .
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+          cache-dependency-path: vortex-web/package-lock.json
+      - run: npm ci
+      - run: npm run wasm
+      - run: npm run format:check
+      - run: npm run lint
+      - run: npm run typecheck
+      - run: npm run build-storybook
+
+  build:
+    name: Build
+    needs: [changes]
+    if: needs.changes.outputs.web == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          enable-sccache: "false"
+      - name: Install wasm-pack
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+        working-directory: .
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+          cache-dependency-path: vortex-web/package-lock.json
+      - run: npm ci
+      - run: npm run build
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: vortex-explorer
+          path: vortex-web/dist/
+
+  deploy:
+    name: Deploy to Cloudflare Pages
+    needs: [build]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      deployments: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.deployment-url }}
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: vortex-explorer
+          path: dist
+      - name: Deploy to Cloudflare Pages
+        id: deploy
+        uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          command: pages deploy dist/ --project-name=vortex-explorer --branch=${{ github.head_ref || github.ref_name }}
diff --git a/.gitignore b/.gitignore
index ecde7a25d5f..3eaf3c2579f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,7 @@ __pycache__/
 # Distribution / packaging
 .Python
 build/
+ninja-build/
 develop-eggs/
 dist/
 downloads/
@@ -218,6 +219,9 @@ profile.json.gz
 # Clang compilation database (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
 compile_commands.json
 
+# Commands
+/justfile
+
 # AI Agents
 .claude
 .opencode
@@ -234,3 +238,6 @@ sweep.timestamp
 # Perfetto
 trace*.json
 trace*.pb
+
+# pytest-benchmark output
+vortex-python/.benchmarks/
diff --git a/.idea/copyright/profiles_settings.xml b/.idea/copyright/profiles_settings.xml
index 61532053af8..fddee87269b 100644
--- a/.idea/copyright/profiles_settings.xml
+++ b/.idea/copyright/profiles_settings.xml
@@ -2,10 +2,24 @@
   <settings default="spdx-apache">
     <module2copyright>
       <element module="rust-files" copyright="spdx-apache" />
+      <element module="web-files" copyright="spdx-apache" />
     </module2copyright>
+    <LanguageOptions name="CSS">
+      <option name="fileTypeOverride" value="3" />
+      <option name="block" value="false" />
+      <option name="prefixLines" value="false" />
+    </LanguageOptions>
     <LanguageOptions name="Rust">
       <option name="fileTypeOverride" value="3" />
       <option name="block" value="false" />
     </LanguageOptions>
+    <LanguageOptions name="TypeScript">
+      <option name="fileTypeOverride" value="3" />
+      <option name="block" value="false" />
+    </LanguageOptions>
+    <LanguageOptions name="TypeScript JSX">
+      <option name="fileTypeOverride" value="3" />
+      <option name="block" value="false" />
+    </LanguageOptions>
   </settings>
 </component>
\ No newline at end of file
diff --git a/.idea/scopes/web_files.xml b/.idea/scopes/web_files.xml
new file mode 100644
index 00000000000..7f11007f7f9
--- /dev/null
+++ b/.idea/scopes/web_files.xml
@@ -0,0 +1,3 @@
+<component name="DependencyValidationManager">
+  <scope name="web-files" pattern="file[vortex]:*/*.ts||file[vortex]:*/*.tsx||file[vortex]:*/*.css" />
+</component>
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000000..f4cc4620f00
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,81 @@
+# Vortex
+
+## Development Guidelines
+
+- project is a monorepo Rust workspace, java bindings in `/java`, python bindings in
+  `/vortex-python`
+- run `cargo build -p` to build a specific crate
+- use `cargo clippy --all-targets --all-features` to make sure a project is free of lint issues.
+  Please do this every time you reach a stopping point or think you've finished work.
+- run `cargo +nightly fmt --all` to format Rust source files. Please do this every time you reach a
+  stopping point or think you've finished work.
+- run `./scripts/public-api.sh` to re-generate the public API lock files. Please do this every time
+  you reach a stopping point or think you've finished work.
+- you can try running
+  `cargo fix --lib --allow-dirty --allow-staged && cargo clippy --fix --lib --allow-dirty --allow-staged`
+  to automatically many fix minor errors.
+- when iterating on CI failures, fetch only failed job logs first
+  (`gh run view <run-id> --job <job-id> --log-failed`) and run narrow local repro commands for the
+  affected crate/tests before running workspace-wide checks.
+- if `gh` commands fail with `error connecting to api.github.com` in sandbox, immediately rerun with
+  escalated network permissions instead of retrying in sandbox.
+- if cargo fails with `sccache: error: Operation not permitted`, rerun the command with
+  `RUSTC_WRAPPER=` so rustc runs directly.
+- run docs doctests from the docs directory (`make -C docs doctest`) so the correct Sphinx Makefile
+  target is used.
+
+## Architecture
+
+- `vortex-buffer` defines zero-copy aligned `Buffer<T>` and `BufferMut<T>` that are guaranteed to be
+  aligned to `T` (or whatever requested runtime alignment).
+- `vortex-array/src/dtype` contains the basic `DType` logical type enum that is the basis of the
+  Vortex type system
+- `vortex-array` contains the basic `Array` trait, as well as several encodings which impl that
+  trait for each encoding. It includes all of most of the Apache Arrow encodings.
+- More exotic compressed encodings live in the crates inside of `/encodings/*`
+- File IO is defined in `vortex-file`. It uses the concept of a `LayoutReader` defined in
+  `vortex-layout` crate.
+- `/vortex-python` contains the python bindings. rst flavored docs for the project are in `/docs`
+
+## Code Style
+
+- Prefer `impl AsRef<T>` to `&T` for public interfaces where possible, e.g. `impl AsRef<Path>`
+- Avoid usage of unsafe where not necessary, use zero-cost safe abstractions wherever possible, or
+  cheap non-zero-cost abstractions.
+- Every new public API definition must have a doc comment. Examples are nice to have but not
+  strictly required.
+- Use `vortex_err!` to create a `VortexError` with a format string and `vortex_bail!` to do the same
+  but immediately return it as a `VortexResult<T>` to the surrounding context.
+- When writing tests, strongly consider using `rstest` cases to parameterize repetitive test logic.
+- If you want to create a large number of tests to an existing file module called `foo.rs`, and if
+  you think doing so would be too many to inline in a `tests` submodule within `foo.rs`, then first
+  promote `foo` to a directory module. You can do this by running
+  `mkdir foo && mv foo.rs foo/mod.rs`. Then, you can create a test file `foo/tests.rs` that you
+  include in `foo/mod.rs` with the appropriate test config flag.
+- If you encounter clippy errors in tests that should only pertain to production code (e.g.,
+  prohibiting panic/unwrap, possible numerical truncation, etc.), then consider allowing those lints
+  at the test module level.
+- Prefer naming test modules `tests`, not `test`.
+- Prefer having test return VortexResult<()> and use ? over unwrap.
+- All imports must be at the top of the module, never inside functions. The only exception is
+  `#[cfg(test)]` blocks, where imports should be at the top of the test module. Function-scoped
+  imports are only acceptable when (a) required, or (b) it would be exceptionally verbose otherwise,
+  such as a match statement where left and right sides have similar names.
+- Imports should be preferred over qualified identifiers.
+- Only write comments that explain non-obvious logic or important context. Avoid commenting simple
+  or self-explanatory code.
+- Use `assert_arrays_eq!` macro for comparing arrays in tests instead of element-by-element
+  comparison.
+- Keep tests concise and to the point - avoid unnecessary setup or verbose assertions.
+- Run tests for a specific crate with `cargo test -p <crate-name>` (e.g.,
+  `cargo test -p vortex-array`).
+
+## Other
+
+- When summarizing your work, please produce summaries in valid Markdown that can be easily
+  copied/pasted to Github.
+
+## Commits
+
+- All commits must be signed of by the committers in the form
+  `Signed-off-by: "COMMITTER" <COMMITTER_EMAIL>`.
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index c3e59a5e74b..00000000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Vortex
-
-## Development Guidelines
-
-* project is a monorepo Rust workspace, java bindings in `/java`, python bindings in `/vortex-python`
-* run `cargo build -p` to build a specific crate
-* use `cargo clippy --all-targets --all-features` to make sure a project is free of lint issues. Please do this every
-  time you reach a stopping point or think you've finished work.
-* run `cargo +nightly fmt --all` to format Rust source files. Please do this every time you reach a stopping point or
-  think you've finished work.
-* you can try running
-  `cargo fix --lib --allow-dirty --allow-staged && cargo clippy --fix --lib --allow-dirty --allow-staged` to
-  automatically many fix minor errors.
-
-## Architecture
-
-* `vortex-buffer` defines zero-copy aligned `Buffer<T>` and `BufferMut<T>` that are guaranteed
-  to be aligned to `T` (or whatever requested runtime alignment).
-* `vortex-array/src/dtype` contains the basic `DType` logical type enum that is the basis of the Vortex
-  type system
-* `vortex-array` contains the basic `Array` trait, as well as several encodings which impl
-  that trait for each encoding. It includes all of most of the Apache Arrow encodings.
-* More exotic compressed encodings live in the crates inside of `/encodings/*`
-* File IO is defined in `vortex-file`. It uses the concept of a `LayoutReader` defined
-  in `vortex-layout` crate.
-* `/vortex-python` contains the python bindings. rst flavored docs for the project are in `/docs`
-
-## Code Style
-
-* Prefer `impl AsRef<T>` to `&T` for public interfaces where possible, e.g. `impl AsRef<Path>`
-* Avoid usage of unsafe where not necessary, use zero-cost safe abstractions wherever possible,
-  or cheap non-zero-cost abstractions.
-* Every new public API definition must have a doc comment. Examples are nice to have but not
-  strictly required.
-* Use `vortex_err!` to create a `VortexError` with a format string and `vortex_bail!` to do the same but immediately
-  return it as a `VortexResult<T>` to the surrounding context.
-* When writing tests, strongly consider using `rstest` cases to parameterize repetitive test logic.
-* If you want to create a large number of tests to an existing file module called `foo.rs`, and if you think doing so
-  would
-  be too many to inline in a `tests` submodule within `foo.rs`, then first promote `foo` to a directory module. You can
-  do
-  this by running `mkdir foo && mv foo.rs foo/mod.rs`. Then, you can create a test file `foo/tests.rs` that you include
-  in `foo/mod.rs` with the appropriate test config flag.
-* If you encounter clippy errors in tests that should only pertain to production code (e.g., prohibiting panic/unwrap,
-  possible numerical truncation, etc.), then consider allowing those lints at the test module level.
-* Prefer naming test modules `tests`, not `test`.
-* Prefer having test return VortexResult<()> and use ? over unwrap.
-* All imports must be at the top of the module, never inside functions. The only exception is `#[cfg(test)]` blocks,
-  where imports should be at the top of the test module. Function-scoped imports are only acceptable when (a) required,
-  or (b) it would be exceptionally verbose otherwise, such as a match statement where left and right sides have similar names.
-* Only write comments that explain non-obvious logic or important context. Avoid commenting simple or self-explanatory code.
-* Use `assert_arrays_eq!` macro for comparing arrays in tests instead of element-by-element comparison.
-* Keep tests concise and to the point - avoid unnecessary setup or verbose assertions.
-* Run tests for a specific crate with `cargo test -p <crate-name>` (e.g., `cargo test -p vortex-array`).
-
-## Other
-
-* When summarizing your work, please produce summaries in valid Markdown that can be easily copied/pasted to Github.
-
-## Commits
-
-* All commits must be signed of by the committers in the form `Signed-off-by: "COMMITTER" <COMMITTER_EMAIL>`.
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 00000000000..47dc3e3d863
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index eeaa13407b2..aef2e0c33ac 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,19 +4,15 @@ Welcome, and thank you for your interest in contributing to Vortex! We are delig
 
 We ask that you read the guidelines below in order to make the process as streamlined as possible.
 
-## AI Assistance Notice
+## AI Assistance
 
 > [!IMPORTANT]
-> The Vortex project allows AI-assisted contributions, which must be properly
-> disclosed in the pull request.
+> The Vortex project permits and embraces AI-assisted contributions. Contributors
+> should disclose usage of conversational or agentic AI tools in the PR description.
 >
-> If you are using any kind of AI assistance when contributing to Vortex, please
-> disclose this in your pull request, along with the extent to which it was used
-> (e.g. writing docs or code generation).
->
-> Contributors are required to be able to understand the AI-assisted output and
-> reason about it. Should a PR indicate no visible human accountability and
-> involvement we reserve the right to close it.
+> For the full AI policy — including disclosure requirements, review standards for
+> AI-generated PRs, and rules for autonomous agents — see the
+> [contributing guide](https://vortex.dev/project/contributing.html#ai-assistance).
 
 ## Code Contributions
 
@@ -35,7 +31,7 @@ The contribution process is outlined below:
 
 3. Open a PR to indicate that the change is ready for review.
    - Ensure that you sign your work via DCO (see below).
-   - Disclose LLM usage as described in [AI Assistance Notice](#ai-assistance-notice).
+   - Disclose LLM usage as described in [AI Assistance](#ai-assistance).
    - CI requires approval from external committers.
 
 ## Governance
diff --git a/Cargo.lock b/Cargo.lock
index 02085fdbe1b..5c7f200d756 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -16,7 +16,7 @@ checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
 dependencies = [
  "cfg-if",
  "cipher",
- "cpufeatures",
+ "cpufeatures 0.2.17",
 ]
 
 [[package]]
@@ -96,7 +96,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
  "anstyle",
- "anstyle-parse",
+ "anstyle-parse 0.2.7",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse 1.0.0",
  "anstyle-query",
  "anstyle-wincon",
  "colorchoice",
@@ -106,9 +121,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
 [[package]]
 name = "anstyle-parse"
@@ -119,6 +134,15 @@ dependencies = [
  "utf8parse",
 ]
 
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
 [[package]]
 name = "anstyle-query"
 version = "1.1.5"
@@ -197,15 +221,12 @@ 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"
-version = "1.8.2"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9f3647c145568cec02c42054e07bdf9a5a698e15b466fb2341bfc393cd24aa5"
+checksum = "a07d1f37ff60921c83bdfc7407723bdefe89b44b98a9b772f225c8f9d67141a6"
 dependencies = [
  "rustversion",
 ]
@@ -234,19 +255,40 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4754a624e5ae42081f464514be454b39711daae0458906dacde5f4c632f33a8"
 dependencies = [
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-csv",
- "arrow-data",
- "arrow-ipc",
- "arrow-json",
- "arrow-ord",
- "arrow-row",
- "arrow-schema",
- "arrow-select",
- "arrow-string",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-csv 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-ipc 57.3.0",
+ "arrow-json 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-row 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+ "arrow-string 57.3.0",
+]
+
+[[package]]
+name = "arrow"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "602268ce9f569f282cedb9a9f6bac569b680af47b9b077d515900c03c5d190da"
+dependencies = [
+ "arrow-arith 58.0.0",
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-cast 58.0.0",
+ "arrow-csv 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-ipc 58.0.0",
+ "arrow-json 58.0.0",
+ "arrow-ord 58.0.0",
+ "arrow-row 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
+ "arrow-string 58.0.0",
 ]
 
 [[package]]
@@ -255,10 +297,24 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "chrono",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd53c6bf277dea91f136ae8e3a5d7041b44b5e489e244e637d00ae302051f56f"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "chrono",
  "num-traits",
 ]
@@ -270,9 +326,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef"
 dependencies = [
  "ahash 0.8.12",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "chrono",
+ "chrono-tz",
+ "half",
+ "hashbrown 0.16.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-array"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53796e07a6525edaf7dc28b540d477a934aff14af97967ad1d5550878969b9e"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "chrono",
  "chrono-tz",
  "half",
@@ -294,18 +369,52 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "arrow-buffer"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2c1a85bb2e94ee10b76531d8bc3ce9b7b4c0d508cabfb17d477f63f2617bd20"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint",
+ "num-traits",
+]
+
 [[package]]
 name = "arrow-cast"
 version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+ "atoi",
+ "base64",
+ "chrono",
+ "comfy-table",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89fb245db6b0e234ed8e15b644edb8664673fefe630575e94e62cd9d489a8a26"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-ord 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
  "atoi",
  "base64",
  "chrono",
@@ -322,9 +431,24 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8da746f4180004e3ce7b83c977daf6394d768332349d3d913998b10a120b790a"
 dependencies = [
- "arrow-array",
- "arrow-cast",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-schema 57.3.0",
+ "chrono",
+ "csv",
+ "csv-core",
+ "regex",
+]
+
+[[package]]
+name = "arrow-csv"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d374882fb465a194462527c0c15a93aa19a554cf690a6b77a26b2a02539937a7"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-cast 58.0.0",
+ "arrow-schema 58.0.0",
  "chrono",
  "csv",
  "csv-core",
@@ -337,8 +461,21 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304"
 dependencies = [
- "arrow-buffer",
- "arrow-schema",
+ "arrow-buffer 57.3.0",
+ "arrow-schema 57.3.0",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-data"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "189d210bc4244c715fa3ed9e6e22864673cccb73d5da28c2723fb2e527329b33"
+dependencies = [
+ "arrow-buffer 58.0.0",
+ "arrow-schema 58.0.0",
  "half",
  "num-integer",
  "num-traits",
@@ -350,13 +487,29 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abf7df950701ab528bf7c0cf7eeadc0445d03ef5d6ffc151eaae6b38a58feff1"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+ "flatbuffers",
+ "lz4_flex 0.12.1",
+ "zstd",
+]
+
+[[package]]
+name = "arrow-ipc"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7968c2e5210c41f4909b2ef76f6e05e172b99021c2def5edf3cc48fdd39d1d6c"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
  "flatbuffers",
- "lz4_flex 0.12.0",
+ "lz4_flex 0.12.1",
  "zstd",
 ]
 
@@ -366,11 +519,35 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ff8357658bedc49792b13e2e862b80df908171275f8e6e075c460da5ee4bf86"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "chrono",
+ "half",
+ "indexmap",
+ "itoa",
+ "lexical-core",
+ "memchr",
+ "num-traits",
+ "ryu",
+ "serde_core",
+ "serde_json",
+ "simdutf8",
+]
+
+[[package]]
+name = "arrow-json"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92111dba5bf900f443488e01f00d8c4ddc2f47f5c50039d18120287b580baa22"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-cast 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "chrono",
  "half",
  "indexmap",
@@ -390,11 +567,24 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "211136cb253577ee1a6665f741a13136d4e563f64f5093ffd6fb837af90b9495"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
 ]
 
 [[package]]
@@ -403,10 +593,23 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "18228633bad92bff92a95746bbeb16e5fc318e8382b75619dec26db79e4de4c0"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "half",
+]
+
+[[package]]
+name = "arrow-row"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e0f20145f9f5ea3fe383e2ba7a7487bf19be36aa9dbf5dd6a1f92f657179663"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "half",
 ]
 
@@ -416,7 +619,18 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
+ "serde_core",
+ "serde_json",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b47e0ca91cc438d2c7879fe95e0bca5329fff28649e30a88c6f760b1faeddcb"
+dependencies = [
+ "bitflags",
  "serde_core",
  "serde_json",
 ]
@@ -428,10 +642,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b"
 dependencies = [
  "ahash 0.8.12",
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-select"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "750a7d1dda177735f5e82a314485b6915c7cccdbb278262ac44090f4aba4a325"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "num-traits",
 ]
 
@@ -441,11 +669,28 @@ version = "57.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "arrow-string"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1eab1208bc4fe55d768cdc9b9f3d9df5a794cdb3ee2586bf89f9b30dc31ad8c"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
  "memchr",
  "num-traits",
  "regex",
@@ -645,15 +890,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "atomic"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
-dependencies = [
- "bytemuck",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -666,12 +902,60 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "aws-lc-rs"
+version = "1.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
+dependencies = [
+ "aws-lc-sys",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
 [[package]]
 name = "base64"
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "beamterm-data"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf74a7c20e83a40e542c032c918f1b5653ad4a137b49b7063e61030983ce243"
+dependencies = [
+ "compact_str",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "beamterm-renderer"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c27cc93582c7ce0f7350adcd2e0ffe21237687ba6bfb67cdea15e6e37001d19f"
+dependencies = [
+ "beamterm-data",
+ "compact_str",
+ "console_error_panic_hook",
+ "js-sys",
+ "thiserror 2.0.18",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "better_io"
 version = "0.2.0"
@@ -698,7 +982,7 @@ version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -713,32 +997,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "bit-set"
-version = "0.5.3"
+name = "bit-vec"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
 dependencies = [
- "bit-vec 0.6.3",
+ "serde",
 ]
 
-[[package]]
-name = "bit-vec"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
-
-[[package]]
-name = "bit-vec"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
 [[package]]
 name = "bitflags"
 version = "2.11.0"
@@ -785,8 +1051,8 @@ dependencies = [
  "arrayvec",
  "cc",
  "cfg-if",
- "constant_time_eq 0.4.2",
- "cpufeatures",
+ "constant_time_eq",
+ "cpufeatures 0.2.17",
 ]
 
 [[package]]
@@ -813,9 +1079,9 @@ dependencies = [
 
 [[package]]
 name = "bon"
-version = "3.9.0"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d13a61f2963b88eef9c1be03df65d42f6996dfeac1054870d950fcf66686f83"
+checksum = "f47dbe92550676ee653353c310dfb9cf6ba17ee70396e1f7cf0a2020ad49b2fe"
 dependencies = [
  "bon-macros",
  "rustversion",
@@ -823,9 +1089,9 @@ dependencies = [
 
 [[package]]
 name = "bon-macros"
-version = "3.9.0"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d314cc62af2b6b0c65780555abb4d02a03dd3b799cd42419044f0c38d99738c0"
+checksum = "519bd3116aeeb42d5372c29d982d16d0170d3d4a5ed85fc7dd91642ffff3c67c"
 dependencies = [
  "darling",
  "ident_case",
@@ -838,19 +1104,20 @@ dependencies = [
 
 [[package]]
 name = "borsh"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
+checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a"
 dependencies = [
  "borsh-derive",
+ "bytes",
  "cfg_aliases",
 ]
 
 [[package]]
 name = "borsh-derive"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c"
+checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59"
 dependencies = [
  "once_cell",
  "proc-macro-crate",
@@ -1039,9 +1306,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.56"
+version = "1.2.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1082,6 +1349,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.0",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.44"
@@ -1093,7 +1371,7 @@ dependencies = [
  "num-traits",
  "serde",
  "wasm-bindgen",
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -1103,7 +1381,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
 dependencies = [
  "chrono",
- "phf 0.12.1",
+ "phf",
 ]
 
 [[package]]
@@ -1156,9 +1434,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.60"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a"
+checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -1166,11 +1444,11 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.60"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
 dependencies = [
- "anstream",
+ "anstream 1.0.0",
  "anstyle",
  "clap_lex",
  "strsim",
@@ -1179,9 +1457,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.55"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1191,9 +1469,18 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "1.0.0"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "cmake"
+version = "0.1.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
 
 [[package]]
 name = "codespan-reporting"
@@ -1208,9 +1495,9 @@ dependencies = [
 
 [[package]]
 name = "codspeed"
-version = "4.3.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38c2eb3388ebe26b5a0ab6bf4969d9c4840143d7f6df07caa3cc851b0606cef6"
+checksum = "b684e94583e85a5ca7e1a6454a89d76a5121240f2fb67eb564129d9bafdb9db0"
 dependencies = [
  "anyhow",
  "cc",
@@ -1218,7 +1505,7 @@ dependencies = [
  "getrandom 0.2.17",
  "glob",
  "libc",
- "nix 0.30.1",
+ "nix",
  "serde",
  "serde_json",
  "statrs",
@@ -1226,9 +1513,9 @@ dependencies = [
 
 [[package]]
 name = "codspeed-criterion-compat-walltime"
-version = "4.3.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c2613d2fac930fe34456be76f9124ee0800bb9db2e7fd2d6c65b9ebe98a292"
+checksum = "96389aaa4bbb872ea4924dc0335b2bb181bcf28d6eedbe8fea29afcc5bde36a6"
 dependencies = [
  "anes",
  "cast",
@@ -1253,9 +1540,9 @@ dependencies = [
 
 [[package]]
 name = "codspeed-divan-compat"
-version = "4.3.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2de65b7489a59709724d489070c6d05b7744039e4bf751d0a2006b90bb5593d"
+checksum = "89e4bf8c7793c170fd0fcf3be97b9032b2ae39c2b9e8818aba3cc10ca0f0c6c0"
 dependencies = [
  "clap",
  "codspeed",
@@ -1266,9 +1553,9 @@ dependencies = [
 
 [[package]]
 name = "codspeed-divan-compat-macros"
-version = "4.3.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ca01ce4fd22b8dcc6c770dcd6b74343642e842482b94e8920d14e10c57638d"
+checksum = "78aae02f2a278588e16e8ca62ea1915b8ab30f8230a09926671bba19ede801a4"
 dependencies = [
  "divan-macros",
  "itertools 0.14.0",
@@ -1280,9 +1567,9 @@ dependencies = [
 
 [[package]]
 name = "codspeed-divan-compat-walltime"
-version = "4.3.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "720ab9d0714718afe5f5832be6e5f5eb5ce97836e24ca7bf7042eea4308b9fb8"
+checksum = "59ffd32c0c59ab8b674b15be65ba7c59aebac047036cfa7fa1e11bc2c178b81f"
 dependencies = [
  "cfg-if",
  "clap",
@@ -1295,9 +1582,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "colored"
@@ -1348,8 +1635,8 @@ name = "compress-bench"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-array",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "async-trait",
  "bytes",
  "clap",
@@ -1357,7 +1644,7 @@ dependencies = [
  "indicatif",
  "itertools 0.14.0",
  "lance-bench",
- "parquet",
+ "parquet 58.0.0",
  "regex",
  "tokio",
  "tracing",
@@ -1415,17 +1702,26 @@ dependencies = [
 
 [[package]]
 name = "console"
-version = "0.16.2"
+version = "0.16.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03e45a4a8926227e4197636ba97a9fc9b00477e9f4bd711395687c5f0734bec4"
+checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87"
 dependencies = [
  "encode_unicode",
  "libc",
- "once_cell",
  "unicode-width 0.2.2",
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "const-random"
 version = "0.1.18"
@@ -1472,12 +1768,6 @@ dependencies = [
  "unicode-xid",
 ]
 
-[[package]]
-name = "constant_time_eq"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
-
 [[package]]
 name = "constant_time_eq"
 version = "0.4.2"
@@ -1529,20 +1819,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "crc"
-version = "3.4.0"
+name = "cpufeatures"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
 dependencies = [
- "crc-catalog",
+ "libc",
 ]
 
-[[package]]
-name = "crc-catalog"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
-
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -1611,10 +1895,11 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "crossterm_winapi",
  "derive_more",
  "document-features",
+ "futures-core",
  "mio",
  "parking_lot",
  "rustix 1.1.4",
@@ -1648,16 +1933,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "csscolorparser"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2a7d3066da2de787b7f032c736763eb7ae5d355f81a68bab2675a96008b0bf"
-dependencies = [
- "lab",
- "phf 0.11.3",
-]
-
 [[package]]
 name = "csv"
 version = "1.4.0"
@@ -1817,8 +2092,8 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ba7cb113e9c0bedf9e9765926031e132fa05a1b09ba6e93a6d1a4d7044457b8"
 dependencies = [
- "arrow",
- "arrow-schema",
+ "arrow 57.3.0",
+ "arrow-schema 57.3.0",
  "async-trait",
  "bytes",
  "chrono",
@@ -1849,12 +2124,12 @@ dependencies = [
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "parking_lot",
  "rand 0.9.2",
  "regex",
  "rstest",
- "sqlparser",
+ "sqlparser 0.59.0",
  "tempfile",
  "tokio",
  "url",
@@ -1863,53 +2138,53 @@ dependencies = [
 
 [[package]]
 name = "datafusion"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d12ee9fdc6cdb5898c7691bb994f0ba606c4acc93a2258d78bb9f26ff8158bb3"
+checksum = "de9f8117889ba9503440f1dd79ebab32ba52ccf1720bb83cd718a29d4edc0d16"
 dependencies = [
- "arrow",
- "arrow-schema",
+ "arrow 58.0.0",
+ "arrow-schema 58.0.0",
  "async-trait",
  "bytes",
  "bzip2",
  "chrono",
- "datafusion-catalog 52.1.0",
- "datafusion-catalog-listing 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-datasource-arrow 52.1.0",
+ "datafusion-catalog 53.0.0",
+ "datafusion-catalog-listing 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-datasource-arrow 53.0.0",
  "datafusion-datasource-avro",
- "datafusion-datasource-csv 52.1.0",
- "datafusion-datasource-json 52.1.0",
+ "datafusion-datasource-csv 53.0.0",
+ "datafusion-datasource-json 53.0.0",
  "datafusion-datasource-parquet",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-functions-aggregate 52.1.0",
- "datafusion-functions-nested 52.1.0",
- "datafusion-functions-table 52.1.0",
- "datafusion-functions-window 52.1.0",
- "datafusion-optimizer 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-adapter 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-optimizer 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
- "datafusion-sql 52.1.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-functions-aggregate 53.0.0",
+ "datafusion-functions-nested 53.0.0",
+ "datafusion-functions-table 53.0.0",
+ "datafusion-functions-window 53.0.0",
+ "datafusion-optimizer 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-adapter 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-optimizer 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
+ "datafusion-sql 53.0.0",
  "flate2",
  "futures",
  "itertools 0.14.0",
  "liblzma",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "parking_lot",
- "parquet",
+ "parquet 58.0.0",
  "rand 0.9.2",
  "regex",
- "sqlparser",
+ "sqlparser 0.61.0",
  "tempfile",
  "tokio",
  "url",
@@ -1924,12 +2199,12 @@ dependencies = [
  "anyhow",
  "clap",
  "custom-labels",
- "datafusion 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
+ "datafusion 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
  "futures",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.13.1",
  "opentelemetry",
  "opentelemetry-otlp",
  "opentelemetry_sdk",
@@ -1949,7 +2224,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66a3a799f914a59b1ea343906a0486f17061f39509af74e874a866428951130d"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "dashmap",
  "datafusion-common 51.0.0",
@@ -1963,32 +2238,32 @@ dependencies = [
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "parking_lot",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-catalog"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "462dc9ef45e5d688aeaae49a7e310587e81b6016b9d03bace5626ad0043e5a9e"
+checksum = "be893b73a13671f310ffcc8da2c546b81efcc54c22e0382c0a28aa3537017137"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "dashmap",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "parking_lot",
  "tokio",
 ]
@@ -1999,7 +2274,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db1b113c80d7a0febcd901476a57aef378e717c54517a163ed51417d87621b0"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "datafusion-catalog 51.0.0",
  "datafusion-common 51.0.0",
@@ -2013,31 +2288,31 @@ dependencies = [
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-catalog-listing"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b96dbf1d728fc321817b744eb5080cdd75312faa6980b338817f68f3caa4208"
+checksum = "830487b51ed83807d6b32d6325f349c3144ae0c9bf772cf2a712db180c31d5e6"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
- "datafusion-catalog 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-adapter 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
+ "datafusion-catalog 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-adapter 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.13.1",
 ]
 
 [[package]]
@@ -2047,42 +2322,43 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c10f7659e96127d25e8366be7c8be4109595d6a2c3eac70421f380a7006a1b0"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "arrow-ipc",
+ "arrow 57.3.0",
+ "arrow-ipc 57.3.0",
  "chrono",
  "half",
  "hashbrown 0.14.5",
  "indexmap",
  "libc",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "paste",
- "sqlparser",
+ "sqlparser 0.59.0",
  "tokio",
  "web-time",
 ]
 
 [[package]]
 name = "datafusion-common"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3237a6ff0d2149af4631290074289cae548c9863c885d821315d54c6673a074a"
+checksum = "0d7663f3af955292f8004e74bcaf8f7ea3d66cc38438749615bb84815b61a293"
 dependencies = [
  "ahash 0.8.12",
  "apache-avro",
- "arrow",
- "arrow-ipc",
+ "arrow 58.0.0",
+ "arrow-ipc 58.0.0",
  "chrono",
  "half",
  "hashbrown 0.16.1",
  "indexmap",
+ "itertools 0.14.0",
  "libc",
  "log",
- "object_store",
- "parquet",
+ "object_store 0.13.1",
+ "parquet 58.0.0",
  "paste",
  "recursive",
- "sqlparser",
+ "sqlparser 0.61.0",
  "tokio",
  "web-time",
 ]
@@ -2100,9 +2376,9 @@ dependencies = [
 
 [[package]]
 name = "datafusion-common-runtime"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70b5e34026af55a1bfccb1ef0a763cf1f64e77c696ffcf5a128a278c31236528"
+checksum = "5f590205c7e32fe1fea48dd53ffb406e56ae0e7a062213a3ac848db8771641bd"
 dependencies = [
  "futures",
  "log",
@@ -2115,7 +2391,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fde13794244bc7581cd82f6fff217068ed79cdc344cafe4ab2c3a1c3510b38d6"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "bytes",
  "chrono",
@@ -2132,7 +2408,7 @@ dependencies = [
  "glob",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "rand 0.9.2",
  "tokio",
  "url",
@@ -2140,32 +2416,32 @@ dependencies = [
 
 [[package]]
 name = "datafusion-datasource"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b2a6be734cc3785e18bbf2a7f2b22537f6b9fb960d79617775a51568c281842"
+checksum = "fde1e030a9dc87b743c806fbd631f5ecfa2ccaa4ffb61fa19144a07fea406b79"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-compression",
  "async-trait",
  "bytes",
  "bzip2",
  "chrono",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-adapter 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-adapter 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "flate2",
  "futures",
  "glob",
  "itertools 0.14.0",
  "liblzma",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "rand 0.9.2",
  "tokio",
  "tokio-util",
@@ -2179,8 +2455,8 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "804fa9b4ecf3157982021770617200ef7c1b2979d57bec9044748314775a9aea"
 dependencies = [
- "arrow",
- "arrow-ipc",
+ "arrow 57.3.0",
+ "arrow-ipc 57.3.0",
  "async-trait",
  "bytes",
  "datafusion-common 51.0.0",
@@ -2193,52 +2469,52 @@ dependencies = [
  "datafusion-session 51.0.0",
  "futures",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.12.5",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-datasource-arrow"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1739b9b07c9236389e09c74f770e88aff7055250774e9def7d3f4f56b3dcc7be"
+checksum = "331ebae7055dc108f9b54994b93dff91f3a17445539efe5b74e89264f7b36e15"
 dependencies = [
- "arrow",
- "arrow-ipc",
+ "arrow 58.0.0",
+ "arrow-ipc 58.0.0",
  "async-trait",
  "bytes",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.13.1",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-datasource-avro"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "828088c2fb681cc0e06fb42f541f76c82a0c10278f9fd6334e22c8d1e3574ee7"
+checksum = "49dda81c79b6ba57b1853a9158abc66eb85a3aa1cede0c517dabec6d8a4ed3aa"
 dependencies = [
  "apache-avro",
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "bytes",
- "datafusion-common 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
  "num-traits",
- "object_store",
+ "object_store 0.13.1",
 ]
 
 [[package]]
@@ -2247,7 +2523,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61a1641a40b259bab38131c5e6f48fac0717bedb7dc93690e604142a849e0568"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "bytes",
  "datafusion-common 51.0.0",
@@ -2259,30 +2535,30 @@ dependencies = [
  "datafusion-physical-plan 51.0.0",
  "datafusion-session 51.0.0",
  "futures",
- "object_store",
+ "object_store 0.12.5",
  "regex",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-datasource-csv"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c73bc54b518bbba7c7650299d07d58730293cfba4356f6f428cc94c20b7600"
+checksum = "9e0d475088325e2986876aa27bb30d0574f72a22955a527d202f454681d55c5c"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "bytes",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
- "object_store",
+ "object_store 0.13.1",
  "regex",
  "tokio",
 ]
@@ -2293,7 +2569,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adeacdb00c1d37271176f8fb6a1d8ce096baba16ea7a4b2671840c5c9c64fe85"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "bytes",
  "datafusion-common 51.0.0",
@@ -2305,59 +2581,61 @@ dependencies = [
  "datafusion-physical-plan 51.0.0",
  "datafusion-session 51.0.0",
  "futures",
- "object_store",
+ "object_store 0.12.5",
  "tokio",
 ]
 
 [[package]]
 name = "datafusion-datasource-json"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37812c8494c698c4d889374ecfabbff780f1f26d9ec095dd1bddfc2a8ca12559"
+checksum = "ea1520d81f31770f3ad6ee98b391e75e87a68a5bb90de70064ace5e0a7182fe8"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "bytes",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
- "object_store",
+ "object_store 0.13.1",
+ "serde_json",
  "tokio",
+ "tokio-stream",
 ]
 
 [[package]]
 name = "datafusion-datasource-parquet"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2210937ecd9f0e824c397e73f4b5385c97cd1aff43ab2b5836fcfd2d321523fb"
+checksum = "95be805d0742ab129720f4c51ad9242cd872599cdb076098b03f061fcdc7f946"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "bytes",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-adapter 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-pruning 52.1.0",
- "datafusion-session 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-adapter 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-pruning 53.0.0",
+ "datafusion-session 53.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "parking_lot",
- "parquet",
+ "parquet 58.0.0",
  "tokio",
 ]
 
@@ -2369,9 +2647,9 @@ checksum = "2b99e13947667b36ad713549237362afb054b2d8f8cc447751e23ec61202db07"
 
 [[package]]
 name = "datafusion-doc"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c825f969126bc2ef6a6a02d94b3c07abff871acf4d6dd759ce1255edb7923ce"
+checksum = "5c93ad9e37730d2c7196e68616f3f2dd3b04c892e03acd3a8eeca6e177f3c06a"
 
 [[package]]
 name = "datafusion-execution"
@@ -2379,14 +2657,14 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63695643190679037bc946ad46a263b62016931547bf119859c511f7ff2f5178"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "dashmap",
  "datafusion-common 51.0.0",
  "datafusion-expr 51.0.0",
  "futures",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "parking_lot",
  "rand 0.9.2",
  "tempfile",
@@ -2395,19 +2673,21 @@ dependencies = [
 
 [[package]]
 name = "datafusion-execution"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa03ef05a2c2f90dd6c743e3e111078e322f4b395d20d4b4d431a245d79521ae"
+checksum = "9437d3cd5d363f9319f8122182d4d233427de79c7eb748f23054c9aaa0fdd8df"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
+ "arrow-buffer 58.0.0",
  "async-trait",
  "chrono",
  "dashmap",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "futures",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "parking_lot",
  "rand 0.9.2",
  "tempfile",
@@ -2420,7 +2700,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9a4787cbf5feb1ab351f789063398f67654a6df75c4d37d7f637dc96f951a91"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "chrono",
  "datafusion-common 51.0.0",
@@ -2433,30 +2713,30 @@ dependencies = [
  "itertools 0.14.0",
  "paste",
  "serde_json",
- "sqlparser",
+ "sqlparser 0.59.0",
 ]
 
 [[package]]
 name = "datafusion-expr"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef33934c1f98ee695cc51192cc5f9ed3a8febee84fdbcd9131bf9d3a9a78276f"
+checksum = "67164333342b86521d6d93fa54081ee39839894fb10f7a700c099af96d7552cf"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "chrono",
- "datafusion-common 52.1.0",
- "datafusion-doc 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-functions-window-common 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-doc 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-functions-window-common 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "indexmap",
  "itertools 0.14.0",
  "paste",
  "recursive",
  "serde_json",
- "sqlparser",
+ "sqlparser 0.61.0",
 ]
 
 [[package]]
@@ -2465,7 +2745,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ce2fb1b8c15c9ac45b0863c30b268c69dc9ee7a1ee13ecf5d067738338173dc"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "indexmap",
  "itertools 0.14.0",
@@ -2474,12 +2754,12 @@ dependencies = [
 
 [[package]]
 name = "datafusion-expr-common"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "000c98206e3dd47d2939a94b6c67af4bfa6732dd668ac4fafdbde408fd9134ea"
+checksum = "ab05fdd00e05d5a6ee362882546d29d6d3df43a6c55355164a7fbee12d163bc9"
 dependencies = [
- "arrow",
- "datafusion-common 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
  "indexmap",
  "itertools 0.14.0",
  "paste",
@@ -2491,8 +2771,8 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "794a9db7f7b96b3346fc007ff25e994f09b8f0511b4cf7dff651fadfe3ebb28f"
 dependencies = [
- "arrow",
- "arrow-buffer",
+ "arrow 57.3.0",
+ "arrow-buffer 57.3.0",
  "base64",
  "blake2",
  "blake3",
@@ -2517,27 +2797,28 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379b01418ab95ca947014066248c22139fe9af9289354de10b445bd000d5d276"
+checksum = "04fb863482d987cf938db2079e07ab0d3bb64595f28907a6c2f8671ad71cca7e"
 dependencies = [
- "arrow",
- "arrow-buffer",
+ "arrow 58.0.0",
+ "arrow-buffer 58.0.0",
  "base64",
  "blake2",
  "blake3",
  "chrono",
  "chrono-tz",
- "datafusion-common 52.1.0",
- "datafusion-doc 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-macros 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-doc 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-macros 53.0.0",
  "hex",
  "itertools 0.14.0",
  "log",
  "md-5",
+ "memchr",
  "num-traits",
  "rand 0.9.2",
  "regex",
@@ -2553,7 +2834,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c25210520a9dcf9c2b2cbbce31ebd4131ef5af7fc60ee92b266dc7d159cb305"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-doc 51.0.0",
  "datafusion-execution 51.0.0",
@@ -2569,22 +2850,23 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-aggregate"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd00d5454ba4c3f8ebbd04bd6a6a9dc7ced7c56d883f70f2076c188be8459e4c"
+checksum = "829856f4e14275fb376c104f27cbf3c3b57a9cfe24885d98677525f5e43ce8d6"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-doc 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-macros 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-doc 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-macros 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "half",
  "log",
+ "num-traits",
  "paste",
 ]
 
@@ -2595,7 +2877,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62f4a66f3b87300bb70f4124b55434d2ae3fe80455f3574701d0348da040b55d"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-expr-common 51.0.0",
  "datafusion-physical-expr-common 51.0.0",
@@ -2603,15 +2885,15 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-aggregate-common"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aec06b380729a87210a4e11f555ec2d729a328142253f8d557b87593622ecc9f"
+checksum = "08af79cc3d2aa874a362fb97decfcbd73d687190cb096f16a6c85a7780cce311"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
 ]
 
 [[package]]
@@ -2620,8 +2902,8 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae5c06eed03918dc7fe7a9f082a284050f0e9ecf95d72f57712d1496da03b8c4"
 dependencies = [
- "arrow",
- "arrow-ord",
+ "arrow 57.3.0",
+ "arrow-ord 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-doc 51.0.0",
  "datafusion-execution 51.0.0",
@@ -2639,23 +2921,25 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-nested"
-version = "52.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904f48d45e0f1eb7d0eb5c0f80f2b5c6046a85454364a6b16a2e0b46f62e7dff"
-dependencies = [
- "arrow",
- "arrow-ord",
- "datafusion-common 52.1.0",
- "datafusion-doc 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-functions-aggregate 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-macros 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+version = "53.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465ae3368146d49c2eda3e2c0ef114424c87e8a6b509ab34c1026ace6497e790"
+dependencies = [
+ "arrow 58.0.0",
+ "arrow-ord 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-doc 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-functions-aggregate 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-macros 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "hashbrown 0.16.1",
  "itertools 0.14.0",
+ "itoa",
  "log",
  "paste",
 ]
@@ -2666,7 +2950,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db4fed1d71738fbe22e2712d71396db04c25de4111f1ec252b8f4c6d3b25d7f5"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "datafusion-catalog 51.0.0",
  "datafusion-common 51.0.0",
@@ -2678,16 +2962,16 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-table"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9a0d20e2b887e11bee24f7734d780a2588b925796ac741c3118dd06d5aa77f0"
+checksum = "6156e6b22fcf1784112fc0173f3ae6e78c8fdb4d3ed0eace9543873b437e2af6"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
- "datafusion-catalog 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-plan 52.1.0",
+ "datafusion-catalog 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-plan 53.0.0",
  "parking_lot",
  "paste",
 ]
@@ -2698,7 +2982,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d92206aa5ae21892f1552b4d61758a862a70956e6fd7a95cb85db1de74bc6d1"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-doc 51.0.0",
  "datafusion-expr 51.0.0",
@@ -2712,18 +2996,18 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-window"
-version = "52.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3414b0a07e39b6979fe3a69c7aa79a9f1369f1d5c8e52146e66058be1b285ee"
-dependencies = [
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-doc 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions-window-common 52.1.0",
- "datafusion-macros 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+version = "53.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca7baec14f866729012efb89011a6973f3a346dc8090c567bfcd328deff551c1"
+dependencies = [
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-doc 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions-window-common 53.0.0",
+ "datafusion-macros 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "log",
  "paste",
 ]
@@ -2740,12 +3024,12 @@ dependencies = [
 
 [[package]]
 name = "datafusion-functions-window-common"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf2feae63cd4754e31add64ce75cae07d015bce4bb41cd09872f93add32523a"
+checksum = "159228c3280d342658466bb556dc24de30047fe1d7e559dc5d16ccc5324166f9"
 dependencies = [
- "datafusion-common 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
 ]
 
 [[package]]
@@ -2761,11 +3045,11 @@ dependencies = [
 
 [[package]]
 name = "datafusion-macros"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4fe888aeb6a095c4bcbe8ac1874c4b9a4c7ffa2ba849db7922683ba20875aaf"
+checksum = "e5427e5da5edca4d21ea1c7f50e1c9421775fe33d7d5726e5641a833566e7578"
 dependencies = [
- "datafusion-doc 52.1.0",
+ "datafusion-doc 53.0.0",
  "quote",
  "syn 2.0.117",
 ]
@@ -2776,7 +3060,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f35f9ec5d08b87fd1893a30c2929f2559c2f9806ca072d8fefca5009dc0f06a"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "chrono",
  "datafusion-common 51.0.0",
  "datafusion-expr 51.0.0",
@@ -2791,16 +3075,16 @@ dependencies = [
 
 [[package]]
 name = "datafusion-optimizer"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a6527c063ae305c11be397a86d8193936f4b84d137fe40bd706dfc178cf733c"
+checksum = "89099eefcd5b223ec685c36a41d35c69239236310d71d339f2af0fa4383f3f46"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "chrono",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-physical-expr 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-physical-expr 53.0.0",
  "indexmap",
  "itertools 0.14.0",
  "log",
@@ -2816,7 +3100,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c30cc8012e9eedcb48bbe112c6eff4ae5ed19cf3003cb0f505662e88b7014c5d"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-expr 51.0.0",
  "datafusion-expr-common 51.0.0",
@@ -2833,17 +3117,17 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-expr"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb028323dd4efd049dd8a78d78fe81b2b969447b39c51424167f973ac5811d9"
+checksum = "0f222df5195d605d79098ef37bdd5323bff0131c9d877a24da6ec98dfca9fe36"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "half",
  "hashbrown 0.16.1",
  "indexmap",
@@ -2861,7 +3145,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f9ff2dbd476221b1f67337699eff432781c4e6e1713d2aefdaa517dfbf79768"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-expr 51.0.0",
  "datafusion-functions 51.0.0",
@@ -2872,16 +3156,16 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-expr-adapter"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78fe0826aef7eab6b4b61533d811234a7a9e5e458331ebbf94152a51fc8ab433"
+checksum = "40838625d63d9c12549d81979db3dd675d159055eb9135009ba272ab0e8d0f64"
 dependencies = [
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "itertools 0.14.0",
 ]
 
@@ -2892,7 +3176,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90da43e1ec550b172f34c87ec68161986ced70fd05c8d2a2add66eef9c276f03"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-expr-common 51.0.0",
  "hashbrown 0.14.5",
@@ -2901,15 +3185,15 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-expr-common"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfccd388620734c661bd8b7ca93c44cdd59fecc9b550eea416a78ffcbb29475f"
+checksum = "eacbcc4cfd502558184ed58fa3c72e775ec65bf077eef5fd2b3453db676f893c"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
+ "arrow 58.0.0",
  "chrono",
- "datafusion-common 52.1.0",
- "datafusion-expr-common 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr-common 53.0.0",
  "hashbrown 0.16.1",
  "indexmap",
  "itertools 0.14.0",
@@ -2922,7 +3206,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce9804f799acd7daef3be7aaffe77c0033768ed8fdbf5fb82fc4c5f2e6bc14e6"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-execution 51.0.0",
  "datafusion-expr 51.0.0",
@@ -2936,19 +3220,19 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-optimizer"
-version = "52.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bde5fa10e73259a03b705d5fddc136516814ab5f441b939525618a4070f5a059"
-dependencies = [
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-pruning 52.1.0",
+version = "53.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d501d0e1d0910f015677121601ac177ec59272ef5c9324d1147b394988f40941"
+dependencies = [
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-pruning 53.0.0",
  "itertools 0.14.0",
  "recursive",
 ]
@@ -2960,9 +3244,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0acf0ad6b6924c6b1aa7d213b181e012e2d3ec0a64ff5b10ee6282ab0f8532ac"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "arrow-ord",
- "arrow-schema",
+ "arrow 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-schema 57.3.0",
  "async-trait",
  "chrono",
  "datafusion-common 51.0.0",
@@ -2986,30 +3270,31 @@ dependencies = [
 
 [[package]]
 name = "datafusion-physical-plan"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1098760fb29127c24cc9ade3277051dc73c9ed0ac0131bd7bcd742e0ad7470"
+checksum = "463c88ad6f1ecab1810f4c9f046898bee035b370137eb79b2b2db925e270631d"
 dependencies = [
  "ahash 0.8.12",
- "arrow",
- "arrow-ord",
- "arrow-schema",
+ "arrow 58.0.0",
+ "arrow-ord 58.0.0",
+ "arrow-schema 58.0.0",
  "async-trait",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-functions-aggregate-common 52.1.0",
- "datafusion-functions-window-common 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-functions-aggregate-common 53.0.0",
+ "datafusion-functions-window-common 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
  "futures",
  "half",
  "hashbrown 0.16.1",
  "indexmap",
  "itertools 0.14.0",
  "log",
+ "num-traits",
  "parking_lot",
  "pin-project-lite",
  "tokio",
@@ -3021,7 +3306,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac2c2498a1f134a9e11a9f5ed202a2a7d7e9774bd9249295593053ea3be999db"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "datafusion-common 51.0.0",
  "datafusion-datasource 51.0.0",
  "datafusion-expr-common 51.0.0",
@@ -3034,17 +3319,17 @@ dependencies = [
 
 [[package]]
 name = "datafusion-pruning"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64d0fef4201777b52951edec086c21a5b246f3c82621569ddb4a26f488bc38a9"
+checksum = "2857618a0ecbd8cd0cf29826889edd3a25774ec26b2995fc3862095c95d88fc6"
 dependencies = [
- "arrow",
- "datafusion-common 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-expr-common 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
+ "arrow 58.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-expr-common 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
  "itertools 0.14.0",
  "log",
 ]
@@ -3065,38 +3350,42 @@ dependencies = [
 
 [[package]]
 name = "datafusion-session"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f71f1e39e8f2acbf1c63b0e93756c2e970a64729dab70ac789587d6237c4fde0"
+checksum = "ef8637e35022c5c775003b3ab1debc6b4a8f0eb41b069bdd5475dd3aa93f6eba"
 dependencies = [
  "async-trait",
- "datafusion-common 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-physical-plan 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-physical-plan 53.0.0",
  "parking_lot",
 ]
 
 [[package]]
 name = "datafusion-spark"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556c431f5f2259620c8223254c0ef57aa9a85c576d4da0166157260f71eb0e25"
+checksum = "923a8b871962a9d860f036f743a20af50ff04729f1da2468ed220dab4f61c97d"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "bigdecimal",
  "chrono",
  "crc32fast",
- "datafusion-catalog 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-functions-nested 52.1.0",
+ "datafusion 53.0.0",
+ "datafusion-catalog 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-functions-aggregate 53.0.0",
+ "datafusion-functions-nested 53.0.0",
  "log",
  "percent-encoding",
  "rand 0.9.2",
+ "serde_json",
  "sha1",
+ "sha2",
  "url",
 ]
 
@@ -3106,7 +3395,7 @@ version = "51.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3fc195fe60634b2c6ccfd131b487de46dc30eccae8a3c35a13f136e7f440414f"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "bigdecimal",
  "chrono",
  "datafusion-common 51.0.0",
@@ -3114,38 +3403,39 @@ dependencies = [
  "indexmap",
  "log",
  "regex",
- "sqlparser",
+ "sqlparser 0.59.0",
 ]
 
 [[package]]
 name = "datafusion-sql"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f44693cfcaeb7a9f12d71d1c576c3a6dc025a12cef209375fa2d16fb3b5670ee"
+checksum = "12d9e9f16a1692a11c94bcc418191fa15fd2b4d72a0c1a0c607db93c0b84dd81"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "bigdecimal",
  "chrono",
- "datafusion-common 52.1.0",
- "datafusion-expr 52.1.0",
+ "datafusion-common 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions-nested 53.0.0",
  "indexmap",
  "log",
  "recursive",
  "regex",
- "sqlparser",
+ "sqlparser 0.61.0",
 ]
 
 [[package]]
 name = "datafusion-sqllogictest"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d388fec80647198ae041d314dd7d9e2305207836ecec3ad48908eac6844cdef"
+checksum = "a43746bd59e7f2655be4c5553ede4a1ceb1cd34005932fa9e2bd0641c714c46e"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "async-trait",
  "bigdecimal",
  "clap",
- "datafusion 52.1.0",
+ "datafusion 53.0.0",
  "datafusion-spark",
  "datafusion-substrait",
  "futures",
@@ -3153,9 +3443,9 @@ dependencies = [
  "indicatif",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "object_store 0.13.1",
  "sqllogictest",
- "sqlparser",
+ "sqlparser 0.61.0",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
@@ -3163,23 +3453,22 @@ dependencies = [
 
 [[package]]
 name = "datafusion-substrait"
-version = "52.1.0"
+version = "53.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6042adacd0bd64e56c22f6a7f9ce0ce1793dd367c899d868179d029f110d9215"
+checksum = "d5e5656a7e63d51dd3e5af3dbd347ea83bbe993a77c66b854b74961570d16490"
 dependencies = [
  "async-recursion",
  "async-trait",
  "chrono",
- "datafusion 52.1.0",
+ "datafusion 53.0.0",
  "half",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.13.1",
  "pbjson-types",
  "prost 0.14.3",
  "substrait",
  "tokio",
  "url",
- "uuid",
 ]
 
 [[package]]
@@ -3208,12 +3497,6 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "807800ff3288b621186fe0a8f3392c4652068257302709c24efd918c3dffcdc2"
 
-[[package]]
-name = "deltae"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5729f5117e208430e437df2f4843f5e5952997175992d1414f94c57d61e270b4"
-
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -3224,17 +3507,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"
@@ -3347,6 +3619,12 @@ dependencies = [
  "vortex-duckdb",
 ]
 
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
 [[package]]
 name = "dyn-clone"
 version = "1.0.20"
@@ -3446,19 +3724,13 @@ dependencies = [
  "regex",
 ]
 
-[[package]]
-name = "env_home"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
-
 [[package]]
 name = "env_logger"
 version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2daee4ea451f429a58296525ddf28b45a3b64f1acf6587e2067437bb11e218d"
 dependencies = [
- "anstream",
+ "anstream 0.6.21",
  "anstyle",
  "env_filter",
  "jiff",
@@ -3493,15 +3765,6 @@ version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b"
 
-[[package]]
-name = "euclid"
-version = "0.22.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df61bf483e837f88d5c2291dcf55c67be7e676b3a51acc48db3a7b163b91ed63"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "event-listener"
 version = "5.4.1"
@@ -3552,16 +3815,6 @@ dependencies = [
  "ext-trait",
 ]
 
-[[package]]
-name = "fancy-regex"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2"
-dependencies = [
- "bit-set",
- "regex",
-]
-
 [[package]]
 name = "fast-float2"
 version = "0.2.3"
@@ -3593,17 +3846,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
-[[package]]
-name = "filedescriptor"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
-dependencies = [
- "libc",
- "thiserror 1.0.69",
- "winapi",
-]
-
 [[package]]
 name = "filetime"
 version = "0.2.27"
@@ -3621,12 +3863,6 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
-[[package]]
-name = "finl_unicode"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9844ddc3a6e533d62bba727eb6c28b5d360921d5175e9ff0f1e621a5c590a4d5"
-
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -3640,12 +3876,6 @@ dependencies = [
  "static_assertions",
 ]
 
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -3658,7 +3888,7 @@ version = "25.12.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "rustc_version",
 ]
 
@@ -3697,21 +3927,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -3740,21 +3955,30 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
 [[package]]
 name = "fsst"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f9e5c0b1c67a38cb92b41535d44623483beb9511592ae23a3bf42ddec758690"
 dependencies = [
- "arrow-array",
+ "arrow-array 57.3.0",
  "rand 0.9.2",
 ]
 
 [[package]]
 name = "fsst-rs"
-version = "0.5.6"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "561f2458a3407836ab8f1acc9113b8cda91b9d6378ba8dad13b2fe1a1d3af5ce"
+checksum = "cdf65e16e100438be0030d113042e07a62bed67203998640ca6fae0404eed71e"
+dependencies = [
+ "rustc-hash",
+]
 
 [[package]]
 name = "fst"
@@ -3898,8 +4122,8 @@ dependencies = [
  "libc",
  "log",
  "rustversion",
- "windows-link 0.2.1",
- "windows-result 0.4.1",
+ "windows-link",
+ "windows-result",
 ]
 
 [[package]]
@@ -3958,9 +4182,9 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc1cc4106ac0a0a512c398961ce95d8150475c84a84e17c4511c3643fa120a17"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-schema 57.3.0",
  "geo-traits",
  "geoarrow-schema",
  "num-traits",
@@ -3974,8 +4198,8 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa84300361ce57fb875bcaa6e32b95b0aff5c6b1af692b936bdd58ff343f4394"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
  "geo",
  "geo-traits",
  "geoarrow-array",
@@ -3988,7 +4212,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e97be4e9f523f92bd6a0e0458323f4b783d073d011664decd8dbf05651704f34"
 dependencies = [
- "arrow-schema",
+ "arrow-schema 57.3.0",
  "geo-traits",
  "serde",
  "serde_json",
@@ -4001,9 +4225,9 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773cfa1fb0d7f7661b76b3fde00f3ffd8e0ff7b3635096f0ff6294fe5ca62a2b"
 dependencies = [
- "arrow-arith",
- "arrow-array",
- "arrow-schema",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-schema 57.3.0",
  "datafusion 51.0.0",
  "geo",
  "geo-traits",
@@ -4062,22 +4286,25 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
- "r-efi",
+ "r-efi 6.0.0",
+ "rand_core 0.10.0",
  "wasip2",
  "wasip3",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -4103,6 +4330,7 @@ dependencies = [
 name = "gpu-scan-cli"
 version = "0.1.0"
 dependencies = [
+ "clap",
  "futures",
  "tokio",
  "tracing",
@@ -4351,22 +4579,6 @@ dependencies = [
  "webpki-roots",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
 [[package]]
 name = "hyper-util"
 version = "0.1.20"
@@ -4384,7 +4596,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.2",
+ "socket2",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -4456,7 +4668,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.62.2",
+ "windows-core",
 ]
 
 [[package]]
@@ -4620,7 +4832,7 @@ version = "0.18.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25470f23803092da7d239834776d653104d551bc4d7eacaf31e6837854b8e9eb"
 dependencies = [
- "console 0.16.2",
+ "console 0.16.3",
  "futures-core",
  "portable-atomic",
  "unicode-width 0.2.2",
@@ -4648,11 +4860,11 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.46.3"
+version = "1.47.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4"
+checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
 dependencies = [
- "console 0.15.11",
+ "console 0.16.3",
  "once_cell",
  "similar",
  "tempfile",
@@ -4660,9 +4872,9 @@ dependencies = [
 
 [[package]]
 name = "instability"
-version = "0.3.11"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357b7205c6cd18dd2c86ed312d1e70add149aea98e7ef72b9fdf0270e555c11d"
+checksum = "5eb2d60ef19920a3a9193c3e371f726ec1dafc045dac788d0fb3704272458971"
 dependencies = [
  "darling",
  "indoc",
@@ -4688,15 +4900,15 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.11.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
 [[package]]
 name = "iri-string"
-version = "0.7.10"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+checksum = "d8e7418f59cc01c88316161279a7f665217ae316b388e58a0d10e29f54f1e5eb"
 dependencies = [
  "memchr",
  "serde",
@@ -4766,9 +4978,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "java-locator"
@@ -4781,9 +4993,9 @@ dependencies = [
 
 [[package]]
 name = "jiff"
-version = "0.2.21"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3e3d65f018c6ae946ab16e80944b97096ed73c35b221d1c478a6c81d8f57940"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
 dependencies = [
  "jiff-static",
  "jiff-tzdb-platform",
@@ -4796,9 +5008,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.21"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17c2b211d863c7fde02cbea8a3c1a439b98e109286554f2860bdded7ff83818"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4807,9 +5019,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-tzdb"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68971ebff725b9e2ca27a601c5eb38a4c5d64422c4cbab0c535f248087eda5c2"
+checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
 
 [[package]]
 name = "jiff-tzdb-platform"
@@ -4830,7 +5042,7 @@ dependencies = [
  "cfg-if",
  "combine",
  "java-locator",
- "jni-sys",
+ "jni-sys 0.3.1",
  "libloading 0.7.4",
  "log",
  "thiserror 1.0.69",
@@ -4840,9 +5052,31 @@ dependencies = [
 
 [[package]]
 name = "jni-sys"
-version = "0.3.0"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
 
 [[package]]
 name = "jobserver"
@@ -4856,9 +5090,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.90"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dc6f6450b3f6d4ed5b16327f38fed626d375a886159ca555bd7822c0c3a5a6"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -4896,36 +5130,30 @@ dependencies = [
 
 [[package]]
 name = "kasuari"
-version = "0.4.11"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fe90c1150662e858c7d5f945089b7517b0a80d8bf7ba4b1b5ffc984e7230a5b"
+checksum = "bde5057d6143cc94e861d90f591b9303d6716c6b9602309150bd068853c10899"
 dependencies = [
  "hashbrown 0.16.1",
  "portable-atomic",
  "thiserror 2.0.18",
 ]
 
-[[package]]
-name = "lab"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f"
-
 [[package]]
 name = "lance"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b7f07b905df393a5554eba19055c620f9ea25a3e40a013bda4bd8dc4ca66f01"
 dependencies = [
- "arrow",
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-ipc",
- "arrow-ord",
- "arrow-row",
- "arrow-schema",
- "arrow-select",
+ "arrow 57.3.0",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-ipc 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-row 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "async-recursion",
  "async-trait",
  "async_cell",
@@ -4957,7 +5185,7 @@ dependencies = [
  "lance-table",
  "log",
  "moka",
- "object_store",
+ "object_store 0.12.5",
  "permutation",
  "pin-project",
  "prost 0.14.3",
@@ -4982,13 +5210,13 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "100e076cb81c8f0c24cd2881c706fc53e037c7d6e81eb320e929e265d157effb"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "bytes",
  "getrandom 0.2.17",
  "half",
@@ -5002,13 +5230,13 @@ name = "lance-bench"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-cast",
+ "arrow-cast 57.3.0",
  "async-trait",
  "clap",
  "futures",
  "lance",
  "lance-encoding",
- "parquet",
+ "parquet 57.3.0",
  "tempfile",
  "tokio",
  "tracing",
@@ -5032,9 +5260,9 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fa01d1cf490ccfd3b8eaeee2781415d0419e6be8366040e57e43677abf2644e"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-schema 57.3.0",
  "async-trait",
  "byteorder",
  "bytes",
@@ -5050,7 +5278,7 @@ dependencies = [
  "mock_instant",
  "moka",
  "num_cpus",
- "object_store",
+ "object_store 0.12.5",
  "pin-project",
  "prost 0.14.3",
  "rand 0.9.2",
@@ -5071,12 +5299,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef89a39e3284eef76f79e63f23de8881a0583ad6feb20ed39f47eadd847a2b88"
 dependencies = [
- "arrow",
- "arrow-array",
- "arrow-buffer",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
+ "arrow 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "async-trait",
  "chrono",
  "datafusion 51.0.0",
@@ -5103,10 +5331,10 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2a60eef5c47e65d91e2ffa8e7e1629c52e7190c8b88a371a1a60601dc49371"
 dependencies = [
- "arrow",
- "arrow-array",
- "arrow-cast",
- "arrow-schema",
+ "arrow 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-schema 57.3.0",
  "chrono",
  "futures",
  "half",
@@ -5123,13 +5351,13 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95ce4a6631308aa681b2671af8f2a845ff781f8d4e755a2a7ccd012379467094"
 dependencies = [
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "bytemuck",
  "byteorder",
  "bytes",
@@ -5162,12 +5390,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2d4d82357cbfaa1a18494226c15b1cb3c8ed0b6c84b91146323c82047ede419"
 dependencies = [
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "async-recursion",
  "async-trait",
  "byteorder",
@@ -5181,7 +5409,7 @@ dependencies = [
  "lance-io",
  "log",
  "num-traits",
- "object_store",
+ "object_store 0.12.5",
  "prost 0.14.3",
  "prost-build",
  "prost-types",
@@ -5212,12 +5440,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20e9c5aa7024a63af9ae89ee8c0f23c8421b7896742e5cd4a271a60f9956cb80"
 dependencies = [
- "arrow",
- "arrow-arith",
- "arrow-array",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
+ "arrow 57.3.0",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-ord 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "async-channel",
  "async-recursion",
  "async-trait",
@@ -5254,7 +5482,7 @@ dependencies = [
  "log",
  "ndarray",
  "num-traits",
- "object_store",
+ "object_store 0.12.5",
  "prost 0.14.3",
  "prost-build",
  "prost-types",
@@ -5281,14 +5509,14 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7d2af0b17fb374a8181bcf1a10bce5703ae3ee4373c1587ce4bba23e15e45c8"
 dependencies = [
- "arrow",
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
+ "arrow 57.3.0",
+ "arrow-arith 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
  "async-recursion",
  "async-trait",
  "byteorder",
@@ -5300,7 +5528,7 @@ dependencies = [
  "lance-core",
  "lance-namespace",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "path_abs",
  "pin-project",
  "prost 0.14.3",
@@ -5319,9 +5547,9 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5125aa62696e75a7475807564b4921f252d8815be606b84bc00e6def0f5c24bb"
 dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-schema 57.3.0",
  "cc",
  "deepsize",
  "half",
@@ -5337,7 +5565,7 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70545c2676ce954dfd801da5c6a631a70bba967826cd3a8f31b47d1f04bbfed3"
 dependencies = [
- "arrow",
+ "arrow 57.3.0",
  "async-trait",
  "bytes",
  "lance-core",
@@ -5351,7 +5579,7 @@ version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2acdba67f84190067532fce07b51a435dd390d7cdc1129a05003e5cb3274cf0"
 dependencies = [
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
  "serde_repr",
@@ -5364,11 +5592,11 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b06ad37bd90045de8ef533df170c6098e6ff6ecb427aade47d7db8e2c86f2678"
 dependencies = [
- "arrow",
- "arrow-array",
- "arrow-buffer",
- "arrow-ipc",
- "arrow-schema",
+ "arrow 57.3.0",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-ipc 57.3.0",
+ "arrow-schema 57.3.0",
  "async-trait",
  "byteorder",
  "bytes",
@@ -5380,7 +5608,7 @@ dependencies = [
  "lance-file",
  "lance-io",
  "log",
- "object_store",
+ "object_store 0.12.5",
  "prost 0.14.3",
  "prost-build",
  "prost-types",
@@ -5505,9 +5733,9 @@ checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
 name = "libc"
-version = "0.2.182"
+version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -5536,7 +5764,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
  "cfg-if",
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -5577,22 +5805,23 @@ dependencies = [
 
 [[package]]
 name = "libredox"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+checksum = "1744e39d1d6a9948f4f388969627434e31128196de472883b39f148769bfe30a"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "libc",
- "redox_syscall 0.7.2",
+ "plain",
+ "redox_syscall 0.7.3",
 ]
 
 [[package]]
 name = "libtest-mimic"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5297962ef19edda4ce33aaa484386e0a5b3d7f2f4e037cbeee00503ef6b29d33"
+checksum = "14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"
 dependencies = [
- "anstream",
+ "anstream 1.0.0",
  "anstyle",
  "clap",
  "escape8259",
@@ -5604,7 +5833,7 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f4de44e98ddbf09375cbf4d17714d18f39195f4f4894e8524501726fd9a8a4a"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
 ]
 
 [[package]]
@@ -5713,39 +5942,28 @@ dependencies = [
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.5"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"
+checksum = "373f5eceeeab7925e0c1098212f2fbc4d416adec9d35051a6ab251e824c1854a"
 
 [[package]]
 name = "lz4_flex"
-version = "0.12.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
+checksum = "98c23545df7ecf1b16c303910a69b079e8e251d60f7dd2cc9b4177f2afaf1746"
 dependencies = [
  "twox-hash",
 ]
 
 [[package]]
 name = "lzma-rust2"
-version = "0.13.0"
+version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c60a23ffb90d527e23192f1246b14746e2f7f071cb84476dd879071696c18a4a"
+checksum = "47bb1e988e6fb779cf720ad431242d3f03167c1b3f2b1aae7f1a94b2495b36ae"
 dependencies = [
- "crc",
  "sha2",
 ]
 
-[[package]]
-name = "mac_address"
-version = "1.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303"
-dependencies = [
- "nix 0.29.0",
- "winapi",
-]
-
 [[package]]
 name = "macro_rules_attribute"
 version = "0.1.3"
@@ -5818,21 +6036,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "memmem"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64a92489e2744ce060c349162be1c5f33c6969234104dbd99ddb5feb08b8c15"
-
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mimalloc"
 version = "0.1.48"
@@ -5894,9 +6097,9 @@ checksum = "dce6dd36094cac388f119d2e9dc82dc730ef91c32a6222170d630e5414b956e6"
 
 [[package]]
 name = "moka"
-version = "0.12.13"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac832c50ced444ef6be0767a008b02c106a909ba79d1d830501e94b96f6b7e"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
 dependencies = [
  "async-lock",
  "crossbeam-channel",
@@ -5946,23 +6149,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2195bf6aa996a481483b29d62a7663eed3fe39600c460e323f8ff41e90bdd89b"
 
-[[package]]
-name = "native-tls"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
-dependencies = [
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
 [[package]]
 name = "ndarray"
 version = "0.16.1"
@@ -5986,24 +6172,11 @@ checksum = "cf5a574dadd7941adeaa71823ecba5e28331b8313fb2e1c6a5c7e5981ea53ad6"
 
 [[package]]
 name = "nix"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
-dependencies = [
- "bitflags 2.11.0",
- "cfg-if",
- "cfg_aliases",
- "libc",
- "memoffset",
-]
-
-[[package]]
-name = "nix"
-version = "0.30.1"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -6030,9 +6203,9 @@ dependencies = [
 
 [[package]]
 name = "noodles-bgzf"
-version = "0.44.0"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab0c2585bad37cfc51a55f29c85449400ac51aaade935049d5d9fc5f8add255"
+checksum = "37290f565045fd2775b549e62dffca7e1afadc70d8d5a3a2ef19609eb3d8193b"
 dependencies = [
  "bytes",
  "crossbeam-channel",
@@ -6045,31 +6218,34 @@ dependencies = [
 
 [[package]]
 name = "noodles-core"
-version = "0.18.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ebfc6396fb51059c98a35bb81b96422ac41ea1bc60b6c8e9c6b2550212e9493"
+checksum = "53e1e8a419dbba0e4000b0e60830b124138c7f2277ad556463506f1a81d32d17"
 dependencies = [
  "bstr",
 ]
 
 [[package]]
 name = "noodles-csi"
-version = "0.52.0"
+version = "0.55.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d09e31153abd7996f22a50d70f43af6c2ebf96a44ee250326ed15d4e183744c9"
+checksum = "c9c846d8128bd80b18d891b13cb9e0bc1d364429d6ab3ec3c83939f3d32ba105"
 dependencies = [
- "bit-vec 0.8.0",
+ "bit-vec",
  "bstr",
+ "futures",
  "indexmap",
  "noodles-bgzf",
  "noodles-core",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
 name = "noodles-tabix"
-version = "0.58.0"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dd8ed06bbf341ce64649717ce0fa1723bf60547eb7d61bd271b79130016dfa4"
+checksum = "2443d0852c9618cd4aa8d11bc7c1884285e46aa4466cf5c1e49f3d9756ca7ced"
 dependencies = [
  "bstr",
  "indexmap",
@@ -6081,9 +6257,9 @@ dependencies = [
 
 [[package]]
 name = "noodles-vcf"
-version = "0.82.0"
+version = "0.86.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d46b26eb1873883e5e6b738c75d4e44c9e1edcc1c6454fc5c25b56202e510bc"
+checksum = "0131147080a5aeadcd6c2ab43e7ca1f9e8018cdd482eed797d081c40e8f0a3c7"
 dependencies = [
  "futures",
  "indexmap",
@@ -6162,17 +6338,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
 
-[[package]]
-name = "num-derive"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "num-integer"
 version = "0.1.46"
@@ -6204,9 +6369,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -6214,9 +6379,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -6239,7 +6404,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
 ]
 
 [[package]]
@@ -6266,6 +6431,30 @@ name = "object_store"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbfbfff40aeccab00ec8a910b57ca8ecf4319b335c542f2edcd19dd25a1e2a00"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "chrono",
+ "futures",
+ "http",
+ "humantime",
+ "itertools 0.14.0",
+ "parking_lot",
+ "percent-encoding",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "url",
+ "walkdir",
+ "wasm-bindgen-futures",
+ "web-time",
+]
+
+[[package]]
+name = "object_store"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2858065e55c148d294a9f3aae3b0fa9458edadb41a108397094566f4e3c0dfb"
 dependencies = [
  "async-trait",
  "base64",
@@ -6284,9 +6473,9 @@ dependencies = [
  "percent-encoding",
  "quick-xml",
  "rand 0.9.2",
- "reqwest",
+ "reqwest 0.12.28",
  "ring",
- "rustls-pemfile",
+ "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
@@ -6301,9 +6490,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 dependencies = [
  "parking_lot_core",
 ]
@@ -6321,36 +6510,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "269bca4c2591a28585d6bf10d9ed0332b7d76900a1b02bec41bdc3a2cdcda107"
 
 [[package]]
-name = "oorandom"
-version = "11.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
-
-[[package]]
-name = "openssl"
-version = "0.10.75"
+name = "oneshot"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
-dependencies = [
- "bitflags 2.11.0",
- "cfg-if",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
+checksum = "cfe21416a02c693fb9f980befcb230ecc70b0b3d1cc4abf88b9675c4c1457f0c"
 
 [[package]]
-name = "openssl-macros"
-version = "0.1.1"
+name = "oorandom"
+version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "openssl-probe"
@@ -6358,18 +6527,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
-[[package]]
-name = "openssl-sys"
-version = "0.9.111"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "opentelemetry"
 version = "0.31.0"
@@ -6394,14 +6551,14 @@ dependencies = [
  "bytes",
  "http",
  "opentelemetry",
- "reqwest",
+ "reqwest 0.12.28",
 ]
 
 [[package]]
 name = "opentelemetry-otlp"
-version = "0.31.0"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2366db2dca4d2ad033cad11e6ee42844fd727007af5ad04a1730f4cb8163bf"
+checksum = "1f69cd6acbb9af919df949cd1ec9e5e7fdc2ef15d234b6b795aaa525cc02f71f"
 dependencies = [
  "http",
  "opentelemetry",
@@ -6409,7 +6566,7 @@ dependencies = [
  "opentelemetry-proto",
  "opentelemetry_sdk",
  "prost 0.14.3",
- "reqwest",
+ "reqwest 0.12.28",
  "thiserror 2.0.18",
  "tracing",
 ]
@@ -6457,15 +6614,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "ordered-float"
-version = "4.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "ordered-float"
 version = "5.1.0"
@@ -6555,7 +6703,7 @@ dependencies = [
  "libc",
  "redox_syscall 0.5.18",
  "smallvec",
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -6565,13 +6713,46 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ee96b29972a257b855ff2341b37e61af5f12d6af1158b6dcdb5b31ea07bb3cb"
 dependencies = [
  "ahash 0.8.12",
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-ipc",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 57.3.0",
+ "arrow-buffer 57.3.0",
+ "arrow-cast 57.3.0",
+ "arrow-data 57.3.0",
+ "arrow-ipc 57.3.0",
+ "arrow-schema 57.3.0",
+ "arrow-select 57.3.0",
+ "base64",
+ "brotli",
+ "bytes",
+ "chrono",
+ "flate2",
+ "half",
+ "hashbrown 0.16.1",
+ "lz4_flex 0.12.1",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "paste",
+ "seq-macro",
+ "simdutf8",
+ "snap",
+ "thrift",
+ "twox-hash",
+ "zstd",
+]
+
+[[package]]
+name = "parquet"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f491d0ef1b510194426ee67ddc18a9b747ef3c42050c19322a2cd2e1666c29b"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-ipc 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
  "base64",
  "brotli",
  "bytes",
@@ -6580,11 +6761,11 @@ dependencies = [
  "futures",
  "half",
  "hashbrown 0.16.1",
- "lz4_flex 0.12.0",
+ "lz4_flex 0.12.1",
  "num-bigint",
  "num-integer",
  "num-traits",
- "object_store",
+ "object_store 0.13.1",
  "paste",
  "seq-macro",
  "simdutf8",
@@ -6595,6 +6776,51 @@ dependencies = [
  "zstd",
 ]
 
+[[package]]
+name = "parquet-variant"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00ba4e5dcbc8ad65882b7337a95c12a0f9cbb6add237c53d93b803b7d7f70f02"
+dependencies = [
+ "arrow-schema 58.0.0",
+ "chrono",
+ "half",
+ "indexmap",
+ "simdutf8",
+ "uuid",
+]
+
+[[package]]
+name = "parquet-variant-compute"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ec4cfb8da15565c8d211b6bc51e8eb481ea65d19132462af3f948b150ac8efe"
+dependencies = [
+ "arrow 58.0.0",
+ "arrow-schema 58.0.0",
+ "chrono",
+ "half",
+ "indexmap",
+ "parquet-variant",
+ "parquet-variant-json",
+ "serde_json",
+ "uuid",
+]
+
+[[package]]
+name = "parquet-variant-json"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3668ff00a6aeb29d172ba15f9d8fedf1675d79bff7d1916daa333efdeaa13e46"
+dependencies = [
+ "arrow-schema 58.0.0",
+ "base64",
+ "chrono",
+ "parquet-variant",
+ "serde_json",
+ "uuid",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -6684,120 +6910,25 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df202b0b0f5b8e389955afd5f27b007b00fb948162953f1db9c70d2c7e3157d7"
 
-[[package]]
-name = "pest"
-version = "2.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662"
-dependencies = [
- "memchr",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220"
-dependencies = [
- "pest",
- "sha2",
-]
-
 [[package]]
 name = "petgraph"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
- "fixedbitset 0.5.7",
+ "fixedbitset",
  "hashbrown 0.15.5",
  "indexmap",
  "serde",
 ]
 
-[[package]]
-name = "phf"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
-dependencies = [
- "phf_macros",
- "phf_shared 0.11.3",
-]
-
 [[package]]
 name = "phf"
 version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
 dependencies = [
- "phf_shared 0.12.1",
-]
-
-[[package]]
-name = "phf_codegen"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
-dependencies = [
- "phf_generator",
- "phf_shared 0.11.3",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
-dependencies = [
- "phf_shared 0.11.3",
- "rand 0.8.5",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
-dependencies = [
- "phf_generator",
- "phf_shared 0.11.3",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
-dependencies = [
- "siphasher",
+ "phf_shared",
 ]
 
 [[package]]
@@ -6811,18 +6942,18 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.1.10"
+version = "1.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.10"
+version = "1.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6831,9 +6962,9 @@ dependencies = [
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "pin-utils"
@@ -6843,20 +6974,20 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "ping"
-version = "0.5.2"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "122ee1f5a6843bec84fcbd5c6ba3622115337a6b8965b93a61aad347648f4e8d"
+checksum = "044b1fa4f259f4df9ad5078e587b208f5d288a25407575fcddb9face30c7c692"
 dependencies = [
- "rand 0.8.5",
- "socket2 0.4.10",
- "thiserror 1.0.69",
+ "rand 0.9.2",
+ "socket2",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "piper"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
 dependencies = [
  "atomic-waker",
  "fastrand",
@@ -6869,6 +7000,12 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
 [[package]]
 name = "plotters"
 version = "0.3.7"
@@ -6925,9 +7062,9 @@ checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a9db96d7fa8782dd8c15ce32ffe8680bbd1e978a43bf51a34d39483540495f5"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
 dependencies = [
  "portable-atomic",
 ]
@@ -6985,9 +7122,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 dependencies = [
  "toml_edit",
 ]
@@ -7129,9 +7266,9 @@ dependencies = [
 
 [[package]]
 name = "public-api"
-version = "0.50.3"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40883c1581e900daa2cc4bc1ac50858f83a8563dd2e3c55b70bba44f57db7b35"
+checksum = "b4597eaaa646a5df48e5f37924b58bd4b2e2a3746d4665195d03538846784858"
 dependencies = [
  "hashbag",
  "rustdoc-types",
@@ -7143,30 +7280,28 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.27.2"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
 dependencies = [
  "chrono",
  "indexmap",
- "indoc",
  "libc",
- "memoffset",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-async-runtimes"
-version = "0.27.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57ddb5b570751e93cc6777e81fee8087e59cd53b5043292f2a6d59d5bd80fdfd"
+checksum = "9e7364a95bf00e8377bbf9b0f09d7ff9715a29d8fcf93b47d1a967363b973178"
 dependencies = [
- "futures",
+ "futures-channel",
+ "futures-util",
  "once_cell",
  "pin-project-lite",
  "pyo3",
@@ -7175,18 +7310,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.27.2"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-bytes"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37248130b5b50c06a3bd2ed0a4e763aff9bf3104991c656bc27c303df0889460"
+checksum = "1d98190ac733bf1c9a3bdbd2856d85abee243f16b7ef1155feefcd613c8704a1"
 dependencies = [
  "bytes",
  "pyo3",
@@ -7194,9 +7329,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.27.2"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -7215,9 +7350,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.27.2"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -7227,9 +7362,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.27.2"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -7240,9 +7375,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-object_store"
-version = "0.7.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef5552f108a4d65b78c924b27513471a9ba425341ada4be5ea0ca53806ae316"
+checksum = "b3056dc8a77db5d44d32e7f740db0b01e5b65a43d181487a6917576959c6eb9a"
 dependencies = [
  "async-trait",
  "bytes",
@@ -7251,7 +7386,7 @@ dependencies = [
  "http",
  "humantime",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.13.1",
  "percent-encoding",
  "pyo3",
  "pyo3-async-runtimes",
@@ -7290,7 +7425,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.6.2",
+ "socket2",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -7299,10 +7434,11 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
+ "aws-lc-rs",
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
@@ -7327,16 +7463,16 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.2",
+ "socket2",
  "tracing",
  "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -7347,6 +7483,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -7366,12 +7508,23 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
 dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.5",
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.0",
 ]
 
 [[package]]
@@ -7412,6 +7565,12 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
+
 [[package]]
 name = "rand_distr"
 version = "0.4.3"
@@ -7432,6 +7591,16 @@ dependencies = [
  "rand 0.9.2",
 ]
 
+[[package]]
+name = "rand_distr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d431c2703ccf129de4d45253c03f49ebb22b97d6ad79ee3ecfc7e3f4862c1d8"
+dependencies = [
+ "num-traits",
+ "rand 0.10.0",
+]
+
 [[package]]
 name = "rand_xoshiro"
 version = "0.6.0"
@@ -7458,8 +7627,8 @@ dependencies = [
  "clap",
  "indicatif",
  "lance-bench",
- "rand 0.9.2",
- "rand_distr 0.5.1",
+ "rand 0.10.0",
+ "rand_distr 0.6.0",
  "tokio",
  "vortex-bench",
 ]
@@ -7492,8 +7661,6 @@ dependencies = [
  "instability",
  "ratatui-core",
  "ratatui-crossterm",
- "ratatui-macros",
- "ratatui-termwiz",
  "ratatui-widgets",
 ]
 
@@ -7503,7 +7670,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ef8dea09a92caaf73bff7adb70b76162e5937524058a7e5bff37869cbbec293"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "compact_str",
  "hashbrown 0.16.1",
  "indoc",
@@ -7529,33 +7696,13 @@ dependencies = [
  "ratatui-core",
 ]
 
-[[package]]
-name = "ratatui-macros"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f1342a13e83e4bb9d0b793d0ea762be633f9582048c892ae9041ef39c936f4"
-dependencies = [
- "ratatui-core",
- "ratatui-widgets",
-]
-
-[[package]]
-name = "ratatui-termwiz"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f76fe0bd0ed4295f0321b1676732e2454024c15a35d01904ddb315afd3d545c"
-dependencies = [
- "ratatui-core",
- "termwiz",
-]
-
 [[package]]
 name = "ratatui-widgets"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7dbfa023cd4e604c2553483820c5fe8aa9d71a42eea5aa77c6e7f35756612db"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "hashbrown 0.16.1",
  "indoc",
  "instability",
@@ -7568,6 +7715,22 @@ dependencies = [
  "unicode-width 0.2.2",
 ]
 
+[[package]]
+name = "ratzilla"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfc729362a3a8714b512f330c8dfaa03979813e9491e21b8e49b81e1e5d78014"
+dependencies = [
+ "beamterm-renderer",
+ "bitvec",
+ "compact_str",
+ "console_error_panic_hook",
+ "ratatui",
+ "thiserror 2.0.18",
+ "unicode-width 0.2.2",
+ "web-sys",
+]
+
 [[package]]
 name = "rawpointer"
 version = "0.2.1"
@@ -7620,16 +7783,16 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d94dd2f7cd932d4dc02cc8b2b50dfd38bd079a4e5d79198b99743d7fcf9a4b4"
+checksum = "6ce70a74e890531977d37e532c34d45e9055d2409ed08ddba14529471ed0be16"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
 ]
 
 [[package]]
@@ -7741,13 +7904,11 @@ dependencies = [
  "http-body-util",
  "hyper",
  "hyper-rustls",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
  "mime",
  "mime_guess",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
@@ -7759,7 +7920,6 @@ dependencies = [
  "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls",
  "tokio-util",
  "tower",
@@ -7773,6 +7933,46 @@ dependencies = [
  "webpki-roots",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64",
+ "bytes",
+ "encoding_rs",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.14"
@@ -7905,9 +8105,9 @@ dependencies = [
 
 [[package]]
 name = "rust_decimal"
-version = "1.40.0"
+version = "1.41.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61f703d19852dbf87cbc513643fa81428361eb6940f1ac14fd58155d295a3eb0"
+checksum = "2ce901f9a19d251159075a4c37af514c3b8ef99c22e02dd8c19161cf397ee94a"
 dependencies = [
  "arrayvec",
  "borsh",
@@ -7917,6 +8117,7 @@ dependencies = [
  "rkyv",
  "serde",
  "serde_json",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -7956,7 +8157,7 @@ version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
@@ -7969,7 +8170,7 @@ version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
@@ -7982,6 +8183,7 @@ version = "0.23.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
 dependencies = [
+ "aws-lc-rs",
  "once_cell",
  "ring",
  "rustls-pki-types",
@@ -8002,15 +8204,6 @@ dependencies = [
  "security-framework",
 ]
 
-[[package]]
-name = "rustls-pemfile"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
-dependencies = [
- "rustls-pki-types",
-]
-
 [[package]]
 name = "rustls-pki-types"
 version = "1.14.0"
@@ -8021,12 +8214,40 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
 [[package]]
 name = "rustls-webpki"
-version = "0.103.9"
+version = "0.103.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
 dependencies = [
+ "aws-lc-rs",
  "ring",
  "rustls-pki-types",
  "untrusted",
@@ -8064,9 +8285,9 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
  "windows-sys 0.61.2",
 ]
@@ -8143,7 +8364,7 @@ version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
@@ -8339,7 +8560,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
 
@@ -8350,7 +8571,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest",
 ]
 
@@ -8449,13 +8670,19 @@ checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
 
 [[package]]
 name = "sketches-ddsketch"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a"
+checksum = "0c6f73aeb92d671e0cc4dca167e59b2deb6387c375391bc99ee743f326994a2b"
 dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sketches-ddsketch"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05e40b6cf54d988dc1a2223531b969c9a9e30906ad90ef64890c27b4bfbb46ea"
+
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -8533,22 +8760,12 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "socket2"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -8565,9 +8782,9 @@ dependencies = [
 
 [[package]]
 name = "sqllogictest"
-version = "0.28.4"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3566426f72a13e393aa34ca3d542c5b0eb86da4c0db137ee9b5cfccc6179e52d"
+checksum = "d03b2262a244037b0b510edbd25a8e6c9fb8d73ee0237fc6cc95a54c16f94a82"
 dependencies = [
  "async-trait",
  "educe",
@@ -8593,10 +8810,20 @@ name = "sqlparser"
 version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4591acadbcf52f0af60eafbb2c003232b2b4cd8de5f0e9437cb8b1b59046cc0f"
+dependencies = [
+ "log",
+ "sqlparser_derive 0.3.0",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
 dependencies = [
  "log",
  "recursive",
- "sqlparser_derive",
+ "sqlparser_derive 0.5.0",
 ]
 
 [[package]]
@@ -8610,6 +8837,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "sqlparser_derive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -8681,6 +8919,15 @@ dependencies = [
  "strum_macros 0.27.2",
 ]
 
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros 0.28.0",
+]
+
 [[package]]
 name = "strum_macros"
 version = "0.26.4"
@@ -8706,6 +8953,18 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "subst"
 version = "0.3.8"
@@ -8791,23 +9050,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.35.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3ffa3e4ff2b324a57f7aeb3c349656c7b127c3c189520251a648102a92496e"
-dependencies = [
- "libc",
- "memchr",
- "ntapi",
- "objc2-core-foundation",
- "objc2-io-kit",
- "windows",
-]
-
-[[package]]
-name = "sysinfo"
-version = "0.37.2"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16607d5caffd1c07ce073528f9ed972d88db15dd44023fa57142963be3feb11f"
+checksum = "92ab6a2f8bfe508deb3c6406578252e491d299cbbf3bc0529ecc3313aee4a52f"
 dependencies = [
  "libc",
  "memchr",
@@ -8823,7 +9068,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
@@ -8897,18 +9142,18 @@ dependencies = [
  "levenshtein_automata",
  "log",
  "lru 0.12.5",
- "lz4_flex 0.11.5",
+ "lz4_flex 0.11.6",
  "measure_time",
  "memmap2",
  "once_cell",
- "oneshot",
+ "oneshot 0.1.13",
  "rayon",
  "regex",
  "rust-stemmers",
  "rustc-hash",
  "serde",
  "serde_json",
- "sketches-ddsketch",
+ "sketches-ddsketch 0.3.1",
  "smallvec",
  "tantivy-bitpacker",
  "tantivy-columnar",
@@ -9026,9 +9271,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tar"
-version = "0.4.44"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
 dependencies = [
  "filetime",
  "libc",
@@ -9058,12 +9303,12 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.26.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "once_cell",
  "rustix 1.1.4",
  "windows-sys 0.61.2",
@@ -9080,88 +9325,25 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
  "rustix 1.1.4",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "terminfo"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4ea810f0692f9f51b382fff5893887bb4580f5fa246fde546e0b13e7fcee662"
-dependencies = [
- "fnv",
- "nom 7.1.3",
- "phf 0.11.3",
- "phf_codegen",
-]
-
-[[package]]
-name = "termios"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411c5bf740737c7918b8b1fe232dca4dc9f8e754b8ad5e20966814001ed0ac6b"
-dependencies = [
- "libc",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "termtree"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
-
-[[package]]
-name = "termwiz"
-version = "0.23.3"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4676b37242ccbd1aabf56edb093a4827dc49086c0ffd764a5705899e0f35f8f7"
-dependencies = [
- "anyhow",
- "base64",
- "bitflags 2.11.0",
- "fancy-regex",
- "filedescriptor",
- "finl_unicode",
- "fixedbitset 0.4.2",
- "hex",
- "lazy_static",
- "libc",
- "log",
- "memmem",
- "nix 0.29.0",
- "num-derive",
- "num-traits",
- "ordered-float 4.6.0",
- "pest",
- "pest_derive",
- "phf 0.11.3",
- "sha2",
- "signal-hook",
- "siphasher",
- "terminfo",
- "termios",
- "thiserror 1.0.69",
- "ucd-trie",
- "unicode-segmentation",
- "vtparse",
- "wezterm-bidi",
- "wezterm-blob-leases",
- "wezterm-color-types",
- "wezterm-dynamic",
- "wezterm-input-types",
- "winapi",
-]
+checksum = "d4d1330fe7f7f872cd05165130b10602d667b205fd85be09be2814b115d4ced9"
 
 [[package]]
 name = "test-with"
-version = "0.14.11"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d75791778b593ea6d76454886a69cd37245c4c9af6fee37c42f024593bf1fb03"
+checksum = "27838d769fa9bf364bf4a352ec88862b6e6cb96a8e6705cc78fbb16ff26ee8b9"
 dependencies = [
  "byte-unit",
  "chrono",
@@ -9171,9 +9353,9 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "reqwest",
+ "reqwest 0.13.2",
  "syn 2.0.117",
- "sysinfo 0.35.2",
+ "sysinfo",
  "uzers",
  "which",
 ]
@@ -9274,6 +9456,7 @@ checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
  "deranged",
  "itoa",
+ "js-sys",
  "libc",
  "num-conv",
  "num_threads",
@@ -9330,9 +9513,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -9345,9 +9528,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
  "bytes",
  "libc",
@@ -9355,32 +9538,22 @@ dependencies = [
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.2",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
@@ -9400,6 +9573,7 @@ dependencies = [
  "futures-core",
  "pin-project-lite",
  "tokio",
+ "tokio-util",
 ]
 
 [[package]]
@@ -9424,10 +9598,10 @@ dependencies = [
  "indexmap",
  "serde_core",
  "serde_spanned",
- "toml_datetime",
+ "toml_datetime 0.7.5+spec-1.1.0",
  "toml_parser",
  "toml_writer",
- "winnow",
+ "winnow 0.7.15",
 ]
 
 [[package]]
@@ -9439,32 +9613,41 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "toml_datetime"
+version = "1.0.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "toml_edit"
-version = "0.23.10+spec-1.0.0"
+version = "0.25.4+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
+checksum = "7193cbd0ce53dc966037f54351dbbcf0d5a642c7f0038c382ef9e677ce8c13f2"
 dependencies = [
  "indexmap",
- "toml_datetime",
+ "toml_datetime 1.0.0+spec-1.1.0",
  "toml_parser",
- "winnow",
+ "winnow 0.7.15",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.9+spec-1.1.0"
+version = "1.0.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+checksum = "7df25b4befd31c4816df190124375d5a20c6b6921e2cad937316de3fccd63420"
 dependencies = [
- "winnow",
+ "winnow 1.0.0",
 ]
 
 [[package]]
 name = "toml_writer"
-version = "1.0.6+spec-1.1.0"
+version = "1.0.7+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+checksum = "f17aaa1c6e3dc22b1da4b6bba97d066e354c7945cac2f7852d4e4e7ca7a6b56d"
 
 [[package]]
 name = "tonic"
@@ -9520,7 +9703,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
  "async-compression",
- "bitflags 2.11.0",
+ "bitflags",
  "bytes",
  "futures-core",
  "futures-util",
@@ -9551,16 +9734,14 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 [[package]]
 name = "tpchgen"
 version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d651db770ccf53b89dd769ed47899c0c089452e3b725c3c48fbc6a2be579638"
+source = "git+https://github.com/clflushopt/tpchgen-rs.git?rev=438e9c2dbc25b2fff82c0efc08b3f13b5707874f#438e9c2dbc25b2fff82c0efc08b3f13b5707874f"
 
 [[package]]
 name = "tpchgen-arrow"
 version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180f3759dffbf26d47021d2a84245a00f20945384bcf22e63c32652b04916e5a"
+source = "git+https://github.com/clflushopt/tpchgen-rs.git?rev=438e9c2dbc25b2fff82c0efc08b3f13b5707874f#438e9c2dbc25b2fff82c0efc08b3f13b5707874f"
 dependencies = [
- "arrow",
+ "arrow 58.0.0",
  "tpchgen",
 ]
 
@@ -9636,9 +9817,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.22"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -9670,6 +9851,12 @@ dependencies = [
  "rand 0.9.2",
 ]
 
+[[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.19.0"
@@ -9719,15 +9906,9 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_tokenstream",
- "syn 2.0.117",
- "typify-impl",
-]
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+ "syn 2.0.117",
+ "typify-impl",
+]
 
 [[package]]
 name = "uint"
@@ -9789,12 +9970,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "unit-prefix"
 version = "0.5.2"
@@ -9851,12 +10026,11 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.21.0"
+version = "1.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
 dependencies = [
- "atomic",
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "js-sys",
  "serde_core",
  "wasm-bindgen",
@@ -9878,12 +10052,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 = "version_check"
 version = "0.9.5"
@@ -9895,12 +10063,14 @@ name = "vortex"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-array",
+ "arrow-array 58.0.0",
  "codspeed-divan-compat",
  "fastlanes",
  "mimalloc",
- "parquet",
- "rand 0.9.2",
+ "parquet 58.0.0",
+ "paste",
+ "rand 0.10.0",
+ "rand_distr 0.6.0",
  "serde_json",
  "tokio",
  "tracing",
@@ -9930,6 +10100,7 @@ dependencies = [
  "vortex-sequence",
  "vortex-session",
  "vortex-sparse",
+ "vortex-tensor",
  "vortex-utils",
  "vortex-zigzag",
  "vortex-zstd",
@@ -9943,7 +10114,7 @@ dependencies = [
  "itertools 0.14.0",
  "num-traits",
  "prost 0.14.3",
- "rand 0.9.2",
+ "rand 0.10.0",
  "rstest",
  "rustc-hash",
  "vortex-array",
@@ -9961,15 +10132,15 @@ version = "0.1.0"
 dependencies = [
  "arbitrary",
  "arcref",
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-cast",
- "arrow-data",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
- "arrow-string",
+ "arrow-arith 58.0.0",
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-cast 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-ord 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
+ "arrow-string 58.0.0",
  "async-lock",
  "bytes",
  "cfg-if",
@@ -9978,7 +10149,7 @@ dependencies = [
  "enum-iterator",
  "flatbuffers",
  "futures",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "goldenfile",
  "half",
  "humansize",
@@ -9994,8 +10165,8 @@ dependencies = [
  "pin-project-lite",
  "primitive-types",
  "prost 0.14.3",
- "rand 0.9.2",
- "rand_distr 0.5.1",
+ "rand 0.10.0",
+ "rand_distr 0.6.0",
  "rstest",
  "rstest_reuse",
  "rustc-hash",
@@ -10007,7 +10178,9 @@ dependencies = [
  "tabled",
  "termtree",
  "tracing",
+ "uuid",
  "vortex-array",
+ "vortex-array-macros",
  "vortex-buffer",
  "vortex-error",
  "vortex-flatbuffers",
@@ -10017,14 +10190,23 @@ dependencies = [
  "vortex-utils",
 ]
 
+[[package]]
+name = "vortex-array-macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "vortex-bench"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-array",
- "arrow-schema",
- "arrow-select",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
+ "arrow-select 58.0.0",
  "async-trait",
  "bytes",
  "bzip2",
@@ -10039,13 +10221,13 @@ dependencies = [
  "noodles-bgzf",
  "noodles-vcf",
  "parking_lot",
- "parquet",
- "rand 0.9.2",
+ "parquet 58.0.0",
+ "rand 0.10.0",
  "regex",
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
- "sysinfo 0.37.2",
+ "sysinfo",
  "tabled",
  "target-lexicon",
  "tokio",
@@ -10066,12 +10248,11 @@ name = "vortex-btrblocks"
 version = "0.1.0"
 dependencies = [
  "codspeed-divan-compat",
- "enum-iterator",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "itertools 0.14.0",
  "num-traits",
  "pco",
- "rand 0.9.2",
+ "rand 0.10.0",
  "rstest",
  "rustc-hash",
  "test-with",
@@ -10079,6 +10260,7 @@ dependencies = [
  "vortex-alp",
  "vortex-array",
  "vortex-buffer",
+ "vortex-compressor",
  "vortex-datetime-parts",
  "vortex-decimal-byte-parts",
  "vortex-error",
@@ -10089,6 +10271,7 @@ dependencies = [
  "vortex-runend",
  "vortex-sequence",
  "vortex-sparse",
+ "vortex-tensor",
  "vortex-utils",
  "vortex-zigzag",
  "vortex-zstd",
@@ -10098,7 +10281,7 @@ dependencies = [
 name = "vortex-buffer"
 version = "0.1.0"
 dependencies = [
- "arrow-buffer",
+ "arrow-buffer 58.0.0",
  "bitvec",
  "bytes",
  "codspeed-divan-compat",
@@ -10121,9 +10304,54 @@ dependencies = [
  "vortex-array",
  "vortex-buffer",
  "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-compat"
+version = "0.1.0"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-select 58.0.0",
+ "bytes",
+ "clap",
+ "futures",
+ "parquet 58.0.0",
+ "reqwest 0.12.28",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tempfile",
+ "tokio",
+ "tpchgen",
+ "tpchgen-arrow",
+ "vortex",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
  "vortex-session",
 ]
 
+[[package]]
+name = "vortex-compressor"
+version = "0.1.0"
+dependencies = [
+ "codspeed-divan-compat",
+ "itertools 0.14.0",
+ "num-traits",
+ "parking_lot",
+ "rand 0.10.0",
+ "rstest",
+ "rustc-hash",
+ "tracing",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-utils",
+]
+
 [[package]]
 name = "vortex-cub"
 version = "0.1.0"
@@ -10142,11 +10370,15 @@ dependencies = [
  "arc-swap",
  "async-trait",
  "bindgen",
+ "bytes",
  "codspeed-criterion-compat-walltime",
  "cudarc",
  "fastlanes",
  "futures",
+ "itertools 0.14.0",
  "kanal",
+ "object_store 0.13.1",
+ "parking_lot",
  "prost 0.14.3",
  "rstest",
  "tokio",
@@ -10173,8 +10405,8 @@ name = "vortex-cxx"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-array",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "async-fs",
  "cxx",
  "futures",
@@ -10188,25 +10420,25 @@ name = "vortex-datafusion"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-schema",
+ "arrow-schema 58.0.0",
  "async-trait",
- "datafusion 52.1.0",
- "datafusion-catalog 52.1.0",
- "datafusion-common 52.1.0",
- "datafusion-common-runtime 52.1.0",
- "datafusion-datasource 52.1.0",
- "datafusion-execution 52.1.0",
- "datafusion-expr 52.1.0",
- "datafusion-functions 52.1.0",
- "datafusion-physical-expr 52.1.0",
- "datafusion-physical-expr-adapter 52.1.0",
- "datafusion-physical-expr-common 52.1.0",
- "datafusion-physical-plan 52.1.0",
- "datafusion-pruning 52.1.0",
+ "datafusion 53.0.0",
+ "datafusion-catalog 53.0.0",
+ "datafusion-common 53.0.0",
+ "datafusion-common-runtime 53.0.0",
+ "datafusion-datasource 53.0.0",
+ "datafusion-execution 53.0.0",
+ "datafusion-expr 53.0.0",
+ "datafusion-functions 53.0.0",
+ "datafusion-physical-expr 53.0.0",
+ "datafusion-physical-expr-adapter 53.0.0",
+ "datafusion-physical-expr-common 53.0.0",
+ "datafusion-physical-plan 53.0.0",
+ "datafusion-pruning 53.0.0",
  "futures",
  "insta",
  "itertools 0.14.0",
- "object_store",
+ "object_store 0.13.1",
  "rstest",
  "tempfile",
  "tokio",
@@ -10263,11 +10495,10 @@ dependencies = [
  "jiff",
  "kanal",
  "num-traits",
- "object_store",
- "once_cell",
+ "object_store 0.13.1",
  "parking_lot",
  "paste",
- "reqwest",
+ "reqwest 0.12.28",
  "rstest",
  "tempfile",
  "tracing",
@@ -10277,7 +10508,6 @@ dependencies = [
  "vortex-runend",
  "vortex-sequence",
  "vortex-utils",
- "walkdir",
  "zip",
 ]
 
@@ -10285,10 +10515,10 @@ dependencies = [
 name = "vortex-error"
 version = "0.1.0"
 dependencies = [
- "arrow-schema",
+ "arrow-schema 58.0.0",
  "flatbuffers",
  "jiff",
- "object_store",
+ "object_store 0.13.1",
  "prost 0.14.3",
  "serial_test",
  "temp-env",
@@ -10299,14 +10529,13 @@ dependencies = [
 name = "vortex-fastlanes"
 version = "0.1.0"
 dependencies = [
- "arrayref",
  "codspeed-divan-compat",
  "fastlanes",
  "itertools 0.14.0",
  "lending-iterator",
  "num-traits",
  "prost 0.14.3",
- "rand 0.9.2",
+ "rand 0.10.0",
  "rstest",
  "vortex-alp",
  "vortex-array",
@@ -10326,7 +10555,7 @@ dependencies = [
  "futures",
  "itertools 0.14.0",
  "mimalloc",
- "object_store",
+ "object_store 0.13.1",
  "paste",
  "prost 0.14.3",
  "tempfile",
@@ -10334,6 +10563,7 @@ dependencies = [
  "tracing-subscriber",
  "url",
  "vortex",
+ "vortex-array",
 ]
 
 [[package]]
@@ -10344,12 +10574,12 @@ dependencies = [
  "bytes",
  "flatbuffers",
  "futures",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "itertools 0.14.0",
  "kanal",
  "moka",
- "object_store",
- "oneshot",
+ "object_store 0.13.1",
+ "oneshot 0.2.1",
  "parking_lot",
  "pin-project-lite",
  "tokio",
@@ -10376,6 +10606,7 @@ dependencies = [
  "vortex-sequence",
  "vortex-session",
  "vortex-sparse",
+ "vortex-tensor",
  "vortex-utils",
  "vortex-zigzag",
  "vortex-zstd",
@@ -10397,7 +10628,7 @@ dependencies = [
  "codspeed-divan-compat",
  "fsst-rs",
  "prost 0.14.3",
- "rand 0.9.2",
+ "rand 0.10.0",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -10413,8 +10644,10 @@ dependencies = [
  "arbitrary",
  "itertools 0.14.0",
  "libfuzzer-sys",
- "strum 0.27.2",
+ "strum 0.28.0",
  "tokio",
+ "tracing",
+ "tracing-subscriber",
  "vortex",
  "vortex-array",
  "vortex-btrblocks",
@@ -10422,6 +10655,7 @@ dependencies = [
  "vortex-cuda",
  "vortex-error",
  "vortex-file",
+ "vortex-fsst",
  "vortex-io",
  "vortex-mask",
  "vortex-runend",
@@ -10440,14 +10674,14 @@ dependencies = [
  "bytes",
  "custom-labels",
  "futures",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "glob",
  "handle",
  "itertools 0.14.0",
  "kanal",
  "log",
- "object_store",
- "oneshot",
+ "object_store 0.13.1",
+ "oneshot 0.2.1",
  "parking_lot",
  "pin-project-lite",
  "rstest",
@@ -10484,12 +10718,12 @@ dependencies = [
 name = "vortex-jni"
 version = "0.1.0"
 dependencies = [
- "arrow-array",
- "arrow-ipc",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-ipc 58.0.0",
+ "arrow-schema 58.0.0",
  "futures",
  "jni",
- "object_store",
+ "object_store 0.13.1",
  "parking_lot",
  "prost 0.14.3",
  "thiserror 2.0.18",
@@ -10505,25 +10739,28 @@ name = "vortex-layout"
 version = "0.1.0"
 dependencies = [
  "arcref",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "async-stream",
  "async-trait",
+ "bit-vec",
  "flatbuffers",
  "futures",
  "itertools 0.14.0",
  "kanal",
  "moka",
  "once_cell",
- "oneshot",
+ "oneshot 0.2.1",
  "parking_lot",
  "paste",
  "pin-project-lite",
  "prost 0.14.3",
  "rstest",
  "rustc-hash",
+ "sketches-ddsketch 0.4.0",
  "termtree",
  "tokio",
  "tracing",
- "uuid",
  "vortex-array",
  "vortex-btrblocks",
  "vortex-buffer",
@@ -10532,6 +10769,7 @@ dependencies = [
  "vortex-io",
  "vortex-mask",
  "vortex-metrics",
+ "vortex-scan",
  "vortex-sequence",
  "vortex-session",
  "vortex-utils",
@@ -10541,7 +10779,8 @@ dependencies = [
 name = "vortex-mask"
 version = "0.1.0"
 dependencies = [
- "arrow-buffer",
+ "arrow-buffer 58.0.0",
+ "codspeed-divan-compat",
  "itertools 0.14.0",
  "rstest",
  "serde",
@@ -10553,9 +10792,9 @@ dependencies = [
 name = "vortex-metrics"
 version = "0.1.0"
 dependencies = [
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "parking_lot",
- "sketches-ddsketch",
+ "sketches-ddsketch 0.4.0",
 ]
 
 [[package]]
@@ -10565,11 +10804,31 @@ dependencies = [
  "bindgen",
  "libloading 0.8.9",
  "liblzma",
- "reqwest",
+ "reqwest 0.12.28",
  "tar",
  "vortex-cuda-macros",
 ]
 
+[[package]]
+name = "vortex-parquet-variant"
+version = "0.1.0"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-buffer 58.0.0",
+ "arrow-schema 58.0.0",
+ "chrono",
+ "parquet-variant",
+ "parquet-variant-compute",
+ "prost 0.14.3",
+ "rstest",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-proto",
+ "vortex-session",
+]
+
 [[package]]
 name = "vortex-pco"
 version = "0.1.0"
@@ -10596,13 +10855,14 @@ dependencies = [
 name = "vortex-python"
 version = "0.1.0"
 dependencies = [
- "arrow-array",
- "arrow-data",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-data 58.0.0",
+ "arrow-schema 58.0.0",
  "bytes",
  "itertools 0.14.0",
  "log",
- "object_store",
+ "mimalloc",
+ "object_store 0.13.1",
  "parking_lot",
  "pyo3",
  "pyo3-bytes",
@@ -10619,13 +10879,13 @@ name = "vortex-runend"
 version = "0.1.0"
 dependencies = [
  "arbitrary",
- "arrow-array",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "codspeed-divan-compat",
  "itertools 0.14.0",
  "num-traits",
  "prost 0.14.3",
- "rand 0.9.2",
+ "rand 0.10.0",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -10638,23 +10898,14 @@ dependencies = [
 name = "vortex-scan"
 version = "0.1.0"
 dependencies = [
- "arrow-array",
- "arrow-schema",
  "async-trait",
- "bit-vec 0.8.0",
  "futures",
- "itertools 0.14.0",
- "parking_lot",
  "roaring 0.11.3",
- "sketches-ddsketch",
  "tracing",
  "vortex-array",
  "vortex-buffer",
  "vortex-error",
- "vortex-io",
- "vortex-layout",
  "vortex-mask",
- "vortex-metrics",
  "vortex-session",
 ]
 
@@ -10706,11 +10957,13 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "async-trait",
+ "bigdecimal",
  "clap",
- "datafusion 52.1.0",
+ "datafusion 53.0.0",
  "datafusion-sqllogictest",
  "futures",
  "indicatif",
+ "rstest",
  "sqllogictest",
  "thiserror 2.0.18",
  "tokio",
@@ -10720,20 +10973,31 @@ dependencies = [
 ]
 
 [[package]]
-name = "vortex-test-e2e"
+name = "vortex-tensor"
 version = "0.1.0"
 dependencies = [
- "futures",
- "tokio",
- "vortex",
+ "half",
+ "itertools 0.14.0",
+ "num-traits",
+ "prost 0.14.3",
+ "rand 0.10.0",
+ "rand_distr 0.6.0",
+ "rstest",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-compressor",
+ "vortex-error",
+ "vortex-fastlanes",
+ "vortex-session",
+ "vortex-utils",
 ]
 
 [[package]]
 name = "vortex-test-e2e-cuda"
 version = "0.1.0"
 dependencies = [
- "arrow-array",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "futures",
  "vortex",
  "vortex-cuda",
@@ -10744,11 +11008,12 @@ name = "vortex-tui"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "arrow-array",
- "arrow-schema",
+ "arrow-array 58.0.0",
+ "arrow-schema 58.0.0",
  "clap",
+ "console_error_panic_hook",
  "crossterm",
- "datafusion 52.1.0",
+ "datafusion 53.0.0",
  "env_logger",
  "flatbuffers",
  "futures",
@@ -10756,14 +11021,19 @@ dependencies = [
  "humansize",
  "indicatif",
  "itertools 0.14.0",
- "parquet",
+ "js-sys",
+ "parquet 58.0.0",
  "ratatui",
+ "ratzilla",
  "serde",
  "serde_json",
  "taffy",
  "tokio",
  "vortex",
  "vortex-datafusion",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
@@ -10776,6 +11046,24 @@ dependencies = [
  "vortex-error",
 ]
 
+[[package]]
+name = "vortex-web-wasm"
+version = "0.1.0"
+dependencies = [
+ "arrow-array 58.0.0",
+ "arrow-ipc 58.0.0",
+ "arrow-schema 58.0.0",
+ "console_error_panic_hook",
+ "futures",
+ "js-sys",
+ "serde",
+ "serde_json",
+ "vortex",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "vortex-zigzag"
 version = "0.1.0"
@@ -10805,15 +11093,6 @@ dependencies = [
  "zstd",
 ]
 
-[[package]]
-name = "vtparse"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9b2acfb050df409c972a37d3b8e08cdea3bddb0c09db9d53137e504cfabed0"
-dependencies = [
- "utf8parse",
-]
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -10859,9 +11138,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.113"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60722a937f594b7fde9adb894d7c092fc1bb6612897c46368d18e7a20208eff2"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -10872,9 +11151,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.63"
+version = "0.4.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a89f4650b770e4521aa6573724e2aed4704372151bd0de9d16a3bbabb87441a"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -10886,9 +11165,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.113"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac8c6395094b6b91c4af293f4c79371c163f9a6f56184d2c9a85f5a95f3950"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -10896,9 +11175,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.113"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3fabce6159dc20728033842636887e4877688ae94382766e00b180abac9d60"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -10909,9 +11188,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.113"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de0e091bdb824da87dc01d967388880d017a0a9bc4f3bdc0d86ee9f9336e3bb5"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
 dependencies = [
  "unicode-ident",
 ]
@@ -10957,7 +11236,7 @@ version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "bitflags 2.11.0",
+ "bitflags",
  "hashbrown 0.15.5",
  "indexmap",
  "semver",
@@ -10965,9 +11244,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.90"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "705eceb4ce901230f8625bd1d665128056ccbe4b7408faa625eec1ba80f59a97"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -10984,95 +11263,30 @@ dependencies = [
 ]
 
 [[package]]
-name = "webpki-roots"
+name = "webpki-root-certs"
 version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
+checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca"
 dependencies = [
  "rustls-pki-types",
 ]
 
 [[package]]
-name = "wezterm-bidi"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c0a6e355560527dd2d1cf7890652f4f09bb3433b6aadade4c9b5ed76de5f3ec"
-dependencies = [
- "log",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-blob-leases"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692daff6d93d94e29e4114544ef6d5c942a7ed998b37abdc19b17136ea428eb7"
-dependencies = [
- "getrandom 0.3.4",
- "mac_address",
- "sha2",
- "thiserror 1.0.69",
- "uuid",
-]
-
-[[package]]
-name = "wezterm-color-types"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7de81ef35c9010270d63772bebef2f2d6d1f2d20a983d27505ac850b8c4b4296"
-dependencies = [
- "csscolorparser",
- "deltae",
- "lazy_static",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-dynamic"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f2ab60e120fd6eaa68d9567f3226e876684639d22a4219b313ff69ec0ccd5ac"
-dependencies = [
- "log",
- "ordered-float 4.6.0",
- "strsim",
- "thiserror 1.0.69",
- "wezterm-dynamic-derive",
-]
-
-[[package]]
-name = "wezterm-dynamic-derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c0cf2d539c645b448eaffec9ec494b8b19bd5077d9e58cb1ae7efece8d575b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "wezterm-input-types"
-version = "0.1.0"
+name = "webpki-roots"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7012add459f951456ec9d6c7e6fc340b1ce15d6fc9629f8c42853412c029e57e"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
 dependencies = [
- "bitflags 1.3.2",
- "euclid",
- "lazy_static",
- "serde",
- "wezterm-dynamic",
+ "rustls-pki-types",
 ]
 
 [[package]]
 name = "which"
-version = "8.0.0"
+version = "8.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d"
+checksum = "81995fafaaaf6ae47a7d0cc83c67caf92aeb7e5331650ae6ff856f7c0c60c459"
 dependencies = [
- "env_home",
- "rustix 1.1.4",
- "winsafe",
+ "libc",
 ]
 
 [[package]]
@@ -11108,37 +11322,23 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
-version = "0.61.3"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
 dependencies = [
  "windows-collections",
- "windows-core 0.61.2",
+ "windows-core",
  "windows-future",
- "windows-link 0.1.3",
  "windows-numerics",
 ]
 
 [[package]]
 name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
-dependencies = [
- "windows-core 0.61.2",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.61.2"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
 dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-core",
 ]
 
 [[package]]
@@ -11149,19 +11349,19 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
  "windows-implement",
  "windows-interface",
- "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
 name = "windows-future"
-version = "0.2.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
 dependencies = [
- "windows-core 0.61.2",
- "windows-link 0.1.3",
+ "windows-core",
+ "windows-link",
  "windows-threading",
 ]
 
@@ -11187,12 +11387,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "windows-link"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
-
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -11201,12 +11395,12 @@ checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-numerics"
-version = "0.2.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
 dependencies = [
- "windows-core 0.61.2",
- "windows-link 0.1.3",
+ "windows-core",
+ "windows-link",
 ]
 
 [[package]]
@@ -11215,18 +11409,9 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
- "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
-]
-
-[[package]]
-name = "windows-result"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
-dependencies = [
- "windows-link 0.1.3",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
@@ -11235,16 +11420,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-link 0.2.1",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
-dependencies = [
- "windows-link 0.1.3",
+ "windows-link",
 ]
 
 [[package]]
@@ -11253,7 +11429,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -11298,7 +11474,7 @@ version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -11338,7 +11514,7 @@ version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
- "windows-link 0.2.1",
+ "windows-link",
  "windows_aarch64_gnullvm 0.53.1",
  "windows_aarch64_msvc 0.53.1",
  "windows_i686_gnu 0.53.1",
@@ -11351,11 +11527,11 @@ dependencies = [
 
 [[package]]
 name = "windows-threading"
-version = "0.1.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
 dependencies = [
- "windows-link 0.1.3",
+ "windows-link",
 ]
 
 [[package]]
@@ -11498,18 +11674,18 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.7.14"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "winsafe"
-version = "0.0.19"
+name = "winnow"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
 
 [[package]]
 name = "wit-bindgen"
@@ -11569,7 +11745,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
  "anyhow",
- "bitflags 2.11.0",
+ "bitflags",
  "indexmap",
  "log",
  "serde",
@@ -11713,18 +11889,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.40"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+checksum = "f2578b716f8a7a858b7f02d5bd870c14bf4ddbbcf3a4c05414ba6503640505e3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.40"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -11757,20 +11933,6 @@ name = "zeroize"
 version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
-dependencies = [
- "zeroize_derive",
-]
-
-[[package]]
-name = "zeroize_derive"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
 
 [[package]]
 name = "zerotrie"
@@ -11816,18 +11978,17 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "6.0.0"
+version = "8.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
+checksum = "5c546feb4481b0fbafb4ef0d79b6204fc41c6f9884b1b73b1d73f82442fc0845"
 dependencies = [
  "aes",
- "arbitrary",
  "bzip2",
- "constant_time_eq 0.3.1",
+ "constant_time_eq",
  "crc32fast",
  "deflate64",
  "flate2",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "hmac",
  "indexmap",
  "lzma-rust2",
@@ -11836,6 +11997,7 @@ dependencies = [
  "ppmd-rust",
  "sha1",
  "time",
+ "typed-path",
  "zeroize",
  "zopfli",
  "zstd",
@@ -11843,9 +12005,9 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c745c48e1007337ed136dc99df34128b9faa6ed542d80a1c673cf55a6d7236c8"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
 
 [[package]]
 name = "zmij"
diff --git a/Cargo.toml b/Cargo.toml
index 95db03905ca..cc0c7c45a0c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 members = [
     # Core crates in dependency order
+    "vortex-array-macros",
     "vortex-error",
     "vortex-buffer",
     "vortex-mask",
@@ -11,6 +12,8 @@ members = [
     "vortex-io",
     "vortex-proto",
     "vortex-array",
+    "vortex-tensor",
+    "vortex-compressor",
     "vortex-btrblocks",
     "vortex-layout",
     "vortex-scan",
@@ -31,7 +34,9 @@ members = [
     "vortex-jni",
     "vortex-python",
     "vortex-tui",
-    "vortex-test/e2e",
+    "vortex-web/crate",
+    "vortex-sqllogictest",
+    "vortex-test/compat-gen",
     "vortex-test/e2e-cuda",
     "xtask",
     # Encodings
@@ -47,13 +52,13 @@ members = [
     "encodings/zigzag",
     "encodings/zstd",
     "encodings/bytebool",
+    "encodings/parquet-variant",
     # Benchmarks
     "benchmarks/lance-bench",
     "benchmarks/compress-bench",
     "benchmarks/datafusion-bench",
     "benchmarks/duckdb-bench",
     "benchmarks/random-access-bench",
-    "vortex-sqllogictest",
 ]
 exclude = ["java/testfiles", "wasm-test"]
 resolver = "2"
@@ -80,27 +85,28 @@ rust-version = "1.90"
 version = "0.1.0"
 
 [workspace.dependencies]
+aho-corasick = "1.1.3"
 anyhow = "1.0.97"
 arbitrary = "1.3.2"
 arc-swap = "1.8"
 arcref = "0.2.0"
-arrayref = "0.3.7"
-arrow-arith = "57.1"
-arrow-array = "57.1"
-arrow-buffer = "57.1"
-arrow-cast = "57.1"
-arrow-data = "57.1"
-arrow-ipc = "57.1"
-arrow-ord = "57.1"
-arrow-schema = "57.1"
-arrow-select = "57.1"
-arrow-string = "57.1"
+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"
 async-fs = "2.2.0"
 async-lock = "3.4"
 async-stream = "0.3.6"
 async-trait = "0.1.89"
+bigdecimal = "0.4.8"
 bindgen = "0.72.0"
-bit-vec = "0.8.0"
+bit-vec = "0.9.0"
 bitvec = "1.0.1"
 bytes = "1.11.1"
 bzip2 = "0.6.0"
@@ -110,7 +116,7 @@ cc = "1.2"
 cfg-if = "1.0.1"
 chrono = "0.4.42"
 clap = "4.5"
-criterion = "0.7"
+criterion = "0.8"
 crossterm = "0.29"
 cudarc = { version = "0.18.2", features = [
     # The NSight Compute version available on lambda.ai hosts does not inject a symbol for
@@ -119,24 +125,26 @@ cudarc = { version = "0.18.2", features = [
     "cuda-12050",
 ] }
 custom-labels = "0.4.4"
+daachorse = "1.0.0"
 dashmap = "6.1.0"
-datafusion = { version = "52", default-features = false, features = ["sql"] }
-datafusion-catalog = { version = "52" }
-datafusion-common = { version = "52" }
-datafusion-common-runtime = { version = "52" }
-datafusion-datasource = { version = "52", default-features = false }
-datafusion-execution = { version = "52" }
-datafusion-expr = { version = "52" }
-datafusion-functions = { version = "52" }
-datafusion-physical-expr = { version = "52" }
-datafusion-physical-expr-adapter = { version = "52" }
-datafusion-physical-expr-common = { version = "52" }
-datafusion-physical-plan = { version = "52" }
-datafusion-pruning = { version = "52" }
-datafusion-sqllogictest = { version = "52" }
+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" }
 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"
 flatbuffers = "25.2.10"
 fsst-rs = "0.5.5"
@@ -152,6 +160,7 @@ indicatif = "0.18.0"
 insta = "1.43"
 inventory = "0.3.20"
 itertools = "0.14.0"
+jetscii = "0.5.3"
 jiff = "0.2.0"
 kanal = "0.1.1"
 lending-iterator = "0.1.7"
@@ -160,22 +169,25 @@ libloading = "0.8"
 liblzma = "0.4"
 log = { version = "0.4.21" }
 loom = { version = "0.7", features = ["checkpoint"] }
+memchr = "2.8.0"
 memmap2 = "0.9.5"
 mimalloc = "0.1.42"
 moka = { version = "0.12.10", default-features = false }
 multiversion = "0.8.0"
-noodles-bgzf = "0.44.0"
-noodles-vcf = "0.82.0"
+noodles-bgzf = "0.46.0"
+noodles-vcf = { version = "0.86.0", features = ["async"] }
 num-traits = "0.2.19"
 num_enum = { version = "0.7.3", default-features = false }
-object_store = { version = "0.12.4", default-features = false }
+object_store = { version = "0.13.1", default-features = false }
 once_cell = "1.21"
-oneshot = "0.1.13"
+oneshot = { version = "0.2.0", features = ["async"] }
 opentelemetry = "0.31.0"
 opentelemetry-otlp = "0.31.0"
 opentelemetry_sdk = "0.31.0"
 parking_lot = { version = "0.12.3", features = ["nightly"] }
-parquet = "57.1"
+parquet = "58"
+parquet-variant = "58"
+parquet-variant-compute = "58"
 paste = "1.0.15"
 pco = "1.0.1"
 pin-project-lite = "0.2.15"
@@ -184,15 +196,17 @@ proc-macro2 = "1.0.95"
 prost = "0.14"
 prost-build = "0.14"
 prost-types = "0.14"
-public-api = "0.50"
-pyo3 = { version = "0.27.0" }
-pyo3-bytes = "0.5"
+public-api = "0.51"
+pyo3 = { version = "0.28.0" }
+pyo3-bytes = "0.6"
 pyo3-log = "0.13.0"
-quote = "1.0.41"
-rand = "0.9.0"
-rand_distr = "0.5"
-ratatui = "0.30"
+pyo3-object_store = "0.9.0"
+quote = "1.0.44"
+rand = "0.10.0"
+rand_distr = "0.6"
+ratatui = { version = "0.30", default-features = false }
 regex = "1.11.0"
+regex-automata = "0.4"
 reqwest = { version = "0.12.4", features = [
     "charset",
     "http2",
@@ -207,38 +221,40 @@ rustc-hash = "2.1"
 serde = "1.0.220"
 serde_json = "1.0.138"
 serde_test = "1.0.176"
+sha2 = "0.10"
 simdutf8 = "0.1.5"
 similar = "2.7.0"
-sketches-ddsketch = "0.3.0"
+sketches-ddsketch = "0.4.0"
 smol = "2.0.2"
 static_assertions = "1.1"
-strum = "0.27"
-syn = { version = "2.0.113", features = ["full"] }
-sysinfo = "0.37.0"
+strum = "0.28"
+syn = { version = "2.0.117", features = ["full"] }
+sysinfo = "0.38.0"
 tabled = { version = "0.20.0", default-features = false }
 taffy = "0.9.0"
 take_mut = "0.2.2"
 tar = "0.4"
 target-lexicon = "0.13"
 tempfile = "3"
-termtree = { version = "0.5" }
-test-with = "0.14"
+termtree = { version = "1.0" }
+test-with = "0.15"
 thiserror = "2.0.3"
 tokio = { version = "1.48" }
 tokio-stream = "0.1.17"
 tokio-util = "0.7.17"
-tpchgen = { version = "2.0.2" }
-tpchgen-arrow = { version = "2.0.2" }
+vortex-array-macros = { version = "0.1.0", path = "./vortex-array-macros" }
+# Pull these into non-public crates to support DF 58
+tpchgen = { version = "2.0.2", git = "https://github.com/clflushopt/tpchgen-rs.git", rev = "438e9c2dbc25b2fff82c0efc08b3f13b5707874f" }
+tpchgen-arrow = { version = "2.0.2", git = "https://github.com/clflushopt/tpchgen-rs.git", rev = "438e9c2dbc25b2fff82c0efc08b3f13b5707874f" }
 tracing = { version = "0.1.41", default-features = false }
 tracing-perfetto = "0.1.5"
 tracing-subscriber = "0.3"
 url = "2.5.7"
-uuid = { version = "1.19", features = ["js"] }
-walkdir = "2.5.0"
-wasm-bindgen-futures = "0.4.39"
+uuid = { version = "1.21", features = ["js"] }
+wasm-bindgen-futures = "0.4.54"
 xshell = "0.2.6"
 zigzag = "0.1.0"
-zip = "6.0.0"
+zip = "8.0.0"
 zstd = { version = "0.13.3", default-features = false, features = [
     "zdict_builder",
 ] }
@@ -250,6 +266,7 @@ vortex-array = { version = "0.1.0", path = "./vortex-array", default-features =
 vortex-btrblocks = { version = "0.1.0", path = "./vortex-btrblocks", default-features = false }
 vortex-buffer = { version = "0.1.0", path = "./vortex-buffer", default-features = false }
 vortex-bytebool = { version = "0.1.0", path = "./encodings/bytebool", default-features = false }
+vortex-compressor = { version = "0.1.0", path = "./vortex-compressor", default-features = false }
 vortex-datafusion = { version = "0.1.0", path = "./vortex-datafusion", default-features = false }
 vortex-datetime-parts = { version = "0.1.0", path = "./encodings/datetime-parts", default-features = false }
 vortex-decimal-byte-parts = { version = "0.1.0", path = "encodings/decimal-byte-parts", default-features = false }
@@ -270,6 +287,7 @@ vortex-scan = { version = "0.1.0", path = "./vortex-scan", default-features = fa
 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-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 }
@@ -277,17 +295,17 @@ vortex-zstd = { version = "0.1.0", path = "./encodings/zstd", default-features =
 
 # No version constraints for unpublished crates.
 vortex-bench = { path = "./vortex-bench", default-features = false }
+vortex-compat = { path = "./vortex-test/compat-gen" }
 vortex-cuda = { path = "./vortex-cuda", default-features = false }
 vortex-cuda-macros = { path = "./vortex-cuda/macros" }
 vortex-duckdb = { path = "./vortex-duckdb", default-features = false }
-vortex-test-e2e = { path = "./vortex-test/e2e", default-features = false }
 vortex-test-e2e-cuda = { path = "./vortex-test/e2e-cuda", default-features = false }
 vortex-tui = { path = "./vortex-tui" }
 
 [workspace.dependencies.getrandom_v03]
 features = ["wasm_js"]
 package = "getrandom"
-version = "0.3.1"
+version = "0.4.0"
 
 [workspace.lints.rust]
 let_underscore_drop = "deny"
@@ -300,6 +318,7 @@ unexpected_cfgs = { level = "deny", check-cfg = [
     "cfg(codspeed)",
     "cfg(disable_loom)",
     "cfg(vortex_nightly)",
+    'cfg(target_os, values("unknown"))',
 ] }
 warnings = "warn"
 
@@ -332,6 +351,7 @@ needless_range_loop = "allow"
 or_fun_call = "deny"
 panic = "deny"
 # panic_in_result_fn = "deny" -- we cannot disable this for tests to use assertions
+clone_on_ref_ptr = "deny"
 redundant_clone = "deny"
 same_name_method = "deny"
 tests_outside_test_module = "deny"
@@ -364,3 +384,15 @@ lto = false
 [profile.bench_assert]
 debug-assertions = true
 inherits = "bench"
+
+[profile.ci]
+inherits = "dev"
+debug = "line-tables-only"
+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"
+incremental = false
diff --git a/REUSE.toml b/REUSE.toml
index ed5c8fda27d..37cc868b2c2 100644
--- a/REUSE.toml
+++ b/REUSE.toml
@@ -17,11 +17,6 @@ path = "benchmarks-website/**"
 SPDX-FileCopyrightText = "Copyright the Vortex contributors"
 SPDX-License-Identifier = "CC-BY-4.0"
 
-[[annotations]]
-path = "benchmarks-website-v2/**"
-SPDX-FileCopyrightText = "Copyright the Vortex contributors"
-SPDX-License-Identifier = "CC-BY-4.0"
-
 # Golden files are licensed under CC-BY-4.0.
 [[annotations]]
 path = "**/goldenfiles/**"
@@ -31,12 +26,12 @@ SPDX-License-Identifier = "CC-BY-4.0"
 # Utility code.
 
 [[annotations]]
-path = ["**/README.md", "CLAUDE.md", "CONTRIBUTING.md", "STYLE.md", "tsc/**.md"]
+path = ["**/README.md", "AGENTS.md", "CLAUDE.md", "CONTRIBUTING.md", "STYLE.md", "tsc/**.md"]
 SPDX-FileCopyrightText = "Copyright the Vortex contributors"
 SPDX-License-Identifier = "CC-BY-4.0"
 
 [[annotations]]
-path = ["**/.gitignore", ".gitmodules", ".python-version", "**/*.lock", "**/*.lockfile", "**/*.toml", "renovate.json", ".idea/**", ".github/**", "codecov.yml", "java/gradle/wrapper/gradle-wrapper.properties"]
+path = ["**/.gitignore", ".gitmodules", ".python-version", "**/*.lock", "**/*.lockfile", "**/*.toml", "**/*.json", ".idea/**", ".github/**", "codecov.yml", "java/gradle/wrapper/gradle-wrapper.properties"]
 precedence = "override"
 SPDX-FileCopyrightText = "Copyright the Vortex contributors"
 SPDX-License-Identifier = "Apache-2.0"
diff --git a/_typos.toml b/_typos.toml
index 5d601d1036f..62c3b0d6358 100644
--- a/_typos.toml
+++ b/_typos.toml
@@ -1,14 +1,14 @@
 [default]
-extend-ignore-identifiers-re = ["ffor", "FFOR", "FoR", "typ"]
+extend-ignore-identifiers-re = ["ffor", "FFOR", "FoR", "typ", "ratatui", "wht", "WHT"]
 # We support a few common special comments to tell the checker to ignore sections of code
 extend-ignore-re = [
-    "(#|//)\\s*spellchecker:ignore-next-line\\n.*",                      # Ignore the next line
-    "(?Rm)^.*(#|//)\\s*spellchecker:disable-line$",                      # Ignore line that ends with this hint
+    "(#|//)\\s*spellchecker:ignore-next-line\\n.*", # Ignore the next line
+    "(?Rm)^.*(#|//)\\s*spellchecker:disable-line$", # Ignore line that ends with this hint
     "(?s)(#|//)\\s*spellchecker:off.*?\\n\\s*(#|//)\\s*spellchecker:on", # Ignore block between hints
 ]
 
 [files]
-extend-exclude = ["/vortex-bench/**", "/docs/references.bib", "benchmarks/**"]
+extend-exclude = ["/vortex-bench/**", "/docs/references.bib", "benchmarks/**", "vortex-sqllogictest/slt/**", "encodings/fsst/src/dfa/tests.rs", "encodings/fsst/src/dfa/flat_contains.rs"]
 
 [type.py]
 extend-ignore-identifiers-re = [
diff --git a/benchmarks-website-v2/index.html b/benchmarks-website-v2/index.html
deleted file mode 100644
index e475f3ad254..00000000000
--- a/benchmarks-website-v2/index.html
+++ /dev/null
@@ -1,36 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vortex Benchmarks</title>
-
-    <!-- Preconnect to font services -->
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-
-    <!-- Web Fonts -->
-    <link
-      href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&display=swap"
-      rel="stylesheet"
-    />
-    <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"
-    />
-
-    <!-- Favicons -->
-    <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
-    <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png" />
-    <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png" />
-    <link rel="manifest" href="/site.webmanifest" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.jsx"></script>
-  </body>
-</html>
diff --git a/benchmarks-website-v2/public/android-chrome-192x192.png b/benchmarks-website-v2/public/android-chrome-192x192.png
deleted file mode 100644
index 1089ab6a060..00000000000
Binary files a/benchmarks-website-v2/public/android-chrome-192x192.png and /dev/null differ
diff --git a/benchmarks-website-v2/public/android-chrome-512x512.png b/benchmarks-website-v2/public/android-chrome-512x512.png
deleted file mode 100644
index 3cfec717ee4..00000000000
Binary files a/benchmarks-website-v2/public/android-chrome-512x512.png and /dev/null differ
diff --git a/benchmarks-website-v2/public/apple-touch-icon.png b/benchmarks-website-v2/public/apple-touch-icon.png
deleted file mode 100644
index 2b34da9ee0c..00000000000
Binary files a/benchmarks-website-v2/public/apple-touch-icon.png and /dev/null differ
diff --git a/benchmarks-website-v2/public/favicon-16x16.png b/benchmarks-website-v2/public/favicon-16x16.png
deleted file mode 100644
index 81dd776858a..00000000000
Binary files a/benchmarks-website-v2/public/favicon-16x16.png and /dev/null differ
diff --git a/benchmarks-website-v2/public/favicon-32x32.png b/benchmarks-website-v2/public/favicon-32x32.png
deleted file mode 100644
index 8d2cb9edabc..00000000000
Binary files a/benchmarks-website-v2/public/favicon-32x32.png and /dev/null differ
diff --git a/benchmarks-website-v2/public/favicon.ico b/benchmarks-website-v2/public/favicon.ico
deleted file mode 100644
index 3d4e2ff9fe0..00000000000
Binary files a/benchmarks-website-v2/public/favicon.ico and /dev/null differ
diff --git a/benchmarks-website-v2/public/site.webmanifest b/benchmarks-website-v2/public/site.webmanifest
deleted file mode 100644
index ba9480d90de..00000000000
--- a/benchmarks-website-v2/public/site.webmanifest
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-  "name": "Vortex Benchmarks",
-  "short_name": "Benchmarks",
-  "icons": [
-    {
-      "src": "/android-chrome-192x192.png",
-      "sizes": "192x192",
-      "type": "image/png"
-    },
-    {
-      "src": "/android-chrome-512x512.png",
-      "sizes": "512x512",
-      "type": "image/png"
-    }
-  ],
-  "theme_color": "#ffffff",
-  "background_color": "#ffffff",
-  "display": "standalone"
-}
diff --git a/benchmarks-website-v2/.dockerignore b/benchmarks-website/.dockerignore
similarity index 100%
rename from benchmarks-website-v2/.dockerignore
rename to benchmarks-website/.dockerignore
diff --git a/benchmarks-website-v2/.gitignore b/benchmarks-website/.gitignore
similarity index 100%
rename from benchmarks-website-v2/.gitignore
rename to benchmarks-website/.gitignore
diff --git a/benchmarks-website-v2/Dockerfile b/benchmarks-website/Dockerfile
similarity index 100%
rename from benchmarks-website-v2/Dockerfile
rename to benchmarks-website/Dockerfile
diff --git a/benchmarks-website/chart-manager.js b/benchmarks-website/chart-manager.js
deleted file mode 100644
index 925283a41c9..00000000000
--- a/benchmarks-website/chart-manager.js
+++ /dev/null
@@ -1,599 +0,0 @@
-"use strict";
-
-// Import dependencies from other modules
-import { CONFIG } from "./config.js";
-import { utils } from "./utils.js";
-
-// Chart management module
-// This module requires the following global dependencies to be available:
-// - window.state: Application state object
-// - window.domElements: DOM elements cache
-// - window.chartObserver: IntersectionObserver for lazy loading
-// - window.zoomSync: Zoom synchronization module
-// - window.debouncedSyncZoom: Debounced zoom synchronization function
-export const chartManager = {
-  remapNames(benchName) {
-    const remappings = {
-      "COMPRESS TIME": "VORTEX WRITE TIME (COMPRESSION)",
-      "DECOMPRESS TIME": "VORTEX SCAN TIME (DECOMPRESSION)",
-      "PARQUET RS-ZSTD COMPRESS TIME": "PARQUET WRITE TIME (COMPRESSION)",
-      "PARQUET RS-ZSTD DECOMPRESS TIME": "PARQUET SCAN TIME (DECOMPRESSION)",
-      "LANCE COMPRESS TIME": "LANCE WRITE TIME (COMPRESSION)",
-      "LANCE DECOMPRESS TIME": "LANCE SCAN TIME (DECOMPRESSION)",
-      "VORTEX SIZE": "VORTEX SIZE",
-      "PARQUET-ZSTD SIZE": "PARQUET SIZE",
-      "LANCE SIZE": "LANCE SIZE",
-      "VORTEX:RAW SIZE": "VORTEX vs RAW SIZE RATIO",
-      "VORTEX:PARQUET-ZSTD SIZE": "VORTEX vs PARQUET SIZE RATIO",
-      "VORTEX:LANCE SIZE": "VORTEX vs LANCE SIZE RATIO",
-      "VORTEX:PARQUET-ZSTD RATIO COMPRESS TIME":
-        "VORTEX vs PARQUET WRITE TIME RATIO",
-      "VORTEX:PARQUET-ZSTD RATIO DECOMPRESS TIME":
-        "VORTEX vs PARQUET SCAN TIME RATIO",
-      "VORTEX:LANCE RATIO COMPRESS TIME": "VORTEX vs LANCE WRITE TIME RATIO",
-      "VORTEX:LANCE RATIO DECOMPRESS TIME": "VORTEX vs LANCE SCAN TIME RATIO",
-    };
-    return remappings[benchName] || benchName;
-  },
-
-  createChartContainer(name, benchName, index) {
-    const container = document.createElement("div");
-    container.className = "chart-container fade-in";
-    container.setAttribute("data-benchmark", name);
-    container.setAttribute("data-chart", benchName);
-
-    const header = document.createElement("div");
-    header.className = "chart-header";
-
-    const title = document.createElement("h3");
-    title.className = "chart-title";
-    title.textContent = this.remapNames(benchName);
-
-    const actions = document.createElement("div");
-    actions.className = "chart-actions";
-
-    const fullscreenBtn = document.createElement("button");
-    fullscreenBtn.className = "chart-action-btn";
-    fullscreenBtn.textContent = "Fullscreen";
-    fullscreenBtn.onclick = () =>
-      chartManager.openModal(name, benchName, index);
-
-    actions.appendChild(fullscreenBtn);
-    header.appendChild(title);
-    header.appendChild(actions);
-    container.appendChild(header);
-
-    const canvas = document.createElement("canvas");
-    canvas.id = `chart-${name}-${index}`;
-    container.appendChild(canvas);
-
-    return { container, canvas };
-  },
-
-  renderChart(
-    parent,
-    name,
-    benchName,
-    dataset,
-    hiddenDatasets,
-    removedDatasets,
-    renamedDatasets,
-    index
-  ) {
-    const { container, canvas } = this.createChartContainer(
-      name,
-      benchName,
-      index
-    );
-    parent.appendChild(container);
-
-    // Store chart configuration for lazy loading
-    const chartConfig = {
-      canvas,
-      name,
-      benchName,
-      dataset,
-      hiddenDatasets,
-      removedDatasets,
-      renamedDatasets,
-      index,
-    };
-
-    // On mobile or when IntersectionObserver is available, use lazy loading
-    const isMobile = utils.isMobile();
-    if (isMobile && window.chartObserver) {
-      container.chartData = chartConfig;
-      window.chartObserver.observe(container);
-      return null; // Don't create chart immediately
-    }
-
-    // Otherwise create chart immediately
-    return this.createChartInstance(chartConfig);
-  },
-
-  createChartInstance(config) {
-    const {
-      canvas,
-      name,
-      benchName,
-      dataset,
-      hiddenDatasets,
-      removedDatasets,
-      renamedDatasets,
-      index,
-    } = config;
-
-    // On mobile, limit data points
-    const isMobile = utils.isMobile();
-    const maxDataPoints = isMobile
-      ? CONFIG.MOBILE_MAX_DATA_POINTS
-      : dataset.commits.length;
-    const startIndex = Math.max(0, dataset.commits.length - maxDataPoints);
-
-    const limitedCommits = dataset.commits.slice(startIndex);
-    const data = {
-      labels: limitedCommits.map((commit) => commit.id.slice(0, 7)),
-      datasets: Array.from(dataset.series)
-        .filter(([name, benches]) => {
-          return removedDatasets === undefined || !removedDatasets.has(name);
-        })
-        .map(([name, benches]) => {
-          const renamedName =
-            renamedDatasets === undefined
-              ? name
-              : renamedDatasets[name] || name;
-          const color = utils.stringToColor(renamedName);
-          // Convert object with numeric keys back to array
-          let benchesArray;
-          if (Array.isArray(benches)) {
-            benchesArray = benches;
-          } else if (benches && typeof benches === "object") {
-            // Convert object with numeric keys to array
-            const maxIndex = Math.max(
-              ...Object.keys(benches)
-                .map((k) => parseInt(k, 10))
-                .filter((n) => !isNaN(n))
-            );
-            benchesArray = new Array(maxIndex + 1);
-            for (let i = 0; i <= maxIndex; i++) {
-              benchesArray[i] = benches[i] || null;
-            }
-          } else {
-            benchesArray = [];
-          }
-          const limitedData = benchesArray.slice(startIndex);
-          return {
-            label: renamedName,
-            data: limitedData.map((b) => (b ? b.value : null)),
-            borderColor: color,
-            backgroundColor: color + "60", // Add alpha for #rrggbbaa
-            hidden:
-              (hiddenDatasets !== undefined && hiddenDatasets.has(name)) ||
-              name.toLowerCase().startsWith("wide table cols"),
-          };
-        }),
-    };
-
-    const options = this.createChartOptions(
-      name,
-      benchName,
-      dataset,
-      limitedCommits,
-      isMobile,
-      index
-    );
-
-    const chart = new Chart(canvas, {
-      type: "line",
-      data: data,
-      options: options,
-    });
-
-    const chartKey = `${name}-${index}`;
-    window.state.chartInstances.set(chartKey, { chart, data, options });
-
-    return chart;
-  },
-
-  createChartOptions(
-    categoryName,
-    benchName,
-    dataset,
-    limitedCommits,
-    isMobile,
-    index
-  ) {
-    const yAxisScale = this.createYAxisScale(benchName, dataset);
-
-    return {
-      responsive: true,
-      maintainAspectRatio: false,
-      aspectRatio: isMobile ? 1.5 : 2,
-      spanGaps: true,
-      pointStyle: isMobile ? false : "crossRot",
-      resizeDelay: 0, // Disable resize delay
-      elements: {
-        line: {
-          borderWidth: 1,
-          tension: 0,
-        },
-        point: {
-          radius: isMobile ? 0 : 3,
-        },
-      },
-      animation: false,
-      scales: {
-        x: {
-          title: {
-            display: true,
-            text: benchName,
-            padding: { bottom: 50 },
-          },
-          min: isMobile
-            ? 0 // Start from the beginning of the sliced data
-            : Math.max(
-                0,
-                dataset.commits.length - CONFIG.DEFAULT_VISIBLE_COMMITS
-              ),
-          max: isMobile
-            ? limitedCommits.length - 1 // Use the length of the sliced data
-            : undefined,
-        },
-        y: yAxisScale,
-      },
-      plugins: this.createPlugins(
-        categoryName,
-        isMobile,
-        limitedCommits,
-        index
-      ),
-      onClick: this.createClickHandler(limitedCommits),
-    };
-  },
-
-  createYAxisScale(benchName, dataset) {
-    const scale = {
-      title: {
-        display: true,
-        text: dataset.commits.length > 0 ? dataset.unit : "",
-      },
-      suggestedMin: 0,
-      beginAtZero: true, // Force chart to start at 0
-    };
-
-    if (
-      benchName.includes("COMPRESS") &&
-      benchName.includes("THROUGHPUT") &&
-      dataset.unit === "MiB/s"
-    ) {
-      scale.suggestedMax = CONFIG.COMPRESS_THROUGHPUT_MAX;
-      scale.max = CONFIG.COMPRESS_THROUGHPUT_MAX;
-    }
-
-    if (
-      benchName.includes("DECOMPRESS") &&
-      benchName.includes("THROUGHPUT") &&
-      dataset.unit === "MiB/s"
-    ) {
-      scale.suggestedMax = CONFIG.DECOMPRESS_THROUGHPUT_MAX;
-      scale.max = CONFIG.DECOMPRESS_THROUGHPUT_MAX;
-    }
-
-    return scale;
-  },
-
-  createPlugins(categoryName, isMobile, limitedCommits, index) {
-    return {
-      zoom: {
-        zoom: {
-          wheel: {
-            enabled: !isMobile,
-            speed: CONFIG.ZOOM_SPEED,
-            modifierKey: null,
-          },
-          mode: "x",
-          drag: {
-            enabled: !isMobile,
-            backgroundColor: "rgba(89, 113, 253, 0.1)",
-          },
-          onZoom: !isMobile
-            ? ({ chart }) => {
-                window.zoomSync.synchronizeZoomForCategory(
-                  categoryName,
-                  chart,
-                  index,
-                  true,
-                  window.state,
-                  window.utils
-                );
-              }
-            : undefined,
-        },
-        pan: {
-          enabled: !isMobile,
-          mode: "x",
-          modifierKey: null,
-          onPan: !isMobile
-            ? ({ chart }) => {
-                window.zoomSync.synchronizeZoomForCategory(
-                  categoryName,
-                  chart,
-                  index,
-                  false,
-                  window.state,
-                  window.utils
-                );
-              }
-            : undefined,
-        },
-        limits: {
-          x: {
-            min: 0,
-            max: limitedCommits.length - 1,
-            minRange: Math.min(
-              CONFIG.MIN_VISIBLE_COMMITS,
-              limitedCommits.length
-            ),
-          },
-        },
-      },
-      legend: {
-        display: true,
-        onClick: this.createLegendClickHandler(),
-      },
-      tooltip: {
-        callbacks: {
-          afterLabel: this.createTooltipCallback(limitedCommits),
-        },
-      },
-    };
-  },
-
-  createClickHandler(limitedCommits) {
-    return (event, elements) => {
-      if (elements.length > 0) {
-        const index = elements[0].index;
-        const commit = limitedCommits[index];
-        if (commit?.url) {
-          window.open(commit.url, "_blank");
-        }
-      }
-    };
-  },
-
-  createLegendClickHandler() {
-    return function (e, legendItem) {
-      const index = legendItem.datasetIndex;
-      const chart = this.chart;
-      const dataset = chart.data.datasets[index];
-      const datasetLabel = dataset.label;
-
-      // Toggle the clicked dataset
-      dataset.hidden = !dataset.hidden;
-
-      // Find the benchmark group name from the chart canvas
-      const canvas = chart.canvas;
-      const container = canvas.closest(".chart-container");
-      const benchmarkGroup = container?.getAttribute("data-benchmark");
-
-      if (benchmarkGroup) {
-        // Synchronize across all charts in the same benchmark group
-        window.state.chartInstances.forEach((chartData, key) => {
-          if (key.startsWith(benchmarkGroup + "-")) {
-            const otherChart = chartData.chart;
-            if (otherChart !== chart) {
-              // Find dataset with matching label
-              otherChart.data.datasets.forEach((ds) => {
-                if (ds.label === datasetLabel) {
-                  ds.hidden = dataset.hidden;
-                }
-              });
-              otherChart.update("none"); // Update without animation
-            }
-          }
-        });
-      }
-
-      chart.update();
-    };
-  },
-
-  createTooltipCallback(limitedCommits) {
-    return (context) => {
-      const dataIndex = context.dataIndex;
-      const commit = limitedCommits[dataIndex];
-      if (!commit) return [];
-
-      return [
-        "",
-        commit.message.split("\n")[0],
-        `${commit.author.name} - ${new Date(
-          commit.timestamp
-        ).toLocaleDateString()}`,
-      ];
-    };
-  },
-
-  openModal(benchmarkName, chartName, index) {
-    const modal = window.domElements.chartModal;
-    const modalCanvas = document.getElementById("modal-chart");
-
-    const chartKey = `${benchmarkName}-${index}`;
-    const originalChart = window.state.chartInstances.get(chartKey);
-    if (!originalChart) return;
-
-    const modalChart = new Chart(modalCanvas, {
-      type: "line",
-      data: JSON.parse(JSON.stringify(originalChart.data)),
-      options: {
-        ...originalChart.options,
-        maintainAspectRatio: false,
-        responsive: true,
-      },
-    });
-
-    modal.classList.add("active");
-    modal.modalChart = modalChart;
-  },
-
-  closeModal() {
-    const modal = window.domElements.chartModal;
-    if (modal.modalChart) {
-      modal.modalChart.destroy();
-      modal.modalChart = null;
-    }
-    modal.classList.remove("active");
-  },
-
-  cleanupCharts() {
-    window.state.chartInstances.forEach((chartData) => {
-      if (chartData?.chart) {
-        chartData.chart.destroy();
-      }
-    });
-    window.state.chartInstances.clear();
-    window.state.charts = [];
-  },
-
-  updateChartsForResize() {
-    // Prevent multiple simultaneous resize operations
-    if (window.state.isResizing) return;
-    window.state.isResizing = true;
-
-    const currentIsMobile = utils.isMobile();
-    const wasDesktop = window.state.lastWindowWidth > CONFIG.MOBILE_BREAKPOINT;
-    const isDesktop = window.innerWidth > CONFIG.MOBILE_BREAKPOINT;
-    const crossedThreshold =
-      (wasDesktop && !isDesktop) || (!wasDesktop && isDesktop);
-
-    // Update window width immediately
-    window.state.lastWindowWidth = window.innerWidth;
-
-    if (!crossedThreshold) {
-      // Simple resize - just update all charts
-      requestAnimationFrame(() => {
-        window.state.chartInstances.forEach((chartData) => {
-          if (chartData?.chart) {
-            chartData.chart.resize();
-            chartData.chart.update("none");
-          }
-        });
-        window.state.isResizing = false;
-      });
-      return;
-    }
-
-    // For threshold crossing, update chart options
-    requestAnimationFrame(() => {
-      // Update all charts
-      window.state.chartInstances.forEach((chartData, key) => {
-        if (chartData?.chart) {
-          const chart = chartData.chart;
-          const totalCommits = chart.data.labels.length;
-
-          // Store current state - deep clone y-axis to preserve all properties
-          const currentXMin = chart.options.scales.x.min;
-          const currentXMax = chart.options.scales.x.max;
-
-          // Store actual scale values before any changes
-          const actualYMin = chart.scales.y?.min;
-          const actualYMax = chart.scales.y?.max;
-
-          const currentYScale = JSON.parse(
-            JSON.stringify(chart.options.scales.y)
-          );
-
-          // Determine new x-axis bounds
-          let newXMin, newXMax;
-          if (currentIsMobile) {
-            // Show all data points on mobile (which is already limited)
-            newXMax = totalCommits - 1;
-            newXMin = 0; // Start from beginning of limited data
-          } else {
-            // Going to desktop - restore previous or use defaults
-            const wasShowingAllMobileData =
-              currentXMin === 0 && currentXMax === totalCommits - 1;
-            if (wasShowingAllMobileData) {
-              newXMin = Math.max(
-                0,
-                totalCommits - CONFIG.DEFAULT_VISIBLE_COMMITS
-              );
-              newXMax = totalCommits - 1;
-            } else {
-              newXMin = currentXMin;
-              newXMax = currentXMax;
-            }
-          }
-
-          // Update all options directly
-          chart.options.aspectRatio = currentIsMobile ? 1.5 : 2;
-          chart.options.pointStyle = currentIsMobile ? false : "crossRot";
-          chart.options.elements.point.radius = currentIsMobile ? 0 : 3;
-
-          // Update zoom settings
-          if (chart.options.plugins.zoom) {
-            const zoomEnabled = !currentIsMobile;
-            chart.options.plugins.zoom.zoom.wheel.enabled = zoomEnabled;
-            chart.options.plugins.zoom.zoom.pinch.enabled = zoomEnabled;
-            chart.options.plugins.zoom.zoom.drag.enabled = false;
-            chart.options.plugins.zoom.pan.enabled = zoomEnabled;
-          }
-
-          // Update x-axis only, preserve y-axis completely
-          chart.options.scales.x.min = newXMin;
-          chart.options.scales.x.max = newXMax;
-
-          // Ensure y-axis is preserved with all its properties
-          Object.keys(currentYScale).forEach((key) => {
-            chart.options.scales.y[key] = currentYScale[key];
-          });
-
-          // Force preserve critical y-axis properties
-          if (currentYScale.min !== undefined)
-            chart.options.scales.y.min = currentYScale.min;
-          if (currentYScale.max !== undefined)
-            chart.options.scales.y.max = currentYScale.max;
-          if (currentYScale.suggestedMin !== undefined)
-            chart.options.scales.y.suggestedMin = currentYScale.suggestedMin;
-          if (currentYScale.suggestedMax !== undefined)
-            chart.options.scales.y.suggestedMax = currentYScale.suggestedMax;
-
-          // If no explicit min/max in options, use the actual computed values
-          if (
-            chart.options.scales.y.min === undefined &&
-            actualYMin !== undefined
-          ) {
-            chart.options.scales.y.min = actualYMin;
-          }
-          if (
-            chart.options.scales.y.max === undefined &&
-            actualYMax !== undefined
-          ) {
-            chart.options.scales.y.max = actualYMax;
-          }
-
-          // Single update per chart
-          chart.update("none");
-        }
-      });
-
-      // Reset animation duration after update
-      setTimeout(() => {
-        window.state.chartInstances.forEach((chartData) => {
-          if (chartData?.chart) {
-            chartData.chart.options.animation.duration = currentIsMobile
-              ? 0
-              : CONFIG.ANIMATION_DURATION;
-          }
-        });
-      }, 100);
-
-      // Recreate debounced sync zoom with new delay
-      if (crossedThreshold && window.zoomSync) {
-        window.zoomSync.recreateDebouncedSync(window.state, utils);
-      }
-
-      window.state.isResizing = false;
-    });
-  },
-};
diff --git a/benchmarks-website/code.js b/benchmarks-website/code.js
deleted file mode 100644
index 2445788eda3..00000000000
--- a/benchmarks-website/code.js
+++ /dev/null
@@ -1,1315 +0,0 @@
-"use strict";
-
-// Import modules
-import { CONFIG, BENCHMARK_DESCRIPTIONS, CATEGORY_TAGS, SCALE_FACTOR_DESCRIPTIONS, ENGINE_LABELS } from './config.js';
-import { utils } from './utils.js';
-import { chartManager } from './chart-manager.js';
-import { scoring } from './scoring.js';
-import { zoomSync } from './zoom-sync.js';
-import { workerManager } from './worker-manager.js';
-
-// Fun rendering messages
-const RENDERING_MESSAGES = [
-  "Materializing charts from the data dimension...",
-  "Rendering graphs faster than light travels...",
-  "Drawing charts with the precision of Leonardo da Vinci...",
-  "Manifesting benchmarks from the quantum realm...",
-  "Generating plots like Bob Ross paints happy trees...",
-  "Building charts with the power of the One Ring...",
-  "Crafting visualizations like Tony Stark builds suits...",
-  "Assembling graphs with Voltron-like precision...",
-];
-
-function getRandomRenderingMessage() {
-  return RENDERING_MESSAGES[Math.floor(Math.random() * RENDERING_MESSAGES.length)];
-}
-
-// Main module
-window.initAndRender = (function () {
-  // State management
-  const state = {
-    currentView: "grid",
-    expandedSections: new Set(), // Start with all sections collapsed
-    activeCategory: "all",
-    activeTag: "all",
-    activeEngines: new Set(["all"]), // Changed to Set for multiple selections
-    searchTerm: "",
-    charts: [],
-    chartInstances: new Map(),
-    pendingZoomUpdates: new Map(),
-    lastWindowWidth: window.innerWidth,
-    isResizing: false,
-  };
-
-  // DOM element cache
-  const domElements = {};
-  let chartObserver = null;
-
-  // UI module
-  const ui = {
-    getTpchDescription(categoryName) {
-      const scaleFactorMatch = categoryName.match(/SF=(\d+)/);
-      const scaleFactor = scaleFactorMatch ? scaleFactorMatch[1] : null;
-      const scaleFactorInfo =
-        SCALE_FACTOR_DESCRIPTIONS[scaleFactor] || "various scale factors";
-
-      if (categoryName.includes("NVMe")) {
-        return `TPC-H benchmark queries executed on local NVMe storage, testing analytical query performance at ${scaleFactorInfo}`;
-      } else if (categoryName.includes("S3")) {
-        return `TPC-H benchmark queries executed against data stored in Amazon S3, measuring cloud storage query performance and the impact of network latency on analytical workloads at ${scaleFactorInfo}`;
-      }
-      return "";
-    },
-
-    getTpcdsDescription(categoryName) {
-      const scaleFactorMatch = categoryName.match(/SF=(\d+)/);
-      const scaleFactor = scaleFactorMatch ? scaleFactorMatch[1] : null;
-      const scaleFactorInfo =
-        SCALE_FACTOR_DESCRIPTIONS[scaleFactor] || "various scale factors";
-
-      if (categoryName.includes("NVMe")) {
-        return `TPC-DS benchmark queries executed on local NVMe storage, testing complex analytical query performance with a retail sales dataset at ${scaleFactorInfo}`;
-      } else if (categoryName.includes("S3")) {
-        return `TPC-DS benchmark queries executed against data stored in Amazon S3, measuring cloud storage query performance for complex retail analytics workloads at ${scaleFactorInfo}`;
-      }
-      return "";
-    },
-
-    getDescription(categoryName) {
-      if (categoryName.startsWith("TPC-H")) {
-        return this.getTpchDescription(categoryName);
-      } else if (categoryName.startsWith("TPC-DS")) {
-        return this.getTpcdsDescription(categoryName);
-      }
-      const baseCategory = categoryName.split(" (")[0];
-      return BENCHMARK_DESCRIPTIONS[baseCategory] || "";
-    },
-
-    benchmarkGroupHasData(benchSet) {
-      if (!benchSet || benchSet.size === 0) return false;
-
-      // Check if any query in the benchmark set has data
-      for (const [queryName, queryData] of benchSet.entries()) {
-        if (!queryData.series || queryData.series.size === 0) continue;
-
-        // Check if any series has any non-null data
-        for (const [seriesName, seriesData] of queryData.series.entries()) {
-          for (let i = 0; i < seriesData.length; i++) {
-            if (seriesData[i] && seriesData[i].value !== null && seriesData[i].value !== undefined) {
-              return true;
-            }
-          }
-        }
-      }
-
-      return false;
-    },
-
-    createBenchmarkSection(name, benchSet, groupFilterSettings = {}) {
-      const { keptCharts, hiddenDatasets, removedDatasets, renamedDatasets } =
-        groupFilterSettings;
-
-      const section = document.createElement("div");
-      section.className = "benchmark-set";
-      section.setAttribute("data-category", name);
-
-      // Check if this benchmark group has any data
-      const hasData = this.benchmarkGroupHasData(benchSet);
-      if (!hasData) {
-        section.classList.add("no-data");
-      }
-
-      // Create wrapper for sticky header to maintain space
-      const stickyWrapper = document.createElement("div");
-      stickyWrapper.className = "sticky-header-wrapper";
-
-      // Create sticky header container
-      const stickyContainer = document.createElement("div");
-      stickyContainer.className = "sticky-header-container";
-
-      // Add header
-      const header = this.createSectionHeader(name, benchSet, keptCharts);
-      stickyContainer.appendChild(header);
-
-      // Add controls
-      const controls = this.createSectionControls(name);
-      if (controls) {
-        stickyContainer.appendChild(controls);
-      }
-
-      stickyWrapper.appendChild(stickyContainer);
-      section.appendChild(stickyWrapper);
-
-      // Add scoring summary for query benchmarks (after sticky container)
-      if (scoring.isQueryBenchmark(name) && benchSet) {
-        const scores = scoring.calculateClickBenchScore(benchSet);
-        const scoreSummary = scoring.formatScoresSummary(scores);
-        if (scoreSummary) {
-          section.appendChild(scoreSummary);
-        }
-      }
-
-      // Add summary for Random Access benchmarks
-      if (scoring.isRandomAccessBenchmark(name) && benchSet) {
-        const metrics = scoring.calculateRandomAccessMetrics(benchSet);
-        const metricsSummary = scoring.formatRandomAccessSummary(metrics);
-        if (metricsSummary) {
-          section.appendChild(metricsSummary);
-        }
-      }
-
-      // Add summary for Compression benchmarks
-      if (scoring.isCompressionBenchmark(name) && benchSet) {
-        const metrics = scoring.calculateCompressionMetrics(benchSet);
-        const metricsSummary = scoring.formatCompressionSummary(metrics);
-        if (metricsSummary) {
-          section.appendChild(metricsSummary);
-        }
-      }
-
-      // Add summary for Compression Size benchmarks
-      if (scoring.isCompressionSizeBenchmark(name) && benchSet) {
-        const metrics = scoring.calculateCompressionSizeMetrics(benchSet);
-        const metricsSummary = scoring.formatCompressionSizeSummary(metrics);
-        if (metricsSummary) {
-          section.appendChild(metricsSummary);
-        }
-      }
-
-      // Add charts container
-      const chartsContainer = document.createElement("div");
-      chartsContainer.className = "benchmark-graphs";
-
-      // Add single-chart class if there's only one chart
-      const chartCount = keptCharts ? keptCharts.length : benchSet?.size || 0;
-      if (chartCount === 1) {
-        chartsContainer.classList.add("single-chart");
-      }
-
-      section.appendChild(chartsContainer);
-
-      // Collapse by default
-      section.classList.add("collapsed");
-
-      return { section, chartsContainer };
-    },
-
-    createSectionHeader(name, benchSet, keptCharts) {
-      const h1id = name.replace(/\s+/g, "_");
-
-      const header = document.createElement("div");
-      header.className = "benchmark-header";
-
-      // Check if the parent section has the no-data class
-      const section = document.querySelector(`[data-category="${name}"]`);
-      const hasNoData = section && section.classList.contains("no-data");
-
-      if (!hasNoData) {
-        header.onclick = (e) => {
-          // Don't toggle if clicking on info icon
-          if (!e.target.closest(".info-icon")) {
-            this.toggleSection(name);
-          }
-        };
-      }
-
-      const titleWrapper = document.createElement("div");
-      titleWrapper.className = "title-wrapper";
-
-      const title = document.createElement("h1");
-      title.id = h1id;
-      title.className = "benchmark-title";
-      title.innerHTML = `<span class="collapse-icon">▼</span> ${name}`;
-
-      // Create a secondary container for link, info, and charts count
-      const secondaryInfo = document.createElement("div");
-      secondaryInfo.className = "benchmark-secondary-info";
-
-      const linkBtn = document.createElement("button");
-      linkBtn.className = "group-link-btn";
-      linkBtn.setAttribute("aria-label", "Copy link to this section");
-      linkBtn.innerHTML = "🔗";
-      linkBtn.onclick = (e) => {
-        e.stopPropagation();
-        this.linkToGroup(name);
-      };
-      secondaryInfo.appendChild(linkBtn);
-
-      // Add info icon with tooltip
-      const description = this.getDescription(name);
-      if (description) {
-        const infoIcon = document.createElement("div");
-        infoIcon.className = "info-icon";
-        infoIcon.innerHTML = "ⓘ";
-        infoIcon.setAttribute("data-tooltip", description);
-        secondaryInfo.appendChild(infoIcon);
-      }
-
-      const meta = document.createElement("div");
-      meta.className = "benchmark-meta";
-      const chartCount = keptCharts ? keptCharts.length : benchSet?.size || 0;
-
-      // Check if the parent section has the no-data class
-      const sectionHasNoData = section && section.classList.contains("no-data");
-      if (sectionHasNoData) {
-        meta.textContent = "No data available";
-      } else {
-        meta.textContent = `${chartCount} charts`;
-      }
-      secondaryInfo.appendChild(meta);
-
-      titleWrapper.appendChild(title);
-      titleWrapper.appendChild(secondaryInfo);
-
-      header.appendChild(titleWrapper);
-
-      return header;
-    },
-
-    createSectionControls(name) {
-      const tags = CATEGORY_TAGS[name] || [];
-      const isQueryGroup = tags.some((tag) => tag.includes("Queries"));
-
-      const container = document.createElement("div");
-      container.className = "engine-filter-container";
-
-      if (isQueryGroup) {
-        const label = document.createElement("span");
-        label.className = "engine-filter-label";
-        label.textContent = "Show: ";
-        container.appendChild(label);
-
-        Object.entries(ENGINE_LABELS).forEach(([engine, label]) => {
-          const btn = document.createElement("button");
-          btn.className =
-            "engine-filter-btn" +
-            (state.activeEngines.has(engine) ? " active" : "");
-          btn.textContent = label;
-          btn.setAttribute("data-engine", engine);
-          btn.setAttribute("data-category", name);
-          btn.onclick = () => this.filterEngine(name, engine);
-          container.appendChild(btn);
-        });
-
-        const separator = document.createElement("span");
-        separator.className = "filter-separator";
-        separator.textContent = "|";
-        container.appendChild(separator);
-      }
-
-      const resetBtn = document.createElement("button");
-      resetBtn.className = "reset-zoom-btn";
-      resetBtn.textContent = "Reset X-Axis";
-      resetBtn.setAttribute("data-category", name);
-      resetBtn.onclick = () => window.zoomSync.resetZoomForCategory(name, state, utils, CONFIG);
-      container.appendChild(resetBtn);
-
-      return container;
-    },
-
-    toggleSection(name) {
-      const section = document.querySelector(`[data-category="${name}"]`);
-      if (!section) return;
-
-      // Don't toggle if section has no data
-      if (section.classList.contains("no-data")) return;
-
-      if (state.expandedSections.has(name)) {
-        state.expandedSections.delete(name);
-        section.classList.add("collapsed");
-      } else {
-        state.expandedSections.add(name);
-        section.classList.remove("collapsed");
-      }
-    },
-
-    linkToGroup(name) {
-      urlManager.updateParams({ group: name });
-
-      const targetSection = document.querySelector(`[data-category="${name}"]`);
-
-      navigator.clipboard.writeText(window.location.href).then(() => {
-        if (targetSection) {
-          const linkBtn = targetSection.querySelector(".group-link-btn");
-          if (linkBtn) {
-            const originalText = linkBtn.innerHTML;
-            linkBtn.innerHTML = "✓";
-            linkBtn.classList.add("copied");
-            setTimeout(() => {
-              linkBtn.innerHTML = originalText;
-              linkBtn.classList.remove("copied");
-            }, CONFIG.LINK_FEEDBACK_DURATION);
-          }
-        }
-      });
-    },
-
-    filterEngine(categoryName, engine) {
-      // Handle "all" button specially
-      if (engine === "all") {
-        state.activeEngines.clear();
-        state.activeEngines.add("all");
-      } else {
-        // Remove "all" if selecting specific engine
-        if (state.activeEngines.has("all")) {
-          state.activeEngines.clear();
-        }
-
-        // Toggle the selected engine
-        if (state.activeEngines.has(engine)) {
-          state.activeEngines.delete(engine);
-          // If no engines selected, revert to "all"
-          if (state.activeEngines.size === 0) {
-            state.activeEngines.add("all");
-          }
-        } else {
-          state.activeEngines.add(engine);
-        }
-      }
-
-      // Update URL with comma-separated engines
-      const engineParam = state.activeEngines.has("all")
-        ? "all"
-        : Array.from(state.activeEngines).join(",");
-      urlManager.updateParams({ engine: engineParam });
-
-      // Update all engine filter buttons
-      document
-        .querySelectorAll(".engine-filter-container")
-        .forEach((container) => {
-          container.querySelectorAll(".engine-filter-btn").forEach((btn) => {
-            const btnEngine = btn.getAttribute("data-engine");
-            btn.classList.toggle("active", state.activeEngines.has(btnEngine));
-          });
-        });
-
-      // Apply filter to charts
-      this.applyEngineFilter();
-    },
-
-    applyEngineFilter() {
-      document.querySelectorAll(".benchmark-set").forEach((section) => {
-        const category = section.getAttribute("data-category");
-        const tags = CATEGORY_TAGS[category] || [];
-        const isQueryGroup = tags.some((tag) => tag.includes("Queries"));
-
-        if (isQueryGroup) {
-          const containers = section.querySelectorAll(".chart-container");
-          containers.forEach((container, index) => {
-            const chartKey = `${category}-${index}`;
-            const chartData = state.chartInstances.get(chartKey);
-
-            if (chartData?.chart) {
-              this.updateChartVisibility(chartData.chart);
-            }
-          });
-        }
-      });
-    },
-
-    updateChartVisibility(chart) {
-      const updates = [];
-
-      chart.data.datasets.forEach((dataset, index) => {
-        const label = dataset.label.toLowerCase();
-
-        // Check if dataset should be visible based on selected engines
-        const shouldShow =
-          state.activeEngines.has("all") ||
-          Array.from(state.activeEngines).some((engine) =>
-            label.includes(engine)
-          );
-
-        if (chart.isDatasetVisible(index) !== shouldShow) {
-          updates.push({ index, visible: shouldShow });
-        }
-      });
-
-      if (updates.length > 0) {
-        updates.forEach(({ index, visible }) => {
-          chart.setDatasetVisibility(index, visible);
-        });
-        chart.update("none");
-      }
-    },
-
-    setView(view) {
-      state.currentView = view;
-      document.querySelectorAll(".benchmark-graphs").forEach((graphs) => {
-        graphs.classList.toggle("list-view", view === "list");
-      });
-
-      document.querySelectorAll(".view-btn").forEach((btn) => {
-        btn.classList.remove("active");
-      });
-      document.getElementById(`${view}-view`).classList.add("active");
-    },
-  };
-
-  // URL management module
-  const urlManager = {
-    getParams() {
-      const params = new URLSearchParams(window.location.search);
-      return {
-        tag: params.get("tag") || "all",
-        engine: params.get("engine") || "all",
-        expanded: params.get("expanded") || "false",
-        group: params.get("group") || null,
-      };
-    },
-
-    updateParams(updates) {
-      const params = new URLSearchParams(window.location.search);
-
-      Object.entries(updates).forEach(([key, value]) => {
-        if (
-          value &&
-          value !== "all" &&
-          !(key === "expanded" && value === "false")
-        ) {
-          params.set(key, value);
-        } else {
-          params.delete(key);
-        }
-      });
-
-      const newURL =
-        window.location.pathname +
-        (params.toString() ? "?" + params.toString() : "");
-      window.history.replaceState({}, "", newURL);
-    },
-
-    initializeFromParams() {
-      const params = this.getParams();
-
-      state.activeTag = params.tag;
-
-      // Handle comma-separated engines
-      if (params.engine && params.engine !== "all") {
-        const engines = params.engine.split(",");
-        state.activeEngines.clear();
-        engines.forEach((engine) => state.activeEngines.add(engine.trim()));
-      }
-
-      const categoryFilter = domElements.categoryFilter;
-      if (categoryFilter) {
-        categoryFilter.value = params.tag;
-        filterManager.filterByTag(params.tag);
-      }
-
-      if (params.engine !== "all") {
-        ui.applyEngineFilter();
-      }
-
-      if (params.group) {
-        setTimeout(() => {
-          navigationManager.focusOnGroup(params.group);
-        }, CONFIG.URL_INIT_DELAY);
-      } else if (params.expanded === "true") {
-        navigationManager.expandAll();
-      }
-    },
-  };
-
-  // Filter management module
-  const filterManager = {
-    filterByTag(tag) {
-      state.activeTag = tag;
-      urlManager.updateParams({ tag });
-
-      // Filter sections
-      document.querySelectorAll(".benchmark-set").forEach((section) => {
-        const category = section.getAttribute("data-category");
-        const tags = CATEGORY_TAGS[category] || [];
-        section.style.display =
-          tag === "all" || tags.includes(tag) ? "block" : "none";
-      });
-
-      // Filter navigation
-      document.querySelectorAll(".toc-list li").forEach((navItem) => {
-        const link = navItem.querySelector("a");
-        if (link) {
-          const targetId = link.getAttribute("href").substring(1);
-          const targetSection = document.getElementById(targetId);
-
-          if (targetSection?.closest(".benchmark-set")) {
-            const category = targetSection
-              .closest(".benchmark-set")
-              .getAttribute("data-category");
-            const tags = CATEGORY_TAGS[category] || [];
-            navItem.style.display =
-              tag === "all" || tags.includes(tag) ? "block" : "none";
-          }
-        }
-      });
-
-      // Update clear filter button
-      const clearBtn = domElements.clearFilter;
-      if (clearBtn) {
-        clearBtn.style.display = tag === "all" ? "none" : "block";
-        clearBtn.textContent = tag === "all" ? "" : `Clear Filter: ${tag}`;
-      }
-    },
-
-    filterBySearch(term) {
-      state.searchTerm = term.toLowerCase();
-
-      document.querySelectorAll(".chart-container").forEach((chart) => {
-        const benchmarkName = chart
-          .getAttribute("data-benchmark")
-          .toLowerCase();
-        const chartName = chart.getAttribute("data-chart").toLowerCase();
-        const matches =
-          benchmarkName.includes(state.searchTerm) ||
-          chartName.includes(state.searchTerm);
-        chart.style.display = matches ? "block" : "none";
-      });
-
-      // Then, hide sections that have no visible charts
-      document.querySelectorAll(".benchmark-set").forEach((section) => {
-        const visibleCharts = section.querySelectorAll(
-          ".chart-container[style='display: block;'], .chart-container:not([style]), .chart-container[style='']"
-        );
-        section.style.display = visibleCharts.length > 0 ? "block" : "none";
-      });
-    },
-  };
-
-  // Navigation management module
-  const navigationManager = {
-    expandAll() {
-      const sections = document.querySelectorAll(".benchmark-set");
-      const updates = [];
-
-      sections.forEach((section) => {
-        // Skip sections with no data
-        if (section.classList.contains("no-data")) return;
-
-        const category = section.getAttribute("data-category");
-        state.expandedSections.add(category);
-        if (section.classList.contains("collapsed")) {
-          updates.push(() => section.classList.remove("collapsed"));
-        }
-      });
-
-      utils.batchDOMUpdates(updates);
-      urlManager.updateParams({ expanded: "true" });
-    },
-
-    collapseAll() {
-      const sections = document.querySelectorAll(".benchmark-set");
-      const updates = [];
-
-      sections.forEach((section) => {
-        const category = section.getAttribute("data-category");
-        state.expandedSections.delete(category);
-        if (!section.classList.contains("collapsed")) {
-          updates.push(() => section.classList.add("collapsed"));
-        }
-      });
-
-      utils.batchDOMUpdates(updates);
-      urlManager.updateParams({ expanded: "false" });
-    },
-
-    focusOnGroup(groupName) {
-      // Find target section
-      const targetSection = document.querySelector(
-        `[data-category="${groupName}"]`
-      );
-      if (targetSection) {
-        // Just scroll to the section without expanding it
-        // The user can click to expand if they want to see the charts
-
-        // Close sidebar after navigation on mobile
-        if (utils.isMobile()) {
-          domElements.sidebar.classList.remove("active");
-        }
-
-        // Scroll to section
-        const targetId = targetSection.querySelector(".benchmark-title").id;
-        const targetElement = document.getElementById(targetId);
-        const headerHeight =
-          document.querySelector(".sticky-header").offsetHeight;
-        const elementPosition =
-          targetElement.getBoundingClientRect().top + window.pageYOffset;
-        const offsetPosition =
-          elementPosition - headerHeight - CONFIG.SCROLL_OFFSET_PADDING;
-
-        window.scrollTo({
-          top: offsetPosition,
-          behavior: "smooth",
-        });
-
-        this.updateActiveNavItem(targetId);
-      }
-    },
-
-    updateActiveNavItem(id) {
-      document.querySelectorAll(".toc-list a").forEach((link) => {
-        link.classList.toggle("active", link.getAttribute("href") === `#${id}`);
-      });
-    },
-
-    handleScroll() {
-      const scrollY = window.scrollY;
-      domElements.backToTop.classList.toggle(
-        "visible",
-        scrollY > CONFIG.BACK_TO_TOP_THRESHOLD
-      );
-
-      // Update active nav item
-      const sections = document.querySelectorAll(".benchmark-set");
-      let current = "";
-
-      sections.forEach((section) => {
-        const rect = section.getBoundingClientRect();
-        if (rect.top <= CONFIG.SCROLL_ACTIVE_THRESHOLD) {
-          current = section.querySelector(".benchmark-title").id;
-        }
-      });
-
-      if (current) {
-        this.updateActiveNavItem(current);
-      }
-    },
-  };
-
-  // Initialization module
-  const initializer = {
-    async loadData() {
-      const [dataResponse, commitsResponse] = await Promise.all([
-        this.fetchAndParseGzippedJsonl(
-          "https://vortex-benchmark-results-database.s3.amazonaws.com/data.json.gz"
-        ),
-        fetch(
-          "https://vortex-benchmark-results-database.s3.amazonaws.com/commits.json"
-        ).then((r) => r.text()),
-      ]);
-
-      // Return parsed data for worker processing
-      // dataResponse is now an array of parsed objects instead of a string
-      return {
-        benchmarkData: dataResponse,
-        commitsData: commitsResponse
-      };
-    },
-
-    async fetchAndParseGzippedJsonl(url) {
-      const response = await fetch(url);
-      const decompressedStream = response.body.pipeThrough(
-        new DecompressionStream("gzip")
-      );
-      const reader = decompressedStream.getReader();
-      const decoder = new TextDecoder();
-
-      let buffer = '';
-      const lines = [];
-
-      while (true) {
-        const { done, value } = await reader.read();
-
-        if (value) {
-          buffer += decoder.decode(value, { stream: true });
-
-          // Process complete lines
-          const parts = buffer.split('\n');
-          // Keep the last part (incomplete line) in the buffer
-          buffer = parts.pop();
-
-          // Parse and collect complete lines
-          for (const line of parts) {
-            const trimmed = line.trim();
-            if (trimmed.length > 0) {
-              try {
-                lines.push(JSON.parse(trimmed));
-              } catch (e) {
-                console.warn('Failed to parse JSONL line:', trimmed, e);
-              }
-            }
-          }
-        }
-
-        if (done) {
-          // Process any remaining buffer
-          buffer += decoder.decode();
-          const trimmed = buffer.trim();
-          if (trimmed.length > 0) {
-            try {
-              lines.push(JSON.parse(trimmed));
-            } catch (e) {
-              console.warn('Failed to parse final JSONL line:', trimmed, e);
-            }
-          }
-          break;
-        }
-      }
-
-      return lines;
-    },
-
-    parseJsonl(jsonl) {
-      return jsonl
-        .split("\n")
-        .filter((line) => line.trim().length !== 0)
-        .map((line) => JSON.parse(line));
-    },
-
-    updateLoadingProgress(progress, message) {
-      const main = domElements.main || document.getElementById("main");
-      const loadingIndicator = main.querySelector('.loading-indicator');
-
-      if (loadingIndicator) {
-        const progressText = loadingIndicator.querySelector('p');
-        if (progressText) {
-          progressText.textContent = `${message} (${Math.round(progress)}%)`;
-        }
-      }
-    },
-
-    initializeControls() {
-      // Cache DOM elements
-      const elementIds = [
-        "menu-toggle",
-        "sidebar",
-        "sidebar-close",
-        "sidebar-overlay",
-        "expand-all",
-        "collapse-all",
-        "grid-view",
-        "list-view",
-        "category-filter",
-        "clear-filter",
-        "search-filter",
-        "back-to-top",
-        "modal-close",
-        "chart-modal",
-        "main",
-        "toc",
-      ];
-
-      elementIds.forEach((id) => {
-        const camelCaseId = id.replace(/-(.)/g, (_match, char) =>
-          char.toUpperCase()
-        );
-        domElements[camelCaseId] = document.getElementById(id);
-      });
-
-      // Initialize sidebar state on desktop
-      if (window.innerWidth >= 1200) {
-        const sidebarPref = localStorage.getItem("sidebarCollapsed");
-        if (domElements.sidebar) {
-          // Set default to collapsed (true) on first visit
-          if (sidebarPref === null) {
-            localStorage.setItem("sidebarCollapsed", "true");
-          }
-
-          // Apply saved preference
-          if (sidebarPref === "false") {
-            // User previously opened sidebar via toggle
-            domElements.sidebar.classList.remove("collapsed");
-            domElements.sidebar.classList.add("open");
-          } else {
-            // Default collapsed or user previously closed it via toggle
-            domElements.sidebar.classList.add("collapsed");
-            domElements.sidebar.classList.remove("open");
-          }
-        }
-      }
-
-      // Initialize chart observer for lazy loading
-      if ("IntersectionObserver" in window) {
-        chartObserver = new IntersectionObserver(
-          (entries) => {
-            entries.forEach((entry) => {
-              if (entry.isIntersecting) {
-                const container = entry.target;
-                if (!container.hasAttribute("data-chart-loaded")) {
-                  container.setAttribute("data-chart-loaded", "true");
-                  const chartData = container.chartData;
-                  if (chartData) {
-                    chartManager.createChartInstance(chartData);
-                  }
-                }
-              }
-            });
-          },
-          {
-            rootMargin: CONFIG.CHART_OBSERVER_MARGIN,
-          }
-        );
-
-        // Initialize sticky header observer
-        const stickyObserver = new IntersectionObserver(
-          (entries) => {
-            entries.forEach((entry) => {
-              const stickyContainer = entry.target.querySelector(
-                ".sticky-header-container"
-              );
-              if (stickyContainer) {
-                if (entry.intersectionRatio < 1) {
-                  stickyContainer.classList.add("is-stuck");
-                } else {
-                  stickyContainer.classList.remove("is-stuck");
-                }
-              }
-            });
-          },
-          {
-            threshold: [1],
-            rootMargin: "-72px 0px 0px 0px", // Adjust based on header height
-          }
-        );
-
-        // Observe all sticky header wrappers after DOM is ready
-        setTimeout(() => {
-          document.querySelectorAll(".sticky-header-wrapper").forEach((wrapper) => {
-            stickyObserver.observe(wrapper);
-          });
-        }, 100);
-      }
-
-      // Make chartObserver globally available for modules
-      window.chartObserver = chartObserver;
-
-      // Initialize zoom sync
-      zoomSync.init(state, utils);
-
-      // Set up event listeners
-      this.setupEventListeners();
-    },
-
-    setupEventListeners() {
-      // Sidebar toggle (for both mobile and desktop)
-      domElements.menuToggle.addEventListener("click", () => {
-        const isDesktop = window.innerWidth >= 1200;
-        if (isDesktop) {
-          // On desktop, toggle collapsed state
-          domElements.sidebar.classList.toggle("collapsed");
-          domElements.sidebar.classList.toggle("open");
-
-          // Save preference to localStorage
-          const isCollapsed =
-            domElements.sidebar.classList.contains("collapsed");
-          localStorage.setItem("sidebarCollapsed", isCollapsed.toString());
-        } else {
-          // On mobile/tablet, toggle active state
-          domElements.sidebar.classList.toggle("active");
-        }
-      });
-
-      domElements.sidebarClose.addEventListener("click", () => {
-        const isDesktop = window.innerWidth >= 1200;
-        if (isDesktop) {
-          domElements.sidebar.classList.add("collapsed");
-          domElements.sidebar.classList.remove("open");
-          localStorage.setItem("sidebarCollapsed", "true");
-        } else {
-          domElements.sidebar.classList.remove("active");
-        }
-      });
-
-      // Sidebar overlay click (mobile and desktop) - only closes, doesn't toggle
-      domElements.sidebarOverlay.addEventListener("click", () => {
-        const isDesktop = window.innerWidth >= 1200;
-        if (isDesktop) {
-          // On desktop, close sidebar (don't toggle, just close)
-          domElements.sidebar.classList.add("collapsed");
-          domElements.sidebar.classList.remove("open");
-          localStorage.setItem("sidebarCollapsed", "true");
-        } else {
-          // On mobile/tablet, remove active state
-          domElements.sidebar.classList.remove("active");
-        }
-      });
-
-      // Expand/Collapse
-      domElements.expandAll.addEventListener("click", () =>
-        navigationManager.expandAll()
-      );
-      domElements.collapseAll.addEventListener("click", () =>
-        navigationManager.collapseAll()
-      );
-
-      // View controls
-      domElements.gridView.addEventListener("click", () => ui.setView("grid"));
-      domElements.listView.addEventListener("click", () => ui.setView("list"));
-
-      // Filters
-      domElements.categoryFilter.addEventListener("change", (e) => {
-        filterManager.filterByTag(e.target.value);
-      });
-
-      domElements.clearFilter.addEventListener("click", () => {
-        domElements.categoryFilter.value = "all";
-        filterManager.filterByTag("all");
-        urlManager.updateParams({ tag: "all" });
-      });
-
-      const debouncedSearch = utils.debounce(
-        (term) => filterManager.filterBySearch(term),
-        CONFIG.SEARCH_DEBOUNCE
-      );
-      domElements.searchFilter.addEventListener("input", (e) => {
-        debouncedSearch(e.target.value);
-      });
-
-      // Scroll handling
-      const throttledScroll = utils.throttle(
-        () => navigationManager.handleScroll(),
-        CONFIG.THROTTLE_SCROLL
-      );
-      window.addEventListener("scroll", throttledScroll);
-
-      domElements.backToTop.addEventListener("click", () => {
-        window.scrollTo({ top: 0, behavior: "smooth" });
-      });
-
-      // Modal
-      domElements.modalClose.addEventListener("click", () =>
-        chartManager.closeModal()
-      );
-      domElements.chartModal.addEventListener("click", (e) => {
-        if (e.target.id === "chart-modal") {
-          chartManager.closeModal();
-        }
-      });
-
-      // Outside click for sidebar on mobile only
-      document.addEventListener("click", (e) => {
-        if (
-          utils.isMobile() &&
-          !domElements.sidebar.contains(e.target) &&
-          !domElements.menuToggle.contains(e.target) &&
-          domElements.sidebar.classList.contains("active")
-        ) {
-          domElements.sidebar.classList.remove("active");
-        }
-      });
-
-      // Window resize handler
-      const debouncedResize = utils.debounce(() => {
-        chartManager.updateChartsForResize();
-
-        const isDesktop = window.innerWidth >= 1200;
-        const wasDesktop = state.lastWindowWidth >= 1200;
-
-        // Handle sidebar state when crossing desktop/mobile threshold
-        if (wasDesktop && !isDesktop) {
-          // Moving from desktop to mobile
-          domElements.sidebar.classList.remove("collapsed");
-          domElements.sidebar.classList.remove("active");
-        } else if (!wasDesktop && isDesktop) {
-          // Moving from mobile to desktop
-          domElements.sidebar.classList.remove("active");
-          // Restore saved collapsed state
-          const sidebarPref = localStorage.getItem("sidebarCollapsed");
-          // Set default to collapsed (true) on first visit
-          if (sidebarPref === null) {
-            localStorage.setItem("sidebarCollapsed", "true");
-          }
-
-          // Apply saved preference
-          if (sidebarPref === "false") {
-            domElements.sidebar.classList.remove("collapsed");
-            domElements.sidebar.classList.add("open");
-          } else {
-            domElements.sidebar.classList.add("collapsed");
-            domElements.sidebar.classList.remove("open");
-          }
-        }
-
-        // Update last window width
-        state.lastWindowWidth = window.innerWidth;
-      }, CONFIG.RESIZE_DEBOUNCE);
-
-      window.addEventListener("resize", debouncedResize);
-    },
-  };
-
-  // Async function to render all benchmark sets with batching
-  async function renderBenchmarkSetsAsync(grouped, main, toc, keptGroups) {
-    const batchSize = 1; // Render 1 benchmark set at a time for maximum responsiveness
-    let currentBatch = 0;
-    let totalSets = 0;
-
-    // Determine what we're rendering
-    let renderQueue = [];
-    if (keptGroups === undefined) {
-      renderQueue = grouped.map(({ name, dataSet }) => ({ name, dataSet, groupFilterSettings: {} }));
-    } else {
-      const dataSetsMap = new Map(
-        grouped.map(({ name, dataSet }) => [name, dataSet])
-      );
-      renderQueue = keptGroups.map(([name, groupFilterSettings]) => ({
-        name,
-        dataSet: dataSetsMap.get(name),
-        groupFilterSettings
-      }));
-    }
-
-    totalSets = renderQueue.length;
-
-    // Process in batches
-    for (let i = 0; i < renderQueue.length; i += batchSize) {
-      const batch = renderQueue.slice(i, i + batchSize);
-
-      // Render this batch
-      for (const { name, dataSet, groupFilterSettings } of batch) {
-        // Add placeholder while rendering
-        const placeholder = document.createElement('div');
-        placeholder.className = 'benchmark-placeholder';
-        placeholder.innerHTML = `
-          <div class="benchmark-header">
-            <div class="title-wrapper">
-              <h1 class="benchmark-title">
-                <span class="collapse-icon">▼</span> ${name}
-              </h1>
-              <div class="benchmark-secondary-info">
-                <div class="benchmark-meta">Loading...</div>
-              </div>
-            </div>
-          </div>
-        `;
-        main.appendChild(placeholder);
-
-        await renderBenchmarkSet(name, dataSet, main, toc, groupFilterSettings);
-
-        // Remove placeholder after rendering
-        if (placeholder.parentNode) {
-          placeholder.remove();
-        }
-
-        currentBatch++;
-      }
-
-      // Update progress and yield control after each batch
-      const progress = (currentBatch / totalSets) * 100;
-      const progressElement = document.getElementById('rendering-progress');
-      if (progressElement) {
-        progressElement.textContent = `${getRandomRenderingMessage()} ${currentBatch}/${totalSets} (${Math.round(progress)}%)`;
-      }
-
-      if (i + batchSize < renderQueue.length) {
-        // Yield control to prevent UI freezing
-        await new Promise(resolve => setTimeout(resolve, 0));
-      }
-    }
-  }
-
-  // Async render benchmark set function
-  async function renderBenchmarkSet(
-    name,
-    benchSet,
-    main,
-    toc,
-    groupFilterSettings = {}
-  ) {
-    const { section, chartsContainer } = ui.createBenchmarkSection(
-      name,
-      benchSet,
-      groupFilterSettings
-    );
-
-    // Add fade-in animation effect
-    section.style.opacity = '0';
-    section.style.transform = 'translateY(20px)';
-    section.style.transition = 'opacity 0.3s ease-out, transform 0.3s ease-out';
-
-    main.appendChild(section);
-
-    // Trigger fade-in animation
-    requestAnimationFrame(() => {
-      section.style.opacity = '1';
-      section.style.transform = 'translateY(0)';
-    });
-
-    // Create TOC entry
-    const tocLi = document.createElement("li");
-    const tocLink = document.createElement("a");
-    const h1id = name.replace(/\s+/g, "_");
-    tocLink.href = "#" + h1id;
-    tocLink.innerHTML = name;
-    tocLink.onclick = (e) => {
-      e.preventDefault();
-
-      // Auto-expand the section if it's collapsed (but not if it has no data)
-      const targetSection = document.querySelector(`[data-category="${name}"]`);
-      if (targetSection && targetSection.classList.contains("collapsed") && !targetSection.classList.contains("no-data")) {
-        state.expandedSections.add(name);
-        targetSection.classList.remove("collapsed");
-      }
-
-      // Close sidebar after navigation on mobile
-      if (utils.isMobile()) {
-        domElements.sidebar.classList.remove("active");
-      }
-
-      const targetElement = document.getElementById(h1id);
-      const headerHeight =
-        document.querySelector(".sticky-header").offsetHeight;
-      const elementPosition =
-        targetElement.getBoundingClientRect().top + window.pageYOffset;
-      const offsetPosition =
-        elementPosition - headerHeight - CONFIG.SCROLL_OFFSET_PADDING;
-
-      window.scrollTo({
-        top: offsetPosition,
-        behavior: "smooth",
-      });
-
-      navigationManager.updateActiveNavItem(h1id);
-    };
-    tocLi.appendChild(tocLink);
-    toc.appendChild(tocLi);
-
-    // Render charts
-    let chartIndex = 0;
-    const { keptCharts, hiddenDatasets, removedDatasets, renamedDatasets } =
-      groupFilterSettings;
-
-    // Render charts with async yielding to prevent UI blocking
-    await renderChartsAsync(
-      benchSet,
-      keptCharts,
-      chartsContainer,
-      name,
-      hiddenDatasets,
-      removedDatasets,
-      renamedDatasets,
-      chartIndex
-    );
-
-    // Update zoom sync cache for this category
-    window.zoomSync.updateCacheForCategory(name);
-  }
-
-  // Async function to render charts with yielding
-  async function renderChartsAsync(
-    benchSet,
-    keptCharts,
-    chartsContainer,
-    name,
-    hiddenDatasets,
-    removedDatasets,
-    renamedDatasets,
-    startIndex
-  ) {
-    let chartIndex = startIndex;
-    const chartsToRender = [];
-
-    // Collect all charts to render
-    if (keptCharts === undefined) {
-      if (benchSet !== undefined) {
-        for (const [benchName, benches] of benchSet.entries()) {
-          chartsToRender.push({ benchName, benches });
-        }
-      }
-    } else if (keptCharts) {
-      for (const benchName of keptCharts) {
-        const benches = benchSet.get(benchName);
-        if (benches) {
-          chartsToRender.push({ benchName, benches });
-        }
-      }
-    } else {
-      // This is the case when keptCharts is not defined at all (not undefined, just missing)
-      if (benchSet !== undefined) {
-        for (const [benchName, benches] of benchSet.entries()) {
-          chartsToRender.push({ benchName, benches });
-        }
-      }
-    }
-
-    // Render charts with yielding between each one
-    for (let i = 0; i < chartsToRender.length; i++) {
-      const { benchName, benches } = chartsToRender[i];
-
-      state.charts.push(
-        chartManager.renderChart(
-          chartsContainer,
-          name,
-          benchName,
-          benches,
-          hiddenDatasets,
-          removedDatasets,
-          renamedDatasets,
-          chartIndex++
-        )
-      );
-
-      // Yield control after each chart to prevent blocking
-      // Only yield if there are more charts to render
-      if (i < chartsToRender.length - 1) {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      }
-    }
-  }
-
-  // Main initialization
-  return async function initAndRender(keptGroups) {
-    try {
-      // Make necessary objects globally available for modules BEFORE rendering charts
-      window.state = state;
-      window.domElements = domElements;
-      window.zoomSync = zoomSync;
-      window.utils = utils;
-
-      // Initialize workers
-      workerManager.init();
-
-      const { benchmarkData, commitsData } = await initializer.loadData();
-
-      // Process data using worker or fallback
-      const grouped = await workerManager.processData(
-        benchmarkData,
-        commitsData,
-        keptGroups,
-        initializer.updateLoadingProgress
-      );
-
-      const main = domElements.main || document.getElementById("main");
-      const toc = domElements.toc || document.getElementById("toc");
-
-      // Clear loading indicator and show rendering progress
-      main.innerHTML = `
-        <div class="loading-indicator">
-          <div class="loading-spinner"></div>
-          <p id="rendering-progress">${getRandomRenderingMessage()} Preparing to render charts...</p>
-        </div>
-      `;
-
-      // Render all charts with batching to prevent UI freezing
-      await renderBenchmarkSetsAsync(grouped, main, toc, keptGroups);
-
-      // Remove rendering progress indicator
-      const loadingIndicator = main.querySelector('.loading-indicator');
-      if (loadingIndicator) {
-        loadingIndicator.remove();
-      }
-
-      initializer.initializeControls();
-      urlManager.initializeFromParams();
-
-      // Clean up workers after initialization (give more time for any pending operations)
-      setTimeout(() => {
-        workerManager.terminate();
-      }, 5000);
-
-      // Ensure workers and zoom sync are cleaned up on page unload
-      window.addEventListener('beforeunload', () => {
-        workerManager.terminate();
-        window.zoomSync.cleanup();
-      });
-    } catch (error) {
-      console.error("Failed to load benchmark data:", error);
-      const main = domElements.main || document.getElementById("main");
-      main.innerHTML = `
-        <div class="loading-indicator">
-          <p style="color: red;">Failed to load benchmark data. Please try refreshing the page.</p>
-          <p>${error.message}</p>
-        </div>
-      `;
-    }
-  };
-})();
diff --git a/benchmarks-website/config.js b/benchmarks-website/config.js
deleted file mode 100644
index b7197489521..00000000000
--- a/benchmarks-website/config.js
+++ /dev/null
@@ -1,167 +0,0 @@
-"use strict";
-
-// Configuration constants
-export const CONFIG = {
-  MOBILE_BREAKPOINT: 1199,
-  MOBILE_MAX_DATA_POINTS: 100,
-  DEFAULT_VISIBLE_COMMITS: 50,
-  DEBOUNCE_DELAY: 150, // Increased from 50ms to reduce update frequency
-  MOBILE_DEBOUNCE_DELAY: 300, // Increased from 200ms for better mobile performance
-  ZOOM_THROTTLE_DELAY: 16, // ~60fps throttling for zoom operations
-  THROTTLE_SCROLL: 100,
-  SEARCH_DEBOUNCE: 300,
-  CHART_OBSERVER_MARGIN: "50px",
-  SCROLL_OFFSET_PADDING: 20,
-  ZOOM_SPEED: 0.1,
-  MIN_VISIBLE_COMMITS: 10,
-  COMPRESS_THROUGHPUT_MAX: 1024,
-  DECOMPRESS_THROUGHPUT_MAX: 8192,
-  ANIMATION_DURATION: 1000,
-  LINK_FEEDBACK_DURATION: 2000,
-  BACK_TO_TOP_THRESHOLD: 200,
-  SCROLL_ACTIVE_THRESHOLD: 100,
-  URL_INIT_DELAY: 100,
-  RESIZE_DEBOUNCE: 250,
-  // Performance monitoring (set to true to enable console timing)
-  ENABLE_ZOOM_PERFORMANCE_TIMING: false,
-};
-
-// Color mappings for series
-export const SERIES_COLOR_MAP = {
-  "vortex-nvme": "#19a508",
-  "parquet-nvme": "#ef7f1d",
-  "datafusion:arrow": "#7a27b1",
-  "datafusion:in-memory-arrow": "#7a27b1",
-  "datafusion:parquet": "#ef7f1d",
-  "datafusion:vortex": "#19a508",
-  "datafusion:lance": "#2D936C",
-  "duckdb:parquet": "#985113",
-  "duckdb:vortex": "#0e5e04",
-  "duckdb:duckdb": "#87752e",
-  "vortex:lance": "#FF8787",
-};
-
-// Brand colors
-export const VORTEX_COLORS = {
-  primary: "#5971FD", // Vortex Blue
-  accent: "#CEE562", // Vortex Green
-  pink: "#EEB3E1", // Vortex Pink
-  black: "#101010", // Vortex Black
-  gray: "#666666", // Secondary gray
-};
-
-// Fallback color palette
-export const FALLBACK_PALETTE = [
-  VORTEX_COLORS.primary,
-  VORTEX_COLORS.accent,
-  VORTEX_COLORS.pink,
-  "#FF8C42", // Orange
-  "#B8336A", // Deep pink
-  "#726DA8", // Purple
-  "#2D936C", // Teal
-  "#E9B44C", // Gold
-];
-
-// Benchmark descriptions
-export const BENCHMARK_DESCRIPTIONS = {
-  "Random Access":
-    "Tests performance of selecting arbitrary row indices from a file on NVMe storage",
-  Compression:
-    "Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet files (with zstd page compression)",
-  "Compression Size":
-    "Compares compressed file sizes and compression ratios across different encoding strategies, helping evaluate the space efficiency trade-offs between Vortex and Parquet formats",
-  "TPC-H (NVMe)":
-    "TPC-H benchmark queries executed on local NVMe storage, testing analytical query performance",
-  "TPC-H (S3)":
-    "TPC-H benchmark queries executed against data stored in Amazon S3, measuring cloud storage query performance and the impact of network latency on analytical workloads",
-  Clickbench:
-    "ClickHouse's analytical benchmark suite testing real-world query patterns on web analytics data, run against NVMe storage",
-  "TPC-DS (NVMe)":
-    "TPC-DS benchmark queries executed on local NVMe storage, testing complex analytical query performance with a retail sales dataset",
-  "Statistical and Population Genetics":`A suite of Statistical and Population genetics queries executed on local NVMe storage.
-
-A custom benchmark for statistical and population genetics workloads using the gnomAD v3.1.2 release of the jointly called One Thousand Genomes (1kG) and Human Genome Diversity Project (HGDP) dataset (1kG+HGDP). Only a prefix of Chromosome 21 is used for benchmarking.
-
-Data source: <https://gnomad.broadinstitute.org/>.`,
-};
-
-// Category tags mapping
-export const CATEGORY_TAGS = {
-  "Random Access": ["Read/Write"],
-  Compression: ["Read/Write"],
-  "Compression Size": ["Read/Write"],
-  Clickbench: ["Queries (NVMe)"],
-  "TPC-H (NVMe) (SF=1)": ["Queries (NVMe)", "TPC-H (SF=1)"],
-  "TPC-H (S3) (SF=1)": ["Queries (S3)", "TPC-H (SF=1)"],
-  "TPC-H (NVMe) (SF=10)": ["Queries (NVMe)", "TPC-H (SF=10)"],
-  "TPC-H (S3) (SF=10)": ["Queries (S3)", "TPC-H (SF=10)"],
-  "TPC-H (NVMe) (SF=100)": ["Queries (NVMe)", "TPC-H (SF=100)"],
-  "TPC-H (S3) (SF=100)": ["Queries (S3)", "TPC-H (SF=100)"],
-  "TPC-H (NVMe) (SF=1000)": ["Queries (NVMe)", "TPC-H (SF=1000)"],
-  "TPC-H (S3) (SF=1000)": ["Queries (S3)", "TPC-H (SF=1000)"],
-  "TPC-DS (NVMe) (SF=1)": ["Queries (NVMe)", "TPC-DS (SF=1)"],
-  "TPC-DS (NVMe) (SF=10)": ["Queries (NVMe)", "TPC-DS (SF=10)"],
-  "Statistical and Population Genetics": ["Queries (NVMe)", "StatPopGen"],
-};
-
-// Scale factor descriptions
-export const SCALE_FACTOR_DESCRIPTIONS = {
-  1: "SF=1 (~1GB of data)",
-  10: "SF=10 (~10GB of data)",
-  100: "SF=100 (~100GB of data)",
-  1000: "SF=1000 (~1TB of data)",
-};
-
-// Query name transformations
-export const QUERY_NAME_MAP = {
-  "TPCH Q1": "TPC-H Q1",
-  "TPCH Q2": "TPC-H Q2",
-  "TPCH Q3": "TPC-H Q3",
-  "TPCH Q4": "TPC-H Q4",
-  "TPCH Q5": "TPC-H Q5",
-  "TPCH Q6": "TPC-H Q6",
-  "TPCH Q7": "TPC-H Q7",
-  "TPCH Q8": "TPC-H Q8",
-  "TPCH Q9": "TPC-H Q9",
-  "TPCH Q10": "TPC-H Q10",
-  "TPCH Q11": "TPC-H Q11",
-  "TPCH Q12": "TPC-H Q12",
-  "TPCH Q13": "TPC-H Q13",
-  "TPCH Q14": "TPC-H Q14",
-  "TPCH Q15": "TPC-H Q15",
-  "TPCH Q16": "TPC-H Q16",
-  "TPCH Q17": "TPC-H Q17",
-  "TPCH Q18": "TPC-H Q18",
-  "TPCH Q19": "TPC-H Q19",
-  "TPCH Q20": "TPC-H Q20",
-  "TPCH Q21": "TPC-H Q21",
-  "TPCH Q22": "TPC-H Q22"
-};
-
-// Engine labels
-export const ENGINE_LABELS = {
-  all: "All",
-  duckdb: "DuckDB",
-  datafusion: "DataFusion",
-  vortex: "Vortex",
-  parquet: "Parquet",
-};
-
-// Group definitions
-export const BENCHMARK_GROUPS = [
-  "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)",
-  "Statistical and Population Genetics"
-];
diff --git a/benchmarks-website/data-processor.js b/benchmarks-website/data-processor.js
deleted file mode 100644
index 26fa39bf6be..00000000000
--- a/benchmarks-website/data-processor.js
+++ /dev/null
@@ -1,74 +0,0 @@
-"use strict";
-
-import { shared } from './data-shared.js';
-import { BENCHMARK_GROUPS } from './config.js';
-
-// Data processing module
-export const dataProcessor = {
-  parseCommits: shared.parseCommits,
-
-  createMissingCommit: shared.createMissingCommit,
-
-  determineGroupId: shared.determineGroupId,
-
-  getTpchGroupId: shared.getTpchGroupId,
-
-  getTpcdsGroupId: shared.getTpcdsGroupId,
-
-  normalizeSeriesName: shared.normalizeSeriesName,
-
-  formatQueryName: shared.formatQueryName,
-
-  convertValue: shared.convertValue,
-
-  getUnit: shared.getUnit,
-
-  downloadAndGroupData(data, commitMetadata, seriesRenameFn) {
-    const commits = this.parseCommits(commitMetadata);
-    const groups = this.initializeGroups();
-    const uncategorizableNames = new Set();
-    const missingCommits = new Set();
-
-    for (const benchmark of data) {
-      this.processBenchmark(
-        benchmark,
-        commitMetadata,
-        commits,
-        groups,
-        seriesRenameFn,
-        missingCommits,
-        uncategorizableNames
-      );
-    }
-
-    this.sortGroups(groups);
-
-    if (missingCommits.size > 0) {
-      console.warn(
-        "These commits were missing from commits.json so the commit message is missing and the datetime is set to 1970-01-01T00:00:00Z",
-        missingCommits
-      );
-    }
-    if (uncategorizableNames.size > 0) {
-      console.warn(
-        "Could not categorize benchmarks with these names, they will not be shown:",
-        uncategorizableNames
-      );
-    }
-
-    return Object.keys(groups).map((name) => ({
-      name,
-      dataSet: groups[name],
-    }));
-  },
-
-  initializeGroups: shared.initializeGroups,
-
-  processBenchmark: shared.processBenchmark,
-
-  applySeriesRenaming: shared.applySeriesRenaming,
-
-  addToGroup: shared.addToGroup,
-
-  sortGroups: shared.sortGroups,
-};
diff --git a/benchmarks-website/data-shared.js b/benchmarks-website/data-shared.js
deleted file mode 100644
index e2a1082bce9..00000000000
--- a/benchmarks-website/data-shared.js
+++ /dev/null
@@ -1,319 +0,0 @@
-import { BENCHMARK_GROUPS, QUERY_NAME_MAP } from './config.js';
-
-export const shared = {
-  parseCommits(commitMetadata) {
-    const commits = [];
-    Object.values(commitMetadata)
-      .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp))
-      .forEach((commit, index) => {
-        commit.sortedIndex = index;
-        commits.push(commit);
-      });
-    return commits;
-  },
-
-  createMissingCommit(commitId) {
-    return {
-      author: { email: "daniel.zidan.king@gmail.com", name: "Dan King" },
-      committer: { email: "noreply@github.com", name: "GitHub" },
-      id: commitId,
-      message: "!! This commit is missing from commits.json !!",
-      timestamp: "1970-01-01T00:00:00Z",
-      tree_id: null,
-      url: `https://github.com/vortex-data/vortex/commit/${commitId}`,
-    };
-  },
-
-  determineGroupId(benchmark) {
-    const { name, dataset, storage } = benchmark;
-
-    if (dataset?.tpch) {
-      const scaleFactor = dataset.tpch.scale_factor;
-      const isNvme = storage === undefined || storage === "nvme";
-      return this.getTpchGroupId(scaleFactor, isNvme);
-    }
-
-    if (dataset?.tpcds) {
-      const scaleFactor = dataset.tpcds.scale_factor;
-      const isNvme = storage === undefined || storage === "nvme";
-      return this.getTpcdsGroupId(scaleFactor, isNvme);
-    }
-
-    if (dataset?.clickbench) return "Clickbench";
-    if (dataset?.statpopgen) return "Statistical and Population Genetics";
-    if (name.startsWith("random-access/")) return "Random Access";
-    if (name.includes("compress time/")) return "Compression";
-    if (name.includes("size/")) return "Compression Size";
-    // Handle ratio patterns for compression throughput
-    if (
-      name.includes("vortex:parquet-zstd ratio") ||
-      name.includes("vortex:lance ratio")
-    ) {
-      return "Compression";
-    }
-    if (name.startsWith("tpch_q")) {
-      const isNvme = storage === undefined || storage === "nvme";
-      return isNvme ? "TPC-H (NVMe) (SF=1)" : "TPC-H (S3) (SF=1)";
-    }
-    if (name.startsWith("tpcds_q")) {
-      const isNvme = storage === undefined || storage === "nvme";
-      return isNvme ? "TPC-DS (NVMe) (SF=1)" : "TPC-DS (S3) (SF=1)";
-    }
-    if (name.startsWith("clickbench")) return "Clickbench";
-
-    return null;
-  },
-
-  getTpchGroupId(scaleFactor, isNvme) {
-    const sf = Number(scaleFactor);
-    const storage = isNvme ? "NVMe" : "S3";
-
-    switch (sf) {
-      case 1:
-        return `TPC-H (${storage}) (SF=1)`;
-      case 10:
-        return `TPC-H (${storage}) (SF=10)`;
-      case 100:
-        return `TPC-H (${storage}) (SF=100)`;
-      case 1000:
-        return `TPC-H (${storage}) (SF=1000)`;
-      default:
-        console.warn("Unknown scale factor:", scaleFactor);
-        return null;
-    }
-  },
-
-  getTpcdsGroupId(scaleFactor, isNvme) {
-    const sf = Number(scaleFactor);
-    const storage = isNvme ? "NVMe" : "S3";
-
-    switch (sf) {
-      case 1:
-        return `TPC-DS (${storage}) (SF=1)`;
-      case 10:
-        return `TPC-DS (${storage}) (SF=10)`;
-      case 100:
-        return `TPC-DS (${storage}) (SF=100)`;
-      case 1000:
-        return `TPC-DS (${storage}) (SF=1000)`;
-      default:
-        console.warn("Unknown scale factor:", scaleFactor);
-        return null;
-    }
-  },
-
-  normalizeSeriesName(name, seriesName, groupId) {
-    let normalizedName = seriesName;
-    let normalizedQuery = name;
-
-    if (
-      seriesName.endsWith(" throughput") ||
-      seriesName.endsWith("throughput")
-    ) {
-      const suffix = seriesName.endsWith(" throughput")
-        ? " throughput"
-        : "throughput";
-      normalizedName = seriesName.slice(0, seriesName.length - suffix.length);
-      normalizedQuery = name.replace("time", "throughput");
-    }
-
-    // Normalize engine names to lowercase for all benchmarks except Compression ones
-    // Keep original capitalization for "Compression" and "Compression Size" benchmarks
-    if (groupId !== "Compression" && groupId !== "Compression Size") {
-      normalizedName = normalizedName
-        .replace(/^DataFusion:/i, "datafusion:")
-        .replace(/^DuckDB:/i, "duckdb:")
-        .replace(/^Vortex:/i, "vortex:")
-        .replace(/^Arrow:/i, "arrow:");
-    }
-
-    return { name: normalizedQuery, seriesName: normalizedName };
-  },
-
-  formatQueryName(query) {
-    let prettyQ = query.replace(/_/g, " ").toUpperCase();
-    prettyQ = QUERY_NAME_MAP[prettyQ] || prettyQ;
-    prettyQ = prettyQ.replace(/^TPCH\s/, "TPC-H ");
-    prettyQ = prettyQ.replace(/^TPCDS\s/, "TPC-DS ");
-    return prettyQ;
-  },
-
-  convertValue(value, unit) {
-    const isNanos = unit === "ns/iter" || unit === "ns";
-    const isBytes = unit === "bytes";
-    const isThroughput = unit === "bytes/ns";
-
-    if (isNanos) return value / 1_000_000;
-    if (isBytes) return value / 1_048_576;
-    if (isThroughput) return (value * 1_000_000_000) / 1_048_576;
-    return value;
-  },
-
-  getUnit(unit) {
-    const isNanos = unit === "ns/iter" || unit === "ns";
-    const isBytes = unit === "bytes";
-    const isThroughput = unit === "bytes/ns";
-
-    if (isNanos) return "ms/iter";
-    if (isBytes) return "MiB";
-    if (isThroughput) return "MiB/s";
-    return unit;
-  },
-
-  initializeGroups() {
-    const groups = {};
-    BENCHMARK_GROUPS.forEach((name) => {
-      groups[name] = new Map();
-    });
-    return groups;
-  },
-
-  processBenchmark(
-    benchmark,
-    commitMetadata,
-    commits,
-    groups,
-    seriesRenameFn,
-    missingCommits,
-    uncategorizableNames
-  ) {
-    // Ensure commit metadata
-    if (!benchmark.commit) {
-      benchmark.commit = commitMetadata[benchmark.commit_id];
-      if (!benchmark.commit) {
-        missingCommits.add(benchmark.commit_id);
-        benchmark.commit = commitMetadata[benchmark.commit_id] =
-          this.createMissingCommit(benchmark.commit_id);
-      }
-    }
-
-    // Determine group
-    const groupId = this.determineGroupId(benchmark);
-    if (!groupId) {
-      uncategorizableNames.add(benchmark.name);
-      return;
-    }
-
-    const group = groups[groupId];
-    if (!group) {
-      console.warn("Cannot find group element in group:", groupId);
-      return;
-    }
-
-    // Process benchmark data
-    let [query, seriesName] = benchmark.name.split("/");
-    const normalized = this.normalizeSeriesName(query, seriesName, groupId);
-    query = normalized.name;
-    seriesName = normalized.seriesName;
-
-    // Apply series renaming
-    seriesName = this.applySeriesRenaming(
-      seriesName,
-      groupId,
-      seriesRenameFn
-    );
-
-    // Format query name
-    const prettyQ = this.formatQueryName(query);
-    if (prettyQ.includes("PARQUET-UNC")) return;
-
-    // Set units
-    let unit = benchmark.unit;
-    if (!unit && benchmark.name.startsWith("vortex size/")) {
-      unit = "bytes";
-    } else if (
-      !unit &&
-      (benchmark.name.startsWith("vortex:raw size/") ||
-        benchmark.name.startsWith("vortex:parquet-zstd size/") ||
-        benchmark.name.startsWith("vortex:lance size/"))
-    ) {
-      unit = "ratio";
-    }
-
-    // Calculate sort position
-    const sortPosition =
-      query.slice(0, 4) === "tpch" || query.slice(0, 5) === "tpcds"
-        ? parseInt(prettyQ.split(" ")[1].substring(1), 10)
-        : 0;
-
-    // Add to group
-    this.addToGroup(
-      group,
-      prettyQ,
-      seriesName,
-      benchmark,
-      unit,
-      sortPosition,
-      commits
-    );
-  },
-
-  applySeriesRenaming(seriesName, groupId, seriesRenameFn) {
-    if (!seriesRenameFn) return seriesName;
-
-    const renamer = seriesRenameFn.find(([name]) => name === groupId);
-    if (renamer?.[1]?.renamedDatasets) {
-      const renameDict = renamer[1].renamedDatasets;
-
-      // Create a case-insensitive lookup map.
-      // Since all series names are normalized to lowercase, we normalize
-      // the keys to lowercase for consistent matching.
-      const caseInsensitiveDict = {};
-      for (const [key, value] of Object.entries(renameDict)) {
-        caseInsensitiveDict[key.toLowerCase()] = value;
-      }
-
-      // Look up using the lowercase series name to handle both
-      // "DataFusion:lance" and "datafusion:lance" correctly.
-      return caseInsensitiveDict[seriesName.toLowerCase()] || seriesName;
-    }
-    return seriesName;
-  },
-
-  addToGroup(
-    group,
-    queryName,
-    seriesName,
-    benchmark,
-    unit,
-    sortPosition,
-    commits
-  ) {
-    let arr = group.get(queryName);
-    if (!arr) {
-      group.set(queryName, {
-        sort_position: sortPosition,
-        commits,
-        unit: this.getUnit(unit),
-        series: new Map(),
-      });
-      arr = group.get(queryName);
-    }
-
-    let series = arr.series.get(seriesName);
-    if (!series) {
-      arr.series.set(seriesName, new Array(commits.length).fill(null));
-      series = arr.series.get(seriesName);
-    }
-
-    series[benchmark.commit.sortedIndex] = {
-      range: "this was the range",
-      value: this.convertValue(benchmark.value, unit),
-    };
-  },
-
-  sortGroups(groups) {
-    const sortByPositionThenName = (a, b) => {
-      const positionCompare = a[1].sort_position - b[1].sort_position;
-      return positionCompare !== 0
-        ? positionCompare
-        : a[0].localeCompare(b[0]);
-    };
-
-    Object.entries(groups).forEach(([name, charts]) => {
-      groups[name] = new Map(
-        [...charts.entries()].sort(sortByPositionThenName)
-      );
-    });
-  },
-};
diff --git a/benchmarks-website/data-worker.js b/benchmarks-website/data-worker.js
deleted file mode 100644
index 2e6f4164096..00000000000
--- a/benchmarks-website/data-worker.js
+++ /dev/null
@@ -1,374 +0,0 @@
-"use strict";
-
-import { shared } from './data-shared.js';
-import { BENCHMARK_GROUPS } from './config.js';
-
-// Data processing web worker
-// Handles heavy data parsing and processing operations off the main thread
-
-// Fun progress messages for data processing
-const DATA_PROCESSING_MESSAGES = [
-  "Crunching numbers like a statistical Sarlacc pit...",
-  "Processing data faster than C-3PO speaks languages...",
-  "Analyzing benchmarks with the precision of a Terminator...",
-  "Computing results with the power of Deep Thought...",
-  "Processing benchmarks in parallel universes...",
-  "Analyzing performance like a Mentat...",
-];
-
-const PARSING_MESSAGES = [
-  "Reading files like Gandalf reads ancient texts...",
-  "Interpreting data with the wisdom of Yoda...",
-  "Parsing JSON like Neo sees the Matrix...",
-  "Reading benchmark data like Sherlock reads clues...",
-  "Translating data like the Babel fish...",
-];
-
-// Fun progress messages for serialization
-const NERDY_PROGRESS_MESSAGES = [
-  // Hitchhiker's Guide to the Galaxy
-  "Calculating the meaning of life, universe, and everything...",
-  "Don't panic! Serializing data...",
-  "Consulting the Guide about data serialization...",
-  "Generating infinite improbability data...",
-
-  // Lord of the Rings
-  "One does not simply serialize into Mordor...",
-  "Precious data must be kept safe, yes precious...",
-  "The data shall not pass! (until serialized)",
-  "Even the smallest dataset can change the course of loading...",
-
-  // Star Wars
-  "These aren't the data structures you're looking for...",
-  "Using the Force to serialize data...",
-  "That's no moon, that's a benchmark dataset!",
-  "Help me Obi-Wan, you're my only hope for fast serialization!",
-
-  // Star Trek
-  "Engaging warp drive for data serialization...",
-  "Make it so, Number Data!",
-  "Beam me up, Scotty! (after serialization)",
-  "Fascinating... this data appears to be logical...",
-
-  // Dune
-  "The spice must flow... and so must the data!",
-  "Fear is the mind-killer, serialization is the data-thriller...",
-  "He who controls the data, controls the universe!",
-
-  // Matrix
-  "There is no spoon... only serialized data...",
-  "Welcome to the real world of data processing...",
-  "I know kung fu... and data serialization!",
-
-  // Douglas Adams / General Sci-Fi
-  "Serializing data with the efficiency of a Babel fish...",
-  "Processing data at the Restaurant at the End of the Universe...",
-  "Vogon poetry is nothing compared to this beautiful data...",
-  "Time is an illusion, lunchtime doubly so, but data serialization is eternal...",
-];
-
-const EMPTY_GROUP_MESSAGES = [
-  "Nothing to see here, move along...",
-  "This group is as empty as the void of space...",
-  "Skipping faster than the Millennium Falcon in 12 parsecs...",
-  "Empty group detected. Resistance is futile, but unnecessary...",
-  "These aren't the benchmarks you're looking for...",
-  "Group more empty than Tatooine's social calendar...",
-];
-
-function getRandomMessage(messages) {
-  return messages[Math.floor(Math.random() * messages.length)];
-}
-
-// Data processor implementation for worker context
-const dataProcessor = {
-  parseCommits: shared.parseCommits,
-
-  createMissingCommit: shared.createMissingCommit,
-
-  determineGroupId: shared.determineGroupId,
-
-  getTpchGroupId: shared.getTpchGroupId,
-
-  getTpcdsGroupId: shared.getTpcdsGroupId,
-
-  normalizeSeriesName: shared.normalizeSeriesName,
-
-  formatQueryName: shared.formatQueryName,
-
-  convertValue: shared.convertValue,
-
-  getUnit: shared.getUnit,
-
-  async downloadAndGroupData(data, commitMetadata, seriesRenameFn) {
-    const commits = this.parseCommits(commitMetadata);
-    const groups = this.initializeGroups();
-    const uncategorizableNames = new Set();
-    const missingCommits = new Set();
-
-    let processed = 0;
-    const total = data.length;
-
-    for (const benchmark of data) {
-      this.processBenchmark(
-        benchmark,
-        commitMetadata,
-        commits,
-        groups,
-        seriesRenameFn,
-        missingCommits,
-        uncategorizableNames
-      );
-
-      let msg = getRandomMessage(DATA_PROCESSING_MESSAGES);
-
-      processed++;
-      // Send progress updates every 1000 items
-      if (processed % 1000 === 0) {
-        self.postMessage({
-          type: 'progress',
-          progress: (processed / total) * 90, // Reserve 10% for serialization
-          message: `${msg} ${processed}/${total}`
-        });
-      }
-    }
-
-    this.sortGroups(groups);
-
-    if (missingCommits.size > 0) {
-      console.warn(
-        "These commits were missing from commits.json so the commit message is missing and the datetime is set to 1970-01-01T00:00:00Z",
-        missingCommits
-      );
-    }
-    if (uncategorizableNames.size > 0) {
-      console.warn(
-        "Could not categorize benchmarks with these names, they will not be shown:",
-        uncategorizableNames
-      );
-    }
-
-    // Convert Maps to serializable objects for transfer using async serialization
-    const serializedGroups = await this.serializeGroupsAsync(groups);
-
-    return serializedGroups;
-  },
-
-  // Helper to serialize Maps for transfer across worker boundary
-  serializeMap(map) {
-    if (!map || typeof map.entries !== 'function') {
-      return map; // Return as-is if not a Map
-    }
-
-    const result = [];
-    for (const [key, value] of map.entries()) {
-      if (value && value.series) {
-        // For series data, convert Map to plain object to avoid deep recursion
-        const serializedSeries = {};
-        if (value.series instanceof Map) {
-          for (const [seriesKey, seriesValue] of value.series.entries()) {
-            serializedSeries[seriesKey] = seriesValue;
-          }
-        } else {
-          Object.assign(serializedSeries, value.series);
-        }
-
-        result.push([key, {
-          ...value,
-          series: serializedSeries
-        }]);
-      } else {
-        result.push([key, value]);
-      }
-    }
-    return result;
-  },
-
-  // Async version of serializeMap that processes in chunks
-  async serializeMapAsync(map, onProgress = null) {
-    if (!map || typeof map.entries !== 'function') {
-      return map; // Return as-is if not a Map
-    }
-
-    const result = [];
-    const entries = Array.from(map.entries());
-    const chunkSize = 50; // Process 50 entries at a time
-
-    for (let i = 0; i < entries.length; i += chunkSize) {
-      const chunk = entries.slice(i, i + chunkSize);
-
-      for (const [key, value] of chunk) {
-        if (value && value.series) {
-          // For series data, convert Map to plain object to avoid deep recursion
-          const serializedSeries = {};
-          if (value.series instanceof Map) {
-            for (const [seriesKey, seriesValue] of value.series.entries()) {
-              serializedSeries[seriesKey] = seriesValue;
-            }
-          } else {
-            Object.assign(serializedSeries, value.series);
-          }
-
-          result.push([key, {
-            ...value,
-            series: serializedSeries
-          }]);
-        } else {
-          result.push([key, value]);
-        }
-      }
-
-      // Yield control and report progress after each chunk
-      if (onProgress) {
-        const progress = ((i + chunkSize) / entries.length) * 100;
-        onProgress(Math.min(progress, 100));
-      }
-
-      // Yield control to prevent blocking
-      if (i + chunkSize < entries.length) {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      }
-    }
-
-    return result;
-  },
-
-  // Async method to serialize all groups with progress reporting
-  async serializeGroupsAsync(groups) {
-    const groupNames = Object.keys(groups);
-    const serializedGroups = [];
-
-    // Note: We process all groups to maintain structure, but skip heavy processing for empty ones
-
-    const progress_message = getRandomMessage(NERDY_PROGRESS_MESSAGES);
-
-    for (let i = 0; i < groupNames.length; i++) {
-      const name = groupNames[i];
-      const group = groups[name];
-
-      // Skip empty groups but still report progress
-      if (!group || group.size === 0) {
-        const overallProgress = 90 + ((i + 1) / groupNames.length) * 10;
-        self.postMessage({
-          type: 'progress',
-          progress: Math.min(overallProgress, 100),
-          message: `${getRandomMessage(EMPTY_GROUP_MESSAGES)} Skipping: ${name} (${i + 1}/${groupNames.length})`
-        });
-
-        // Still add empty group to maintain structure
-        serializedGroups.push({
-          name,
-          dataSet: []
-        });
-
-        // Brief yield
-        await new Promise(resolve => setTimeout(resolve, 0));
-        continue;
-      }
-
-      // Report progress for this group serialization
-      const groupProgress = (progress) => {
-        const overallProgress = 90 + ((i + (progress / 100)) / groupNames.length) * 10;
-        self.postMessage({
-          type: 'progress',
-          progress: Math.min(overallProgress, 100),
-          message: `${progress_message} ${name} (${i + 1}/${groupNames.length})`
-        });
-      };
-
-      const serializedMap = await this.serializeMapAsync(group, groupProgress);
-      serializedGroups.push({
-        name,
-        dataSet: serializedMap
-      });
-
-      // Brief yield between groups
-      if (i < groupNames.length - 1) {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      }
-    }
-
-    return serializedGroups;
-  },
-
-  initializeGroups: shared.initializeGroups,
-
-  processBenchmark: shared.processBenchmark,
-
-  applySeriesRenaming: shared.applySeriesRenaming,
-
-  addToGroup: shared.addToGroup,
-
-  sortGroups: shared.sortGroups,
-};
-
-// JSONL parser for worker context
-function parseJsonl(jsonl) {
-  return jsonl
-    .split("\n")
-    .filter((line) => line.trim().length !== 0)
-    .map((line) => JSON.parse(line));
-}
-
-// Worker message handler
-self.addEventListener('message', async function(e) {
-  const { type, data } = e.data;
-
-  try {
-    switch (type) {
-      case 'parseData':
-        self.postMessage({
-          type: 'progress',
-          progress: 10,
-          message: `${getRandomMessage(PARSING_MESSAGES)} Benchmark data...`
-        });
-
-        // benchmarkData might already be parsed as an array
-        const benchmarkData = Array.isArray(data.benchmarkData)
-          ? data.benchmarkData
-          : parseJsonl(data.benchmarkData);
-
-        self.postMessage({
-          type: 'progress',
-          progress: 30,
-          message: `${getRandomMessage(PARSING_MESSAGES)} Commit data...`
-        });
-
-        const commitsData = parseJsonl(data.commitsData);
-
-        self.postMessage({
-          type: 'progress',
-          progress: 50,
-          message: `${getRandomMessage(DATA_PROCESSING_MESSAGES).replace('...', ' and grouping data...')}`
-        });
-
-        const commits = {};
-        commitsData.forEach((commit) => {
-          commits[commit.id] = commit;
-        });
-
-        const result = await dataProcessor.downloadAndGroupData(
-          benchmarkData,
-          commits,
-          data.keptGroups
-        );
-
-        self.postMessage({
-          type: 'dataProcessed',
-          result: result,
-          progress: 100,
-          message: 'Data processing complete!'
-        });
-        break;
-
-      default:
-        throw new Error(`Unknown message type: ${type}`);
-    }
-  } catch (error) {
-    self.postMessage({
-      type: 'error',
-      error: error.message,
-      stack: error.stack
-    });
-  }
-});
diff --git a/benchmarks-website-v2/docker-compose.yml b/benchmarks-website/docker-compose.yml
similarity index 100%
rename from benchmarks-website-v2/docker-compose.yml
rename to benchmarks-website/docker-compose.yml
diff --git a/benchmarks-website-v2/ec2-init.txt b/benchmarks-website/ec2-init.txt
similarity index 100%
rename from benchmarks-website-v2/ec2-init.txt
rename to benchmarks-website/ec2-init.txt
diff --git a/benchmarks-website/index.html b/benchmarks-website/index.html
index 48f4c8bc003..e475f3ad254 100644
--- a/benchmarks-website/index.html
+++ b/benchmarks-website/index.html
@@ -1,21 +1,19 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
   <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vortex Benchmarks</title>
 
     <!-- Preconnect to font services -->
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
 
     <!-- Web Fonts -->
-    <!-- Funnel Display for headers -->
     <link
       href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&display=swap"
       rel="stylesheet"
     />
-
-    <!-- Geist font from Vercel -->
     <link
       rel="stylesheet"
       href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-sans/style.css"
@@ -25,437 +23,14 @@
       href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-mono/style.css"
     />
 
-    <link
-      rel="preload"
-      href="https://vortex-benchmark-results-database.s3.amazonaws.com/data.json.gz"
-      as="fetch"
-      crossorigin
-    />
-    <link
-      rel="preload"
-      href="https://vortex-benchmark-results-database.s3.amazonaws.com/commits.json"
-      as="fetch"
-      crossorigin
-    />
-    <link rel="apple-touch-icon" sizes="180x180" href="apple-touch-icon.png" />
-    <link rel="icon" type="image/png" sizes="32x32" href="favicon-32x32.png" />
-    <link rel="icon" type="image/png" sizes="16x16" href="favicon-16x16.png" />
-    <link rel="manifest" href="site.webmanifest" />
-    <link rel="stylesheet" href="style.css" />
-    <title>Vortex Benchmarks</title>
-    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.4/dist/chart.umd.min.js"></script>
-    <script src="https://cdn.rawgit.com/h2non/jsHashes/master/hashes.js"></script>
-    <!-- Chart.js Zoom Plugin -->
-    <script src="https://cdn.jsdelivr.net/npm/hammerjs@2.0.8"></script>
-    <script src="https://cdn.jsdelivr.net/npm/chartjs-plugin-zoom@2.0.1/dist/chartjs-plugin-zoom.min.js"></script>
-    <!-- Chart.js Zoom Plugin -->
-
-    <!-- <script src="data.js"></script> -->
-    <script type="module" id="main-script">
-      import "./code.js";
-
-      // Wait for initialization to complete
-      const waitForInit = () => {
-        if (window.initAndRender) {
-          window.initAndRender([
-            [
-              "Random Access",
-              {
-                renamedDatasets: {
-                  "vortex-tokio-local-disk": "vortex-nvme",
-                  "lance-tokio-local-disk": "lance-nvme",
-                  "parquet-tokio-local-disk": "parquet-nvme",
-                },
-              },
-            ],
-            [
-              "Compression",
-              {
-                keptCharts: [
-                  "COMPRESS TIME",
-                  "DECOMPRESS TIME",
-                  "PARQUET RS-ZSTD COMPRESS TIME",
-                  "PARQUET RS-ZSTD DECOMPRESS TIME",
-                  "LANCE COMPRESS TIME",
-                  "LANCE DECOMPRESS TIME",
-                  "VORTEX:PARQUET-ZSTD RATIO COMPRESS TIME",
-                  "VORTEX:PARQUET-ZSTD RATIO DECOMPRESS TIME",
-                  "VORTEX:LANCE RATIO COMPRESS TIME",
-                  "VORTEX:LANCE RATIO DECOMPRESS TIME",
-                ],
-                hiddenDatasets: new Set([
-                  "wide table cols=1000 chunks=1 rows=1000",
-                  "wide table cols=1000 chunks=50 rows=1000",
-                ]),
-                removedDatasets: new Set([
-                  "TPC-H l_comment canonical",
-                  "TPC-H l_comment chunked without fsst",
-                  "wide table cols=10 chunks=1 rows=1000",
-                  "wide table cols=100 chunks=1 rows=1000",
-                  "wide table cols=10 chunks=50 rows=1000",
-                  "wide table cols=100 chunks=50 rows=1000",
-                ]),
-                renamedDatasets: {
-                  lance: "lance",
-                  Lance: "lance",
-                  LANCE: "lance",
-                },
-              },
-            ],
-            [
-              "Compression Size",
-              {
-                keptCharts: [
-                  "VORTEX SIZE",
-                  "PARQUET-ZSTD SIZE",
-                  "LANCE SIZE",
-                  "VORTEX:PARQUET-ZSTD SIZE",
-                  "VORTEX:LANCE SIZE",
-                ],
-                hiddenDatasets: new Set(["wide table cols=1000"]),
-                removedDatasets: new Set([
-                  "wide table cols=10 chunks=1 rows=1000",
-                  "wide table cols=100 chunks=1 rows=1000",
-                  "wide table cols=10 chunks=50 rows=1000",
-                  "wide table cols=100 chunks=50 rows=1000",
-                ]),
-                renamedDatasets: {
-                  lance: "lance",
-                  Lance: "lance",
-                  LANCE: "lance",
-                },
-              },
-            ],
-            [
-              "Clickbench",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (NVMe) (SF=1)",
-              {
-                keptCharts: undefined,
-                hiddenDatasets: new Set(["datafusion:lance"]),
-                removedDatasets: new Set([]),
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-              },
-            ],
-            [
-              "TPC-H (S3) (SF=1)",
-              {
-                keptCharts: undefined,
-                hiddenDatasets: new Set(["datafusion:lance"]),
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-              },
-            ],
-            [
-              "TPC-H (NVMe) (SF=10)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (S3) (SF=10)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (NVMe) (SF=100)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (S3) (SF=100)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (NVMe) (SF=1000)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-H (S3) (SF=1000)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-                  "DataFusion:lance": "datafusion:lance",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-                hiddenDatasets: new Set(["datafusion:lance"]),
-              },
-            ],
-            [
-              "TPC-DS (NVMe) (SF=1)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-              },
-            ],
-            [
-              "TPC-DS (NVMe) (SF=10)",
-              {
-                renamedDatasets: {
-                  "DataFusion:vortex-file-compressed": "datafusion:vortex",
-                  "DataFusion:parquet": "datafusion:parquet",
-                  "DataFusion:arrow": "datafusion:in-memory-arrow",
-
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-              },
-            ],
-            [
-              "Statistical and Population Genetics",
-              {
-                renamedDatasets: {
-                  "DuckDB:vortex-file-compressed": "duckdb:vortex",
-                  "DuckDB:parquet": "duckdb:parquet",
-                  "DuckDB:duckdb": "duckdb:duckdb",
-                },
-              },
-            ],
-          ]);
-        } else {
-          setTimeout(waitForInit, 100);
-        }
-      };
-
-      waitForInit();
-    </script>
+    <!-- Favicons -->
+    <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
+    <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png" />
+    <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png" />
+    <link rel="manifest" href="/site.webmanifest" />
   </head>
-
   <body>
-    <!-- Sticky Header -->
-    <header class="sticky-header">
-      <div class="header-content">
-        <div class="header-left">
-          <button id="menu-toggle" class="menu-toggle" aria-label="Toggle menu">
-            ☰
-          </button>
-          <a href="/" class="logo-link">
-            <img src="vortex_black_nobg.svg" alt="Vortex" class="site-logo" />
-          </a>
-        </div>
-        <h1 class="site-title">Vortex Benchmarks</h1>
-        <div class="header-center">
-          <div class="filter-controls">
-            <button id="expand-all" class="control-btn">Expand All</button>
-            <button id="collapse-all" class="control-btn">Collapse All</button>
-            <select
-              id="category-filter"
-              class="category-filter"
-              aria-label="Filter benchmarks by category"
-            >
-              <option value="all">All Benchmarks</option>
-              <option value="Read/Write">Read/Write</option>
-              <option value="Queries (NVMe)">Queries (NVMe)</option>
-              <option value="Queries (S3)">Queries (S3)</option>
-              <option value="TPC-H (SF=1)">TPC-H (SF=1)</option>
-              <option value="TPC-H (SF=10)">TPC-H (SF=10)</option>
-              <option value="TPC-H (SF=100)">TPC-H (SF=100)</option>
-              <option value="TPC-H (SF=1000)">TPC-H (SF=1000)</option>
-              <option value="TPC-DS (SF=1)">TPC-DS (SF=1)</option>
-              <option value="TPC-DS (SF=10)">TPC-DS (SF=10)</option>
-            </select>
-            <input
-              type="text"
-              id="search-filter"
-              class="search-filter"
-              placeholder="Search benchmarks..."
-            />
-          </div>
-        </div>
-        <div class="header-right">
-          <div class="view-controls">
-            <button
-              id="grid-view"
-              class="view-btn active"
-              aria-label="Grid view"
-            >
-              ⊞
-            </button>
-            <button id="list-view" class="view-btn" aria-label="List view">
-              ☰
-            </button>
-          </div>
-          <a
-            href="https://github.com/vortex-data/vortex"
-            class="repo-link"
-            rel="noopener"
-          >
-            <svg
-              class="github-logo"
-              viewBox="0 0 16 16"
-              width="16"
-              height="16"
-              fill="currentColor"
-            >
-              <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>
-    </header>
-
-    <!-- Main Content Area -->
-    <div class="main-container">
-      <!-- Sidebar hover zone -->
-      <div class="sidebar-hover-zone" id="sidebar-hover-zone"></div>
-
-      <!-- Sidebar Navigation -->
-      <aside id="sidebar" class="sidebar collapsed">
-        <nav class="sidebar-nav">
-          <div class="sidebar-header">
-            <h2>Navigation</h2>
-            <button
-              id="sidebar-close"
-              class="sidebar-close"
-              aria-label="Close sidebar"
-            >
-              ×
-            </button>
-          </div>
-          <button id="clear-filter" class="clear-filter-btn hidden">
-            Clear Filter
-          </button>
-          <ul id="toc" class="toc-list"></ul>
-          <div class="sidebar-footer">
-            <a
-              href="https://vortex-benchmark-results-database.s3.amazonaws.com/data.json.gz"
-              class="download-btn"
-              download
-            >
-              Download Data
-            </a>
-          </div>
-        </nav>
-      </aside>
-
-      <!-- Main Content -->
-      <main id="main" class="main-content">
-        <div class="loading-indicator" id="loading">
-          <div class="spinner"></div>
-          <p>Loading benchmarks...</p>
-        </div>
-      </main>
-
-      <!-- Sidebar overlay for mobile -->
-      <div class="sidebar-overlay" id="sidebar-overlay"></div>
-    </div>
-
-    <!-- Back to Top Button -->
-    <button id="back-to-top" class="back-to-top" aria-label="Back to top">
-      ↑
-    </button>
-
-    <!-- Fullscreen Chart Modal -->
-    <div id="chart-modal" class="chart-modal">
-      <div class="modal-content">
-        <button class="modal-close" id="modal-close">×</button>
-        <div class="modal-chart-container">
-          <canvas id="modal-chart"></canvas>
-        </div>
-      </div>
-    </div>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
   </body>
 </html>
diff --git a/benchmarks-website-v2/package-lock.json b/benchmarks-website/package-lock.json
similarity index 76%
rename from benchmarks-website-v2/package-lock.json
rename to benchmarks-website/package-lock.json
index addf01b4519..9fbe9f01769 100644
--- a/benchmarks-website-v2/package-lock.json
+++ b/benchmarks-website/package-lock.json
@@ -22,7 +22,7 @@
         "@types/react-dom": "^18.3.0",
         "@vitejs/plugin-react": "^4.3.1",
         "concurrently": "^8.2.2",
-        "vite": "^5.4.0"
+        "vite": "^6.0.0"
       },
       "engines": {
         "node": ">=18.0.0"
@@ -85,9 +85,9 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.0.tgz",
-      "integrity": "sha512-vSH118/wwM/pLR38g/Sgk05sNtro6TlTJKuiMXDaZqPUfjTFcudpCOt00IhOfj+1BFAX+UFAlzCU+6WXr3GLFQ==",
+      "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==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -201,23 +201,23 @@
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
-      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/template": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/types": "^7.29.0"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
-      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -263,9 +263,9 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
-      "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz",
+      "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -321,9 +321,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
       "cpu": [
         "ppc64"
       ],
@@ -334,13 +334,13 @@
         "aix"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
       "cpu": [
         "arm"
       ],
@@ -351,13 +351,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
       "cpu": [
         "arm64"
       ],
@@ -368,13 +368,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
       "cpu": [
         "x64"
       ],
@@ -385,13 +385,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
       "cpu": [
         "arm64"
       ],
@@ -402,13 +402,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
       "cpu": [
         "x64"
       ],
@@ -419,13 +419,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
       "cpu": [
         "arm64"
       ],
@@ -436,13 +436,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
       "cpu": [
         "x64"
       ],
@@ -453,13 +453,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
       "cpu": [
         "arm"
       ],
@@ -470,13 +470,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
       "cpu": [
         "arm64"
       ],
@@ -487,13 +487,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
       "cpu": [
         "ia32"
       ],
@@ -504,13 +504,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
       "cpu": [
         "loong64"
       ],
@@ -521,13 +521,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
       "cpu": [
         "mips64el"
       ],
@@ -538,13 +538,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
       "cpu": [
         "ppc64"
       ],
@@ -555,13 +555,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
       "cpu": [
         "riscv64"
       ],
@@ -572,13 +572,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
       "cpu": [
         "s390x"
       ],
@@ -589,13 +589,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
       "cpu": [
         "x64"
       ],
@@ -606,13 +606,30 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
       "cpu": [
         "x64"
       ],
@@ -623,13 +640,30 @@
         "netbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
       "cpu": [
         "x64"
       ],
@@ -640,13 +674,30 @@
         "openbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
       "cpu": [
         "x64"
       ],
@@ -657,13 +708,13 @@
         "sunos"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
       "cpu": [
         "arm64"
       ],
@@ -674,13 +725,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
       "cpu": [
         "ia32"
       ],
@@ -691,13 +742,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
       "cpu": [
         "x64"
       ],
@@ -708,7 +759,7 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@jridgewell/gen-mapping": {
@@ -775,9 +826,9 @@
       "license": "MIT"
     },
     "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz",
-      "integrity": "sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.0.tgz",
+      "integrity": "sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==",
       "cpu": [
         "arm"
       ],
@@ -789,9 +840,9 @@
       ]
     },
     "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz",
-      "integrity": "sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.0.tgz",
+      "integrity": "sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==",
       "cpu": [
         "arm64"
       ],
@@ -803,9 +854,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz",
-      "integrity": "sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.0.tgz",
+      "integrity": "sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==",
       "cpu": [
         "arm64"
       ],
@@ -817,9 +868,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz",
-      "integrity": "sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.0.tgz",
+      "integrity": "sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==",
       "cpu": [
         "x64"
       ],
@@ -831,9 +882,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz",
-      "integrity": "sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.0.tgz",
+      "integrity": "sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==",
       "cpu": [
         "arm64"
       ],
@@ -845,9 +896,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz",
-      "integrity": "sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.0.tgz",
+      "integrity": "sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==",
       "cpu": [
         "x64"
       ],
@@ -859,9 +910,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz",
-      "integrity": "sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.0.tgz",
+      "integrity": "sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==",
       "cpu": [
         "arm"
       ],
@@ -873,9 +924,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz",
-      "integrity": "sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.0.tgz",
+      "integrity": "sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==",
       "cpu": [
         "arm"
       ],
@@ -887,9 +938,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz",
-      "integrity": "sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.0.tgz",
+      "integrity": "sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==",
       "cpu": [
         "arm64"
       ],
@@ -901,9 +952,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz",
-      "integrity": "sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.0.tgz",
+      "integrity": "sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==",
       "cpu": [
         "arm64"
       ],
@@ -915,9 +966,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz",
-      "integrity": "sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.0.tgz",
+      "integrity": "sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==",
       "cpu": [
         "loong64"
       ],
@@ -929,9 +980,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz",
-      "integrity": "sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.0.tgz",
+      "integrity": "sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==",
       "cpu": [
         "loong64"
       ],
@@ -943,9 +994,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz",
-      "integrity": "sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==",
       "cpu": [
         "ppc64"
       ],
@@ -957,9 +1008,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz",
-      "integrity": "sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.0.tgz",
+      "integrity": "sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==",
       "cpu": [
         "ppc64"
       ],
@@ -971,9 +1022,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz",
-      "integrity": "sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.0.tgz",
+      "integrity": "sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==",
       "cpu": [
         "riscv64"
       ],
@@ -985,9 +1036,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz",
-      "integrity": "sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.0.tgz",
+      "integrity": "sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==",
       "cpu": [
         "riscv64"
       ],
@@ -999,9 +1050,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz",
-      "integrity": "sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.0.tgz",
+      "integrity": "sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==",
       "cpu": [
         "s390x"
       ],
@@ -1013,9 +1064,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz",
-      "integrity": "sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==",
       "cpu": [
         "x64"
       ],
@@ -1027,9 +1078,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz",
-      "integrity": "sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.0.tgz",
+      "integrity": "sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==",
       "cpu": [
         "x64"
       ],
@@ -1041,9 +1092,9 @@
       ]
     },
     "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz",
-      "integrity": "sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.0.tgz",
+      "integrity": "sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==",
       "cpu": [
         "x64"
       ],
@@ -1055,9 +1106,9 @@
       ]
     },
     "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz",
-      "integrity": "sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.0.tgz",
+      "integrity": "sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==",
       "cpu": [
         "arm64"
       ],
@@ -1069,9 +1120,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz",
-      "integrity": "sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.0.tgz",
+      "integrity": "sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==",
       "cpu": [
         "arm64"
       ],
@@ -1083,9 +1134,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz",
-      "integrity": "sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.0.tgz",
+      "integrity": "sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==",
       "cpu": [
         "ia32"
       ],
@@ -1097,9 +1148,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz",
-      "integrity": "sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==",
       "cpu": [
         "x64"
       ],
@@ -1111,9 +1162,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz",
-      "integrity": "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.0.tgz",
+      "integrity": "sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==",
       "cpu": [
         "x64"
       ],
@@ -1258,13 +1309,16 @@
       }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.9.19",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
-      "integrity": "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==",
+      "version": "2.10.10",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.10.tgz",
+      "integrity": "sha512-sUoJ3IMxx4AyRqO4MLeHlnGDkyXRoUG0/AI9fjK+vS72ekpV0yWVY7O0BVjmBcRtkNcsAO2QDZ4tdKKGoI6YaQ==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
-        "baseline-browser-mapping": "dist/cli.js"
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
       }
     },
     "node_modules/browserslist": {
@@ -1302,9 +1356,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001767",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001767.tgz",
-      "integrity": "sha512-34+zUAMhSH+r+9eKmYG+k2Rpt8XttfE4yXAjoZvkAPs15xcYQhyBYdalJ65BzivAvGRMViEjy6oKr/S91loekQ==",
+      "version": "1.0.30001780",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001780.tgz",
+      "integrity": "sha512-llngX0E7nQci5BPJDqoZSbuZ5Bcs9F5db7EtgfwBerX9XGtkkiO4NwfDDIRzHTTwcYC8vC7bmeUEPGrKlR/TkQ==",
       "dev": true,
       "funding": [
         {
@@ -1496,9 +1550,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.283",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.283.tgz",
-      "integrity": "sha512-3vifjt1HgrGW/h76UEeny+adYApveS9dH2h3p57JYzBSXJIKUJAvtmIytDKjcSCt9xHfrNCFJ7gts6vkhuq++w==",
+      "version": "1.5.321",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.321.tgz",
+      "integrity": "sha512-L2C7Q279W2D/J4PLZLk7sebOILDSWos7bMsMNN06rK482umHUrh/3lM8G7IlHFOYip2oAg5nha1rCMxr/rs6ZQ==",
       "dev": true,
       "license": "ISC"
     },
@@ -1510,9 +1564,9 @@
       "license": "MIT"
     },
     "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -1520,32 +1574,35 @@
         "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
       }
     },
     "node_modules/escalade": {
@@ -1558,6 +1615,24 @@
         "node": ">=6"
       }
     },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -1719,9 +1794,9 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.27",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
-      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "version": "2.0.36",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
+      "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
       "dev": true,
       "license": "MIT"
     },
@@ -1732,10 +1807,23 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/postcss": {
-      "version": "8.5.6",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
       "dev": true,
       "funding": [
         {
@@ -1817,9 +1905,9 @@
       }
     },
     "node_modules/rollup": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.57.1.tgz",
-      "integrity": "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==",
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.0.tgz",
+      "integrity": "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1833,31 +1921,31 @@
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.57.1",
-        "@rollup/rollup-android-arm64": "4.57.1",
-        "@rollup/rollup-darwin-arm64": "4.57.1",
-        "@rollup/rollup-darwin-x64": "4.57.1",
-        "@rollup/rollup-freebsd-arm64": "4.57.1",
-        "@rollup/rollup-freebsd-x64": "4.57.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.57.1",
-        "@rollup/rollup-linux-arm-musleabihf": "4.57.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.57.1",
-        "@rollup/rollup-linux-arm64-musl": "4.57.1",
-        "@rollup/rollup-linux-loong64-gnu": "4.57.1",
-        "@rollup/rollup-linux-loong64-musl": "4.57.1",
-        "@rollup/rollup-linux-ppc64-gnu": "4.57.1",
-        "@rollup/rollup-linux-ppc64-musl": "4.57.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.57.1",
-        "@rollup/rollup-linux-riscv64-musl": "4.57.1",
-        "@rollup/rollup-linux-s390x-gnu": "4.57.1",
-        "@rollup/rollup-linux-x64-gnu": "4.57.1",
-        "@rollup/rollup-linux-x64-musl": "4.57.1",
-        "@rollup/rollup-openbsd-x64": "4.57.1",
-        "@rollup/rollup-openharmony-arm64": "4.57.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.57.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.57.1",
-        "@rollup/rollup-win32-x64-gnu": "4.57.1",
-        "@rollup/rollup-win32-x64-msvc": "4.57.1",
+        "@rollup/rollup-android-arm-eabi": "4.60.0",
+        "@rollup/rollup-android-arm64": "4.60.0",
+        "@rollup/rollup-darwin-arm64": "4.60.0",
+        "@rollup/rollup-darwin-x64": "4.60.0",
+        "@rollup/rollup-freebsd-arm64": "4.60.0",
+        "@rollup/rollup-freebsd-x64": "4.60.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.0",
+        "@rollup/rollup-linux-arm64-musl": "4.60.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.0",
+        "@rollup/rollup-linux-loong64-musl": "4.60.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-musl": "4.60.0",
+        "@rollup/rollup-openbsd-x64": "4.60.0",
+        "@rollup/rollup-openharmony-arm64": "4.60.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.0",
+        "@rollup/rollup-win32-x64-gnu": "4.60.0",
+        "@rollup/rollup-win32-x64-msvc": "4.60.0",
         "fsevents": "~2.3.2"
       }
     },
@@ -1963,6 +2051,23 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
     "node_modules/tree-kill": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
@@ -2012,21 +2117,24 @@
       }
     },
     "node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "version": "6.4.2",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz",
+      "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
@@ -2035,19 +2143,25 @@
         "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
         "less": "*",
         "lightningcss": "^1.21.0",
         "sass": "*",
         "sass-embedded": "*",
         "stylus": "*",
         "sugarss": "*",
-        "terser": "^5.4.0"
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
         "@types/node": {
           "optional": true
         },
+        "jiti": {
+          "optional": true
+        },
         "less": {
           "optional": true
         },
@@ -2068,6 +2182,12 @@
         },
         "terser": {
           "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
         }
       }
     },
diff --git a/benchmarks-website-v2/package.json b/benchmarks-website/package.json
similarity index 97%
rename from benchmarks-website-v2/package.json
rename to benchmarks-website/package.json
index 0194ff7652b..9c1bcc623d2 100644
--- a/benchmarks-website-v2/package.json
+++ b/benchmarks-website/package.json
@@ -27,6 +27,6 @@
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.1",
     "concurrently": "^8.2.2",
-    "vite": "^5.4.0"
+    "vite": "^6.0.0"
   }
 }
diff --git a/benchmarks-website/android-chrome-192x192.png b/benchmarks-website/public/android-chrome-192x192.png
similarity index 100%
rename from benchmarks-website/android-chrome-192x192.png
rename to benchmarks-website/public/android-chrome-192x192.png
diff --git a/benchmarks-website/android-chrome-512x512.png b/benchmarks-website/public/android-chrome-512x512.png
similarity index 100%
rename from benchmarks-website/android-chrome-512x512.png
rename to benchmarks-website/public/android-chrome-512x512.png
diff --git a/benchmarks-website/apple-touch-icon.png b/benchmarks-website/public/apple-touch-icon.png
similarity index 100%
rename from benchmarks-website/apple-touch-icon.png
rename to benchmarks-website/public/apple-touch-icon.png
diff --git a/benchmarks-website/favicon-16x16.png b/benchmarks-website/public/favicon-16x16.png
similarity index 100%
rename from benchmarks-website/favicon-16x16.png
rename to benchmarks-website/public/favicon-16x16.png
diff --git a/benchmarks-website/favicon-32x32.png b/benchmarks-website/public/favicon-32x32.png
similarity index 100%
rename from benchmarks-website/favicon-32x32.png
rename to benchmarks-website/public/favicon-32x32.png
diff --git a/benchmarks-website/favicon.ico b/benchmarks-website/public/favicon.ico
similarity index 100%
rename from benchmarks-website/favicon.ico
rename to benchmarks-website/public/favicon.ico
diff --git a/benchmarks-website/site.webmanifest b/benchmarks-website/public/site.webmanifest
similarity index 100%
rename from benchmarks-website/site.webmanifest
rename to benchmarks-website/public/site.webmanifest
diff --git a/benchmarks-website/vortex_black_nobg.svg b/benchmarks-website/public/vortex_black_nobg.svg
similarity index 100%
rename from benchmarks-website/vortex_black_nobg.svg
rename to benchmarks-website/public/vortex_black_nobg.svg
diff --git a/benchmarks-website/public/vortex_white_nobg.svg b/benchmarks-website/public/vortex_white_nobg.svg
new file mode 100644
index 00000000000..767362ad28f
--- /dev/null
+++ b/benchmarks-website/public/vortex_white_nobg.svg
@@ -0,0 +1,70 @@
+<svg width="655" height="190" viewBox="0 0 655 190" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="655" height="190" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M336.632 50.0713C345.675 50.0713 353.42 51.8997 359.866 55.5557C366.409 59.2117 371.46 64.4069 375.02 71.1416C378.579 77.8764 380.359 85.8623 380.359 95.0986C380.359 104.239 378.579 112.224 375.02 119.055C371.46 125.789 366.409 130.986 359.866 134.642C353.324 138.297 345.579 140.125 336.632 140.125C327.781 140.125 320.083 138.297 313.541 134.642C306.999 130.889 301.899 125.646 298.243 118.911C294.683 112.176 292.903 104.239 292.903 95.0986C292.903 85.9586 294.683 78.0209 298.243 71.2861C301.803 64.5514 306.854 59.3562 313.396 55.7002C320.035 51.948 327.78 50.0713 336.632 50.0713ZM336.632 61.9053C327.203 61.9053 319.794 64.8401 314.406 70.709C309.115 76.4817 306.469 84.6118 306.469 95.0986C306.469 105.585 309.115 113.763 314.406 119.632C319.794 125.405 327.203 128.291 336.632 128.291C346.157 128.291 353.565 125.404 358.856 119.632C364.148 113.763 366.794 105.585 366.794 95.0986C366.794 84.5154 364.148 76.3371 358.856 70.5645C353.565 64.7919 346.157 61.9054 336.632 61.9053Z" fill="url(#paint0_linear_4803_85)"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M534.167 50.0713C542.345 50.0714 549.416 51.7549 555.381 55.1221C561.346 58.3932 565.964 63.0599 569.235 69.1211C572.603 75.1824 574.287 82.3508 574.287 90.625V96.6855H504.148C504.533 106.595 507.42 114.341 512.808 119.921C518.292 125.501 525.556 128.291 534.6 128.291C540.853 128.291 546.145 126.944 550.475 124.25C554.9 121.556 557.931 117.66 559.566 112.561H573.421C571.208 121.316 566.685 128.099 559.854 132.909C553.12 137.72 544.75 140.125 534.744 140.125C525.893 140.125 518.196 138.297 511.653 134.642C505.111 130.889 500.06 125.597 496.5 118.767C492.94 111.936 491.16 103.95 491.16 94.8096C491.16 85.6696 492.94 77.7801 496.5 71.1416C500.06 64.4069 505.063 59.2117 511.509 55.5557C517.955 51.8996 525.508 50.0713 534.167 50.0713ZM534.022 61.6172C526.229 61.6172 519.734 63.7818 514.539 68.1113C509.44 72.4408 506.217 78.502 504.87 86.2949H561.153C560.48 78.502 557.738 72.4408 552.928 68.1113C548.117 63.7819 541.815 61.6172 534.022 61.6172Z" fill="url(#paint1_linear_4803_85)"/>
+<path d="M255.222 125.116H255.799L286.105 51.8037H299.671L262.87 138.394H247.284L210.482 51.8037H224.481L255.222 125.116Z" fill="url(#paint2_linear_4803_85)"/>
+<path d="M466.534 51.8037H490.202V62.1943H466.679V127.714H492.511V138.394H465.957C461.916 138.394 458.741 137.384 456.432 135.363C454.219 133.247 453.112 130.119 453.112 125.982V62.1943H435.015C425.971 62.1943 418.899 65.4657 413.8 70.8535C408.701 76.2413 406.151 83.5531 406.151 92.7891V138.394H392.586V66.2354H385.37V51.8037H400.379V67.6777H406.439C408.941 62.5787 412.694 58.5865 417.696 55.7002C422.795 52.7176 428.809 51.8037 435.736 51.8037H453.257V25.8262H466.534V51.8037Z" fill="url(#paint3_linear_4803_85)"/>
+<path d="M610.623 85.2852L636.889 51.8037H651.608L618.849 93.9434L653.341 138.394H637.754L610.189 102.892L582.625 138.394H567.616L602.108 93.9434L569.348 51.8037H584.356L610.623 85.2852Z" fill="url(#paint4_linear_4803_85)"/>
+<path d="M105.168 122.273L105.17 122.274L114.347 127.573L106.886 188.563L97.542 183.169L97.54 183.168L97.3184 183.04L96.7461 182.707L96.8281 182.051L96.8594 181.796L96.8604 181.794L102.731 135.653L65.7314 164.088L65.2021 164.496L64.623 164.163L64.3994 164.034L64.3975 164.033L55.2871 158.773L104.375 121.817L105.168 122.273Z" fill="url(#paint5_linear_4803_85)"/>
+<path d="M82.7344 120.434L82.9043 121.074L82.9688 121.319L85.4756 130.669L85.541 130.916L85.7119 131.555L38.502 168.474L37.3115 169.408L34.2793 158.094L71.7842 129.055L25.7715 123.031L24.8516 122.912L24.6123 122.016L21.8887 111.854L82.7344 120.434Z" fill="url(#paint6_linear_4803_85)"/>
+<path d="M168.337 151.263L168.697 151.721L169.631 152.912L158.317 155.944L129.278 118.438L123.222 164.707L123.136 165.372L122.487 165.545L122.238 165.61L122.239 165.611L112.078 168.333L120.564 108.146L120.656 107.489L121.297 107.319L131.14 104.682L131.778 104.512L168.337 151.263Z" fill="url(#paint7_linear_4803_85)"/>
+<path d="M188.787 83.3379L183.264 92.9043L182.931 93.4795L135.878 87.4912L164.721 125.024L164.385 125.604L164.255 125.825L164.256 125.826L158.996 134.937L122.039 85.8477L122.371 85.2744L122.498 85.0537L127.797 75.877L188.787 83.3379Z" fill="url(#paint8_linear_4803_85)"/>
+<path d="M67.8545 103.419L68.4072 104.151L63.1084 113.329L63.1074 113.33L62.6484 114.123L1.65918 106.662L7.05469 97.3184L7.18066 97.0977L7.5127 96.5195L8.17383 96.6045L54.5664 102.507L26.291 65.7109L25.7256 64.9775L31.4502 55.0635L67.8545 103.419Z" fill="url(#paint9_linear_4803_85)"/>
+<path d="M69.79 82.5078L69.1533 82.6797L68.9062 82.7461L68.9053 82.7471L59.5547 85.251L59.5557 85.252L58.6699 85.4912L20.8184 37.0869L32.1279 34.0557L32.5361 34.5811L61.167 71.5605L67.3125 24.6279L67.959 24.4561L78.3691 21.666L69.79 82.5078Z" fill="url(#paint10_linear_4803_85)"/>
+<path d="M156.167 31.9062L118.661 60.9434L164.675 66.9688H164.677L165.595 67.0908L168.556 78.1455L107.713 69.5664L104.971 59.332L104.97 59.3301L104.904 59.083L104.734 58.4443L153.136 20.5947L156.167 31.9062Z" fill="url(#paint11_linear_4803_85)"/>
+<path d="M92.9033 6.83105L93.126 6.95801L93.7031 7.29004L87.7148 54.3438L125.248 25.5029L126.051 25.9678L135.16 31.2275L86.6006 67.7861L86.0713 68.1836L76.8945 62.8857L76.8936 62.8848L76.1006 62.4258L83.5615 1.43652L92.9033 6.83105Z" fill="url(#paint12_linear_4803_85)"/>
+<defs>
+<linearGradient id="paint0_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint1_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint2_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint3_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint4_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint5_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint6_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint7_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint8_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint9_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint10_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint11_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+<linearGradient id="paint12_linear_4803_85" x1="327.5" y1="1.43652" x2="327.5" y2="188.563" gradientUnits="userSpaceOnUse">
+<stop stop-color="white"/>
+<stop offset="1" stop-color="#CDCDCD"/>
+</linearGradient>
+</defs>
+</svg>
diff --git a/benchmarks-website/scoring.js b/benchmarks-website/scoring.js
deleted file mode 100644
index 95b3d020ffb..00000000000
--- a/benchmarks-website/scoring.js
+++ /dev/null
@@ -1,634 +0,0 @@
-"use strict";
-
-// Scoring module for benchmarks
-const scoring = {
-  isQueryBenchmark(categoryName) {
-    return (
-      categoryName === "Clickbench" ||
-      categoryName.startsWith("TPC-H") ||
-      categoryName.startsWith("TPC-DS") ||
-      categoryName === "Statistical and Population Genetics"
-    );
-  },
-
-  isRandomAccessBenchmark(categoryName) {
-    return categoryName === "Random Access";
-  },
-
-  isCompressionBenchmark(categoryName) {
-    return categoryName === "Compression";
-  },
-
-  isCompressionSizeBenchmark(categoryName) {
-    return categoryName === "Compression Size";
-  },
-
-  // Helper: Get latest data point for each series across all queries
-  getLatestDataPerSeries(benchSet) {
-    const seriesLatestData = new Map();
-
-    // First pass: collect all unique series names across all queries
-    const allSeriesNames = new Set();
-    for (const [queryName, queryData] of benchSet.entries()) {
-      if (!queryData.series || queryData.series.size === 0) continue;
-      for (const seriesName of queryData.series.keys()) {
-        allSeriesNames.add(seriesName);
-      }
-    }
-
-    // Initialize the map with all series names (empty Maps for each)
-    for (const seriesName of allSeriesNames) {
-      seriesLatestData.set(seriesName, new Map());
-    }
-
-    // Second pass: populate with latest non-null values where available
-    for (const [queryName, queryData] of benchSet.entries()) {
-      if (!queryData.series || queryData.series.size === 0) continue;
-
-      for (const [seriesName, seriesData] of queryData.series.entries()) {
-        // Find the most recent non-null value for this series
-        for (let i = seriesData.length - 1; i >= 0; i--) {
-          const result = seriesData[i];
-          if (result && result.value !== null && result.value !== undefined) {
-            seriesLatestData.get(seriesName).set(queryName, result.value);
-            break;
-          }
-        }
-      }
-    }
-
-    return seriesLatestData;
-  },
-
-  // Helper: Calculate geometric mean score for query benchmarks
-  calculateGeometricMeanScores(seriesLatestData, benchSet) {
-    const seriesScores = new Map();
-
-    for (const [seriesName, queryResults] of seriesLatestData.entries()) {
-      const ratios = [];
-      let totalRuntime = 0;
-      let maxRuntime = 0;
-
-      // Calculate max runtime for penalty
-      for (const runtime of queryResults.values()) {
-        maxRuntime = Math.max(maxRuntime, runtime);
-        totalRuntime += runtime;
-      }
-
-      // Apply penalty rules: if max runtime < 300s, use 300s, then multiply by 2
-      const penalty = Math.max(300000, maxRuntime) * 2;
-
-      // For each query, calculate ratio against baseline
-      for (const [queryName, queryData] of benchSet.entries()) {
-        // Find baseline (best result) across all series for this query
-        let baseline = Infinity;
-
-        for (const [sName, latestData] of seriesLatestData.entries()) {
-          if (latestData.has(queryName)) {
-            baseline = Math.min(baseline, latestData.get(queryName));
-          }
-        }
-
-        if (baseline === Infinity) continue;
-
-        // Get this series' result or use penalty
-        const seriesRuntime = queryResults.has(queryName)
-          ? queryResults.get(queryName)
-          : penalty;
-
-        // Calculate ratio with 10ms constant shift
-        const ratio = (10 + seriesRuntime) / (10 + baseline);
-        ratios.push(ratio);
-      }
-
-      if (ratios.length > 0) {
-        const product = ratios.reduce((acc, ratio) => acc * ratio, 1);
-        const geometricMean = Math.pow(product, 1 / ratios.length);
-        seriesScores.set(seriesName, {
-          score: geometricMean,
-          queryCount: ratios.length,
-          totalRuntime: totalRuntime,
-          actualQueryCount: queryResults.size,
-        });
-      }
-    }
-
-    return seriesScores;
-  },
-
-  calculateClickBenchScore(benchSet) {
-    if (!benchSet || benchSet.size === 0) return null;
-
-    // Step 1: Get latest data for each series
-    const seriesLatestData = this.getLatestDataPerSeries(benchSet);
-
-    if (seriesLatestData.size === 0) return null;
-
-    // Step 2: Calculate scores using the modular scoring function
-    return this.calculateGeometricMeanScores(seriesLatestData, benchSet);
-  },
-
-  formatScoresSummary(scores) {
-    if (!scores || scores.size === 0) return null;
-
-    // Sort by score (lower is better)
-    const sortedScores = Array.from(scores.entries()).sort(
-      (a, b) => a[1].score - b[1].score,
-    );
-
-    const summaryDiv = document.createElement("div");
-    summaryDiv.className = "benchmark-scores-summary";
-
-    const title = document.createElement("h3");
-    title.className = "scores-title";
-    title.textContent = "Performance Summary";
-    summaryDiv.appendChild(title);
-
-    const scoresList = document.createElement("div");
-    scoresList.className = "scores-list";
-
-    sortedScores.forEach(([seriesName, data], index) => {
-      const scoreItem = document.createElement("div");
-      scoreItem.className = "score-item";
-
-      const rank = index + 1;
-      const scoreText = data.score.toFixed(2);
-
-      // Format runtime - assuming it's in milliseconds
-      const formatRuntime = (ms) => {
-        if (ms < 1000) return `${ms.toFixed(0)}ms`;
-        if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-        return `${(ms / 60000).toFixed(1)}m`;
-      };
-
-      const totalRuntimeText = formatRuntime(data.totalRuntime);
-
-      scoreItem.innerHTML = `
-        <span class="score-rank">#${rank}</span>
-        <span class="score-series">${seriesName}</span>
-        <span class="score-metrics">
-          <span class="score-value">${scoreText}x</span>
-          <span class="score-runtime">${totalRuntimeText}</span>
-        </span>
-      `;
-
-      scoresList.appendChild(scoreItem);
-    });
-
-    summaryDiv.appendChild(scoresList);
-
-    const explanation = document.createElement("div");
-    explanation.className = "scores-explanation";
-    explanation.textContent =
-      "Score: geometric mean of query time ratio to fastest with 10ms constant shift | Total: sum of all query times (lower is better)";
-    summaryDiv.appendChild(explanation);
-
-    return summaryDiv;
-  },
-
-  calculateRandomAccessMetrics(benchSet) {
-    if (!benchSet || benchSet.size === 0) return null;
-
-    // For Random Access, we want the latest data point for each series
-    const latestResults = new Map();
-
-    // Get the first (and likely only) query in the benchmark set
-    for (const [queryName, queryData] of benchSet.entries()) {
-      if (!queryData.series || queryData.series.size === 0) continue;
-
-      // Find the most recent commit with data
-      let latestCommitWithData = -1;
-      for (let i = queryData.commits.length - 1; i >= 0; i--) {
-        let hasData = false;
-        for (const [seriesName, seriesData] of queryData.series.entries()) {
-          const result = seriesData[i];
-          if (result && result.value !== null && result.value !== undefined) {
-            hasData = true;
-            break;
-          }
-        }
-        if (hasData) {
-          latestCommitWithData = i;
-          break;
-        }
-      }
-
-      if (latestCommitWithData === -1) continue;
-
-      // Get results for all series at the latest commit with data
-      for (const [seriesName, seriesData] of queryData.series.entries()) {
-        if (latestCommitWithData < seriesData.length) {
-          const result = seriesData[latestCommitWithData];
-          if (result && result.value !== null && result.value !== undefined) {
-            latestResults.set(seriesName, result.value);
-          }
-        }
-      }
-
-      break; // Only process the first query for Random Access
-    }
-
-    if (latestResults.size === 0) return null;
-
-    // Find the fastest time
-    let fastestTime = Infinity;
-    for (const time of latestResults.values()) {
-      fastestTime = Math.min(fastestTime, time);
-    }
-
-    // Calculate metrics for each series
-    const seriesMetrics = new Map();
-    for (const [seriesName, time] of latestResults.entries()) {
-      seriesMetrics.set(seriesName, {
-        time: time,
-        ratio: time / fastestTime,
-      });
-    }
-
-    return seriesMetrics;
-  },
-
-  formatRandomAccessSummary(metrics) {
-    if (!metrics || metrics.size === 0) return null;
-
-    // Sort by time (lower is better)
-    const sortedMetrics = Array.from(metrics.entries()).sort(
-      (a, b) => a[1].time - b[1].time,
-    );
-
-    const summaryDiv = document.createElement("div");
-    summaryDiv.className = "benchmark-scores-summary";
-
-    const title = document.createElement("h3");
-    title.className = "scores-title";
-    title.textContent = "Random Access Performance";
-    summaryDiv.appendChild(title);
-
-    const metricsList = document.createElement("div");
-    metricsList.className = "scores-list";
-
-    // Format time helper
-    const formatTime = (ms) => {
-      if (ms < 1) return `${(ms * 1000).toFixed(0)}μs`;
-      if (ms < 1000) return `${ms.toFixed(1)}ms`;
-      return `${(ms / 1000).toFixed(2)}s`;
-    };
-
-    sortedMetrics.forEach(([seriesName, data], index) => {
-      const metricItem = document.createElement("div");
-      metricItem.className = "score-item";
-
-      const rank = index + 1;
-      const timeText = formatTime(data.time);
-      const ratioText = data.ratio.toFixed(2);
-
-      metricItem.innerHTML = `
-        <span class="score-rank">#${rank}</span>
-        <span class="score-series">${seriesName}</span>
-        <span class="score-metrics">
-          <span class="score-runtime">${timeText}</span>
-          <span class="score-value">${ratioText}x</span>
-        </span>
-      `;
-
-      metricsList.appendChild(metricItem);
-    });
-
-    summaryDiv.appendChild(metricsList);
-
-    const explanation = document.createElement("div");
-    explanation.className = "scores-explanation";
-    explanation.textContent =
-      "Random access time | Ratio to fastest (lower is better)";
-    summaryDiv.appendChild(explanation);
-
-    return summaryDiv;
-  },
-
-  calculateCompressionMetrics(benchSet) {
-    if (!benchSet || benchSet.size === 0) return null;
-
-    // For Compression, we want the geometric mean of the ratio charts
-    const compressRatios = [];
-    const decompressRatios = [];
-
-    // Find the specific ratio charts
-    const compressRatioChart = benchSet.get(
-      "VORTEX:PARQUET-ZSTD RATIO COMPRESS TIME",
-    );
-    const decompressRatioChart = benchSet.get(
-      "VORTEX:PARQUET-ZSTD RATIO DECOMPRESS TIME",
-    );
-
-    if (!compressRatioChart && !decompressRatioChart) return null;
-
-    // Find the most recent commit with data
-    let latestCommitWithData = -1;
-
-    // Check compress ratio chart
-    if (compressRatioChart && compressRatioChart.series) {
-      for (let i = compressRatioChart.commits.length - 1; i >= 0; i--) {
-        let hasData = false;
-        for (const [
-          seriesName,
-          seriesData,
-        ] of compressRatioChart.series.entries()) {
-          const result = seriesData[i];
-          if (result && result.value !== null && result.value !== undefined) {
-            hasData = true;
-            break;
-          }
-        }
-        if (hasData) {
-          latestCommitWithData = i;
-          break;
-        }
-      }
-    }
-
-    // Check decompress ratio chart if we haven't found data yet
-    if (
-      latestCommitWithData === -1 &&
-      decompressRatioChart &&
-      decompressRatioChart.series
-    ) {
-      for (let i = decompressRatioChart.commits.length - 1; i >= 0; i--) {
-        let hasData = false;
-        for (const [
-          seriesName,
-          seriesData,
-        ] of decompressRatioChart.series.entries()) {
-          const result = seriesData[i];
-          if (result && result.value !== null && result.value !== undefined) {
-            hasData = true;
-            break;
-          }
-        }
-        if (hasData) {
-          latestCommitWithData = i;
-          break;
-        }
-      }
-    }
-
-    if (latestCommitWithData === -1) return null;
-
-    // Collect compress ratios (excluding wide table cols)
-    if (compressRatioChart && compressRatioChart.series) {
-      for (const [
-        seriesName,
-        seriesData,
-      ] of compressRatioChart.series.entries()) {
-        // Skip wide table cols datasets
-        if (seriesName.toLowerCase().startsWith("wide table cols")) continue;
-
-        if (latestCommitWithData < seriesData.length) {
-          const result = seriesData[latestCommitWithData];
-          if (
-            result &&
-            result.value !== null &&
-            result.value !== undefined &&
-            result.value > 0
-          ) {
-            // Invert the ratio (1/value) so higher is better
-            compressRatios.push(1 / result.value);
-          }
-        }
-      }
-    }
-
-    // Collect decompress ratios (excluding wide table cols)
-    if (decompressRatioChart && decompressRatioChart.series) {
-      for (const [
-        seriesName,
-        seriesData,
-      ] of decompressRatioChart.series.entries()) {
-        // Skip wide table cols datasets
-        if (seriesName.toLowerCase().startsWith("wide table cols")) continue;
-
-        if (latestCommitWithData < seriesData.length) {
-          const result = seriesData[latestCommitWithData];
-          if (
-            result &&
-            result.value !== null &&
-            result.value !== undefined &&
-            result.value > 0
-          ) {
-            // Invert the ratio (1/value) so higher is better
-            decompressRatios.push(1 / result.value);
-          }
-        }
-      }
-    }
-
-    // Calculate geometric means
-    const calculateGeometricMean = (values) => {
-      if (values.length === 0) return null;
-      const product = values.reduce((acc, val) => acc * val, 1);
-      return Math.pow(product, 1 / values.length);
-    };
-
-    const metrics = {
-      compressRatio: calculateGeometricMean(compressRatios),
-      decompressRatio: calculateGeometricMean(decompressRatios),
-      compressCount: compressRatios.length,
-      decompressCount: decompressRatios.length,
-    };
-
-    return metrics;
-  },
-
-  formatCompressionSummary(metrics) {
-    if (!metrics) return null;
-
-    const summaryDiv = document.createElement("div");
-    summaryDiv.className = "benchmark-scores-summary";
-
-    const title = document.createElement("h3");
-    title.className = "scores-title";
-    title.textContent = "Compression Throughput vs Parquet";
-    summaryDiv.appendChild(title);
-
-    const metricsList = document.createElement("div");
-    metricsList.className = "scores-list";
-
-    // Compress ratio
-    if (metrics.compressRatio !== null) {
-      const compressItem = document.createElement("div");
-      compressItem.className = "score-item";
-      compressItem.innerHTML = `
-        <span class="score-rank">⚡</span>
-        <span class="score-series">Write Speed (Compression)</span>
-        <span class="score-metrics">
-          <span class="score-value">${metrics.compressRatio.toFixed(2)}x</span>
-        </span>
-      `;
-      metricsList.appendChild(compressItem);
-    }
-
-    // Decompress ratio
-    if (metrics.decompressRatio !== null) {
-      const decompressItem = document.createElement("div");
-      decompressItem.className = "score-item";
-      decompressItem.innerHTML = `
-        <span class="score-rank">📤</span>
-        <span class="score-series">Scan Speed (Decompression)</span>
-        <span class="score-metrics">
-          <span class="score-value">${metrics.decompressRatio.toFixed(
-            2,
-          )}x</span>
-        </span>
-      `;
-      metricsList.appendChild(decompressItem);
-    }
-
-    summaryDiv.appendChild(metricsList);
-
-    const explanation = document.createElement("div");
-    explanation.className = "scores-explanation";
-    explanation.textContent =
-      "Inverse geometric mean of Vortex/Parquet ratios across 9 datasets (higher is better)";
-    summaryDiv.appendChild(explanation);
-
-    return summaryDiv;
-  },
-
-  calculateCompressionSizeMetrics(benchSet) {
-    if (!benchSet || benchSet.size === 0) return null;
-
-    // For Compression Size, we want the geometric mean of the size ratio chart
-    const sizeRatios = [];
-
-    // Find the size ratio chart
-    const sizeRatioChart = benchSet.get("VORTEX:PARQUET-ZSTD SIZE");
-
-    if (!sizeRatioChart) return null;
-
-    // Find the most recent commit with data
-    let latestCommitWithData = -1;
-
-    if (sizeRatioChart.series) {
-      for (let i = sizeRatioChart.commits.length - 1; i >= 0; i--) {
-        let hasData = false;
-        for (const [
-          seriesName,
-          seriesData,
-        ] of sizeRatioChart.series.entries()) {
-          const result = seriesData[i];
-          if (result && result.value !== null && result.value !== undefined) {
-            hasData = true;
-            break;
-          }
-        }
-        if (hasData) {
-          latestCommitWithData = i;
-          break;
-        }
-      }
-    }
-
-    if (latestCommitWithData === -1) return null;
-
-    // Collect size ratios (excluding wide table cols)
-    for (const [seriesName, seriesData] of sizeRatioChart.series.entries()) {
-      // Skip wide table cols datasets
-      if (seriesName.toLowerCase().startsWith("wide table cols")) continue;
-
-      if (latestCommitWithData < seriesData.length) {
-        const result = seriesData[latestCommitWithData];
-        if (
-          result &&
-          result.value !== null &&
-          result.value !== undefined &&
-          result.value > 0
-        ) {
-          // Keep the ratio as-is (lower is better for size)
-          sizeRatios.push(result.value);
-        }
-      }
-    }
-
-    // Calculate geometric mean of size ratios
-    const calculateGeometricMean = (values) => {
-      if (values.length === 0) return null;
-      const product = values.reduce((acc, val) => acc * val, 1);
-      return Math.pow(product, 1 / values.length);
-    };
-
-    // Calculate min and max
-    const minRatio = sizeRatios.length > 0 ? Math.min(...sizeRatios) : null;
-    const maxRatio = sizeRatios.length > 0 ? Math.max(...sizeRatios) : null;
-
-    const metrics = {
-      sizeRatio: calculateGeometricMean(sizeRatios),
-      minRatio: minRatio,
-      maxRatio: maxRatio,
-      sizeRatioCount: sizeRatios.length,
-    };
-
-    return metrics;
-  },
-
-  formatCompressionSizeSummary(metrics) {
-    if (!metrics || metrics.sizeRatio === null) return null;
-
-    const summaryDiv = document.createElement("div");
-    summaryDiv.className = "benchmark-scores-summary";
-
-    const title = document.createElement("h3");
-    title.className = "scores-title";
-    title.textContent = "Compression Size Summary";
-    summaryDiv.appendChild(title);
-
-    const metricsList = document.createElement("div");
-    metricsList.className = "scores-list";
-
-    // Min ratio
-    const minItem = document.createElement("div");
-    minItem.className = "score-item";
-    minItem.innerHTML = `
-      <span class="score-rank">⬇️</span>
-      <span class="score-series">Min Size Ratio</span>
-      <span class="score-metrics">
-        <span class="score-value">${metrics.minRatio.toFixed(2)}x</span>
-      </span>
-    `;
-    metricsList.appendChild(minItem);
-
-    // Mean ratio
-    const meanItem = document.createElement("div");
-    meanItem.className = "score-item";
-    meanItem.innerHTML = `
-      <span class="score-rank">📊</span>
-      <span class="score-series">Mean Size Ratio</span>
-      <span class="score-metrics">
-        <span class="score-value">${metrics.sizeRatio.toFixed(2)}x</span>
-      </span>
-    `;
-    metricsList.appendChild(meanItem);
-
-    // Max ratio
-    const maxItem = document.createElement("div");
-    maxItem.className = "score-item";
-    maxItem.innerHTML = `
-      <span class="score-rank">⬆️</span>
-      <span class="score-series">Max Size Ratio</span>
-      <span class="score-metrics">
-        <span class="score-value">${metrics.maxRatio.toFixed(2)}x</span>
-      </span>
-    `;
-    metricsList.appendChild(maxItem);
-
-    summaryDiv.appendChild(metricsList);
-
-    const explanation = document.createElement("div");
-    explanation.className = "scores-explanation";
-    explanation.textContent = `Geometric mean of Vortex/Parquet size ratios across ${metrics.sizeRatioCount} datasets (lower is better)`;
-    summaryDiv.appendChild(explanation);
-
-    return summaryDiv;
-  },
-};
-
-// Export the scoring module
-export { scoring };
diff --git a/benchmarks-website-v2/server.js b/benchmarks-website/server.js
similarity index 98%
rename from benchmarks-website-v2/server.js
rename to benchmarks-website/server.js
index 248feafa9a4..a9af96234fe 100644
--- a/benchmarks-website-v2/server.js
+++ b/benchmarks-website/server.js
@@ -15,10 +15,10 @@ const __dirname = path.dirname(__filename);
 const PORT = process.env.PORT || 3000;
 const DATA_URL =
   process.env.DATA_URL ||
-  "https://vortex-benchmark-results-database.s3.amazonaws.com/data.json.gz";
+  "https://vortex-ci-benchmark-results.s3.amazonaws.com/data.json.gz";
 const COMMITS_URL =
   process.env.COMMITS_URL ||
-  "https://vortex-benchmark-results-database.s3.amazonaws.com/commits.json";
+  "https://vortex-ci-benchmark-results.s3.amazonaws.com/commits.json";
 const REFRESH_INTERVAL = process.env.REFRESH_INTERVAL || 5 * 60 * 1000;
 const MAX_POINTS = 200;
 const USE_LOCAL_DATA = process.env.USE_LOCAL_DATA === "true";
@@ -135,6 +135,13 @@ function formatQuery(q) {
   return q.toUpperCase().replace(/[_-]/g, " ");
 }
 
+function normalizeChartName(group, chartName) {
+  if (group === "Compression Size" && chartName === "VORTEX FILE COMPRESSED SIZE") {
+    return "VORTEX SIZE";
+  }
+  return chartName;
+}
+
 // LTTB downsampling
 function lttbIndices(seriesMap, target) {
   const keys = [...seriesMap.keys()];
@@ -298,6 +305,7 @@ async function refresh() {
         seriesName = rename(parts[1] || "default");
         chartName = formatQuery(parts[0]);
       }
+      chartName = normalizeChartName(group, chartName);
       if (chartName.includes("PARQUET-UNC")) return;
 
       // Skip throughput metrics (keep only time/size)
diff --git a/benchmarks-website-v2/src/App.jsx b/benchmarks-website/src/App.jsx
similarity index 100%
rename from benchmarks-website-v2/src/App.jsx
rename to benchmarks-website/src/App.jsx
diff --git a/benchmarks-website-v2/src/api.js b/benchmarks-website/src/api.js
similarity index 100%
rename from benchmarks-website-v2/src/api.js
rename to benchmarks-website/src/api.js
diff --git a/benchmarks-website-v2/src/components/BenchmarkSection.jsx b/benchmarks-website/src/components/BenchmarkSection.jsx
similarity index 100%
rename from benchmarks-website-v2/src/components/BenchmarkSection.jsx
rename to benchmarks-website/src/components/BenchmarkSection.jsx
diff --git a/benchmarks-website-v2/src/components/BenchmarkSummary.jsx b/benchmarks-website/src/components/BenchmarkSummary.jsx
similarity index 100%
rename from benchmarks-website-v2/src/components/BenchmarkSummary.jsx
rename to benchmarks-website/src/components/BenchmarkSummary.jsx
diff --git a/benchmarks-website-v2/src/components/ChartContainer.jsx b/benchmarks-website/src/components/ChartContainer.jsx
similarity index 93%
rename from benchmarks-website-v2/src/components/ChartContainer.jsx
rename to benchmarks-website/src/components/ChartContainer.jsx
index 588367eb86f..1dfb193e836 100644
--- a/benchmarks-website-v2/src/components/ChartContainer.jsx
+++ b/benchmarks-website/src/components/ChartContainer.jsx
@@ -1,28 +1,28 @@
-import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import {
-  Chart as ChartJS,
   CategoryScale,
+  Chart as ChartJS,
+  Legend,
   LinearScale,
-  PointElement,
   LineElement,
+  PointElement,
   Title,
   Tooltip,
-  Legend,
 } from 'chart.js';
 import zoomPlugin from 'chartjs-plugin-zoom';
-import { Line } from 'react-chartjs-2';
 import {
-  SkipBack,
   ChevronLeft,
   ChevronRight,
+  Expand,
+  MoveHorizontal,
+  SkipBack,
   SkipForward,
   ZoomIn,
   ZoomOut,
-  MoveHorizontal,
-  Expand,
 } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Line } from 'react-chartjs-2';
 import { fetchChartData } from '../api';
-import { stringToColor, formatDate } from '../utils';
+import { formatDate, stringToColor } from '../utils';
 
 ChartJS.register(
   CategoryScale,
@@ -354,7 +354,7 @@ export default function ChartContainer({
           boxWidth: 12,
           padding: 8,
           font: {
-            size: 11,
+            size: 12,
             family: 'Geist, sans-serif',
           },
           usePointStyle: true,
@@ -363,8 +363,8 @@ export default function ChartContainer({
       },
       tooltip: {
         backgroundColor: 'rgba(16, 16, 16, 0.9)',
-        titleFont: { family: 'Geist, sans-serif', size: 12 },
-        bodyFont: { family: 'Geist Mono, monospace', size: 11 },
+        titleFont: { family: 'Geist, sans-serif', size: 13 },
+        bodyFont: { family: 'Geist Mono, monospace', size: 12 },
         padding: 12,
         cornerRadius: 4,
         position: 'topCorner',
@@ -393,6 +393,30 @@ export default function ChartContainer({
             const formattedValue = value < 1 ? value.toFixed(4) : value.toFixed(2);
             return `${item.dataset.label}: ${formattedValue} ${unit || ''}`;
           },
+          labelTextColor: (tooltipItem) => {
+            const chart = tooltipItem.chart;
+            const activeElements = chart._active || [];
+            if (activeElements.length === 0) return '#ffffff';
+            const lastEvent = chart._lastEvent;
+            if (!lastEvent) return '#ffffff';
+            // Find which dataset point is closest to the cursor
+            let hoveredDatasetIndex = activeElements[0].datasetIndex;
+            let closestDist = Infinity;
+            for (const el of activeElements) {
+              const point = chart.getDatasetMeta(el.datasetIndex).data[el.index];
+              if (point) {
+                const dist = Math.hypot(point.x - lastEvent.x, point.y - lastEvent.y);
+                if (dist < closestDist) {
+                  closestDist = dist;
+                  hoveredDatasetIndex = el.datasetIndex;
+                }
+              }
+            }
+            if (tooltipItem.datasetIndex === hoveredDatasetIndex) {
+              return '#ffffff';
+            }
+            return 'rgba(255, 255, 255, 0.45)';
+          },
         },
       },
       zoom: {
@@ -429,13 +453,13 @@ export default function ChartContainer({
         display: true,
         grid: {
           display: true,
-          color: 'rgba(0, 0, 0, 0.12)',
+          color: 'rgba(166, 166, 166, 0.12)',
         },
         ticks: {
           maxRotation: 45,
           minRotation: 45,
           font: {
-            size: 10,
+            size: 11,
             family: 'Geist, sans-serif',
           },
           maxTicksLimit: 10,
@@ -457,11 +481,11 @@ export default function ChartContainer({
         display: true,
         beginAtZero: true,
         grid: {
-          color: 'rgba(0, 0, 0, 0.12)',
+          color: 'rgba(166, 166, 166, 0.12)',
         },
         ticks: {
           font: {
-            size: 11,
+            size: 12,
             family: 'Geist Mono, monospace',
           },
         },
@@ -469,7 +493,7 @@ export default function ChartContainer({
           display: !!unit,
           text: unit || '',
           font: {
-            size: 11,
+            size: 12,
             family: 'Geist, sans-serif',
           },
         },
diff --git a/benchmarks-website-v2/src/components/Header.jsx b/benchmarks-website/src/components/Header.jsx
similarity index 92%
rename from benchmarks-website-v2/src/components/Header.jsx
rename to benchmarks-website/src/components/Header.jsx
index a9280789231..95edda98560 100644
--- a/benchmarks-website-v2/src/components/Header.jsx
+++ b/benchmarks-website/src/components/Header.jsx
@@ -24,11 +24,11 @@ export default function Header({
             ☰
           </button>
           <a href="/" className="logo-link">
-            <img
-              src="/vortex_black_nobg.svg"
-              alt="Vortex"
-              className="site-logo"
-            />
+            <picture>
+                <source srcset="/vortex_black_nobg.svg" media="(prefers-color-scheme: light)"/>
+                <source srcset="/vortex_white_nobg.svg" media="(prefers-color-scheme: dark)"/>
+                <img src="/vortex_black_nobg.svg" alt="Vortex" className="site-logo"/>
+            </picture>
           </a>
         </div>
 
diff --git a/benchmarks-website-v2/src/components/Modal.jsx b/benchmarks-website/src/components/Modal.jsx
similarity index 100%
rename from benchmarks-website-v2/src/components/Modal.jsx
rename to benchmarks-website/src/components/Modal.jsx
diff --git a/benchmarks-website-v2/src/components/Sidebar.jsx b/benchmarks-website/src/components/Sidebar.jsx
similarity index 93%
rename from benchmarks-website-v2/src/components/Sidebar.jsx
rename to benchmarks-website/src/components/Sidebar.jsx
index d60d560c1d1..3a53b801f8e 100644
--- a/benchmarks-website-v2/src/components/Sidebar.jsx
+++ b/benchmarks-website/src/components/Sidebar.jsx
@@ -46,7 +46,7 @@ export default function Sidebar({
 
         <div className="sidebar-footer">
           <a
-            href="https://vortex-benchmark-results-database.s3.amazonaws.com/data.json.gz"
+            href="https://vortex-ci-benchmark-results.s3.amazonaws.com/data.json.gz"
             className="download-btn"
             download
           >
diff --git a/benchmarks-website-v2/src/config.js b/benchmarks-website/src/config.js
similarity index 100%
rename from benchmarks-website-v2/src/config.js
rename to benchmarks-website/src/config.js
diff --git a/benchmarks-website-v2/src/main.jsx b/benchmarks-website/src/main.jsx
similarity index 100%
rename from benchmarks-website-v2/src/main.jsx
rename to benchmarks-website/src/main.jsx
diff --git a/benchmarks-website-v2/src/styles/index.css b/benchmarks-website/src/styles/index.css
similarity index 97%
rename from benchmarks-website-v2/src/styles/index.css
rename to benchmarks-website/src/styles/index.css
index 5f912544d4a..b32bf21377c 100644
--- a/benchmarks-website-v2/src/styles/index.css
+++ b/benchmarks-website/src/styles/index.css
@@ -35,6 +35,20 @@
   --radius-lg: 12px;
 }
 
+@media (prefers-color-scheme: dark) { :root {
+  --primary-color: var(--vortex-blue);
+  --primary-hover: #8a9cff;
+  --accent-color: var(--vortex-green);
+  --bg-color: #050507;
+  --bg-secondary: #121219;
+  --text-color: #F5F5F7;
+  --text-secondary: #A0A0B0;
+  --border-color: #30303a;
+  --shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.6);
+  --shadow-md: 0 4px 8px rgba(0, 0, 0, 0.7);
+  --shadow-lg: 0 12px 24px rgba(0, 0, 0, 0.8);
+}}
+
 /* Reset and base styles */
 * {
   box-sizing: border-box;
@@ -100,6 +114,7 @@ code, pre {
   padding: 0 32px;
   width: 100%;
   gap: 24px;
+  background: var(--bg-secondary);
 }
 
 .header-left {
@@ -177,6 +192,7 @@ code, pre {
   padding: 8px 20px;
   border: 1px solid var(--border-color);
   background: var(--bg-color);
+  color: var(--text-color);
   border-radius: var(--radius-md);
   cursor: pointer;
   font-size: 14px;
@@ -206,6 +222,7 @@ code, pre {
   font-size: 14px;
   font-weight: 500;
   background: var(--bg-color);
+  color: var(--text-color);
   transition: border-color 0.2s;
 }
 
@@ -264,7 +281,7 @@ code, pre {
 /* Sidebar Navigation */
 .sidebar {
   width: var(--sidebar-width);
-  background: rgba(250, 250, 250, 0.98);
+  background: var(--bg-secondary);
   -webkit-backdrop-filter: blur(10px);
   backdrop-filter: blur(10px);
   border-right: 1px solid var(--border-color);
@@ -508,6 +525,7 @@ code, pre {
   padding: 16px 32px;
   background: var(--bg-secondary);
   border-bottom: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
   cursor: pointer;
   -webkit-user-select: none;
   user-select: none;
@@ -516,7 +534,7 @@ code, pre {
 }
 
 .benchmark-header:hover {
-  background: #F5F5F5;
+  background: var(--bg-color);
 }
 
 .title-wrapper {
diff --git a/benchmarks-website-v2/src/utils.js b/benchmarks-website/src/utils.js
similarity index 100%
rename from benchmarks-website-v2/src/utils.js
rename to benchmarks-website/src/utils.js
diff --git a/benchmarks-website/style.css b/benchmarks-website/style.css
deleted file mode 100644
index 514f1c1079f..00000000000
--- a/benchmarks-website/style.css
+++ /dev/null
@@ -1,1532 +0,0 @@
-/* CSS Variables for consistent theming */
-:root {
-  /* Vortex Brand Colors */
-  --vortex-black: #101010;
-  --vortex-gray: #ECECEC;
-  --vortex-green: #CEE562;
-  --vortex-blue: #5971FD;
-  --vortex-pink: #EEB3E1;
-  
-  /* Theme Colors */
-  --primary-color: var(--vortex-blue);
-  --primary-hover: #4A5FE5;
-  --accent-color: var(--vortex-green);
-  --bg-color: #ffffff;
-  --bg-secondary: #FAFAFA;
-  --text-color: var(--vortex-black);
-  --text-secondary: #666666;
-  --border-color: var(--vortex-gray);
-  
-  /* Layout */
-  --header-height: 72px;
-  --sidebar-width: 280px;
-  --chart-spacing: 24px;
-  --mobile-breakpoint: 768px;
-  --tablet-breakpoint: 1024px;
-  
-  /* Shadows - softer for modern look */
-  --shadow-sm: 0 1px 3px rgba(16,16,16,0.08);
-  --shadow-md: 0 4px 8px rgba(16,16,16,0.08);
-  --shadow-lg: 0 12px 24px rgba(16,16,16,0.12);
-  
-  /* Border Radius */
-  --radius-sm: 4px;
-  --radius-md: 8px;
-  --radius-lg: 12px;
-}
-
-/* Reset and base styles */
-* {
-  box-sizing: border-box;
-}
-
-html {
-  font-family: "Geist", -apple-system, BlinkMacSystemFont, "Segoe UI", "SF Pro Display", Roboto, sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  background-color: var(--bg-color);
-  font-size: 16px;
-  scroll-behavior: smooth;
-  overflow-x: hidden;
-}
-
-body {
-  color: var(--text-color);
-  margin: 0;
-  padding: 0;
-  font-size: 1em;
-  font-weight: 400;
-  padding-top: var(--header-height);
-  line-height: 1.6;
-  letter-spacing: -0.01em;
-  overflow-x: hidden;
-  position: relative;
-}
-
-/* Sticky Header */
-.sticky-header {
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  height: var(--header-height);
-  background: rgba(255, 255, 255, 0.95);
-  -webkit-backdrop-filter: blur(10px);
-  backdrop-filter: blur(10px);
-  border-bottom: 1px solid var(--border-color);
-  box-shadow: var(--shadow-sm);
-  z-index: 1000;
-  display: flex;
-  align-items: center;
-}
-
-.header-content {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  height: 100%;
-  padding: 0 32px;
-  width: 100%;
-}
-
-/* Match padding with main content */
-@media (min-width: 1600px) {
-  .header-content {
-    padding: 0 60px;
-  }
-}
-
-@media (min-width: 1920px) {
-  .header-content {
-    padding: 0 80px;
-  }
-}
-
-.header-left {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-}
-
-.menu-toggle {
-  display: block;
-  background: none;
-  border: none;
-  font-size: 20px;
-  cursor: pointer;
-  padding: 8px;
-  border-radius: var(--radius-sm);
-  transition: all 0.2s;
-  color: var(--text-color);
-}
-
-.menu-toggle:hover {
-  background-color: var(--bg-secondary);
-}
-
-.logo-link {
-  display: flex;
-  align-items: center;
-  text-decoration: none;
-  transition: opacity 0.2s;
-}
-
-.logo-link:hover {
-  opacity: 0.8;
-}
-
-.site-logo {
-  height: 48px;
-  width: auto;
-  display: block;
-}
-
-.site-title {
-  font-family: "Funnel Display", sans-serif;
-  font-size: 1.5rem;
-  font-weight: 600;
-  margin: 0;
-  margin-left: calc(var(--sidebar-width) - 180px); /* Moved left by ~100px */
-  color: var(--text-color);
-  display: none;
-  white-space: nowrap;
-}
-
-/* Show title on desktop screens */
-@media (min-width: 1400px) {
-  .site-title {
-    display: block;
-  }
-}
-
-.header-center {
-  flex: 1;
-  display: flex;
-  justify-content: center;
-  padding: 0 20px;
-}
-
-.filter-controls {
-  display: flex;
-  align-items: center;
-  gap: 16px;
-}
-
-.control-btn, .view-btn {
-  font-family: "Geist", sans-serif;
-  padding: 8px 20px;
-  border: 1px solid var(--border-color);
-  background: var(--bg-color);
-  border-radius: var(--radius-md);
-  cursor: pointer;
-  font-size: 14px;
-  font-weight: 500;
-  transition: all 0.2s;
-  white-space: nowrap;
-}
-
-.control-btn:hover, .view-btn:hover {
-  background-color: var(--bg-secondary);
-  border-color: var(--primary-color);
-  transform: translateY(-1px);
-  box-shadow: var(--shadow-sm);
-}
-
-.view-btn.active {
-  background-color: var(--primary-color);
-  color: white;
-  border-color: var(--primary-color);
-}
-
-.category-filter, .search-filter {
-  font-family: "Geist", sans-serif;
-  padding: 8px 12px;
-  border: 1px solid var(--border-color);
-  border-radius: var(--radius-md);
-  font-size: 14px;
-  font-weight: 500;
-  background: var(--bg-color);
-  transition: border-color 0.2s;
-}
-
-.category-filter:focus, .search-filter:focus {
-  outline: none;
-  border-color: var(--primary-color);
-}
-
-.search-filter {
-  width: 200px;
-}
-
-.header-right {
-  display: flex;
-  align-items: center;
-  gap: 16px;
-}
-
-.view-controls {
-  display: flex;
-  gap: 4px;
-}
-
-.repo-link {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  color: var(--text-color);
-  text-decoration: none;
-  font-weight: 600;
-  font-size: 14px;
-  padding: 8px 16px;
-  border: 1px solid var(--border-color);
-  border-radius: var(--radius-md);
-  transition: all 0.2s;
-}
-
-.github-logo {
-  flex-shrink: 0;
-}
-
-.repo-link:hover {
-  background-color: var(--bg-secondary);
-  border-color: var(--primary-color);
-  color: var(--primary-color);
-}
-
-/* Main Container */
-.main-container {
-  display: flex;
-  min-height: calc(100vh - var(--header-height));
-  overflow-x: hidden;
-  width: 100%;
-}
-
-/* Sidebar Navigation */
-.sidebar {
-  width: var(--sidebar-width);
-  background: rgba(250, 250, 250, 0.98);
-  -webkit-backdrop-filter: blur(10px);
-  backdrop-filter: blur(10px);
-  border-right: 1px solid var(--border-color);
-  position: fixed;
-  top: var(--header-height);
-  left: 0;
-  height: calc(100vh - var(--header-height));
-  overflow-y: auto;
-  transition: transform 0.3s ease;
-  z-index: 998;
-  transform: translateX(-100%); /* Start collapsed by default */
-}
-
-/* Desktop: sidebar overlay styling */
-@media (min-width: 1200px) {
-  .sidebar {
-    box-shadow: 2px 0 12px rgba(0, 0, 0, 0.15);
-  }
-  
-  .sidebar.collapsed {
-    transform: translateX(-100%);
-  }
-  
-  .sidebar:not(.collapsed) {
-    transform: translateX(0);
-  }
-  
-  /* Remove margin from main content - sidebar is now overlay */
-  .main-content {
-    margin-left: 0;
-    width: 100%;
-  }
-}
-
-/* Hide sidebar on tablets and mobile by default */
-@media (max-width: 1199px) {
-  .sidebar {
-    transform: translateX(-100%);
-    box-shadow: 2px 0 12px rgba(0, 0, 0, 0.15);
-  }
-  
-  .sidebar.active {
-    transform: translateX(0);
-  }
-}
-
-.sidebar-nav {
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-}
-
-.sidebar-header {
-  padding: 20px;
-  border-bottom: 1px solid var(--border-color);
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-}
-
-.sidebar-header h2 {
-  font-family: "Funnel Display", sans-serif;
-  margin: 0;
-  font-size: 1.2rem;
-  color: var(--text-color);
-  font-weight: 600;
-}
-
-.sidebar-close {
-  display: none;
-  background: none;
-  border: none;
-  font-size: 24px;
-  cursor: pointer;
-  padding: 4px;
-  line-height: 1;
-}
-
-/* Show close button on tablets and mobile */
-@media (max-width: 1199px) {
-  .sidebar-close {
-    display: block;
-  }
-}
-
-.clear-filter-btn {
-  font-family: "Geist", sans-serif;
-  width: calc(100% - 40px);
-  margin: 16px 20px;
-  padding: 10px 16px;
-  background-color: var(--primary-color);
-  color: white;
-  border: 1px solid var(--primary-color);
-  border-radius: var(--radius-md);
-  font-size: 14px;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.clear-filter-btn:hover {
-  background-color: var(--primary-hover);
-  border-color: var(--primary-hover);
-}
-
-.toc-list {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-  flex: 1;
-  overflow-y: auto;
-}
-
-.toc-list li {
-  border-bottom: 1px solid rgba(0,0,0,0.05);
-}
-
-.toc-list a {
-  display: block;
-  padding: 12px 20px;
-  color: var(--text-color);
-  text-decoration: none;
-  transition: all 0.2s;
-  position: relative;
-}
-
-.toc-list a:hover {
-  background-color: rgba(89, 113, 253, 0.08);
-  color: var(--primary-color);
-  padding-left: 24px;
-}
-
-.toc-list a.active {
-  background-color: rgba(89, 113, 253, 0.12);
-  color: var(--primary-color);
-  font-weight: 600;
-}
-
-.toc-list a.active::before {
-  content: '';
-  position: absolute;
-  left: 0;
-  top: 0;
-  bottom: 0;
-  width: 4px;
-  background-color: var(--primary-color);
-}
-
-.sidebar-footer {
-  padding: 20px;
-  border-top: 1px solid var(--border-color);
-}
-
-.download-btn {
-  display: block;
-  width: 100%;
-  padding: 10px 16px;
-  background-color: transparent;
-  color: var(--text-secondary);
-  text-align: center;
-  text-decoration: none;
-  border: 1px solid var(--border-color);
-  border-radius: var(--radius-md);
-  font-size: 13px;
-  font-weight: 500;
-  transition: all 0.2s;
-}
-
-.download-btn:hover {
-  background-color: var(--bg-secondary);
-  color: var(--text-color);
-  border-color: var(--text-secondary);
-}
-
-/* Main Content */
-.main-content {
-  flex: 1;
-  padding: 32px;
-  width: 100%;
-  position: relative;
-}
-
-/* Larger padding on wide screens */
-@media (min-width: 1600px) {
-  .main-content {
-    padding: 40px 60px;
-  }
-}
-
-@media (min-width: 1920px) {
-  .main-content {
-    padding: 48px 80px;
-  }
-}
-
-/* Adjust padding on smaller screens */
-@media (max-width: 768px) {
-  .main-content {
-    padding: 16px;
-  }
-}
-
-/* Loading Indicator */
-.loading-indicator {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  min-height: 400px;
-  gap: 16px;
-}
-
-.loading-indicator p {
-  font-family: "Geist", sans-serif;
-  color: var(--text-secondary);
-  font-size: 14px;
-  font-weight: 500;
-}
-
-.spinner {
-  width: 48px;
-  height: 48px;
-  border: 3px solid var(--border-color);
-  border-top: 3px solid var(--primary-color);
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
-
-@keyframes spin {
-  0% { transform: rotate(0deg); }
-  100% { transform: rotate(360deg); }
-}
-
-/* Benchmark Sections */
-.benchmark-set {
-  margin-bottom: 48px;
-  background: var(--bg-color);
-  border-radius: var(--radius-lg);
-  border: 1px solid var(--border-color);
-  overflow: visible; /* Changed from hidden to allow sticky headers */
-  transition: all 0.3s ease;
-  position: relative;
-  z-index: 1;
-}
-
-/* Remove top margin from first benchmark set */
-.benchmark-set:first-child {
-  margin-top: 0;
-}
-
-/* Prevent layout shift when first section expands */
-.benchmark-set:first-child:not(.collapsed) {
-  margin-top: 0;
-  padding-top: 0;
-}
-
-/* Style for benchmark groups with no data */
-.benchmark-set.no-data {
-  opacity: 0.5;
-}
-
-.benchmark-set.no-data .benchmark-header {
-  cursor: not-allowed;
-}
-
-.benchmark-set.no-data .benchmark-title {
-  color: var(--text-secondary);
-}
-
-.benchmark-set.no-data .collapse-icon {
-  visibility: hidden;
-}
-
-/* Reduce margin on mobile */
-@media (max-width: 768px) {
-  .benchmark-set {
-    margin-bottom: 24px;
-    border-radius: var(--radius-md);
-  }
-}
-
-.benchmark-set.collapsed .benchmark-graphs {
-  display: none;
-}
-
-.benchmark-set.collapsed .engine-filter-container {
-  display: none;
-}
-
-/* Wrapper to maintain space when header becomes sticky */
-.sticky-header-wrapper {
-  position: relative;
-}
-
-/* Headers are not sticky when collapsed */
-.sticky-header-container {
-  position: relative;
-  z-index: 50;
-  background: var(--bg-secondary);
-  /* Maintain border radius at top */
-  border-radius: var(--radius-lg) var(--radius-lg) 0 0;
-  margin: 0;
-  padding: 0;
-}
-
-/* Sticky headers only on desktop to avoid mobile layout issues */
-@media (min-width: 769px) {
-  .benchmark-set:not(.collapsed) .sticky-header-container {
-    position: sticky;
-    top: calc(var(--header-height) - 1px);
-    /* Add shadow when stuck */
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0);
-    transition: box-shadow 0.2s ease;
-  }
-
-  /* Add shadow when the header is stuck (only for expanded groups) */
-  .benchmark-set:not(.collapsed) .sticky-header-container.is-stuck {
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-  }
-}
-
-
-.benchmark-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 16px 32px;
-  background: var(--bg-secondary);
-  border-bottom: 1px solid var(--border-color);
-  cursor: pointer;
-  -webkit-user-select: none;
-  user-select: none;
-  transition: background-color 0.2s;
-}
-
-/* Adjust padding on smaller screens */
-@media (max-width: 1200px) {
-  .benchmark-header {
-    padding: 14px 24px;
-  }
-}
-
-@media (max-width: 768px) {
-  .benchmark-header {
-    padding: 12px 16px;
-  }
-}
-
-.benchmark-header:hover {
-  background: #F5F5F5;
-}
-
-.title-wrapper {
-  display: flex;
-  align-items: center;
-  gap: 16px;
-  flex: 1;
-  min-width: 0;
-}
-
-.benchmark-title {
-  font-family: "Funnel Display", sans-serif;
-  font-size: 1.5rem;
-  font-weight: 600;
-  margin: 0;
-  color: var(--text-color);
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  letter-spacing: -0.02em;
-  line-height: 1.2;
-}
-
-.group-link-btn {
-  font-size: 18px;
-  background: none;
-  border: none;
-  cursor: pointer;
-  opacity: 0.5;
-  padding: 4px 8px;
-  border-radius: var(--radius-sm);
-  transition: all 0.2s;
-  color: var(--text-secondary);
-}
-
-.benchmark-header:hover .group-link-btn {
-  opacity: 1;
-}
-
-.group-link-btn:hover {
-  background-color: var(--bg-secondary);
-  color: var(--primary-color);
-}
-
-.group-link-btn.copied {
-  color: var(--accent-color);
-  opacity: 1;
-}
-
-.collapse-icon {
-  font-size: 1rem;
-  transition: transform 0.3s ease;
-  flex-shrink: 0;
-}
-
-.benchmark-set.collapsed .collapse-icon {
-  transform: rotate(-90deg);
-}
-
-.benchmark-secondary-info {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  flex-shrink: 0;
-}
-
-.benchmark-meta {
-  font-family: "Geist Mono", monospace;
-  display: flex;
-  gap: 16px;
-  font-size: 11px;
-  font-weight: 500;
-  color: var(--text-secondary);
-  letter-spacing: 0.02em;
-  text-transform: uppercase;
-  flex-shrink: 0;
-  line-height: 1;
-}
-
-/* Info icon with tooltip */
-.info-icon {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 20px;
-  height: 20px;
-  border-radius: 50%;
-  background: var(--bg-secondary);
-  color: var(--text-secondary);
-  font-size: 16px;
-  cursor: help;
-  position: relative;
-  transition: all 0.2s;
-  flex-shrink: 0;
-}
-
-.info-icon:hover {
-  background: var(--primary-color);
-  color: white;
-}
-
-.info-icon::after {
-  content: attr(data-tooltip);
-  position: absolute;
-  top: 100%;
-  left: 50%;
-  transform: translateX(-50%);
-  margin-top: 8px;
-  padding: 8px 12px;
-  background: rgba(16, 16, 16, 0.9);
-  color: white;
-  font-size: 13px;
-  line-height: 1.4;
-  border-radius: var(--radius-sm);
-  white-space: normal;
-  width: 300px;
-  max-width: 90vw;
-  opacity: 0;
-  visibility: hidden;
-  transition: all 0.2s;
-  pointer-events: none;
-  z-index: 100;
-  font-weight: normal;
-}
-
-.info-icon:hover::after {
-  opacity: 1;
-  visibility: visible;
-}
-
-/* Engine Filter Controls */
-.engine-filter-container {
-  padding: 12px 32px;
-  background: var(--bg-secondary);
-  border-bottom: 1px solid var(--border-color);
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  flex-wrap: wrap;
-}
-
-/* Adjust padding on smaller screens */
-@media (max-width: 768px) {
-  .engine-filter-container {
-    padding: 12px 16px;
-  }
-}
-
-.engine-filter-label {
-  font-family: "Geist", sans-serif;
-  font-size: 14px;
-  font-weight: 500;
-  color: var(--text-secondary);
-}
-
-.engine-filter-btn {
-  font-family: "Geist", sans-serif;
-  padding: 6px 14px;
-  border: 1px solid var(--border-color);
-  background: var(--bg-color);
-  border-radius: var(--radius-sm);
-  font-size: 13px;
-  font-weight: 500;
-  color: var(--text-color);
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.engine-filter-btn:hover {
-  background-color: var(--bg-secondary);
-  border-color: var(--primary-color);
-}
-
-.engine-filter-btn.active {
-  background-color: var(--primary-color);
-  color: white;
-  border-color: var(--primary-color);
-}
-
-.engine-filter-btn.active:hover {
-  background-color: var(--primary-hover);
-  border-color: var(--primary-hover);
-}
-
-.filter-separator {
-  margin: 0 12px;
-  color: var(--border-color);
-  font-weight: 300;
-}
-
-.reset-zoom-btn {
-  font-family: "Geist", sans-serif;
-  padding: 6px 14px;
-  border: 1px solid var(--border-color);
-  background: var(--bg-color);
-  border-radius: var(--radius-sm);
-  font-size: 13px;
-  font-weight: 500;
-  color: var(--text-secondary);
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.reset-zoom-btn:hover {
-  background-color: var(--bg-secondary);
-  border-color: var(--primary-color);
-  color: var(--text-color);
-}
-
-/* Chart Grid */
-.benchmark-graphs {
-  display: grid;
-  grid-template-columns: 1fr;
-  gap: 20px;
-  padding: 20px;
-  /* Maintain border radius at bottom */
-  border-radius: 0 0 var(--radius-lg) var(--radius-lg);
-  background: var(--bg-color);
-}
-
-/* Two columns on larger screens */
-@media (min-width: 1200px) {
-  .benchmark-graphs {
-    grid-template-columns: repeat(2, 1fr);
-    gap: 24px;
-    padding: 24px;
-  }
-  
-  /* Single chart groups should use full width */
-  .benchmark-graphs.single-chart {
-    grid-template-columns: 1fr;
-    max-width: 1400px;
-    margin: 0 auto;
-  }
-}
-
-/* Use more space on wider screens */
-@media (min-width: 1600px) {
-  .benchmark-graphs {
-    padding: 28px 32px;
-  }
-  
-  .benchmark-graphs.single-chart {
-    max-width: 1600px;
-  }
-}
-
-@media (min-width: 1920px) {
-  .benchmark-graphs.single-chart {
-    max-width: 1800px;
-  }
-}
-
-/* Single column up to 1200px for better readability */
-@media (max-width: 1199px) {
-  .benchmark-graphs {
-    grid-template-columns: 1fr;
-    max-width: 900px;
-    margin: 0 auto;
-  }
-}
-
-.benchmark-graphs.list-view {
-  grid-template-columns: 1fr;
-  max-width: 1200px;
-  margin: 0 auto;
-}
-
-@media (min-width: 1600px) {
-  .benchmark-graphs.list-view {
-    max-width: 1400px;
-  }
-}
-
-.chart-container {
-  background: var(--bg-color);
-  border: 1px solid var(--border-color);
-  border-radius: var(--radius-md);
-  padding: 20px;
-  position: relative;
-  transition: all 0.3s ease;
-  display: flex;
-  flex-direction: column;
-}
-
-/* Larger padding on bigger screens */
-@media (min-width: 1600px) {
-  .chart-container {
-    padding: 24px;
-  }
-}
-
-.chart-container:hover {
-  box-shadow: var(--shadow-md);
-  transform: translateY(-2px);
-  border-color: var(--primary-color);
-}
-
-.chart-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 8px;
-}
-
-.chart-title {
-  font-family: "Funnel Display", sans-serif;
-  font-size: 16px;
-  font-weight: 500;
-  color: var(--text-color);
-  letter-spacing: -0.01em;
-}
-
-.chart-actions {
-  display: flex;
-  gap: 8px;
-}
-
-.chart-action-btn {
-  background: var(--bg-color);
-  border: 1px solid var(--border-color);
-  padding: 6px 12px;
-  border-radius: var(--radius-sm);
-  cursor: pointer;
-  font-size: 12px;
-  font-weight: 500;
-  transition: all 0.2s;
-}
-
-.chart-action-btn:hover {
-  background-color: #f5f5f5;
-  border-color: var(--primary-color);
-}
-
-/* Back to Top Button */
-.back-to-top {
-  position: fixed;
-  bottom: 32px;
-  right: 32px;
-  width: 48px;
-  height: 48px;
-  background-color: var(--primary-color);
-  color: white;
-  border: none;
-  border-radius: 50%;
-  font-size: 20px;
-  cursor: pointer;
-  box-shadow: 0 4px 12px rgba(89, 113, 253, 0.3);
-  opacity: 0;
-  visibility: hidden;
-  transition: all 0.3s ease;
-  z-index: 999;
-}
-
-.back-to-top.visible {
-  opacity: 1;
-  visibility: visible;
-}
-
-.back-to-top:hover {
-  background-color: var(--primary-hover);
-  transform: translateY(-4px);
-  box-shadow: 0 8px 20px rgba(89, 113, 253, 0.4);
-}
-
-/* Chart Modal */
-.chart-modal {
-  display: none;
-  position: fixed;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  background-color: rgba(0, 0, 0, 0.8);
-  z-index: 2000;
-}
-
-.chart-modal.active {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.modal-content {
-  background: var(--bg-color);
-  padding: 32px;
-  border-radius: var(--radius-lg);
-  width: 90%;
-  max-width: 1200px;
-  height: 80vh;
-  position: relative;
-  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.2);
-}
-
-.modal-close {
-  position: absolute;
-  top: 16px;
-  right: 16px;
-  background: none;
-  border: none;
-  font-size: 32px;
-  cursor: pointer;
-  color: #666;
-  padding: 0;
-  width: 40px;
-  height: 40px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 4px;
-  transition: all 0.2s;
-}
-
-.modal-close:hover {
-  background-color: rgba(0, 0, 0, 0.05);
-  color: #333;
-}
-
-.modal-chart-container {
-  width: 100%;
-  height: calc(100% - 48px);
-  position: relative;
-}
-
-/* Sidebar hover zone - disabled */
-.sidebar-hover-zone {
-  display: none;
-}
-
-/* Sidebar overlay for all screen sizes */
-.sidebar-overlay {
-  display: none;
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: rgba(0, 0, 0, 0.5);
-  z-index: 997;
-}
-
-/* Lighter overlay on desktop for better UX */
-@media (min-width: 1200px) {
-  .sidebar-overlay {
-    background: rgba(0, 0, 0, 0.3);
-  }
-}
-
-/* Show overlay only when sidebar has explicit 'open' class */
-.sidebar.open ~ .sidebar-overlay {
-  display: block;
-}
-
-/* For mobile - show overlay when active class is present */
-@media (max-width: 1199px) {
-  .sidebar.active ~ .sidebar-overlay {
-    display: block;
-  }
-  
-  /* On mobile, don't use the 'open' class rule */
-  .sidebar.open ~ .sidebar-overlay {
-    display: none;
-  }
-  
-  /* Re-enable for mobile active state */
-  .sidebar.active ~ .sidebar-overlay {
-    display: block;
-  }
-}
-
-/* Site title visibility handled in the .site-title section above */
-
-/* Tablet styles */
-@media (min-width: 769px) and (max-width: 1199px) {
-  .header-center {
-    display: flex;
-  }
-  
-  .search-filter {
-    width: 150px;
-  }
-}
-
-@media (max-width: 768px) {
-  :root {
-    --header-height: 56px;
-  }
-  
-  body {
-    padding-top: var(--header-height);
-  }
-
-  .header-content {
-    padding: 0 8px;
-    gap: 8px;
-  }
-
-  .header-left {
-    gap: 8px;
-  }
-
-  .header-right {
-    gap: 8px;
-  }
-
-  .site-logo {
-    height: 32px;
-  }
-  
-  .site-title {
-    display: none;
-  }
-
-  .view-controls {
-    display: none;
-  }
-
-  .repo-link {
-    padding: 6px 10px;
-    font-size: 12px;
-  }
-
-  .repo-link span {
-    display: none;
-  }
-
-  .header-center {
-    display: none;
-  }
-
-  /* Menu toggle and sidebar are handled in their respective sections above */
-
-  .main-content {
-    padding: 16px;
-  }
-
-  .benchmark-set {
-    margin-bottom: 24px;
-  }
-
-  .benchmark-header {
-    padding: 16px;
-    flex-wrap: wrap;
-    gap: 12px;
-  }
-  
-  /* Sticky header handled in the sticky-header-container section above */
-
-  .benchmark-title {
-    font-size: 1.25rem;
-    flex: 1 1 100%;
-  }
-  
-  .title-wrapper {
-    flex-wrap: wrap;
-    flex: 1 1 100%;
-  }
-  
-  .benchmark-secondary-info {
-    flex: 1 1 100%;
-    margin-top: 8px;
-  }
-
-  .benchmark-graphs {
-    grid-template-columns: 1fr;
-    gap: 16px;
-    padding: 16px;
-  }
-  
-  .benchmark-set {
-    border-radius: 0;
-    margin-bottom: 16px;
-  }
-
-  .chart-container {
-    padding: 12px;
-    will-change: auto; /* Prevent unnecessary GPU layers */
-  }
-  
-  .chart-container canvas {
-    max-height: 350px; /* Smaller charts on mobile */
-    min-height: 250px; /* Ensure minimum height */
-  }
-  
-  /* Disable hover effects on mobile */
-  .chart-container:hover {
-    transform: none;
-    box-shadow: none;
-  }
-  
-  /* Hide fullscreen button on mobile */
-  .chart-action-btn {
-    display: none;
-  }
-  
-  /* Hide engine filters on mobile to save space */
-  .engine-filter-container {
-    padding: 12px 16px;
-    flex-wrap: wrap;
-  }
-  
-  .filter-separator {
-    display: none;
-  }
-  
-  /* Hide reset zoom button on mobile since X-axis scrolling is disabled */
-  .reset-zoom-btn {
-    display: none;
-  }
-  
-  /* Hide empty control containers on mobile */
-  .engine-filter-container:not(:has(.engine-filter-btn)) {
-    display: none;
-  }
-
-  .back-to-top {
-    bottom: 16px;
-    right: 16px;
-    width: 40px;
-    height: 40px;
-    font-size: 16px;
-  }
-
-  .modal-content {
-    padding: 16px;
-    height: 90vh;
-  }
-}
-
-/* Additional brand styling */
-.header-content {
-  gap: 24px;
-}
-
-.filter-controls {
-  max-width: 600px;
-}
-
-/* Typography hierarchy */
-h1, h2, h3, h4, h5, h6 {
-  font-family: "Funnel Display", sans-serif;
-  font-weight: 600;
-  letter-spacing: -0.02em;
-}
-
-code, pre {
-  font-family: "Geist Mono", monospace;
-  font-size: 0.9em;
-}
-
-/* Utility Classes */
-.hidden {
-  display: none !important;
-}
-
-.fade-in {
-  animation: fadeIn 0.3s ease;
-}
-
-@keyframes fadeIn {
-  from {
-    opacity: 0;
-    transform: translateY(10px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-/* Chart specific improvements - handled in main .chart-container section above */
-
-.chart-container canvas {
-  max-height: 450px;
-  min-height: 320px;
-  width: 100% !important;
-  height: auto !important;
-  display: block;
-}
-
-.benchmark-graphs.list-view .chart-container canvas {
-  max-height: 600px;
-  min-height: 400px;
-}
-
-/* Larger charts on wide screens */
-@media (min-width: 1600px) {
-  .chart-container canvas {
-    max-height: 520px;
-    min-height: 360px;
-  }
-  
-  .benchmark-graphs.list-view .chart-container canvas {
-    max-height: 620px;
-    min-height: 450px;
-  }
-}
-
-
-/* Wide screen optimizations - keep 2 columns but add more spacing */
-@media (min-width: 1920px) {
-  .benchmark-graphs {
-    grid-template-columns: repeat(2, 1fr);
-    gap: 32px;
-    padding: 32px 48px;
-  }
-  
-  .chart-container canvas {
-    max-height: 580px;
-    min-height: 400px;
-  }
-  
-  .benchmark-graphs.list-view .chart-container canvas {
-    max-height: 680px;
-    min-height: 480px;
-  }
-}
-
-/* Ultra-wide screens - still 2 columns but even more padding */
-@media (min-width: 2400px) {
-  .benchmark-graphs {
-    grid-template-columns: repeat(2, 1fr);
-    gap: 36px;
-    padding: 36px 60px;
-  }
-}
-
-@media (max-width: 480px) {
-  .site-title {
-    font-size: 1rem;
-  }
-  
-  .benchmark-title {
-    font-size: 1.2rem;
-  }
-  
-  .chart-title {
-    font-size: 14px;
-  }
-}
-
-/* Benchmark Scores Summary */
-.benchmark-scores-summary {
-  background: var(--bg-secondary);
-  border-bottom: 1px solid var(--border-color);
-  padding: 12px 32px;
-  margin: 0;
-  /* Ensure no top margin when following sticky container */
-  margin-top: 0 !important;
-}
-
-@media (max-width: 768px) {
-  .benchmark-scores-summary {
-    padding: 8px 16px;
-  }
-  
-  .benchmark-scores-summary .scores-list {
-    display: flex;
-    flex-direction: column;
-    column-count: 1;
-    gap: 6px;
-  }
-  
-  .benchmark-scores-summary .scores-title {
-    font-size: 11px;
-    margin-bottom: 6px;
-  }
-  
-  .benchmark-scores-summary .score-item {
-    padding: 8px 10px;
-    margin-bottom: 6px;
-    font-size: 12px;
-  }
-  
-  .benchmark-scores-summary .score-rank {
-    font-size: 13px;
-    min-width: 28px;
-  }
-  
-  .benchmark-scores-summary .score-series {
-    font-size: 13px;
-    margin: 0 6px;
-  }
-  
-  .benchmark-scores-summary .score-value {
-    font-size: 12px;
-    padding: 2px 8px;
-  }
-  
-  .benchmark-scores-summary .score-runtime,
-  .benchmark-scores-summary .score-label {
-    font-size: 11px;
-  }
-  
-  .benchmark-scores-summary .scores-explanation {
-    font-size: 11px;
-    margin-top: 6px;
-  }
-}
-
-.scores-title {
-  font-size: 12px;
-  font-weight: 600;
-  margin: 0 0 8px 0;
-  color: var(--text-secondary);
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-}
-
-.scores-list {
-  column-count: 2;
-  column-gap: 20px;
-}
-
-/* Single item should use full width */
-.scores-list:has(.score-item:only-child) {
-  column-count: 1;
-}
-
-/* Single column for smaller screens */
-@media (max-width: 780px) {
-  .scores-list {
-    column-count: 1;
-  }
-}
-
-.score-item {
-  display: flex;
-  align-items: center;
-  background: var(--bg-color);
-  padding: 10px 12px;
-  margin-bottom: 8px;
-  border-radius: var(--radius-sm);
-  border: 1px solid var(--border-color);
-  transition: all 0.2s ease;
-  font-size: 13px;
-  break-inside: avoid;
-}
-
-.score-item:hover {
-  border-color: var(--primary-color);
-  background: var(--bg-secondary);
-}
-
-.score-rank {
-  font-weight: 600;
-  color: var(--primary-color);
-  min-width: 30px;
-  font-size: 14px;
-}
-
-.score-series {
-  flex: 1;
-  font-weight: 500;
-  color: var(--text-color);
-  margin: 0 8px;
-  font-size: 14px;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-.score-metrics {
-  display: flex;
-  gap: 6px;
-  align-items: center;
-}
-
-.score-value {
-  font-family: 'Geist Mono', monospace;
-  font-weight: 600;
-  color: var(--text-secondary);
-  background: var(--bg-secondary);
-  padding: 3px 10px;
-  border-radius: var(--radius-sm);
-  font-size: 13px;
-}
-
-.score-runtime {
-  font-family: 'Geist Mono', monospace;
-  font-weight: 600;
-  color: var(--primary-color);
-  background: rgba(89, 113, 253, 0.1);
-  padding: 3px 10px;
-  border-radius: var(--radius-sm);
-  font-size: 13px;
-}
-
-.scores-explanation {
-  margin-top: 8px;
-  font-size: 11px;
-  color: var(--text-secondary);
-  font-style: italic;
-  text-align: center;
-}
-
-.score-label {
-  font-size: 13px;
-  color: var(--text-secondary);
-  margin: 0 2px;
-}
-
-/* Responsive - consolidated with above mobile styles */
-@media (max-width: 768px) {
-  .score-item {
-    min-width: 0;
-    width: 100%;
-  }
-  
-  .score-series {
-    flex: 1;
-    min-width: 0;
-  }
-}
-
diff --git a/benchmarks-website/utils.js b/benchmarks-website/utils.js
deleted file mode 100644
index d1ef7e30729..00000000000
--- a/benchmarks-website/utils.js
+++ /dev/null
@@ -1,64 +0,0 @@
-"use strict";
-
-import { CONFIG, SERIES_COLOR_MAP, FALLBACK_PALETTE } from './config.js';
-
-// Utility functions
-export const utils = {
-  throttle(func, limit) {
-    let inThrottle;
-    return function (...args) {
-      if (!inThrottle) {
-        func.apply(this, args);
-        inThrottle = true;
-        setTimeout(() => (inThrottle = false), limit);
-      }
-    };
-  },
-
-  debounce(func, wait) {
-    let timeout;
-    return function (...args) {
-      clearTimeout(timeout);
-      timeout = setTimeout(() => func.apply(this, args), wait);
-    };
-  },
-
-  isMobile() {
-    return window.innerWidth <= CONFIG.MOBILE_BREAKPOINT;
-  },
-
-  getDebounceDelay() {
-    return utils.isMobile()
-      ? CONFIG.MOBILE_DEBOUNCE_DELAY
-      : CONFIG.DEBOUNCE_DELAY;
-  },
-
-  stringToColor(str) {
-    // First try the exact string
-    if (SERIES_COLOR_MAP[str]) {
-      return SERIES_COLOR_MAP[str];
-    }
-
-    // Try lowercase version for backward compatibility with old data
-    // This handles cases like "DataFusion:parquet" -> "datafusion:parquet"
-    const lowerStr = str
-      .replace(/^DataFusion:/i, "datafusion:")
-      .replace(/^DuckDB:/i, "duckdb:")
-      .replace(/^Vortex:/i, "vortex:")
-      .replace(/^Arrow:/i, "arrow:");
-
-    if (lowerStr !== str && SERIES_COLOR_MAP[lowerStr]) {
-      return SERIES_COLOR_MAP[lowerStr];
-    }
-
-    const hash = new Hashes.MD5().hex(str);
-    const index = parseInt(hash.slice(0, 2), 16) % FALLBACK_PALETTE.length;
-    return FALLBACK_PALETTE[index];
-  },
-
-  batchDOMUpdates(updates) {
-    requestAnimationFrame(() => {
-      updates.forEach((update) => update());
-    });
-  },
-};
\ No newline at end of file
diff --git a/benchmarks-website-v2/vite.config.js b/benchmarks-website/vite.config.js
similarity index 100%
rename from benchmarks-website-v2/vite.config.js
rename to benchmarks-website/vite.config.js
diff --git a/benchmarks-website/worker-manager.js b/benchmarks-website/worker-manager.js
deleted file mode 100644
index 11b17116767..00000000000
--- a/benchmarks-website/worker-manager.js
+++ /dev/null
@@ -1,167 +0,0 @@
-"use strict";
-
-import { dataProcessor } from './data-processor.js';
-
-// Worker manager for handling web worker communication and fallbacks
-export const workerManager = {
-  dataWorker: null,
-  supportsWorkers: typeof Worker !== 'undefined',
-  isProcessing: false,
-  
-  // Initialize workers
-  init() {
-    if (this.supportsWorkers) {
-      try {
-        this.dataWorker = new Worker('./data-worker.js', { type: 'module' });
-        return true;
-      } catch (error) {
-        this.supportsWorkers = false;
-        return false;
-      }
-    }
-    return false;
-  },
-
-  // Process data using worker or fallback
-  async processData(benchmarkData, commitsData, keptGroups, onProgress) {
-    if (this.supportsWorkers && this.dataWorker) {
-      this.isProcessing = true;
-      try {
-        const result = await this.processDataWithWorker(benchmarkData, commitsData, keptGroups, onProgress);
-        this.isProcessing = false;
-        return result;
-      } catch (error) {
-        this.isProcessing = false;
-        throw error;
-      }
-    } else {
-      return this.processDataFallback(benchmarkData, commitsData, keptGroups, onProgress);
-    }
-  },
-
-  // Process data using web worker
-  processDataWithWorker(benchmarkData, commitsData, keptGroups, onProgress) {
-    return new Promise((resolve, reject) => {
-      const handleMessage = (e) => {
-        const { type, result, progress, message, error, stack } = e.data;
-        
-        switch (type) {
-          case 'progress':
-            if (onProgress) {
-              onProgress(progress, message);
-            }
-            break;
-            
-          case 'dataProcessed':
-            if (onProgress) {
-              onProgress(progress, message);
-            }
-            // Deserialize the result
-            const deserializedResult = result.map(group => ({
-              name: group.name,
-              dataSet: this.deserializeMap(group.dataSet)
-            }));
-            
-            this.dataWorker.removeEventListener('message', handleMessage);
-            resolve(deserializedResult);
-            break;
-            
-          case 'error':
-            this.dataWorker.removeEventListener('message', handleMessage);
-            reject(new Error(`Worker error: ${error}\n${stack}`));
-            break;
-        }
-      };
-
-      this.dataWorker.addEventListener('message', handleMessage);
-      
-      this.dataWorker.postMessage({
-        type: 'parseData',
-        data: {
-          benchmarkData,
-          commitsData,
-          keptGroups
-        }
-      });
-    });
-  },
-
-  // Fallback data processing on main thread
-  async processDataFallback(benchmarkData, commitsData, keptGroups, onProgress) {
-    if (onProgress) onProgress(10, 'Parsing benchmark data...');
-
-    // benchmarkData is now already parsed as an array
-    const parsedBenchmarkData = Array.isArray(benchmarkData)
-      ? benchmarkData
-      : this.parseJsonl(benchmarkData);
-
-    if (onProgress) onProgress(30, 'Parsing commit data...');
-
-    const parsedCommitsData = this.parseJsonl(commitsData);
-
-    if (onProgress) onProgress(50, 'Processing and grouping data...');
-
-    // Convert commits array to object
-    const commits = {};
-    parsedCommitsData.forEach((commit) => {
-      commits[commit.id] = commit;
-    });
-
-    // Use existing data processor
-    const result = dataProcessor.downloadAndGroupData(
-      parsedBenchmarkData,
-      commits,
-      keptGroups
-    );
-
-    if (onProgress) onProgress(100, 'Data processing complete!');
-
-    return result;
-  },
-
-  // Utility function to parse JSONL
-  parseJsonl(jsonl) {
-    return jsonl
-      .split("\n")
-      .filter((line) => line.trim().length !== 0)
-      .map((line) => JSON.parse(line));
-  },
-
-  // Helper to deserialize Maps from worker
-  deserializeMap(serializedMap) {
-    if (!Array.isArray(serializedMap)) {
-      return serializedMap; // Return as-is if not a serialized array
-    }
-    
-    const result = new Map();
-    for (const [key, value] of serializedMap) {
-      if (value && value.series && typeof value.series === 'object') {
-        // Convert series object back to Map
-        const seriesMap = new Map();
-        for (const [seriesKey, seriesValue] of Object.entries(value.series)) {
-          seriesMap.set(seriesKey, seriesValue);
-        }
-        result.set(key, {
-          ...value,
-          series: seriesMap
-        });
-      } else {
-        result.set(key, value);
-      }
-    }
-    return result;
-  },
-
-  // Clean up workers (with safety check)
-  terminate() {
-    if (this.isProcessing) {
-      setTimeout(() => this.terminate(), 1000);
-      return;
-    }
-    
-    if (this.dataWorker) {
-      this.dataWorker.terminate();
-      this.dataWorker = null;
-    }
-  }
-};
diff --git a/benchmarks-website/zoom-sync.js b/benchmarks-website/zoom-sync.js
deleted file mode 100644
index af7761556d9..00000000000
--- a/benchmarks-website/zoom-sync.js
+++ /dev/null
@@ -1,234 +0,0 @@
-"use strict";
-
-import { CONFIG } from './config.js';
-
-// Zoom synchronization module
-// This module handles synchronizing zoom levels across multiple charts in the same category
-// Dependencies: CONFIG, utils, and state objects must be available globally
-
-// Initialize debounced zoom sync function
-let debouncedSyncZoom = null;
-let throttledZoomHandler = null;
-
-// Cache for chart containers to avoid repeated DOM queries
-const chartContainerCache = new Map();
-
-// IntersectionObserver for tracking visible charts
-let visibilityObserver = null;
-const visibleCharts = new Set();
-
-// Initialize visibility observer for smart batching
-function initializeVisibilityObserver() {
-  if (!visibilityObserver && "IntersectionObserver" in window) {
-    visibilityObserver = new IntersectionObserver(
-      (entries) => {
-        entries.forEach((entry) => {
-          const container = entry.target;
-          const chartKey = container.getAttribute('data-chart-key');
-          
-          if (entry.isIntersecting) {
-            visibleCharts.add(chartKey);
-          } else {
-            visibleCharts.delete(chartKey);
-          }
-        });
-      },
-      {
-        rootMargin: '100px', // Include charts slightly outside viewport
-        threshold: 0.1
-      }
-    );
-  }
-}
-
-// Update container cache for a category
-function updateContainerCache(categoryName) {
-  const categorySection = document.querySelector(`[data-category="${categoryName}"]`);
-  if (!categorySection) return;
-  
-  const containers = categorySection.querySelectorAll(".chart-container");
-  chartContainerCache.set(categoryName, Array.from(containers));
-  
-  // Set up visibility tracking for new containers
-  containers.forEach((container, index) => {
-    const chartKey = `${categoryName}-${index}`;
-    container.setAttribute('data-chart-key', chartKey);
-    
-    if (visibilityObserver) {
-      visibilityObserver.observe(container);
-    }
-  });
-}
-
-// Initialize the debounced zoom sync function
-function initializeDebouncedSync(state, utils) {
-  debouncedSyncZoom = utils.debounce((categoryName) => {
-    const update = state.pendingZoomUpdates.get(categoryName);
-    if (!update) return;
-    
-    const { min, max, sourceIndex } = update;
-    
-    // Performance timing (optional)
-    let startTime;
-    if (CONFIG.ENABLE_ZOOM_PERFORMANCE_TIMING) {
-      startTime = performance.now();
-    }
-    
-    // Get cached containers or update cache
-    let chartContainers = chartContainerCache.get(categoryName);
-    if (!chartContainers) {
-      updateContainerCache(categoryName);
-      chartContainers = chartContainerCache.get(categoryName);
-    }
-    
-    if (!chartContainers) return;
-    
-    // Use requestAnimationFrame for smooth updates
-    requestAnimationFrame(() => {
-      const updateQueue = [];
-      
-      chartContainers.forEach((container, index) => {
-        // Skip the source chart
-        if (index === sourceIndex) return;
-        
-        const chartKey = `${categoryName}-${index}`;
-        
-        // Only update visible charts for better performance
-        if (!visibleCharts.has(chartKey)) return;
-        
-        const chartData = state.chartInstances.get(chartKey);
-        
-        if (chartData?.chart) {
-          updateQueue.push({
-            chart: chartData.chart,
-            min,
-            max
-          });
-        }
-      });
-      
-      // Batch update all charts
-      updateQueue.forEach(({ chart, min, max }) => {
-        chart.options.scales.x.min = min;
-        chart.options.scales.x.max = max;
-        chart.update("none");
-      });
-      
-      // Performance timing (optional)
-      if (CONFIG.ENABLE_ZOOM_PERFORMANCE_TIMING && startTime) {
-        const endTime = performance.now();
-        console.log(`Zoom sync for ${categoryName}: ${(endTime - startTime).toFixed(2)}ms (${updateQueue.length} charts updated, ${visibleCharts.size} visible)`);
-      }
-    });
-    
-    // Clear the pending update
-    state.pendingZoomUpdates.delete(categoryName);
-  }, utils.getDebounceDelay());
-  
-  // Initialize throttled zoom handler for wheel events
-  throttledZoomHandler = utils.throttle((categoryName, sourceChart, sourceIndex, state, utils) => {
-    synchronizeZoomForCategory(categoryName, sourceChart, sourceIndex, true, state, utils);
-  }, CONFIG.ZOOM_THROTTLE_DELAY);
-}
-
-// Simplified synchronization function
-function synchronizeZoomForCategory(
-  categoryName,
-  sourceChart,
-  sourceIndex,
-  isZoom = true,
-  state,
-  utils
-) {
-  // Get the current zoom state from the source chart
-  const xScale = sourceChart.scales.x;
-  const min = xScale.min;
-  const max = xScale.max;
-
-  // Store the update for this category (simplified - no complex anchor logic)
-  state.pendingZoomUpdates.set(categoryName, { min, max, sourceIndex });
-
-  // Debounce the actual sync operation
-  if (debouncedSyncZoom) {
-    debouncedSyncZoom(categoryName);
-  }
-}
-
-// Zoom synchronization module
-export const zoomSync = {
-  // Initialize the zoom sync module with state reference
-  init(state, utils) {
-    initializeDebouncedSync(state, utils);
-    initializeVisibilityObserver();
-  },
-
-  // Recreate debounced sync zoom with new delay (used when mobile/desktop changes)
-  recreateDebouncedSync(state, utils) {
-    initializeDebouncedSync(state, utils);
-  },
-
-  // Main synchronization function with throttling support
-  synchronizeZoomForCategory(
-    categoryName,
-    sourceChart,
-    sourceIndex,
-    isZoom = true,
-    state,
-    utils
-  ) {
-    // Use throttling for wheel-based zoom events for better performance
-    if (isZoom && throttledZoomHandler) {
-      throttledZoomHandler(categoryName, sourceChart, sourceIndex, state, utils);
-    } else {
-      synchronizeZoomForCategory(categoryName, sourceChart, sourceIndex, isZoom, state, utils);
-    }
-  },
-
-  // Update container cache when new charts are added
-  updateCacheForCategory(categoryName) {
-    updateContainerCache(categoryName);
-  },
-
-  // Clean up observers and caches
-  cleanup() {
-    if (visibilityObserver) {
-      visibilityObserver.disconnect();
-      visibilityObserver = null;
-    }
-    chartContainerCache.clear();
-    visibleCharts.clear();
-  },
-
-  resetZoomForCategory(categoryName, state, utils, CONFIG) {
-    // Get cached containers or update cache
-    let containers = chartContainerCache.get(categoryName);
-    if (!containers) {
-      updateContainerCache(categoryName);
-      containers = chartContainerCache.get(categoryName);
-    }
-    
-    if (!containers) return;
-
-    const isCurrentlyMobile = utils.isMobile();
-
-    // Use requestAnimationFrame for smooth updates
-    requestAnimationFrame(() => {
-      containers.forEach((container, index) => {
-        const chartKey = `${categoryName}-${index}`;
-        const chartData = state.chartInstances.get(chartKey);
-
-        if (chartData?.chart) {
-          const chart = chartData.chart;
-          const totalCommits = chart.data.labels.length;
-          const minIndex = isCurrentlyMobile
-            ? 0
-            : Math.max(0, totalCommits - CONFIG.DEFAULT_VISIBLE_COMMITS);
-
-          chart.options.scales.x.min = minIndex;
-          chart.options.scales.x.max = totalCommits - 1;
-          chart.update("none");
-        }
-      });
-    });
-  },
-};
\ No newline at end of file
diff --git a/benchmarks/compress-bench/src/lib.rs b/benchmarks/compress-bench/src/lib.rs
index c429e24e84e..3705343fe5a 100644
--- a/benchmarks/compress-bench/src/lib.rs
+++ b/benchmarks/compress-bench/src/lib.rs
@@ -4,7 +4,8 @@
 use std::sync::Arc;
 
 use ::vortex::array::arrays::ChunkedArray;
-use ::vortex::array::arrays::recursive_list_from_list_view;
+use ::vortex::array::arrays::chunked::ChunkedArrayExt;
+use ::vortex::array::arrays::listview::recursive_list_from_list_view;
 use arrow_array::RecordBatch;
 use arrow_schema::Schema;
 #[cfg(feature = "lance")]
@@ -15,16 +16,15 @@ pub mod vortex;
 pub fn chunked_to_vec_record_batch(
     chunked: ChunkedArray,
 ) -> anyhow::Result<(Vec<RecordBatch>, Arc<Schema>)> {
-    let chunks_vec = chunked.chunks();
-    assert!(!chunks_vec.is_empty(), "empty chunks");
+    assert!(chunked.nchunks() > 0, "empty chunks");
 
-    let batches = chunks_vec
-        .iter()
+    let batches = chunked
+        .iter_chunks()
         .map(|array| {
             // TODO(connor)[ListView]: The rust Parquet implementation does not support writing
             // `ListView` to Parquet files yet.
             let converted_array = recursive_list_from_list_view(array.clone())?;
-            Ok(RecordBatch::try_from(converted_array.as_ref())?)
+            Ok(RecordBatch::try_from(&converted_array)?)
         })
         .collect::<anyhow::Result<Vec<_>>>()?;
 
diff --git a/benchmarks/compress-bench/src/main.rs b/benchmarks/compress-bench/src/main.rs
index 315a5b82f3b..26b71f1abe3 100644
--- a/benchmarks/compress-bench/src/main.rs
+++ b/benchmarks/compress-bench/src/main.rs
@@ -13,7 +13,6 @@ use indicatif::ProgressBar;
 use itertools::Itertools;
 use regex::Regex;
 use vortex::utils::aliases::hash_map::HashMap;
-use vortex_bench::BenchmarkOutput;
 use vortex_bench::Engine;
 use vortex_bench::Format;
 use vortex_bench::Target;
@@ -23,6 +22,7 @@ use vortex_bench::compress::Compressor;
 use vortex_bench::compress::benchmark_compress;
 use vortex_bench::compress::benchmark_decompress;
 use vortex_bench::compress::calculate_ratios;
+use vortex_bench::create_output_writer;
 use vortex_bench::datasets::Dataset;
 use vortex_bench::datasets::struct_list_of_ints::StructListOfInts;
 use vortex_bench::datasets::taxi_data::TaxiData;
@@ -169,8 +169,7 @@ async fn run_compress(
 
     progress.finish();
 
-    let output = BenchmarkOutput::with_path(BENCHMARK_ID, output_path);
-    let mut writer = output.create_writer()?;
+    let mut writer = create_output_writer(&display_format, output_path, BENCHMARK_ID)?;
 
     match display_format {
         DisplayFormat::Table => {
diff --git a/benchmarks/compress-bench/src/parquet.rs b/benchmarks/compress-bench/src/parquet.rs
index 0a4e9105600..aaf64f81c94 100644
--- a/benchmarks/compress-bench/src/parquet.rs
+++ b/benchmarks/compress-bench/src/parquet.rs
@@ -53,7 +53,7 @@ impl Compressor for ParquetCompressor {
         // Read the input parquet file
         let file = File::open(parquet_path)?;
         let builder = ParquetRecordBatchReaderBuilder::try_new(file)?;
-        let schema = builder.schema().clone();
+        let schema = Arc::clone(builder.schema());
         let reader = builder.build()?;
         let batches: Vec<RecordBatch> = reader.collect::<Result<Vec<_>, _>>()?;
 
@@ -69,7 +69,7 @@ impl Compressor for ParquetCompressor {
         // First compress to get the bytes we'll decompress
         let file = File::open(parquet_path)?;
         let builder = ParquetRecordBatchReaderBuilder::try_new(file)?;
-        let schema = builder.schema().clone();
+        let schema = Arc::clone(builder.schema());
         let reader = builder.build()?;
         let batches: Vec<RecordBatch> = reader.collect::<Result<Vec<_>, _>>()?;
 
diff --git a/benchmarks/compress-bench/src/vortex.rs b/benchmarks/compress-bench/src/vortex.rs
index b2eb1a5d490..9d548fd60ec 100644
--- a/benchmarks/compress-bench/src/vortex.rs
+++ b/benchmarks/compress-bench/src/vortex.rs
@@ -12,6 +12,7 @@ use async_trait::async_trait;
 use bytes::Bytes;
 use futures::StreamExt;
 use futures::pin_mut;
+use vortex::array::IntoArray;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::WriteOptionsSessionExt;
 use vortex_bench::Format;
@@ -37,7 +38,7 @@ impl Compressor for VortexCompressor {
         let mut cursor = Cursor::new(&mut buf);
         SESSION
             .write_options()
-            .write(&mut cursor, uncompressed.to_array_stream())
+            .write(&mut cursor, uncompressed.into_array().to_array_stream())
             .await?;
         let elapsed = start.elapsed();
 
@@ -51,7 +52,7 @@ impl Compressor for VortexCompressor {
         let mut cursor = Cursor::new(&mut buf);
         SESSION
             .write_options()
-            .write(&mut cursor, uncompressed.to_array_stream())
+            .write(&mut cursor, uncompressed.into_array().to_array_stream())
             .await?;
 
         // Now decompress
diff --git a/benchmarks/datafusion-bench/src/lib.rs b/benchmarks/datafusion-bench/src/lib.rs
index 43b86331e9f..94ea053ba8f 100644
--- a/benchmarks/datafusion-bench/src/lib.rs
+++ b/benchmarks/datafusion-bench/src/lib.rs
@@ -81,8 +81,10 @@ pub fn make_object_store(
                     .with_bucket_name(bucket_name)
                     .build()?,
             );
-            session
-                .register_object_store(&Url::parse(&format!("s3://{bucket_name}/"))?, s3.clone());
+            session.register_object_store(
+                &Url::parse(&format!("s3://{bucket_name}/"))?,
+                Arc::<object_store::aws::AmazonS3>::clone(&s3),
+            );
             Ok(s3)
         }
         "gs" => {
@@ -92,13 +94,16 @@ pub fn make_object_store(
                     .with_bucket_name(bucket_name)
                     .build()?,
             );
-            session
-                .register_object_store(&Url::parse(&format!("gs://{bucket_name}/"))?, gcs.clone());
+            session.register_object_store(
+                &Url::parse(&format!("gs://{bucket_name}/"))?,
+                Arc::<object_store::gcp::GoogleCloudStorage>::clone(&gcs),
+            );
             Ok(gcs)
         }
         _ => {
             let fs = Arc::new(LocalFileSystem::default());
-            session.register_object_store(&Url::parse("file:/")?, fs.clone());
+            session
+                .register_object_store(&Url::parse("file:/")?, Arc::<LocalFileSystem>::clone(&fs));
             Ok(fs)
         }
     }
diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs
index f915c9c7d3e..8d85dd8f4eb 100644
--- a/benchmarks/datafusion-bench/src/main.rs
+++ b/benchmarks/datafusion-bench/src/main.rs
@@ -26,7 +26,7 @@ use datafusion_physical_plan::collect;
 use futures::StreamExt;
 use parking_lot::Mutex;
 use tokio::fs::File;
-use vortex::scan::api::DataSourceRef;
+use vortex::scan::DataSourceRef;
 use vortex_bench::Benchmark;
 use vortex_bench::BenchmarkArg;
 use vortex_bench::CompactionStrategy;
@@ -39,6 +39,8 @@ use vortex_bench::conversions::convert_parquet_directory_to_vortex;
 use vortex_bench::create_benchmark;
 use vortex_bench::create_output_writer;
 use vortex_bench::display::DisplayFormat;
+use vortex_bench::runner::BenchmarkMode;
+use vortex_bench::runner::BenchmarkQueryResult;
 use vortex_bench::runner::SqlBenchmarkRunner;
 use vortex_bench::runner::filter_queries;
 use vortex_bench::setup_logging_and_tracing;
@@ -95,9 +97,6 @@ struct Args {
     #[arg(long, default_value_t = false)]
     explain: bool,
 
-    #[arg(long, default_value_t = false)]
-    explain_analyze: bool,
-
     #[arg(long, value_delimiter = ',', value_parser = value_parser!(Format))]
     formats: Vec<Format>,
 
@@ -162,10 +161,18 @@ async fn main() -> anyhow::Result<()> {
         Arc::new(Mutex::new(Vec::new()));
     let show_metrics = args.show_metrics;
 
+    let mode = if args.explain {
+        BenchmarkMode::Explain
+    } else {
+        BenchmarkMode::Run {
+            iterations: args.iterations,
+        }
+    };
+
     runner
         .run_all_async(
             &filtered_queries,
-            args.iterations,
+            mode,
             |format| {
                 let benchmark = &*benchmark;
                 async move {
@@ -187,7 +194,6 @@ async fn main() -> anyhow::Result<()> {
                             .with_labelset(get_labelset_from_global())
                             .await?;
                         let time = timer.elapsed();
-                        let row_count = batches.iter().map(|batch| batch.num_rows()).sum::<usize>();
 
                         // Store plan for metrics (only store once per query/format combination)
                         if show_metrics {
@@ -197,11 +203,11 @@ async fn main() -> anyhow::Result<()> {
                                 .iter()
                                 .any(|(idx, f, _)| *idx == query_idx && *f == *format)
                             {
-                                plans_mut.push((query_idx, *format, plan.clone()));
+                                plans_mut.push((query_idx, *format, Arc::clone(&plan)));
                             }
                         }
 
-                        anyhow::Ok((row_count, Some(time), plan))
+                        anyhow::Ok((Some(time), DataFusionQueryResult(batches)))
                     }
                     .with_labelset(labelset),
                 )
@@ -209,15 +215,17 @@ async fn main() -> anyhow::Result<()> {
         )
         .await?;
 
-    // Print metrics if requested
-    if show_metrics {
-        let plans = collected_plans.lock();
-        print_metrics(plans.as_ref());
-    }
+    if !args.explain {
+        // Print metrics if requested
+        if show_metrics {
+            let plans = collected_plans.lock();
+            print_metrics(plans.as_ref());
+        }
 
-    let benchmark_id = format!("datafusion-{}", benchmark.dataset_name());
-    let writer = create_output_writer(&args.display_format, args.output_path, &benchmark_id)?;
-    runner.export_to(&args.display_format, writer)?;
+        let benchmark_id = format!("datafusion-{}", benchmark.dataset_name());
+        let writer = create_output_writer(&args.display_format, args.output_path, &benchmark_id)?;
+        runner.export_to(&args.display_format, writer)?;
+    }
 
     Ok(())
 }
@@ -244,7 +252,7 @@ async fn register_benchmark_tables<B: Benchmark + ?Sized>(
                 let pattern = benchmark.pattern(table.name, format);
                 let table_url = ListingTableUrl::try_new(benchmark_base.clone(), pattern)?;
 
-                let mut listing_options = ListingOptions::new(file_format.clone())
+                let mut listing_options = ListingOptions::new(Arc::clone(&file_format))
                     .with_session_config_options(session.state().config());
                 if benchmark.dataset_name() == "polarsignals" && format == Format::Parquet {
                     // Work around a DataFusion bug (fixed in 53.0.0) where the
@@ -283,7 +291,7 @@ async fn register_v2_tables<B: Benchmark + ?Sized>(
     use vortex::file::multi::MultiFileDataSource;
     use vortex::io::object_store::ObjectStoreFileSystem;
     use vortex::io::session::RuntimeSessionExt;
-    use vortex::scan::api::DataSource as _;
+    use vortex::scan::DataSource as _;
     use vortex_datafusion::v2::VortexTable;
 
     let benchmark_base = benchmark.data_url().join(&format!("{}/", format.name()))?;
@@ -296,8 +304,10 @@ async fn register_v2_tables<B: Benchmark + ?Sized>(
             .runtime_env()
             .object_store(table_url.object_store())?;
 
-        let fs: vortex::io::filesystem::FileSystemRef =
-            Arc::new(ObjectStoreFileSystem::new(store.clone(), SESSION.handle()));
+        let fs: vortex::io::filesystem::FileSystemRef = Arc::new(ObjectStoreFileSystem::new(
+            Arc::clone(&store),
+            SESSION.handle(),
+        ));
         let base_prefix = benchmark_base.path().trim_start_matches('/').to_string();
         let fs = fs.with_prefix(base_prefix);
 
@@ -379,6 +389,21 @@ async fn register_arrow_tables<B: Benchmark + ?Sized>(
     Ok(())
 }
 
+/// Wrapper around DataFusion record batches implementing `BenchmarkQueryResult`.
+pub struct DataFusionQueryResult(pub Vec<RecordBatch>);
+
+impl BenchmarkQueryResult for DataFusionQueryResult {
+    fn row_count(&self) -> usize {
+        self.0.iter().map(|batch| batch.num_rows()).sum()
+    }
+
+    fn display(self) -> String {
+        datafusion::arrow::util::pretty::pretty_format_batches(&self.0)
+            .map(|d| d.to_string())
+            .unwrap_or_else(|e| format!("<error: {e}>"))
+    }
+}
+
 pub async fn execute_query(
     ctx: &SessionContext,
     query: &str,
@@ -393,7 +418,7 @@ pub async fn execute_query(
         .create_physical_plan()
         .with_labelset(get_labelset_from_global())
         .await?;
-    let result = collect(plan.clone(), task_ctx)
+    let result = collect(Arc::clone(&plan), task_ctx)
         .with_labelset(get_labelset_from_global())
         .await?;
 
diff --git a/benchmarks/duckdb-bench/src/lib.rs b/benchmarks/duckdb-bench/src/lib.rs
index a92a84e9e93..fed9f82b004 100644
--- a/benchmarks/duckdb-bench/src/lib.rs
+++ b/benchmarks/duckdb-bench/src/lib.rs
@@ -3,6 +3,7 @@
 
 //! DuckDB context for benchmarks.
 
+use std::ops::Deref;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::time::Instant;
@@ -14,9 +15,11 @@ use vortex_bench::Benchmark;
 use vortex_bench::Format;
 use vortex_bench::IdempotentPath;
 use vortex_bench::generate_duckdb_registration_sql;
+use vortex_bench::runner::BenchmarkQueryResult;
 use vortex_duckdb::duckdb::Config;
 use vortex_duckdb::duckdb::Connection;
 use vortex_duckdb::duckdb::Database;
+use vortex_duckdb::duckdb::QueryResult;
 
 /// DuckDB context for benchmarks.
 pub struct DuckClient {
@@ -189,4 +192,32 @@ impl DuckClient {
 
         Ok(())
     }
+
+    /// Execute a query and return a `DuckQueryResult` wrapper.
+    pub fn execute_query_result(&self, query: &str) -> Result<(Option<Duration>, DuckQueryResult)> {
+        trace!("execute duckdb query: {query}");
+        let time_instant = Instant::now();
+        let result = self.connection().query(query)?;
+        let query_time = time_instant.elapsed();
+        Ok((Some(query_time), DuckQueryResult(result)))
+    }
+}
+
+/// Wrapper around DuckDB's `QueryResult` implementing `BenchmarkQueryResult`.
+pub struct DuckQueryResult(pub QueryResult);
+
+impl BenchmarkQueryResult for DuckQueryResult {
+    fn row_count(&self) -> usize {
+        usize::try_from(self.0.row_count()).unwrap_or(0)
+    }
+
+    fn display(self) -> String {
+        let mut output = String::new();
+        for chunk in self.0 {
+            let chunk_str =
+                String::try_from(chunk.deref()).unwrap_or_else(|_| "<error>".to_string());
+            output.push_str(&chunk_str);
+        }
+        output
+    }
 }
diff --git a/benchmarks/duckdb-bench/src/main.rs b/benchmarks/duckdb-bench/src/main.rs
index 2bd5b0b99c1..7ab8f1ac7ab 100644
--- a/benchmarks/duckdb-bench/src/main.rs
+++ b/benchmarks/duckdb-bench/src/main.rs
@@ -3,7 +3,6 @@
 
 mod validation;
 
-use std::ops::Deref;
 use std::path::PathBuf;
 
 use clap::Parser;
@@ -21,6 +20,7 @@ use vortex_bench::conversions::convert_parquet_directory_to_vortex;
 use vortex_bench::create_benchmark;
 use vortex_bench::create_output_writer;
 use vortex_bench::display::DisplayFormat;
+use vortex_bench::runner::BenchmarkMode;
 use vortex_bench::runner::SqlBenchmarkRunner;
 use vortex_bench::runner::filter_queries;
 use vortex_bench::setup_logging_and_tracing;
@@ -139,33 +139,6 @@ fn main() -> anyhow::Result<()> {
         })?;
     }
 
-    if args.explain {
-        for format in &args.formats {
-            let ctx = DuckClient::new(
-                &*benchmark,
-                *format,
-                args.delete_duckdb_database,
-                args.threads,
-            )?;
-            ctx.register_tables(&*benchmark, *format)?;
-
-            for (query_idx, query) in &filtered_queries {
-                println!("=== Q{query_idx} [{format}] ===");
-                println!("{query}");
-                println!();
-                let result = ctx.connection().query(&format!("EXPLAIN {query}"))?;
-                for chunk in result {
-                    let chunk_str =
-                        String::try_from(chunk.deref()).unwrap_or_else(|_| "<error>".to_string());
-                    println!("{chunk_str}");
-                }
-                println!();
-            }
-        }
-
-        return Ok(());
-    }
-
     let mut runner = SqlBenchmarkRunner::new(
         &*benchmark,
         Engine::DuckDB,
@@ -176,9 +149,17 @@ fn main() -> anyhow::Result<()> {
 
     let benchmark_name = benchmark.dataset().to_string();
 
+    let mode = if args.explain {
+        BenchmarkMode::Explain
+    } else {
+        BenchmarkMode::Run {
+            iterations: args.iterations,
+        }
+    };
+
     runner.run_all(
         &filtered_queries,
-        args.iterations,
+        mode,
         |format| {
             let ctx = DuckClient::new(
                 &*benchmark,
@@ -200,13 +181,15 @@ fn main() -> anyhow::Result<()> {
             if !args.reuse {
                 ctx.reopen()?;
             }
-            ctx.execute_query(query)
+            ctx.execute_query_result(query)
         },
     )?;
 
-    let benchmark_id = format!("duckdb-{}", benchmark.dataset_name());
-    let writer = create_output_writer(&args.display_format, args.output_path, &benchmark_id)?;
-    runner.export_to(&args.display_format, writer)?;
+    if !args.explain {
+        let benchmark_id = format!("duckdb-{}", benchmark.dataset_name());
+        let writer = create_output_writer(&args.display_format, args.output_path, &benchmark_id)?;
+        runner.export_to(&args.display_format, writer)?;
+    }
 
     Ok(())
 }
diff --git a/benchmarks/lance-bench/src/compress.rs b/benchmarks/lance-bench/src/compress.rs
index 93891ec5555..a7732730ef7 100644
--- a/benchmarks/lance-bench/src/compress.rs
+++ b/benchmarks/lance-bench/src/compress.rs
@@ -4,6 +4,7 @@
 use std::fs;
 use std::fs::File;
 use std::path::Path;
+use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 
@@ -92,7 +93,7 @@ impl Compressor for LanceCompressor {
         // Read the input parquet file
         let file = File::open(parquet_path)?;
         let builder = ParquetRecordBatchReaderBuilder::try_new(file)?;
-        let schema = builder.schema().clone();
+        let schema = Arc::clone(builder.schema());
         let reader = builder.build()?;
         let batches: Vec<RecordBatch> = reader.collect::<Result<Vec<_>, _>>()?;
 
@@ -131,7 +132,7 @@ impl Compressor for LanceCompressor {
         // First compress to get the Lance dataset
         let file = File::open(parquet_path)?;
         let builder = ParquetRecordBatchReaderBuilder::try_new(file)?;
-        let schema = builder.schema().clone();
+        let schema = Arc::clone(builder.schema());
         let reader = builder.build()?;
         let batches: Vec<RecordBatch> = reader.collect::<Result<Vec<_>, _>>()?;
 
diff --git a/benchmarks/lance-bench/src/convert.rs b/benchmarks/lance-bench/src/convert.rs
index 0da159b25e4..ac1db099953 100644
--- a/benchmarks/lance-bench/src/convert.rs
+++ b/benchmarks/lance-bench/src/convert.rs
@@ -84,7 +84,7 @@ impl Iterator for ParquetFilesIterator {
 
 impl RecordBatchReader for ParquetFilesIterator {
     fn schema(&self) -> SchemaRef {
-        self.schema.clone()
+        Arc::clone(&self.schema)
     }
 }
 
@@ -161,7 +161,7 @@ pub async fn convert_parquet_to_lance<'p>(
             // Get schema from the first Parquet file
             let first_file = File::open(&parquet_files[0])?;
             let first_builder = ParquetRecordBatchReaderBuilder::try_new(first_file)?;
-            let schema = first_builder.schema().clone();
+            let schema = Arc::clone(first_builder.schema());
 
             // Create a streaming iterator that reads from all Parquet files
             let batch_iter = ParquetFilesIterator::new(parquet_files, schema)?;
@@ -237,7 +237,7 @@ pub fn convert_utf8view_batch(batch: RecordBatch) -> anyhow::Result<RecordBatch>
             // Cast Utf8View to Utf8.
             cast(column, &DataType::Utf8)?
         } else {
-            column.clone()
+            Arc::clone(column)
         };
         new_columns.push(new_column);
     }
@@ -277,6 +277,6 @@ impl Iterator for ConvertingParquetFilesIterator {
 
 impl RecordBatchReader for ConvertingParquetFilesIterator {
     fn schema(&self) -> SchemaRef {
-        self.converted_schema.clone()
+        Arc::clone(&self.converted_schema)
     }
 }
diff --git a/benchmarks/lance-bench/src/main.rs b/benchmarks/lance-bench/src/main.rs
index d127ca649db..73fa8426ffe 100644
--- a/benchmarks/lance-bench/src/main.rs
+++ b/benchmarks/lance-bench/src/main.rs
@@ -23,6 +23,8 @@ use vortex_bench::Opts;
 use vortex_bench::create_benchmark;
 use vortex_bench::create_output_writer;
 use vortex_bench::display::DisplayFormat;
+use vortex_bench::runner::BenchmarkMode;
+use vortex_bench::runner::BenchmarkQueryResult;
 use vortex_bench::runner::SqlBenchmarkRunner;
 use vortex_bench::runner::filter_queries;
 use vortex_bench::setup_logging_and_tracing;
@@ -99,7 +101,9 @@ async fn main() -> anyhow::Result<()> {
     runner
         .run_all_async(
             &filtered_queries,
-            args.iterations,
+            BenchmarkMode::Run {
+                iterations: args.iterations,
+            },
             |_format| async {
                 let session = SessionContext::new();
                 register_lance_tables(&session, &*benchmark).await?;
@@ -108,10 +112,9 @@ async fn main() -> anyhow::Result<()> {
             |_query_idx, session, query| {
                 Box::pin(async move {
                     let timer = Instant::now();
-                    let (batches, plan) = execute_query(session, query).await?;
+                    let (batches, _plan) = execute_query(session, query).await?;
                     let time = timer.elapsed();
-                    let row_count = batches.iter().map(|batch| batch.num_rows()).sum::<usize>();
-                    anyhow::Ok((row_count, Some(time), plan))
+                    anyhow::Ok((Some(time), LanceQueryResult(batches)))
                 })
             },
         )
@@ -148,6 +151,22 @@ async fn register_lance_tables<B: Benchmark + ?Sized>(
     Ok(())
 }
 
+/// Wrapper around Lance/DataFusion record batches implementing `BenchmarkQueryResult`.
+struct LanceQueryResult(Vec<RecordBatch>);
+
+impl BenchmarkQueryResult for LanceQueryResult {
+    fn row_count(&self) -> usize {
+        self.0.iter().map(|batch| batch.num_rows()).sum()
+    }
+
+    fn display(self) -> String {
+        // Lance uses the same Arrow RecordBatch type
+        lance::deps::datafusion::arrow::util::pretty::pretty_format_batches(&self.0)
+            .map(|d| d.to_string())
+            .unwrap_or_else(|e| format!("<error: {e}>"))
+    }
+}
+
 pub async fn execute_query(
     ctx: &SessionContext,
     query: &str,
diff --git a/benchmarks/random-access-bench/src/main.rs b/benchmarks/random-access-bench/src/main.rs
index 83b79823a16..2fb617e8787 100644
--- a/benchmarks/random-access-bench/src/main.rs
+++ b/benchmarks/random-access-bench/src/main.rs
@@ -9,15 +9,15 @@ use anyhow::Result;
 use clap::Parser;
 use clap::ValueEnum;
 use indicatif::ProgressBar;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use rand_distr::Distribution;
 use rand_distr::Exp;
-use vortex_bench::BenchmarkOutput;
 use vortex_bench::Engine;
 use vortex_bench::Format;
 use vortex_bench::Target;
+use vortex_bench::create_output_writer;
 use vortex_bench::datasets::feature_vectors::FeatureVectorsData;
 use vortex_bench::datasets::nested_lists::NestedListsData;
 use vortex_bench::datasets::nested_structs::NestedStructsData;
@@ -416,8 +416,7 @@ async fn run_random_access(
 
     progress.finish();
 
-    let output = BenchmarkOutput::with_path(BENCHMARK_ID, output_path);
-    let mut writer = output.create_writer()?;
+    let mut writer = create_output_writer(&display_format, output_path, BENCHMARK_ID)?;
 
     match display_format {
         DisplayFormat::Table => {
diff --git a/clippy.toml b/clippy.toml
index 592ede3e6ad..4b6fc10fe76 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -12,4 +12,5 @@ disallowed-types = [
 
 disallowed-methods = [
     { path = "itertools::Itertools::counts", reason = "It uses the default hasher which is slow for primitives. Just inline the loop for better performance.", allow-invalid = true },
+    { path = "std::result::Result::and", reason = "This method is a footgun, especially when working with `Result<Validity>`.", allow-invalid = true },
 ]
diff --git a/docs/api/c/dtypes.rst b/docs/api/c/dtypes.rst
index 257a70bfa1f..08791f53b98 100644
--- a/docs/api/c/dtypes.rst
+++ b/docs/api/c/dtypes.rst
@@ -78,9 +78,6 @@ Struct Fields
 .. c:autotype:: vx_struct_fields
     :file: vortex.h
 
-.. c:autofunction:: vx_struct_fields_clone
-    :file: vortex.h
-
 .. c:autofunction:: vx_struct_fields_free
     :file: vortex.h
 
diff --git a/docs/api/cpp/index.rst b/docs/api/cpp/index.rst
index 43d6c2ae409..befb980f6a9 100644
--- a/docs/api/cpp/index.rst
+++ b/docs/api/cpp/index.rst
@@ -20,7 +20,7 @@ Installation
 The C++ bindings are built using CMake. Requirements:
 
 * CMake 3.22 or higher
-* C++17 compatible compiler
+* C++20 compatible compiler
 * Rust toolchain (for building the underlying Rust library)
 
 .. code-block:: bash
diff --git a/docs/api/python/arrays.rst b/docs/api/python/arrays.rst
index da6c6a7a449..55d4bc6d0b3 100644
--- a/docs/api/python/arrays.rst
+++ b/docs/api/python/arrays.rst
@@ -144,7 +144,7 @@ Registry and Serde
 .. autoclass:: vortex.ArrayContext
     :members:
 
-.. autoclass:: vortex.ArrayParts
+.. autoclass:: vortex.SerializedArray
     :members:
 
 
diff --git a/docs/api/python/store.rst b/docs/api/python/store.rst
index bd2c2eb4892..305657c65f1 100644
--- a/docs/api/python/store.rst
+++ b/docs/api/python/store.rst
@@ -1,17 +1,18 @@
+====================
 Object Store support
 ====================
 
-Vortex arrays support reading and writing to object storage systems such as, S3, Google Cloud Storage, and
-Azure Blob Storage.
-
-.. autosummary::
-   :nosignatures:
-
-.. raw:: html
+Vortex arrays support reading and writing to many object storage systems:
 
-   <hr>
+.. toctree::
+   :maxdepth: 1
 
-.. automodule:: vortex.store
-    :members:
-    :imported-members:
+   store/aws
+   store/gcs
+   store/azure
+   store/http
+   store/local
+   store/memory
+   store/config
 
+.. autofunction:: vortex.store.from_url
diff --git a/docs/api/python/store/aws.rst b/docs/api/python/store/aws.rst
new file mode 100644
index 00000000000..f29fc1d72cb
--- /dev/null
+++ b/docs/api/python/store/aws.rst
@@ -0,0 +1,20 @@
+====================
+S3 and S3-compatible
+====================
+
+
+.. autosummary::
+   vortex.store.S3Store
+   vortex.store.S3Config
+   vortex.store.S3Credential
+   vortex.store.S3CredentialProvider
+
+.. autoclass:: vortex.store.S3Store
+   :members:
+.. autoclass:: vortex.store.S3Config
+   :members:
+.. autoclass:: vortex.store.S3Credential
+   :members:
+.. autoclass:: vortex.store.S3CredentialProvider
+   :members:
+
diff --git a/docs/api/python/store/azure.rst b/docs/api/python/store/azure.rst
new file mode 100644
index 00000000000..d06a42dcaf7
--- /dev/null
+++ b/docs/api/python/store/azure.rst
@@ -0,0 +1,29 @@
+==================
+Azure Blob Storage
+==================
+
+.. autosummary::
+   vortex.store.AzureStore
+   vortex.store.AzureConfig
+   vortex.store.AzureAccessKey
+   vortex.store.AzureSASToken
+   vortex.store.AzureBearerToken
+   vortex.store.AzureCredential
+   vortex.store.AzureCredentialProvider
+
+
+.. autoclass:: vortex.store.AzureStore
+   :members:
+.. autoclass:: vortex.store.AzureConfig
+   :members:
+.. autoclass:: vortex.store.AzureAccessKey
+   :members:
+.. autoclass:: vortex.store.AzureSASToken
+   :members:
+.. autoclass:: vortex.store.AzureBearerToken
+   :members:
+.. autoclass:: vortex.store.AzureCredential
+   :members:
+.. autoclass:: vortex.store.AzureCredentialProvider
+   :members:
+
diff --git a/docs/api/python/store/config.rst b/docs/api/python/store/config.rst
new file mode 100644
index 00000000000..90a3bd48c1a
--- /dev/null
+++ b/docs/api/python/store/config.rst
@@ -0,0 +1,16 @@
+====================
+Common Configuration
+====================
+
+.. autosummary::
+   vortex.store.ClientConfig
+   vortex.store.RetryConfig
+   vortex.store.BackoffConfig
+
+
+.. autoclass:: vortex.store.ClientConfig
+   :members:
+.. autoclass:: vortex.store.RetryConfig
+   :members:
+.. autoclass:: vortex.store.BackoffConfig
+   :members:
diff --git a/docs/api/python/store/gcs.rst b/docs/api/python/store/gcs.rst
new file mode 100644
index 00000000000..a4a3300b4b5
--- /dev/null
+++ b/docs/api/python/store/gcs.rst
@@ -0,0 +1,18 @@
+====================
+Google Cloud Storage
+====================
+
+.. autosummary::
+   vortex.store.GCSStore
+   vortex.store.GCSConfig
+   vortex.store.GCSCredential
+   vortex.store.GCSCredentialProvider
+
+.. autoclass:: vortex.store.GCSStore
+   :members:
+.. autoclass:: vortex.store.GCSConfig
+   :members:
+.. autoclass:: vortex.store.GCSCredential
+   :members:
+.. autoclass:: vortex.store.GCSCredentialProvider
+   :members:
diff --git a/docs/api/python/store/http.rst b/docs/api/python/store/http.rst
new file mode 100644
index 00000000000..49b6f71de3a
--- /dev/null
+++ b/docs/api/python/store/http.rst
@@ -0,0 +1,6 @@
+====
+HTTP
+====
+
+.. autoclass:: vortex.store.HTTPStore
+   :members:
diff --git a/docs/api/python/store/local.rst b/docs/api/python/store/local.rst
new file mode 100644
index 00000000000..a92b5211945
--- /dev/null
+++ b/docs/api/python/store/local.rst
@@ -0,0 +1,6 @@
+=====
+Local
+=====
+
+.. autoclass:: vortex.store.LocalStore
+   :members:
diff --git a/docs/api/python/store/memory.rst b/docs/api/python/store/memory.rst
new file mode 100644
index 00000000000..beab652f770
--- /dev/null
+++ b/docs/api/python/store/memory.rst
@@ -0,0 +1,6 @@
+======
+Memory
+======
+
+.. autoclass:: vortex.store.MemoryStore
+   :members:
diff --git a/docs/developer-guide/benchmarking.md b/docs/developer-guide/benchmarking.md
index e971db2b239..2e09c727dd7 100644
--- a/docs/developer-guide/benchmarking.md
+++ b/docs/developer-guide/benchmarking.md
@@ -1,14 +1,11 @@
 # Benchmarking
 
 Vortex has two categories of benchmarks: microbenchmarks for individual operations, and SQL
-benchmarks for end-to-end query performance. The `bench-orchestrator` tool coordinates running
-SQL benchmarks across different engines without compiling them all into a single binary.
+benchmarks for end-to-end query performance.
 
 ## Microbenchmarks
 
-Microbenchmarks use the Divan framework and live in `benches/` directories within individual
-crates. They cover low-level operations such as encoding, decoding, compute kernels, buffer
-operations, and scalar access.
+Microbenchmarks use the Divan framework and live in `benches/` directories within individual crates.
 
 Run microbenchmarks for a specific crate with:
 
@@ -16,6 +13,146 @@ Run microbenchmarks for a specific crate with:
 cargo bench -p <crate-name>
 ```
 
+## Best Practices
+
+### Separate setup from profiled code
+
+Always use `bencher.with_inputs(|| ...)` so fixture construction is excluded from timing:
+
+```rust
+bencher
+    .with_inputs(|| bench_fixture()))
+    .bench_refs(|(array, indices)| {
+        array.take(indices.to_array()).unwrap()
+    });
+```
+
+### Exclude `Drop` from measurements
+
+Divan measures only the closure body, **not** the `Drop` of its return value.
+Structure your benchmark so that expensive drops happen via the return value or
+via bench_refs inputs.
+
+- **Return the value** from the closure — Divan will drop it after timing stops:
+
+  ```rust
+  bencher
+      .with_inputs(|| make_big_vec())
+      .bench_values(|v| transform(v))  // drop of the result is NOT timed
+  ```
+
+- **Use `bench_refs`** — the input is dropped after the entire sample loop, not per-iteration:
+
+  ```rust
+  bencher
+      .with_inputs(|| make_big_vec())
+      .bench_refs(|v| v.sort())  // v is dropped outside the timed region
+  ```
+
+Structure your benchmark so that expensive drops happen via the return value or via `bench_refs` inputs.
+
+### Black-box inputs to prevent compiler optimization
+
+The compiler can constant-fold or eliminate work if it can prove that inputs are known at
+compile time.
+
+Values provided through `with_inputs` are automatically black-boxed by Divan — no action
+needed:
+
+```rust
+// ✓ `array` and `indices` are automatically black-boxed by Divan
+bencher
+    .with_inputs(|| (&prebuilt_array, &prebuilt_indices))
+    .bench_refs(|(array, indices)| array.take(indices.to_array()).unwrap());
+```
+
+### Captured variables
+
+Variables captured from the surrounding scope are _not_ black-boxed. Wrap them with
+`divan::black_box()` or pass them through `with_inputs` instead:
+
+```rust
+let array = make_array();
+
+// ✗ `array` is captured — the compiler may optimize based on its known contents
+bencher.bench(|| process(&array));
+
+// ✓ Option A: pass through with_inputs
+bencher
+    .with_inputs(|| &array)
+    .bench_refs(|array| process(array));
+
+// ✓ Option B: explicit black_box on the capture
+bencher.bench(|| process(divan::black_box(&array)));
+```
+
+### Return values and manual loops
+
+Return values are automatically black-boxed. You only need explicit
+`black_box` for side-effect-free results inside manual loops:
+
+```rust
+bencher.with_inputs(|| &array).bench_refs(|array| {
+    for idx in 0..len {
+        divan::black_box(array.scalar_at(idx).unwrap());
+    }
+});
+```
+
+### Use deterministic, seeded RNG
+
+Always use `StdRng::seed_from_u64(N)` for reproducible data generation:
+
+```rust
+let mut rng = StdRng::seed_from_u64(0);
+```
+
+### Parameterize with `args`, `consts`, and `types`
+
+Use Divan's parameterization features and define parameter arrays as named constants:
+
+```rust
+const NUM_INDICES: &[usize] = &[1_000, 10_000, 100_000];
+const VECTOR_SIZE: &[usize] = &[16, 256, 2048, 8192];
+
+#[divan::bench(args = NUM_INDICES, consts = VECTOR_SIZE)]
+fn my_bench<const N: usize>(bencher: Bencher, num_indices: usize) { ... }
+```
+
+### Keep per-iteration execution time under ~1 ms
+
+Each individual iteration of the benchmarked closure should complete in
+**less than 1ms**. This is to keep benchmarks snappy, locally and on CI.
+
+### Gate CodSpeed-incompatible benchmarks
+
+Use `#[cfg(not(codspeed))]` for benchmarks that are incompatible with CodSpeed.
+
+### CodSpeed's single-run model
+
+CI benchmarks run under [CodSpeed's CPU simulation](https://codspeed.io/docs/instruments/cpu),
+which executes each benchmark **exactly once** and estimates CPU cycles from the instruction
+trace — including cache and memory access costs. This has several implications:
+
+- **`sample_count` and `sample_size` have no effect** — CodSpeed always runs one iteration.
+- **Results are deterministic** — the simulated cycle count is derived from the instruction
+  trace, not wall-clock time, so there is no noise from system load or scheduling.
+- **System calls are excluded** — CodSpeed only measures user-space code. Benchmarks that
+  rely on I/O or kernel interactions will not reflect those costs, so they should use the
+  [walltime instrument](https://codspeed.io/docs/instruments/walltime) or be gated with
+  `#[cfg(not(codspeed))]`.
+
+### Prefer `mimalloc` for throughput benchmarks
+
+Throughput benchmarks should use `mimalloc` as the global allocator to reduce system allocator
+noise:
+
+```rust
+use mimalloc::MiMalloc;
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+```
+
 ## SQL Benchmarks
 
 SQL benchmarks measure end-to-end query performance across different engines and file formats.
@@ -48,51 +185,11 @@ cargo run --release --bin duckdb-bench -- <benchmark>
 
 ## Orchestrator
 
-The `bench-orchestrator` is a Python CLI tool (`vx-bench`) that coordinates running benchmarks
-across multiple engines. It builds and invokes the per-engine binaries, stores results, and
-provides comparison tooling. This avoids compiling all engines into a single binary, which
-would be slow and create dependency conflicts.
-
-Install it with:
-
-```bash
-uv tool install "bench_orchestrator @ ./bench-orchestrator/"
-```
-
-### Running Benchmarks
-
-```bash
-# Run TPC-H on DataFusion and DuckDB, comparing Parquet and Vortex
-vx-bench run tpch --engine datafusion,duckdb --format parquet,vortex
-
-# Run a subset of queries with fewer iterations
-vx-bench run tpch -q 1,6,12 -i 3
-
-# Run with memory tracking
-vx-bench run tpch --track-memory
-
-# Run with CPU profiling
-vx-bench run tpch --samply
-```
-
-### Comparing Results
-
-```bash
-# Compare formats/engines within the most recent run
-vx-bench compare --run latest
-
-# Compare across two labeled runs
-vx-bench compare --runs baseline,feature
-```
-
-Comparison output is color-coded: green for improvements (>10%), yellow for neutral, red for
-regressions.
-
-### Result Storage
+The `bench-orchestrator` is a Python CLI tool (`vx-bench`) that coordinates running SQL
+benchmarks across multiple engines, stores results, and provides comparison tooling.
 
-Results are stored as JSON Lines files under `target/vortex-bench/runs/`, with each run
-containing metadata (git commit, timestamp, configuration) and per-query timing data. The
-`vx-bench list` command shows recent runs.
+See [`bench-orchestrator/README.md`](https://github.com/vortex-data/vortex/blob/develop/bench-orchestrator/README.md) for installation,
+commands, and example workflows.
 
 ## CI Benchmarks
 
diff --git a/docs/developer-guide/internals/architecture.md b/docs/developer-guide/internals/architecture.md
index 05620fcff81..3354c25cd85 100644
--- a/docs/developer-guide/internals/architecture.md
+++ b/docs/developer-guide/internals/architecture.md
@@ -76,12 +76,12 @@ Language bindings expose Vortex to non-Rust environments.
 
 Query engine integrations allow Vortex files to be queried through existing analytics engines.
 
-| Crate / Directory    | Engine     | Notes                                        |
-| -------------------- | ---------- | -------------------------------------------- |
-| `vortex-datafusion/` | DataFusion | `TableProvider` and `FileFormat` integration |
-| `vortex-duckdb/`     | DuckDB     | Table function integration                   |
-| `java/vortex-spark/` | Spark      | DataSource V2 connector via JNI              |
-| `java/vortex-trino/` | Trino      | Trino connector (in development)             |
+| Crate / Directory                | Engine     | Notes                                        |
+|----------------------------------| ---------- |----------------------------------------------|
+| `vortex-datafusion/`             | DataFusion | `TableProvider` and `FileFormat` integration |
+| `vortex-duckdb/`                 | DuckDB     | Table function integration                   |
+| `java/vortex-spark_{2.12,2.13}/` | Spark      | Spark DataSource V2 connector via JNI        |
+| `java/vortex-trino/`             | Trino      | Trino connector (in development)             |
 
 ## Other Crates
 
diff --git a/docs/developer-guide/internals/execution.md b/docs/developer-guide/internals/execution.md
index 0b503dd55e8..07eb88875b5 100644
--- a/docs/developer-guide/internals/execution.md
+++ b/docs/developer-guide/internals/execution.md
@@ -1,9 +1,9 @@
 # Execution
 
-Vortex defers computation wherever possible. When an expression is applied to an array, the
-result is not computed immediately. Instead, a `ScalarFnArray` is constructed that captures the
-operation and its inputs as a new array node. The actual computation happens later, when the
-array is materialized -- either by a scan, a query engine, or an explicit `execute()` call.
+Vortex defers computation wherever possible. Instead of immediately materializing intermediate
+results, it represents them as arrays that still describe work to be done, such as `FilterArray`
+and [`ScalarFnArray`](../../concepts/expressions.md). The actual computation happens later, when
+the array is materialized -- either by a scan, a query engine, or an explicit `execute()` call.
 
 ## Why Defer
 
@@ -32,8 +32,8 @@ pub trait Executable: Sized {
 }
 ```
 
-The `ExecutionCtx` carries the session and provides access to registered encodings during
-execution. Arrays can be executed into different target types:
+The `ExecutionCtx` carries the session and accumulates a trace of execution steps for debugging.
+Arrays can be executed into different target types:
 
 - **`Canonical`** -- fully materializes the array into its canonical form.
 - **`Columnar`** -- like `Canonical`, but with a variant for constant arrays to avoid
@@ -41,10 +41,192 @@ execution. Arrays can be executed into different target types:
 - **Specific array types** (`PrimitiveArray`, `BoolArray`, `StructArray`, etc.) -- executes
   to canonical form and unwraps to the expected type, panicking if the dtype does not match.
 
+## Constant Short-Circuiting
+
+Executing to `Columnar` rather than `Canonical` enables an important optimization: if the
+array is constant (a scalar repeated to a given length), execution returns the `ConstantArray`
+directly rather than expanding it. This avoids allocating and filling a buffer with repeated
+values.
+
+```rust
+pub enum Columnar {
+    Canonical(Canonical),
+    Constant(ConstantArray),
+}
+```
+
+Almost all compute functions can make use of constant input values, and many query engines
+support constant vectors directly, avoiding unnecessary expansion.
+
+## Execution Overview
+
+The `execute_until<M: Matcher>` method on `ArrayRef` drives execution. The scheduler is
+iterative: it rewrites and executes arrays in small steps until the current array matches the
+requested target form.
+
+At a high level, each iteration works like this:
+
+1. `optimize(current)` runs metadata-only rewrites to fixpoint:
+   `reduce` lets an array simplify itself, and `reduce_parent` lets a child rewrite its parent.
+2. If optimization does not finish execution, each child gets a chance to `execute_parent`,
+   meaning "execute my parent's operation using my representation".
+3. If no child can do that, the array's own `execute` method returns the next `ExecutionStep`.
+
+This keeps execution iterative rather than recursive, and it gives optimization rules another
+chance to fire after every structural or computational step.
+
+## The Four Layers
+
+The execution model has four layers, but they are not all invoked in the same way. Layers 1 and
+2 make up `optimize`, which runs to fixpoint before and after execution steps. Layers 3 and 4
+run only after optimization has stalled.
+
+```
+execute_until(root):
+  current = optimize(root)             # Layers 1-2 to fixpoint
+
+  loop:
+    if current matches target:
+      return / reattach to parent
+
+    Layer 3: try execute_parent on each child
+      if one succeeds:
+        current = optimize(result)
+        continue
+
+    Layer 4: call execute(current)
+      ExecuteChild(i, pred) -> focus child[i], then optimize
+      Done                  -> current = optimize(result)
+```
+
+### Layer 1: `reduce` -- self-rewrite rules
+
+An encoding applies `ArrayReduceRule` rules to itself. These are structural simplifications
+that look only at the array's own metadata and children types, not buffer contents.
+
+Examples:
+- A `FilterArray` with an all-true mask reduces to its child.
+- A `FilterArray` with an all-false mask reduces to an empty canonical array.
+- A `ScalarFnArray` whose children are all constants evaluates once and returns a `ConstantArray`.
+
+### Layer 2: `reduce_parent` -- child-driven rewrite rules
+
+Each child is given the opportunity to rewrite its parent via `ArrayParentReduceRule`. The child
+matches on the parent's type via a `Matcher` and can return a replacement. This is still
+metadata-only.
+
+Examples:
+- A `FilterArray` child of another `FilterArray` merges the two masks into one.
+- A `PrimitiveArray` inside a `MaskedArray` absorbs the mask into its own validity field.
+- A `DictArray` child of a `ScalarFnArray` pushes the scalar function into the dictionary
+  values, applying the function to `N` unique values instead of `M >> N` total rows.
+- A `RunEndArray` child of a `ScalarFnArray` pushes the function into the run values.
+
+### Layer 3: `execute_parent` -- parent kernels
+
+Each child is given the opportunity to execute its parent in a fused manner via
+`ExecuteParentKernel`. Unlike reduce rules, parent kernels may read buffers and perform real
+computation.
+
+An encoding declares its parent kernels in a `ParentKernelSet`, specifying which parent types
+each kernel handles via a `Matcher`:
+
+```rust
+pub trait ExecuteParentKernel<V: VTable> {
+    type Parent: Matcher;  // which parent types this kernel handles
+
+    fn execute_parent(
+        &self,
+        array: &V::Array,                          // the child
+        parent: <Self::Parent as Matcher>::Match<'_>, // the matched parent
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>>;
+}
+```
+
+Examples:
+- A `RunEndArray` child of a `SliceArray` performs a binary search on the run ends to produce a
+  new `RunEndArray` with adjusted offsets, or a `ConstantArray` if the slice falls within a
+  single run.
+- A `PrimitiveArray` child of a `FilterArray` applies the filter mask directly over its buffer,
+  producing a filtered `PrimitiveArray` in one pass.
+
+### Layer 4: `execute` -- the encoding's own decode step
+
+If no reduce rule or parent kernel handled the array, the encoding's `VTable::execute` method
+is called. This is the encoding's chance to decode itself one step closer to canonical form.
+
+Instead of recursively executing children inline, `execute` returns an `ExecutionResult`
+containing an `ExecutionStep` that tells the scheduler what to do next:
+
+```rust
+pub enum ExecutionStep {
+    /// Ask the scheduler to execute child[idx] until it matches the predicate,
+    /// then replace the child and re-enter execution for this array.
+    ExecuteChild(usize, DonePredicate),
+
+    /// Execution is complete. The array in the ExecutionResult is the result.
+    Done,
+}
+```
+
+## The Execution Loop
+
+The full `execute_until<M: Matcher>` loop uses an explicit work stack to manage
+parent-child relationships without recursion:
+
+```
+execute_until<M>(root):
+  stack = []
+  current = optimize(root)
+
+  loop:
+    ┌─────────────────────────────────────────────────────┐
+    │ Is current "done"?                                  │
+    │   (matches M if at root, or matches the stack       │
+    │    frame's DonePredicate if inside a child)         │
+    ├──────────────────────┬──────────────────────────────┘
+    │ yes                  │ no
+    │                      │
+    │  stack empty?        │  Already canonical?
+    │  ├─ yes → return     │  ├─ yes → pop stack (can't make more progress)
+    │  └─ no  → pop frame, │  └─ no  → continue to execution steps
+    │     replace child,   │
+    │     optimize, loop   │
+    │                      ▼
+    │         ┌────────────────────────────────────┐
+    │         │  Try execute_parent on each child  │
+    │         │  (Layer 3 parent kernels)          │
+    │         ├────────┬───────────────────────────┘
+    │         │ Some   │ None
+    │         │        │
+    │         │        ▼
+    │         │  ┌─────────────────────────────────┐
+    │         │  │  Call execute (Layer 4)         │
+    │         │  │  Returns ExecutionResult        │
+    │         │  ├────────┬────────────────────────┘
+    │         │  │        │
+    │         │  │  ExecuteChild(i, pred)?
+    │         │  │  ├─ yes → push (array, i, pred)
+    │         │  │  │        current = child[i]
+    │         │  │  │        optimize, loop
+    │         │  │  └─ Done → current = result
+    │         │  │            loop
+    │         │  │
+    │         ▼  ▼
+    │    optimize result, loop
+    └──────────────────────────
+```
+
+Note that `optimize` runs after every transformation. This is what enables cross-step
+optimizations: after a child is decoded, new `reduce_parent` rules may now match that were
+previously blocked.
+
 ## Incremental Execution
 
 Execution is incremental: each call to `execute` moves the array one step closer to canonical
-form, not necessarily all the way. This gives each child the opportunity to optimize before the 
+form, not necessarily all the way. This gives each child the opportunity to optimize before the
 next iteration of execution.
 
 For example, consider a `DictArray` whose codes are a sliced `RunEndArray`. Dict-RLE is a common
@@ -60,59 +242,82 @@ If execution jumped straight to canonicalizing the dict's children, it would exp
 codes through the slice, missing the Dict-RLE optimization entirely. Incremental execution
 avoids this:
 
-1. First iteration: the slice executes and returns a new `RunEndArray` whose offsets have been binary searched.
+1. First iteration: the slice `execute_parent` (parent kernel on RunEnd for Slice) performs a
+   binary search on run ends, returning a new `RunEndArray` with adjusted offsets.
 
 2. Second iteration: the `RunEndArray` codes child now matches the Dict-RLE pattern. Its
    `execute_parent` provides a fused kernel that expands runs while performing dictionary
    lookups in a single pass, returning the canonical array directly.
 
-The execution loop runs until the array is canonical or constant:
-
-1. **Child optimization** -- each child is given the opportunity to optimize its parent's
-   execution by calling `execute_parent` on the child's vtable. If a child can handle the
-   parent more efficiently, it returns the result directly.
-
-2. **Incremental execution** -- if no child provides an optimized path, the array's own
-   `execute` vtable method is called. This executes children one step and returns a new
-   array that is closer to canonical form, or executes the array itself.
-
-## Constant Short-Circuiting
+## Walkthrough: Executing a RunEnd-Encoded Array
 
-Executing to `Columnar` rather than `Canonical` enables an important optimization: if the
-array is constant (a scalar repeated to a given length), execution returns the `ConstantArray`
-directly rather than expanding it. This avoids allocating and filling a buffer with repeated
-values.
+To make the execution flow concrete, here is a step-by-step trace of executing a
+`RunEndArray` to `Canonical`:
 
-```rust
-pub enum Columnar {
-    Canonical(Canonical),
-    Constant(ConstantArray),
-}
+```
+Input:  RunEndArray { ends: [3, 7, 10], values: [A, B, C], len: 10 }
+Goal:   Canonical (PrimitiveArray or similar)
+
+Iteration 1:
+  reduce?         → None (no self-rewrite rules match)
+  reduce_parent?  → None (no parent, this is root)
+  execute_parent? → None (no parent)
+  execute         → ends are not Primitive yet?
+                    ExecuteChild(0, Primitive::matches)
+                    Stack: [(RunEnd, child_idx=0, Primitive::matches)]
+                    Focus on: ends
+
+Iteration 2:
+  Current: ends array
+  Already Primitive? → yes, done.
+  Pop stack → replace child 0 in RunEnd, optimize.
+
+Iteration 3:
+  reduce?         → None
+  reduce_parent?  → None
+  execute_parent? → None
+  execute         → values are not Canonical yet?
+                    ExecuteChild(1, AnyCanonical::matches)
+                    Stack: [(RunEnd, child_idx=1, AnyCanonical::matches)]
+                    Focus on: values
+
+Iteration 4:
+  Current: values array
+  Already Canonical? → yes, done.
+  Pop stack → replace child 1 in RunEnd, optimize.
+
+Iteration 5:
+  reduce?         → None
+  reduce_parent?  → None
+  execute_parent? → None
+  execute         → all children ready, decode runs:
+                    [A, A, A, B, B, B, B, C, C, C]
+                    Done → return PrimitiveArray
+
+→ Result: PrimitiveArray [A, A, A, B, B, B, B, C, C, C]
 ```
 
-Almost all compute functions can make use of constant input values, and many query engines support constant vectors
-avoiding unnecessary expansion.
-
-## ScalarFnArray
+## Implementing an Encoding: Where Does My Logic Go?
 
-A `ScalarFnArray` holds a scalar function (the operation to perform), a list of child arrays
-(the inputs), and the expected output dtype and length. It is itself a valid Vortex array and
-can be nested, sliced, and passed through the same APIs as any other array.
+When adding a new encoding or optimizing an existing one, the key question is whether the
+transformation needs to read buffer data:
 
-When an expression like `{x: $, y: $ + 1}` is applied to a bit-packed integer array, the
-result is a tree of `ScalarFnArray` nodes rather than a materialized struct:
+| If you need to... | Put it in | Example |
+|-------------------|-----------|---------|
+| Rewrite the array by looking only at its own structure | `reduce` (Layer 1) | `FilterArray` removes itself when the mask is all true |
+| Rewrite the parent by looking at your type and the parent's structure | `reduce_parent` (Layer 2) | `DictArray` pushes a scalar function into its values |
+| Execute the parent's operation using your compressed representation | `execute_parent` / parent kernel (Layer 3) | `PrimitiveArray` applies a filter mask directly over its buffer |
+| Decode yourself toward canonical form | `execute` (Layer 4) | `RunEndArray` expands runs into a `PrimitiveArray` |
 
-```
-scalar_fn(struct.pack):
-  children:
-    - bitpacked(...)                    # x: passed through unchanged
-    - scalar_fn(binary.add):            # y: deferred addition
-        children:
-          - bitpacked(...)              #    original array
-          - constant(1)                 #    literal 1
-```
+Rules of thumb:
 
-Nothing is computed until the tree is executed.
+- Prefer `reduce` over `execute` when possible. Reduce rules are cheaper because they are
+  metadata-only and run before any buffers are touched.
+- Parent rules and parent kernels enable the "child sees parent" pattern. A child encoding often
+  knows how to handle its parent's operation more efficiently than the parent knows how to handle
+  the child.
+- Treat `execute` as the fallback. If no reduce rule or parent kernel applies, the encoding
+  decodes itself and uses `ExecuteChild` to request child execution when needed.
 
 ## Future Work
 
diff --git a/docs/developer-guide/internals/session.md b/docs/developer-guide/internals/session.md
index 75d8bbe7a99..5aff27845af 100644
--- a/docs/developer-guide/internals/session.md
+++ b/docs/developer-guide/internals/session.md
@@ -45,7 +45,7 @@ Plugins register with the session by accessing the relevant component and callin
 
 ```rust
 // Register a custom array encoding
-session.arrays().register(MyEncoding::ID, &MyEncoding);
+session.arrays().register(MyEncoding);
 
 // Register a custom layout
 session.layouts().register(MyLayout::encoding());
diff --git a/docs/developer-guide/internals/vtables.md b/docs/developer-guide/internals/vtables.md
index 0ea3f69e60a..77283ea012d 100644
--- a/docs/developer-guide/internals/vtables.md
+++ b/docs/developer-guide/internals/vtables.md
@@ -9,43 +9,81 @@ post-conditions at the boundary between the two.
 ## The Pattern
 
 Every vtable-backed type in Vortex follows the same structural pattern. For a concept `Foo`,
-there are six components:
-
-| Component     | Name                | Visibility | Role                                                 |
-|---------------|---------------------|------------|------------------------------------------------------|
-| VTable trait  | `FooVTable`         | Public     | Non-object-safe trait that plugin authors implement  |
-| Typed wrapper | `Foo<V: FooVTable>` | Public     | Cheaply cloneable typed handle, passed to VTable fns |
-| Erased ref    | `FooRef`            | Public     | Type-erased handle for heterogeneous storage         |
-| Inner struct  | `FooInner<V>`       | Private    | Holds vtable + data, sole implementor of `DynFoo`    |
-| Sealed trait  | `DynFoo`            | Private    | Object-safe trait implemented only by `FooInner`     |
-| Plugin        | `FooPlugin`         | Public     | Registry trait for ID-based deserialization          |
-
-**Typed form** `Foo<V>` is generic over the vtable type `V`. This is what plugin authors
-construct and what callers use when they know the concrete type. It provides compile-time
-type safety and direct access to the vtable's associated types (e.g. `V::Metadata`).
-
-**Erased form** `FooRef` is a concrete, non-generic struct that hides the vtable type behind
-a trait object. This is what the rest of the system passes around. It can be stored in
-collections, serialized, and threaded through APIs without propagating generic parameters.
-
-Both forms are internally `Arc`-wrapped, making cloning cheap. Upcasting from `Foo<V>` to
-`FooRef` is free (just moving the `Arc`). Downcasting from `FooRef` to `Foo<V>` is a checked
-pointer cast -- also free after the type check.
-
-**VTable methods** receive `&Foo<V>` -- the typed wrapper. Since `Foo<V>` provides access to
-the underlying data (metadata, children, buffers, etc.), there is no need to expose the
-inner struct. `FooInner<V>` is a private implementation detail that holds the data and
-implements the sealed `DynFoo` trait. Both `Foo<V>` and `FooRef` are thin `Arc` wrappers
-around `FooInner<V>` and `dyn DynFoo` respectively.
+there are five components:
+
+| Component    | Name                | Visibility | Role                                                |
+|--------------|---------------------|------------|-----------------------------------------------------|
+| VTable trait | `FooVTable`         | Public     | Non-object-safe trait that plugin authors implement |
+| Data struct  | `Foo<V: FooVTable>` | Public     | Generic data struct, lives behind Arc               |
+| Erased ref   | `FooRef`            | Public     | Type-erased handle, public API surface              |
+| Sealed trait | `DynFoo`            | Private    | Object-safe, blanket impl for `Foo<V>`              |
+| Plugin       | `FooPlugin`         | Public     | Registry trait for ID-based deserialization         |
+
+Three layers of dispatch:
+
+```
+FooRef          thin Arc wrapper, delegates to DynFoo
+  → DynFoo      sealed, thin blanket forwarder to Foo<V> inherent methods
+    → Foo<V>    public API with pre/post-conditions, delegates to FooVTable
+      → FooVTable  plugin authors implement
+```
+
+**Data struct** `Foo<V>` is generic over the vtable type `V`. It holds the vtable instance
+(which may be zero-sized for native implementations or non-zero-sized for language bindings),
+common fields, and a VTable-specific associated type for concept-specific data (e.g.
+`V::Metadata` for ExtDType, `V::Array` for Array). `Foo<V>` is not Arc-wrapped — it lives
+behind `Arc` inside `FooRef`. `Foo<V>` has inherent methods for all operations, with
+pre/post-condition enforcement. These delegate to `FooVTable` methods.
+
+`Foo<V>` implements `Deref` to the VTable's associated data type. This means encoding-specific
+methods defined on the associated type are callable directly on `&Foo<V>` (and therefore on
+the result of downcasting from `&FooRef`), while common methods on `Foo<V>` remain accessible
+via normal method resolution.
+
+**Sealed trait** `DynFoo` is object-safe and has a blanket `impl<V: FooVTable> DynFoo for Foo<V>`.
+This blanket impl is a thin forwarder to `Foo<V>` inherent methods — no logic of its own.
+Its purpose is to enable dynamic dispatch from `FooRef` through to the typed `Foo<V>`.
+`DynFoo` must stay private (`pub(super)`) because it exposes internal plumbing
+(`as_any`, `metadata_any`) that should not be part of the public API.
+
+**Erased form** `FooRef` wraps `Arc<dyn DynFoo>`. It delegates to `DynFoo` methods, which
+forward to `Foo<V>`. It can be stored in collections, serialized, and threaded through APIs
+without propagating generic parameters. Cloning is cheap (Arc clone).
+
+**Downcasting** from `FooRef` to `Foo<V>` is borrowed:
+
+```
+FooRef::as_::<V>(&self) -> &Foo<V>           borrow, free after type check
+FooRef::downcast::<V>(self) -> Arc<Foo<V>>   owned, free after type check
+```
 
 **Plugin** `FooPlugin` is a separate trait for registry-based deserialization. It knows how to
 reconstruct a `FooRef` from serialized bytes without knowing `V` at compile time. Plugins are
 registered in the session by their ID.
 
+## File Conventions
+
+For a concept `Foo`, the components are organized into these files:
+
+| File         | Contains                                                                    |
+|--------------|-----------------------------------------------------------------------------|
+| `vtable.rs`  | `FooVTable` trait definition                                                |
+| `typed.rs`   | `Foo<V>` data struct, inherent methods, `DynFoo` sealed trait, blanket impl |
+| `erased.rs`  | `FooRef` struct                                                             |
+| `plugin.rs`  | `FooPlugin` trait, registration                                             |
+| `matcher.rs` | Downcasting helpers (`is`, `as_`, `as_opt`, pattern matching traits)        |
+
+For Array encodings, each encoding has its own module (e.g. `arrays/primitive/`):
+
+| File                   | Contains                                                    |
+|------------------------|-------------------------------------------------------------|
+| `arrays/foo/mod.rs`    | `V::Array` associated type, encoding-specific methods on it |
+| `arrays/foo/vtable.rs` | `ArrayVTable` impl for this encoding                        |
+| `arrays/foo/compute/`  | Compute kernel implementations                              |
+
 ## Example: ExtDType
 
-Extension dtypes follow this pattern. The vtable defines the extension's ID, metadata type,
-serialization, and validation:
+Extension dtypes follow this pattern:
 
 ```rust
 trait ExtDTypeVTable: Sized + Send + Sync + Clone + Debug {
@@ -56,25 +94,22 @@ trait ExtDTypeVTable: Sized + Send + Sync + Clone + Debug {
     fn deserialize(&self, metadata: &[u8]) -> VortexResult<Self::Metadata>;
     fn validate(&self, metadata: &Self::Metadata, storage_dtype: &DType) -> VortexResult<()>;
 }
-```
 
-The typed form `ExtDType<V>` wraps an `Arc` containing the vtable instance, the metadata, and
-the storage dtype. Users who know the concrete type get full access to the typed metadata:
+struct ExtDType<V: ExtDTypeVTable> {
+    vtable: V,
+    metadata: V::Metadata,
+    storage_dtype: DType,
+}
 
-```rust
-let ts: ExtDType<Timestamp> =...;
-let unit: & TimeUnit = & ts.metadata().unit;    // V::Metadata is concrete
+struct ExtDTypeRef(Arc<dyn DynExtDType>);
 ```
 
-The erased form `ExtDTypeRef` wraps the same `Arc` behind the private `DynExtDType` trait.
-Code that does not need to know the concrete type works with `ExtDTypeRef` and can
-pattern-match to recover the typed form when needed:
+Downcasting from the erased form recovers the typed data struct:
 
 ```rust
 let ext: & ExtDTypeRef = dtype.ext();
-if let Some(meta) = ext.metadata_opt::<Timestamp>() {
-// meta is &TimestampMetadata -- type-safe from here
-}
+let ts: & ExtDType<Timestamp> = ext.as_::<Timestamp>();
+let unit: & TimeUnit = & ts.metadata;     // V::Metadata is concrete
 ```
 
 ## Why Not `dyn Trait`
@@ -97,22 +132,47 @@ plugin authors implement) from the public API (what callers use). The public API
 inputs, enforce invariants, and transform outputs without exposing those concerns to vtable
 implementors. With `dyn Trait`, the trait surface is the public API.
 
-## File Layout Convention
+## Method Overlap and `same_name_method`
+
+`Foo<V>` and `DynFoo` necessarily share method names: `Foo<V>` needs inherent methods
+so callers (including VTable authors who receive `&Foo<Self>`) can use them directly,
+and `DynFoo` needs the same methods for object-safe dispatch from `FooRef`.
 
-Each vtable-backed concept `Foo` lives in its own module directory with a consistent file
-structure:
+Because `Foo<V>` implements `DynFoo`, having both an inherent `id()` and a trait `id()`
+on the same type triggers `clippy::same_name_method`. The correct handling is:
 
-| File         | Contents                                                          |
-|--------------|-------------------------------------------------------------------|
-| `vtable.rs`  | `FooVTable` — the non-object-safe trait users implement           |
-| `plugin.rs`  | `FooPlugin` — registry trait for deserialization + blanket impl   |
-| `typed.rs`   | `Foo<V>` + `FooInner<V>` + `DynFoo` + impl (typed wrapper + guts) |
-| `erased.rs`  | `FooRef` + Display/Debug/PartialEq/Hash impls (erased public API) |
-| `matcher.rs` | `Matcher` trait + blanket impl for `V: FooVTable`                 |
-| `mod.rs`     | Re-exports, `FooId` type alias, sealed module                     |
+1. **Logic lives in `Foo<V>` inherent methods.** Pre/post-conditions, field access, and
+   delegation to `FooVTable` all happen here.
+2. **`DynFoo` blanket impl is a thin forwarder.** Each method body is just `self.method()`.
+   Rust's method resolution picks inherent methods over trait methods, so this calls the
+   inherent impl — no infinite recursion.
+3. **`#[allow(clippy::same_name_method)]`** on the `Foo<V>` inherent impl block
+   acknowledges the intentional shadowing.
 
-The private internals (`FooInner`, `DynFoo`, sealed module) are `pub(super)` within the
-concept's module. Everything else is re-exported from `mod.rs`.
+```rust
+#[allow(clippy::same_name_method)]
+impl<V: FooVTable> Foo<V> {
+    pub fn id(&self) -> FooId {
+        self.vtable.id()            // logic lives here
+    }
+}
+
+impl<V: FooVTable> DynFoo for Foo<V> {
+    fn id(&self) -> FooId {
+        self.id()                   // thin forwarder to inherent
+    }
+}
+```
+
+`DynFoo` must stay **private** (`pub(super)`) because it exposes internal plumbing
+(`as_any`, `metadata_any`) that external callers should never reach. Making it public
+or implementing it for `FooRef` would leak these internals. Instead, `FooRef` has its
+own inherent methods that delegate to `DynFoo` — providing a clean public API without
+exposing the dispatch machinery.
+
+Methods that exist only for erased dispatch (e.g. `as_any`, `metadata_any`,
+`metadata_hash`) have no inherent counterpart on `Foo<V>` and live exclusively in
+`DynFoo`.
 
 ## Registration and Deserialization
 
@@ -128,40 +188,100 @@ consistent across all vtable-backed types in Vortex.
 
 All four vtable-backed types are converging on the pattern described above.
 
-### ExtDType -- Done
+### ExtDType -- Partially done
 
-The reference implementation. All components follow the convention:
+File split already matches conventions: `vtable.rs`, `typed.rs`, `erased.rs`,
+`plugin.rs`, `matcher.rs`. Remaining:
 
-- `ExtVTable` (vtable trait, uniquely not prefixed `ExtDType` for historical reasons)
-- `ExtDType<V>`, `ExtDTypeRef`, `ExtDTypeInner`, `DynExtDType`, `ExtDTypePlugin`
-- `Matcher` trait with blanket impl
-- File layout: `vtable.rs`, `plugin.rs`, `typed.rs`, `erased.rs`, `matcher.rs`
-- `ExtDTypeMetadata` wrapper removed; methods inlined on `ExtDTypeRef`
+- **Drop internal Arc from `ExtDType<V>`.** Currently wraps
+  `Arc<ExtDTypeAdapter<V>>`. Should become the data struct itself, with
+  `ExtDTypeRef(Arc<dyn DynExtDType>)` holding the Arc. Remove `ExtDTypeAdapter`.
+- **Rename** `ExtDTypeImpl` → `DynExtDType`, `DynExtVTable` → `ExtDTypePlugin`.
+- **Remove `ExtDTypeMetadata`** erased wrapper. Its methods (`serialize`, `Display`,
+  `Debug`, `PartialEq`, `Hash`) should move to `ExtDTypeRef`.
 
-### ScalarFn -- Done
+### Expr -- Not started
 
-Follows the convention with `ScalarFnVTable`, `ScalarFnPlugin`, `ScalarFnInner`, `DynScalarFn`,
-`ScalarFn<V>`, `ScalarFnRef`. File layout: `vtable.rs`, `plugin.rs`, `typed.rs`, `erased.rs`.
-Vtable types and reduce/execute adaptors live in `scalar_fn/fns/`.
-Factory functions (e.g. `root()`, `lit()`, `eq()`) live in `expr/exprs.rs`.
+Currently uses `VTable` (unqualified), `VTableAdapter`, `DynExprVTable` (sealed trait),
+and `ExprVTable` (confusingly, the erased ref). Needs renaming to `ExprVTable`, `DynExpr`,
+`ExprRef`. Introduce `Expr<V>` data struct, remove `VTableAdapter`.
 
 ### Layout -- Not started
 
 Currently uses `VTable` (unqualified), `LayoutAdapter`, and `Layout` (sealed trait doubling
-as public API). Needs renaming to `LayoutVTable`, `LayoutInner`, `DynLayout`, `LayoutRef`.
-Typed wrapper `Layout<V>` does not exist yet.
+as public API). Needs renaming to `LayoutVTable`, `DynLayout`, `LayoutRef`. Introduce
+`Layout<V>` data struct, remove `LayoutAdapter`.
 
 ### Array -- Not started
 
 The largest migration. Currently uses `VTable` (unqualified), `ArrayAdapter`, `Array` (sealed
-trait doubling as public API), `ArrayRef`, and `DynVTable`. In addition to renaming
-(`ArrayVTable`, `ArrayInner`, `DynArray`, `ArrayPlugin`), this requires:
-
-1. **Standardize data storage.** Replace per-encoding array structs with a common inner
-   struct holding `(dtype, len, V::Metadata, buffers, children, stats)`. Per-encoding typed
-   accessors (e.g. `DictArray::codes()`) become methods on `Array<DictVTable>`.
-2. **Collapse sub-vtables.** Fold `BaseArrayVTable`, `OperationsVTable`, `ValidityVTable`, and
-   `VisitorVTable` into `ArrayVTable`. Many methods become trivial or generic once data
-   storage is standardized.
-3. **Introduce typed wrapper.** Add `Array<V>` analogous to `ExtDType<V>`, replacing the
-   current `type Array` associated type on the vtable.
+trait doubling as public API), `ArrayRef`, and `DynVTable`.
+
+#### Target Types
+
+```rust
+pub trait ArrayVTable: 'static + Sized + Send + Sync {
+    type Array: 'static + Send + Sync + Clone + Debug;
+    // Methods encoding authors implement.
+    // Receive &Array<Self> for typed access.
+}
+
+pub struct Array<V: ArrayVTable> {
+    vtable: V,          // ZST for native encodings, non-ZST for language bindings
+    dtype: DType,
+    len: usize,
+    array: V::Array,    // encoding-specific data (buffers, children, etc.)
+    stats: ArrayStats,
+}
+
+impl<V: ArrayVTable> Deref for Array<V> {
+    type Target = V::Array;
+}
+
+pub struct ArrayRef(Arc<dyn DynArray>);
+
+trait DynArray: sealed { ... }  // object-safe, thin forwarder
+```
+
+`Array<V>` has inherent methods for all operations (slice, filter, take, etc.)
+with pre/post-condition enforcement. These delegate to `ArrayVTable` methods.
+`DynArray` is a thin blanket forwarder so `ArrayRef` can reach them.
+
+`Array<V>` derefs to `V::Array`, so encoding-specific methods defined on
+the associated type are callable directly on `&Array<V>`. Common methods
+(`dtype()`, `len()`) are inherent on `Array<V>` and resolve first.
+
+Children live in `V::Array` — each encoding owns its child representation.
+The VTable provides `nchildren()` / `child(i)` for generic traversal.
+
+Constructors live on the vtable ZST: `Primitive::new(...) -> ArrayRef`.
+
+When a VTable method needs to signal "return me unchanged" (e.g. `execute`
+for canonical types), it returns `None`. The `ArrayRef` public method handles
+this by cloning its own Arc.
+
+#### Phases
+
+**Phase 0: Rename `Array` trait → `DynArray`.**
+Mechanical rename. Frees the `Array` name for the generic struct.
+
+**Phase 1: Introduce `Array<V>`, migrate encodings.**
+Per encoding:
+
+1. Rename vtable ZST (`PrimitiveVTable` → `Primitive`).
+2. Current bespoke array struct becomes `V::Array` (the associated type).
+3. Wrap it in the generic `Array<V>` struct with common fields hoisted out.
+4. Move constructors to vtable ZST.
+5. Update all call sites (clean break, no type aliases).
+
+**Phase 2: Update sub-vtable signatures.**
+`ValidityVTable`, `OperationsVTable` methods change from `&V::Array` to
+`&Array<V>`.
+
+**Phase 3: Migrate erased layer.**
+
+1. Blanket `impl<V: ArrayVTable> DynArray for Array<V>` forwarding to `Array<V>` inherent methods.
+2. `ArrayRef` becomes concrete struct wrapping `Arc<dyn DynArray>`.
+3. Move `impl dyn DynArray` methods to `impl ArrayRef`.
+4. Remove old `DynArray` trait, `ArrayAdapter`, `vtable!` macro.
+   Introduce `ArrayPlugin` for ID-based deserialization.
diff --git a/docs/project/contributing.md b/docs/project/contributing.md
index 19ea1b0c528..fa6ea57d926 100644
--- a/docs/project/contributing.md
+++ b/docs/project/contributing.md
@@ -34,8 +34,73 @@ git commit -s
 
 ## AI Assistance
 
-AI-assisted contributions are permitted but must be disclosed in the pull request, along with the
-extent of use. Contributors must be able to understand and reason about AI-generated output.
+The Vortex project permits and embraces AI-assisted contributions. Today, most PRs involve some
+degree of AI assistance — whether through IDE autocomplete, conversational AI, or autonomous agents.
+This section describes our expectations around disclosure, review, and accountability.
+
+### Repository Setup
+
+The repository has [Claude Code](https://docs.anthropic.com/en/docs/claude-code) configured as a
+GitHub Action. Users with write access to the repository can mention `@claude` in PR comments or
+issue comments to trigger AI-powered code reviews, request changes, or generate PRs. Configuration
+for Claude's behavior lives in `CLAUDE.md` at the repository root.
+
+### Disclosure
+
+Contributors should disclose AI usage in the PR description when conversational or agentic AI tools
+(e.g., Claude, ChatGPT, Claude Code) were used to produce code, documentation, or tests. Standard
+IDE autocomplete (e.g., Copilot tab-completion) does not require disclosure.
+
+AI-translated content should note that it was translated with AI assistance.
+
+### Human vs. Agent PRs
+
+We distinguish between two kinds of AI-assisted PRs:
+
+- **Human PRs** — A human writes the PR, possibly with significant AI assistance. The human author
+  is accountable for the code quality and correctness, just as they would be for any handwritten
+  code. Standard review rules apply (one approving reviewer).
+
+- **Agent PRs** — An autonomous AI agent (e.g., triggered via `@claude` or a scheduled GitHub
+  Action) opens the PR with minimal human steering. Agent PRs require **two human reviewers**
+  before merge.
+
+The distinction is straightforward: if a human opened the PR, it's a human PR. If an automated
+agent opened it, it's an agent PR.
+
+### Review Standards
+
+AI-assisted code should receive extra scrutiny during review. AI tools can produce code that is
+superficially correct but subtly wrong — off-by-one errors, incorrect edge case handling, or tests
+that pass without actually exercising the intended behavior. Reviewers should pay particular
+attention to:
+
+- Correctness of logic, not just whether it compiles and passes CI.
+- Tests that genuinely validate behavior rather than merely achieving coverage.
+- Unnecessary complexity or over-abstraction.
+
+The project may use AI-powered review tools on PRs. Reviewers are free to use AI to assist their
+reviews without disclosure.
+
+### AI Agents
+
+AI agents (bots, scheduled actions, etc.) are permitted to:
+
+- Open pull requests, with a human assigned as the responsible party.
+- Post review comments on pull requests.
+
+AI agents must **not**:
+
+- Merge or approve pull requests.
+- Push code to protected branches.
+
+A human is accountable for all actions taken by an agent operating under their authority.
+
+### AI-Generated Tests
+
+AI-generated tests are welcome, but contributors must verify that tests actually exercise the
+intended behavior — not just pass. A green test suite produced by AI can give a false sense of
+coverage if the assertions are trivial or the setup doesn't reflect real conditions.
 
 ## Coding Style
 
diff --git a/docs/pyproject.toml b/docs/pyproject.toml
index 63378cbf06f..809bd55d67f 100644
--- a/docs/pyproject.toml
+++ b/docs/pyproject.toml
@@ -12,7 +12,7 @@ dependencies = [
     "sphinx-copybutton>=0.5.2",
     "sphinx-design>=0.6.0",
     "sphinx-inline-tabs>=2023.4.21",
-    "sphinx>=8.0.2",
+    "sphinx>=9.0.0",
     "sphinxcontrib-bibtex>=2.6.3",
     "sphinxcontrib-mermaid>=1.0.0",
     "sphinxext-opengraph>=0.9.1",
diff --git a/encodings/alp/benches/alp_compress.rs b/encodings/alp/benches/alp_compress.rs
index 1c550c54414..239541533f8 100644
--- a/encodings/alp/benches/alp_compress.rs
+++ b/encodings/alp/benches/alp_compress.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng as _;
 use rand::rngs::StdRng;
 use vortex_alp::ALPFloat;
@@ -12,15 +12,15 @@ use vortex_alp::ALPRDFloat;
 use vortex_alp::RDEncoder;
 use vortex_alp::alp_encode;
 use vortex_alp::decompress_into_array;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::dtype::NativePType;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -91,29 +91,59 @@ fn decompress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64
     let values = values.freeze();
     bencher
         .with_inputs(|| {
-            alp_encode(
-                &PrimitiveArray::new(Buffer::copy_from(&values), validity.clone()),
-                None,
+            (
+                alp_encode(
+                    &PrimitiveArray::new(Buffer::copy_from(&values), validity.clone()),
+                    None,
+                )
+                .unwrap(),
+                LEGACY_SESSION.create_execution_ctx(),
             )
-            .unwrap()
         })
-        .bench_values(decompress_into_array);
+        .bench_values(|(v, mut ctx)| decompress_into_array(v, &mut ctx));
 }
 
-#[divan::bench(types = [f32, f64], args = [10_000, 100_000])]
-fn compress_rd<T: ALPRDFloat>(bencher: Bencher, n: usize) {
-    let primitive = PrimitiveArray::new(buffer![T::from(1.23).unwrap(); n], Validity::NonNullable);
-    let encoder = RDEncoder::new(&[T::from(1.23).unwrap()]);
+const RD_BENCH_ARGS: &[(usize, f64)] = &[
+    // length, fraction_patch
+    (10_000, 0.0),
+    (10_000, 0.01),
+    (10_000, 0.1),
+    (100_000, 0.0),
+    (100_000, 0.01),
+    (100_000, 0.1),
+];
+
+fn make_rd_array<T: ALPRDFloat + NativePType>(n: usize, fraction_patch: f64) -> PrimitiveArray {
+    let base_val = T::from(1.23).unwrap();
+    let mut rng = StdRng::seed_from_u64(42);
+    let mut values = buffer![base_val; n].into_mut();
+    if fraction_patch > 0.0 {
+        let outlier = T::from(1000.0).unwrap();
+        for index in 0..values.len() {
+            if rng.random_bool(fraction_patch) {
+                values[index] = outlier;
+            }
+        }
+    }
+    PrimitiveArray::new(values.freeze(), Validity::NonNullable)
+}
+
+#[divan::bench(types = [f32, f64], args = RD_BENCH_ARGS)]
+fn compress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f64)) {
+    let (n, fraction_patch) = args;
+    let primitive = make_rd_array::<T>(n, fraction_patch);
+    let encoder = RDEncoder::new(primitive.as_slice::<T>());
 
     bencher
         .with_inputs(|| (&primitive, &encoder))
         .bench_refs(|(primitive, encoder)| encoder.encode(primitive))
 }
 
-#[divan::bench(types = [f32, f64], args = [10_000, 100_000])]
-fn decompress_rd<T: ALPRDFloat>(bencher: Bencher, n: usize) {
-    let primitive = PrimitiveArray::new(buffer![T::from(1.23).unwrap(); n], Validity::NonNullable);
-    let encoder = RDEncoder::new(&[T::from(1.23).unwrap()]);
+#[divan::bench(types = [f32, f64], args = RD_BENCH_ARGS)]
+fn decompress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f64)) {
+    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);
 
     bencher
diff --git a/encodings/alp/public-api.lock b/encodings/alp/public-api.lock
index 093efd20442..0c5987dbae5 100644
--- a/encodings/alp/public-api.lock
+++ b/encodings/alp/public-api.lock
@@ -2,341 +2,353 @@ pub mod vortex_alp
 
 pub macro vortex_alp::match_each_alp_float_ptype!
 
-pub struct vortex_alp::ALPArray
+pub struct vortex_alp::ALP
 
-impl vortex_alp::ALPArray
+impl vortex_alp::ALP
 
-pub fn vortex_alp::ALPArray::encoded(&self) -> &vortex_array::array::ArrayRef
+pub const vortex_alp::ALP::ID: vortex_array::array::ArrayId
 
-pub fn vortex_alp::ALPArray::exponents(&self) -> vortex_alp::Exponents
+impl vortex_alp::ALP
 
-pub fn vortex_alp::ALPArray::into_parts(self) -> (vortex_array::array::ArrayRef, vortex_alp::Exponents, core::option::Option<vortex_array::patches::Patches>, vortex_array::dtype::DType)
+pub fn vortex_alp::ALP::new(encoded: vortex_array::array::erased::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_alp::ALPArray
 
-pub fn vortex_alp::ALPArray::new(encoded: vortex_array::array::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> Self
+pub unsafe fn vortex_alp::ALP::new_unchecked(encoded: vortex_array::array::erased::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_alp::ALPArray
 
-pub fn vortex_alp::ALPArray::patches(&self) -> core::option::Option<&vortex_array::patches::Patches>
+pub fn vortex_alp::ALP::try_new(encoded: vortex_array::array::erased::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_error::VortexResult<vortex_alp::ALPArray>
 
-pub fn vortex_alp::ALPArray::ptype(&self) -> vortex_array::dtype::ptype::PType
+impl core::clone::Clone for vortex_alp::ALP
 
-pub fn vortex_alp::ALPArray::try_new(encoded: vortex_array::array::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_error::VortexResult<Self>
+pub fn vortex_alp::ALP::clone(&self) -> vortex_alp::ALP
 
-impl core::clone::Clone for vortex_alp::ALPArray
+impl core::fmt::Debug for vortex_alp::ALP
 
-pub fn vortex_alp::ALPArray::clone(&self) -> vortex_alp::ALPArray
+pub fn vortex_alp::ALP::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_alp::ALPArray
+impl vortex_array::array::vtable::VTable for vortex_alp::ALP
 
-pub fn vortex_alp::ALPArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_alp::ALP::ArrayData = vortex_alp::ALPData
 
-impl core::convert::From<vortex_alp::ALPArray> for vortex_array::array::ArrayRef
+pub type vortex_alp::ALP::OperationsVTable = vortex_alp::ALP
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_alp::ALPArray) -> vortex_array::array::ArrayRef
+pub type vortex_alp::ALP::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-impl core::fmt::Debug for vortex_alp::ALPArray
+pub fn vortex_alp::ALP::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_alp::ALPArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_alp::ALP::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::ops::deref::Deref for vortex_alp::ALPArray
+pub fn vortex_alp::ALP::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_alp::ALPArray::Target = dyn vortex_array::array::Array
+pub fn vortex_alp::ALP::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_alp::ALPArray::deref(&self) -> &Self::Target
+pub fn vortex_alp::ALP::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_alp::ALPArray
+pub fn vortex_alp::ALP::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_alp::ALPArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_alp::ALP::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::clone::Clone for vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_alp::ALPMetadata::clone(&self) -> vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::default::Default for vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::validate(&self, data: &vortex_alp::ALPData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_alp::ALPMetadata::default() -> Self
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_alp::ALP> for vortex_alp::ALP
 
-impl core::fmt::Debug for vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_alp::ALP>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_alp::ALPMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_alp::ALP> for vortex_alp::ALP
 
-impl prost::message::Message for vortex_alp::ALPMetadata
+pub fn vortex_alp::ALP::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_alp::ALP>) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_alp::ALPMetadata::clear(&mut self)
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_alp::ALP
 
-pub fn vortex_alp::ALPMetadata::encoded_len(&self) -> usize
+pub fn vortex_alp::ALP::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub struct vortex_alp::ALPRDArray
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_alp::ALP
 
-impl vortex_alp::ALPRDArray
+pub fn vortex_alp::ALP::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDArray::is_f32(&self) -> bool
+impl vortex_array::arrays::slice::SliceKernel for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::left_parts(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_alp::ALP::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDArray::left_parts_dictionary(&self) -> &vortex_buffer::buffer::Buffer<u16>
+impl vortex_array::scalar_fn::fns::between::kernel::BetweenReduce for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::left_parts_patches(&self) -> core::option::Option<&vortex_array::patches::Patches>
+pub fn vortex_alp::ALP::between(array: vortex_array::array::view::ArrayView<'_, Self>, lower: &vortex_array::array::erased::ArrayRef, upper: &vortex_array::array::erased::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDArray::replace_left_parts_patches(&mut self, patches: core::option::Option<vortex_array::patches::Patches>)
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::right_bit_width(&self) -> u8
+pub fn vortex_alp::ALP::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDArray::right_parts(&self) -> &vortex_array::array::ArrayRef
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::try_new(dtype: vortex_array::dtype::DType, left_parts: vortex_array::array::ArrayRef, left_parts_dictionary: vortex_buffer::buffer::Buffer<u16>, right_parts: vortex_array::array::ArrayRef, right_bit_width: u8, left_parts_patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_error::VortexResult<Self>
+pub fn vortex_alp::ALP::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::clone::Clone for vortex_alp::ALPRDArray
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskKernel for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::clone(&self) -> vortex_alp::ALPRDArray
+pub fn vortex_alp::ALP::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_alp::ALPRDArray
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_alp::ALP
 
-pub fn vortex_alp::ALPRDArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub fn vortex_alp::ALP::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::convert::From<vortex_alp::ALPRDArray> for vortex_array::array::ArrayRef
+pub struct vortex_alp::ALPData
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_alp::ALPRDArray) -> vortex_array::array::ArrayRef
+impl vortex_alp::ALPData
 
-impl core::fmt::Debug for vortex_alp::ALPRDArray
+pub fn vortex_alp::ALPData::exponents(&self) -> vortex_alp::Exponents
 
-pub fn vortex_alp::ALPRDArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_alp::ALPData
 
-impl core::ops::deref::Deref for vortex_alp::ALPRDArray
+pub fn vortex_alp::ALPData::new(exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> Self
 
-pub type vortex_alp::ALPRDArray::Target = dyn vortex_array::array::Array
+impl core::clone::Clone for vortex_alp::ALPData
 
-pub fn vortex_alp::ALPRDArray::deref(&self) -> &Self::Target
+pub fn vortex_alp::ALPData::clone(&self) -> vortex_alp::ALPData
 
-impl vortex_array::array::IntoArray for vortex_alp::ALPRDArray
+impl core::fmt::Debug for vortex_alp::ALPData
 
-pub fn vortex_alp::ALPRDArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_alp::ALPData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_alp::ALPRDMetadata
+impl core::fmt::Display for vortex_alp::ALPData
 
-impl vortex_alp::ALPRDMetadata
+pub fn vortex_alp::ALPData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_alp::ALPRDMetadata::left_parts_ptype(&self) -> vortex_array::dtype::ptype::PType
+impl vortex_array::hash::ArrayEq for vortex_alp::ALPData
 
-pub fn vortex_alp::ALPRDMetadata::set_left_parts_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
+pub fn vortex_alp::ALPData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-impl core::clone::Clone for vortex_alp::ALPRDMetadata
+impl vortex_array::hash::ArrayHash for vortex_alp::ALPData
 
-pub fn vortex_alp::ALPRDMetadata::clone(&self) -> vortex_alp::ALPRDMetadata
+pub fn vortex_alp::ALPData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-impl core::default::Default for vortex_alp::ALPRDMetadata
+pub struct vortex_alp::ALPMetadata
 
-pub fn vortex_alp::ALPRDMetadata::default() -> Self
+impl core::clone::Clone for vortex_alp::ALPMetadata
 
-impl core::fmt::Debug for vortex_alp::ALPRDMetadata
+pub fn vortex_alp::ALPMetadata::clone(&self) -> vortex_alp::ALPMetadata
 
-pub fn vortex_alp::ALPRDMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::default::Default for vortex_alp::ALPMetadata
 
-impl prost::message::Message for vortex_alp::ALPRDMetadata
+pub fn vortex_alp::ALPMetadata::default() -> Self
 
-pub fn vortex_alp::ALPRDMetadata::clear(&mut self)
+impl core::fmt::Debug for vortex_alp::ALPMetadata
 
-pub fn vortex_alp::ALPRDMetadata::encoded_len(&self) -> usize
+pub fn vortex_alp::ALPMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_alp::ALPRDVTable
+impl prost::message::Message for vortex_alp::ALPMetadata
 
-impl vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPMetadata::clear(&mut self)
+
+pub fn vortex_alp::ALPMetadata::encoded_len(&self) -> usize
+
+pub struct vortex_alp::ALPRD
 
-pub const vortex_alp::ALPRDVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_alp::ALPRD
 
-impl core::fmt::Debug for vortex_alp::ALPRDVTable
+pub const vortex_alp::ALPRD::ID: vortex_array::array::ArrayId
 
-pub fn vortex_alp::ALPRDVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub unsafe fn vortex_alp::ALPRD::new_unchecked(dtype: vortex_array::dtype::DType, left_parts: vortex_array::array::erased::ArrayRef, left_parts_dictionary: vortex_buffer::buffer::Buffer<u16>, right_parts: vortex_array::array::erased::ArrayRef, right_bit_width: u8, left_parts_patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_alp::ALPRDArray
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::try_new(dtype: vortex_array::dtype::DType, left_parts: vortex_array::array::erased::ArrayRef, left_parts_dictionary: vortex_buffer::buffer::Buffer<u16>, right_parts: vortex_array::array::erased::ArrayRef, right_bit_width: u8, left_parts_patches: core::option::Option<vortex_array::patches::Patches>) -> vortex_error::VortexResult<vortex_alp::ALPRDArray>
 
-pub fn vortex_alp::ALPRDVTable::take(array: &vortex_alp::ALPRDArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_alp::ALPRD
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::clone(&self) -> vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::filter(array: &vortex_alp::ALPRDArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Debug for vortex_alp::ALPRD
 
-impl vortex_array::arrays::slice::SliceKernel for vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_alp::ALPRDVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::array::vtable::VTable for vortex_alp::ALPRD
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_alp::ALPRDVTable
+pub type vortex_alp::ALPRD::ArrayData = vortex_alp::ALPRDData
 
-pub fn vortex_alp::ALPRDVTable::cast(array: &vortex_alp::ALPRDArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub type vortex_alp::ALPRD::OperationsVTable = vortex_alp::ALPRD
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_alp::ALPRDVTable
+pub type vortex_alp::ALPRD::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-pub fn vortex_alp::ALPRDVTable::mask(array: &vortex_alp::ALPRDArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_alp::ALPRD::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::VTable for vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_alp::ALPRDVTable::Array = vortex_alp::ALPRDArray
+pub fn vortex_alp::ALPRD::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_alp::ALPRDVTable::ArrayVTable = vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub type vortex_alp::ALPRDVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_alp::ALPRDMetadata>
+pub fn vortex_alp::ALPRD::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_alp::ALPRDVTable::OperationsVTable = vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::id(&self) -> vortex_array::array::ArrayId
 
-pub type vortex_alp::ALPRDVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub fn vortex_alp::ALPRD::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub type vortex_alp::ALPRDVTable::VisitorVTable = vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRD::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_alp::ALPRDArray>
+pub fn vortex_alp::ALPRD::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_alp::ALPRDVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_alp::ALPRD::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_alp::ALPRDVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_alp::ALPRD::validate(&self, data: &vortex_alp::ALPRDData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_alp::ALPRDVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_alp::ALPRD> for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_alp::ALPRD::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_alp::ALPRD>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_alp::ALPRDVTable::metadata(array: &vortex_alp::ALPRDArray) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_alp::ALPRD> for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_alp::ALPRD::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_alp::ALPRD>) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_alp::ALPRDVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_alp::ALPRD::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_alp::ALPRDVTable> for vortex_alp::ALPRDVTable
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::array_eq(array: &vortex_alp::ALPRDArray, other: &vortex_alp::ALPRDArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_alp::ALPRD::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDVTable::array_hash<H: core::hash::Hasher>(array: &vortex_alp::ALPRDArray, state: &mut H, precision: vortex_array::hash::Precision)
+impl vortex_array::arrays::slice::SliceKernel for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::dtype(array: &vortex_alp::ALPRDArray) -> &vortex_array::dtype::DType
+pub fn vortex_alp::ALPRD::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPRDVTable::len(array: &vortex_alp::ALPRDArray) -> usize
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::stats(array: &vortex_alp::ALPRDArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_alp::ALPRD::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_alp::ALPRDVTable> for vortex_alp::ALPRDVTable
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_alp::ALPRD
 
-pub fn vortex_alp::ALPRDVTable::scalar_at(array: &vortex_alp::ALPRDArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_alp::ALPRD::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_alp::ALPRDVTable> for vortex_alp::ALPRDVTable
+pub struct vortex_alp::ALPRDData
 
-pub fn vortex_alp::ALPRDVTable::validity_child(array: &vortex_alp::ALPRDArray) -> &vortex_array::array::ArrayRef
+impl vortex_alp::ALPRDData
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_alp::ALPRDVTable> for vortex_alp::ALPRDVTable
+pub fn vortex_alp::ALPRDData::into_parts(self, left_parts: vortex_array::array::erased::ArrayRef, right_parts: vortex_array::array::erased::ArrayRef) -> vortex_alp::ALPRDDataParts
 
-pub fn vortex_alp::ALPRDVTable::nbuffers(_array: &vortex_alp::ALPRDArray) -> usize
+pub fn vortex_alp::ALPRDData::left_parts_dictionary(&self) -> &vortex_buffer::buffer::Buffer<u16>
 
-pub fn vortex_alp::ALPRDVTable::nchildren(array: &vortex_alp::ALPRDArray) -> usize
+pub fn vortex_alp::ALPRDData::new(left_parts_dictionary: vortex_buffer::buffer::Buffer<u16>, right_bit_width: u8, left_parts_patches: core::option::Option<vortex_array::patches::Patches>) -> Self
 
-pub fn vortex_alp::ALPRDVTable::visit_buffers(_array: &vortex_alp::ALPRDArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_alp::ALPRDData::right_bit_width(&self) -> u8
 
-pub fn vortex_alp::ALPRDVTable::visit_children(array: &vortex_alp::ALPRDArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+impl core::clone::Clone for vortex_alp::ALPRDData
 
-pub struct vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDData::clone(&self) -> vortex_alp::ALPRDData
 
-impl vortex_alp::ALPVTable
+impl core::fmt::Debug for vortex_alp::ALPRDData
 
-pub const vortex_alp::ALPVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_alp::ALPRDData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::fmt::Debug for vortex_alp::ALPVTable
+impl core::fmt::Display for vortex_alp::ALPRDData
 
-pub fn vortex_alp::ALPVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_alp::ALPRDData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_alp::ALPVTable
+impl vortex_array::hash::ArrayEq for vortex_alp::ALPRDData
 
-pub fn vortex_alp::ALPVTable::take(array: &vortex_alp::ALPArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_alp::ALPRDData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_alp::ALPVTable
+impl vortex_array::hash::ArrayHash for vortex_alp::ALPRDData
 
-pub fn vortex_alp::ALPVTable::filter(array: &vortex_alp::ALPArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_alp::ALPRDData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-impl vortex_array::arrays::slice::SliceKernel for vortex_alp::ALPVTable
+pub struct vortex_alp::ALPRDDataParts
 
-pub fn vortex_alp::ALPVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_alp::ALPRDDataParts::left_parts: vortex_array::array::erased::ArrayRef
 
-impl vortex_array::compute::nan_count::NaNCountKernel for vortex_alp::ALPVTable
+pub vortex_alp::ALPRDDataParts::left_parts_dictionary: vortex_buffer::buffer::Buffer<u16>
 
-pub fn vortex_alp::ALPVTable::nan_count(&self, array: &vortex_alp::ALPArray) -> vortex_error::VortexResult<usize>
+pub vortex_alp::ALPRDDataParts::left_parts_patches: core::option::Option<vortex_array::patches::Patches>
 
-impl vortex_array::scalar_fn::fns::between::kernel::BetweenReduce for vortex_alp::ALPVTable
+pub vortex_alp::ALPRDDataParts::right_parts: vortex_array::array::erased::ArrayRef
 
-pub fn vortex_alp::ALPVTable::between(array: &vortex_alp::ALPArray, lower: &dyn vortex_array::array::Array, upper: &dyn vortex_array::array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_alp::ALPRDDataParts
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDDataParts::clone(&self) -> vortex_alp::ALPRDDataParts
 
-pub fn vortex_alp::ALPVTable::compare(lhs: &vortex_alp::ALPArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Debug for vortex_alp::ALPRDDataParts
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDDataParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_alp::ALPVTable::cast(array: &vortex_alp::ALPArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_alp::ALPRDMetadata
+
+impl vortex_alp::ALPRDMetadata
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskKernel for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDMetadata::left_parts_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_alp::ALPVTable::mask(array: &vortex_alp::ALPArray, mask: &vortex_array::array::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_alp::ALPRDMetadata::set_left_parts_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
+
+impl core::clone::Clone for vortex_alp::ALPRDMetadata
+
+pub fn vortex_alp::ALPRDMetadata::clone(&self) -> vortex_alp::ALPRDMetadata
+
+impl core::default::Default for vortex_alp::ALPRDMetadata
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDMetadata::default() -> Self
 
-pub fn vortex_alp::ALPVTable::mask(array: &vortex_alp::ALPArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Debug for vortex_alp::ALPRDMetadata
 
-impl vortex_array::vtable::VTable for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_alp::ALPVTable::Array = vortex_alp::ALPArray
+impl prost::message::Message for vortex_alp::ALPRDMetadata
 
-pub type vortex_alp::ALPVTable::ArrayVTable = vortex_alp::ALPVTable
+pub fn vortex_alp::ALPRDMetadata::clear(&mut self)
 
-pub type vortex_alp::ALPVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_alp::ALPMetadata>
+pub fn vortex_alp::ALPRDMetadata::encoded_len(&self) -> usize
 
-pub type vortex_alp::ALPVTable::OperationsVTable = vortex_alp::ALPVTable
+pub struct vortex_alp::ALPSlots
 
-pub type vortex_alp::ALPVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub vortex_alp::ALPSlots::encoded: vortex_array::array::erased::ArrayRef
 
-pub type vortex_alp::ALPVTable::VisitorVTable = vortex_alp::ALPVTable
+pub vortex_alp::ALPSlots::patch_chunk_offsets: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_alp::ALPVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_alp::ALPArray>
+pub vortex_alp::ALPSlots::patch_indices: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_alp::ALPVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub vortex_alp::ALPSlots::patch_values: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_alp::ALPVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl vortex_alp::ALPSlots
 
-pub fn vortex_alp::ALPVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub const vortex_alp::ALPSlots::COUNT: usize
 
-pub fn vortex_alp::ALPVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub const vortex_alp::ALPSlots::ENCODED: usize
 
-pub fn vortex_alp::ALPVTable::metadata(array: &vortex_alp::ALPArray) -> vortex_error::VortexResult<Self::Metadata>
+pub const vortex_alp::ALPSlots::NAMES: [&'static str; 4]
 
-pub fn vortex_alp::ALPVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub const vortex_alp::ALPSlots::PATCH_CHUNK_OFFSETS: usize
 
-pub fn vortex_alp::ALPVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub const vortex_alp::ALPSlots::PATCH_INDICES: usize
 
-pub fn vortex_alp::ALPVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub const vortex_alp::ALPSlots::PATCH_VALUES: usize
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_alp::ALPVTable> for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPSlots::from_slots(slots: alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>) -> Self
 
-pub fn vortex_alp::ALPVTable::array_eq(array: &vortex_alp::ALPArray, other: &vortex_alp::ALPArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_alp::ALPSlots::into_slots(self) -> alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_alp::ALPVTable::array_hash<H: core::hash::Hasher>(array: &vortex_alp::ALPArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub struct vortex_alp::ALPSlotsView<'a>
 
-pub fn vortex_alp::ALPVTable::dtype(array: &vortex_alp::ALPArray) -> &vortex_array::dtype::DType
+pub vortex_alp::ALPSlotsView::encoded: &'a vortex_array::array::erased::ArrayRef
 
-pub fn vortex_alp::ALPVTable::len(array: &vortex_alp::ALPArray) -> usize
+pub vortex_alp::ALPSlotsView::patch_chunk_offsets: core::option::Option<&'a vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_alp::ALPVTable::stats(array: &vortex_alp::ALPArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub vortex_alp::ALPSlotsView::patch_indices: core::option::Option<&'a vortex_array::array::erased::ArrayRef>
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_alp::ALPVTable> for vortex_alp::ALPVTable
+pub vortex_alp::ALPSlotsView::patch_values: core::option::Option<&'a vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_alp::ALPVTable::scalar_at(array: &vortex_alp::ALPArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl<'a> vortex_alp::ALPSlotsView<'a>
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_alp::ALPVTable> for vortex_alp::ALPVTable
+pub fn vortex_alp::ALPSlotsView<'a>::from_slots(slots: &'a [core::option::Option<vortex_array::array::erased::ArrayRef>]) -> Self
 
-pub fn vortex_alp::ALPVTable::validity_child(array: &vortex_alp::ALPArray) -> &vortex_array::array::ArrayRef
+pub fn vortex_alp::ALPSlotsView<'a>::to_owned(&self) -> vortex_alp::ALPSlots
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_alp::ALPVTable> for vortex_alp::ALPVTable
+impl<'a> core::clone::Clone for vortex_alp::ALPSlotsView<'a>
 
-pub fn vortex_alp::ALPVTable::nbuffers(_array: &vortex_alp::ALPArray) -> usize
+pub fn vortex_alp::ALPSlotsView<'a>::clone(&self) -> vortex_alp::ALPSlotsView<'a>
 
-pub fn vortex_alp::ALPVTable::nchildren(array: &vortex_alp::ALPArray) -> usize
+impl<'a> core::fmt::Debug for vortex_alp::ALPSlotsView<'a>
 
-pub fn vortex_alp::ALPVTable::visit_buffers(_array: &vortex_alp::ALPArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_alp::ALPSlotsView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_alp::ALPVTable::visit_children(array: &vortex_alp::ALPArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+impl<'a> core::marker::Copy for vortex_alp::ALPSlotsView<'a>
 
 pub struct vortex_alp::Exponents
 
@@ -374,12 +386,56 @@ pub struct vortex_alp::RDEncoder
 
 impl vortex_alp::RDEncoder
 
-pub fn vortex_alp::RDEncoder::encode(&self, array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_alp::ALPRDArray
+pub fn vortex_alp::RDEncoder::encode(&self, array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_alp::ALPRDArray
 
 pub fn vortex_alp::RDEncoder::from_parts(right_bit_width: u8, codes: alloc::vec::Vec<u16>) -> Self
 
 pub fn vortex_alp::RDEncoder::new<T>(sample: &[T]) -> Self where T: vortex_alp::ALPRDFloat + vortex_array::dtype::ptype::NativePType, <T as vortex_alp::ALPRDFloat>::UINT: vortex_array::dtype::ptype::NativePType
 
+pub trait vortex_alp::ALPArrayExt: vortex_alp::ALPArraySlotsExt
+
+pub fn vortex_alp::ALPArrayExt::exponents(&self) -> vortex_alp::Exponents
+
+pub fn vortex_alp::ALPArrayExt::patches(&self) -> core::option::Option<vortex_array::patches::Patches>
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_alp::ALP>> vortex_alp::ALPArrayExt for T
+
+pub fn T::exponents(&self) -> vortex_alp::Exponents
+
+pub fn T::patches(&self) -> core::option::Option<vortex_array::patches::Patches>
+
+pub trait vortex_alp::ALPArrayOwnedExt
+
+pub fn vortex_alp::ALPArrayOwnedExt::into_parts(self) -> (vortex_array::array::erased::ArrayRef, vortex_alp::Exponents, core::option::Option<vortex_array::patches::Patches>)
+
+impl vortex_alp::ALPArrayOwnedExt for vortex_array::array::typed::Array<vortex_alp::ALP>
+
+pub fn vortex_array::array::typed::Array<vortex_alp::ALP>::into_parts(self) -> (vortex_array::array::erased::ArrayRef, vortex_alp::Exponents, core::option::Option<vortex_array::patches::Patches>)
+
+pub trait vortex_alp::ALPArraySlotsExt: vortex_array::array::typed::TypedArrayRef<vortex_alp::ALP>
+
+pub fn vortex_alp::ALPArraySlotsExt::encoded(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_alp::ALPArraySlotsExt::patch_chunk_offsets(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_alp::ALPArraySlotsExt::patch_indices(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_alp::ALPArraySlotsExt::patch_values(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_alp::ALPArraySlotsExt::slots_view(&self) -> vortex_alp::ALPSlotsView<'_>
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_alp::ALP>> vortex_alp::ALPArraySlotsExt for T
+
+pub fn T::encoded(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn T::patch_chunk_offsets(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn T::patch_indices(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn T::patch_values(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
+
+pub fn T::slots_view(&self) -> vortex_alp::ALPSlotsView<'_>
+
 pub trait vortex_alp::ALPFloat: vortex_alp::alp::private::Sealed + num_traits::float::Float + core::fmt::Display + vortex_array::dtype::ptype::NativePType
 
 pub type vortex_alp::ALPFloat::ALPInt: num_traits::int::PrimInt + core::fmt::Display + num_traits::cast::ToPrimitive + core::marker::Copy + vortex_array::dtype::ptype::NativePType + core::convert::Into<vortex_array::scalar::typed_view::primitive::pvalue::PValue>
@@ -440,6 +496,32 @@ pub const f32::SWEET: Self
 
 pub fn f32::as_int(self) -> Self::ALPInt
 
+pub fn f32::decode(encoded: &[Self::ALPInt], exponents: vortex_alp::Exponents) -> alloc::vec::Vec<Self>
+
+pub fn f32::decode_buffer(encoded: vortex_buffer::buffer_mut::BufferMut<Self::ALPInt>, exponents: vortex_alp::Exponents) -> vortex_buffer::buffer_mut::BufferMut<Self>
+
+pub fn f32::decode_into(encoded: &[Self::ALPInt], exponents: vortex_alp::Exponents, output: &mut [Self])
+
+pub fn f32::decode_single(encoded: Self::ALPInt, exponents: vortex_alp::Exponents) -> Self
+
+pub fn f32::decode_slice_inplace(encoded: &mut [Self::ALPInt], exponents: vortex_alp::Exponents)
+
+pub fn f32::encode(values: &[Self], exponents: core::option::Option<vortex_alp::Exponents>) -> (vortex_alp::Exponents, vortex_buffer::buffer::Buffer<Self::ALPInt>, vortex_buffer::buffer::Buffer<u64>, vortex_buffer::buffer::Buffer<Self>, vortex_buffer::buffer_mut::BufferMut<u64>)
+
+pub fn f32::encode_above(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f32::encode_below(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f32::encode_single(value: Self, exponents: vortex_alp::Exponents) -> core::option::Option<Self::ALPInt>
+
+pub fn f32::encode_single_unchecked(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f32::estimate_encoded_size(encoded: &[Self::ALPInt], patches: &[Self]) -> usize
+
+pub fn f32::fast_round(self) -> Self
+
+pub fn f32::find_best_exponents(values: &[Self]) -> vortex_alp::Exponents
+
 pub fn f32::from_int(n: Self::ALPInt) -> Self
 
 impl vortex_alp::ALPFloat for f64
@@ -458,8 +540,66 @@ pub const f64::SWEET: Self
 
 pub fn f64::as_int(self) -> Self::ALPInt
 
+pub fn f64::decode(encoded: &[Self::ALPInt], exponents: vortex_alp::Exponents) -> alloc::vec::Vec<Self>
+
+pub fn f64::decode_buffer(encoded: vortex_buffer::buffer_mut::BufferMut<Self::ALPInt>, exponents: vortex_alp::Exponents) -> vortex_buffer::buffer_mut::BufferMut<Self>
+
+pub fn f64::decode_into(encoded: &[Self::ALPInt], exponents: vortex_alp::Exponents, output: &mut [Self])
+
+pub fn f64::decode_single(encoded: Self::ALPInt, exponents: vortex_alp::Exponents) -> Self
+
+pub fn f64::decode_slice_inplace(encoded: &mut [Self::ALPInt], exponents: vortex_alp::Exponents)
+
+pub fn f64::encode(values: &[Self], exponents: core::option::Option<vortex_alp::Exponents>) -> (vortex_alp::Exponents, vortex_buffer::buffer::Buffer<Self::ALPInt>, vortex_buffer::buffer::Buffer<u64>, vortex_buffer::buffer::Buffer<Self>, vortex_buffer::buffer_mut::BufferMut<u64>)
+
+pub fn f64::encode_above(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f64::encode_below(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f64::encode_single(value: Self, exponents: vortex_alp::Exponents) -> core::option::Option<Self::ALPInt>
+
+pub fn f64::encode_single_unchecked(value: Self, exponents: vortex_alp::Exponents) -> Self::ALPInt
+
+pub fn f64::estimate_encoded_size(encoded: &[Self::ALPInt], patches: &[Self]) -> usize
+
+pub fn f64::fast_round(self) -> Self
+
+pub fn f64::find_best_exponents(values: &[Self]) -> vortex_alp::Exponents
+
 pub fn f64::from_int(n: Self::ALPInt) -> Self
 
+pub trait vortex_alp::ALPRDArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_alp::ALPRD>
+
+pub fn vortex_alp::ALPRDArrayExt::left_parts(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_alp::ALPRDArrayExt::left_parts_dictionary(&self) -> &vortex_buffer::buffer::Buffer<u16>
+
+pub fn vortex_alp::ALPRDArrayExt::left_parts_patches(&self) -> core::option::Option<vortex_array::patches::Patches>
+
+pub fn vortex_alp::ALPRDArrayExt::right_bit_width(&self) -> u8
+
+pub fn vortex_alp::ALPRDArrayExt::right_parts(&self) -> &vortex_array::array::erased::ArrayRef
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_alp::ALPRD>> vortex_alp::ALPRDArrayExt for T
+
+pub fn T::left_parts(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn T::left_parts_dictionary(&self) -> &vortex_buffer::buffer::Buffer<u16>
+
+pub fn T::left_parts_patches(&self) -> core::option::Option<vortex_array::patches::Patches>
+
+pub fn T::right_bit_width(&self) -> u8
+
+pub fn T::right_parts(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub trait vortex_alp::ALPRDArrayOwnedExt
+
+pub fn vortex_alp::ALPRDArrayOwnedExt::into_data_parts(self) -> vortex_alp::ALPRDDataParts
+
+impl vortex_alp::ALPRDArrayOwnedExt for vortex_array::array::typed::Array<vortex_alp::ALPRD>
+
+pub fn vortex_array::array::typed::Array<vortex_alp::ALPRD>::into_data_parts(self) -> vortex_alp::ALPRDDataParts
+
 pub trait vortex_alp::ALPRDFloat: vortex_alp::alp_rd::private::Sealed + num_traits::float::Float + core::marker::Copy + vortex_array::dtype::ptype::NativePType
 
 pub type vortex_alp::ALPRDFloat::UINT: vortex_array::dtype::ptype::NativePType + num_traits::int::PrimInt + num_traits::identities::One + core::marker::Copy
@@ -478,6 +618,8 @@ impl vortex_alp::ALPRDFloat for f32
 
 pub type f32::UINT = u32
 
+pub const f32::BITS: usize
+
 pub fn f32::from_bits(bits: Self::UINT) -> Self
 
 pub fn f32::from_u16(value: u16) -> Self::UINT
@@ -490,6 +632,8 @@ impl vortex_alp::ALPRDFloat for f64
 
 pub type f64::UINT = u64
 
+pub const f64::BITS: usize
+
 pub fn f64::from_bits(bits: Self::UINT) -> Self
 
 pub fn f64::from_u16(value: u16) -> Self::UINT
@@ -498,8 +642,14 @@ pub fn f64::to_bits(value: Self) -> Self::UINT
 
 pub fn f64::to_u16(bits: Self::UINT) -> u16
 
-pub fn vortex_alp::alp_encode(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, exponents: core::option::Option<vortex_alp::Exponents>) -> vortex_error::VortexResult<vortex_alp::ALPArray>
+pub fn vortex_alp::alp_encode(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, exponents: core::option::Option<vortex_alp::Exponents>) -> vortex_error::VortexResult<vortex_alp::ALPArray>
+
+pub fn vortex_alp::alp_rd_decode<T: vortex_alp::ALPRDFloat>(left_parts: vortex_buffer::buffer_mut::BufferMut<u16>, left_parts_dict: &[u16], right_bit_width: u8, right_parts: vortex_buffer::buffer_mut::BufferMut<<T as vortex_alp::ALPRDFloat>::UINT>, left_parts_patches: core::option::Option<vortex_array::patches::Patches>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_buffer::buffer::Buffer<T>>
+
+pub fn vortex_alp::decompress_into_array(array: vortex_alp::ALPArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::vtable::PrimitiveArray>
+
+pub fn vortex_alp::initialize(session: &vortex_session::VortexSession)
 
-pub fn vortex_alp::alp_rd_decode<T: vortex_alp::ALPRDFloat>(left_parts: vortex_buffer::buffer::Buffer<u16>, left_parts_dict: &[u16], right_bit_width: u8, right_parts: vortex_buffer::buffer_mut::BufferMut<<T as vortex_alp::ALPRDFloat>::UINT>, left_parts_patches: core::option::Option<&vortex_array::patches::Patches>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_buffer::buffer::Buffer<T>>
+pub type vortex_alp::ALPArray = vortex_array::array::typed::Array<vortex_alp::ALP>
 
-pub fn vortex_alp::decompress_into_array(array: vortex_alp::ALPArray) -> vortex_error::VortexResult<vortex_array::arrays::primitive::array::PrimitiveArray>
+pub type vortex_alp::ALPRDArray = vortex_array::array::typed::Array<vortex_alp::ALPRD>
diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs
index 00759bea0a7..73852549965 100644
--- a/encodings/alp/src/alp/array.rs
+++ b/encodings/alp/src/alp/array.rs
@@ -2,40 +2,42 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
+use prost::Message;
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::TypedArrayRef;
+use vortex_array::array_slots;
+use vortex_array::arrays::Primitive;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::PType;
 use vortex_array::patches::Patches;
 use vortex_array::patches::PatchesMetadata;
+use vortex_array::require_child;
+use vortex_array::require_patches;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
 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_error::vortex_panic;
 use vortex_session::VortexSession;
 
 use crate::ALPFloat;
@@ -44,57 +46,97 @@ use crate::alp::decompress::execute_decompress;
 use crate::alp::rules::PARENT_KERNELS;
 use crate::alp::rules::RULES;
 
-vtable!(ALP);
+/// A [`ALP`]-encoded Vortex array.
+pub type ALPArray = Array<ALP>;
 
-impl VTable for ALPVTable {
-    type Array = ALPArray;
+impl ArrayHash for ALPData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.exponents.hash(state);
+        self.patch_offset.hash(state);
+        self.patch_offset_within_chunk.hash(state);
+    }
+}
+
+impl ArrayEq for ALPData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.exponents == other.exponents
+            && self.patch_offset == other.patch_offset
+            && self.patch_offset_within_chunk == other.patch_offset_within_chunk
+    }
+}
 
-    type Metadata = ProstMetadata<ALPMetadata>;
+impl VTable for ALP {
+    type ArrayData = ALPData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &ALPArray) -> VortexResult<Self::Metadata> {
-        let exponents = array.exponents();
-        Ok(ProstMetadata(ALPMetadata {
-            exp_e: exponents.e as u32,
-            exp_f: exponents.f as u32,
-            patches: array
-                .patches()
-                .map(|p| p.to_metadata(array.len(), array.dtype()))
-                .transpose()?,
-        }))
+    fn validate(
+        &self,
+        data: &ALPData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let slots = ALPSlotsView::from_slots(slots);
+        validate_parts(
+            dtype,
+            len,
+            data.exponents,
+            slots.encoded,
+            patches_from_slots(
+                &slots,
+                data.patch_offset,
+                data.patch_offset_within_chunk,
+                len,
+            ),
+        )
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ALPArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<ALPMetadata> as DeserializeMetadata>::deserialize(bytes)?,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let exponents = array.exponents();
+        Ok(Some(
+            ALPMetadata {
+                exp_e: exponents.e as u32,
+                exp_f: exponents.f as u32,
+                patches: array
+                    .patches()
+                    .map(|p| p.to_metadata(array.len(), array.dtype()))
+                    .transpose()?,
+            }
+            .encode_to_vec(),
         ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ALPArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = ALPMetadata::decode(metadata)?;
         let encoded_ptype = match &dtype {
             DType::Primitive(PType::F32, n) => DType::Primitive(PType::I32, *n),
             DType::Primitive(PType::F64, n) => DType::Primitive(PType::I64, *n),
@@ -116,68 +158,37 @@ impl VTable for ALPVTable {
             })
             .transpose()?;
 
-        ALPArray::try_new(
-            encoded,
+        let slots = ALPData::make_slots(&encoded, &patches);
+        let data = ALPData::new(
             Exponents {
                 e: u8::try_from(metadata.exp_e)?,
                 f: u8::try_from(metadata.exp_f)?,
             },
             patches,
-        )
+        );
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // Children: encoded, patches (if present): indices, values, chunk_offsets (optional)
-        let patches_info = array
-            .patches
-            .as_ref()
-            .map(|p| (p.array_len(), p.offset(), p.chunk_offsets().is_some()));
-
-        let expected_children = match &patches_info {
-            Some((_, _, has_chunk_offsets)) => 1 + 2 + if *has_chunk_offsets { 1 } else { 0 },
-            None => 1,
-        };
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        ALPSlots::NAMES[idx].to_string()
+    }
 
-        vortex_ensure!(
-            children.len() == expected_children,
-            "ALPArray expects {} children, got {}",
-            expected_children,
-            children.len()
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = require_child!(array, array.encoded(), ALPSlots::ENCODED => Primitive);
+        require_patches!(
+            array,
+            ALPSlots::PATCH_INDICES,
+            ALPSlots::PATCH_VALUES,
+            ALPSlots::PATCH_CHUNK_OFFSETS
         );
 
-        let mut children_iter = children.into_iter();
-        array.encoded = children_iter
-            .next()
-            .ok_or_else(|| vortex_err!("Expected encoded child"))?;
-
-        if let Some((array_len, offset, _has_chunk_offsets)) = patches_info {
-            let indices = children_iter
-                .next()
-                .ok_or_else(|| vortex_err!("Expected patch indices child"))?;
-            let values = children_iter
-                .next()
-                .ok_or_else(|| vortex_err!("Expected patch values child"))?;
-            let chunk_offsets = children_iter.next();
-
-            array.patches = Some(Patches::new(
-                array_len,
-                offset,
-                indices,
-                values,
-                chunk_offsets,
-            )?);
-        }
-
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        // TODO(joe): take by value
-        Ok(execute_decompress(array.clone(), ctx)?.into_array())
+        Ok(ExecutionResult::done(
+            execute_decompress(array, ctx)?.into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -185,7 +196,7 @@ impl VTable for ALPVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -194,19 +205,39 @@ impl VTable for ALPVTable {
     }
 }
 
+#[array_slots(ALP)]
+pub struct ALPSlots {
+    /// The ALP-encoded values array.
+    pub encoded: ArrayRef,
+    /// The indices of exception values that could not be ALP-encoded.
+    pub patch_indices: Option<ArrayRef>,
+    /// The exception values that could not be ALP-encoded.
+    pub patch_values: Option<ArrayRef>,
+    /// Chunk offsets for the patch indices/values.
+    pub patch_chunk_offsets: Option<ArrayRef>,
+}
+
 #[derive(Clone, Debug)]
-pub struct ALPArray {
-    encoded: ArrayRef,
-    patches: Option<Patches>,
-    dtype: DType,
+pub struct ALPData {
+    patch_offset: Option<usize>,
+    patch_offset_within_chunk: Option<usize>,
     exponents: Exponents,
-    stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
-pub struct ALPVTable;
+impl Display for ALPData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "exponents: {}", self.exponents)?;
+        if let Some(offset) = self.patch_offset {
+            write!(f, ", patch_offset: {offset}")?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ALP;
 
-impl ALPVTable {
+impl ALP {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.alp");
 }
 
@@ -220,9 +251,9 @@ pub struct ALPMetadata {
     pub(crate) patches: Option<PatchesMetadata>,
 }
 
-impl ALPArray {
-    fn validate(
-        encoded: &dyn Array,
+impl ALPData {
+    fn validate_components(
+        encoded: &ArrayRef,
         exponents: Exponents,
         patches: Option<&Patches>,
     ) -> VortexResult<()> {
@@ -272,8 +303,20 @@ impl ALPArray {
         Ok(())
     }
 
+    fn logical_dtype(encoded: &ArrayRef) -> VortexResult<DType> {
+        match encoded.dtype() {
+            DType::Primitive(PType::I32, nullability) => {
+                Ok(DType::Primitive(PType::F32, *nullability))
+            }
+            DType::Primitive(PType::I64, nullability) => {
+                Ok(DType::Primitive(PType::F64, *nullability))
+            }
+            _ => vortex_bail!("ALP encoded ints have invalid DType {}", encoded.dtype(),),
+        }
+    }
+
     /// Validate that any patches provided are valid for the ALPArray.
-    fn validate_patches<T: ALPFloat>(patches: &Patches, encoded: &dyn Array) -> VortexResult<()> {
+    fn validate_patches<T: ALPFloat>(patches: &Patches, encoded: &ArrayRef) -> VortexResult<()> {
         vortex_ensure!(
             patches.array_len() == encoded.len(),
             "patches array_len != encoded len: {} != {}",
@@ -292,13 +335,22 @@ impl ALPArray {
     }
 }
 
-impl ALPArray {
+impl ALPData {
     /// Build a new `ALPArray` from components, panicking on validation failure.
     ///
-    /// See [`ALPArray::try_new`] for reference on preconditions that must pass before
+    /// See [`ALP::try_new`] for reference on preconditions that must pass before
     /// calling this method.
-    pub fn new(encoded: ArrayRef, exponents: Exponents, patches: Option<Patches>) -> Self {
-        Self::try_new(encoded, exponents, patches).vortex_expect("ALPArray new")
+    pub fn new(exponents: Exponents, patches: Option<Patches>) -> Self {
+        let (patch_offset, patch_offset_within_chunk) = match &patches {
+            Some(p) => (Some(p.offset()), p.offset_within_chunk()),
+            None => (None, None),
+        };
+
+        Self {
+            patch_offset,
+            patch_offset_within_chunk,
+            exponents,
+        }
     }
 
     /// Build a new `ALPArray` from components:
@@ -307,169 +359,163 @@ impl ALPArray {
     /// * `exponents` are the ALP exponents, valid range depends on the data type
     /// * `patches` are any patch values that don't cleanly encode using the ALP conversion function
     ///
-    /// This method validates the inputs and will return an error if any validation fails.
-    ///
-    /// # Validation
-    ///
-    /// * The `encoded` array must be either `i32` or `i64`
-    ///     * If `i32`, any `patches` must have DType `f32` with same nullability
-    ///     * If `i64`, then `patches`must have DType `f64` with same nullability
-    /// * `exponents` must be in the valid range depending on if the ALPArray is of type `f32` or
-    ///   `f64`.
-    /// * `patches` must have an `array_len` equal to the length of `encoded`
-    ///
-    /// Any failure of these preconditions will result in an error being returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use vortex_alp::{ALPArray, Exponents};
-    /// # use vortex_array::IntoArray;
-    /// # use vortex_buffer::buffer;
-    ///
-    /// // Returns error because buffer has wrong PType.
-    /// let result = ALPArray::try_new(
-    ///     buffer![1i8].into_array(),
-    ///     Exponents { e: 1, f: 1 },
-    ///     None
-    /// );
-    /// assert!(result.is_err());
-    ///
-    /// // Returns error because Exponents are out of bounds for f32
-    /// let result = ALPArray::try_new(
-    ///     buffer![1i32, 2i32].into_array(),
-    ///     Exponents { e: 100, f: 100 },
-    ///     None
-    /// );
-    /// assert!(result.is_err());
-    ///
-    /// // Success!
-    /// let value = ALPArray::try_new(
-    ///     buffer![0i32].into_array(),
-    ///     Exponents { e: 1, f: 1 },
-    ///     None
-    /// ).unwrap();
+    /// Build a new `ALPArray` from components without validation.
     ///
-    /// assert_eq!(value.scalar_at(0).unwrap(), 0f32.into());
-    /// ```
+    /// See [`ALP::try_new`] for information about the preconditions that should be checked
+    /// **before** calling this method.
+    pub(crate) unsafe fn new_unchecked(exponents: Exponents, patches: Option<Patches>) -> Self {
+        Self::new(exponents, patches)
+    }
+}
+
+/// Constructors for [`ALPArray`].
+impl ALP {
+    pub fn new(encoded: ArrayRef, exponents: Exponents, patches: Option<Patches>) -> ALPArray {
+        let dtype = ALPData::logical_dtype(&encoded).vortex_expect("ALP encoded dtype");
+        let len = encoded.len();
+        let slots = ALPData::make_slots(&encoded, &patches);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ALP, dtype, len, ALPData::new(exponents, patches))
+                    .with_slots(slots),
+            )
+        }
+    }
+
     pub fn try_new(
         encoded: ArrayRef,
         exponents: Exponents,
         patches: Option<Patches>,
-    ) -> VortexResult<Self> {
-        Self::validate(&encoded, exponents, patches.as_ref())?;
-
-        let dtype = match encoded.dtype() {
-            DType::Primitive(PType::I32, nullability) => DType::Primitive(PType::F32, *nullability),
-            DType::Primitive(PType::I64, nullability) => DType::Primitive(PType::F64, *nullability),
-            _ => unreachable!(),
-        };
-
-        Ok(Self {
-            dtype,
-            encoded,
-            exponents,
-            patches,
-            stats_set: Default::default(),
-        })
+    ) -> VortexResult<ALPArray> {
+        let dtype = ALPData::logical_dtype(&encoded)?;
+        let len = encoded.len();
+        let slots = ALPData::make_slots(&encoded, &patches);
+        let data = ALPData::new(exponents, patches);
+        Array::try_from_parts(ArrayParts::new(ALP, dtype, len, data).with_slots(slots))
     }
 
-    /// Build a new `ALPArray` from components without validation.
-    ///
-    /// See [`ALPArray::try_new`] for information about the preconditions that should be checked
-    /// **before** calling this method.
-    pub(crate) unsafe fn new_unchecked(
+    /// # Safety
+    /// See [`ALP::try_new`] for preconditions.
+    pub unsafe fn new_unchecked(
         encoded: ArrayRef,
         exponents: Exponents,
         patches: Option<Patches>,
-        dtype: DType,
-    ) -> Self {
-        Self {
-            dtype,
-            encoded,
-            exponents,
-            patches,
-            stats_set: Default::default(),
+    ) -> ALPArray {
+        let dtype = ALPData::logical_dtype(&encoded).vortex_expect("ALP encoded dtype");
+        let len = encoded.len();
+        let slots = ALPData::make_slots(&encoded, &patches);
+        let data = unsafe { ALPData::new_unchecked(exponents, patches) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(ALP, dtype, len, data).with_slots(slots))
         }
     }
+}
 
-    pub fn ptype(&self) -> PType {
-        self.dtype.as_ptype()
-    }
-
-    pub fn encoded(&self) -> &ArrayRef {
-        &self.encoded
+impl ALPData {
+    fn make_slots(encoded: &ArrayRef, patches: &Option<Patches>) -> Vec<Option<ArrayRef>> {
+        let (patch_indices, patch_values, patch_chunk_offsets) = match patches {
+            Some(p) => (
+                Some(p.indices().clone()),
+                Some(p.values().clone()),
+                p.chunk_offsets().clone(),
+            ),
+            None => (None, None, None),
+        };
+        vec![
+            Some(encoded.clone()),
+            patch_indices,
+            patch_values,
+            patch_chunk_offsets,
+        ]
     }
 
     #[inline]
     pub fn exponents(&self) -> Exponents {
         self.exponents
     }
+}
 
-    pub fn patches(&self) -> Option<&Patches> {
-        self.patches.as_ref()
+pub trait ALPArrayExt: ALPArraySlotsExt {
+    fn exponents(&self) -> Exponents {
+        self.exponents
     }
 
-    /// Consumes the array and returns its parts.
-    #[inline]
-    pub fn into_parts(self) -> (ArrayRef, Exponents, Option<Patches>, DType) {
-        (self.encoded, self.exponents, self.patches, self.dtype)
+    fn patches(&self) -> Option<Patches> {
+        patches_from_slots(
+            &self.slots_view(),
+            self.patch_offset,
+            self.patch_offset_within_chunk,
+            self.as_ref().len(),
+        )
     }
 }
 
-impl ValidityChild<ALPVTable> for ALPVTable {
-    fn validity_child(array: &ALPArray) -> &ArrayRef {
-        array.encoded()
+fn patches_from_slots(
+    slots: &ALPSlotsView,
+    patch_offset: Option<usize>,
+    patch_offset_within_chunk: Option<usize>,
+    len: usize,
+) -> Option<Patches> {
+    match (slots.patch_indices, slots.patch_values) {
+        (Some(indices), Some(values)) => {
+            let patch_offset = patch_offset.vortex_expect("has patch slots but no patch_offset");
+            Some(unsafe {
+                Patches::new_unchecked(
+                    len,
+                    patch_offset,
+                    indices.clone(),
+                    values.clone(),
+                    slots.patch_chunk_offsets.cloned(),
+                    patch_offset_within_chunk,
+                )
+            })
+        }
+        _ => None,
     }
 }
 
-impl BaseArrayVTable<ALPVTable> for ALPVTable {
-    fn len(array: &ALPArray) -> usize {
-        array.encoded.len()
-    }
-
-    fn dtype(array: &ALPArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ALPArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &ALPArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.encoded.array_hash(state, precision);
-        array.exponents.hash(state);
-        array.patches.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &ALPArray, other: &ALPArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.encoded.array_eq(&other.encoded, precision)
-            && array.exponents == other.exponents
-            && array.patches.array_eq(&other.patches, precision)
-    }
+fn validate_parts(
+    dtype: &DType,
+    len: usize,
+    exponents: Exponents,
+    encoded: &ArrayRef,
+    patches: Option<Patches>,
+) -> VortexResult<()> {
+    let logical_dtype = ALPData::logical_dtype(encoded)?;
+    ALPData::validate_components(encoded, exponents, patches.as_ref())?;
+    vortex_ensure!(
+        encoded.len() == len,
+        "ALP encoded len {} != outer len {len}",
+        encoded.len(),
+    );
+    vortex_ensure!(
+        &logical_dtype == dtype,
+        "ALP dtype {} does not match encoded logical dtype {}",
+        dtype,
+        logical_dtype,
+    );
+    Ok(())
 }
 
-impl VisitorVTable<ALPVTable> for ALPVTable {
-    fn visit_buffers(_array: &ALPArray, _visitor: &mut dyn ArrayBufferVisitor) {}
+impl<T: TypedArrayRef<ALP>> ALPArrayExt for T {}
 
-    fn nbuffers(_array: &ALPArray) -> usize {
-        0
-    }
+pub trait ALPArrayOwnedExt {
+    fn into_parts(self) -> (ArrayRef, Exponents, Option<Patches>);
+}
 
-    fn visit_children(array: &ALPArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("encoded", array.encoded());
-        if let Some(patches) = array.patches() {
-            visitor.visit_patches(patches);
-        }
+impl ALPArrayOwnedExt for Array<ALP> {
+    #[inline]
+    fn into_parts(self) -> (ArrayRef, Exponents, Option<Patches>) {
+        let patches = self.patches();
+        let exponents = self.exponents();
+        let encoded = self.encoded().clone();
+        (encoded, exponents, patches)
     }
+}
 
-    fn nchildren(array: &ALPArray) -> usize {
-        // encoded + optional patches (indices + values + optional chunk_offsets)
-        1 + array
-            .patches()
-            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
+impl ValidityChild<ALP> for ALP {
+    fn validity_child(array: ArrayView<'_, ALP>) -> ArrayRef {
+        array.encoded().clone()
     }
 }
 
@@ -481,12 +527,13 @@ mod tests {
     use rstest::rstest;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::session::ArraySession;
-    use vortex_array::vtable::ValidityHelper;
+    use vortex_error::VortexExpect;
     use vortex_session::VortexSession;
 
     use super::*;
@@ -512,10 +559,15 @@ mod tests {
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
-            encoded.to_array().execute::<Canonical>(&mut ctx).unwrap()
+            encoded
+                .clone()
+                .into_array()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
         };
         // Compare against the traditional array-based decompress path
-        let expected = decompress_into_array(encoded).unwrap();
+        let expected =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(result_canonical.into_array(), expected);
     }
@@ -536,10 +588,15 @@ mod tests {
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
-            encoded.to_array().execute::<Canonical>(&mut ctx).unwrap()
+            encoded
+                .clone()
+                .into_array()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
         };
         // Compare against the traditional array-based decompress path
-        let expected = decompress_into_array(encoded).unwrap();
+        let expected =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(result_canonical.into_array(), expected);
     }
@@ -566,10 +623,15 @@ mod tests {
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
-            encoded.to_array().execute::<Canonical>(&mut ctx).unwrap()
+            encoded
+                .clone()
+                .into_array()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
         };
         // Compare against the traditional array-based decompress path
-        let expected = decompress_into_array(encoded).unwrap();
+        let expected =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(result_canonical.into_array(), expected);
     }
@@ -594,10 +656,15 @@ mod tests {
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
-            encoded.to_array().execute::<Canonical>(&mut ctx).unwrap()
+            encoded
+                .clone()
+                .into_array()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
         };
         // Compare against the traditional array-based decompress path
-        let expected = decompress_into_array(encoded).unwrap();
+        let expected =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(result_canonical.into_array(), expected);
     }
@@ -625,10 +692,15 @@ mod tests {
 
         let result_canonical = {
             let mut ctx = SESSION.create_execution_ctx();
-            encoded.to_array().execute::<Canonical>(&mut ctx).unwrap()
+            encoded
+                .clone()
+                .into_array()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
         };
         // Compare against the traditional array-based decompress path
-        let expected = decompress_into_array(encoded).unwrap();
+        let expected =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(result_canonical.into_array(), expected);
     }
@@ -666,7 +738,11 @@ mod tests {
         for idx in 0..slice_len {
             let expected_value = values[slice_start + idx];
 
-            let result_valid = result_primitive.validity().is_valid(idx).unwrap();
+            let result_valid = result_primitive
+                .validity()
+                .vortex_expect("result validity should be derivable")
+                .is_valid(idx)
+                .unwrap();
             assert_eq!(
                 result_valid,
                 expected_value.is_some(),
@@ -762,14 +838,18 @@ mod tests {
         .unwrap();
 
         // Build a new ALPArray with the same encoded data but patches without chunk_offsets.
-        let alp_without_chunk_offsets = ALPArray::new(
+        let alp_without_chunk_offsets = ALP::new(
             normally_encoded.encoded().clone(),
             normally_encoded.exponents(),
             Some(patches_without_chunk_offsets),
         );
 
         // The legacy decompress_into_array path should work correctly.
-        let result_legacy = decompress_into_array(alp_without_chunk_offsets.clone()).unwrap();
+        let result_legacy = decompress_into_array(
+            alp_without_chunk_offsets.clone(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
         let legacy_slice = result_legacy.as_slice::<f64>();
 
         // Verify the legacy path produces correct values.
diff --git a/encodings/alp/src/alp/compress.rs b/encodings/alp/src/alp/compress.rs
index b082a781479..b5c259aeef1 100644
--- a/encodings/alp/src/alp/compress.rs
+++ b/encodings/alp/src/alp/compress.rs
@@ -8,13 +8,13 @@ use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::PType;
 use vortex_array::patches::Patches;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_mask::Mask;
 
+use crate::ALP;
 use crate::Exponents;
 use crate::alp::ALPArray;
 use crate::alp::ALPFloat;
@@ -47,14 +47,7 @@ pub fn alp_encode(parray: &PrimitiveArray, exponents: Option<Exponents>) -> Vort
     };
 
     // SAFETY: alp_encode_components_typed must return well-formed components
-    unsafe {
-        Ok(ALPArray::new_unchecked(
-            encoded,
-            exponents,
-            patches,
-            parray.dtype().clone(),
-        ))
-    }
+    unsafe { Ok(ALP::new_unchecked(encoded, exponents, patches)) }
 }
 
 #[expect(
@@ -73,7 +66,7 @@ where
     let (exponents, encoded, exceptional_positions, exceptional_values, mut chunk_offsets) =
         T::encode(values_slice, exponents);
 
-    let encoded_array = PrimitiveArray::new(encoded, values.validity().clone()).into_array();
+    let encoded_array = PrimitiveArray::new(encoded, values.validity()?).into_array();
 
     let validity = values.validity_mask()?;
     // exceptional_positions may contain exceptions at invalid positions (which contain garbage
@@ -131,7 +124,9 @@ mod tests {
 
     use f64::consts::E;
     use f64::consts::PI;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::NativePType;
     use vortex_array::validity::Validity;
@@ -139,6 +134,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use super::*;
+    use crate::alp::array::ALPArrayExt;
+    use crate::alp::array::ALPArraySlotsExt;
     use crate::decompress_into_array;
 
     #[test]
@@ -150,7 +147,8 @@ mod tests {
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 9, f: 6 });
 
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         assert_arrays_eq!(decoded, array);
     }
 
@@ -163,7 +161,8 @@ mod tests {
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 9, f: 6 });
 
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         let expected = PrimitiveArray::from_option_iter(vec![None, Some(1.234f32), None]);
         assert_arrays_eq!(decoded, expected);
     }
@@ -179,7 +178,8 @@ mod tests {
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 16, f: 13 });
 
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         let expected_decoded = PrimitiveArray::new(values, Validity::NonNullable);
         assert_arrays_eq!(decoded, expected_decoded);
     }
@@ -196,7 +196,8 @@ mod tests {
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 16, f: 13 });
 
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         assert_arrays_eq!(decoded, array);
     }
 
@@ -217,7 +218,8 @@ mod tests {
 
         assert_arrays_eq!(encoded, array);
 
-        let _decoded = decompress_into_array(encoded).unwrap();
+        let _decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
     }
 
     #[test]
@@ -232,7 +234,7 @@ mod tests {
         let original =
             PrimitiveArray::new(buffer![195.26274f64, PI, -48.815685], Validity::AllInvalid);
         let alp_arr = alp_encode(&original, None).unwrap();
-        let decompressed = alp_arr.to_primitive();
+        let decompressed = alp_arr.into_array().to_primitive();
 
         assert_eq!(
             // The second and third values become exceptions and are replaced
@@ -250,7 +252,7 @@ mod tests {
             Validity::NonNullable,
         );
         let encoded = alp_encode(&original, None).unwrap();
-        let decoded = encoded.to_primitive();
+        let decoded = encoded.as_array().to_primitive();
         for idx in 0..original.len() {
             let decoded_val = decoded.as_slice::<f32>()[idx];
             let original_val = original.as_slice::<f32>()[idx];
@@ -439,7 +441,8 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
 
         assert!(encoded.patches().is_none());
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         assert_arrays_eq!(decoded, array);
     }
 
@@ -450,7 +453,8 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
 
         assert!(encoded.patches().is_none());
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         assert_arrays_eq!(decoded, array);
     }
 
@@ -467,7 +471,8 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
 
         assert!(encoded.patches().is_some());
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
         assert_arrays_eq!(decoded, array);
     }
 
@@ -488,7 +493,8 @@ mod tests {
         let encoded = alp_encode(&array, None).unwrap();
 
         assert!(encoded.patches().is_some());
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         for idx in 0..size {
             let decoded_val = decoded.as_slice::<f64>()[idx];
@@ -515,7 +521,8 @@ mod tests {
 
         let array = PrimitiveArray::from_option_iter(values);
         let encoded = alp_encode(&array, None).unwrap();
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(decoded, array);
     }
@@ -535,8 +542,49 @@ mod tests {
 
         let array = PrimitiveArray::new(Buffer::from(values), validity);
         let encoded = alp_encode(&array, None).unwrap();
-        let decoded = decompress_into_array(encoded).unwrap();
+        let decoded =
+            decompress_into_array(encoded, &mut LEGACY_SESSION.create_execution_ctx()).unwrap();
 
         assert_arrays_eq!(decoded, array);
     }
+
+    /// Regression test for patch_chunk index-out-of-bounds when slicing a multi-chunk
+    /// ALP array mid-chunk with patches in the trailing chunk.
+    ///
+    /// The bug: chunk_offsets are sliced at chunk granularity (1024-row boundaries)
+    /// but patches indices/values are sliced at element granularity. When a slice ends
+    /// mid-chunk, patches_end_idx could exceed patches_indices.len(), causing OOB panic
+    /// during decompression.
+    #[test]
+    fn test_slice_mid_chunk_with_patches_in_trailing_chunk() {
+        // 3 chunks (3072 elements), patches scattered across all chunks.
+        let mut values = vec![1.0f64; 3072];
+        // Chunk 0 patches (indices 0..1024)
+        values[100] = PI;
+        values[500] = E;
+        // Chunk 1 patches (indices 1024..2048)
+        values[1100] = PI;
+        values[1500] = E;
+        values[1900] = PI;
+        // Chunk 2 patches (indices 2048..3072)
+        values[2100] = PI;
+        values[2500] = E;
+        values[2900] = PI;
+
+        let original = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
+        let encoded = alp_encode(&original, None).unwrap();
+        assert!(encoded.patches().is_some());
+
+        // Slice ending mid-chunk-2 (element 2500 is inside chunk 2 = 2048..3072).
+        // This creates a mismatch: chunk_offsets includes the full chunk 2 offset,
+        // but patches_indices only includes patches up to element 2500.
+        let sliced_alp = encoded.slice(0..2500).unwrap();
+        let expected = original.slice(0..2500).unwrap();
+        assert_arrays_eq!(sliced_alp, expected);
+
+        // Also test slicing that starts mid-chunk (both start and end mid-chunk).
+        let sliced_alp = encoded.slice(500..2500).unwrap();
+        let expected = original.slice(500..2500).unwrap();
+        assert_arrays_eq!(sliced_alp, expected);
+    }
 }
diff --git a/encodings/alp/src/alp/compute/between.rs b/encodings/alp/src/alp/compute/between.rs
index 109c1bbc7f8..c1922a719f9 100644
--- a/encodings/alp/src/alp/compute/between.rs
+++ b/encodings/alp/src/alp/compute/between.rs
@@ -3,8 +3,8 @@
 
 use std::fmt::Debug;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::builtins::ArrayBuiltins;
@@ -17,16 +17,17 @@ use vortex_array::scalar_fn::fns::between::BetweenReduce;
 use vortex_array::scalar_fn::fns::between::StrictComparison;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
+use crate::ALP;
 use crate::ALPFloat;
-use crate::ALPVTable;
+use crate::alp::array::ALPArrayExt;
+use crate::alp::array::ALPArraySlotsExt;
 use crate::match_each_alp_float_ptype;
 
-impl BetweenReduce for ALPVTable {
+impl BetweenReduce for ALP {
     fn between(
-        array: &ALPArray,
-        lower: &dyn Array,
-        upper: &dyn Array,
+        array: ArrayView<'_, Self>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
         options: &BetweenOptions,
     ) -> VortexResult<Option<ArrayRef>> {
         let (Some(lower), Some(upper)) = (lower.as_constant(), upper.as_constant()) else {
@@ -39,7 +40,7 @@ impl BetweenReduce for ALPVTable {
 
         let nullability =
             array.dtype().nullability() | lower.dtype().nullability() | upper.dtype().nullability();
-        match_each_alp_float_ptype!(array.ptype(), |F| {
+        match_each_alp_float_ptype!(array.dtype().as_ptype(), |F| {
             between_impl::<F>(
                 array,
                 F::try_from(&lower)?,
@@ -53,7 +54,7 @@ impl BetweenReduce for ALPVTable {
 }
 
 fn between_impl<T: NativePType + ALPFloat>(
-    array: &ALPArray,
+    array: ArrayView<'_, ALP>,
     lower: T,
     upper: T,
     nullability: Nullability,
@@ -102,6 +103,7 @@ mod tests {
     use vortex_array::scalar_fn::fns::between::StrictComparison;
 
     use crate::ALPArray;
+    use crate::alp::array::ALPArrayExt;
     use crate::alp::compute::between::between_impl;
     use crate::alp_encode;
 
@@ -112,7 +114,8 @@ mod tests {
         options: &BetweenOptions,
         expected: bool,
     ) {
-        let res = between_impl(arr, lower, upper, Nullability::Nullable, options).unwrap();
+        let res =
+            between_impl(arr.as_view(), lower, upper, Nullability::Nullable, options).unwrap();
         assert_arrays_eq!(res, BoolArray::from_iter([Some(expected)]));
     }
 
diff --git a/encodings/alp/src/alp/compute/cast.rs b/encodings/alp/src/alp/compute/cast.rs
index 77ee32d8d03..83ee609f886 100644
--- a/encodings/alp/src/alp/compute/cast.rs
+++ b/encodings/alp/src/alp/compute/cast.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
@@ -9,11 +10,12 @@ use vortex_array::patches::Patches;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::alp::ALPArray;
-use crate::alp::ALPVTable;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
+use crate::alp::ALP;
 
-impl CastReduce for ALPVTable {
-    fn cast(array: &ALPArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for ALP {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Check if this is just a nullability change
         if array.dtype().eq_ignore_nullability(dtype) {
             // For nullability-only changes, we can avoid decoding
@@ -29,7 +31,7 @@ impl CastReduce for ALPVTable {
                 .patches()
                 .map(|p| {
                     if p.values().dtype() == dtype {
-                        Ok(p.clone())
+                        Ok(p)
                     } else {
                         Patches::new(
                             p.array_len(),
@@ -45,13 +47,7 @@ impl CastReduce for ALPVTable {
             // SAFETY: casting nullability doesn't alter the invariants
             unsafe {
                 Ok(Some(
-                    ALPArray::new_unchecked(
-                        new_encoded,
-                        array.exponents(),
-                        new_patches,
-                        dtype.clone(),
-                    )
-                    .into_array(),
+                    ALP::new_unchecked(new_encoded, array.exponents(), new_patches).into_array(),
                 ))
             }
         } else {
@@ -76,6 +72,7 @@ mod tests {
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
 
+    use crate::alp::array::ALPArrayExt;
     use crate::alp_encode;
 
     #[test]
@@ -89,7 +86,7 @@ mod tests {
         );
 
         let nullable_dtype = DType::Primitive(PType::F32, Nullability::Nullable);
-        let casted = alp.to_array().cast(nullable_dtype.clone())?;
+        let casted = alp.into_array().cast(nullable_dtype.clone())?;
 
         let expected = values.cast(nullable_dtype)?;
 
@@ -104,7 +101,7 @@ mod tests {
         let alp = alp_encode(&values.to_primitive(), None)?;
 
         let casted = alp
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::NonNullable))?;
         assert_eq!(
             casted.dtype(),
@@ -126,7 +123,7 @@ mod tests {
         let alp = alp_encode(&values.to_primitive(), None)?;
 
         let casted = alp
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I32, Nullability::NonNullable))?;
         assert_eq!(
             casted.dtype(),
@@ -147,7 +144,7 @@ mod tests {
     #[case(buffer![0.0f32, -1.5, 2.5, -3.5, 4.5].into_array())]
     fn test_cast_alp_conformance(#[case] array: vortex_array::ArrayRef) -> VortexResult<()> {
         let alp = alp_encode(&array.to_primitive(), None).vortex_expect("cannot fail");
-        test_cast_conformance(alp.as_ref());
+        test_cast_conformance(&alp.into_array());
 
         Ok(())
     }
diff --git a/encodings/alp/src/alp/compute/compare.rs b/encodings/alp/src/alp/compute/compare.rs
index 0116bb16d9b..245715c2a6e 100644
--- a/encodings/alp/src/alp/compute/compare.rs
+++ b/encodings/alp/src/alp/compute/compare.rs
@@ -3,8 +3,8 @@
 
 use std::fmt::Debug;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
@@ -18,17 +18,18 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
-use crate::ALPArray;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 use crate::ALPFloat;
-use crate::ALPVTable;
 use crate::match_each_alp_float_ptype;
 
 // TODO(joe): add fuzzing.
 
-impl CompareKernel for ALPVTable {
+impl CompareKernel for ALP {
     fn compare(
-        lhs: &ALPArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -70,7 +71,7 @@ impl CompareKernel for ALPVTable {
 /// the encoded value to the encoded values in the ALPArray. There are fixups when the value doesn't
 /// encode into the ALP domain.
 fn alp_scalar_compare<F: ALPFloat + Into<Scalar>>(
-    alp: &ALPArray,
+    alp: ArrayView<ALP>,
     value: F,
     operator: CompareOperator,
 ) -> VortexResult<Option<ArrayRef>>
@@ -168,7 +169,7 @@ mod tests {
     use crate::alp_encode;
 
     fn test_alp_compare<F: ALPFloat + Into<Scalar>>(
-        alp: &ALPArray,
+        alp: ArrayView<ALP>,
         value: F,
         operator: CompareOperator,
     ) -> Option<ArrayRef>
@@ -189,13 +190,13 @@ mod tests {
             vec![1234; 1025]
         );
 
-        let r = alp_scalar_compare(&encoded, 1.3_f32, CompareOperator::Eq)
+        let r = alp_scalar_compare(encoded.as_view(), 1.3_f32, CompareOperator::Eq)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([false; 1025]);
         assert_arrays_eq!(r, expected);
 
-        let r = alp_scalar_compare(&encoded, 1.234f32, CompareOperator::Eq)
+        let r = alp_scalar_compare(encoded.as_view(), 1.234f32, CompareOperator::Eq)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([true; 1025]);
@@ -213,14 +214,14 @@ mod tests {
         );
 
         #[allow(clippy::excessive_precision)]
-        let r_eq = alp_scalar_compare(&encoded, 1.234444_f32, CompareOperator::Eq)
+        let r_eq = alp_scalar_compare(encoded.as_view(), 1.234444_f32, CompareOperator::Eq)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([false; 1025]);
         assert_arrays_eq!(r_eq, expected);
 
         #[allow(clippy::excessive_precision)]
-        let r_neq = alp_scalar_compare(&encoded, 1.234444f32, CompareOperator::NotEq)
+        let r_neq = alp_scalar_compare(encoded.as_view(), 1.234444f32, CompareOperator::NotEq)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([true; 1025]);
@@ -238,28 +239,28 @@ mod tests {
         );
 
         // !(0.0605_f32 >= 0.06051_f32);
-        let r_gte = alp_scalar_compare(&encoded, 0.06051_f32, CompareOperator::Gte)
+        let r_gte = alp_scalar_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Gte)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([false; 10]);
         assert_arrays_eq!(r_gte, expected);
 
         // (0.0605_f32 > 0.06051_f32);
-        let r_gt = alp_scalar_compare(&encoded, 0.06051_f32, CompareOperator::Gt)
+        let r_gt = alp_scalar_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Gt)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([false; 10]);
         assert_arrays_eq!(r_gt, expected);
 
         // 0.0605_f32 <= 0.06051_f32;
-        let r_lte = alp_scalar_compare(&encoded, 0.06051_f32, CompareOperator::Lte)
+        let r_lte = alp_scalar_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Lte)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_lte, expected);
 
         //0.0605_f32 < 0.06051_f32;
-        let r_lt = alp_scalar_compare(&encoded, 0.06051_f32, CompareOperator::Lt)
+        let r_lt = alp_scalar_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Lt)
             .unwrap()
             .unwrap();
         let expected = BoolArray::from_iter([true; 10]);
@@ -276,31 +277,33 @@ mod tests {
             vec![0; 10]
         );
 
-        let r_gte = test_alp_compare(&encoded, -0.00000001_f32, CompareOperator::Gte).unwrap();
+        let r_gte =
+            test_alp_compare(encoded.as_view(), -0.00000001_f32, CompareOperator::Gte).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_gte, expected);
 
-        let r_gte = test_alp_compare(&encoded, -0.0_f32, CompareOperator::Gte).unwrap();
+        let r_gte = test_alp_compare(encoded.as_view(), -0.0_f32, CompareOperator::Gte).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_gte, expected);
 
-        let r_gt = test_alp_compare(&encoded, -0.0000000001f32, CompareOperator::Gt).unwrap();
+        let r_gt =
+            test_alp_compare(encoded.as_view(), -0.0000000001f32, CompareOperator::Gt).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_gt, expected);
 
-        let r_gte = test_alp_compare(&encoded, -0.0_f32, CompareOperator::Gt).unwrap();
+        let r_gte = test_alp_compare(encoded.as_view(), -0.0_f32, CompareOperator::Gt).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_gte, expected);
 
-        let r_lte = test_alp_compare(&encoded, 0.06051_f32, CompareOperator::Lte).unwrap();
+        let r_lte = test_alp_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Lte).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_lte, expected);
 
-        let r_lt = test_alp_compare(&encoded, 0.06051_f32, CompareOperator::Lt).unwrap();
+        let r_lt = test_alp_compare(encoded.as_view(), 0.06051_f32, CompareOperator::Lt).unwrap();
         let expected = BoolArray::from_iter([true; 10]);
         assert_arrays_eq!(r_lt, expected);
 
-        let r_lt = test_alp_compare(&encoded, -0.00001_f32, CompareOperator::Lt).unwrap();
+        let r_lt = test_alp_compare(encoded.as_view(), -0.00001_f32, CompareOperator::Lt).unwrap();
         let expected = BoolArray::from_iter([false; 10]);
         assert_arrays_eq!(r_lt, expected);
     }
@@ -314,7 +317,7 @@ mod tests {
 
         // Not supported!
         assert!(
-            alp_scalar_compare(&encoded, 1_000_000.9_f32, CompareOperator::Eq)
+            alp_scalar_compare(encoded.as_view(), 1_000_000.9_f32, CompareOperator::Eq)
                 .unwrap()
                 .is_none()
         )
@@ -348,7 +351,7 @@ mod tests {
         let array = PrimitiveArray::from_iter([1.234f32; 10]);
         let encoded = alp_encode(&array, None).unwrap();
 
-        let r = test_alp_compare(&encoded, value, CompareOperator::Gt).unwrap();
+        let r = test_alp_compare(encoded.as_view(), value, CompareOperator::Gt).unwrap();
         let expected = BoolArray::from_iter([result; 10]);
         assert_arrays_eq!(r, expected);
     }
@@ -362,7 +365,7 @@ mod tests {
         let array = PrimitiveArray::from_iter([1.234f32; 10]);
         let encoded = alp_encode(&array, None).unwrap();
 
-        let r = test_alp_compare(&encoded, value, CompareOperator::Lt).unwrap();
+        let r = test_alp_compare(encoded.as_view(), value, CompareOperator::Lt).unwrap();
         let expected = BoolArray::from_iter([result; 10]);
         assert_arrays_eq!(r, expected);
     }
diff --git a/encodings/alp/src/alp/compute/filter.rs b/encodings/alp/src/alp/compute/filter.rs
index e759c8e6be8..10acc57ab8f 100644
--- a/encodings/alp/src/alp/compute/filter.rs
+++ b/encodings/alp/src/alp/compute/filter.rs
@@ -2,36 +2,38 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
-use vortex_array::arrays::FilterKernel;
+use vortex_array::IntoArray;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::ALPArray;
-use crate::ALPVTable;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 
-impl FilterKernel for ALPVTable {
+impl FilterKernel for ALP {
     fn filter(
-        array: &ALPArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let patches = array
             .patches()
-            .map(|p| p.filter(mask))
+            .map(|p| p.filter(mask, ctx))
             .transpose()?
             .flatten();
 
         // SAFETY: filtering the values does not change correctness
         unsafe {
             Ok(Some(
-                ALPArray::new_unchecked(
+                ALP::new_unchecked(
                     array.encoded().filter(mask.clone())?,
                     array.exponents(),
                     patches,
-                    array.dtype().clone(),
                 )
-                .to_array(),
+                .into_array(),
             ))
         }
     }
@@ -60,6 +62,6 @@ mod test {
     ].into_array())]
     fn test_filter_alp_conformance(#[case] array: ArrayRef) {
         let alp = alp_encode(&array.to_primitive(), None).unwrap();
-        test_filter_conformance(alp.as_ref());
+        test_filter_conformance(&alp.into_array());
     }
 }
diff --git a/encodings/alp/src/alp/compute/mask.rs b/encodings/alp/src/alp/compute/mask.rs
index d39a9b2c2fe..82eab0ebfa5 100644
--- a/encodings/alp/src/alp/compute/mask.rs
+++ b/encodings/alp/src/alp/compute/mask.rs
@@ -2,44 +2,52 @@
 // 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::builtins::ArrayBuiltins;
 use vortex_array::scalar_fn::fns::mask::MaskKernel;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_array::validity::Validity;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
-use crate::ALPVTable;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 
-impl MaskReduce for ALPVTable {
-    fn mask(array: &ALPArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for ALP {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // Masking sparse patches requires reading indices, fall back to kernel.
         if array.patches().is_some() {
             return Ok(None);
         }
         let masked_encoded = array.encoded().clone().mask(mask.clone())?;
         Ok(Some(
-            ALPArray::new(masked_encoded, array.exponents(), None).to_array(),
+            ALP::new(masked_encoded, array.exponents(), None).into_array(),
         ))
     }
 }
 
-impl MaskKernel for ALPVTable {
+impl MaskKernel for ALP {
     fn mask(
-        array: &ALPArray,
+        array: ArrayView<'_, Self>,
         mask: &ArrayRef,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let vortex_mask = Validity::Array(mask.not()?).to_mask(array.len());
+        let vortex_mask = Validity::Array(mask.not()?).execute_mask(array.len(), ctx)?;
         let masked_encoded = array.encoded().clone().mask(mask.clone())?;
+        let masked_dtype = array
+            .dtype()
+            .with_nullability(masked_encoded.dtype().nullability());
         let masked_patches = array
             .patches()
-            .map(|p| p.mask(&vortex_mask))
+            .map(|p| p.mask(&vortex_mask, ctx))
             .transpose()?
-            .flatten();
+            .flatten()
+            .map(|patches| patches.cast_values(&masked_dtype))
+            .transpose()?;
         Ok(Some(
-            ALPArray::new(masked_encoded, array.exponents(), masked_patches).to_array(),
+            ALP::new(masked_encoded, array.exponents(), masked_patches).into_array(),
         ))
     }
 }
@@ -48,11 +56,17 @@ impl MaskKernel for ALPVTable {
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::scalar_fn::fns::mask::MaskKernel;
     use vortex_buffer::buffer;
 
+    use crate::alp::array::ALPArrayExt;
     use crate::alp_encode;
 
     #[rstest]
@@ -66,7 +80,7 @@ mod test {
     ].into_array())]
     fn test_mask_alp_conformance(#[case] array: vortex_array::ArrayRef) {
         let alp = alp_encode(&array.to_primitive(), None).unwrap();
-        test_mask_conformance(alp.as_ref());
+        test_mask_conformance(&alp.into_array());
     }
 
     #[test]
@@ -79,6 +93,25 @@ mod test {
         let array = PrimitiveArray::from_iter(values);
         let alp = alp_encode(&array, None).unwrap();
         assert!(alp.patches().is_some(), "expected patches");
-        test_mask_conformance(alp.as_ref());
+        test_mask_conformance(&alp.into_array());
+    }
+
+    #[test]
+    fn test_mask_alp_with_patches_casts_surviving_patch_values_to_nullable() {
+        let values = PrimitiveArray::from_iter([1.234f32, f32::NAN, 2.345, f32::INFINITY, 3.456]);
+        let alp = alp_encode(&values, None).unwrap();
+        assert!(alp.patches().is_some(), "expected patches");
+
+        let keep_mask = BoolArray::from_iter([false, true, true, true, true]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let masked = <crate::ALP as MaskKernel>::mask(alp.as_view(), &keep_mask, &mut ctx)
+            .unwrap()
+            .unwrap();
+
+        let masked_alp = masked.as_opt::<crate::ALP>().unwrap();
+        let masked_patches = masked_alp.patches().unwrap();
+
+        assert_eq!(masked.dtype().nullability(), Nullability::Nullable);
+        assert_eq!(masked_patches.dtype().nullability(), Nullability::Nullable);
     }
 }
diff --git a/encodings/alp/src/alp/compute/mod.rs b/encodings/alp/src/alp/compute/mod.rs
index af435684496..6bbc1483b2b 100644
--- a/encodings/alp/src/alp/compute/mod.rs
+++ b/encodings/alp/src/alp/compute/mod.rs
@@ -6,7 +6,7 @@ mod cast;
 mod compare;
 mod filter;
 mod mask;
-mod nan_count;
+pub(crate) mod nan_count;
 mod slice;
 mod take;
 
@@ -36,7 +36,7 @@ mod tests {
     #[case::repeating_pattern(alp_encode(&PrimitiveArray::from_iter([1.1f32, 2.2, 3.3, 1.1, 2.2, 3.3, 1.1, 2.2, 3.3]), None).unwrap())]
     #[case::close_values(alp_encode(&PrimitiveArray::from_iter([100.001f64, 100.002, 100.003, 100.004, 100.005]), None).unwrap())]
     fn test_alp_consistency(#[case] array: ALPArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
diff --git a/encodings/alp/src/alp/compute/nan_count.rs b/encodings/alp/src/alp/compute/nan_count.rs
index 74d8e27ebb9..b76dd6e7a97 100644
--- a/encodings/alp/src/alp/compute/nan_count.rs
+++ b/encodings/alp/src/alp/compute/nan_count.rs
@@ -1,24 +1,46 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::NaNCountKernel;
-use vortex_array::compute::NaNCountKernelAdapter;
-use vortex_array::compute::nan_count;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::nan_count::NanCount;
+use vortex_array::aggregate_fn::fns::nan_count::nan_count;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
-use crate::ALPVTable;
+use crate::ALP;
+use crate::ALPArrayExt;
 
-impl NaNCountKernel for ALPVTable {
-    fn nan_count(&self, array: &ALPArray) -> VortexResult<usize> {
-        // NANs can only be in patches
-        if let Some(patches) = array.patches() {
-            nan_count(patches.values())
-        } else {
-            Ok(0)
+/// ALP-specific NaN count kernel.
+///
+/// NaN values can only appear in the patches array of an ALP-encoded array, since the encoded
+/// integer values cannot represent NaN. This avoids decoding the entire array.
+#[derive(Debug)]
+pub(crate) struct ALPNanCountKernel;
+
+impl DynAggregateKernel for ALPNanCountKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<NanCount>() {
+            return Ok(None);
         }
+
+        let Some(alp) = batch.as_opt::<ALP>() else {
+            return Ok(None);
+        };
+
+        let count = if let Some(patches) = alp.patches() {
+            nan_count(patches.values(), ctx)?
+        } else {
+            0
+        };
+
+        Ok(Some(Scalar::from(count as u64)))
     }
 }
-
-register_kernel!(NaNCountKernelAdapter(ALPVTable).lift());
diff --git a/encodings/alp/src/alp/compute/slice.rs b/encodings/alp/src/alp/compute/slice.rs
index 04884008722..cb8c122fdc6 100644
--- a/encodings/alp/src/alp/compute/slice.rs
+++ b/encodings/alp/src/alp/compute/slice.rs
@@ -4,21 +4,23 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceKernel;
+use vortex_array::arrays::slice::SliceKernel;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
-use crate::ALPVTable;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 
-impl SliceKernel for ALPVTable {
+impl SliceKernel for ALP {
     fn slice(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let sliced_alp = ALPArray::new(
+        let sliced_alp = ALP::new(
             array.encoded().slice(range.clone())?,
             array.exponents(),
             array
diff --git a/encodings/alp/src/alp/compute/take.rs b/encodings/alp/src/alp/compute/take.rs
index 9d97c598e28..cf0b5301684 100644
--- a/encodings/alp/src/alp/compute/take.rs
+++ b/encodings/alp/src/alp/compute/take.rs
@@ -1,26 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
-use crate::ALPVTable;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 
-impl TakeExecute for ALPVTable {
+impl TakeExecute for ALP {
     fn take(
-        array: &ALPArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let taken_encoded = array.encoded().take(indices.to_array())?;
+        let taken_encoded = array.encoded().take(indices.clone())?;
         let taken_patches = array
             .patches()
-            .map(|p| p.take(indices))
+            .map(|p| p.take(indices, ctx))
             .transpose()?
             .flatten()
             .map(|patches| {
@@ -32,7 +33,7 @@ impl TakeExecute for ALPVTable {
             })
             .transpose()?;
         Ok(Some(
-            ALPArray::new(taken_encoded, array.exponents(), taken_patches).into_array(),
+            ALP::new(taken_encoded, array.exponents(), taken_patches).into_array(),
         ))
     }
 }
@@ -55,6 +56,6 @@ mod test {
     #[case(buffer![42.42f64].into_array())]
     fn test_take_alp_conformance(#[case] array: vortex_array::ArrayRef) {
         let alp = alp_encode(&array.to_primitive(), None).unwrap();
-        test_take_conformance(alp.as_ref());
+        test_take_conformance(&alp.into_array());
     }
 }
diff --git a/encodings/alp/src/alp/decompress.rs b/encodings/alp/src/alp/decompress.rs
index 49f657699d7..6bc5b469d42 100644
--- a/encodings/alp/src/alp/decompress.rs
+++ b/encodings/alp/src/alp/decompress.rs
@@ -4,18 +4,18 @@
 use std::mem::transmute;
 
 use vortex_array::ExecutionCtx;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::chunk_range;
-use vortex_array::arrays::patch_chunk;
+use vortex_array::arrays::primitive::chunk_range;
+use vortex_array::arrays::primitive::patch_chunk;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::patches::Patches;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::ALPArray;
+use crate::ALPArrayOwnedExt;
 use crate::ALPFloat;
 use crate::Exponents;
 use crate::match_each_alp_float_ptype;
@@ -25,19 +25,19 @@ use crate::match_each_alp_float_ptype;
 /// # Returns
 ///
 /// A `PrimitiveArray` containing the decompressed floating-point values with all patches applied.
-pub fn decompress_into_array(array: ALPArray) -> VortexResult<PrimitiveArray> {
-    let (encoded, exponents, patches, dtype) = array.into_parts();
+pub fn decompress_into_array(
+    array: ALPArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<PrimitiveArray> {
+    let dtype = array.dtype().clone();
+    let (encoded, exponents, patches) = ALPArrayOwnedExt::into_parts(array);
     if let Some(ref patches) = patches
         && let Some(chunk_offsets) = patches.chunk_offsets()
     {
-        let prim_encoded = encoded.to_primitive();
-        // We need to drop ALPArray here in case converting encoded buffer into
-        // primitive didn't create a copy. In that case both alp_encoded and array
-        // will hold a reference to the buffer we want to mutate.
-        drop(encoded);
-        let patches_chunk_offsets = chunk_offsets.as_ref().to_primitive();
-        let patches_indices = patches.indices().to_primitive();
-        let patches_values = patches.values().to_primitive();
+        let prim_encoded = encoded.execute::<PrimitiveArray>(ctx)?;
+        let patches_chunk_offsets = chunk_offsets.clone().execute::<PrimitiveArray>(ctx)?;
+        let patches_indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
+        let patches_values = patches.values().clone().execute::<PrimitiveArray>(ctx)?;
         Ok(decompress_chunked_core(
             prim_encoded,
             exponents,
@@ -48,12 +48,8 @@ pub fn decompress_into_array(array: ALPArray) -> VortexResult<PrimitiveArray> {
             dtype,
         ))
     } else {
-        let encoded_prim = encoded.to_primitive();
-        // We need to drop ALPArray here in case converting encoded buffer into
-        // primitive didn't create a copy. In that case both alp_encoded and array
-        // will hold a reference to the buffer we want to mutate.
-        drop(encoded);
-        decompress_unchunked_core(encoded_prim, exponents, patches, dtype)
+        let encoded_prim = encoded.execute::<PrimitiveArray>(ctx)?;
+        decompress_unchunked_core(encoded_prim, exponents, patches, dtype, ctx)
     }
 }
 
@@ -66,7 +62,8 @@ pub fn decompress_into_array(array: ALPArray) -> VortexResult<PrimitiveArray> {
 ///
 /// A `PrimitiveArray` containing the decompressed floating-point values with all patches applied.
 pub fn execute_decompress(array: ALPArray, ctx: &mut ExecutionCtx) -> VortexResult<PrimitiveArray> {
-    let (encoded, exponents, patches, dtype) = array.into_parts();
+    let dtype = array.dtype().clone();
+    let (encoded, exponents, patches) = ALPArrayOwnedExt::into_parts(array);
     if let Some(ref patches) = patches
         && let Some(chunk_offsets) = patches.chunk_offsets()
     {
@@ -86,7 +83,7 @@ pub fn execute_decompress(array: ALPArray, ctx: &mut ExecutionCtx) -> VortexResu
         ))
     } else {
         let encoded = encoded.execute::<PrimitiveArray>(ctx)?;
-        decompress_unchunked_core(encoded, exponents, patches, dtype)
+        decompress_unchunked_core(encoded, exponents, patches, dtype, ctx)
     }
 }
 
@@ -107,7 +104,9 @@ fn decompress_chunked_core(
     patches: &Patches,
     dtype: DType,
 ) -> PrimitiveArray {
-    let validity = encoded.validity().clone();
+    let validity = encoded
+        .validity()
+        .vortex_expect("ALP validity should be derivable");
     let ptype = dtype.as_ptype();
     let array_len = encoded.len();
     let offset_within_chunk = patches.offset_within_chunk().unwrap_or(0);
@@ -155,8 +154,9 @@ fn decompress_unchunked_core(
     exponents: Exponents,
     patches: Option<Patches>,
     dtype: DType,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<PrimitiveArray> {
-    let validity = encoded.validity().clone();
+    let validity = encoded.validity()?;
     let ptype = dtype.as_ptype();
 
     let decoded = match_each_alp_float_ptype!(ptype, |T| {
@@ -167,7 +167,7 @@ fn decompress_unchunked_core(
     });
 
     if let Some(patches) = patches {
-        decoded.patch(&patches)
+        decoded.patch(&patches, ctx)
     } else {
         Ok(decoded)
     }
diff --git a/encodings/alp/src/alp/mod.rs b/encodings/alp/src/alp/mod.rs
index ef39aefe005..7d5049b59e3 100644
--- a/encodings/alp/src/alp/mod.rs
+++ b/encodings/alp/src/alp/mod.rs
@@ -15,14 +15,14 @@ use num_traits::ToPrimitive;
 
 mod array;
 mod compress;
-mod compute;
+pub(crate) mod compute;
 mod decompress;
 mod ops;
 mod rules;
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::ProstMetadata;
+    use prost::Message;
     use vortex_array::dtype::PType;
     use vortex_array::patches::PatchesMetadata;
     use vortex_array::test_harness::check_metadata;
@@ -34,7 +34,7 @@ mod tests {
     fn test_alp_metadata() {
         check_metadata(
             "alp.metadata",
-            ProstMetadata(ALPMetadata {
+            &ALPMetadata {
                 patches: Some(PatchesMetadata::new(
                     usize::MAX,
                     usize::MAX,
@@ -45,7 +45,8 @@ mod tests {
                 )),
                 exp_e: u32::MAX,
                 exp_f: u32::MAX,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/alp/src/alp/ops.rs b/encodings/alp/src/alp/ops.rs
index a0e6388a4dc..dcd8cecf1d5 100644
--- a/encodings/alp/src/alp/ops.rs
+++ b/encodings/alp/src/alp/ops.rs
@@ -1,18 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::ALPArray;
+use crate::ALP;
+use crate::ALPArrayExt;
+use crate::ALPArraySlotsExt;
 use crate::ALPFloat;
-use crate::ALPVTable;
 use crate::match_each_alp_float_ptype;
 
-impl OperationsVTable<ALPVTable> for ALPVTable {
-    fn scalar_at(array: &ALPArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ALP> for ALP {
+    fn scalar_at(
+        array: ArrayView<'_, ALP>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         if let Some(patches) = array.patches()
             && let Some(patch) = patches.get_patched(index)?
         {
@@ -21,7 +28,7 @@ impl OperationsVTable<ALPVTable> for ALPVTable {
 
         let encoded_val = array.encoded().scalar_at(index)?;
 
-        Ok(match_each_alp_float_ptype!(array.ptype(), |T| {
+        Ok(match_each_alp_float_ptype!(array.dtype().as_ptype(), |T| {
             let encoded_val: <T as ALPFloat>::ALPInt =
                 (&encoded_val).try_into().vortex_expect("invalid ALPInt");
             Scalar::primitive(
diff --git a/encodings/alp/src/alp/rules.rs b/encodings/alp/src/alp/rules.rs
index 166b996de91..fe13682ccd8 100644
--- a/encodings/alp/src/alp/rules.rs
+++ b/encodings/alp/src/alp/rules.rs
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::SliceExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
+use vortex_array::arrays::slice::SliceExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor;
@@ -12,18 +12,18 @@ use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::ALPVTable;
+use crate::ALP;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<ALPVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&MaskExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<ALP> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&MaskExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&SliceExecuteAdaptor(ALP)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(ALP)),
 ]);
 
-pub(super) const RULES: ParentRuleSet<ALPVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&BetweenReduceAdaptor(ALPVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(ALPVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALPVTable)),
+pub(super) const RULES: ParentRuleSet<ALP> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&BetweenReduceAdaptor(ALP)),
+    ParentRuleSet::lift(&CastReduceAdaptor(ALP)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ALP)),
 ]);
diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs
index b3d09c0d75a..431b69c125d 100644
--- a/encodings/alp/src/alp_rd/array.rs
+++ b/encodings/alp/src/alp_rd/array.rs
@@ -2,21 +2,26 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
 use itertools::Itertools;
+use prost::Message;
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::TypedArrayRef;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
@@ -24,30 +29,28 @@ use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::patches::Patches;
 use vortex_array::patches::PatchesMetadata;
+use vortex_array::require_child;
+use vortex_array::require_patches;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
 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_mask::Mask;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
 use crate::alp_rd::kernel::PARENT_KERNELS;
 use crate::alp_rd::rules::RULES;
 use crate::alp_rd_decode;
 
-vtable!(ALPRD);
+/// A [`ALPRD`]-encoded Vortex array.
+pub type ALPRDArray = Array<ALPRD>;
 
 #[derive(Clone, prost::Message)]
 pub struct ALPRDMetadata {
@@ -63,62 +66,104 @@ pub struct ALPRDMetadata {
     patches: Option<PatchesMetadata>,
 }
 
-impl VTable for ALPRDVTable {
-    type Array = ALPRDArray;
+impl ArrayHash for ALPRDData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.left_parts_dictionary.array_hash(state, precision);
+        self.right_bit_width.hash(state);
+        self.patch_offset.hash(state);
+        self.patch_offset_within_chunk.hash(state);
+    }
+}
+
+impl ArrayEq for ALPRDData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.left_parts_dictionary
+            .array_eq(&other.left_parts_dictionary, precision)
+            && self.right_bit_width == other.right_bit_width
+            && self.patch_offset == other.patch_offset
+            && self.patch_offset_within_chunk == other.patch_offset_within_chunk
+    }
+}
 
-    type Metadata = ProstMetadata<ALPRDMetadata>;
+impl VTable for ALPRD {
+    type ArrayData = ALPRDData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &ALPRDArray) -> VortexResult<Self::Metadata> {
-        let dict = array
-            .left_parts_dictionary()
-            .iter()
-            .map(|&i| i as u32)
-            .collect::<Vec<_>>();
+    fn validate(
+        &self,
+        data: &ALPRDData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        validate_parts(
+            dtype,
+            len,
+            left_parts_from_slots(slots),
+            right_parts_from_slots(slots),
+            patches_from_slots(
+                slots,
+                data.patch_offset,
+                data.patch_offset_within_chunk,
+                len,
+            )
+            .as_ref(),
+        )
+    }
 
-        Ok(ProstMetadata(ALPRDMetadata {
-            right_bit_width: array.right_bit_width() as u32,
-            dict_len: array.left_parts_dictionary().len() as u32,
-            dict,
-            left_parts_ptype: array.left_parts.dtype().as_ptype() as i32,
-            patches: array
-                .left_parts_patches()
-                .map(|p| p.to_metadata(array.len(), array.left_parts().dtype()))
-                .transpose()?,
-        }))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ALPRDArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<ALPRDMetadata> as DeserializeMetadata>::deserialize(bytes)?,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let dict = array
+            .left_parts_dictionary()
+            .iter()
+            .map(|&i| i as u32)
+            .collect::<Vec<_>>();
+
+        Ok(Some(
+            ALPRDMetadata {
+                right_bit_width: array.right_bit_width() as u32,
+                dict_len: array.left_parts_dictionary().len() as u32,
+                dict,
+                left_parts_ptype: array.left_parts().dtype().as_ptype() as i32,
+                patches: array
+                    .left_parts_patches()
+                    .map(|p| p.to_metadata(array.len(), p.dtype()))
+                    .transpose()?,
+            }
+            .encode_to_vec(),
         ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ALPRDArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = ALPRDMetadata::decode(metadata)?;
         if children.len() < 2 {
             vortex_bail!(
                 "Expected at least 2 children for ALPRD encoding, found {}",
@@ -126,10 +171,10 @@ impl VTable for ALPRDVTable {
             );
         }
 
-        let left_parts_dtype = DType::Primitive(metadata.0.left_parts_ptype(), dtype.nullability());
+        let left_parts_dtype = DType::Primitive(metadata.left_parts_ptype(), dtype.nullability());
         let left_parts = children.get(0, &left_parts_dtype, len)?;
-        let left_parts_dictionary: Buffer<u16> = metadata.0.dict.as_slice()
-            [0..metadata.0.dict_len as usize]
+        let left_parts_dictionary: Buffer<u16> = metadata.dict.as_slice()
+            [0..metadata.dict_len as usize]
             .iter()
             .map(|&i| {
                 u16::try_from(i)
@@ -149,11 +194,10 @@ impl VTable for ALPRDVTable {
         let right_parts = children.get(1, &right_parts_dtype, len)?;
 
         let left_parts_patches = metadata
-            .0
             .patches
             .map(|p| {
                 let indices = children.get(2, &p.indices_dtype()?, p.len()?)?;
-                let values = children.get(3, &left_parts_dtype, p.len()?)?;
+                let values = children.get(3, &left_parts_dtype.as_nonnullable(), p.len()?)?;
 
                 Patches::new(
                     len,
@@ -165,107 +209,89 @@ impl VTable for ALPRDVTable {
                 )
             })
             .transpose()?;
-
-        ALPRDArray::try_new(
-            dtype.clone(),
-            left_parts,
+        let left_parts_patches = ALPRDData::canonicalize_patches(&left_parts, left_parts_patches)?;
+        let slots = ALPRDData::make_slots(&left_parts, &right_parts, &left_parts_patches);
+        let data = ALPRDData::new(
             left_parts_dictionary,
-            right_parts,
-            u8::try_from(metadata.0.right_bit_width).map_err(|_| {
+            u8::try_from(metadata.right_bit_width).map_err(|_| {
                 vortex_err!(
                     "right_bit_width {} out of u8 range",
-                    metadata.0.right_bit_width
+                    metadata.right_bit_width
                 )
             })?,
             left_parts_patches,
-        )
+        );
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // Children: left_parts, right_parts, patches (if present): indices, values
-        let patches_info = array
-            .left_parts_patches
-            .as_ref()
-            .map(|p| (p.array_len(), p.offset()));
-
-        let expected_children = if patches_info.is_some() { 4 } else { 2 };
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
 
-        vortex_ensure!(
-            children.len() == expected_children,
-            "ALPRDArray expects {} children, got {}",
-            expected_children,
-            children.len()
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = require_child!(array, array.left_parts(), 0 => Primitive);
+        let array = require_child!(array, array.right_parts(), 1 => Primitive);
+        require_patches!(
+            array,
+            LP_PATCH_INDICES_SLOT,
+            LP_PATCH_VALUES_SLOT,
+            LP_PATCH_CHUNK_OFFSETS_SLOT
         );
 
-        let mut children_iter = children.into_iter();
-        array.left_parts = children_iter
-            .next()
-            .ok_or_else(|| vortex_err!("Expected left_parts child"))?;
-        array.right_parts = children_iter
-            .next()
-            .ok_or_else(|| vortex_err!("Expected right_parts child"))?;
-
-        if let Some((array_len, offset)) = patches_info {
-            let indices = children_iter
-                .next()
-                .ok_or_else(|| vortex_err!("Expected patch indices child"))?;
-            let values = children_iter
-                .next()
-                .ok_or_else(|| vortex_err!("Expected patch values child"))?;
-
-            array.left_parts_patches = Some(Patches::new(
-                array_len, offset, indices, values,
-                None, // chunk_offsets not currently supported for ALPRD
-            )?);
-        }
-
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        let left_parts = array.left_parts().clone().execute::<PrimitiveArray>(ctx)?;
-        let right_parts = array.right_parts().clone().execute::<PrimitiveArray>(ctx)?;
+        let dtype = array.dtype().clone();
+        let right_bit_width = array.right_bit_width();
+        let ALPRDDataParts {
+            left_parts,
+            right_parts,
+            left_parts_dictionary,
+            left_parts_patches,
+        } = ALPRDArrayOwnedExt::into_data_parts(array);
+        let ptype = dtype.as_ptype();
+
+        let left_parts = left_parts
+            .try_downcast::<Primitive>()
+            .ok()
+            .vortex_expect("ALPRD execute: left_parts is primitive");
+        let right_parts = right_parts
+            .try_downcast::<Primitive>()
+            .ok()
+            .vortex_expect("ALPRD execute: right_parts is primitive");
 
         // Decode the left_parts using our builtin dictionary.
-        let left_parts_dict = array.left_parts_dictionary();
+        let left_parts_dict = left_parts_dictionary;
+        let validity = left_parts.validity_mask()?;
 
-        let validity = array
-            .left_parts()
-            .validity()?
-            .to_array(array.len())
-            .execute::<Mask>(ctx)?;
-
-        let decoded_array = if array.is_f32() {
+        let decoded_array = if ptype == PType::F32 {
             PrimitiveArray::new(
                 alp_rd_decode::<f32>(
-                    left_parts.into_buffer::<u16>(),
-                    left_parts_dict,
-                    array.right_bit_width,
+                    left_parts.into_buffer_mut::<u16>(),
+                    &left_parts_dict,
+                    right_bit_width,
                     right_parts.into_buffer_mut::<u32>(),
-                    array.left_parts_patches(),
+                    left_parts_patches,
                     ctx,
                 )?,
-                Validity::from_mask(validity, array.dtype().nullability()),
+                Validity::from_mask(validity, dtype.nullability()),
             )
         } else {
             PrimitiveArray::new(
                 alp_rd_decode::<f64>(
-                    left_parts.into_buffer::<u16>(),
-                    left_parts_dict,
-                    array.right_bit_width,
+                    left_parts.into_buffer_mut::<u16>(),
+                    &left_parts_dict,
+                    right_bit_width,
                     right_parts.into_buffer_mut::<u64>(),
-                    array.left_parts_patches(),
+                    left_parts_patches,
                     ctx,
                 )?,
-                Validity::from_mask(validity, array.dtype().nullability()),
+                Validity::from_mask(validity, dtype.nullability()),
             )
         };
 
-        Ok(decoded_array.into_array())
+        Ok(ExecutionResult::done(decoded_array.into_array()))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -273,7 +299,7 @@ impl VTable for ALPRDVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -282,26 +308,57 @@ impl VTable for ALPRDVTable {
     }
 }
 
+/// The left (most significant) parts of the real-double encoded values.
+pub(super) const LEFT_PARTS_SLOT: usize = 0;
+/// The right (least significant) parts of the real-double encoded values.
+pub(super) const RIGHT_PARTS_SLOT: usize = 1;
+/// The indices of left-parts exception values that could not be dictionary-encoded.
+pub(super) const LP_PATCH_INDICES_SLOT: usize = 2;
+/// The exception values for left-parts that could not be dictionary-encoded.
+pub(super) const LP_PATCH_VALUES_SLOT: usize = 3;
+/// Chunk offsets for the left-parts patch indices/values.
+pub(super) const LP_PATCH_CHUNK_OFFSETS_SLOT: usize = 4;
+pub(super) const NUM_SLOTS: usize = 5;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = [
+    "left_parts",
+    "right_parts",
+    "patch_indices",
+    "patch_values",
+    "patch_chunk_offsets",
+];
+
 #[derive(Clone, Debug)]
-pub struct ALPRDArray {
-    dtype: DType,
-    left_parts: ArrayRef,
-    left_parts_patches: Option<Patches>,
+pub struct ALPRDData {
+    patch_offset: Option<usize>,
+    patch_offset_within_chunk: Option<usize>,
     left_parts_dictionary: Buffer<u16>,
-    right_parts: ArrayRef,
     right_bit_width: u8,
-    stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
-pub struct ALPRDVTable;
+impl Display for ALPRDData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "right_bit_width: {}", self.right_bit_width)?;
+        if let Some(offset) = self.patch_offset {
+            write!(f, ", patch_offset: {offset}")?;
+        }
+        Ok(())
+    }
+}
 
-impl ALPRDVTable {
-    pub const ID: ArrayId = ArrayId::new_ref("vortex.alprd");
+#[derive(Clone, Debug)]
+pub struct ALPRDDataParts {
+    pub left_parts: ArrayRef,
+    pub left_parts_patches: Option<Patches>,
+    pub left_parts_dictionary: Buffer<u16>,
+    pub right_parts: ArrayRef,
 }
 
-impl ALPRDArray {
-    /// Build a new `ALPRDArray` from components.
+#[derive(Clone, Debug)]
+pub struct ALPRD;
+
+impl ALPRD {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.alprd");
+
     pub fn try_new(
         dtype: DType,
         left_parts: ArrayRef,
@@ -309,103 +366,115 @@ impl ALPRDArray {
         right_parts: ArrayRef,
         right_bit_width: u8,
         left_parts_patches: Option<Patches>,
-    ) -> VortexResult<Self> {
-        if !dtype.is_float() {
-            vortex_bail!("ALPRDArray given invalid DType ({dtype})");
-        }
-
+    ) -> VortexResult<ALPRDArray> {
         let len = left_parts.len();
-        if right_parts.len() != len {
-            vortex_bail!(
-                "left_parts (len {}) and right_parts (len {}) must be of same length",
-                len,
-                right_parts.len()
-            );
-        }
-
-        if !left_parts.dtype().is_unsigned_int() {
-            vortex_bail!("left_parts dtype must be uint");
-        }
-        // we delegate array validity to the left_parts child
-        if dtype.is_nullable() != left_parts.dtype().is_nullable() {
-            vortex_bail!(
-                "ALPRDArray dtype nullability ({}) must match left_parts dtype nullability ({})",
-                dtype,
-                left_parts.dtype()
-            );
-        }
+        let left_parts_patches = ALPRDData::canonicalize_patches(&left_parts, left_parts_patches)?;
+        let slots = ALPRDData::make_slots(&left_parts, &right_parts, &left_parts_patches);
+        let data = ALPRDData::new(left_parts_dictionary, right_bit_width, left_parts_patches);
+        Array::try_from_parts(ArrayParts::new(ALPRD, dtype, len, data).with_slots(slots))
+    }
 
-        // we enforce right_parts to be non-nullable uint
-        if !right_parts.dtype().is_unsigned_int() || right_parts.dtype().is_nullable() {
-            vortex_bail!(MismatchedTypes: "non-nullable uint", right_parts.dtype());
+    /// # Safety
+    /// See [`ALPRD::try_new`] for preconditions.
+    pub unsafe fn new_unchecked(
+        dtype: DType,
+        left_parts: ArrayRef,
+        left_parts_dictionary: Buffer<u16>,
+        right_parts: ArrayRef,
+        right_bit_width: u8,
+        left_parts_patches: Option<Patches>,
+    ) -> ALPRDArray {
+        let len = left_parts.len();
+        let slots = ALPRDData::make_slots(&left_parts, &right_parts, &left_parts_patches);
+        let data = unsafe {
+            ALPRDData::new_unchecked(left_parts_dictionary, right_bit_width, left_parts_patches)
+        };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(ALPRD, dtype, len, data).with_slots(slots))
         }
+    }
+}
 
-        let left_parts_patches = left_parts_patches
+impl ALPRDData {
+    fn canonicalize_patches(
+        left_parts: &ArrayRef,
+        left_parts_patches: Option<Patches>,
+    ) -> VortexResult<Option<Patches>> {
+        left_parts_patches
             .map(|patches| {
                 if !patches.values().all_valid()? {
                     vortex_bail!("patches must be all valid: {}", patches.values());
                 }
                 // TODO(ngates): assert the DType, don't cast it.
                 // TODO(joe): assert the DType, don't cast it in the next PR.
-                let mut patches = patches.cast_values(left_parts.dtype())?;
+                let mut patches = patches.cast_values(&left_parts.dtype().as_nonnullable())?;
                 // Force execution of the lazy cast so patch values are materialized
                 // before serialization.
                 *patches.values_mut() = patches.values().to_canonical()?.into_array();
                 Ok(patches)
             })
-            .transpose()?;
-
-        Ok(Self {
-            dtype,
-            left_parts,
-            left_parts_dictionary,
-            right_parts,
-            right_bit_width,
-            left_parts_patches,
-            stats_set: Default::default(),
-        })
+            .transpose()
     }
 
-    /// Build a new `ALPRDArray` from components. This does not perform any validation, and instead
-    /// it constructs it from parts.
-    pub(crate) unsafe fn new_unchecked(
-        dtype: DType,
-        left_parts: ArrayRef,
+    /// Build a new `ALPRDArray` from components.
+    pub fn new(
         left_parts_dictionary: Buffer<u16>,
-        right_parts: ArrayRef,
         right_bit_width: u8,
         left_parts_patches: Option<Patches>,
     ) -> Self {
+        let (patch_offset, patch_offset_within_chunk) = match &left_parts_patches {
+            Some(patches) => (Some(patches.offset()), patches.offset_within_chunk()),
+            None => (None, None),
+        };
+
         Self {
-            dtype,
-            left_parts,
-            left_parts_patches,
+            patch_offset,
+            patch_offset_within_chunk,
             left_parts_dictionary,
-            right_parts,
             right_bit_width,
-            stats_set: Default::default(),
         }
     }
 
-    /// Returns true if logical type of the array values is f32.
-    ///
-    /// Returns false if the logical type of the array values is f64.
-    #[inline]
-    pub fn is_f32(&self) -> bool {
-        matches!(&self.dtype, DType::Primitive(PType::F32, _))
+    /// Build a new `ALPRDArray` from components. This does not perform any validation, and instead
+    /// it constructs it from parts.
+    pub(crate) unsafe fn new_unchecked(
+        left_parts_dictionary: Buffer<u16>,
+        right_bit_width: u8,
+        left_parts_patches: Option<Patches>,
+    ) -> Self {
+        Self::new(left_parts_dictionary, right_bit_width, left_parts_patches)
     }
 
-    /// The leftmost (most significant) bits of the floating point values stored in the array.
-    ///
-    /// These are bit-packed and dictionary encoded, and cannot directly be interpreted without
-    /// the metadata of this array.
-    pub fn left_parts(&self) -> &ArrayRef {
-        &self.left_parts
+    fn make_slots(
+        left_parts: &ArrayRef,
+        right_parts: &ArrayRef,
+        patches: &Option<Patches>,
+    ) -> Vec<Option<ArrayRef>> {
+        let (pi, pv, pco) = match patches {
+            Some(p) => (
+                Some(p.indices().clone()),
+                Some(p.values().clone()),
+                p.chunk_offsets().clone(),
+            ),
+            None => (None, None, None),
+        };
+        vec![
+            Some(left_parts.clone()),
+            Some(right_parts.clone()),
+            pi,
+            pv,
+            pco,
+        ]
     }
 
-    /// The rightmost (least significant) bits of the floating point values stored in the array.
-    pub fn right_parts(&self) -> &ArrayRef {
-        &self.right_parts
+    /// Return all the owned parts of the array
+    pub fn into_parts(self, left_parts: ArrayRef, right_parts: ArrayRef) -> ALPRDDataParts {
+        ALPRDDataParts {
+            left_parts,
+            left_parts_patches: None,
+            left_parts_dictionary: self.left_parts_dictionary,
+            right_parts,
+        }
     }
 
     #[inline]
@@ -413,91 +482,174 @@ impl ALPRDArray {
         self.right_bit_width
     }
 
-    /// Patches of left-most bits.
-    pub fn left_parts_patches(&self) -> Option<&Patches> {
-        self.left_parts_patches.as_ref()
-    }
-
     /// The dictionary that maps the codes in `left_parts` into bit patterns.
     #[inline]
     pub fn left_parts_dictionary(&self) -> &Buffer<u16> {
         &self.left_parts_dictionary
     }
+}
 
-    pub fn replace_left_parts_patches(&mut self, patches: Option<Patches>) {
-        self.left_parts_patches = patches;
-    }
+fn left_parts_from_slots(slots: &[Option<ArrayRef>]) -> &ArrayRef {
+    slots[LEFT_PARTS_SLOT]
+        .as_ref()
+        .vortex_expect("ALPRDArray left_parts slot")
+}
+
+fn right_parts_from_slots(slots: &[Option<ArrayRef>]) -> &ArrayRef {
+    slots[RIGHT_PARTS_SLOT]
+        .as_ref()
+        .vortex_expect("ALPRDArray right_parts slot")
 }
 
-impl ValidityChild<ALPRDVTable> for ALPRDVTable {
-    fn validity_child(array: &ALPRDArray) -> &ArrayRef {
-        array.left_parts()
+fn patches_from_slots(
+    slots: &[Option<ArrayRef>],
+    patch_offset: Option<usize>,
+    patch_offset_within_chunk: Option<usize>,
+    len: usize,
+) -> Option<Patches> {
+    match (&slots[LP_PATCH_INDICES_SLOT], &slots[LP_PATCH_VALUES_SLOT]) {
+        (Some(indices), Some(values)) => {
+            let patch_offset = patch_offset.vortex_expect("ALPRDArray patch slots without offset");
+            Some(unsafe {
+                Patches::new_unchecked(
+                    len,
+                    patch_offset,
+                    indices.clone(),
+                    values.clone(),
+                    slots[LP_PATCH_CHUNK_OFFSETS_SLOT].clone(),
+                    patch_offset_within_chunk,
+                )
+            })
+        }
+        _ => None,
     }
 }
 
-impl BaseArrayVTable<ALPRDVTable> for ALPRDVTable {
-    fn len(array: &ALPRDArray) -> usize {
-        array.left_parts.len()
+fn validate_parts(
+    dtype: &DType,
+    len: usize,
+    left_parts: &ArrayRef,
+    right_parts: &ArrayRef,
+    left_parts_patches: Option<&Patches>,
+) -> VortexResult<()> {
+    if !dtype.is_float() {
+        vortex_bail!("ALPRDArray given invalid DType ({dtype})");
     }
 
-    fn dtype(array: &ALPRDArray) -> &DType {
-        &array.dtype
+    vortex_ensure!(
+        left_parts.len() == len,
+        "left_parts len {} != outer len {len}",
+        left_parts.len(),
+    );
+    vortex_ensure!(
+        right_parts.len() == len,
+        "right_parts len {} != outer len {len}",
+        right_parts.len(),
+    );
+
+    if !left_parts.dtype().is_unsigned_int() {
+        vortex_bail!("left_parts dtype must be uint");
+    }
+    if dtype.is_nullable() != left_parts.dtype().is_nullable() {
+        vortex_bail!(
+            "ALPRDArray dtype nullability ({}) must match left_parts dtype nullability ({})",
+            dtype,
+            left_parts.dtype()
+        );
+    }
+
+    let expected_right_parts_dtype = match dtype {
+        DType::Primitive(PType::F32, _) => DType::Primitive(PType::U32, Nullability::NonNullable),
+        DType::Primitive(PType::F64, _) => DType::Primitive(PType::U64, Nullability::NonNullable),
+        _ => vortex_bail!("Expected f32 or f64 dtype, got {:?}", dtype),
+    };
+    vortex_ensure!(
+        right_parts.dtype() == &expected_right_parts_dtype,
+        "right_parts dtype {} does not match expected {}",
+        right_parts.dtype(),
+        expected_right_parts_dtype,
+    );
+
+    if let Some(patches) = left_parts_patches {
+        vortex_ensure!(
+            patches.array_len() == len,
+            "patches array_len {} != outer len {len}",
+            patches.array_len(),
+        );
+        vortex_ensure!(
+            patches.dtype().eq_ignore_nullability(left_parts.dtype()),
+            "patches dtype {} does not match left_parts dtype {}",
+            patches.dtype(),
+            left_parts.dtype(),
+        );
+        vortex_ensure!(
+            patches.values().all_valid()?,
+            "patches must be all valid: {}",
+            patches.values()
+        );
     }
 
-    fn stats(array: &ALPRDArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
+    Ok(())
+}
+
+pub trait ALPRDArrayExt: TypedArrayRef<ALPRD> {
+    fn left_parts(&self) -> &ArrayRef {
+        left_parts_from_slots(self.as_ref().slots())
     }
 
-    fn array_hash<H: std::hash::Hasher>(array: &ALPRDArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.left_parts.array_hash(state, precision);
-        array.left_parts_dictionary.array_hash(state, precision);
-        array.right_parts.array_hash(state, precision);
-        array.right_bit_width.hash(state);
-        array.left_parts_patches.array_hash(state, precision);
+    fn right_parts(&self) -> &ArrayRef {
+        right_parts_from_slots(self.as_ref().slots())
     }
 
-    fn array_eq(array: &ALPRDArray, other: &ALPRDArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.left_parts.array_eq(&other.left_parts, precision)
-            && array
-                .left_parts_dictionary
-                .array_eq(&other.left_parts_dictionary, precision)
-            && array.right_parts.array_eq(&other.right_parts, precision)
-            && array.right_bit_width == other.right_bit_width
-            && array
-                .left_parts_patches
-                .array_eq(&other.left_parts_patches, precision)
+    fn right_bit_width(&self) -> u8 {
+        ALPRDData::right_bit_width(self)
     }
-}
 
-impl VisitorVTable<ALPRDVTable> for ALPRDVTable {
-    fn visit_buffers(_array: &ALPRDArray, _visitor: &mut dyn ArrayBufferVisitor) {}
+    fn left_parts_patches(&self) -> Option<Patches> {
+        patches_from_slots(
+            self.as_ref().slots(),
+            self.patch_offset,
+            self.patch_offset_within_chunk,
+            self.as_ref().len(),
+        )
+    }
 
-    fn nbuffers(_array: &ALPRDArray) -> usize {
-        0
+    fn left_parts_dictionary(&self) -> &Buffer<u16> {
+        ALPRDData::left_parts_dictionary(self)
     }
+}
+impl<T: TypedArrayRef<ALPRD>> ALPRDArrayExt for T {}
 
-    fn visit_children(array: &ALPRDArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("left_parts", array.left_parts());
-        visitor.visit_child("right_parts", array.right_parts());
-        if let Some(patches) = array.left_parts_patches() {
-            visitor.visit_patches(patches);
-        }
+pub trait ALPRDArrayOwnedExt {
+    fn into_data_parts(self) -> ALPRDDataParts;
+}
+
+impl ALPRDArrayOwnedExt for Array<ALPRD> {
+    fn into_data_parts(self) -> ALPRDDataParts {
+        let left_parts_patches = self.left_parts_patches();
+        let left_parts = self.left_parts().clone();
+        let right_parts = self.right_parts().clone();
+        let mut parts = ALPRDDataParts {
+            left_parts,
+            left_parts_patches: None,
+            left_parts_dictionary: self.left_parts_dictionary().clone(),
+            right_parts,
+        };
+        parts.left_parts_patches = left_parts_patches;
+        parts
     }
+}
 
-    fn nchildren(array: &ALPRDArray) -> usize {
-        // left_parts + right_parts + optional patches (indices + values)
-        2 + array
-            .left_parts_patches()
-            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
+impl ValidityChild<ALPRD> for ALPRD {
+    fn validity_child(array: ArrayView<'_, ALPRD>) -> ArrayRef {
+        array.left_parts().clone()
     }
 }
 
 #[cfg(test)]
 mod test {
+    use prost::Message;
     use rstest::rstest;
-    use vortex_array::ProstMetadata;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
@@ -531,7 +683,7 @@ mod test {
 
         let rd_array = encoder.encode(&real_array);
 
-        let decoded = rd_array.to_primitive();
+        let decoded = rd_array.as_array().to_primitive();
 
         assert_arrays_eq!(decoded, PrimitiveArray::from_option_iter(reals));
     }
@@ -541,7 +693,7 @@ mod test {
     fn test_alprd_metadata() {
         check_metadata(
             "alprd.metadata",
-            ProstMetadata(ALPRDMetadata {
+            &ALPRDMetadata {
                 right_bit_width: u32::MAX,
                 patches: Some(PatchesMetadata::new(
                     usize::MAX,
@@ -554,7 +706,8 @@ mod test {
                 dict: Vec::new(),
                 left_parts_ptype: PType::U64 as i32,
                 dict_len: 8,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/alp/src/alp_rd/compute/cast.rs b/encodings/alp/src/alp_rd/compute/cast.rs
index 74dacdb68dc..01eab5d126f 100644
--- a/encodings/alp/src/alp_rd/compute/cast.rs
+++ b/encodings/alp/src/alp_rd/compute/cast.rs
@@ -2,17 +2,18 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::alp_rd::ALPRDArray;
-use crate::alp_rd::ALPRDVTable;
+use crate::ALPRDArrayExt;
+use crate::alp_rd::ALPRD;
 
-impl CastReduce for ALPRDVTable {
-    fn cast(array: &ALPRDArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for ALPRD {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // ALPRDArray stores floating-point values, so only cast between float types
         // or if just changing nullability
 
@@ -28,13 +29,13 @@ impl CastReduce for ALPRDVTable {
             )?;
 
             return Ok(Some(
-                ALPRDArray::try_new(
+                ALPRD::try_new(
                     dtype.clone(),
                     new_left_parts,
                     array.left_parts_dictionary().clone(),
                     array.right_parts().clone(),
                     array.right_bit_width(),
-                    array.left_parts_patches().cloned(),
+                    array.left_parts_patches(),
                 )?
                 .into_array(),
             ));
@@ -48,6 +49,7 @@ impl CastReduce for ALPRDVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::builtins::ArrayBuiltins;
@@ -66,7 +68,7 @@ mod tests {
         let alprd = encoder.encode(&arr);
 
         let casted = alprd
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -91,13 +93,14 @@ mod tests {
 
         // Cast to NonNullable should fail since we have nulls
         let result = alprd
-            .to_array()
+            .clone()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::NonNullable));
         assert!(result.is_err());
 
         // Cast to same type with Nullable should succeed
         let casted = alprd
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -138,6 +141,6 @@ mod tests {
         encoder.encode(&arr)
     })]
     fn test_cast_alprd_conformance(#[case] alprd: crate::alp_rd::ALPRDArray) {
-        test_cast_conformance(alprd.as_ref());
+        test_cast_conformance(&alprd.into_array());
     }
 }
diff --git a/encodings/alp/src/alp_rd/compute/filter.rs b/encodings/alp/src/alp_rd/compute/filter.rs
index 6ea1b39eb1a..8815a049dc6 100644
--- a/encodings/alp/src/alp_rd/compute/filter.rs
+++ b/encodings/alp/src/alp_rd/compute/filter.rs
@@ -2,29 +2,30 @@
 // 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::arrays::FilterKernel;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::ALPRDArray;
-use crate::ALPRDVTable;
+use crate::ALPRD;
+use crate::ALPRDArrayExt;
 
-impl FilterKernel for ALPRDVTable {
+impl FilterKernel for ALPRD {
     fn filter(
-        array: &ALPRDArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let left_parts_exceptions = array
             .left_parts_patches()
-            .map(|patches| patches.filter(mask))
+            .map(|patches| patches.filter(mask, ctx))
             .transpose()?
             .flatten();
 
         Ok(Some(
-            ALPRDArray::try_new(
+            ALPRD::try_new(
                 array.dtype().clone(),
                 array.left_parts().filter(mask.clone())?,
                 array.left_parts_dictionary().clone(),
@@ -48,6 +49,7 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
+    use crate::ALPRDArrayExt;
     use crate::ALPRDFloat;
     use crate::RDEncoder;
 
diff --git a/encodings/alp/src/alp_rd/compute/mask.rs b/encodings/alp/src/alp_rd/compute/mask.rs
index 4ab918196cb..001c44d4825 100644
--- a/encodings/alp/src/alp_rd/compute/mask.rs
+++ b/encodings/alp/src/alp_rd/compute/mask.rs
@@ -2,31 +2,32 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ScalarFnArrayExt;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
 use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::fns::mask::Mask as MaskExpr;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_error::VortexResult;
 
-use crate::ALPRDArray;
-use crate::ALPRDVTable;
+use crate::ALPRD;
+use crate::ALPRDArrayExt;
 
-impl MaskReduce for ALPRDVTable {
-    fn mask(array: &ALPRDArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for ALPRD {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_left_parts = MaskExpr.try_new_array(
             array.left_parts().len(),
             EmptyOptions,
             [array.left_parts().clone(), mask.clone()],
         )?;
         Ok(Some(
-            ALPRDArray::try_new(
+            ALPRD::try_new(
                 array.dtype().as_nullable(),
                 masked_left_parts,
                 array.left_parts_dictionary().clone(),
                 array.right_parts().clone(),
                 array.right_bit_width(),
-                array.left_parts_patches().cloned(),
+                array.left_parts_patches(),
             )?
             .into_array(),
         ))
diff --git a/encodings/alp/src/alp_rd/compute/mod.rs b/encodings/alp/src/alp_rd/compute/mod.rs
index 139aa772e2f..1971dc28b0e 100644
--- a/encodings/alp/src/alp_rd/compute/mod.rs
+++ b/encodings/alp/src/alp_rd/compute/mod.rs
@@ -66,7 +66,7 @@ mod tests {
         encoder.encode(&arr)
     })]
     fn test_alp_rd_consistency(#[case] array: ALPRDArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
diff --git a/encodings/alp/src/alp_rd/compute/take.rs b/encodings/alp/src/alp_rd/compute/take.rs
index 9e4e5641232..fe12255f063 100644
--- a/encodings/alp/src/alp_rd/compute/take.rs
+++ b/encodings/alp/src/alp_rd/compute/take.rs
@@ -1,28 +1,28 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::ALPRDArray;
-use crate::ALPRDVTable;
+use crate::ALPRD;
+use crate::ALPRDArrayExt;
 
-impl TakeExecute for ALPRDVTable {
+impl TakeExecute for ALPRD {
     fn take(
-        array: &ALPRDArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let taken_left_parts = array.left_parts().take(indices.to_array())?;
+        let taken_left_parts = array.left_parts().take(indices.clone())?;
         let left_parts_exceptions = array
             .left_parts_patches()
-            .map(|patches| patches.take(indices))
+            .map(|patches| patches.take(indices, ctx))
             .transpose()?
             .flatten()
             .map(|p| {
@@ -35,11 +35,11 @@ impl TakeExecute for ALPRDVTable {
             .transpose()?;
         let right_parts = array
             .right_parts()
-            .take(indices.to_array())?
+            .take(indices.clone())?
             .fill_null(Scalar::zero_value(array.right_parts().dtype()))?;
 
         Ok(Some(
-            ALPRDArray::try_new(
+            ALPRD::try_new(
                 array
                     .dtype()
                     .with_nullability(taken_left_parts.dtype().nullability()),
@@ -57,11 +57,13 @@ impl TakeExecute for ALPRDVTable {
 #[cfg(test)]
 mod test {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::take::test_take_conformance;
 
+    use crate::ALPRDArrayExt;
     use crate::ALPRDFloat;
     use crate::RDEncoder;
 
@@ -109,7 +111,7 @@ mod test {
         );
 
         let taken = encoded
-            .take(PrimitiveArray::from_option_iter([Some(0), Some(2), None]).to_array())
+            .take(PrimitiveArray::from_option_iter([Some(0), Some(2), None]).into_array())
             .unwrap()
             .to_primitive();
 
@@ -126,7 +128,7 @@ mod test {
         test_take_conformance(
             &RDEncoder::new(&[a, b])
                 .encode(&PrimitiveArray::from_iter([a, b, outlier, b, outlier]))
-                .to_array(),
+                .into_array(),
         );
     }
 
@@ -143,7 +145,7 @@ mod test {
                     Some(a),
                     None,
                 ]))
-                .to_array(),
+                .into_array(),
         );
     }
 }
diff --git a/encodings/alp/src/alp_rd/kernel.rs b/encodings/alp/src/alp_rd/kernel.rs
index c2f37e5495e..66721cbb1f9 100644
--- a/encodings/alp/src/alp_rd/kernel.rs
+++ b/encodings/alp/src/alp_rd/kernel.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::SliceExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
+use vortex_array::arrays::slice::SliceExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::alp_rd::ALPRDVTable;
+use crate::alp_rd::ALPRD;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRDVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPRDVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPRDVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPRDVTable)),
+pub(crate) static PARENT_KERNELS: ParentKernelSet<ALPRD> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&SliceExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(ALPRD)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(ALPRD)),
 ]);
diff --git a/encodings/alp/src/alp_rd/mod.rs b/encodings/alp/src/alp_rd/mod.rs
index f156e50fc50..6202dd799e7 100644
--- a/encodings/alp/src/alp_rd/mod.rs
+++ b/encodings/alp/src/alp_rd/mod.rs
@@ -25,12 +25,10 @@ use num_traits::Float;
 use num_traits::One;
 use num_traits::PrimInt;
 use rustc_hash::FxBuildHasher;
-use vortex_array::Array;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_integer_ptype;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
@@ -229,7 +227,12 @@ impl RDEncoder {
         }
 
         // Bit-pack down the encoded left-parts array that have been dictionary encoded.
-        let primitive_left = PrimitiveArray::new(left_parts, array.validity().clone());
+        let primitive_left = PrimitiveArray::new(
+            left_parts,
+            array
+                .validity()
+                .vortex_expect("ALP RD validity should be derivable"),
+        );
         // SAFETY: by construction, all values in left_parts can be packed to left_bit_width.
         let packed_left = unsafe {
             bitpack_encode_unchecked(primitive_left, left_bit_width as _)
@@ -273,7 +276,7 @@ impl RDEncoder {
             .vortex_expect("Patches construction in encode")
         });
 
-        ALPRDArray::try_new(
+        ALPRD::try_new(
             DType::Primitive(T::PTYPE, packed_left.dtype().nullability()),
             packed_left,
             Buffer::<u16>::copy_from(&self.codes),
@@ -285,44 +288,68 @@ impl RDEncoder {
     }
 }
 
-/// Decode a vector of ALP-RD encoded values back into their original floating point format.
+/// Decode ALP-RD encoded values back into their original floating point format.
 ///
 /// # Panics
 ///
-/// The function panics if the provided `left_parts` and `right_parts` differ in length.
+/// Panics if `left_parts` and `right_parts` differ in length.
 pub fn alp_rd_decode<T: ALPRDFloat>(
-    left_parts: Buffer<u16>,
+    mut left_parts: BufferMut<u16>,
     left_parts_dict: &[u16],
     right_bit_width: u8,
     right_parts: BufferMut<T::UINT>,
-    left_parts_patches: Option<&Patches>,
+    left_parts_patches: Option<Patches>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Buffer<T>> {
     if left_parts.len() != right_parts.len() {
         vortex_panic!("alp_rd_decode: left_parts.len != right_parts.len");
     }
 
-    // Decode the left-parts dictionary
-    let mut values = BufferMut::<u16>::from_iter(
-        left_parts
-            .iter()
-            .map(|code| left_parts_dict[*code as usize]),
-    );
+    let shift = right_bit_width as usize;
 
-    // Apply any patches
     if let Some(patches) = left_parts_patches {
+        // Patched path: some left-part codes map to exception values that live outside
+        // the dictionary. We must dictionary-decode first, then overwrite the exceptions,
+        // before we can combine with right-parts.
+
+        // Dictionary-decode every code in-place (code → actual left bit-pattern).
+        for code in left_parts.iter_mut() {
+            *code = left_parts_dict[*code as usize];
+        }
+
+        // Overwrite exception positions with their true left bit-patterns.
         let indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
         let patch_values = patches.values().clone().execute::<PrimitiveArray>(ctx)?;
-        alp_rd_apply_patches(&mut values, &indices, &patch_values, patches.offset());
-    }
+        alp_rd_apply_patches(&mut left_parts, &indices, &patch_values, patches.offset());
+
+        // Reconstruct floats by shifting each decoded left value into the MSBs
+        // and OR-ing with the corresponding right value.
+        alp_rd_combine_inplace::<T>(
+            right_parts,
+            |right, &left| {
+                *right = (<T as ALPRDFloat>::from_u16(left) << shift) | *right;
+            },
+            left_parts.as_ref(),
+        )
+    } else {
+        // Non-patched fast path: every code maps through the dictionary, so we can
+        // pre-shift the entire dictionary once and reduce the per-element hot loop to
+        // a single table lookup + OR.
+        let mut shifted_dict = [T::UINT::default(); MAX_DICT_SIZE as usize];
+        for (i, &entry) in left_parts_dict.iter().enumerate() {
+            shifted_dict[i] = <T as ALPRDFloat>::from_u16(entry) << shift;
+        }
 
-    // Shift the left-parts and add in the right-parts.
-    Ok(alp_rd_decode_core(
-        left_parts_dict,
-        right_bit_width,
-        right_parts,
-        values,
-    ))
+        // Each element: look up the pre-shifted left value by code, OR with right-parts.
+        alp_rd_combine_inplace::<T>(
+            right_parts,
+            |right, &code| {
+                // SAFETY: codes are bounded by dict size (< left_parts_dict.len() <= MAX_DICT_SIZE).
+                *right = unsafe { *shifted_dict.get_unchecked(code as usize) } | *right;
+            },
+            left_parts.as_ref(),
+        )
+    }
 }
 
 /// Apply patches to the decoded left-parts values.
@@ -343,25 +370,19 @@ fn alp_rd_apply_patches(
     })
 }
 
-/// Core decode logic shared between `alp_rd_decode` and `execute_alp_rd_decode`.
-fn alp_rd_decode_core<T: ALPRDFloat>(
-    _left_parts_dict: &[u16],
-    right_bit_width: u8,
-    right_parts: BufferMut<T::UINT>,
-    values: BufferMut<u16>,
-) -> Buffer<T> {
-    // Shift the left-parts and add in the right-parts.
-    let mut index = 0;
-    right_parts
-        .map_each_in_place(|right| {
-            let left = values[index];
-            index += 1;
-            let left = <T as ALPRDFloat>::from_u16(left);
-            T::from_bits((left << (right_bit_width as usize)) | right)
-        })
-        .freeze()
+/// Zip `right_parts` with `left_data`, apply `combine_fn` per element, then reinterpret the
+/// buffer from `T::UINT` to `T` (same bit-width: u32↔f32, u64↔f64).
+fn alp_rd_combine_inplace<T: ALPRDFloat>(
+    mut right_parts: BufferMut<T::UINT>,
+    combine_fn: impl Fn(&mut T::UINT, &u16),
+    left_data: &[u16],
+) -> VortexResult<Buffer<T>> {
+    for (right, left) in right_parts.as_mut_slice().iter_mut().zip(left_data.iter()) {
+        combine_fn(right, left);
+    }
+    // SAFETY: all bit patterns of T::UINT are valid T (u32↔f32 or u64↔f64).
+    Ok(unsafe { right_parts.transmute::<T>() }.freeze())
 }
-
 /// Find the best "cut point" for a set of floating point values such that we can
 /// cast them all to the relevant value instead.
 fn find_best_dictionary<T: ALPRDFloat>(samples: &[T]) -> ALPRDDictionary {
diff --git a/encodings/alp/src/alp_rd/ops.rs b/encodings/alp/src/alp_rd/ops.rs
index 5bba5567344..ed4dcba2dfd 100644
--- a/encodings/alp/src/alp_rd/ops.rs
+++ b/encodings/alp/src/alp_rd/ops.rs
@@ -1,17 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::dtype::PType;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::ALPRDArray;
-use crate::ALPRDVTable;
+use crate::ALPRD;
+use crate::ALPRDArrayExt;
 
-impl OperationsVTable<ALPRDVTable> for ALPRDVTable {
-    fn scalar_at(array: &ALPRDArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ALPRD> for ALPRD {
+    fn scalar_at(
+        array: ArrayView<'_, ALPRD>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // The left value can either be a direct value, or an exception.
         // The exceptions array represents exception positions with non-null values.
         let maybe_patched_value = match array.left_parts_patches() {
@@ -35,7 +41,7 @@ impl OperationsVTable<ALPRDVTable> for ALPRDVTable {
         };
 
         // combine left and right values
-        Ok(if array.is_f32() {
+        Ok(if array.dtype().as_ptype() == PType::F32 {
             let right: u32 = array
                 .right_parts()
                 .scalar_at(index)?
@@ -64,6 +70,7 @@ mod test {
     use vortex_array::assert_arrays_eq;
     use vortex_array::scalar::Scalar;
 
+    use crate::ALPRDArrayExt;
     use crate::ALPRDFloat;
     use crate::RDEncoder;
 
diff --git a/encodings/alp/src/alp_rd/rules.rs b/encodings/alp/src/alp_rd/rules.rs
index 7503e9dee06..be5eda6e7f3 100644
--- a/encodings/alp/src/alp_rd/rules.rs
+++ b/encodings/alp/src/alp_rd/rules.rs
@@ -5,9 +5,9 @@ use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::alp_rd::ALPRDVTable;
+use crate::alp_rd::ALPRD;
 
-pub(crate) static RULES: ParentRuleSet<ALPRDVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ALPRDVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ALPRDVTable)),
+pub(crate) static RULES: ParentRuleSet<ALPRD> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(ALPRD)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ALPRD)),
 ]);
diff --git a/encodings/alp/src/alp_rd/slice.rs b/encodings/alp/src/alp_rd/slice.rs
index 3e7ac2333c9..c36e138ff84 100644
--- a/encodings/alp/src/alp_rd/slice.rs
+++ b/encodings/alp/src/alp_rd/slice.rs
@@ -4,17 +4,18 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceKernel;
+use vortex_array::arrays::slice::SliceKernel;
 use vortex_error::VortexResult;
 
-use crate::alp_rd::ALPRDArray;
-use crate::alp_rd::ALPRDVTable;
+use crate::ALPRDArrayExt;
+use crate::alp_rd::ALPRD;
 
-impl SliceKernel for ALPRDVTable {
+impl SliceKernel for ALPRD {
     fn slice(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -26,7 +27,7 @@ impl SliceKernel for ALPRDVTable {
 
         // SAFETY: slicing components does not change the encoded values
         Ok(Some(unsafe {
-            ALPRDArray::new_unchecked(
+            ALPRD::new_unchecked(
                 array.dtype().clone(),
                 array.left_parts().slice(range.clone())?,
                 array.left_parts_dictionary().clone(),
diff --git a/encodings/alp/src/lib.rs b/encodings/alp/src/lib.rs
index 4a32453631f..3a955f368af 100644
--- a/encodings/alp/src/lib.rs
+++ b/encodings/alp/src/lib.rs
@@ -18,6 +18,24 @@
 
 pub use alp::*;
 pub use alp_rd::*;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::nan_count::NanCount;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
 
 mod alp;
 mod alp_rd;
+
+/// Initialize ALP encoding in the given session.
+pub fn initialize(session: &VortexSession) {
+    session.arrays().register(ALP);
+    session.arrays().register(ALPRD);
+
+    // Register the ALP-specific NaN count aggregate kernel.
+    session.aggregate_fns().register_aggregate_kernel(
+        ALP::ID,
+        Some(NanCount.id()),
+        &compute::nan_count::ALPNanCountKernel,
+    );
+}
diff --git a/encodings/bytebool/Cargo.toml b/encodings/bytebool/Cargo.toml
index 53197452ff5..bca2ed71aa9 100644
--- a/encodings/bytebool/Cargo.toml
+++ b/encodings/bytebool/Cargo.toml
@@ -21,6 +21,7 @@ num-traits = { workspace = true }
 vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
 vortex-session = { workspace = true }
 
 [dev-dependencies]
diff --git a/encodings/bytebool/public-api.lock b/encodings/bytebool/public-api.lock
index 1170933ce3b..63d9c1b9518 100644
--- a/encodings/bytebool/public-api.lock
+++ b/encodings/bytebool/public-api.lock
@@ -1,135 +1,135 @@
 pub mod vortex_bytebool
 
-pub struct vortex_bytebool::ByteBoolArray
+pub struct vortex_bytebool::ByteBool
 
-impl vortex_bytebool::ByteBoolArray
+impl vortex_bytebool::ByteBool
 
-pub fn vortex_bytebool::ByteBoolArray::as_slice(&self) -> &[bool]
+pub const vortex_bytebool::ByteBool::ID: vortex_array::array::ArrayId
 
-pub fn vortex_bytebool::ByteBoolArray::buffer(&self) -> &vortex_array::buffer::BufferHandle
+pub fn vortex_bytebool::ByteBool::from_option_vec(data: alloc::vec::Vec<core::option::Option<bool>>) -> vortex_bytebool::ByteBoolArray
 
-pub fn vortex_bytebool::ByteBoolArray::from_vec<V: core::convert::Into<vortex_array::validity::Validity>>(data: alloc::vec::Vec<bool>, validity: V) -> Self
+pub fn vortex_bytebool::ByteBool::from_vec<V: core::convert::Into<vortex_array::validity::Validity>>(data: alloc::vec::Vec<bool>, validity: V) -> vortex_bytebool::ByteBoolArray
 
-pub fn vortex_bytebool::ByteBoolArray::new(buffer: vortex_array::buffer::BufferHandle, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_bytebool::ByteBool::new(buffer: vortex_array::buffer::BufferHandle, validity: vortex_array::validity::Validity) -> vortex_bytebool::ByteBoolArray
 
-impl core::clone::Clone for vortex_bytebool::ByteBoolArray
+impl core::clone::Clone for vortex_bytebool::ByteBool
 
-pub fn vortex_bytebool::ByteBoolArray::clone(&self) -> vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBool::clone(&self) -> vortex_bytebool::ByteBool
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_bytebool::ByteBoolArray
+impl core::fmt::Debug for vortex_bytebool::ByteBool
 
-pub fn vortex_bytebool::ByteBoolArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub fn vortex_bytebool::ByteBool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<alloc::vec::Vec<bool>> for vortex_bytebool::ByteBoolArray
+impl vortex_array::array::vtable::VTable for vortex_bytebool::ByteBool
 
-pub fn vortex_bytebool::ByteBoolArray::from(value: alloc::vec::Vec<bool>) -> Self
+pub type vortex_bytebool::ByteBool::ArrayData = vortex_bytebool::ByteBoolData
 
-impl core::convert::From<alloc::vec::Vec<core::option::Option<bool>>> for vortex_bytebool::ByteBoolArray
+pub type vortex_bytebool::ByteBool::OperationsVTable = vortex_bytebool::ByteBool
 
-pub fn vortex_bytebool::ByteBoolArray::from(value: alloc::vec::Vec<core::option::Option<bool>>) -> Self
+pub type vortex_bytebool::ByteBool::ValidityVTable = vortex_bytebool::ByteBool
 
-impl core::convert::From<vortex_bytebool::ByteBoolArray> for vortex_array::array::ArrayRef
+pub fn vortex_bytebool::ByteBool::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_bytebool::ByteBoolArray) -> vortex_array::array::ArrayRef
+pub fn vortex_bytebool::ByteBool::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::fmt::Debug for vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_bytebool::ByteBoolArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_bytebool::ByteBool::execute(array: vortex_array::array::typed::Array<Self>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-impl core::ops::deref::Deref for vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBool::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_bytebool::ByteBoolArray::Target = dyn vortex_array::array::Array
+pub fn vortex_bytebool::ByteBool::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_bytebool::ByteBoolArray::deref(&self) -> &Self::Target
+pub fn vortex_bytebool::ByteBool::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::array::IntoArray for vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBool::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_bytebool::ByteBoolArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_bytebool::ByteBool::serialize(_array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::validity::ValidityHelper for vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBool::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_bytebool::ByteBoolArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_bytebool::ByteBool::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_bytebool::ByteBoolVTable
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_bytebool::ByteBool> for vortex_bytebool::ByteBool
 
-impl vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_bytebool::ByteBool>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub const vortex_bytebool::ByteBoolVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_bytebool::ByteBool> for vortex_bytebool::ByteBool
 
-impl core::fmt::Debug for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::validity(array: vortex_array::array::view::ArrayView<'_, vortex_bytebool::ByteBool>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_bytebool::ByteBoolVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_bytebool::ByteBool
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_bytebool::ByteBoolVTable::take(array: &vortex_bytebool::ByteBoolArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::slice::SliceReduce for vortex_bytebool::ByteBool
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_bytebool::ByteBoolVTable::slice(array: &vortex_bytebool::ByteBoolArray, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_bytebool::ByteBool
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_bytebool::ByteBoolVTable::cast(array: &vortex_bytebool::ByteBoolArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_bytebool::ByteBool
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBool::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_bytebool::ByteBoolVTable::mask(array: &vortex_bytebool::ByteBoolArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_bytebool::ByteBoolData
 
-impl vortex_array::vtable::VTable for vortex_bytebool::ByteBoolVTable
+impl vortex_bytebool::ByteBoolData
 
-pub type vortex_bytebool::ByteBoolVTable::Array = vortex_bytebool::ByteBoolArray
+pub fn vortex_bytebool::ByteBoolData::as_slice(&self) -> &[bool]
 
-pub type vortex_bytebool::ByteBoolVTable::ArrayVTable = vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBoolData::buffer(&self) -> &vortex_array::buffer::BufferHandle
 
-pub type vortex_bytebool::ByteBoolVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub fn vortex_bytebool::ByteBoolData::from_vec<V: core::convert::Into<vortex_array::validity::Validity>>(data: alloc::vec::Vec<bool>, validity: V) -> Self
 
-pub type vortex_bytebool::ByteBoolVTable::OperationsVTable = vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBoolData::is_empty(&self) -> bool
 
-pub type vortex_bytebool::ByteBoolVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromValidityHelper
+pub fn vortex_bytebool::ByteBoolData::len(&self) -> usize
 
-pub type vortex_bytebool::ByteBoolVTable::VisitorVTable = vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBoolData::new(buffer: vortex_array::buffer::BufferHandle, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_bytebool::ByteBoolVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_bytebool::ByteBoolArray>
+pub fn vortex_bytebool::ByteBoolData::validate(buffer: &vortex_array::buffer::BufferHandle, validity: &vortex_array::validity::Validity, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<()>
 
-pub fn vortex_bytebool::ByteBoolVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl core::clone::Clone for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_bytebool::ByteBoolData::clone(&self) -> vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::convert::From<alloc::vec::Vec<bool>> for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_bytebool::ByteBoolData::from(value: alloc::vec::Vec<bool>) -> Self
 
-pub fn vortex_bytebool::ByteBoolVTable::metadata(_array: &vortex_bytebool::ByteBoolArray) -> vortex_error::VortexResult<Self::Metadata>
+impl core::convert::From<alloc::vec::Vec<core::option::Option<bool>>> for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_bytebool::ByteBoolData::from(value: alloc::vec::Vec<core::option::Option<bool>>) -> Self
 
-pub fn vortex_bytebool::ByteBoolVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::fmt::Debug for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_bytebool::ByteBoolData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_bytebool::ByteBoolVTable> for vortex_bytebool::ByteBoolVTable
+impl core::fmt::Display for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::array_eq(array: &vortex_bytebool::ByteBoolArray, other: &vortex_bytebool::ByteBoolArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_bytebool::ByteBoolData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_bytebool::ByteBoolVTable::array_hash<H: core::hash::Hasher>(array: &vortex_bytebool::ByteBoolArray, state: &mut H, precision: vortex_array::hash::Precision)
+impl vortex_array::hash::ArrayEq for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::dtype(array: &vortex_bytebool::ByteBoolArray) -> &vortex_array::dtype::DType
+pub fn vortex_bytebool::ByteBoolData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_bytebool::ByteBoolVTable::len(array: &vortex_bytebool::ByteBoolArray) -> usize
+impl vortex_array::hash::ArrayHash for vortex_bytebool::ByteBoolData
 
-pub fn vortex_bytebool::ByteBoolVTable::stats(array: &vortex_bytebool::ByteBoolArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_bytebool::ByteBoolData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_bytebool::ByteBoolVTable> for vortex_bytebool::ByteBoolVTable
+pub trait vortex_bytebool::ByteBoolArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_bytebool::ByteBool>
 
-pub fn vortex_bytebool::ByteBoolVTable::scalar_at(array: &vortex_bytebool::ByteBoolArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_bytebool::ByteBoolArrayExt::validity(&self) -> vortex_array::validity::Validity
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_bytebool::ByteBoolVTable> for vortex_bytebool::ByteBoolVTable
+pub fn vortex_bytebool::ByteBoolArrayExt::validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_bytebool::ByteBoolVTable::nbuffers(_array: &vortex_bytebool::ByteBoolArray) -> usize
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_bytebool::ByteBool>> vortex_bytebool::ByteBoolArrayExt for T
 
-pub fn vortex_bytebool::ByteBoolVTable::nchildren(array: &vortex_bytebool::ByteBoolArray) -> usize
+pub fn T::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_bytebool::ByteBoolVTable::visit_buffers(array: &vortex_bytebool::ByteBoolArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn T::validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_bytebool::ByteBoolVTable::visit_children(array: &vortex_bytebool::ByteBoolArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub type vortex_bytebool::ByteBoolArray = vortex_array::array::typed::Array<vortex_bytebool::ByteBool>
diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs
index 0fdfb8c75e9..c1a2ebf7fce 100644
--- a/encodings/bytebool/src/array.rs
+++ b/encodings/bytebool/src/array.rs
@@ -2,86 +2,120 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
 
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::EmptyMetadata;
+use vortex_array::ArrayView;
 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;
 use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_array::vtable::ValidityVTableFromValidityHelper;
-use vortex_array::vtable::VisitorVTable;
-use vortex_array::vtable::validity_nchildren;
+use vortex_array::vtable::ValidityVTable;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
 use vortex_buffer::BitBuffer;
 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_panic;
+use vortex_mask::Mask;
 use vortex_session::VortexSession;
 
 use crate::kernel::PARENT_KERNELS;
 
-vtable!(ByteBool);
+/// A [`ByteBool`]-encoded Vortex array.
+pub type ByteBoolArray = Array<ByteBool>;
 
-impl VTable for ByteBoolVTable {
-    type Array = ByteBoolArray;
+impl ArrayHash for ByteBoolData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.buffer.array_hash(state, precision);
+    }
+}
+
+impl ArrayEq for ByteBoolData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.buffer.array_eq(&other.buffer, precision)
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl VTable for ByteBool {
+    type ArrayData = ByteBoolData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &ByteBoolArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let validity = child_to_validity(&slots[VALIDITY_SLOT], dtype.nullability());
+        ByteBoolData::validate(data.buffer(), &validity, dtype, len)
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.buffer().clone(),
+            _ => vortex_panic!("ByteBoolArray buffer index {idx} out of bounds"),
+        }
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("values".to_string()),
+            _ => vortex_panic!("ByteBoolArray buffer_name index {idx} out of bounds"),
+        }
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ByteBoolArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "ByteBoolArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         let validity = if children.is_empty() {
             Validity::from(dtype.nullability())
         } else if children.len() == 1 {
@@ -96,41 +130,33 @@ impl VTable for ByteBoolVTable {
         }
         let buffer = buffers[0].clone();
 
-        Ok(ByteBoolArray::new(buffer, validity))
+        let data = ByteBoolData::new(buffer, validity.clone());
+        let slots = ByteBoolData::make_slots(&validity, len);
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "ByteBoolArray expects at most 1 child (validity), got {}",
-            children.len()
-        );
-
-        array.validity = if children.is_empty() {
-            Validity::from(array.dtype.nullability())
-        } else {
-            Validity::Array(children.into_iter().next().vortex_expect("checked"))
-        };
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         crate::rules::RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let boolean_buffer = BitBuffer::from(array.as_slice());
-        let validity = array.validity().clone();
-        Ok(BoolArray::new(boolean_buffer, validity).into_array())
+        let validity = array.validity()?;
+        Ok(ExecutionResult::done(
+            BoolArray::new(boolean_buffer, validity).into_array(),
+        ))
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -139,22 +165,111 @@ impl VTable for ByteBoolVTable {
     }
 }
 
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
+
 #[derive(Clone, Debug)]
-pub struct ByteBoolArray {
-    dtype: DType,
+pub struct ByteBoolData {
     buffer: BufferHandle,
-    validity: Validity,
-    stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
-pub struct ByteBoolVTable;
+impl Display for ByteBoolData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+pub trait ByteBoolArrayExt: TypedArrayRef<ByteBool> {
+    fn validity(&self) -> Validity {
+        child_to_validity(
+            &self.as_ref().slots()[VALIDITY_SLOT],
+            self.as_ref().dtype().nullability(),
+        )
+    }
+
+    fn validity_mask(&self) -> Mask {
+        self.validity().to_mask(self.as_ref().len())
+    }
+}
+
+impl<T: TypedArrayRef<ByteBool>> ByteBoolArrayExt for T {}
 
-impl ByteBoolVTable {
+#[derive(Clone, Debug)]
+pub struct ByteBool;
+
+impl ByteBool {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.bytebool");
+
+    pub fn new(buffer: BufferHandle, validity: Validity) -> ByteBoolArray {
+        let dtype = DType::Bool(validity.nullability());
+        let slots = ByteBoolData::make_slots(&validity, buffer.len());
+        let data = ByteBoolData::new(buffer, validity);
+        let len = data.len();
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ByteBool, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Construct a [`ByteBoolArray`] from a `Vec<bool>` and validity.
+    pub fn from_vec<V: Into<Validity>>(data: Vec<bool>, validity: V) -> ByteBoolArray {
+        let validity = validity.into();
+        let data = ByteBoolData::from_vec(data, validity.clone());
+        let dtype = DType::Bool(validity.nullability());
+        let len = data.len();
+        let slots = ByteBoolData::make_slots(&validity, len);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ByteBool, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Construct a [`ByteBoolArray`] from optional bools.
+    pub fn from_option_vec(data: Vec<Option<bool>>) -> ByteBoolArray {
+        let validity = Validity::from_iter(data.iter().map(|v| v.is_some()));
+        let data = ByteBoolData::from(data);
+        let dtype = DType::Bool(validity.nullability());
+        let len = data.len();
+        let slots = ByteBoolData::make_slots(&validity, len);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ByteBool, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
 }
 
-impl ByteBoolArray {
+impl ByteBoolData {
+    pub fn validate(
+        buffer: &BufferHandle,
+        validity: &Validity,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        let expected_dtype = DType::Bool(validity.nullability());
+        vortex_ensure!(
+            dtype == &expected_dtype,
+            "expected dtype {expected_dtype}, got {dtype}"
+        );
+        vortex_ensure!(
+            buffer.len() == len,
+            "expected len {len}, got {}",
+            buffer.len()
+        );
+        if let Some(vlen) = validity.maybe_len() {
+            vortex_ensure!(vlen == len, "expected validity len {len}, got {vlen}");
+        }
+        Ok(())
+    }
+
+    fn make_slots(validity: &Validity, len: usize) -> Vec<Option<ArrayRef>> {
+        vec![validity_to_child(validity, len)]
+    }
+
     pub fn new(buffer: BufferHandle, validity: Validity) -> Self {
         let length = buffer.len();
         if let Some(vlen) = validity.maybe_len()
@@ -166,12 +281,17 @@ impl ByteBoolArray {
                 vlen
             );
         }
-        Self {
-            dtype: DType::Bool(validity.nullability()),
-            buffer,
-            validity,
-            stats_set: Default::default(),
-        }
+        Self { buffer }
+    }
+
+    /// Returns the number of elements in the array.
+    pub fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    /// Returns `true` if the array contains no elements.
+    pub fn is_empty(&self) -> bool {
+        self.buffer.len() == 0
     }
 
     // TODO(ngates): deprecate construction from vec
@@ -192,44 +312,18 @@ impl ByteBoolArray {
     }
 }
 
-impl ValidityHelper for ByteBoolArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
-    }
-}
-
-impl BaseArrayVTable<ByteBoolVTable> for ByteBoolVTable {
-    fn len(array: &ByteBoolArray) -> usize {
-        array.buffer.len()
-    }
-
-    fn dtype(array: &ByteBoolArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ByteBoolArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &ByteBoolArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.buffer.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &ByteBoolArray, other: &ByteBoolArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.buffer.array_eq(&other.buffer, precision)
-            && array.validity.array_eq(&other.validity, precision)
+impl ValidityVTable<ByteBool> for ByteBool {
+    fn validity(array: ArrayView<'_, ByteBool>) -> VortexResult<Validity> {
+        Ok(ByteBoolArrayExt::validity(&array))
     }
 }
 
-impl OperationsVTable<ByteBoolVTable> for ByteBoolVTable {
-    fn scalar_at(array: &ByteBoolArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ByteBool> for ByteBool {
+    fn scalar_at(
+        array: ArrayView<'_, ByteBool>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(Scalar::bool(
             array.buffer.as_host()[index] == 1,
             array.dtype().nullability(),
@@ -237,31 +331,13 @@ impl OperationsVTable<ByteBoolVTable> for ByteBoolVTable {
     }
 }
 
-impl VisitorVTable<ByteBoolVTable> for ByteBoolVTable {
-    fn visit_buffers(array: &ByteBoolArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle("values", array.buffer());
-    }
-
-    fn nbuffers(_array: &ByteBoolArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &ByteBoolArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &ByteBoolArray) -> usize {
-        validity_nchildren(array.validity())
-    }
-}
-
-impl From<Vec<bool>> for ByteBoolArray {
+impl From<Vec<bool>> for ByteBoolData {
     fn from(value: Vec<bool>) -> Self {
         Self::from_vec(value, Validity::AllValid)
     }
 }
 
-impl From<Vec<Option<bool>>> for ByteBoolArray {
+impl From<Vec<Option<bool>>> for ByteBoolData {
     fn from(value: Vec<Option<bool>>) -> Self {
         let validity = Validity::from_iter(value.iter().map(|v| v.is_some()));
 
@@ -274,6 +350,18 @@ impl From<Vec<Option<bool>>> for ByteBoolArray {
 
 #[cfg(test)]
 mod tests {
+    use vortex_array::ArrayContext;
+    use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::serde::SerializeOptions;
+    use vortex_array::serde::SerializedArray;
+    use vortex_array::session::ArraySession;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_session::VortexSession;
+    use vortex_session::registry::ReadContext;
+
     use super::*;
 
     #[test]
@@ -281,7 +369,7 @@ mod tests {
         let v = vec![true, false];
         let v_len = v.len();
 
-        let arr = ByteBoolArray::from(v);
+        let arr = ByteBool::from_vec(v, Validity::AllValid);
         assert_eq!(v_len, arr.len());
 
         for idx in 0..arr.len() {
@@ -289,7 +377,7 @@ mod tests {
         }
 
         let v = vec![Some(true), None, Some(false)];
-        let arr = ByteBoolArray::from(v);
+        let arr = ByteBool::from_option_vec(v);
         assert!(arr.is_valid(0).unwrap());
         assert!(!arr.is_valid(1).unwrap());
         assert!(arr.is_valid(2).unwrap());
@@ -298,7 +386,7 @@ mod tests {
         let v: Vec<Option<bool>> = vec![None, None];
         let v_len = v.len();
 
-        let arr = ByteBoolArray::from(v);
+        let arr = ByteBool::from_option_vec(v);
         assert_eq!(v_len, arr.len());
 
         for idx in 0..arr.len() {
@@ -306,4 +394,32 @@ mod tests {
         }
         assert_eq!(arr.len(), 2);
     }
+
+    #[test]
+    fn test_nullable_bytebool_serde_roundtrip() {
+        let array = ByteBool::from_option_vec(vec![Some(true), None, Some(false), None]);
+        let dtype = array.dtype().clone();
+        let len = array.len();
+        let session = VortexSession::empty().with::<ArraySession>();
+        session.arrays().register(ByteBool);
+
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+
+        let parts = SerializedArray::try_from(concat.freeze()).unwrap();
+        let decoded = parts
+            .decode(&dtype, len, &ReadContext::new(ctx.to_ids()), &session)
+            .unwrap();
+
+        assert_arrays_eq!(decoded, array);
+    }
 }
diff --git a/encodings/bytebool/src/compute.rs b/encodings/bytebool/src/compute.rs
index 4df9cdb61c9..0fd75cb8123 100644
--- a/encodings/bytebool/src/compute.rs
+++ b/encodings/bytebool/src/compute.rs
@@ -2,25 +2,23 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use num_traits::AsPrimitive;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_error::VortexResult;
 
-use super::ByteBoolArray;
-use super::ByteBoolVTable;
+use super::ByteBool;
 
-impl CastReduce for ByteBoolVTable {
-    fn cast(array: &ByteBoolArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for ByteBool {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // ByteBool is essentially a bool array stored as bytes
         // The main difference from BoolArray is the storage format
         // For casting, we can decode to canonical (BoolArray) and let it handle the cast
@@ -28,12 +26,11 @@ impl CastReduce for ByteBoolVTable {
         // If just changing nullability, we can optimize
         if array.dtype().eq_ignore_nullability(dtype) {
             let new_validity = array
-                .validity()
-                .clone()
+                .validity()?
                 .cast_nullability(dtype.nullability(), array.len())?;
 
             return Ok(Some(
-                ByteBoolArray::new(array.buffer().clone(), new_validity).into_array(),
+                ByteBool::new(array.buffer().clone(), new_validity).into_array(),
             ));
         }
 
@@ -42,32 +39,29 @@ impl CastReduce for ByteBoolVTable {
     }
 }
 
-impl MaskReduce for ByteBoolVTable {
-    fn mask(array: &ByteBoolArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for ByteBool {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            ByteBoolArray::new(
+            ByteBool::new(
                 array.buffer().clone(),
-                array
-                    .validity()
-                    .clone()
-                    .and(Validity::Array(mask.clone()))?,
+                array.validity()?.and(Validity::Array(mask.clone()))?,
             )
             .into_array(),
         ))
     }
 }
 
-impl TakeExecute for ByteBoolVTable {
+impl TakeExecute for ByteBool {
     fn take(
-        array: &ByteBoolArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let indices = indices.to_primitive();
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
         let bools = array.as_slice();
 
         // This handles combining validity from both source array and nullable indices
-        let validity = array.validity().take(indices.as_ref())?;
+        let validity = array.validity()?.take(&indices.clone().into_array())?;
 
         let taken_bools = match_each_integer_ptype!(indices.ptype(), |I| {
             indices
@@ -80,9 +74,7 @@ impl TakeExecute for ByteBoolVTable {
                 .collect::<Vec<bool>>()
         });
 
-        Ok(Some(
-            ByteBoolArray::from_vec(taken_bools, validity).into_array(),
-        ))
+        Ok(Some(ByteBool::from_vec(taken_bools, validity).into_array()))
     }
 }
 
@@ -101,82 +93,99 @@ mod tests {
     use vortex_array::scalar_fn::fns::operators::Operator;
 
     use super::*;
+    use crate::ByteBoolArray;
+
+    fn bb(v: Vec<bool>) -> ByteBoolArray {
+        ByteBool::from_vec(v, Validity::AllValid)
+    }
+
+    fn bb_opt(v: Vec<Option<bool>>) -> ByteBoolArray {
+        ByteBool::from_option_vec(v)
+    }
 
     #[test]
     fn test_slice() {
         let original = vec![Some(true), Some(true), None, Some(false), None];
-        let vortex_arr = ByteBoolArray::from(original);
+        let vortex_arr = bb_opt(original);
 
         let sliced_arr = vortex_arr.slice(1..4).unwrap();
 
-        let expected = ByteBoolArray::from(vec![Some(true), None, Some(false)]);
-        assert_arrays_eq!(sliced_arr, expected.to_array());
+        let expected = bb_opt(vec![Some(true), None, Some(false)]);
+        assert_arrays_eq!(sliced_arr, expected.into_array());
     }
 
     #[test]
     fn test_compare_all_equal() {
-        let lhs = ByteBoolArray::from(vec![true; 5]);
-        let rhs = ByteBoolArray::from(vec![true; 5]);
+        let lhs = bb(vec![true; 5]);
+        let rhs = bb(vec![true; 5]);
 
-        let arr = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let arr = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
 
-        let expected = ByteBoolArray::from(vec![true; 5]);
-        assert_arrays_eq!(arr, expected.to_array());
+        let expected = bb(vec![true; 5]);
+        assert_arrays_eq!(arr, expected.into_array());
     }
 
     #[test]
     fn test_compare_all_different() {
-        let lhs = ByteBoolArray::from(vec![false; 5]);
-        let rhs = ByteBoolArray::from(vec![true; 5]);
+        let lhs = bb(vec![false; 5]);
+        let rhs = bb(vec![true; 5]);
 
-        let arr = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let arr = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
 
-        let expected = ByteBoolArray::from(vec![false; 5]);
-        assert_arrays_eq!(arr, expected.to_array());
+        let expected = bb(vec![false; 5]);
+        assert_arrays_eq!(arr, expected.into_array());
     }
 
     #[test]
     fn test_compare_with_nulls() {
-        let lhs = ByteBoolArray::from(vec![true; 5]);
-        let rhs = ByteBoolArray::from(vec![Some(true), Some(true), Some(true), Some(false), None]);
+        let lhs = bb(vec![true; 5]);
+        let rhs = bb_opt(vec![Some(true), Some(true), Some(true), Some(false), None]);
 
-        let arr = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let arr = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
 
-        let expected =
-            ByteBoolArray::from(vec![Some(true), Some(true), Some(true), Some(false), None]);
-        assert_arrays_eq!(arr, expected.to_array());
+        let expected = bb_opt(vec![Some(true), Some(true), Some(true), Some(false), None]);
+        assert_arrays_eq!(arr, expected.into_array());
     }
 
     #[test]
     fn test_mask_byte_bool() {
-        test_mask_conformance(ByteBoolArray::from(vec![true, false, true, true, false]).as_ref());
+        test_mask_conformance(&bb(vec![true, false, true, true, false]).into_array());
         test_mask_conformance(
-            ByteBoolArray::from(vec![Some(true), Some(true), None, Some(false), None]).as_ref(),
+            &bb_opt(vec![Some(true), Some(true), None, Some(false), None]).into_array(),
         );
     }
 
     #[test]
     fn test_filter_byte_bool() {
-        test_filter_conformance(ByteBoolArray::from(vec![true, false, true, true, false]).as_ref());
+        test_filter_conformance(&bb(vec![true, false, true, true, false]).into_array());
         test_filter_conformance(
-            ByteBoolArray::from(vec![Some(true), Some(true), None, Some(false), None]).as_ref(),
+            &bb_opt(vec![Some(true), Some(true), None, Some(false), None]).into_array(),
         );
     }
 
     #[rstest]
-    #[case(ByteBoolArray::from(vec![true, false, true, true, false]))]
-    #[case(ByteBoolArray::from(vec![Some(true), Some(true), None, Some(false), None]))]
-    #[case(ByteBoolArray::from(vec![true, false]))]
-    #[case(ByteBoolArray::from(vec![true]))]
+    #[case(bb(vec![true, false, true, true, false]))]
+    #[case(bb_opt(vec![Some(true), Some(true), None, Some(false), None]))]
+    #[case(bb(vec![true, false]))]
+    #[case(bb(vec![true]))]
     fn test_take_byte_bool_conformance(#[case] array: ByteBoolArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 
     #[test]
     fn test_cast_bytebool_to_nullable() {
-        let array = ByteBoolArray::from(vec![true, false, true, false]);
+        let array = bb(vec![true, false, true, false]);
         let casted = array
-            .to_array()
+            .into_array()
             .cast(DType::Bool(Nullability::Nullable))
             .unwrap();
         assert_eq!(casted.dtype(), &DType::Bool(Nullability::Nullable));
@@ -184,25 +193,25 @@ mod tests {
     }
 
     #[rstest]
-    #[case(ByteBoolArray::from(vec![true, false, true, true, false]))]
-    #[case(ByteBoolArray::from(vec![Some(true), Some(false), None, Some(true), None]))]
-    #[case(ByteBoolArray::from(vec![false]))]
-    #[case(ByteBoolArray::from(vec![true]))]
-    #[case(ByteBoolArray::from(vec![Some(true), None]))]
+    #[case(bb(vec![true, false, true, true, false]))]
+    #[case(bb_opt(vec![Some(true), Some(false), None, Some(true), None]))]
+    #[case(bb(vec![false]))]
+    #[case(bb(vec![true]))]
+    #[case(bb_opt(vec![Some(true), None]))]
     fn test_cast_bytebool_conformance(#[case] array: ByteBoolArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[rstest]
-    #[case::non_nullable(ByteBoolArray::from(vec![true, false, true, true, false]))]
-    #[case::nullable(ByteBoolArray::from(vec![Some(true), Some(false), None, Some(true), None]))]
-    #[case::all_true(ByteBoolArray::from(vec![true, true, true, true]))]
-    #[case::all_false(ByteBoolArray::from(vec![false, false, false, false]))]
-    #[case::single_true(ByteBoolArray::from(vec![true]))]
-    #[case::single_false(ByteBoolArray::from(vec![false]))]
-    #[case::single_null(ByteBoolArray::from(vec![None]))]
-    #[case::mixed_with_nulls(ByteBoolArray::from(vec![Some(true), None, Some(false), None, Some(true)]))]
+    #[case::non_nullable(bb(vec![true, false, true, true, false]))]
+    #[case::nullable(bb_opt(vec![Some(true), Some(false), None, Some(true), None]))]
+    #[case::all_true(bb(vec![true, true, true, true]))]
+    #[case::all_false(bb(vec![false, false, false, false]))]
+    #[case::single_true(bb(vec![true]))]
+    #[case::single_false(bb(vec![false]))]
+    #[case::single_null(bb_opt(vec![None]))]
+    #[case::mixed_with_nulls(bb_opt(vec![Some(true), None, Some(false), None, Some(true)]))]
     fn test_bytebool_consistency(#[case] array: ByteBoolArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/bytebool/src/kernel.rs b/encodings/bytebool/src/kernel.rs
index 91eb3add3a6..4373520039a 100644
--- a/encodings/bytebool/src/kernel.rs
+++ b/encodings/bytebool/src/kernel.rs
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::ByteBoolVTable;
+use crate::ByteBool;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<ByteBoolVTable> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ByteBoolVTable))]);
+pub(crate) const PARENT_KERNELS: ParentKernelSet<ByteBool> =
+    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ByteBool))]);
diff --git a/encodings/bytebool/src/rules.rs b/encodings/bytebool/src/rules.rs
index a5a1ee8a105..f67d3567326 100644
--- a/encodings/bytebool/src/rules.rs
+++ b/encodings/bytebool/src/rules.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::ByteBoolVTable;
+use crate::ByteBool;
 
-pub(crate) static RULES: ParentRuleSet<ByteBoolVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ByteBoolVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ByteBoolVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ByteBoolVTable)),
+pub(crate) static RULES: ParentRuleSet<ByteBool> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(ByteBool)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ByteBool)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(ByteBool)),
 ]);
diff --git a/encodings/bytebool/src/slice.rs b/encodings/bytebool/src/slice.rs
index 77c00865470..34ffa844b3f 100644
--- a/encodings/bytebool/src/slice.rs
+++ b/encodings/bytebool/src/slice.rs
@@ -4,20 +4,19 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
-use vortex_array::vtable::ValidityHelper;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::ByteBoolArray;
-use crate::ByteBoolVTable;
+use crate::ByteBool;
 
-impl SliceReduce for ByteBoolVTable {
-    fn slice(array: &ByteBoolArray, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for ByteBool {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            ByteBoolArray::new(
+            ByteBool::new(
                 array.buffer().slice(range.clone()),
-                array.validity().slice(range)?,
+                array.validity()?.slice(range)?,
             )
             .into_array(),
         ))
diff --git a/encodings/datetime-parts/public-api.lock b/encodings/datetime-parts/public-api.lock
index ab46008a673..3cdc22cc7b7 100644
--- a/encodings/datetime-parts/public-api.lock
+++ b/encodings/datetime-parts/public-api.lock
@@ -1,223 +1,191 @@
 pub mod vortex_datetime_parts
 
-pub struct vortex_datetime_parts::DateTimePartsArray
+pub struct vortex_datetime_parts::DateTimeParts
 
-impl vortex_datetime_parts::DateTimePartsArray
+impl vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArray::days(&self) -> &vortex_array::array::ArrayRef
+pub const vortex_datetime_parts::DateTimeParts::ID: vortex_array::array::ArrayId
 
-pub fn vortex_datetime_parts::DateTimePartsArray::into_parts(self) -> vortex_datetime_parts::DateTimePartsArrayParts
+pub fn vortex_datetime_parts::DateTimeParts::try_from_temporal(temporal: vortex_array::arrays::datetime::TemporalArray) -> vortex_error::VortexResult<vortex_datetime_parts::DateTimePartsArray>
 
-pub fn vortex_datetime_parts::DateTimePartsArray::seconds(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_datetime_parts::DateTimeParts::try_new(dtype: vortex_array::dtype::DType, days: vortex_array::array::erased::ArrayRef, seconds: vortex_array::array::erased::ArrayRef, subseconds: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_datetime_parts::DateTimePartsArray>
 
-pub fn vortex_datetime_parts::DateTimePartsArray::subseconds(&self) -> &vortex_array::array::ArrayRef
+impl core::clone::Clone for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArray::try_new(dtype: vortex_array::dtype::DType, days: vortex_array::array::ArrayRef, seconds: vortex_array::array::ArrayRef, subseconds: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_datetime_parts::DateTimeParts::clone(&self) -> vortex_datetime_parts::DateTimeParts
 
-impl core::clone::Clone for vortex_datetime_parts::DateTimePartsArray
+impl core::fmt::Debug for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArray::clone(&self) -> vortex_datetime_parts::DateTimePartsArray
+pub fn vortex_datetime_parts::DateTimeParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_datetime_parts::DateTimePartsArray
+impl vortex_array::array::vtable::VTable for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_datetime_parts::DateTimeParts::ArrayData = vortex_datetime_parts::DateTimePartsData
 
-impl core::convert::From<vortex_datetime_parts::DateTimePartsArray> for vortex_array::array::ArrayRef
+pub type vortex_datetime_parts::DateTimeParts::OperationsVTable = vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_datetime_parts::DateTimePartsArray) -> vortex_array::array::ArrayRef
+pub type vortex_datetime_parts::DateTimeParts::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-impl core::convert::TryFrom<vortex_array::arrays::datetime::TemporalArray> for vortex_datetime_parts::DateTimePartsArray
+pub fn vortex_datetime_parts::DateTimeParts::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_datetime_parts::DateTimePartsArray::Error = vortex_error::VortexError
+pub fn vortex_datetime_parts::DateTimeParts::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_datetime_parts::DateTimePartsArray::try_from(array: vortex_array::arrays::datetime::TemporalArray) -> core::result::Result<Self, Self::Error>
+pub fn vortex_datetime_parts::DateTimeParts::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsArray
+pub fn vortex_datetime_parts::DateTimeParts::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_datetime_parts::DateTimePartsArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_datetime_parts::DateTimeParts::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::ops::deref::Deref for vortex_datetime_parts::DateTimePartsArray
+pub fn vortex_datetime_parts::DateTimeParts::id(&self) -> vortex_array::array::ArrayId
 
-pub type vortex_datetime_parts::DateTimePartsArray::Target = dyn vortex_array::array::Array
+pub fn vortex_datetime_parts::DateTimeParts::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_datetime_parts::DateTimePartsArray::deref(&self) -> &Self::Target
+pub fn vortex_datetime_parts::DateTimeParts::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_datetime_parts::DateTimePartsArray
+pub fn vortex_datetime_parts::DateTimeParts::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_datetime_parts::DateTimePartsArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_datetime_parts::DateTimeParts::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_datetime_parts::DateTimePartsArrayParts
+pub fn vortex_datetime_parts::DateTimeParts::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_datetime_parts::DateTimePartsArrayParts::days: vortex_array::array::ArrayRef
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_datetime_parts::DateTimeParts> for vortex_datetime_parts::DateTimeParts
 
-pub vortex_datetime_parts::DateTimePartsArrayParts::dtype: vortex_array::dtype::DType
+pub fn vortex_datetime_parts::DateTimeParts::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_datetime_parts::DateTimeParts>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_datetime_parts::DateTimePartsArrayParts::seconds: vortex_array::array::ArrayRef
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_datetime_parts::DateTimeParts> for vortex_datetime_parts::DateTimeParts
 
-pub vortex_datetime_parts::DateTimePartsArrayParts::subseconds: vortex_array::array::ArrayRef
+pub fn vortex_datetime_parts::DateTimeParts::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_datetime_parts::DateTimeParts>) -> vortex_array::array::erased::ArrayRef
 
-impl core::clone::Clone for vortex_datetime_parts::DateTimePartsArrayParts
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArrayParts::clone(&self) -> vortex_datetime_parts::DateTimePartsArrayParts
+pub fn vortex_datetime_parts::DateTimeParts::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsArrayParts
+impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsArrayParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_datetime_parts::DateTimeParts::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-#[repr(C)] pub struct vortex_datetime_parts::DateTimePartsMetadata
-
-pub vortex_datetime_parts::DateTimePartsMetadata::days_ptype: i32
-
-pub vortex_datetime_parts::DateTimePartsMetadata::seconds_ptype: i32
-
-pub vortex_datetime_parts::DateTimePartsMetadata::subseconds_ptype: i32
-
-impl vortex_datetime_parts::DateTimePartsMetadata
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::days_ptype(&self) -> vortex_array::dtype::ptype::PType
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::seconds_ptype(&self) -> vortex_array::dtype::ptype::PType
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::set_days_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::set_seconds_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::set_subseconds_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::subseconds_ptype(&self) -> vortex_array::dtype::ptype::PType
-
-impl vortex_datetime_parts::DateTimePartsMetadata
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::get_days_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::get_seconds_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::get_subseconds_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
-
-impl core::clone::Clone for vortex_datetime_parts::DateTimePartsMetadata
-
-pub fn vortex_datetime_parts::DateTimePartsMetadata::clone(&self) -> vortex_datetime_parts::DateTimePartsMetadata
-
-impl core::default::Default for vortex_datetime_parts::DateTimePartsMetadata
+impl vortex_array::arrays::slice::SliceReduce for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsMetadata::default() -> Self
+pub fn vortex_datetime_parts::DateTimeParts::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsMetadata
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_datetime_parts::DateTimeParts::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl prost::message::Message for vortex_datetime_parts::DateTimePartsMetadata
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_datetime_parts::DateTimeParts
 
-pub fn vortex_datetime_parts::DateTimePartsMetadata::clear(&mut self)
+pub fn vortex_datetime_parts::DateTimeParts::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_datetime_parts::DateTimePartsMetadata::encoded_len(&self) -> usize
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_datetime_parts::DateTimeParts
 
-pub struct vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimeParts::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_datetime_parts::DateTimePartsVTable
+pub struct vortex_datetime_parts::DateTimePartsData
 
-pub const vortex_datetime_parts::DateTimePartsVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_datetime_parts::DateTimePartsData
 
-impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimePartsData::validate(dtype: &vortex_array::dtype::DType, days: &vortex_array::array::erased::ArrayRef, seconds: &vortex_array::array::erased::ArrayRef, subseconds: &vortex_array::array::erased::ArrayRef, len: usize) -> vortex_error::VortexResult<()>
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_datetime_parts::DateTimePartsData
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimePartsData::clone(&self) -> vortex_datetime_parts::DateTimePartsData
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::take(array: &vortex_datetime_parts::DateTimePartsArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::convert::TryFrom<vortex_array::arrays::datetime::TemporalData> for vortex_datetime_parts::DateTimePartsData
 
-impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_datetime_parts::DateTimePartsVTable
+pub type vortex_datetime_parts::DateTimePartsData::Error = vortex_error::VortexError
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::filter(array: &vortex_datetime_parts::DateTimePartsArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_datetime_parts::DateTimePartsData::try_from(array: vortex_array::arrays::datetime::TemporalArray) -> core::result::Result<Self, Self::Error>
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_datetime_parts::DateTimePartsVTable
+impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsData
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_datetime_parts::DateTimePartsData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::is_constant::IsConstantKernel for vortex_datetime_parts::DateTimePartsVTable
+impl core::fmt::Display for vortex_datetime_parts::DateTimePartsData
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::is_constant(&self, array: &vortex_datetime_parts::DateTimePartsArray, opts: &vortex_array::compute::is_constant::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_datetime_parts::DateTimePartsData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_datetime_parts::DateTimePartsVTable
+impl vortex_array::hash::ArrayEq for vortex_datetime_parts::DateTimePartsData
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::compare(lhs: &vortex_datetime_parts::DateTimePartsArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_datetime_parts::DateTimePartsData::array_eq(&self, _other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_datetime_parts::DateTimePartsVTable
+impl vortex_array::hash::ArrayHash for vortex_datetime_parts::DateTimePartsData
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::cast(array: &vortex_datetime_parts::DateTimePartsArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_datetime_parts::DateTimePartsData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::hash::Precision)
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_datetime_parts::DateTimePartsVTable
+#[repr(C)] pub struct vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::mask(array: &vortex_datetime_parts::DateTimePartsArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_datetime_parts::DateTimePartsMetadata::days_ptype: i32
 
-impl vortex_array::vtable::VTable for vortex_datetime_parts::DateTimePartsVTable
+pub vortex_datetime_parts::DateTimePartsMetadata::seconds_ptype: i32
 
-pub type vortex_datetime_parts::DateTimePartsVTable::Array = vortex_datetime_parts::DateTimePartsArray
+pub vortex_datetime_parts::DateTimePartsMetadata::subseconds_ptype: i32
 
-pub type vortex_datetime_parts::DateTimePartsVTable::ArrayVTable = vortex_datetime_parts::DateTimePartsVTable
+impl vortex_datetime_parts::DateTimePartsMetadata
 
-pub type vortex_datetime_parts::DateTimePartsVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_datetime_parts::DateTimePartsMetadata>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::days_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub type vortex_datetime_parts::DateTimePartsVTable::OperationsVTable = vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimePartsMetadata::seconds_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub type vortex_datetime_parts::DateTimePartsVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub fn vortex_datetime_parts::DateTimePartsMetadata::set_days_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub type vortex_datetime_parts::DateTimePartsVTable::VisitorVTable = vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimePartsMetadata::set_seconds_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_datetime_parts::DateTimePartsArray>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::set_subseconds_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::subseconds_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::get_days_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_datetime_parts::DateTimePartsMetadata::get_seconds_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::metadata(array: &vortex_datetime_parts::DateTimePartsArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::get_subseconds_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::clone(&self) -> vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl core::default::Default for vortex_datetime_parts::DateTimePartsMetadata
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_datetime_parts::DateTimePartsVTable> for vortex_datetime_parts::DateTimePartsVTable
+pub fn vortex_datetime_parts::DateTimePartsMetadata::default() -> Self
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::array_eq(array: &vortex_datetime_parts::DateTimePartsArray, other: &vortex_datetime_parts::DateTimePartsArray, precision: vortex_array::hash::Precision) -> bool
+impl core::fmt::Debug for vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::array_hash<H: core::hash::Hasher>(array: &vortex_datetime_parts::DateTimePartsArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_datetime_parts::DateTimePartsMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::dtype(array: &vortex_datetime_parts::DateTimePartsArray) -> &vortex_array::dtype::DType
+impl prost::message::Message for vortex_datetime_parts::DateTimePartsMetadata
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::len(array: &vortex_datetime_parts::DateTimePartsArray) -> usize
+pub fn vortex_datetime_parts::DateTimePartsMetadata::clear(&mut self)
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::stats(array: &vortex_datetime_parts::DateTimePartsArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_datetime_parts::DateTimePartsMetadata::encoded_len(&self) -> usize
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_datetime_parts::DateTimePartsVTable> for vortex_datetime_parts::DateTimePartsVTable
+pub struct vortex_datetime_parts::TemporalParts
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::scalar_at(array: &vortex_datetime_parts::DateTimePartsArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub vortex_datetime_parts::TemporalParts::days: vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_datetime_parts::DateTimePartsVTable> for vortex_datetime_parts::DateTimePartsVTable
+pub vortex_datetime_parts::TemporalParts::seconds: vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::validity_child(array: &vortex_datetime_parts::DateTimePartsArray) -> &vortex_array::array::ArrayRef
+pub vortex_datetime_parts::TemporalParts::subseconds: vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_datetime_parts::DateTimePartsVTable> for vortex_datetime_parts::DateTimePartsVTable
+pub trait vortex_datetime_parts::DateTimePartsArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::nbuffers(_array: &vortex_datetime_parts::DateTimePartsArray) -> usize
+pub fn vortex_datetime_parts::DateTimePartsArrayExt::days(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::nchildren(_array: &vortex_datetime_parts::DateTimePartsArray) -> usize
+pub fn vortex_datetime_parts::DateTimePartsArrayExt::seconds(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::visit_buffers(_array: &vortex_datetime_parts::DateTimePartsArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_datetime_parts::DateTimePartsArrayExt::subseconds(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_datetime_parts::DateTimePartsVTable::visit_children(array: &vortex_datetime_parts::DateTimePartsArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_datetime_parts::DateTimeParts>> vortex_datetime_parts::DateTimePartsArrayExt for T
 
-pub struct vortex_datetime_parts::TemporalParts
+pub fn T::days(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub vortex_datetime_parts::TemporalParts::days: vortex_array::array::ArrayRef
+pub fn T::seconds(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub vortex_datetime_parts::TemporalParts::seconds: vortex_array::array::ArrayRef
+pub fn T::subseconds(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub vortex_datetime_parts::TemporalParts::subseconds: vortex_array::array::ArrayRef
+pub fn vortex_datetime_parts::initialize(session: &vortex_session::VortexSession)
 
 pub fn vortex_datetime_parts::split_temporal(array: vortex_array::arrays::datetime::TemporalArray) -> vortex_error::VortexResult<vortex_datetime_parts::TemporalParts>
+
+pub type vortex_datetime_parts::DateTimePartsArray = vortex_array::array::typed::Array<vortex_datetime_parts::DateTimeParts>
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
index 8a500944108..f66bd2b742a 100644
--- a/encodings/datetime-parts/src/array.rs
+++ b/encodings/datetime-parts/src/array.rs
@@ -2,46 +2,58 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
 
+use prost::Message;
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::TypedArrayRef;
+use vortex_array::arrays::TemporalArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
 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_error::vortex_panic;
 use vortex_session::VortexSession;
 
+use crate::TemporalParts;
 use crate::canonical::decode_to_temporal;
 use crate::compute::kernel::PARENT_KERNELS;
 use crate::compute::rules::PARENT_RULES;
+use crate::split_temporal;
 
-vtable!(DateTimeParts);
+/// A [`DateTimeParts`]-encoded Vortex array.
+pub type DateTimePartsArray = Array<DateTimeParts>;
+
+impl ArrayHash for DateTimePartsData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
+
+impl ArrayEq for DateTimePartsData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
 
 #[derive(Clone, prost::Message)]
 #[repr(C)]
@@ -73,51 +85,71 @@ impl DateTimePartsMetadata {
     }
 }
 
-impl VTable for DateTimePartsVTable {
-    type Array = DateTimePartsArray;
-
-    type Metadata = ProstMetadata<DateTimePartsMetadata>;
+impl VTable for DateTimeParts {
+    type ArrayData = DateTimePartsData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &DateTimePartsArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DateTimePartsMetadata {
-            days_ptype: PType::try_from(array.days().dtype())? as i32,
-            seconds_ptype: PType::try_from(array.seconds().dtype())? as i32,
-            subseconds_ptype: PType::try_from(array.subseconds().dtype())? as i32,
-        }))
+    fn validate(
+        &self,
+        _data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let days = slots[DAYS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray days slot");
+        let seconds = slots[SECONDS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray seconds slot");
+        let subseconds = slots[SUBSECONDS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray subseconds slot");
+        DateTimePartsData::validate(dtype, days, seconds, subseconds, len)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("DateTimePartsArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("DateTimePartsArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<DateTimePartsMetadata> as DeserializeMetadata>::deserialize(bytes)?,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            DateTimePartsMetadata {
+                days_ptype: PType::try_from(array.days().dtype())? as i32,
+                seconds_ptype: PType::try_from(array.seconds().dtype())? as i32,
+                subseconds_ptype: PType::try_from(array.subseconds().dtype())? as i32,
+            }
+            .encode_to_vec(),
         ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<DateTimePartsArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = DateTimePartsMetadata::decode(metadata)?;
         if children.len() != 3 {
             vortex_bail!(
                 "Expected 3 children for datetime-parts encoding, found {}",
@@ -127,44 +159,37 @@ impl VTable for DateTimePartsVTable {
 
         let days = children.get(
             0,
-            &DType::Primitive(metadata.0.get_days_ptype()?, dtype.nullability()),
+            &DType::Primitive(metadata.get_days_ptype()?, dtype.nullability()),
             len,
         )?;
         let seconds = children.get(
             1,
-            &DType::Primitive(metadata.0.get_seconds_ptype()?, Nullability::NonNullable),
+            &DType::Primitive(metadata.get_seconds_ptype()?, Nullability::NonNullable),
             len,
         )?;
         let subseconds = children.get(
             2,
-            &DType::Primitive(metadata.0.get_subseconds_ptype()?, Nullability::NonNullable),
+            &DType::Primitive(metadata.get_subseconds_ptype()?, Nullability::NonNullable),
             len,
         )?;
 
-        DateTimePartsArray::try_new(dtype.clone(), days, seconds, subseconds)
+        let slots = vec![Some(days), Some(seconds), Some(subseconds)];
+        let data = DateTimePartsData {};
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 3,
-            "DateTimePartsArray expects exactly 3 children (days, seconds, subseconds), got {}",
-            children.len()
-        );
-
-        let mut children_iter = children.into_iter();
-        array.days = children_iter.next().vortex_expect("checked");
-        array.seconds = children_iter.next().vortex_expect("checked");
-        array.subseconds = children_iter.next().vortex_expect("checked");
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(decode_to_temporal(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            decode_to_temporal(&array, ctx)?.into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -172,7 +197,7 @@ impl VTable for DateTimePartsVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -181,37 +206,92 @@ impl VTable for DateTimePartsVTable {
     }
 }
 
+/// The days component of the datetime, stored as an integer array.
+pub(super) const DAYS_SLOT: usize = 0;
+/// The seconds component of the datetime (within the day).
+pub(super) const SECONDS_SLOT: usize = 1;
+/// The sub-second component of the datetime.
+pub(super) const SUBSECONDS_SLOT: usize = 2;
+pub(super) const NUM_SLOTS: usize = 3;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["days", "seconds", "subseconds"];
+
 #[derive(Clone, Debug)]
-pub struct DateTimePartsArray {
-    dtype: DType,
-    days: ArrayRef,
-    seconds: ArrayRef,
-    subseconds: ArrayRef,
-    stats_set: ArrayStats,
+pub struct DateTimePartsData {}
+
+impl Display for DateTimePartsData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
 }
 
-#[derive(Clone, Debug)]
-pub struct DateTimePartsArrayParts {
-    pub dtype: DType,
-    pub days: ArrayRef,
-    pub seconds: ArrayRef,
-    pub subseconds: ArrayRef,
+pub trait DateTimePartsArrayExt: TypedArrayRef<DateTimeParts> {
+    fn days(&self) -> &ArrayRef {
+        self.as_ref().slots()[DAYS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray days slot")
+    }
+
+    fn seconds(&self) -> &ArrayRef {
+        self.as_ref().slots()[SECONDS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray seconds slot")
+    }
+
+    fn subseconds(&self) -> &ArrayRef {
+        self.as_ref().slots()[SUBSECONDS_SLOT]
+            .as_ref()
+            .vortex_expect("DateTimePartsArray subseconds slot")
+    }
 }
 
-#[derive(Debug)]
-pub struct DateTimePartsVTable;
+impl<T: TypedArrayRef<DateTimeParts>> DateTimePartsArrayExt for T {}
+
+#[derive(Clone, Debug)]
+pub struct DateTimeParts;
 
-impl DateTimePartsVTable {
+impl DateTimeParts {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.datetimeparts");
-}
 
-impl DateTimePartsArray {
+    /// Construct a new [`DateTimePartsArray`] from its components.
     pub fn try_new(
         dtype: DType,
         days: ArrayRef,
         seconds: ArrayRef,
         subseconds: ArrayRef,
-    ) -> VortexResult<Self> {
+    ) -> VortexResult<DateTimePartsArray> {
+        let len = days.len();
+        DateTimePartsData::validate(&dtype, &days, &seconds, &subseconds, len)?;
+        let slots = vec![Some(days), Some(seconds), Some(subseconds)];
+        let data = DateTimePartsData {};
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(DateTimeParts, dtype, len, data).with_slots(slots),
+            )
+        })
+    }
+
+    /// Construct a [`DateTimePartsArray`] from a [`TemporalArray`].
+    pub fn try_from_temporal(temporal: TemporalArray) -> VortexResult<DateTimePartsArray> {
+        let dtype = temporal.dtype().clone();
+        let TemporalParts {
+            days,
+            seconds,
+            subseconds,
+        } = split_temporal(temporal)?;
+        Self::try_new(dtype, days, seconds, subseconds)
+    }
+}
+
+impl DateTimePartsData {
+    pub fn validate(
+        dtype: &DType,
+        days: &ArrayRef,
+        seconds: &ArrayRef,
+        subseconds: &ArrayRef,
+        len: usize,
+    ) -> VortexResult<()> {
+        vortex_ensure!(days.len() == len, "expected len {len}, got {}", days.len());
+
         if !days.dtype().is_int() || (dtype.is_nullable() != days.dtype().is_nullable()) {
             vortex_bail!(
                 "Expected integer with nullability {}, got {}",
@@ -226,8 +306,7 @@ impl DateTimePartsArray {
             vortex_bail!(MismatchedTypes: "non-nullable integer", subseconds.dtype());
         }
 
-        let length = days.len();
-        if length != seconds.len() || length != subseconds.len() {
+        if len != seconds.len() || len != subseconds.len() {
             vortex_bail!(
                 "Mismatched lengths {} {} {}",
                 days.len(),
@@ -236,108 +315,12 @@ impl DateTimePartsArray {
             );
         }
 
-        Ok(Self {
-            dtype,
-            days,
-            seconds,
-            subseconds,
-            stats_set: Default::default(),
-        })
-    }
-
-    pub(crate) unsafe fn new_unchecked(
-        dtype: DType,
-        days: ArrayRef,
-        seconds: ArrayRef,
-        subseconds: ArrayRef,
-    ) -> Self {
-        Self {
-            dtype,
-            days,
-            seconds,
-            subseconds,
-            stats_set: Default::default(),
-        }
-    }
-
-    pub fn into_parts(self) -> DateTimePartsArrayParts {
-        DateTimePartsArrayParts {
-            dtype: self.dtype,
-            days: self.days,
-            seconds: self.seconds,
-            subseconds: self.subseconds,
-        }
-    }
-
-    pub fn days(&self) -> &ArrayRef {
-        &self.days
-    }
-
-    pub fn seconds(&self) -> &ArrayRef {
-        &self.seconds
-    }
-
-    pub fn subseconds(&self) -> &ArrayRef {
-        &self.subseconds
-    }
-}
-
-impl BaseArrayVTable<DateTimePartsVTable> for DateTimePartsVTable {
-    fn len(array: &DateTimePartsArray) -> usize {
-        array.days.len()
-    }
-
-    fn dtype(array: &DateTimePartsArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &DateTimePartsArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &DateTimePartsArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.days.array_hash(state, precision);
-        array.seconds.array_hash(state, precision);
-        array.subseconds.array_hash(state, precision);
-    }
-
-    fn array_eq(
-        array: &DateTimePartsArray,
-        other: &DateTimePartsArray,
-        precision: Precision,
-    ) -> bool {
-        array.dtype == other.dtype
-            && array.days.array_eq(&other.days, precision)
-            && array.seconds.array_eq(&other.seconds, precision)
-            && array.subseconds.array_eq(&other.subseconds, precision)
-    }
-}
-
-impl ValidityChild<DateTimePartsVTable> for DateTimePartsVTable {
-    fn validity_child(array: &DateTimePartsArray) -> &ArrayRef {
-        array.days()
+        Ok(())
     }
 }
 
-impl VisitorVTable<DateTimePartsVTable> for DateTimePartsVTable {
-    fn visit_buffers(_array: &DateTimePartsArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &DateTimePartsArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &DateTimePartsArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("days", array.days());
-        visitor.visit_child("seconds", array.seconds());
-        visitor.visit_child("subseconds", array.subseconds());
-    }
-
-    fn nchildren(_array: &DateTimePartsArray) -> usize {
-        3
+impl ValidityChild<DateTimeParts> for DateTimeParts {
+    fn validity_child(array: ArrayView<'_, DateTimeParts>) -> ArrayRef {
+        array.days().clone()
     }
 }
diff --git a/encodings/datetime-parts/src/canonical.rs b/encodings/datetime-parts/src/canonical.rs
index 06c943bf266..f1d1aaf6914 100644
--- a/encodings/datetime-parts/src/canonical.rs
+++ b/encodings/datetime-parts/src/canonical.rs
@@ -19,6 +19,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::DateTimePartsArray;
+use crate::array::DateTimePartsArrayExt;
 
 /// Decode an [Array] into a [TemporalArray].
 ///
@@ -54,7 +55,7 @@ pub fn decode_to_temporal(
     // We split this into separate passes because often the seconds and/org subseconds components
     // are constant.
     let mut values: BufferMut<i64> = days_buf
-        .into_buffer_mut::<i64>()
+        .into_buffer::<i64>()
         .map_each_in_place(|d| d * 86_400 * divisor);
 
     if let Some(seconds) = array.seconds().as_constant() {
@@ -95,8 +96,11 @@ pub fn decode_to_temporal(
     }
 
     Ok(TemporalArray::new_timestamp(
-        PrimitiveArray::new(values.freeze(), Validity::copy_from_array(array.as_ref())?)
-            .into_array(),
+        PrimitiveArray::new(
+            values.freeze(),
+            Validity::copy_from_array(&array.clone().into_array())?,
+        )
+        .into_array(),
         options.unit,
         options.tz.clone(),
     ))
@@ -107,18 +111,16 @@ mod test {
     use rstest::rstest;
     use vortex_array::ExecutionCtx;
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_array::validity::Validity;
-    use vortex_array::vtable::ValidityHelper;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
-    use crate::DateTimePartsArray;
+    use crate::DateTimeParts;
     use crate::canonical::decode_to_temporal;
 
     #[rstest]
@@ -138,25 +140,33 @@ mod test {
             ],
             validity.clone(),
         );
-        let date_times = DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+        let date_times = DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
             milliseconds.clone().into_array(),
             TimeUnit::Milliseconds,
             Some("UTC".into()),
-        ))
-        .unwrap();
+        ))?;
 
-        assert_eq!(
-            date_times.validity_mask().unwrap(),
-            validity.to_mask(date_times.len())
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+
+        assert!(
+            date_times
+                .as_array()
+                .validity()?
+                .mask_eq(&validity, &mut ctx)?
         );
 
-        let mut ctx = ExecutionCtx::new(VortexSession::empty());
         let primitive_values = decode_to_temporal(&date_times, &mut ctx)?
             .temporal_values()
-            .to_primitive();
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)?;
 
         assert_arrays_eq!(primitive_values, milliseconds);
-        assert_eq!(primitive_values.validity(), &validity);
+        assert!(
+            primitive_values
+                .validity()
+                .unwrap()
+                .mask_eq(&validity, &mut ctx)?
+        );
         Ok(())
     }
 }
diff --git a/encodings/datetime-parts/src/compress.rs b/encodings/datetime-parts/src/compress.rs
index 8ef0c760546..2edb6097c7b 100644
--- a/encodings/datetime-parts/src/compress.rs
+++ b/encodings/datetime-parts/src/compress.rs
@@ -9,14 +9,12 @@ use vortex_array::arrays::TemporalArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::PType;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
+use crate::DateTimePartsData;
 use crate::timestamp;
-
 pub struct TemporalParts {
     pub days: ArrayRef,
     pub seconds: ArrayRef,
@@ -32,7 +30,8 @@ pub fn split_temporal(array: TemporalArray) -> VortexResult<TemporalParts> {
 
     // After this operation, timestamps will be a PrimitiveArray<i64>
     let timestamps = temporal_values
-        .to_array()
+        .clone()
+        .into_array()
         .cast(DType::Primitive(
             PType::I64,
             temporal_values.dtype().nullability(),
@@ -52,13 +51,13 @@ pub fn split_temporal(array: TemporalArray) -> VortexResult<TemporalParts> {
     }
 
     Ok(TemporalParts {
-        days: PrimitiveArray::new(days, temporal_values.validity().clone()).into_array(),
+        days: PrimitiveArray::new(days, temporal_values.validity()?).into_array(),
         seconds: seconds.into_array(),
         subseconds: subseconds.into_array(),
     })
 }
 
-impl TryFrom<TemporalArray> for DateTimePartsArray {
+impl TryFrom<TemporalArray> for DateTimePartsData {
     type Error = VortexError;
 
     fn try_from(array: TemporalArray) -> Result<Self, Self::Error> {
@@ -68,7 +67,14 @@ impl TryFrom<TemporalArray> for DateTimePartsArray {
             seconds,
             subseconds,
         } = split_temporal(array)?;
-        DateTimePartsArray::try_new(DType::Extension(ext_dtype), days, seconds, subseconds)
+        DateTimePartsData::validate(
+            &DType::Extension(ext_dtype),
+            &days,
+            &seconds,
+            &subseconds,
+            days.len(),
+        )?;
+        Ok(DateTimePartsData {})
     }
 }
 
@@ -76,13 +82,15 @@ impl TryFrom<TemporalArray> for DateTimePartsArray {
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_array::validity::Validity;
-    use vortex_array::vtable::ValidityHelper;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
     use crate::TemporalParts;
     use crate::split_temporal;
@@ -109,8 +117,28 @@ mod tests {
             seconds,
             subseconds,
         } = split_temporal(temporal_array).unwrap();
-        assert_eq!(days.to_primitive().validity(), &validity);
-        assert_eq!(seconds.to_primitive().validity(), &Validity::NonNullable);
-        assert_eq!(subseconds.to_primitive().validity(), &Validity::NonNullable);
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(
+            days.to_primitive()
+                .validity()
+                .vortex_expect("days validity should be derivable")
+                .mask_eq(&validity, &mut ctx)
+                .unwrap()
+        );
+        assert!(matches!(
+            seconds
+                .to_primitive()
+                .validity()
+                .vortex_expect("seconds validity should be derivable"),
+            Validity::NonNullable
+        ));
+        assert!(matches!(
+            subseconds
+                .to_primitive()
+                .validity()
+                .vortex_expect("subseconds validity should be derivable"),
+            Validity::NonNullable
+        ));
     }
 }
diff --git a/encodings/datetime-parts/src/compute/cast.rs b/encodings/datetime-parts/src/compute/cast.rs
index ab103fdf8b1..0e56d594dcb 100644
--- a/encodings/datetime-parts/src/compute/cast.rs
+++ b/encodings/datetime-parts/src/compute/cast.rs
@@ -1,25 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
-
-impl CastReduce for DateTimePartsVTable {
-    fn cast(array: &DateTimePartsArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
+impl CastReduce for DateTimeParts {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !array.dtype().eq_ignore_nullability(dtype) {
             return Ok(None);
         };
 
         Ok(Some(
-            DateTimePartsArray::try_new(
+            DateTimeParts::try_new(
                 dtype.clone(),
                 array
                     .days()
@@ -35,7 +34,6 @@ impl CastReduce for DateTimePartsVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
@@ -47,10 +45,11 @@ mod tests {
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
+    use crate::DateTimeParts;
     use crate::DateTimePartsArray;
 
     fn date_time_array(validity: Validity) -> ArrayRef {
-        DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+        DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
             PrimitiveArray::new(
                 buffer![
                     86_400i64,            // element with only day component
@@ -105,7 +104,7 @@ mod tests {
     }
 
     #[rstest]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![
             0i64,
             86_400_000,  // 1 day in ms
@@ -116,7 +115,7 @@ mod tests {
         TimeUnit::Milliseconds,
         Some("UTC".into())
     )).unwrap())]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_option_iter([
             Some(0i64),
             None,
@@ -127,13 +126,13 @@ mod tests {
         TimeUnit::Milliseconds,
         Some("UTC".into())
     )).unwrap())]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![86_400_000_000_000i64].into_array(), // 1 day in ns
         TimeUnit::Nanoseconds,
         Some("UTC".into())
     )).unwrap())]
     fn test_cast_datetime_parts_conformance(#[case] array: DateTimePartsArray) {
         use vortex_array::compute::conformance::cast::test_cast_conformance;
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/datetime-parts/src/compute/compare.rs b/encodings/datetime-parts/src/compute/compare.rs
index e3465472a8f..bd50a7a5d0f 100644
--- a/encodings/datetime-parts/src/compute/compare.rs
+++ b/encodings/datetime-parts/src/compute/compare.rs
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
@@ -16,14 +16,14 @@ use vortex_array::scalar_fn::fns::operators::CompareOperator;
 use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_error::VortexResult;
 
-use crate::array::DateTimePartsArray;
-use crate::array::DateTimePartsVTable;
+use crate::array::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 use crate::timestamp;
 
-impl CompareKernel for DateTimePartsVTable {
+impl CompareKernel for DateTimeParts {
     fn compare(
-        lhs: &DateTimePartsArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -67,7 +67,7 @@ impl CompareKernel for DateTimePartsVTable {
 }
 
 fn compare_eq(
-    lhs: &DateTimePartsArray,
+    lhs: ArrayView<DateTimeParts>,
     ts_parts: &timestamp::TimestampParts,
     nullability: Nullability,
 ) -> VortexResult<Option<ArrayRef>> {
@@ -102,7 +102,7 @@ fn compare_eq(
 }
 
 fn compare_ne(
-    lhs: &DateTimePartsArray,
+    lhs: ArrayView<DateTimeParts>,
     ts_parts: &timestamp::TimestampParts,
     nullability: Nullability,
 ) -> VortexResult<Option<ArrayRef>> {
@@ -142,7 +142,7 @@ fn compare_ne(
 }
 
 fn compare_lt(
-    lhs: &DateTimePartsArray,
+    lhs: ArrayView<DateTimeParts>,
     ts_parts: &timestamp::TimestampParts,
     nullability: Nullability,
 ) -> VortexResult<Option<ArrayRef>> {
@@ -156,7 +156,7 @@ fn compare_lt(
 }
 
 fn compare_gt(
-    lhs: &DateTimePartsArray,
+    lhs: ArrayView<DateTimeParts>,
     ts_parts: &timestamp::TimestampParts,
     nullability: Nullability,
 ) -> VortexResult<Option<ArrayRef>> {
@@ -170,7 +170,7 @@ fn compare_gt(
 }
 
 fn compare_dtp(
-    lhs: &dyn Array,
+    lhs: &ArrayRef,
     rhs: i64,
     operator: CompareOperator,
     nullability: Nullability,
@@ -180,7 +180,7 @@ fn compare_dtp(
         .into_array()
         .cast(lhs.dtype().with_nullability(nullability))
     {
-        Ok(casted) => lhs.to_array().binary(casted, Operator::from(operator)),
+        Ok(casted) => lhs.binary(casted, Operator::from(operator)),
         // The narrowing cast failed. Therefore, we know lhs < rhs.
         _ => {
             let constant_value = match operator {
@@ -206,12 +206,14 @@ mod test {
     use vortex_buffer::buffer;
 
     use super::*;
+    use crate::DateTimeParts;
+    use crate::DateTimePartsArray;
 
     fn dtp_array_from_timestamp<T: IntegerPType>(
         value: T,
         validity: Validity,
     ) -> DateTimePartsArray {
-        DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+        DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
             PrimitiveArray::new(buffer![value], validity).into_array(),
             TimeUnit::Seconds,
             Some("UTC".into()),
@@ -227,11 +229,18 @@ mod test {
     fn compare_date_time_parts_eq(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
         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.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let comparison = lhs
+            .clone()
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
 
         let rhs = dtp_array_from_timestamp(0i64, rhs_validity); // January 1, 1970, 00:00:00 UTC
-        let comparison = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let comparison = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
     }
 
@@ -244,15 +253,16 @@ mod test {
         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
-            .to_array()
-            .binary(rhs.to_array(), Operator::NotEq)
+            .clone()
+            .into_array()
+            .binary(rhs.into_array(), Operator::NotEq)
             .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
 
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity); // January 2, 1970, 00:00:00 UTC
         let comparison = lhs
-            .to_array()
-            .binary(rhs.to_array(), Operator::NotEq)
+            .into_array()
+            .binary(rhs.into_array(), Operator::NotEq)
             .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
     }
@@ -266,7 +276,10 @@ mod test {
         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
 
-        let comparison = lhs.to_array().binary(rhs.to_array(), Operator::Lt).unwrap();
+        let comparison = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Lt)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
     }
 
@@ -279,7 +292,10 @@ mod test {
         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
 
-        let comparison = lhs.to_array().binary(rhs.to_array(), Operator::Gt).unwrap();
+        let comparison = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Gt)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
     }
 
@@ -298,7 +314,7 @@ mod test {
             Some("UTC".into()),
         );
 
-        let lhs = DateTimePartsArray::try_new(
+        let lhs = DateTimeParts::try_new(
             DType::Extension(temporal_array.ext_dtype()),
             PrimitiveArray::new(buffer![0i32], lhs_validity).into_array(),
             PrimitiveArray::new(buffer![0u32], Validity::NonNullable).into_array(),
@@ -309,21 +325,30 @@ mod test {
         // Timestamp with a value larger than i32::MAX.
         let rhs = dtp_array_from_timestamp(i64::MAX, rhs_validity);
 
-        let comparison = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let comparison = lhs
+            .clone()
+            .into_array()
+            .binary(rhs.clone().into_array(), Operator::Eq)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
 
         let comparison = lhs
-            .to_array()
-            .binary(rhs.to_array(), Operator::NotEq)
+            .clone()
+            .into_array()
+            .binary(rhs.clone().into_array(), Operator::NotEq)
             .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
 
-        let comparison = lhs.to_array().binary(rhs.to_array(), Operator::Lt).unwrap();
+        let comparison = lhs
+            .clone()
+            .into_array()
+            .binary(rhs.clone().into_array(), Operator::Lt)
+            .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
 
         let comparison = lhs
-            .to_array()
-            .binary(rhs.to_array(), Operator::Lte)
+            .into_array()
+            .binary(rhs.into_array(), Operator::Lte)
             .unwrap();
         assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
 
diff --git a/encodings/datetime-parts/src/compute/filter.rs b/encodings/datetime-parts/src/compute/filter.rs
index 9e23264ad8b..d717d3d3500 100644
--- a/encodings/datetime-parts/src/compute/filter.rs
+++ b/encodings/datetime-parts/src/compute/filter.rs
@@ -2,18 +2,18 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterReduce;
+use vortex_array::arrays::filter::FilterReduce;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
-
-impl FilterReduce for DateTimePartsVTable {
-    fn filter(array: &DateTimePartsArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
+impl FilterReduce for DateTimeParts {
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            DateTimePartsArray::try_new(
+            DateTimeParts::try_new(
                 array.dtype().clone(),
                 array.days().filter(mask.clone())?,
                 array.seconds().filter(mask.clone())?,
@@ -33,7 +33,7 @@ mod test {
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_buffer::buffer;
 
-    use crate::DateTimePartsArray;
+    use crate::DateTimeParts;
 
     #[test]
     fn test_filter_datetime_parts() {
@@ -50,8 +50,8 @@ mod test {
         let temporal =
             TemporalArray::new_timestamp(timestamps, TimeUnit::Milliseconds, Some("UTC".into()));
 
-        let array = DateTimePartsArray::try_from(temporal).unwrap();
-        test_filter_conformance(array.as_ref());
+        let array = DateTimeParts::try_from_temporal(temporal).unwrap();
+        test_filter_conformance(&array.into_array());
 
         // Test with nullable values
         let timestamps = PrimitiveArray::from_option_iter([
@@ -66,7 +66,7 @@ mod test {
         let temporal =
             TemporalArray::new_timestamp(timestamps, TimeUnit::Milliseconds, Some("UTC".into()));
 
-        let array = DateTimePartsArray::try_from(temporal).unwrap();
-        test_filter_conformance(array.as_ref());
+        let array = DateTimeParts::try_from_temporal(temporal).unwrap();
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/encodings/datetime-parts/src/compute/is_constant.rs b/encodings/datetime-parts/src/compute/is_constant.rs
index f06583b4616..94e6806e785 100644
--- a/encodings/datetime-parts/src/compute/is_constant.rs
+++ b/encodings/datetime-parts/src/compute/is_constant.rs
@@ -1,45 +1,42 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::IsConstantKernel;
-use vortex_array::compute::IsConstantKernelAdapter;
-use vortex_array::compute::IsConstantOpts;
-use vortex_array::compute::is_constant_opts;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 
-impl IsConstantKernel for DateTimePartsVTable {
-    fn is_constant(
-        &self,
-        array: &DateTimePartsArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        let Some(days) = is_constant_opts(array.days().as_ref(), opts)? else {
-            return Ok(None);
-        };
-        if !days {
-            return Ok(Some(false));
-        }
+/// DateTimeParts-specific is_constant kernel.
+///
+/// Checks each component (days, seconds, subseconds) individually.
+#[derive(Debug)]
+pub(crate) struct DateTimePartsIsConstantKernel;
 
-        let Some(seconds) = is_constant_opts(array.seconds().as_ref(), opts)? else {
+impl DynAggregateKernel for DateTimePartsIsConstantKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
             return Ok(None);
-        };
-        if !seconds {
-            return Ok(Some(false));
         }
 
-        let Some(subseconds) = is_constant_opts(array.subseconds().as_ref(), opts)? else {
+        let Some(array) = batch.as_opt::<DateTimeParts>() else {
             return Ok(None);
         };
-        if !subseconds {
-            return Ok(Some(false));
-        }
 
-        Ok(Some(true))
+        let result = is_constant(array.days(), ctx)?
+            && is_constant(array.seconds(), ctx)?
+            && is_constant(array.subseconds(), ctx)?;
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
-
-register_kernel!(IsConstantKernelAdapter(DateTimePartsVTable).lift());
diff --git a/encodings/datetime-parts/src/compute/kernel.rs b/encodings/datetime-parts/src/compute/kernel.rs
index 93fad338ae1..e07f1d00f38 100644
--- a/encodings/datetime-parts/src/compute/kernel.rs
+++ b/encodings/datetime-parts/src/compute/kernel.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
 
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<DateTimePartsVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(DateTimePartsVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DateTimePartsVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<DateTimeParts> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(DateTimeParts)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(DateTimeParts)),
 ]);
diff --git a/encodings/datetime-parts/src/compute/mask.rs b/encodings/datetime-parts/src/compute/mask.rs
index fb62aaed78a..de737105ffe 100644
--- a/encodings/datetime-parts/src/compute/mask.rs
+++ b/encodings/datetime-parts/src/compute/mask.rs
@@ -2,27 +2,26 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsArrayParts;
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 
-impl MaskReduce for DateTimePartsVTable {
-    fn mask(array: &DateTimePartsArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
-        let DateTimePartsArrayParts {
-            dtype,
-            days,
-            seconds,
-            subseconds,
-        } = array.clone().into_parts();
-        let masked_days = days.mask(mask.clone())?;
+impl MaskReduce for DateTimeParts {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+        let masked_days = array.days().clone().mask(mask.clone())?;
         Ok(Some(
-            DateTimePartsArray::try_new(dtype.as_nullable(), masked_days, seconds, subseconds)?
-                .into_array(),
+            DateTimeParts::try_new(
+                array.dtype().as_nullable(),
+                masked_days,
+                array.seconds().clone(),
+                array.subseconds().clone(),
+            )?
+            .into_array(),
         ))
     }
 }
diff --git a/encodings/datetime-parts/src/compute/mod.rs b/encodings/datetime-parts/src/compute/mod.rs
index 56347262fd8..53717a52b0c 100644
--- a/encodings/datetime-parts/src/compute/mod.rs
+++ b/encodings/datetime-parts/src/compute/mod.rs
@@ -4,7 +4,7 @@
 mod cast;
 mod compare;
 mod filter;
-mod is_constant;
+pub(crate) mod is_constant;
 pub(crate) mod kernel;
 mod mask;
 pub(super) mod rules;
@@ -21,56 +21,61 @@ mod tests {
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_buffer::buffer;
 
+    use crate::DateTimeParts;
     use crate::DateTimePartsArray;
 
+    fn dtp_from_temporal(temporal: TemporalArray) -> DateTimePartsArray {
+        DateTimeParts::try_from_temporal(temporal).unwrap()
+    }
+
     #[rstest]
     // Basic datetime arrays
-    #[case::datetime_seconds(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case::datetime_seconds(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![0i64, 86400, 172800, 259200, 345600].into_array(),
         TimeUnit::Seconds,
         Some("UTC".into()),
-    )).unwrap())]
-    #[case::datetime_millis(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    )))]
+    #[case::datetime_millis(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![0i64, 86400000, 172800000].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into()),
-    )).unwrap())]
-    #[case::datetime_micros(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    )))]
+    #[case::datetime_micros(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![0i64, 86400000000, 172800000000].into_array(),
         TimeUnit::Microseconds,
         Some("UTC".into()),
-    )).unwrap())]
-    #[case::datetime_nanos(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    )))]
+    #[case::datetime_nanos(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![0i64, 86400000000000].into_array(),
         TimeUnit::Nanoseconds,
         Some("UTC".into()),
-    )).unwrap())]
+    )))]
     // Nullable arrays
-    #[case::datetime_nullable_seconds(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case::datetime_nullable_seconds(dtp_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_option_iter([Some(0i64), None, Some(86400), Some(172800), None]).into_array(),
         TimeUnit::Seconds,
         Some("UTC".into()),
-    )).unwrap())]
+    )))]
     // Edge cases
-    #[case::datetime_single(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case::datetime_single(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![1234567890i64].into_array(),
         TimeUnit::Seconds,
         Some("UTC".into()),
-    )).unwrap())]
+    )))]
     // Large arrays (> 1024 elements)
-    #[case::datetime_large(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case::datetime_large(dtp_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_iter((0..1500).map(|i| i as i64 * 86400)).into_array(),
         TimeUnit::Seconds,
         Some("UTC".into()),
-    )).unwrap())]
+    )))]
     // Different time patterns
-    #[case::datetime_with_subseconds(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case::datetime_with_subseconds(dtp_from_temporal(TemporalArray::new_timestamp(
         buffer![123456789i64, 234567890, 345678901, 456789012, 567890123].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into()),
-    )).unwrap())]
+    )))]
 
     fn test_datetime_parts_consistency(#[case] array: DateTimePartsArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/datetime-parts/src/compute/rules.rs b/encodings/datetime-parts/src/compute/rules.rs
index a4345556f67..c18d959cd7e 100644
--- a/encodings/datetime-parts/src/compute/rules.rs
+++ b/encodings/datetime-parts/src/compute/rules.rs
@@ -1,17 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::AnyScalarFn;
+use vortex_array::arrays::Constant;
 use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::ConstantVTable;
-use vortex_array::arrays::FilterArray;
-use vortex_array::arrays::FilterReduceAdaptor;
-use vortex_array::arrays::FilterVTable;
+use vortex_array::arrays::Filter;
 use vortex_array::arrays::ScalarFnArray;
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::filter::FilterReduceAdaptor;
+use vortex_array::arrays::scalar_fn::AnyScalarFn;
+use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
+use vortex_array::arrays::scalar_fn::ScalarFnVTable;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::extension::datetime::Timestamp;
@@ -25,17 +26,16 @@ use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 use crate::timestamp;
-
-pub(crate) const PARENT_RULES: ParentRuleSet<DateTimePartsVTable> = ParentRuleSet::new(&[
+pub(crate) const PARENT_RULES: ParentRuleSet<DateTimeParts> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&DTPFilterPushDownRule),
     ParentRuleSet::lift(&DTPComparisonPushDownRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(DateTimePartsVTable)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(DateTimePartsVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DateTimePartsVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DateTimePartsVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(DateTimeParts)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(DateTimeParts)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(DateTimeParts)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(DateTimeParts)),
 ]);
 
 /// Push the filter into the days column of a date time parts, we could extend this to other fields
@@ -43,22 +43,22 @@ pub(crate) const PARENT_RULES: ParentRuleSet<DateTimePartsVTable> = ParentRuleSe
 #[derive(Debug)]
 struct DTPFilterPushDownRule;
 
-impl ArrayParentReduceRule<DateTimePartsVTable> for DTPFilterPushDownRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<DateTimeParts> for DTPFilterPushDownRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &DateTimePartsArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, DateTimeParts>,
+        parent: ArrayView<'_, Filter>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         debug_assert_eq!(child_idx, 0);
 
-        if !child.seconds().is::<ConstantVTable>() || !child.subseconds().is::<ConstantVTable>() {
+        if !child.seconds().is::<Constant>() || !child.subseconds().is::<Constant>() {
             return Ok(None);
         }
 
-        DateTimePartsArray::try_new(
+        DateTimeParts::try_new(
             child.dtype().clone(),
             child.days().clone().filter(parent.filter_mask().clone())?,
             ConstantArray::new(
@@ -89,13 +89,13 @@ impl ArrayParentReduceRule<DateTimePartsVTable> for DTPFilterPushDownRule {
 #[derive(Debug)]
 struct DTPComparisonPushDownRule;
 
-impl ArrayParentReduceRule<DateTimePartsVTable> for DTPComparisonPushDownRule {
+impl ArrayParentReduceRule<DateTimeParts> for DTPComparisonPushDownRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        child: &DateTimePartsArray,
-        parent: &ScalarFnArray,
+        child: ArrayView<'_, DateTimeParts>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // Only handle comparison operations (Binary comparisons or Between)
@@ -113,12 +113,11 @@ impl ArrayParentReduceRule<DateTimePartsVTable> for DTPComparisonPushDownRule {
             return Ok(None);
         }
 
-        let children = parent.children();
         let days = child.days();
 
         // Build new children: replace DTP with days, replace constant timestamps with days constants
-        let mut new_children = Vec::with_capacity(children.len());
-        for (idx, c) in children.iter().enumerate() {
+        let mut new_children = Vec::with_capacity(parent.nchildren());
+        for (idx, c) in parent.iter_children().enumerate() {
             if idx == child_idx {
                 // This is the DTP child - replace with days
                 new_children.push(days.clone());
@@ -174,15 +173,15 @@ fn try_extract_days_constant(array: &ArrayRef) -> Option<i64> {
 /// Check if an array is a constant with value zero.
 fn is_constant_zero(array: &ArrayRef) -> bool {
     array
-        .as_opt::<ConstantVTable>()
+        .as_opt::<Constant>()
         .is_some_and(|c| c.scalar().is_zero() == Some(true))
 }
 
 #[cfg(test)]
 mod tests {
     use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::arrays::ScalarFnArrayExt;
     use vortex_array::arrays::TemporalArray;
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_array::extension::datetime::TimestampOptions;
     use vortex_array::optimizer::ArrayOptimizer;
@@ -194,6 +193,8 @@ mod tests {
     use vortex_buffer::Buffer;
 
     use super::*;
+    use crate::DateTimeParts;
+    use crate::DateTimePartsArray;
 
     const SECONDS_PER_DAY: i64 = 86400;
 
@@ -216,7 +217,8 @@ mod tests {
             time_unit,
             None,
         );
-        DateTimePartsArray::try_from(temporal).unwrap()
+        DateTimeParts::try_from_temporal(temporal)
+            .vortex_expect("TemporalArray must produce valid DateTimeParts")
     }
 
     /// Create a constant timestamp scalar at midnight for the given day.
@@ -276,7 +278,7 @@ mod tests {
 
         // The result should be a ScalarFn over primitive days, not over DTP
         assert!(
-            !optimized.is::<DateTimePartsVTable>(),
+            !optimized.is::<DateTimeParts>(),
             "Expected pushdown to remove DTP from expression"
         );
 
@@ -348,7 +350,7 @@ mod tests {
             TimeUnit::Seconds,
             None,
         );
-        let dtp = DateTimePartsArray::try_from(temporal).unwrap();
+        let dtp = DateTimeParts::try_from_temporal(temporal).unwrap();
         let len = dtp.len();
 
         // Compare against midnight constant
diff --git a/encodings/datetime-parts/src/compute/slice.rs b/encodings/datetime-parts/src/compute/slice.rs
index 1a36ebcd885..46819a41562 100644
--- a/encodings/datetime-parts/src/compute/slice.rs
+++ b/encodings/datetime-parts/src/compute/slice.rs
@@ -4,24 +4,25 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 
-impl SliceReduce for DateTimePartsVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for DateTimeParts {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: slicing all components preserves values
-        Ok(Some(unsafe {
-            DateTimePartsArray::new_unchecked(
+        Ok(Some(
+            DateTimeParts::try_new(
                 array.dtype().clone(),
                 array.days().slice(range.clone())?,
                 array.seconds().slice(range.clone())?,
                 array.subseconds().slice(range)?,
-            )
-            .into_array()
-        }))
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/datetime-parts/src/compute/take.rs b/encodings/datetime-parts/src/compute/take.rs
index 50b14fa22b6..cd15c466b2a 100644
--- a/encodings/datetime-parts/src/compute/take.rs
+++ b/encodings/datetime-parts/src/compute/take.rs
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::Nullability;
 use vortex_array::expr::stats::Stat;
@@ -15,16 +15,18 @@ use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
-
-fn take_datetime_parts(array: &DateTimePartsArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
+fn take_datetime_parts(
+    array: ArrayView<DateTimeParts>,
+    indices: &ArrayRef,
+) -> VortexResult<ArrayRef> {
     // we go ahead and canonicalize here to avoid worst-case canonicalizing 3 separate times
     let indices = indices.to_primitive();
 
-    let taken_days = array.days().take(indices.to_array())?;
-    let taken_seconds = array.seconds().take(indices.to_array())?;
-    let taken_subseconds = array.subseconds().take(indices.to_array())?;
+    let taken_days = array.days().take(indices.clone().into_array())?;
+    let taken_seconds = array.seconds().take(indices.clone().into_array())?;
+    let taken_subseconds = array.subseconds().take(indices.clone().into_array())?;
 
     // Update the dtype if the nullability changed due to nullable indices
     let dtype = if taken_days.dtype().is_nullable() != array.dtype().is_nullable() {
@@ -36,13 +38,10 @@ fn take_datetime_parts(array: &DateTimePartsArray, indices: &dyn Array) -> Vorte
     };
 
     if !taken_seconds.dtype().is_nullable() && !taken_subseconds.dtype().is_nullable() {
-        return Ok(DateTimePartsArray::try_new(
-            dtype,
-            taken_days,
-            taken_seconds,
-            taken_subseconds,
-        )?
-        .into_array());
+        return Ok(
+            DateTimeParts::try_new(dtype, taken_days, taken_seconds, taken_subseconds)?
+                .into_array(),
+        );
     }
 
     // DateTimePartsArray requires seconds and subseconds to be non-nullable.
@@ -79,16 +78,13 @@ fn take_datetime_parts(array: &DateTimePartsArray, indices: &dyn Array) -> Vorte
         .cast(array.subseconds().dtype())?;
     let taken_subseconds = taken_subseconds.fill_null(subseconds_fill)?;
 
-    Ok(
-        DateTimePartsArray::try_new(dtype, taken_days, taken_seconds, taken_subseconds)?
-            .into_array(),
-    )
+    Ok(DateTimeParts::try_new(dtype, taken_days, taken_seconds, taken_subseconds)?.into_array())
 }
 
-impl TakeExecute for DateTimePartsVTable {
+impl TakeExecute for DateTimeParts {
     fn take(
-        array: &DateTimePartsArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         take_datetime_parts(array, indices).map(Some)
@@ -105,10 +101,11 @@ mod tests {
     use vortex_array::extension::datetime::TimeUnit;
     use vortex_buffer::buffer;
 
+    use crate::DateTimeParts;
     use crate::DateTimePartsArray;
 
     #[rstest]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![
             0i64,
             86_400_000,  // 1 day in ms
@@ -119,7 +116,7 @@ mod tests {
         TimeUnit::Milliseconds,
         Some("UTC".into())
     )).unwrap())]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_option_iter([
             Some(0i64),
             None,
@@ -130,12 +127,12 @@ mod tests {
         TimeUnit::Milliseconds,
         Some("UTC".into())
     )).unwrap())]
-    #[case(DateTimePartsArray::try_from(TemporalArray::new_timestamp(
+    #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![86_400_000i64].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
     )).unwrap())]
     fn test_take_datetime_parts_conformance(#[case] array: DateTimePartsArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/encodings/datetime-parts/src/lib.rs b/encodings/datetime-parts/src/lib.rs
index fa0dbc01fe9..1babf4abaab 100644
--- a/encodings/datetime-parts/src/lib.rs
+++ b/encodings/datetime-parts/src/lib.rs
@@ -11,9 +11,26 @@ mod compute;
 mod ops;
 mod timestamp;
 
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
+
+/// Initialize datetime-parts encoding in the given session.
+pub fn initialize(session: &VortexSession) {
+    session.arrays().register(DateTimeParts);
+
+    session.aggregate_fns().register_aggregate_kernel(
+        DateTimeParts::ID,
+        Some(IsConstant.id()),
+        &compute::is_constant::DateTimePartsIsConstantKernel,
+    );
+}
+
 #[cfg(test)]
 mod test {
-    use vortex_array::ProstMetadata;
+    use prost::Message;
     use vortex_array::dtype::PType;
     use vortex_array::test_harness::check_metadata;
 
@@ -24,11 +41,12 @@ mod test {
     fn test_datetimeparts_metadata() {
         check_metadata(
             "datetimeparts.metadata",
-            ProstMetadata(DateTimePartsMetadata {
+            &DateTimePartsMetadata {
                 days_ptype: PType::I64 as i32,
                 seconds_ptype: PType::I64 as i32,
                 subseconds_ptype: PType::I64 as i32,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/datetime-parts/src/ops.rs b/encodings/datetime-parts/src/ops.rs
index 0736e731cb8..2c224b078d5 100644
--- a/encodings/datetime-parts/src/ops.rs
+++ b/encodings/datetime-parts/src/ops.rs
@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::dtype::DType;
 use vortex_array::extension::datetime::Timestamp;
 use vortex_array::scalar::Scalar;
@@ -10,13 +11,17 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::DateTimePartsArray;
-use crate::DateTimePartsVTable;
+use crate::DateTimeParts;
+use crate::array::DateTimePartsArrayExt;
 use crate::timestamp;
 use crate::timestamp::TimestampParts;
 
-impl OperationsVTable<DateTimePartsVTable> for DateTimePartsVTable {
-    fn scalar_at(array: &DateTimePartsArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<DateTimeParts> for DateTimeParts {
+    fn scalar_at(
+        array: ArrayView<'_, DateTimeParts>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let DType::Extension(ext) = array.dtype().clone() else {
             vortex_panic!(
                 "DateTimePartsArray must have extension dtype, found {}",
@@ -28,7 +33,7 @@ impl OperationsVTable<DateTimePartsVTable> for DateTimePartsVTable {
             vortex_panic!(Compute: "must decode TemporalMetadata from extension metadata");
         };
 
-        if !array.is_valid(index)? {
+        if !array.as_ref().is_valid(index)? {
             return Ok(Scalar::null(DType::Extension(ext)));
         }
 
diff --git a/encodings/decimal-byte-parts/public-api.lock b/encodings/decimal-byte-parts/public-api.lock
index 2ea7909ee23..397885e1b45 100644
--- a/encodings/decimal-byte-parts/public-api.lock
+++ b/encodings/decimal-byte-parts/public-api.lock
@@ -1,146 +1,112 @@
 pub mod vortex_decimal_byte_parts
 
-pub struct vortex_decimal_byte_parts::DecimalBytePartsArray
+pub struct vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_decimal_byte_parts::DecimalBytePartsArray
+impl vortex_decimal_byte_parts::DecimalByteParts
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::decimal_dtype(&self) -> &vortex_array::dtype::decimal::DecimalDType
+pub const vortex_decimal_byte_parts::DecimalByteParts::ID: vortex_array::array::ArrayId
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::into_parts(self) -> vortex_decimal_byte_parts::DecimalBytePartsArrayParts
+pub fn vortex_decimal_byte_parts::DecimalByteParts::try_new(msp: vortex_array::array::erased::ArrayRef, decimal_dtype: vortex_array::dtype::decimal::DecimalDType) -> vortex_error::VortexResult<vortex_decimal_byte_parts::DecimalBytePartsArray>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::try_new(msp: vortex_array::array::ArrayRef, decimal_dtype: vortex_array::dtype::decimal::DecimalDType) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_decimal_byte_parts::DecimalByteParts
 
-impl core::clone::Clone for vortex_decimal_byte_parts::DecimalBytePartsArray
+pub fn vortex_decimal_byte_parts::DecimalByteParts::clone(&self) -> vortex_decimal_byte_parts::DecimalByteParts
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::clone(&self) -> vortex_decimal_byte_parts::DecimalBytePartsArray
+impl core::fmt::Debug for vortex_decimal_byte_parts::DecimalByteParts
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_decimal_byte_parts::DecimalBytePartsArray
+pub fn vortex_decimal_byte_parts::DecimalByteParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::as_ref(&self) -> &dyn vortex_array::array::Array
+impl vortex_array::array::vtable::VTable for vortex_decimal_byte_parts::DecimalByteParts
 
-impl core::convert::From<vortex_decimal_byte_parts::DecimalBytePartsArray> for vortex_array::array::ArrayRef
+pub type vortex_decimal_byte_parts::DecimalByteParts::ArrayData = vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_decimal_byte_parts::DecimalBytePartsArray) -> vortex_array::array::ArrayRef
+pub type vortex_decimal_byte_parts::DecimalByteParts::OperationsVTable = vortex_decimal_byte_parts::DecimalByteParts
 
-impl core::fmt::Debug for vortex_decimal_byte_parts::DecimalBytePartsArray
+pub type vortex_decimal_byte_parts::DecimalByteParts::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_decimal_byte_parts::DecimalByteParts::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::ops::deref::Deref for vortex_decimal_byte_parts::DecimalBytePartsArray
+pub fn vortex_decimal_byte_parts::DecimalByteParts::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsArray::Target = dyn vortex_array::array::Array
+pub fn vortex_decimal_byte_parts::DecimalByteParts::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::deref(&self) -> &Self::Target
+pub fn vortex_decimal_byte_parts::DecimalByteParts::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-impl vortex_array::array::IntoArray for vortex_decimal_byte_parts::DecimalBytePartsArray
+pub fn vortex_decimal_byte_parts::DecimalByteParts::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_decimal_byte_parts::DecimalByteParts::id(&self) -> vortex_array::array::ArrayId
 
-pub struct vortex_decimal_byte_parts::DecimalBytePartsArrayParts
+pub fn vortex_decimal_byte_parts::DecimalByteParts::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub vortex_decimal_byte_parts::DecimalBytePartsArrayParts::dtype: vortex_array::dtype::DType
+pub fn vortex_decimal_byte_parts::DecimalByteParts::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub vortex_decimal_byte_parts::DecimalBytePartsArrayParts::msp: vortex_array::array::ArrayRef
+pub fn vortex_decimal_byte_parts::DecimalByteParts::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub const vortex_decimal_byte_parts::DecimalBytePartsVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_decimal_byte_parts::DecimalByteParts> for vortex_decimal_byte_parts::DecimalByteParts
 
-impl core::fmt::Debug for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_decimal_byte_parts::DecimalByteParts>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_decimal_byte_parts::DecimalByteParts> for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_decimal_byte_parts::DecimalByteParts>) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::take(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::filter(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::slice(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::slice::SliceReduce for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::compute::is_constant::IsConstantKernel for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::is_constant(&self, array: &vortex_decimal_byte_parts::DecimalBytePartsArray, opts: &vortex_array::compute::is_constant::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::compare(lhs: &Self::Array, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::cast(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_decimal_byte_parts::DecimalByteParts
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_decimal_byte_parts::DecimalBytePartsVTable
+pub fn vortex_decimal_byte_parts::DecimalByteParts::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::mask(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_decimal_byte_parts::DecimalBytePartsData
 
-impl vortex_array::vtable::VTable for vortex_decimal_byte_parts::DecimalBytePartsVTable
+impl vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::Array = vortex_decimal_byte_parts::DecimalBytePartsArray
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::validate(msp: &vortex_array::array::erased::ArrayRef, decimal_dtype: vortex_array::dtype::decimal::DecimalDType, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<()>
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::ArrayVTable = vortex_decimal_byte_parts::DecimalBytePartsVTable
+impl core::clone::Clone for vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_decimal_byte_parts::DecimalBytesPartsMetadata>
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::clone(&self) -> vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::OperationsVTable = vortex_decimal_byte_parts::DecimalBytePartsVTable
+impl core::fmt::Debug for vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_decimal_byte_parts::DecimalBytePartsVTable::VisitorVTable = vortex_decimal_byte_parts::DecimalBytePartsVTable
+impl core::fmt::Display for vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_decimal_byte_parts::DecimalBytePartsArray>
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::hash::ArrayEq for vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::array_eq(&self, _other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::hash::ArrayHash for vortex_decimal_byte_parts::DecimalBytePartsData
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_decimal_byte_parts::DecimalBytePartsData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::metadata(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> vortex_error::VortexResult<Self::Metadata>
+pub struct vortex_decimal_byte_parts::DecimalBytePartsDataParts
 
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
-
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_decimal_byte_parts::DecimalBytePartsVTable> for vortex_decimal_byte_parts::DecimalBytePartsVTable
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::array_eq(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, other: &vortex_decimal_byte_parts::DecimalBytePartsArray, precision: vortex_array::hash::Precision) -> bool
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::array_hash<H: core::hash::Hasher>(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, state: &mut H, precision: vortex_array::hash::Precision)
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::dtype(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> &vortex_array::dtype::DType
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::len(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> usize
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::stats(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> vortex_array::stats::array::StatsSetRef<'_>
-
-impl vortex_array::vtable::operations::OperationsVTable<vortex_decimal_byte_parts::DecimalBytePartsVTable> for vortex_decimal_byte_parts::DecimalBytePartsVTable
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::scalar_at(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
-
-impl vortex_array::vtable::validity::ValidityChild<vortex_decimal_byte_parts::DecimalBytePartsVTable> for vortex_decimal_byte_parts::DecimalBytePartsVTable
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::validity_child(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> &vortex_array::array::ArrayRef
-
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_decimal_byte_parts::DecimalBytePartsVTable> for vortex_decimal_byte_parts::DecimalBytePartsVTable
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::nbuffers(_array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> usize
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::nchildren(_array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> usize
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::visit_buffers(_array: &vortex_decimal_byte_parts::DecimalBytePartsArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
-
-pub fn vortex_decimal_byte_parts::DecimalBytePartsVTable::visit_children(array: &vortex_decimal_byte_parts::DecimalBytePartsArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub vortex_decimal_byte_parts::DecimalBytePartsDataParts::msp: vortex_array::array::erased::ArrayRef
 
 pub struct vortex_decimal_byte_parts::DecimalBytesPartsMetadata
 
@@ -167,3 +133,15 @@ impl prost::message::Message for vortex_decimal_byte_parts::DecimalBytesPartsMet
 pub fn vortex_decimal_byte_parts::DecimalBytesPartsMetadata::clear(&mut self)
 
 pub fn vortex_decimal_byte_parts::DecimalBytesPartsMetadata::encoded_len(&self) -> usize
+
+pub trait vortex_decimal_byte_parts::DecimalBytePartsArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_decimal_byte_parts::DecimalByteParts>
+
+pub fn vortex_decimal_byte_parts::DecimalBytePartsArrayExt::msp(&self) -> &vortex_array::array::erased::ArrayRef
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_decimal_byte_parts::DecimalByteParts>> vortex_decimal_byte_parts::DecimalBytePartsArrayExt for T
+
+pub fn T::msp(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_decimal_byte_parts::initialize(session: &vortex_session::VortexSession)
+
+pub type vortex_decimal_byte_parts::DecimalBytePartsArray = vortex_array::array::typed::Array<vortex_decimal_byte_parts::DecimalByteParts>
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
index ff679fba411..e554bbfae71 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
@@ -1,19 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
-
-impl CastReduce for DecimalBytePartsVTable {
-    fn cast(array: &DecimalBytePartsArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
+impl CastReduce for DecimalByteParts {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // DecimalBytePartsArray can only have Decimal dtype, so we only handle decimal-to-decimal casts
         let DType::Decimal(target_decimal, target_nullability) = dtype else {
             // Cannot cast decimal to non-decimal types - delegate to canonical form
@@ -21,7 +21,11 @@ impl CastReduce for DecimalBytePartsVTable {
         };
 
         // Check if this is just a nullability change
-        if array.decimal_dtype() == target_decimal
+        if array
+            .dtype()
+            .as_decimal_opt()
+            .vortex_expect("must be a decimal dtype")
+            == target_decimal
             && array.dtype().nullability() != *target_nullability
         {
             // Cast the msp array to handle nullability change
@@ -30,7 +34,7 @@ impl CastReduce for DecimalBytePartsVTable {
                 .cast(array.msp().dtype().with_nullability(*target_nullability))?;
 
             return Ok(Some(
-                DecimalBytePartsArray::try_new(new_msp, *target_decimal)?.into_array(),
+                DecimalByteParts::try_new(new_msp, *target_decimal)?.into_array(),
             ));
         }
 
@@ -52,20 +56,19 @@ mod tests {
     use vortex_array::dtype::Nullability;
     use vortex_buffer::buffer;
 
+    use crate::DecimalByteParts;
     use crate::DecimalBytePartsArray;
 
     #[test]
     fn test_cast_decimal_byte_parts_nullability() {
         let decimal_dtype = DecimalDType::new(10, 2);
-        let array = DecimalBytePartsArray::try_new(
-            buffer![100i32, 200, 300, 400].into_array(),
-            decimal_dtype,
-        )
-        .unwrap();
+        let array =
+            DecimalByteParts::try_new(buffer![100i32, 200, 300, 400].into_array(), decimal_dtype)
+                .unwrap();
 
         // Cast to nullable decimal
         let casted = array
-            .to_array()
+            .into_array()
             .cast(DType::Decimal(decimal_dtype, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -81,7 +84,7 @@ mod tests {
     #[test]
     fn test_cast_decimal_byte_parts_nullable_to_non_nullable() {
         let decimal_dtype = DecimalDType::new(10, 2);
-        let array = DecimalBytePartsArray::try_new(
+        let array = DecimalByteParts::try_new(
             PrimitiveArray::from_option_iter([Some(100i32), None, Some(300)]).into_array(),
             decimal_dtype,
         )
@@ -89,35 +92,35 @@ mod tests {
 
         // Cast to non-nullable should fail due to nulls - force evaluation via to_canonical
         let result = array
-            .to_array()
+            .into_array()
             .cast(DType::Decimal(decimal_dtype, Nullability::NonNullable))
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
         assert!(result.is_err());
     }
 
     #[rstest]
-    #[case::i32(DecimalBytePartsArray::try_new(
+    #[case::i32(DecimalByteParts::try_new(
         buffer![100i32, 200, 300, 400, 500].into_array(),
         DecimalDType::new(10, 2),
     ).unwrap())]
-    #[case::i64(DecimalBytePartsArray::try_new(
+    #[case::i64(DecimalByteParts::try_new(
         buffer![1000i64, 2000, 3000, 4000].into_array(),
         DecimalDType::new(19, 4),
     ).unwrap())]
-    #[case::nullable(DecimalBytePartsArray::try_new(
+    #[case::nullable(DecimalByteParts::try_new(
         PrimitiveArray::from_option_iter([Some(100i32), None, Some(300), Some(400), None])
             .into_array(),
         DecimalDType::new(10, 2),
     ).unwrap())]
-    #[case::single(DecimalBytePartsArray::try_new(
+    #[case::single(DecimalByteParts::try_new(
         buffer![42i32].into_array(),
         DecimalDType::new(5, 1),
     ).unwrap())]
-    #[case::negative(DecimalBytePartsArray::try_new(
+    #[case::negative(DecimalByteParts::try_new(
         buffer![-100i32, -200, 300, -400, 500].into_array(),
         DecimalDType::new(10, 2),
     ).unwrap())]
     fn test_cast_decimal_byte_parts_conformance(#[case] array: DecimalBytePartsArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs
index 0178b06c8c6..43f06b6e695 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs
@@ -3,9 +3,10 @@
 
 use Sign::Negative;
 use num_traits::NumCast;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::IntegerPType;
@@ -23,13 +24,14 @@ use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 use crate::decimal_byte_parts::compute::compare::Sign::Positive;
 
-impl CompareKernel for DecimalBytePartsVTable {
+impl CompareKernel for DecimalByteParts {
     fn compare(
-        lhs: &Self::Array,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -37,21 +39,23 @@ impl CompareKernel for DecimalBytePartsVTable {
             return Ok(None);
         };
 
-        let nullability = lhs.dtype.nullability() | rhs.dtype().nullability();
-        let scalar_type = lhs.msp.dtype().with_nullability(nullability);
+        let nullability = lhs.dtype().nullability() | rhs.dtype().nullability();
+        let scalar_type = lhs.msp().dtype().with_nullability(nullability);
 
         let rhs_decimal = rhs_const
             .as_decimal()
             .decimal_value()
             .vortex_expect("checked for null in entry func");
 
-        match decimal_value_wrapper_to_primitive(rhs_decimal, lhs.msp.as_primitive_typed().ptype())
-        {
+        match decimal_value_wrapper_to_primitive(
+            rhs_decimal,
+            lhs.msp().as_primitive_typed().ptype(),
+        ) {
             Ok(value) => {
                 let encoded_scalar = Scalar::try_new(scalar_type, Some(value))?;
                 let encoded_const = ConstantArray::new(encoded_scalar, rhs.len());
-                lhs.msp
-                    .binary(encoded_const.to_array(), Operator::from(operator))
+                lhs.msp()
+                    .binary(encoded_const.into_array(), Operator::from(operator))
                     .map(Some)
             }
 
@@ -61,13 +65,13 @@ impl CompareKernel for DecimalBytePartsVTable {
                 // (depending on the `sign`) than all values in MSP.
                 // If the LHS or the RHS contain nulls, then we must fallback to the canonicalized
                 // implementation which does null-checking instead.
-                if lhs.all_valid()? && rhs.all_valid()? {
+                if lhs.array().all_valid()? && rhs.all_valid()? {
                     Ok(Some(
                         ConstantArray::new(
                             unconvertible_value(sign, operator, nullability),
                             lhs.len(),
                         )
-                        .to_array(),
+                        .into_array(),
                     ))
                 } else {
                     Ok(None)
@@ -140,7 +144,6 @@ where
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::ConstantArray;
@@ -157,24 +160,24 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
 
-    use crate::DecimalBytePartsArray;
+    use crate::DecimalByteParts;
 
     #[test]
     fn compare_decimal_const() {
         let decimal_dtype = DecimalDType::new(8, 2);
         let dtype = DType::Decimal(decimal_dtype, Nullability::Nullable);
-        let lhs = DecimalBytePartsArray::try_new(
-            PrimitiveArray::new(buffer![100i32, 200i32, 400i32], Validity::AllValid).to_array(),
+        let lhs = DecimalByteParts::try_new(
+            PrimitiveArray::new(buffer![100i32, 200i32, 400i32], Validity::AllValid).into_array(),
             decimal_dtype,
         )
         .unwrap()
-        .to_array();
+        .into_array();
         let rhs = ConstantArray::new(
             Scalar::try_new(dtype, Some(DecimalValue::I64(400).into())).unwrap(),
             lhs.len(),
         );
 
-        let res = lhs.binary(rhs.to_array(), Operator::Eq).unwrap();
+        let res = lhs.binary(rhs.into_array(), Operator::Eq).unwrap();
 
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
@@ -183,7 +186,7 @@ mod tests {
     #[test]
     fn test_byteparts_compare_nullable() -> VortexResult<()> {
         let decimal_type = DecimalDType::new(19, -11);
-        let lhs = DecimalBytePartsArray::try_new(
+        let lhs = DecimalByteParts::try_new(
             PrimitiveArray::new(
                 buffer![1i64, 2i64, 3i64, 4i64],
                 Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
@@ -202,7 +205,7 @@ mod tests {
         )
         .into_array();
 
-        let res = lhs.to_array().binary(rhs, Operator::Lte)?;
+        let res = lhs.into_array().binary(rhs, Operator::Lte)?;
         let expected =
             BoolArray::from_iter([None, Some(true), Some(true), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
@@ -214,12 +217,12 @@ mod tests {
     fn compare_decimal_const_unconvertible_comparison() {
         let decimal_dtype = DecimalDType::new(40, 2);
         let dtype = DType::Decimal(decimal_dtype, Nullability::Nullable);
-        let lhs = DecimalBytePartsArray::try_new(
-            PrimitiveArray::new(buffer![100i32, 200i32, 400i32], Validity::AllValid).to_array(),
+        let lhs = DecimalByteParts::try_new(
+            PrimitiveArray::new(buffer![100i32, 200i32, 400i32], Validity::AllValid).into_array(),
             decimal_dtype,
         )
         .unwrap()
-        .to_array();
+        .into_array();
         // This cannot be converted to a i32.
         let rhs = ConstantArray::new(
             Scalar::try_new(
@@ -230,15 +233,15 @@ mod tests {
             lhs.len(),
         );
 
-        let res = lhs.binary(rhs.to_array(), Operator::Eq).unwrap();
+        let res = lhs.binary(rhs.clone().into_array(), Operator::Eq).unwrap();
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
-        let res = lhs.binary(rhs.to_array(), Operator::Gt).unwrap();
+        let res = lhs.binary(rhs.clone().into_array(), Operator::Gt).unwrap();
         let expected = BoolArray::from_iter([Some(true), Some(true), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
 
-        let res = lhs.binary(rhs.to_array(), Operator::Lt).unwrap();
+        let res = lhs.binary(rhs.into_array(), Operator::Lt).unwrap();
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
@@ -248,15 +251,15 @@ mod tests {
             lhs.len(),
         );
 
-        let res = lhs.binary(rhs.to_array(), Operator::Eq).unwrap();
+        let res = lhs.binary(rhs.clone().into_array(), Operator::Eq).unwrap();
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
-        let res = lhs.binary(rhs.to_array(), Operator::Gt).unwrap();
+        let res = lhs.binary(rhs.clone().into_array(), Operator::Gt).unwrap();
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
-        let res = lhs.binary(rhs.to_array(), Operator::Lt).unwrap();
+        let res = lhs.binary(rhs.into_array(), Operator::Lt).unwrap();
         let expected = BoolArray::from_iter([Some(true), Some(true), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
     }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs
index be762b1b977..c82171b0e13 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/filter.rs
@@ -2,17 +2,25 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
-use vortex_array::arrays::FilterReduce;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
+use vortex_array::arrays::filter::FilterReduce;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
-
-impl FilterReduce for DecimalBytePartsVTable {
-    fn filter(array: &DecimalBytePartsArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
-        DecimalBytePartsArray::try_new(array.msp.filter(mask.clone())?, *array.decimal_dtype())
-            .map(|d| Some(d.to_array()))
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
+impl FilterReduce for DecimalByteParts {
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+        DecimalByteParts::try_new(
+            array.msp().filter(mask.clone())?,
+            *array
+                .dtype()
+                .as_decimal_opt()
+                .vortex_expect("must be a decimal dtype"),
+        )
+        .map(|d| Some(d.into_array()))
     }
 }
 
@@ -24,7 +32,7 @@ mod test {
     use vortex_array::dtype::DecimalDType;
     use vortex_buffer::buffer;
 
-    use crate::DecimalBytePartsArray;
+    use crate::DecimalByteParts;
 
     #[test]
     fn test_filter_decimal_byte_parts() {
@@ -32,15 +40,15 @@ mod test {
         let msp = buffer![100i32, 200, 300, 400, 500].into_array();
 
         let decimal_dtype = DecimalDType::new(8, 2);
-        let array = DecimalBytePartsArray::try_new(msp, decimal_dtype).unwrap();
-        test_filter_conformance(array.as_ref());
+        let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap();
+        test_filter_conformance(&array.into_array());
 
         // Test with nullable values
         let msp = PrimitiveArray::from_option_iter([Some(10i64), None, Some(30), Some(40), None])
             .into_array();
 
         let decimal_dtype = DecimalDType::new(18, 4);
-        let array = DecimalBytePartsArray::try_new(msp, decimal_dtype).unwrap();
-        test_filter_conformance(array.as_ref());
+        let array = DecimalByteParts::try_new(msp, decimal_dtype).unwrap();
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/is_constant.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/is_constant.rs
index 30e00d4bb5b..4d271eb80b3 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/is_constant.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/is_constant.rs
@@ -1,24 +1,40 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::IsConstantKernel;
-use vortex_array::compute::IsConstantKernelAdapter;
-use vortex_array::compute::IsConstantOpts;
-use vortex_array::compute::is_constant_opts;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-impl IsConstantKernel for DecimalBytePartsVTable {
-    fn is_constant(
+/// DecimalByteParts-specific is_constant kernel.
+///
+/// Delegates to checking if the MSP (most significant part) is constant.
+#[derive(Debug)]
+pub(crate) struct DecimalBytePartsIsConstantKernel;
+
+impl DynAggregateKernel for DecimalBytePartsIsConstantKernel {
+    fn aggregate(
         &self,
-        array: &DecimalBytePartsArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        is_constant_opts(&array.msp, opts)
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
+            return Ok(None);
+        }
+
+        let Some(array) = batch.as_opt::<DecimalByteParts>() else {
+            return Ok(None);
+        };
+
+        let result = is_constant(array.msp(), ctx)?;
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
-
-register_kernel!(IsConstantKernelAdapter(DecimalBytePartsVTable).lift());
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/kernel.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/kernel.rs
index 27057e81d60..9e16b4f81dc 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/kernel.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/kernel.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
 
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<DecimalBytePartsVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(DecimalBytePartsVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DecimalBytePartsVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<DecimalByteParts> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(DecimalByteParts)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(DecimalByteParts)),
 ]);
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mask.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mask.rs
index 27aa87da4f8..0f007519894 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mask.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mask.rs
@@ -2,25 +2,34 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ScalarFnArrayExt;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
 use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::fns::mask::Mask as MaskExpr;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-impl MaskReduce for DecimalBytePartsVTable {
-    fn mask(array: &DecimalBytePartsArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for DecimalByteParts {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_msp = MaskExpr.try_new_array(
-            array.msp.len(),
+            array.msp().len(),
             EmptyOptions,
-            [array.msp.clone(), mask.clone()],
+            [array.msp().clone(), mask.clone()],
         )?;
         Ok(Some(
-            DecimalBytePartsArray::try_new(masked_msp, *array.decimal_dtype())?.into_array(),
+            DecimalByteParts::try_new(
+                masked_msp,
+                *array
+                    .dtype()
+                    .as_decimal_opt()
+                    .vortex_expect("must be a decimal dtype"),
+            )?
+            .into_array(),
         ))
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
index feea08c3f1b..35da5be40b6 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
@@ -4,7 +4,7 @@
 mod cast;
 mod compare;
 mod filter;
-mod is_constant;
+pub(crate) mod is_constant;
 pub(crate) mod kernel;
 mod mask;
 mod take;
@@ -18,56 +18,57 @@ mod tests {
     use vortex_array::dtype::DecimalDType;
     use vortex_buffer::buffer;
 
+    use crate::DecimalByteParts;
     use crate::DecimalBytePartsArray;
 
     #[rstest]
     // Basic decimal byte parts arrays
-    #[case::decimal_i32(DecimalBytePartsArray::try_new(
+    #[case::decimal_i32(DecimalByteParts::try_new(
         buffer![100i32, 200, 300, 400, 500].into_array(),
         DecimalDType::new(10, 2)
     ).unwrap())]
-    #[case::decimal_i64(DecimalBytePartsArray::try_new(
+    #[case::decimal_i64(DecimalByteParts::try_new(
         buffer![1000i64, 2000, 3000, 4000, 5000].into_array(),
         DecimalDType::new(19, 4)
     ).unwrap())]
     // Nullable arrays
-    #[case::decimal_nullable_i32(DecimalBytePartsArray::try_new(
+    #[case::decimal_nullable_i32(DecimalByteParts::try_new(
         PrimitiveArray::from_option_iter([Some(100i32), None, Some(300), Some(400), None]).into_array(),
         DecimalDType::new(10, 2)
     ).unwrap())]
-    #[case::decimal_nullable_i64(DecimalBytePartsArray::try_new(
+    #[case::decimal_nullable_i64(DecimalByteParts::try_new(
         PrimitiveArray::from_option_iter([Some(1000i64), None, Some(3000), Some(4000), None]).into_array(),
         DecimalDType::new(19, 4)
     ).unwrap())]
     // Different precision/scale combinations
-    #[case::decimal_high_precision(DecimalBytePartsArray::try_new(
+    #[case::decimal_high_precision(DecimalByteParts::try_new(
         buffer![123456789i32, 987654321, -123456789].into_array(),
         DecimalDType::new(38, 10)
     ).unwrap())]
-    #[case::decimal_zero_scale(DecimalBytePartsArray::try_new(
+    #[case::decimal_zero_scale(DecimalByteParts::try_new(
         buffer![100i32, 200, 300].into_array(),
         DecimalDType::new(10, 0)
     ).unwrap())]
     // Edge cases
-    #[case::decimal_single(DecimalBytePartsArray::try_new(
+    #[case::decimal_single(DecimalByteParts::try_new(
         buffer![42i32].into_array(),
         DecimalDType::new(5, 1)
     ).unwrap())]
-    #[case::decimal_negative(DecimalBytePartsArray::try_new(
+    #[case::decimal_negative(DecimalByteParts::try_new(
         buffer![-100i32, -200, 300, -400, 500].into_array(),
         DecimalDType::new(10, 2)
     ).unwrap())]
     // Large arrays
-    #[case::decimal_large(DecimalBytePartsArray::try_new(
+    #[case::decimal_large(DecimalByteParts::try_new(
         PrimitiveArray::from_iter((0..1500).map(|i| i * 100)).into_array(),
         DecimalDType::new(10, 2)
     ).unwrap())]
-    #[case::decimal_large_i64(DecimalBytePartsArray::try_new(
+    #[case::decimal_large_i64(DecimalByteParts::try_new(
         PrimitiveArray::from_iter((0..2000i64).map(|i| i * 1000000)).into_array(),
         DecimalDType::new(19, 6)
     ).unwrap())]
 
     fn test_decimal_byte_parts_consistency(#[case] array: DecimalBytePartsArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs
index ba5a04c7d3b..807b660ec73 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/take.rs
@@ -1,22 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::IntoArray;
+use vortex_array::arrays::dict::TakeExecute;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-impl TakeExecute for DecimalBytePartsVTable {
+impl TakeExecute for DecimalByteParts {
     fn take(
-        array: &DecimalBytePartsArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        DecimalBytePartsArray::try_new(array.msp.take(indices.to_array())?, *array.decimal_dtype())
-            .map(|a| Some(a.to_array()))
+        DecimalByteParts::try_new(
+            array.msp().take(indices.clone())?,
+            *array
+                .dtype()
+                .as_decimal_opt()
+                .vortex_expect("must be a decimal dtype"),
+        )
+        .map(|a| Some(a.into_array()))
     }
 }
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 5cd96148726..ea90bf575e0 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -1,24 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-mod compute;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
+
+use vortex_array::Array;
+use vortex_array::ArrayParts;
+use vortex_array::ArrayView;
+pub(crate) mod compute;
 mod rules;
 mod slice;
 
-use std::hash::Hash;
-
 use prost::Message as _;
-use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::TypedArrayRef;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
@@ -30,27 +33,32 @@ use vortex_array::scalar::DecimalValue;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
-use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
 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 crate::decimal_byte_parts::compute::kernel::PARENT_KERNELS;
 use crate::decimal_byte_parts::rules::PARENT_RULES;
 
-vtable!(DecimalByteParts);
+/// A [`DecimalByteParts`]-encoded Vortex array.
+pub type DecimalBytePartsArray = Array<DecimalByteParts>;
+
+impl ArrayHash for DecimalBytePartsData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
+
+impl ArrayEq for DecimalBytePartsData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
 
 #[derive(Clone, prost::Message)]
 pub struct DecimalBytesPartsMetadata {
@@ -60,48 +68,67 @@ pub struct DecimalBytesPartsMetadata {
     lower_part_count: u32,
 }
 
-impl VTable for DecimalBytePartsVTable {
-    type Array = DecimalBytePartsArray;
-
-    type Metadata = ProstMetadata<DecimalBytesPartsMetadata>;
+impl VTable for DecimalByteParts {
+    type ArrayData = DecimalBytePartsData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &DecimalBytePartsArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DecimalBytesPartsMetadata {
-            zeroth_child_ptype: PType::try_from(array.msp.dtype())? as i32,
-            lower_part_count: 0,
-        }))
+    fn validate(
+        &self,
+        _data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let Some(decimal_dtype) = dtype.as_decimal_opt() else {
+            vortex_bail!("expected decimal dtype, got {}", dtype)
+        };
+        let msp = slots[MSP_SLOT]
+            .as_ref()
+            .vortex_expect("DecimalBytePartsArray msp slot");
+        DecimalBytePartsData::validate(msp, *decimal_dtype, dtype, len)
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("DecimalBytePartsArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("DecimalBytePartsArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DecimalBytesPartsMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            DecimalBytesPartsMetadata {
+                zeroth_child_ptype: PType::try_from(array.msp().dtype())? as i32,
+                lower_part_count: 0,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<DecimalBytePartsArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = DecimalBytesPartsMetadata::decode(metadata)?;
         let Some(decimal_dtype) = dtype.as_decimal_opt() else {
             vortex_bail!("decoding decimal but given non decimal dtype {}", dtype)
         };
@@ -115,33 +142,29 @@ impl VTable for DecimalBytePartsVTable {
             "lower_part_count > 0 not currently supported"
         );
 
-        DecimalBytePartsArray::try_new(msp, *decimal_dtype)
+        let slots = vec![Some(msp.clone())];
+        let data = DecimalBytePartsData::try_new(msp.dtype(), msp.len(), *decimal_dtype)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1,
-            "DecimalBytePartsArray expects exactly 1 child (msp), got {}",
-            children.len()
-        );
-        array.msp = children.into_iter().next().vortex_expect("checked");
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        to_canonical_decimal(array, ctx)
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        to_canonical_decimal(&array, ctx).map(ExecutionResult::done)
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -150,107 +173,102 @@ impl VTable for DecimalBytePartsVTable {
     }
 }
 
+/// The most significant parts of the decimal values.
+pub(super) const MSP_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["msp"];
+
 /// This array encodes decimals as between 1-4 columns of primitive typed children.
 /// The most significant part (msp) sorting the most significant decimal bits.
 /// This array must be signed and is nullable iff the decimal is nullable.
 ///
 /// e.g. for a decimal i128 \[ 127..64 | 64..0 \] msp = 127..64 and lower_part\[0\] = 64..0
 #[derive(Clone, Debug)]
-pub struct DecimalBytePartsArray {
-    msp: ArrayRef,
+pub struct DecimalBytePartsData {
     // NOTE: the lower_parts is currently unused, we reserve this field so that it is properly
     //  read/written during serde, but provide no constructor to initialize this to anything
     //  other than the empty Vec.
-    // Must update `DecimalBytePartsArrayParts` too.
     _lower_parts: Vec<ArrayRef>,
-    dtype: DType,
-    stats_set: ArrayStats,
 }
 
-pub struct DecimalBytePartsArrayParts {
-    pub msp: ArrayRef,
-    pub dtype: DType,
+impl Display for DecimalBytePartsData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
 }
 
-impl DecimalBytePartsArray {
-    pub fn try_new(msp: ArrayRef, decimal_dtype: DecimalDType) -> VortexResult<Self> {
-        if !msp.dtype().is_signed_int() {
-            vortex_bail!("decimal bytes parts, first part must be a signed array")
-        }
+pub struct DecimalBytePartsDataParts {
+    pub msp: ArrayRef,
+}
 
-        let nullable = msp.dtype().nullability();
-        Ok(Self {
-            msp,
-            _lower_parts: Vec::new(),
-            dtype: DType::Decimal(decimal_dtype, nullable),
-            stats_set: Default::default(),
-        })
+pub trait DecimalBytePartsArrayExt: TypedArrayRef<DecimalByteParts> {
+    fn msp(&self) -> &ArrayRef {
+        self.as_ref().slots()[MSP_SLOT]
+            .as_ref()
+            .vortex_expect("DecimalBytePartsArray msp slot")
     }
+}
 
-    pub(crate) unsafe fn new_unchecked(msp: ArrayRef, decimal_dtype: DecimalDType) -> Self {
-        let nullable = msp.dtype().nullability();
-        Self {
-            msp,
-            _lower_parts: Vec::new(),
-            dtype: DType::Decimal(decimal_dtype, nullable),
-            stats_set: Default::default(),
-        }
-    }
+impl<T: TypedArrayRef<DecimalByteParts>> DecimalBytePartsArrayExt for T {}
 
-    /// If `_lower_parts` is supported check all calls use this correctly.
-    pub fn into_parts(self) -> DecimalBytePartsArrayParts {
-        DecimalBytePartsArrayParts {
-            msp: self.msp,
-            dtype: self.dtype,
+impl DecimalBytePartsData {
+    pub fn validate(
+        msp: &ArrayRef,
+        decimal_dtype: DecimalDType,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        if !msp.dtype().is_signed_int() {
+            vortex_bail!("decimal bytes parts, first part must be a signed array")
         }
-    }
 
-    pub fn decimal_dtype(&self) -> &DecimalDType {
-        self.dtype
-            .as_decimal_opt()
-            .vortex_expect("must be a decimal dtype")
+        let expected_dtype = DType::Decimal(decimal_dtype, msp.dtype().nullability());
+        vortex_ensure!(
+            dtype == &expected_dtype,
+            "expected dtype {expected_dtype}, got {dtype}"
+        );
+        vortex_ensure!(msp.len() == len, "expected len {len}, got {}", msp.len());
+        Ok(())
     }
 
-    pub(crate) fn msp(&self) -> &ArrayRef {
-        &self.msp
+    pub(crate) fn try_new(
+        msp_dtype: &DType,
+        msp_len: usize,
+        decimal_dtype: DecimalDType,
+    ) -> VortexResult<Self> {
+        let expected_dtype = DType::Decimal(decimal_dtype, msp_dtype.nullability());
+        vortex_ensure!(
+            msp_dtype.is_signed_int(),
+            "decimal bytes parts, first part must be a signed array"
+        );
+        let _ = msp_len;
+        drop(expected_dtype);
+        Ok(Self {
+            _lower_parts: Vec::new(),
+        })
     }
 }
 
-#[derive(Debug)]
-pub struct DecimalBytePartsVTable;
+#[derive(Clone, Debug)]
+pub struct DecimalByteParts;
 
-impl DecimalBytePartsVTable {
+impl DecimalByteParts {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.decimal_byte_parts");
-}
 
-impl BaseArrayVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
-    fn len(array: &DecimalBytePartsArray) -> usize {
-        array.msp.len()
-    }
-
-    fn dtype(array: &DecimalBytePartsArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &DecimalBytePartsArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &DecimalBytePartsArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.msp.array_hash(state, precision);
-    }
-
-    fn array_eq(
-        array: &DecimalBytePartsArray,
-        other: &DecimalBytePartsArray,
-        precision: Precision,
-    ) -> bool {
-        array.dtype == other.dtype && array.msp.array_eq(&other.msp, precision)
+    /// Construct a new [`DecimalBytePartsArray`] from an MSP array and decimal dtype.
+    pub fn try_new(
+        msp: ArrayRef,
+        decimal_dtype: DecimalDType,
+    ) -> VortexResult<DecimalBytePartsArray> {
+        let len = msp.len();
+        let dtype = DType::Decimal(decimal_dtype, msp.dtype().nullability());
+        let slots = vec![Some(msp.clone())];
+        let data = DecimalBytePartsData::try_new(msp.dtype(), msp.len(), decimal_dtype)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(DecimalByteParts, dtype, len, data).with_slots(slots),
+            )
+        })
     }
 }
 
@@ -260,7 +278,7 @@ fn to_canonical_decimal(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     // TODO(joe): support parts len != 1
-    let prim = array.msp.clone().execute::<PrimitiveArray>(ctx)?;
+    let prim = array.msp().clone().execute::<PrimitiveArray>(ctx)?;
     // Depending on the decimal type and the min/max of the primitive array we can choose
     // the correct buffer size
 
@@ -270,56 +288,47 @@ fn to_canonical_decimal(
         unsafe {
             DecimalArray::new_unchecked(
                 prim.to_buffer::<P>(),
-                *array.decimal_dtype(),
-                prim.validity().clone(),
+                *array
+                    .dtype()
+                    .as_decimal_opt()
+                    .vortex_expect("must be a decimal dtype"),
+                prim.validity()?,
             )
         }
         .into_array()
     }))
 }
 
-impl OperationsVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
-    fn scalar_at(array: &DecimalBytePartsArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<DecimalByteParts> for DecimalByteParts {
+    fn scalar_at(
+        array: ArrayView<'_, DecimalByteParts>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // TODO(joe): support parts len != 1
-        let scalar = array.msp.scalar_at(index)?;
+        let scalar = array.msp().scalar_at(index)?;
 
         // Note. values in msp, can only be signed integers upto size i64.
         let primitive_scalar = scalar.as_primitive();
         // TODO(joe): extend this to support multiple parts.
         let value = primitive_scalar.as_::<i64>().vortex_expect("non-null");
         Scalar::try_new(
-            array.dtype.clone(),
+            array.dtype().clone(),
             Some(ScalarValue::Decimal(DecimalValue::I64(value))),
         )
     }
 }
 
-impl ValidityChild<DecimalBytePartsVTable> for DecimalBytePartsVTable {
-    fn validity_child(array: &DecimalBytePartsArray) -> &ArrayRef {
+impl ValidityChild<DecimalByteParts> for DecimalByteParts {
+    fn validity_child(array: ArrayView<'_, DecimalByteParts>) -> ArrayRef {
         // validity stored in 0th child
-        &array.msp
-    }
-}
-
-impl VisitorVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
-    fn visit_buffers(_array: &DecimalBytePartsArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &DecimalBytePartsArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &DecimalBytePartsArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("msp", &array.msp);
-    }
-
-    fn nchildren(_array: &DecimalBytePartsArray) -> usize {
-        1
+        array.msp().clone()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::dtype::DType;
@@ -331,22 +340,22 @@ mod tests {
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
-    use crate::DecimalBytePartsArray;
+    use crate::DecimalByteParts;
 
     #[test]
     fn test_scalar_at_decimal_parts() {
         let decimal_dtype = DecimalDType::new(8, 2);
         let dtype = DType::Decimal(decimal_dtype, Nullability::Nullable);
-        let array = DecimalBytePartsArray::try_new(
+        let array = DecimalByteParts::try_new(
             PrimitiveArray::new(
                 buffer![100i32, 200i32, 400i32],
-                Validity::Array(BoolArray::from_iter(vec![false, true, true]).to_array()),
+                Validity::Array(BoolArray::from_iter(vec![false, true, true]).into_array()),
             )
-            .to_array(),
+            .into_array(),
             decimal_dtype,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         assert_eq!(Scalar::null(dtype.clone()), array.scalar_at(0).unwrap());
         assert_eq!(
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/rules.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/rules.rs
index 0155d657606..7fafa0d5289 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/rules.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/rules.rs
@@ -1,40 +1,40 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterArray;
-use vortex_array::arrays::FilterReduceAdaptor;
-use vortex_array::arrays::FilterVTable;
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::Filter;
+use vortex_array::arrays::filter::FilterReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ArrayParentReduceRule;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-pub(super) const PARENT_RULES: ParentRuleSet<DecimalBytePartsVTable> = ParentRuleSet::new(&[
+pub(super) const PARENT_RULES: ParentRuleSet<DecimalByteParts> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&DecimalBytePartsFilterPushDownRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(DecimalBytePartsVTable)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(DecimalBytePartsVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DecimalBytePartsVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DecimalBytePartsVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(DecimalByteParts)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(DecimalByteParts)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(DecimalByteParts)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(DecimalByteParts)),
 ]);
 
 #[derive(Debug)]
 struct DecimalBytePartsFilterPushDownRule;
 
-impl ArrayParentReduceRule<DecimalBytePartsVTable> for DecimalBytePartsFilterPushDownRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<DecimalByteParts> for DecimalBytePartsFilterPushDownRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &DecimalBytePartsArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, DecimalByteParts>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // TODO(ngates): we should benchmark whether to push-down filters with "lower parts".
@@ -43,9 +43,15 @@ impl ArrayParentReduceRule<DecimalBytePartsVTable> for DecimalBytePartsFilterPus
             return Ok(None);
         }
 
-        let new_msp = child.msp.filter(parent.filter_mask().clone())?;
-        let new_child =
-            DecimalBytePartsArray::try_new(new_msp, *child.decimal_dtype())?.into_array();
+        let new_msp = child.msp().filter(parent.filter_mask().clone())?;
+        let new_child = DecimalByteParts::try_new(
+            new_msp,
+            *child
+                .dtype()
+                .as_decimal_opt()
+                .vortex_expect("must be a decimal dtype"),
+        )?
+        .into_array();
         Ok(Some(new_child))
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/slice.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/slice.rs
index 656ce4eccf5..a9c022d2051 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/slice.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/slice.rs
@@ -4,19 +4,26 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::DecimalBytePartsArray;
-use crate::DecimalBytePartsVTable;
+use crate::DecimalByteParts;
+use crate::decimal_byte_parts::DecimalBytePartsArrayExt;
 
-impl SliceReduce for DecimalBytePartsVTable {
-    fn slice(array: &DecimalBytePartsArray, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        // SAFETY: slicing encoded MSP does not change the encoded values
-        Ok(Some(unsafe {
-            DecimalBytePartsArray::new_unchecked(array.msp().slice(range)?, *array.decimal_dtype())
-                .into_array()
-        }))
+impl SliceReduce for DecimalByteParts {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        Ok(Some(
+            DecimalByteParts::try_new(
+                array.msp().slice(range)?,
+                *array
+                    .dtype()
+                    .as_decimal_opt()
+                    .vortex_expect("must be a decimal dtype"),
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/decimal-byte-parts/src/lib.rs b/encodings/decimal-byte-parts/src/lib.rs
index e97cd6becef..58c2d1dc69a 100644
--- a/encodings/decimal-byte-parts/src/lib.rs
+++ b/encodings/decimal-byte-parts/src/lib.rs
@@ -3,6 +3,7 @@
 
 mod decimal_byte_parts;
 
+use decimal_byte_parts::compute::is_constant::DecimalBytePartsIsConstantKernel;
 /// This encoding allow compression of decimals using integer compression schemes.
 /// Decimals can be compressed by narrowing the signed decimal value into the smallest signed value,
 /// then integer compression if that is a value `ptype`, otherwise the decimal can be split into
@@ -12,3 +13,19 @@ mod decimal_byte_parts;
 /// an i128 decimal could be converted into a [i64, u64] with further narrowing applied to either
 /// value.
 pub use decimal_byte_parts::*;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
+
+/// Initialize decimal-byte-parts encoding in the given session.
+pub fn initialize(session: &VortexSession) {
+    session.arrays().register(DecimalByteParts);
+
+    session.aggregate_fns().register_aggregate_kernel(
+        DecimalByteParts::ID,
+        Some(IsConstant.id()),
+        &DecimalBytePartsIsConstantKernel,
+    );
+}
diff --git a/encodings/fastlanes/Cargo.toml b/encodings/fastlanes/Cargo.toml
index 5c99b1e2157..a14e19389bc 100644
--- a/encodings/fastlanes/Cargo.toml
+++ b/encodings/fastlanes/Cargo.toml
@@ -17,7 +17,6 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
-arrayref = { workspace = true }
 fastlanes = { workspace = true }
 itertools = { workspace = true }
 lending-iterator = { workspace = true }
@@ -55,3 +54,8 @@ required-features = ["_test-harness"]
 name = "compute_between"
 harness = false
 required-features = ["_test-harness"]
+
+[[bench]]
+name = "bit_transpose"
+harness = false
+required-features = ["_test-harness"]
diff --git a/encodings/fastlanes/benches/bit_transpose.rs b/encodings/fastlanes/benches/bit_transpose.rs
new file mode 100644
index 00000000000..4bc9027cc28
--- /dev/null
+++ b/encodings/fastlanes/benches/bit_transpose.rs
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+
+use divan::Bencher;
+use vortex_fastlanes::bit_transpose::scalar::transpose_bits_scalar;
+use vortex_fastlanes::bit_transpose::scalar::untranspose_bits_scalar;
+
+fn main() {
+    divan::main();
+}
+
+/// Generate deterministic test data.
+#[allow(clippy::cast_possible_truncation)]
+fn generate_test_data(seed: usize) -> [u8; 128] {
+    let mut data = [0u8; 128];
+    for (i, byte) in data.iter_mut().enumerate() {
+        *byte = seed.wrapping_mul(17).wrapping_add(i).wrapping_mul(31) as u8;
+    }
+    data
+}
+
+const BATCH_SIZE: usize = 1000;
+
+// ============================================================================
+// Transpose: single array
+// ============================================================================
+
+#[divan::bench]
+fn transpose_scalar(bencher: Bencher) {
+    let input = generate_test_data(42);
+
+    bencher
+        .with_inputs(|| (&input, [0u8; 128]))
+        .bench_refs(|(input, output)| {
+            transpose_bits_scalar(input, output);
+        });
+}
+
+// ============================================================================
+// Transpose: throughput (1000 arrays)
+// ============================================================================
+
+#[divan::bench]
+fn transpose_scalar_throughput(bencher: Bencher) {
+    let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+    bencher
+        .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+        .bench_refs(|(inputs, outputs)| {
+            for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                transpose_bits_scalar(input, output);
+            }
+        });
+}
+
+// ============================================================================
+// Untranspose: single array
+// ============================================================================
+
+#[divan::bench]
+fn untranspose_scalar(bencher: Bencher) {
+    let input = generate_test_data(42);
+
+    bencher
+        .with_inputs(|| (&input, [0u8; 128]))
+        .bench_refs(|(input, output)| {
+            untranspose_bits_scalar(input, output);
+        });
+}
+
+// ============================================================================
+// Untranspose: throughput (1000 arrays)
+// ============================================================================
+
+#[divan::bench]
+fn untranspose_scalar_throughput(bencher: Bencher) {
+    let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+    bencher
+        .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+        .bench_refs(|(inputs, outputs)| {
+            for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                untranspose_bits_scalar(input, output);
+            }
+        });
+}
+
+// ============================================================================
+// x86_64 benchmarks
+// ============================================================================
+
+#[cfg(target_arch = "x86_64")]
+mod x86 {
+    use divan::Bencher;
+    use vortex_fastlanes::bit_transpose::x86::has_bmi2;
+    use vortex_fastlanes::bit_transpose::x86::has_vbmi;
+    use vortex_fastlanes::bit_transpose::x86::transpose_bits_bmi2;
+    use vortex_fastlanes::bit_transpose::x86::transpose_bits_vbmi;
+    use vortex_fastlanes::bit_transpose::x86::untranspose_bits_bmi2;
+    use vortex_fastlanes::bit_transpose::x86::untranspose_bits_vbmi;
+
+    use super::BATCH_SIZE;
+    use super::generate_test_data;
+
+    // --- Transpose: single array ---
+
+    #[divan::bench]
+    fn transpose_bmi2(bencher: Bencher) {
+        if !has_bmi2() {
+            return;
+        }
+
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { transpose_bits_bmi2(input, output) };
+            });
+    }
+
+    #[divan::bench]
+    fn transpose_vbmi(bencher: Bencher) {
+        if !has_vbmi() {
+            return;
+        }
+
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { transpose_bits_vbmi(input, output) };
+            });
+    }
+
+    // --- Untranspose: single array ---
+
+    #[divan::bench]
+    fn untranspose_bmi2(bencher: Bencher) {
+        if !has_bmi2() {
+            return;
+        }
+
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { untranspose_bits_bmi2(input, output) };
+            });
+    }
+
+    #[divan::bench]
+    fn untranspose_vbmi(bencher: Bencher) {
+        if !has_vbmi() {
+            return;
+        }
+
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { untranspose_bits_vbmi(input, output) };
+            });
+    }
+
+    // --- Transpose: throughput (1000 arrays) ---
+
+    #[divan::bench]
+    fn transpose_bmi2_throughput(bencher: Bencher) {
+        if !has_bmi2() {
+            return;
+        }
+
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { transpose_bits_bmi2(input, output) };
+                }
+            });
+    }
+
+    #[divan::bench]
+    fn transpose_vbmi_throughput(bencher: Bencher) {
+        if !has_vbmi() {
+            return;
+        }
+
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { transpose_bits_vbmi(input, output) };
+                }
+            });
+    }
+
+    // --- Untranspose: throughput (1000 arrays) ---
+
+    #[divan::bench]
+    fn untranspose_bmi2_throughput(bencher: Bencher) {
+        if !has_bmi2() {
+            return;
+        }
+
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { untranspose_bits_bmi2(input, output) };
+                }
+            });
+    }
+
+    #[divan::bench]
+    fn untranspose_vbmi_throughput(bencher: Bencher) {
+        if !has_vbmi() {
+            return;
+        }
+
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { untranspose_bits_vbmi(input, output) };
+                }
+            });
+    }
+}
+
+// ============================================================================
+// aarch64 benchmarks
+// ============================================================================
+
+#[cfg(target_arch = "aarch64")]
+mod aarch64 {
+    use vortex_fastlanes::bit_transpose::aarch64::transpose_bits_neon;
+    use vortex_fastlanes::bit_transpose::aarch64::untranspose_bits_neon;
+
+    use super::BATCH_SIZE;
+    use super::Bencher;
+    use super::generate_test_data;
+
+    // --- Transpose: single array ---
+
+    #[divan::bench]
+    fn transpose_neon(bencher: Bencher) {
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { transpose_bits_neon(input, output) };
+            });
+    }
+
+    // --- Untranspose: single array ---
+
+    #[divan::bench]
+    fn untranspose_neon(bencher: Bencher) {
+        let input = generate_test_data(42);
+
+        bencher
+            .with_inputs(|| (&input, [0u8; 128]))
+            .bench_refs(|(input, output)| {
+                unsafe { untranspose_bits_neon(input, output) };
+            });
+    }
+
+    // --- Transpose: throughput (1000 arrays) ---
+
+    #[divan::bench]
+    fn transpose_neon_throughput(bencher: Bencher) {
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { transpose_bits_neon(input, output) };
+                }
+            });
+    }
+
+    // --- Untranspose: throughput (1000 arrays) ---
+
+    #[divan::bench]
+    fn untranspose_neon_throughput(bencher: Bencher) {
+        let inputs: Vec<[u8; 128]> = (0..BATCH_SIZE).map(generate_test_data).collect();
+
+        bencher
+            .with_inputs(|| (&inputs, vec![[0u8; 128]; BATCH_SIZE]))
+            .bench_refs(|(inputs, outputs)| {
+                for (input, output) in inputs.iter().zip(outputs.iter_mut()) {
+                    unsafe { untranspose_bits_neon(input, output) };
+                }
+            });
+    }
+}
diff --git a/encodings/fastlanes/benches/bitpacking_take.rs b/encodings/fastlanes/benches/bitpacking_take.rs
index a71c5655b3f..61bd234c0f1 100644
--- a/encodings/fastlanes/benches/bitpacking_take.rs
+++ b/encodings/fastlanes/benches/bitpacking_take.rs
@@ -5,39 +5,37 @@
 #![allow(clippy::cast_possible_truncation)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::prelude::StdRng;
-use vortex_array::Array;
 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::compute::warm_up_vtables;
 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;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
 #[divan::bench]
 fn take_10_stratified(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
-    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 10_000));
+    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_553));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -46,7 +44,7 @@ fn take_10_stratified(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10_contiguous(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
     let indices = buffer![0..10].into_array();
@@ -55,7 +53,7 @@ fn take_10_contiguous(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -64,7 +62,7 @@ fn take_10_contiguous(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10k_random(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let range = Uniform::new(0, values.len()).unwrap();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
@@ -76,7 +74,7 @@ fn take_10k_random(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -85,7 +83,7 @@ fn take_10k_random(bencher: Bencher) {
 
 #[divan::bench]
 fn take_10k_contiguous(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+    let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed = bitpack_to_best_bit_width(&uncompressed).unwrap();
     let indices = PrimitiveArray::from_iter(0..10_000);
@@ -94,7 +92,7 @@ fn take_10k_contiguous(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -102,17 +100,17 @@ fn take_10k_contiguous(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn take_200k_dispersed(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+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).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| (i * 42) % values.len() as u64));
+    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()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -120,17 +118,17 @@ fn take_200k_dispersed(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn take_200k_first_chunk_only(bencher: Bencher) {
-    let values = fixture(1_000_000, 8);
+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).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| ((i * 42) % 1024) as u64));
+    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()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -154,8 +152,8 @@ fn fixture(len: usize, bits: usize) -> Buffer<u32> {
 // I've iterated on both thresholds (1) and (2) using this collection of benchmarks, and those
 // were roughly the best values that I found.
 
-const BIG_BASE2: u32 = 1048576;
-const NUM_EXCEPTIONS: u32 = 10000;
+const BIG_BASE2: u32 = 65536;
+const NUM_EXCEPTIONS: u32 = 1024;
 
 #[divan::bench]
 fn patched_take_10_stratified(bencher: Bencher) {
@@ -169,13 +167,13 @@ fn patched_take_10_stratified(bencher: Bencher) {
         NUM_EXCEPTIONS as usize
     );
 
-    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 10_000));
+    let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_653));
 
     bencher
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -200,7 +198,7 @@ fn patched_take_10_contiguous(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -221,7 +219,7 @@ fn patched_take_10k_random(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -239,7 +237,7 @@ fn patched_take_10k_contiguous_not_patches(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -265,7 +263,7 @@ fn patched_take_10k_contiguous_patches(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -273,17 +271,17 @@ fn patched_take_10k_contiguous_patches(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn patched_take_200k_dispersed(bencher: Bencher) {
+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).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| (i * 42) % values.len() as u64));
+    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()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -291,17 +289,17 @@ fn patched_take_200k_dispersed(bencher: Bencher) {
 }
 
 #[divan::bench]
-fn patched_take_200k_first_chunk_only(bencher: Bencher) {
+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).unwrap();
-    let indices = PrimitiveArray::from_iter((0..200_000).map(|i| ((i * 42) % 1024) as u64));
+    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()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -326,7 +324,7 @@ fn patched_take_10k_adversarial(bencher: Bencher) {
         .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
-                .take(indices.to_array())
+                .take(indices.clone().into_array())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
diff --git a/encodings/fastlanes/benches/canonicalize_bench.rs b/encodings/fastlanes/benches/canonicalize_bench.rs
index e18c47c778f..e6942067fca 100644
--- a/encodings/fastlanes/benches/canonicalize_bench.rs
+++ b/encodings/fastlanes/benches/canonicalize_bench.rs
@@ -6,21 +6,18 @@ use std::sync::LazyLock;
 use divan::Bencher;
 use rand::SeedableRng;
 use rand::prelude::StdRng;
-use vortex_array::Array;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::PrimitiveBuilder;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::session::ArraySession;
 use vortex_error::VortexExpect;
 use vortex_fastlanes::bitpack_compress::test_harness::make_array;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
diff --git a/encodings/fastlanes/benches/compute_between.rs b/encodings/fastlanes/benches/compute_between.rs
index 56ddb0e8444..a490a7bd544 100644
--- a/encodings/fastlanes/benches/compute_between.rs
+++ b/encodings/fastlanes/benches/compute_between.rs
@@ -3,21 +3,21 @@
 #![expect(clippy::unwrap_used)]
 
 use num_traits::NumCast;
-use rand::Rng;
+use rand::RngExt;
 use rand::rngs::StdRng;
-use vortex_alp::ALPArray;
+use vortex_alp::ALP;
+use vortex_alp::ALPArrayExt;
+use vortex_alp::ALPArraySlotsExt;
 use vortex_alp::alp_encode;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::dtype::NativePType;
 use vortex_error::VortexExpect;
 use vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -56,7 +56,7 @@ fn generate_alp_bit_pack_primitive_array<T: NativePType + NumCast>(
     let bp = bitpack_to_best_bit_width(&encoded)
         .vortex_expect("")
         .into_array();
-    ALPArray::new(bp, alp.exponents(), None).into_array()
+    ALP::new(bp, alp.exponents(), None).into_array()
 }
 
 const BENCH_ARGS: &[usize] = &[2 << 10, 2 << 13, 2 << 14];
@@ -99,14 +99,16 @@ mod primitive {
             .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 let gte = arr
-                    .to_array()
+                    .clone()
+                    .into_array()
                     .binary(
                         ConstantArray::new(min, arr.len()).into_array(),
                         Operator::Gte,
                     )
                     .vortex_expect("");
                 let lt = arr
-                    .to_array()
+                    .clone()
+                    .into_array()
                     .binary(
                         ConstantArray::new(max, arr.len()).into_array(),
                         Operator::Lt,
@@ -135,7 +137,8 @@ mod primitive {
         bencher
             .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
-                arr.to_array()
+                arr.clone()
+                    .into_array()
                     .between(
                         ConstantArray::new(min, arr.len()).into_array(),
                         ConstantArray::new(max, arr.len()).into_array(),
@@ -189,14 +192,14 @@ mod bitpack {
             .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 let gte = arr
-                    .to_array()
+                    .clone()
                     .binary(
                         ConstantArray::new(min, arr.len()).into_array(),
                         Operator::Gte,
                     )
                     .vortex_expect("");
                 let lt = arr
-                    .to_array()
+                    .clone()
                     .binary(
                         ConstantArray::new(max, arr.len()).into_array(),
                         Operator::Lt,
@@ -280,14 +283,14 @@ mod alp {
             .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 let gte = arr
-                    .to_array()
+                    .clone()
                     .binary(
                         ConstantArray::new(min, arr.len()).into_array(),
                         Operator::Gte,
                     )
                     .vortex_expect("");
                 let lt = arr
-                    .to_array()
+                    .clone()
                     .binary(
                         ConstantArray::new(max, arr.len()).into_array(),
                         Operator::Lt,
diff --git a/encodings/fastlanes/goldenfiles/for.metadata b/encodings/fastlanes/goldenfiles/for.metadata
new file mode 100644
index 00000000000..0e9da711b3e
--- /dev/null
+++ b/encodings/fastlanes/goldenfiles/for.metadata
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/encodings/fastlanes/public-api.lock b/encodings/fastlanes/public-api.lock
index 67f46364d15..15cc889bf9f 100644
--- a/encodings/fastlanes/public-api.lock
+++ b/encodings/fastlanes/public-api.lock
@@ -1,22 +1,36 @@
 pub mod vortex_fastlanes
 
+pub mod vortex_fastlanes::bit_transpose
+
+pub fn vortex_fastlanes::bit_transpose::transpose_bitbuffer(bits: vortex_buffer::bit::buf::BitBuffer) -> vortex_buffer::bit::buf::BitBuffer
+
+pub fn vortex_fastlanes::bit_transpose::transpose_bits(input: &[u8; 128], output: &mut [u8; 128])
+
+pub fn vortex_fastlanes::bit_transpose::transpose_validity(validity: &vortex_array::validity::Validity, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+
+pub fn vortex_fastlanes::bit_transpose::untranspose_bitbuffer(bits: vortex_buffer::bit::buf::BitBuffer) -> vortex_buffer::bit::buf::BitBuffer
+
+pub fn vortex_fastlanes::bit_transpose::untranspose_bits(input: &[u8; 128], output: &mut [u8; 128])
+
+pub fn vortex_fastlanes::bit_transpose::untranspose_validity(validity: &vortex_array::validity::Validity, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+
 pub mod vortex_fastlanes::bitpack_compress
 
-pub fn vortex_fastlanes::bitpack_compress::bit_width_histogram(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<alloc::vec::Vec<usize>>
+pub fn vortex_fastlanes::bitpack_compress::bit_width_histogram(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<alloc::vec::Vec<usize>>
 
-pub fn vortex_fastlanes::bitpack_compress::bitpack_encode(array: &vortex_array::arrays::primitive::array::PrimitiveArray, bit_width: u8, bit_width_freq: core::option::Option<&[usize]>) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
+pub fn vortex_fastlanes::bitpack_compress::bitpack_encode(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray, bit_width: u8, bit_width_freq: core::option::Option<&[usize]>) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
-pub unsafe fn vortex_fastlanes::bitpack_compress::bitpack_encode_unchecked(array: vortex_array::arrays::primitive::array::PrimitiveArray, bit_width: u8) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
+pub unsafe fn vortex_fastlanes::bitpack_compress::bitpack_encode_unchecked(array: vortex_array::arrays::primitive::vtable::PrimitiveArray, bit_width: u8) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
 pub fn vortex_fastlanes::bitpack_compress::bitpack_primitive<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(array: &[T], bit_width: u8) -> vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
+pub fn vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
-pub unsafe fn vortex_fastlanes::bitpack_compress::bitpack_unchecked(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, bit_width: u8) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
+pub unsafe fn vortex_fastlanes::bitpack_compress::bitpack_unchecked(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, bit_width: u8) -> vortex_buffer::ByteBuffer
 
 pub fn vortex_fastlanes::bitpack_compress::find_best_bit_width(ptype: vortex_array::dtype::ptype::PType, bit_width_freq: &[usize]) -> vortex_error::VortexResult<u8>
 
-pub fn vortex_fastlanes::bitpack_compress::gather_patches(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, bit_width: u8, num_exceptions_hint: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::patches::Patches>>
+pub fn vortex_fastlanes::bitpack_compress::gather_patches(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, bit_width: u8, num_exceptions_hint: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::patches::Patches>>
 
 pub mod vortex_fastlanes::bitpack_decompress
 
@@ -26,18 +40,14 @@ pub fn vortex_fastlanes::bitpack_decompress::apply_patches_to_uninit_range_fn<T:
 
 pub fn vortex_fastlanes::bitpack_decompress::count_exceptions(bit_width: u8, bit_width_freq: &[usize]) -> usize
 
-pub fn vortex_fastlanes::bitpack_decompress::unpack_array(array: &vortex_fastlanes::BitPackedArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::array::PrimitiveArray>
+pub fn vortex_fastlanes::bitpack_decompress::unpack_array(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::BitPacked>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::vtable::PrimitiveArray>
 
-pub fn vortex_fastlanes::bitpack_decompress::unpack_primitive_array<T: vortex_fastlanes::unpack_iter::BitPacked>(array: &vortex_fastlanes::BitPackedArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::array::PrimitiveArray>
+pub fn vortex_fastlanes::bitpack_decompress::unpack_primitive_array<T: vortex_fastlanes::unpack_iter::BitPacked>(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::BitPacked>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::vtable::PrimitiveArray>
 
-pub fn vortex_fastlanes::bitpack_decompress::unpack_single(array: &vortex_fastlanes::BitPackedArray, index: usize) -> vortex_array::scalar::Scalar
+pub fn vortex_fastlanes::bitpack_decompress::unpack_single(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::BitPacked>, index: usize) -> vortex_array::scalar::Scalar
 
 pub unsafe fn vortex_fastlanes::bitpack_decompress::unpack_single_primitive<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(packed: &[T], bit_width: usize, index_to_decode: usize) -> T
 
-pub fn vortex_fastlanes::bitpack_decompress::unpack_to_primitive(array: &vortex_fastlanes::BitPackedArray) -> vortex_array::arrays::primitive::array::PrimitiveArray
-
-pub fn vortex_fastlanes::bitpack_decompress::unpack_to_primitive_typed<P: vortex_fastlanes::unpack_iter::BitPacked>(array: &vortex_fastlanes::BitPackedArray) -> vortex_array::arrays::primitive::array::PrimitiveArray
-
 pub mod vortex_fastlanes::unpack_iter
 
 pub struct vortex_fastlanes::unpack_iter::BitPackingStrategy
@@ -68,15 +78,15 @@ pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, S>::decode_into(&mut sel
 
 pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, S>::initial(&mut self) -> core::option::Option<&mut [T]>
 
-pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, S>::new_with_strategy(strategy: S, packed: vortex_buffer::ByteBuffer, bit_width: usize, offset: usize, len: usize) -> Self
-
 pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, S>::trailer(&mut self) -> core::option::Option<&mut [T]>
 
+pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, S>::try_new_with_strategy(strategy: S, packed: vortex_buffer::ByteBuffer, bit_width: usize, offset: usize, len: usize) -> vortex_error::VortexResult<Self>
+
 impl<T: vortex_fastlanes::unpack_iter::BitPacked> vortex_fastlanes::unpack_iter::UnpackedChunks<T, vortex_fastlanes::unpack_iter::BitPackingStrategy>
 
 pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, vortex_fastlanes::unpack_iter::BitPackingStrategy>::full_chunks(&mut self) -> vortex_fastlanes::unpack_iter::BitUnpackIterator<'_, T>
 
-pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, vortex_fastlanes::unpack_iter::BitPackingStrategy>::new(array: &vortex_fastlanes::BitPackedArray) -> Self
+pub fn vortex_fastlanes::unpack_iter::UnpackedChunks<T, vortex_fastlanes::unpack_iter::BitPackingStrategy>::try_new(array: &vortex_fastlanes::BitPackedData, len: usize) -> vortex_error::VortexResult<Self>
 
 pub trait vortex_fastlanes::unpack_iter::BitPacked: vortex_array::dtype::ptype::PhysicalPType<Physicalfastlanes::bitpacking::BitPacking>
 
@@ -106,574 +116,566 @@ pub unsafe fn vortex_fastlanes::unpack_iter::BitPackingStrategy::unpack_chunk(&s
 
 pub type vortex_fastlanes::unpack_iter::BitUnpackedChunks<T> = vortex_fastlanes::unpack_iter::UnpackedChunks<T, vortex_fastlanes::unpack_iter::BitPackingStrategy>
 
-pub struct vortex_fastlanes::BitPackedArray
-
-impl vortex_fastlanes::BitPackedArray
-
-pub fn vortex_fastlanes::BitPackedArray::bit_width(&self) -> u8
-
-pub fn vortex_fastlanes::BitPackedArray::encode(array: &dyn vortex_array::array::Array, bit_width: u8) -> vortex_error::VortexResult<Self>
-
-pub fn vortex_fastlanes::BitPackedArray::into_parts(self) -> vortex_fastlanes::BitPackedArrayParts
+pub struct vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::max_packed_value(&self) -> usize
+impl vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::offset(&self) -> u16
+pub const vortex_fastlanes::BitPacked::ID: vortex_array::array::ArrayId
 
-pub fn vortex_fastlanes::BitPackedArray::packed(&self) -> &vortex_array::buffer::BufferHandle
+pub fn vortex_fastlanes::BitPacked::encode(array: &vortex_array::array::erased::ArrayRef, bit_width: u8) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
-pub fn vortex_fastlanes::BitPackedArray::packed_slice<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(&self) -> &[T]
+pub fn vortex_fastlanes::BitPacked::into_parts(array: vortex_fastlanes::BitPackedArray) -> vortex_fastlanes::BitPackedDataParts
 
-pub fn vortex_fastlanes::BitPackedArray::patches(&self) -> core::option::Option<&vortex_array::patches::Patches>
+pub fn vortex_fastlanes::BitPacked::try_new(packed: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::ptype::PType, validity: vortex_array::validity::Validity, patches: core::option::Option<vortex_array::patches::Patches>, bit_width: u8, len: usize, offset: u16) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
-pub fn vortex_fastlanes::BitPackedArray::ptype(&self) -> vortex_array::dtype::ptype::PType
+impl core::clone::Clone for vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::replace_patches(&mut self, patches: core::option::Option<vortex_array::patches::Patches>)
+pub fn vortex_fastlanes::BitPacked::clone(&self) -> vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::try_new(packed: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::ptype::PType, validity: vortex_array::validity::Validity, patches: core::option::Option<vortex_array::patches::Patches>, bit_width: u8, length: usize, offset: u16) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::unpacked_chunks<T: vortex_fastlanes::unpack_iter::BitPacked>(&self) -> vortex_fastlanes::unpack_iter::BitUnpackedChunks<T>
+pub fn vortex_fastlanes::BitPacked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::clone::Clone for vortex_fastlanes::BitPackedArray
+impl vortex_array::array::vtable::VTable for vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::clone(&self) -> vortex_fastlanes::BitPackedArray
+pub type vortex_fastlanes::BitPacked::ArrayData = vortex_fastlanes::BitPackedData
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_fastlanes::BitPackedArray
+pub type vortex_fastlanes::BitPacked::OperationsVTable = vortex_fastlanes::BitPacked
 
-pub fn vortex_fastlanes::BitPackedArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_fastlanes::BitPacked::ValidityVTable = vortex_fastlanes::BitPacked
 
-impl core::convert::From<vortex_fastlanes::BitPackedArray> for vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPacked::append_to_builder(array: vortex_array::array::view::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_fastlanes::BitPackedArray) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPacked::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::fmt::Debug for vortex_fastlanes::BitPackedArray
+pub fn vortex_fastlanes::BitPacked::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_fastlanes::BitPackedArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fastlanes::BitPacked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-impl core::ops::deref::Deref for vortex_fastlanes::BitPackedArray
+pub fn vortex_fastlanes::BitPacked::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub type vortex_fastlanes::BitPackedArray::Target = dyn vortex_array::array::Array
+pub fn vortex_fastlanes::BitPacked::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::BitPackedArray::deref(&self) -> &Self::Target
+pub fn vortex_fastlanes::BitPacked::id(&self) -> vortex_array::array::ArrayId
 
-impl vortex_array::array::IntoArray for vortex_fastlanes::BitPackedArray
+pub fn vortex_fastlanes::BitPacked::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_fastlanes::BitPackedArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPacked::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::validity::ValidityHelper for vortex_fastlanes::BitPackedArray
+pub fn vortex_fastlanes::BitPacked::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_fastlanes::BitPackedArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_fastlanes::BitPacked::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_fastlanes::BitPackedArrayParts
+pub fn vortex_fastlanes::BitPacked::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_fastlanes::BitPackedArrayParts::bit_width: u8
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_fastlanes::BitPacked> for vortex_fastlanes::BitPacked
 
-pub vortex_fastlanes::BitPackedArrayParts::len: usize
+pub fn vortex_fastlanes::BitPacked::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::BitPacked>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_fastlanes::BitPackedArrayParts::offset: u16
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_fastlanes::BitPacked> for vortex_fastlanes::BitPacked
 
-pub vortex_fastlanes::BitPackedArrayParts::packed: vortex_array::buffer::BufferHandle
+pub fn vortex_fastlanes::BitPacked::validity(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::BitPacked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_fastlanes::BitPackedArrayParts::patches: core::option::Option<vortex_array::patches::Patches>
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_fastlanes::BitPacked
 
-pub vortex_fastlanes::BitPackedArrayParts::validity: vortex_array::validity::Validity
+pub fn vortex_fastlanes::BitPacked::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub struct vortex_fastlanes::BitPackedVTable
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_fastlanes::BitPacked
 
-impl vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPacked::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub const vortex_fastlanes::BitPackedVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::arrays::slice::SliceReduce for vortex_fastlanes::BitPacked
 
-impl core::fmt::Debug for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPacked::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::BitPackedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::BitPacked
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPacked::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::BitPackedVTable::take(array: &vortex_fastlanes::BitPackedArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_fastlanes::BitPackedData
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_fastlanes::BitPackedVTable
+impl vortex_fastlanes::BitPackedData
 
-pub fn vortex_fastlanes::BitPackedVTable::filter(array: &vortex_fastlanes::BitPackedArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedData::bit_width(&self) -> u8
 
-impl vortex_array::arrays::slice::SliceKernel for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPackedData::encode(array: &vortex_array::array::erased::ArrayRef, bit_width: u8) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
 
-pub fn vortex_fastlanes::BitPackedVTable::slice(array: &vortex_fastlanes::BitPackedArray, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedData::max_packed_value(&self) -> usize
 
-impl vortex_array::compute::is_constant::IsConstantKernel for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPackedData::offset(&self) -> u16
 
-pub fn vortex_fastlanes::BitPackedVTable::is_constant(&self, array: &vortex_fastlanes::BitPackedArray, opts: &vortex_array::compute::is_constant::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_fastlanes::BitPackedData::packed(&self) -> &vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPackedData::packed_slice<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(&self) -> &[T]
 
-pub fn vortex_fastlanes::BitPackedVTable::cast(array: &vortex_fastlanes::BitPackedArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedData::ptype(&self, dtype: &vortex_array::dtype::DType) -> vortex_array::dtype::ptype::PType
 
-impl vortex_array::vtable::VTable for vortex_fastlanes::BitPackedVTable
+pub fn vortex_fastlanes::BitPackedData::try_new(packed: vortex_array::buffer::BufferHandle, patches: core::option::Option<vortex_array::patches::Patches>, bit_width: u8, offset: u16) -> vortex_error::VortexResult<Self>
 
-pub type vortex_fastlanes::BitPackedVTable::Array = vortex_fastlanes::BitPackedArray
+pub fn vortex_fastlanes::BitPackedData::unpacked_chunks<T: vortex_fastlanes::unpack_iter::BitPacked>(&self, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<vortex_fastlanes::unpack_iter::BitUnpackedChunks<T>>
 
-pub type vortex_fastlanes::BitPackedVTable::ArrayVTable = vortex_fastlanes::BitPackedVTable
+impl core::clone::Clone for vortex_fastlanes::BitPackedData
 
-pub type vortex_fastlanes::BitPackedVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_fastlanes::bitpacking::vtable::BitPackedMetadata>
+pub fn vortex_fastlanes::BitPackedData::clone(&self) -> vortex_fastlanes::BitPackedData
 
-pub type vortex_fastlanes::BitPackedVTable::OperationsVTable = vortex_fastlanes::BitPackedVTable
+impl core::fmt::Debug for vortex_fastlanes::BitPackedData
 
-pub type vortex_fastlanes::BitPackedVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromValidityHelper
+pub fn vortex_fastlanes::BitPackedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_fastlanes::BitPackedVTable::VisitorVTable = vortex_fastlanes::BitPackedVTable
+impl core::fmt::Display for vortex_fastlanes::BitPackedData
 
-pub fn vortex_fastlanes::BitPackedVTable::append_to_builder(array: &vortex_fastlanes::BitPackedArray, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_fastlanes::BitPackedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fastlanes::BitPackedVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_fastlanes::BitPackedArray>
+impl vortex_array::hash::ArrayEq for vortex_fastlanes::BitPackedData
 
-pub fn vortex_fastlanes::BitPackedVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_fastlanes::BitPackedData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_fastlanes::BitPackedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl vortex_array::hash::ArrayHash for vortex_fastlanes::BitPackedData
 
-pub fn vortex_fastlanes::BitPackedVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-pub fn vortex_fastlanes::BitPackedVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub struct vortex_fastlanes::BitPackedDataParts
 
-pub fn vortex_fastlanes::BitPackedVTable::metadata(array: &vortex_fastlanes::BitPackedArray) -> vortex_error::VortexResult<Self::Metadata>
+pub vortex_fastlanes::BitPackedDataParts::bit_width: u8
 
-pub fn vortex_fastlanes::BitPackedVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_fastlanes::BitPackedDataParts::len: usize
 
-pub fn vortex_fastlanes::BitPackedVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub vortex_fastlanes::BitPackedDataParts::offset: u16
 
-pub fn vortex_fastlanes::BitPackedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub vortex_fastlanes::BitPackedDataParts::packed: vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_fastlanes::BitPackedVTable> for vortex_fastlanes::BitPackedVTable
+pub vortex_fastlanes::BitPackedDataParts::patches: core::option::Option<vortex_array::patches::Patches>
 
-pub fn vortex_fastlanes::BitPackedVTable::array_eq(array: &vortex_fastlanes::BitPackedArray, other: &vortex_fastlanes::BitPackedArray, precision: vortex_array::hash::Precision) -> bool
+pub vortex_fastlanes::BitPackedDataParts::validity: vortex_array::validity::Validity
 
-pub fn vortex_fastlanes::BitPackedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_fastlanes::BitPackedArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub struct vortex_fastlanes::BitPackedSlots
 
-pub fn vortex_fastlanes::BitPackedVTable::dtype(array: &vortex_fastlanes::BitPackedArray) -> &vortex_array::dtype::DType
+pub vortex_fastlanes::BitPackedSlots::patch_chunk_offsets: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_fastlanes::BitPackedVTable::len(array: &vortex_fastlanes::BitPackedArray) -> usize
+pub vortex_fastlanes::BitPackedSlots::patch_indices: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_fastlanes::BitPackedVTable::stats(array: &vortex_fastlanes::BitPackedArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub vortex_fastlanes::BitPackedSlots::patch_values: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_fastlanes::BitPackedVTable> for vortex_fastlanes::BitPackedVTable
+pub vortex_fastlanes::BitPackedSlots::validity_child: core::option::Option<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_fastlanes::BitPackedVTable::scalar_at(array: &vortex_fastlanes::BitPackedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_fastlanes::BitPackedSlots
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_fastlanes::BitPackedVTable> for vortex_fastlanes::BitPackedVTable
+pub const vortex_fastlanes::BitPackedSlots::COUNT: usize
 
-pub fn vortex_fastlanes::BitPackedVTable::nbuffers(_array: &vortex_fastlanes::BitPackedArray) -> usize
+pub const vortex_fastlanes::BitPackedSlots::NAMES: [&'static str; 4]
 
-pub fn vortex_fastlanes::BitPackedVTable::nchildren(array: &vortex_fastlanes::BitPackedArray) -> usize
+pub const vortex_fastlanes::BitPackedSlots::PATCH_CHUNK_OFFSETS: usize
 
-pub fn vortex_fastlanes::BitPackedVTable::visit_buffers(array: &vortex_fastlanes::BitPackedArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub const vortex_fastlanes::BitPackedSlots::PATCH_INDICES: usize
 
-pub fn vortex_fastlanes::BitPackedVTable::visit_children(array: &vortex_fastlanes::BitPackedArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub const vortex_fastlanes::BitPackedSlots::PATCH_VALUES: usize
 
-pub struct vortex_fastlanes::DeltaArray
+pub const vortex_fastlanes::BitPackedSlots::VALIDITY_CHILD: usize
 
-impl vortex_fastlanes::DeltaArray
+pub fn vortex_fastlanes::BitPackedSlots::from_slots(slots: alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>) -> Self
 
-pub fn vortex_fastlanes::DeltaArray::bases(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPackedSlots::into_slots(self) -> alloc::vec::Vec<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::DeltaArray::deltas(&self) -> &vortex_array::array::ArrayRef
+pub struct vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::dtype(&self) -> &vortex_array::dtype::DType
+impl vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::is_empty(&self) -> bool
+pub const vortex_fastlanes::Delta::ID: vortex_array::array::ArrayId
 
-pub fn vortex_fastlanes::DeltaArray::len(&self) -> usize
+pub fn vortex_fastlanes::Delta::try_from_primitive_array(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_fastlanes::DeltaArray>
 
-pub fn vortex_fastlanes::DeltaArray::offset(&self) -> usize
+pub fn vortex_fastlanes::Delta::try_new(bases: vortex_array::array::erased::ArrayRef, deltas: vortex_array::array::erased::ArrayRef, offset: usize, len: usize) -> vortex_error::VortexResult<vortex_fastlanes::DeltaArray>
 
-pub fn vortex_fastlanes::DeltaArray::try_from_delta_compress_parts(bases: vortex_array::array::ArrayRef, deltas: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::try_from_primitive_array(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<Self>
+pub fn vortex_fastlanes::Delta::clone(&self) -> vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::try_from_vec<T: vortex_array::dtype::ptype::NativePType>(vec: alloc::vec::Vec<T>) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::try_new(bases: vortex_array::array::ArrayRef, deltas: vortex_array::array::ArrayRef, offset: usize, logical_len: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_fastlanes::Delta::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::clone::Clone for vortex_fastlanes::DeltaArray
+impl vortex_array::array::vtable::VTable for vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::clone(&self) -> vortex_fastlanes::DeltaArray
+pub type vortex_fastlanes::Delta::ArrayData = vortex_fastlanes::DeltaData
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_fastlanes::DeltaArray
+pub type vortex_fastlanes::Delta::OperationsVTable = vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_fastlanes::Delta::ValidityVTable = vortex_fastlanes::Delta
 
-impl core::convert::From<vortex_fastlanes::DeltaArray> for vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::Delta::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_fastlanes::DeltaArray) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::Delta::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::fmt::Debug for vortex_fastlanes::DeltaArray
+pub fn vortex_fastlanes::Delta::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_fastlanes::DeltaArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fastlanes::Delta::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-impl core::ops::deref::Deref for vortex_fastlanes::DeltaArray
+pub fn vortex_fastlanes::Delta::id(&self) -> vortex_array::array::ArrayId
 
-pub type vortex_fastlanes::DeltaArray::Target = dyn vortex_array::array::Array
+pub fn vortex_fastlanes::Delta::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_fastlanes::DeltaArray::deref(&self) -> &Self::Target
+pub fn vortex_fastlanes::Delta::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_fastlanes::DeltaArray
+pub fn vortex_fastlanes::Delta::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_fastlanes::DeltaArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::Delta::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::validity::ValidityChildSliceHelper for vortex_fastlanes::DeltaArray
+pub fn vortex_fastlanes::Delta::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_fastlanes::DeltaArray::unsliced_child_and_slice(&self) -> (&vortex_array::array::ArrayRef, usize, usize)
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_fastlanes::Delta> for vortex_fastlanes::Delta
 
-pub struct vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::Delta::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::Delta>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_fastlanes::DeltaVTable
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_fastlanes::Delta> for vortex_fastlanes::Delta
 
-pub const vortex_fastlanes::DeltaVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fastlanes::Delta::validity(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::Delta>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Debug for vortex_fastlanes::DeltaVTable
+impl vortex_array::arrays::slice::SliceReduce for vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fastlanes::Delta::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_fastlanes::DeltaVTable
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::Delta
 
-pub fn vortex_fastlanes::DeltaVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::Delta::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::DeltaVTable
+pub struct vortex_fastlanes::DeltaData
 
-pub fn vortex_fastlanes::DeltaVTable::cast(array: &vortex_fastlanes::DeltaArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_fastlanes::DeltaData
 
-impl vortex_array::vtable::VTable for vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::DeltaData::try_new(offset: usize) -> vortex_error::VortexResult<Self>
 
-pub type vortex_fastlanes::DeltaVTable::Array = vortex_fastlanes::DeltaArray
+impl core::clone::Clone for vortex_fastlanes::DeltaData
 
-pub type vortex_fastlanes::DeltaVTable::ArrayVTable = vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::DeltaData::clone(&self) -> vortex_fastlanes::DeltaData
 
-pub type vortex_fastlanes::DeltaVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_fastlanes::delta::vtable::DeltaMetadata>
+impl core::fmt::Debug for vortex_fastlanes::DeltaData
 
-pub type vortex_fastlanes::DeltaVTable::OperationsVTable = vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::DeltaData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_fastlanes::DeltaVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChildSliceHelper
+impl core::fmt::Display for vortex_fastlanes::DeltaData
 
-pub type vortex_fastlanes::DeltaVTable::VisitorVTable = vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::DeltaData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fastlanes::DeltaVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_fastlanes::DeltaArray>
+impl vortex_array::hash::ArrayEq for vortex_fastlanes::DeltaData
 
-pub fn vortex_fastlanes::DeltaVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_fastlanes::DeltaData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_fastlanes::DeltaVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl vortex_array::hash::ArrayHash for vortex_fastlanes::DeltaData
 
-pub fn vortex_fastlanes::DeltaVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fastlanes::DeltaData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_fastlanes::DeltaVTable::metadata(array: &vortex_fastlanes::DeltaArray) -> vortex_error::VortexResult<Self::Metadata>
+pub struct vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::DeltaVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::DeltaVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub const vortex_fastlanes::FoR::ID: vortex_array::array::ArrayId
 
-pub fn vortex_fastlanes::DeltaVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_fastlanes::FoR::encode(array: vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::FoRArray>
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_fastlanes::DeltaVTable> for vortex_fastlanes::DeltaVTable
+pub fn vortex_fastlanes::FoR::try_new(encoded: vortex_array::array::erased::ArrayRef, reference: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_fastlanes::FoRArray>
 
-pub fn vortex_fastlanes::DeltaVTable::array_eq(array: &vortex_fastlanes::DeltaArray, other: &vortex_fastlanes::DeltaArray, precision: vortex_array::hash::Precision) -> bool
+impl core::clone::Clone for vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::DeltaVTable::array_hash<H: core::hash::Hasher>(array: &vortex_fastlanes::DeltaArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_fastlanes::FoR::clone(&self) -> vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::DeltaVTable::dtype(array: &vortex_fastlanes::DeltaArray) -> &vortex_array::dtype::DType
+impl core::fmt::Debug for vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::DeltaVTable::len(array: &vortex_fastlanes::DeltaArray) -> usize
+pub fn vortex_fastlanes::FoR::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fastlanes::DeltaVTable::stats(array: &vortex_fastlanes::DeltaArray) -> vortex_array::stats::array::StatsSetRef<'_>
+impl vortex_array::array::vtable::VTable for vortex_fastlanes::FoR
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_fastlanes::DeltaVTable> for vortex_fastlanes::DeltaVTable
+pub type vortex_fastlanes::FoR::ArrayData = vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::DeltaVTable::scalar_at(array: &vortex_fastlanes::DeltaArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_fastlanes::FoR::OperationsVTable = vortex_fastlanes::FoR
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_fastlanes::DeltaVTable> for vortex_fastlanes::DeltaVTable
+pub type vortex_fastlanes::FoR::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-pub fn vortex_fastlanes::DeltaVTable::nbuffers(_array: &vortex_fastlanes::DeltaArray) -> usize
+pub fn vortex_fastlanes::FoR::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_fastlanes::DeltaVTable::nchildren(_array: &vortex_fastlanes::DeltaArray) -> usize
+pub fn vortex_fastlanes::FoR::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_fastlanes::DeltaVTable::visit_buffers(_array: &vortex_fastlanes::DeltaArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_fastlanes::FoR::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_fastlanes::DeltaVTable::visit_children(array: &vortex_fastlanes::DeltaArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub fn vortex_fastlanes::FoR::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub struct vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_fastlanes::FoRArray::encode(array: vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::FoRArray>
+pub fn vortex_fastlanes::FoR::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::FoRArray::encoded(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::FoR::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_fastlanes::FoRArray::ptype(&self) -> vortex_array::dtype::ptype::PType
+pub fn vortex_fastlanes::FoR::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_fastlanes::FoRArray::reference_scalar(&self) -> &vortex_array::scalar::Scalar
+pub fn vortex_fastlanes::FoR::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_fastlanes::FoRArray::try_new(encoded: vortex_array::array::ArrayRef, reference: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_fastlanes::FoR> for vortex_fastlanes::FoR
 
-impl core::clone::Clone for vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::FoR>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_fastlanes::FoRArray::clone(&self) -> vortex_fastlanes::FoRArray
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_fastlanes::FoR> for vortex_fastlanes::FoR
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::FoR>) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fastlanes::FoRArray::as_ref(&self) -> &dyn vortex_array::array::Array
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_fastlanes::FoR
 
-impl core::convert::From<vortex_fastlanes::FoRArray> for vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::FoR::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_fastlanes::FoRArray) -> vortex_array::array::ArrayRef
+impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_fastlanes::FoR
 
-impl core::fmt::Debug for vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::FoRArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::slice::SliceReduce for vortex_fastlanes::FoR
 
-impl core::ops::deref::Deref for vortex_fastlanes::FoRArray
+pub fn vortex_fastlanes::FoR::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_fastlanes::FoRArray::Target = dyn vortex_array::array::Array
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::FoRArray::deref(&self) -> &Self::Target
+pub fn vortex_fastlanes::FoR::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_fastlanes::FoRArray
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::FoR
 
-pub fn vortex_fastlanes::FoRArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::FoR::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub struct vortex_fastlanes::FoRVTable
+pub struct vortex_fastlanes::FoRData
 
-impl vortex_fastlanes::FoRVTable
+impl vortex_fastlanes::FoRData
 
-pub const vortex_fastlanes::FoRVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fastlanes::FoRData::encode(array: vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::FoRArray>
 
-impl core::fmt::Debug for vortex_fastlanes::FoRVTable
+impl vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fastlanes::FoRData::ptype(&self) -> vortex_array::dtype::ptype::PType
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_fastlanes::FoRVTable
+impl core::clone::Clone for vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::take(array: &vortex_fastlanes::FoRArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::FoRData::clone(&self) -> vortex_fastlanes::FoRData
 
-impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_fastlanes::FoRVTable
+impl core::fmt::Debug for vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::filter(array: &vortex_fastlanes::FoRArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::FoRData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_fastlanes::FoRVTable
+impl core::fmt::Display for vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::FoRData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::is_constant::IsConstantKernel for vortex_fastlanes::FoRVTable
+impl vortex_array::hash::ArrayEq for vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::is_constant(&self, array: &vortex_fastlanes::FoRArray, opts: &vortex_array::compute::is_constant::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_fastlanes::FoRData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-impl vortex_array::compute::is_sorted::IsSortedKernel for vortex_fastlanes::FoRVTable
+impl vortex_array::hash::ArrayHash for vortex_fastlanes::FoRData
 
-pub fn vortex_fastlanes::FoRVTable::is_sorted(&self, array: &vortex_fastlanes::FoRArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_fastlanes::FoRData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_fastlanes::FoRVTable::is_strict_sorted(&self, array: &vortex_fastlanes::FoRArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub struct vortex_fastlanes::RLE
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_fastlanes::FoRVTable
+impl vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::compare(lhs: &vortex_fastlanes::FoRArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub const vortex_fastlanes::RLE::ID: vortex_array::array::ArrayId
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::FoRVTable
+pub fn vortex_fastlanes::RLE::encode(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::RLEArray>
 
-pub fn vortex_fastlanes::FoRVTable::cast(array: &vortex_fastlanes::FoRArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub unsafe fn vortex_fastlanes::RLE::new_unchecked(values: vortex_array::array::erased::ArrayRef, indices: vortex_array::array::erased::ArrayRef, values_idx_offsets: vortex_array::array::erased::ArrayRef, offset: usize, length: usize) -> vortex_fastlanes::RLEArray
 
-impl vortex_array::vtable::VTable for vortex_fastlanes::FoRVTable
+pub fn vortex_fastlanes::RLE::try_new(values: vortex_array::array::erased::ArrayRef, indices: vortex_array::array::erased::ArrayRef, values_idx_offsets: vortex_array::array::erased::ArrayRef, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_fastlanes::RLEArray>
 
-pub type vortex_fastlanes::FoRVTable::Array = vortex_fastlanes::FoRArray
+impl core::clone::Clone for vortex_fastlanes::RLE
 
-pub type vortex_fastlanes::FoRVTable::ArrayVTable = vortex_fastlanes::FoRVTable
+pub fn vortex_fastlanes::RLE::clone(&self) -> vortex_fastlanes::RLE
 
-pub type vortex_fastlanes::FoRVTable::Metadata = vortex_array::scalar::Scalar
+impl core::fmt::Debug for vortex_fastlanes::RLE
 
-pub type vortex_fastlanes::FoRVTable::OperationsVTable = vortex_fastlanes::FoRVTable
+pub fn vortex_fastlanes::RLE::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_fastlanes::FoRVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+impl vortex_array::array::vtable::VTable for vortex_fastlanes::RLE
 
-pub type vortex_fastlanes::FoRVTable::VisitorVTable = vortex_fastlanes::FoRVTable
+pub type vortex_fastlanes::RLE::ArrayData = vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::FoRVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_fastlanes::FoRArray>
+pub type vortex_fastlanes::RLE::OperationsVTable = vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::deserialize(bytes: &[u8], dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_fastlanes::RLE::ValidityVTable = vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_fastlanes::RLE::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_fastlanes::FoRVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::RLE::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_fastlanes::FoRVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fastlanes::RLE::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_fastlanes::FoRVTable::metadata(array: &vortex_fastlanes::FoRArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_fastlanes::RLE::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_fastlanes::FoRVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::RLE::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::FoRVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_fastlanes::RLE::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_fastlanes::FoRVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_fastlanes::RLE::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_fastlanes::FoRVTable> for vortex_fastlanes::FoRVTable
+pub fn vortex_fastlanes::RLE::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::FoRVTable::array_eq(array: &vortex_fastlanes::FoRArray, other: &vortex_fastlanes::FoRArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_fastlanes::RLE::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_fastlanes::FoRVTable::array_hash<H: core::hash::Hasher>(array: &vortex_fastlanes::FoRArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_fastlanes::RLE::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_fastlanes::FoRVTable::dtype(array: &vortex_fastlanes::FoRArray) -> &vortex_array::dtype::DType
+pub fn vortex_fastlanes::RLE::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_fastlanes::FoRVTable::len(array: &vortex_fastlanes::FoRArray) -> usize
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_fastlanes::RLE> for vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::stats(array: &vortex_fastlanes::FoRArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_fastlanes::RLE::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::RLE>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_fastlanes::FoRVTable> for vortex_fastlanes::FoRVTable
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_fastlanes::RLE> for vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::scalar_at(array: &vortex_fastlanes::FoRArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_fastlanes::RLE::validity(array: vortex_array::array::view::ArrayView<'_, vortex_fastlanes::RLE>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_fastlanes::FoRVTable> for vortex_fastlanes::FoRVTable
+impl vortex_array::arrays::slice::SliceKernel for vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::validity_child(array: &vortex_fastlanes::FoRArray) -> &vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::RLE::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_fastlanes::FoRVTable> for vortex_fastlanes::FoRVTable
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::RLE
 
-pub fn vortex_fastlanes::FoRVTable::nbuffers(_array: &vortex_fastlanes::FoRArray) -> usize
+pub fn vortex_fastlanes::RLE::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fastlanes::FoRVTable::nchildren(_array: &vortex_fastlanes::FoRArray) -> usize
+pub struct vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::FoRVTable::visit_buffers(_array: &vortex_fastlanes::FoRArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+impl vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::FoRVTable::visit_children(array: &vortex_fastlanes::FoRArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub fn vortex_fastlanes::RLEData::encode(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_fastlanes::RLEArray>
 
-pub struct vortex_fastlanes::RLEArray
+impl vortex_fastlanes::RLEData
 
-impl vortex_fastlanes::RLEArray
+pub unsafe fn vortex_fastlanes::RLEData::new_unchecked(offset: usize) -> Self
 
-pub fn vortex_fastlanes::RLEArray::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_fastlanes::RLEData::offset(&self) -> usize
 
-pub fn vortex_fastlanes::RLEArray::indices(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::RLEData::try_new(offset: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_fastlanes::RLEArray::is_empty(&self) -> bool
+impl core::clone::Clone for vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::RLEArray::len(&self) -> usize
+pub fn vortex_fastlanes::RLEData::clone(&self) -> vortex_fastlanes::RLEData
 
-pub unsafe fn vortex_fastlanes::RLEArray::new_unchecked(values: vortex_array::array::ArrayRef, indices: vortex_array::array::ArrayRef, values_idx_offsets: vortex_array::array::ArrayRef, dtype: vortex_array::dtype::DType, offset: usize, length: usize) -> Self
+impl core::fmt::Debug for vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::RLEArray::offset(&self) -> usize
+pub fn vortex_fastlanes::RLEData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fastlanes::RLEArray::try_new(values: vortex_array::array::ArrayRef, indices: vortex_array::array::ArrayRef, values_idx_offsets: vortex_array::array::ArrayRef, offset: usize, length: usize) -> vortex_error::VortexResult<Self>
+impl core::fmt::Display for vortex_fastlanes::RLEData
 
-pub fn vortex_fastlanes::RLEArray::values(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::RLEData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fastlanes::RLEArray::values_idx_offsets(&self) -> &vortex_array::array::ArrayRef
+impl vortex_array::hash::ArrayEq for vortex_fastlanes::RLEData
 
-impl vortex_fastlanes::RLEArray
+pub fn vortex_fastlanes::RLEData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_fastlanes::RLEArray::encode(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<Self>
+impl vortex_array::hash::ArrayHash for vortex_fastlanes::RLEData
 
-impl core::clone::Clone for vortex_fastlanes::RLEArray
+pub fn vortex_fastlanes::RLEData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_fastlanes::RLEArray::clone(&self) -> vortex_fastlanes::RLEArray
+pub static vortex_fastlanes::USE_EXPERIMENTAL_PATCHES: std::sync::lazy_lock::LazyLock<bool>
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_fastlanes::RLEArray
+pub trait vortex_fastlanes::BitPackedArrayExt: vortex_fastlanes::BitPackedArraySlotsExt
 
-pub fn vortex_fastlanes::RLEArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub fn vortex_fastlanes::BitPackedArrayExt::bit_width(&self) -> u8
 
-impl core::convert::From<vortex_fastlanes::RLEArray> for vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPackedArrayExt::offset(&self) -> u16
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_fastlanes::RLEArray) -> vortex_array::array::ArrayRef
+pub fn vortex_fastlanes::BitPackedArrayExt::packed(&self) -> &vortex_array::buffer::BufferHandle
 
-impl core::fmt::Debug for vortex_fastlanes::RLEArray
+pub fn vortex_fastlanes::BitPackedArrayExt::packed_slice<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(&self) -> &[T]
 
-pub fn vortex_fastlanes::RLEArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fastlanes::BitPackedArrayExt::patches(&self) -> core::option::Option<vortex_array::patches::Patches>
 
-impl core::ops::deref::Deref for vortex_fastlanes::RLEArray
+pub fn vortex_fastlanes::BitPackedArrayExt::unpacked_chunks<T: vortex_fastlanes::unpack_iter::BitPacked>(&self) -> vortex_error::VortexResult<vortex_fastlanes::unpack_iter::BitUnpackedChunks<T>>
 
-pub type vortex_fastlanes::RLEArray::Target = dyn vortex_array::array::Array
+pub fn vortex_fastlanes::BitPackedArrayExt::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_fastlanes::RLEArray::deref(&self) -> &Self::Target
+pub fn vortex_fastlanes::BitPackedArrayExt::validity_mask(&self) -> vortex_mask::Mask
 
-impl vortex_array::array::IntoArray for vortex_fastlanes::RLEArray
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::BitPacked>> vortex_fastlanes::BitPackedArrayExt for T
 
-pub fn vortex_fastlanes::RLEArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn T::bit_width(&self) -> u8
 
-impl vortex_array::vtable::validity::ValidityChildSliceHelper for vortex_fastlanes::RLEArray
+pub fn T::offset(&self) -> u16
 
-pub fn vortex_fastlanes::RLEArray::unsliced_child_and_slice(&self) -> (&vortex_array::array::ArrayRef, usize, usize)
+pub fn T::packed(&self) -> &vortex_array::buffer::BufferHandle
 
-pub struct vortex_fastlanes::RLEVTable
+pub fn T::packed_slice<T: vortex_array::dtype::ptype::NativePType + fastlanes::bitpacking::BitPacking>(&self) -> &[T]
 
-impl vortex_fastlanes::RLEVTable
+pub fn T::patches(&self) -> core::option::Option<vortex_array::patches::Patches>
 
-pub const vortex_fastlanes::RLEVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn T::unpacked_chunks<T: vortex_fastlanes::unpack_iter::BitPacked>(&self) -> vortex_error::VortexResult<vortex_fastlanes::unpack_iter::BitUnpackedChunks<T>>
 
-impl core::fmt::Debug for vortex_fastlanes::RLEVTable
+pub fn T::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_fastlanes::RLEVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn T::validity_mask(&self) -> vortex_mask::Mask
 
-impl vortex_array::arrays::slice::SliceKernel for vortex_fastlanes::RLEVTable
+pub trait vortex_fastlanes::BitPackedArraySlotsExt: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::BitPacked>
 
-pub fn vortex_fastlanes::RLEVTable::slice(array: &vortex_fastlanes::RLEArray, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedArraySlotsExt::patch_chunk_offsets(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fastlanes::RLEVTable
+pub fn vortex_fastlanes::BitPackedArraySlotsExt::patch_indices(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_fastlanes::RLEVTable::cast(array: &vortex_fastlanes::RLEArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::BitPackedArraySlotsExt::patch_values(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-impl vortex_array::vtable::VTable for vortex_fastlanes::RLEVTable
+pub fn vortex_fastlanes::BitPackedArraySlotsExt::slots_view(&self) -> vortex_fastlanes::bitpacking::array::BitPackedSlotsView<'_>
 
-pub type vortex_fastlanes::RLEVTable::Array = vortex_fastlanes::RLEArray
+pub fn vortex_fastlanes::BitPackedArraySlotsExt::validity_child(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub type vortex_fastlanes::RLEVTable::ArrayVTable = vortex_fastlanes::RLEVTable
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::BitPacked>> vortex_fastlanes::BitPackedArraySlotsExt for T
 
-pub type vortex_fastlanes::RLEVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_fastlanes::rle::vtable::RLEMetadata>
+pub fn T::patch_chunk_offsets(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub type vortex_fastlanes::RLEVTable::OperationsVTable = vortex_fastlanes::RLEVTable
+pub fn T::patch_indices(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub type vortex_fastlanes::RLEVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChildSliceHelper
+pub fn T::patch_values(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub type vortex_fastlanes::RLEVTable::VisitorVTable = vortex_fastlanes::RLEVTable
+pub fn T::slots_view(&self) -> vortex_fastlanes::bitpacking::array::BitPackedSlotsView<'_>
 
-pub fn vortex_fastlanes::RLEVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_fastlanes::RLEArray>
+pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_fastlanes::RLEVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub trait vortex_fastlanes::FoRArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::FoR>
 
-pub fn vortex_fastlanes::RLEVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_fastlanes::FoRArrayExt::encoded(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fastlanes::RLEVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fastlanes::FoRArrayExt::reference_scalar(&self) -> &vortex_array::scalar::Scalar
 
-pub fn vortex_fastlanes::RLEVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::FoR>> vortex_fastlanes::FoRArrayExt for T
 
-pub fn vortex_fastlanes::RLEVTable::metadata(array: &vortex_fastlanes::RLEArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn T::encoded(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fastlanes::RLEVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn T::reference_scalar(&self) -> &vortex_array::scalar::Scalar
 
-pub fn vortex_fastlanes::RLEVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub trait vortex_fastlanes::RLEArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::RLE>
 
-pub fn vortex_fastlanes::RLEVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_fastlanes::RLEArrayExt::indices(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_fastlanes::RLEVTable> for vortex_fastlanes::RLEVTable
+pub fn vortex_fastlanes::RLEArrayExt::offset(&self) -> usize
 
-pub fn vortex_fastlanes::RLEVTable::array_eq(array: &vortex_fastlanes::RLEArray, other: &vortex_fastlanes::RLEArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_fastlanes::RLEArrayExt::values(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fastlanes::RLEVTable::array_hash<H: core::hash::Hasher>(array: &vortex_fastlanes::RLEArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_fastlanes::RLEArrayExt::values_idx_offset(&self, chunk_idx: usize) -> usize
 
-pub fn vortex_fastlanes::RLEVTable::dtype(array: &vortex_fastlanes::RLEArray) -> &vortex_array::dtype::DType
+pub fn vortex_fastlanes::RLEArrayExt::values_idx_offsets(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fastlanes::RLEVTable::len(array: &vortex_fastlanes::RLEArray) -> usize
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_fastlanes::RLE>> vortex_fastlanes::RLEArrayExt for T
 
-pub fn vortex_fastlanes::RLEVTable::stats(array: &vortex_fastlanes::RLEArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn T::indices(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_fastlanes::RLEVTable> for vortex_fastlanes::RLEVTable
+pub fn T::offset(&self) -> usize
 
-pub fn vortex_fastlanes::RLEVTable::scalar_at(array: &vortex_fastlanes::RLEArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn T::values(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_fastlanes::RLEVTable> for vortex_fastlanes::RLEVTable
+pub fn T::values_idx_offset(&self, chunk_idx: usize) -> usize
 
-pub fn vortex_fastlanes::RLEVTable::validity_child(array: &vortex_fastlanes::RLEArray) -> &vortex_array::array::ArrayRef
+pub fn T::values_idx_offsets(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_fastlanes::RLEVTable> for vortex_fastlanes::RLEVTable
+pub fn vortex_fastlanes::delta_compress(array: &vortex_array::arrays::primitive::vtable::PrimitiveArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<(vortex_array::arrays::primitive::vtable::PrimitiveArray, vortex_array::arrays::primitive::vtable::PrimitiveArray)>
 
-pub fn vortex_fastlanes::RLEVTable::nbuffers(_array: &vortex_fastlanes::RLEArray) -> usize
+pub fn vortex_fastlanes::initialize(session: &vortex_session::VortexSession)
 
-pub fn vortex_fastlanes::RLEVTable::nchildren(_array: &vortex_fastlanes::RLEArray) -> usize
+pub type vortex_fastlanes::BitPackedArray = vortex_array::array::typed::Array<vortex_fastlanes::BitPacked>
 
-pub fn vortex_fastlanes::RLEVTable::visit_buffers(_array: &vortex_fastlanes::RLEArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub type vortex_fastlanes::DeltaArray = vortex_array::array::typed::Array<vortex_fastlanes::Delta>
 
-pub fn vortex_fastlanes::RLEVTable::visit_children(array: &vortex_fastlanes::RLEArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub type vortex_fastlanes::FoRArray = vortex_array::array::typed::Array<vortex_fastlanes::FoR>
 
-pub fn vortex_fastlanes::delta_compress(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<(vortex_array::arrays::primitive::array::PrimitiveArray, vortex_array::arrays::primitive::array::PrimitiveArray)>
+pub type vortex_fastlanes::RLEArray = vortex_array::array::typed::Array<vortex_fastlanes::RLE>
diff --git a/encodings/fastlanes/src/bit_transpose/aarch64.rs b/encodings/fastlanes/src/bit_transpose/aarch64.rs
new file mode 100644
index 00000000000..7a854b43a3f
--- /dev/null
+++ b/encodings/fastlanes/src/bit_transpose/aarch64.rs
@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![cfg(target_arch = "aarch64")]
+
+use core::arch::aarch64::uint64x2_t;
+use core::arch::aarch64::vandq_u64;
+use core::arch::aarch64::vdupq_n_u64;
+use core::arch::aarch64::veorq_u64;
+use core::arch::aarch64::vgetq_lane_u64;
+use core::arch::aarch64::vld1q_u8;
+use core::arch::aarch64::vld1q_u8_x4;
+use core::arch::aarch64::vorrq_u8;
+use core::arch::aarch64::vqtbl4q_u8;
+use core::arch::aarch64::vreinterpretq_u8_u64;
+use core::arch::aarch64::vreinterpretq_u64_u8;
+use core::arch::aarch64::vshlq_n_u64;
+use core::arch::aarch64::vshrq_n_u64;
+use core::arch::aarch64::vst1q_u8;
+
+use crate::bit_transpose::BASE_PATTERN_FIRST;
+use crate::bit_transpose::BASE_PATTERN_SECOND;
+use crate::bit_transpose::TRANSPOSE_2X2;
+use crate::bit_transpose::TRANSPOSE_4X4;
+use crate::bit_transpose::TRANSPOSE_8X8;
+
+/// Gather indices for the first half from input[0..64].
+/// Each group needs 4 bytes at stride 16 (the low half of the stride pattern).
+/// Layout: [`g0_from_lo(4` bytes), pad(4 bytes), `g1_from_lo(4` bytes), pad(4 bytes), ...]
+/// Two groups per 16-byte NEON register.
+static GATHER_FIRST_LO: [[u8; 16]; 4] = [
+    // Groups 0,1 from BASE_PATTERN_FIRST: bases 0, 8
+    [
+        0, 16, 32, 48, 0xFF, 0xFF, 0xFF, 0xFF, 8, 24, 40, 56, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    // Groups 2,3: bases 4, 12
+    [
+        4, 20, 36, 52, 0xFF, 0xFF, 0xFF, 0xFF, 12, 28, 44, 60, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    // Groups 4,5: bases 2, 10
+    [
+        2, 18, 34, 50, 0xFF, 0xFF, 0xFF, 0xFF, 10, 26, 42, 58, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    // Groups 6,7: bases 6, 14
+    [
+        6, 22, 38, 54, 0xFF, 0xFF, 0xFF, 0xFF, 14, 30, 46, 62, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+];
+
+/// Gather indices for the first half from input[64..128].
+/// These fill in bytes 4-7 of each u64 (the high half of the stride pattern).
+static GATHER_FIRST_HI: [[u8; 16]; 4] = [
+    // Groups 0,1: bases 0, 8 (offset by -64 since table starts at input[64])
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 0, 16, 32, 48, 0xFF, 0xFF, 0xFF, 0xFF, 8, 24, 40, 56,
+    ],
+    // Groups 2,3: bases 4, 12
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 4, 20, 36, 52, 0xFF, 0xFF, 0xFF, 0xFF, 12, 28, 44, 60,
+    ],
+    // Groups 4,5: bases 2, 10
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 2, 18, 34, 50, 0xFF, 0xFF, 0xFF, 0xFF, 10, 26, 42, 58,
+    ],
+    // Groups 6,7: bases 6, 14
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 6, 22, 38, 54, 0xFF, 0xFF, 0xFF, 0xFF, 14, 30, 46, 62,
+    ],
+];
+
+/// Gather indices for the second half from input[0..64].
+/// Uses `BASE_PATTERN_SECOND`: bases [1, 9, 5, 13, 3, 11, 7, 15]
+static GATHER_SECOND_LO: [[u8; 16]; 4] = [
+    [
+        1, 17, 33, 49, 0xFF, 0xFF, 0xFF, 0xFF, 9, 25, 41, 57, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    [
+        5, 21, 37, 53, 0xFF, 0xFF, 0xFF, 0xFF, 13, 29, 45, 61, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    [
+        3, 19, 35, 51, 0xFF, 0xFF, 0xFF, 0xFF, 11, 27, 43, 59, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+    [
+        7, 23, 39, 55, 0xFF, 0xFF, 0xFF, 0xFF, 15, 31, 47, 63, 0xFF, 0xFF, 0xFF, 0xFF,
+    ],
+];
+
+/// Gather indices for the second half from input[64..128].
+static GATHER_SECOND_HI: [[u8; 16]; 4] = [
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 1, 17, 33, 49, 0xFF, 0xFF, 0xFF, 0xFF, 9, 25, 41, 57,
+    ],
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 5, 21, 37, 53, 0xFF, 0xFF, 0xFF, 0xFF, 13, 29, 45, 61,
+    ],
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 3, 19, 35, 51, 0xFF, 0xFF, 0xFF, 0xFF, 11, 27, 43, 59,
+    ],
+    [
+        0xFF, 0xFF, 0xFF, 0xFF, 7, 23, 39, 55, 0xFF, 0xFF, 0xFF, 0xFF, 15, 31, 47, 63,
+    ],
+];
+
+/// 8x8 byte transpose (scatter) permutation split into 4 × 16-byte chunks for NEON TBL.
+/// Input layout:  [g0b0..g0b7, g1b0..g1b7, ..., g7b0..g7b7] (64 bytes, group-major)
+/// Output layout: [g0b0,g1b0,..,g7b0, g0b1,g1b1,..,g7b1, ...] (64 bytes, row-major)
+/// Same permutation as x86 `SCATTER_8X8`, split for 16-byte NEON registers.
+static SCATTER_8X8_NEON: [[u8; 16]; 4] = [
+    [0, 8, 16, 24, 32, 40, 48, 56, 1, 9, 17, 25, 33, 41, 49, 57],
+    [2, 10, 18, 26, 34, 42, 50, 58, 3, 11, 19, 27, 35, 43, 51, 59],
+    [4, 12, 20, 28, 36, 44, 52, 60, 5, 13, 21, 29, 37, 45, 53, 61],
+    [6, 14, 22, 30, 38, 46, 54, 62, 7, 15, 23, 31, 39, 47, 55, 63],
+];
+
+/// Perform 8x8 bit transpose on two u64s packed in a `uint64x2_t`.
+#[allow(unsafe_op_in_unsafe_fn)]
+unsafe fn bit_transpose_8x8_neon(mut v: uint64x2_t) -> uint64x2_t {
+    let mask1 = vdupq_n_u64(TRANSPOSE_2X2);
+    let t = vandq_u64(veorq_u64(v, vshrq_n_u64::<7>(v)), mask1);
+    v = veorq_u64(veorq_u64(v, t), vshlq_n_u64::<7>(t));
+
+    let mask2 = vdupq_n_u64(TRANSPOSE_4X4);
+    let t = vandq_u64(veorq_u64(v, vshrq_n_u64::<14>(v)), mask2);
+    v = veorq_u64(veorq_u64(v, t), vshlq_n_u64::<14>(t));
+
+    let mask3 = vdupq_n_u64(TRANSPOSE_8X8);
+    let t = vandq_u64(veorq_u64(v, vshrq_n_u64::<28>(v)), mask3);
+    veorq_u64(veorq_u64(v, t), vshlq_n_u64::<28>(t))
+}
+
+/// Transpose 1024 bits using ARM NEON with TBL-based vectorized gather and scatter.
+///
+/// Uses `vqtbl4q_u8` to gather bytes from the 128-byte input in parallel,
+/// avoiding scalar byte-by-byte loads. Then uses `vqtbl4q_u8` again to perform
+/// the 8x8 byte transpose for scatter. This is the NEON analog of x86 VBMI's
+/// `vpermb`/`vpermi2b` byte permutation instructions.
+///
+/// # Safety
+/// Requires `AArch64` with NEON (always available on `AArch64`).
+#[allow(unsafe_op_in_unsafe_fn)]
+#[inline(never)]
+pub unsafe fn transpose_bits_neon(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Load all 128 input bytes into two uint8x16x4_t tables (64 bytes each)
+    let tbl_lo = vld1q_u8_x4(input.as_ptr());
+    let tbl_hi = vld1q_u8_x4(input.as_ptr().add(64));
+
+    // Load scatter permutation indices (4 × 16 bytes)
+    let scatter0 = vld1q_u8(SCATTER_8X8_NEON[0].as_ptr());
+    let scatter1 = vld1q_u8(SCATTER_8X8_NEON[1].as_ptr());
+    let scatter2 = vld1q_u8(SCATTER_8X8_NEON[2].as_ptr());
+    let scatter3 = vld1q_u8(SCATTER_8X8_NEON[3].as_ptr());
+
+    // Process first 64 output bytes (8 groups from BASE_PATTERN_FIRST)
+    // Gather and bit-transpose all 4 pairs, then scatter the full 64 bytes
+    let mut buf = [0u8; 64];
+    for (i, (gather_lo, gather_high)) in [
+        (GATHER_FIRST_LO, GATHER_FIRST_HI),
+        (GATHER_SECOND_LO, GATHER_SECOND_HI),
+    ]
+    .iter()
+    .enumerate()
+    {
+        for pair in 0..4 {
+            let idx_lo = vld1q_u8(gather_lo[pair].as_ptr());
+            let idx_hi = vld1q_u8(gather_high[pair].as_ptr());
+
+            let from_lo = vqtbl4q_u8(tbl_lo, idx_lo);
+            let from_hi = vqtbl4q_u8(tbl_hi, idx_hi);
+            let gathered = vorrq_u8(from_lo, from_hi);
+
+            let v = bit_transpose_8x8_neon(vreinterpretq_u64_u8(gathered));
+            vst1q_u8(buf.as_mut_ptr().add(pair * 16), vreinterpretq_u8_u64(v));
+        }
+
+        // Load the 64-byte result as a TBL table and apply 8x8 byte transpose
+        let result_tbl = vld1q_u8_x4(buf.as_ptr());
+        vst1q_u8(
+            output.as_mut_ptr().add(i * 64),
+            vqtbl4q_u8(result_tbl, scatter0),
+        );
+        vst1q_u8(
+            output.as_mut_ptr().add(i * 64 + 16),
+            vqtbl4q_u8(result_tbl, scatter1),
+        );
+        vst1q_u8(
+            output.as_mut_ptr().add(i * 64 + 32),
+            vqtbl4q_u8(result_tbl, scatter2),
+        );
+        vst1q_u8(
+            output.as_mut_ptr().add(i * 64 + 48),
+            vqtbl4q_u8(result_tbl, scatter3),
+        );
+    }
+}
+
+/// Untranspose 1024 bits using ARM NEON with TBL-based vectorized operations.
+///
+/// # Safety
+/// Requires `AArch64` with NEON (always available on `AArch64`).
+#[allow(unsafe_op_in_unsafe_fn)]
+#[inline(never)]
+pub unsafe fn untranspose_bits_neon(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Load scatter indices (SCATTER_8X8 is self-inverse, so same table un-scatters)
+    let scatter0 = vld1q_u8(SCATTER_8X8_NEON[0].as_ptr());
+    let scatter1 = vld1q_u8(SCATTER_8X8_NEON[1].as_ptr());
+    let scatter2 = vld1q_u8(SCATTER_8X8_NEON[2].as_ptr());
+    let scatter3 = vld1q_u8(SCATTER_8X8_NEON[3].as_ptr());
+
+    // Each iteration un-scatters the 64-byte input block to group-major order
+    let mut buf = [0u8; 64];
+    for (i, base_pattern) in [BASE_PATTERN_FIRST, BASE_PATTERN_SECOND].iter().enumerate() {
+        let in_tbl = vld1q_u8_x4(input.as_ptr().add(i * 64));
+        vst1q_u8(buf.as_mut_ptr(), vqtbl4q_u8(in_tbl, scatter0));
+        vst1q_u8(buf.as_mut_ptr().add(16), vqtbl4q_u8(in_tbl, scatter1));
+        vst1q_u8(buf.as_mut_ptr().add(32), vqtbl4q_u8(in_tbl, scatter2));
+        vst1q_u8(buf.as_mut_ptr().add(48), vqtbl4q_u8(in_tbl, scatter3));
+
+        // Bit-transpose each pair and scatter to stride-16 output
+        for pair in 0..4 {
+            let base_group_0 = pair * 2;
+            let base_group_1 = pair * 2 + 1;
+
+            let gathered = vld1q_u8(buf.as_ptr().add(pair * 16));
+            let v = bit_transpose_8x8_neon(vreinterpretq_u64_u8(gathered));
+
+            let result_0 = vgetq_lane_u64::<0>(v);
+            let result_1 = vgetq_lane_u64::<1>(v);
+
+            let out_base_0 = base_pattern[base_group_0];
+            let out_base_1 = base_pattern[base_group_1];
+            for i in 0..8 {
+                output[out_base_0 + i * 16] = (result_0 >> (i * 8)) as u8;
+                output[out_base_1 + i * 16] = (result_1 >> (i * 8)) as u8;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::bit_transpose::aarch64::transpose_bits_neon;
+    use crate::bit_transpose::aarch64::untranspose_bits_neon;
+    use crate::bit_transpose::generate_test_data;
+    use crate::bit_transpose::transpose_bits_baseline;
+    use crate::bit_transpose::untranspose_bits_baseline;
+
+    #[test]
+    fn test_neon_matches_baseline() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut tbl_out = [0u8; 128];
+
+            transpose_bits_baseline(&input, &mut baseline_out);
+            unsafe { transpose_bits_neon(&input, &mut tbl_out) };
+
+            assert_eq!(
+                baseline_out, tbl_out,
+                "NEON TBL transpose doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_neon_roundtrip() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut transposed = [0u8; 128];
+            let mut roundtrip = [0u8; 128];
+
+            unsafe {
+                transpose_bits_neon(&input, &mut transposed);
+                untranspose_bits_neon(&transposed, &mut roundtrip);
+            }
+
+            assert_eq!(
+                input, roundtrip,
+                "NEON TBL roundtrip failed for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_untranspose_neon_matches_baseline() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut tbl_out = [0u8; 128];
+
+            untranspose_bits_baseline(&input, &mut baseline_out);
+            unsafe { untranspose_bits_neon(&input, &mut tbl_out) };
+
+            assert_eq!(
+                baseline_out, tbl_out,
+                "NEON TBL untranspose doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+}
diff --git a/encodings/fastlanes/src/bit_transpose/mod.rs b/encodings/fastlanes/src/bit_transpose/mod.rs
new file mode 100644
index 00000000000..01e5d4a0b1c
--- /dev/null
+++ b/encodings/fastlanes/src/bit_transpose/mod.rs
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Fast implementations of the `FastLanes` 1024-bit transpose.
+//!
+//! The `FastLanes` transpose is a fixed permutation of 1024 bits (128 bytes) that
+//! enables SIMD parallelism for encodings like delta and RLE. This module provides
+//! optimized implementations for different x86 SIMD instruction sets.
+//!
+//! The key insight is that each output byte is formed by extracting the SAME bit
+//! position from 8 different input bytes at stride 16. The input byte groups follow
+//! the `FL_ORDER` permutation pattern.
+
+#[cfg(feature = "_test-harness")]
+pub mod aarch64;
+#[cfg(feature = "_test-harness")]
+pub mod scalar;
+#[cfg(feature = "_test-harness")]
+pub mod x86;
+
+#[cfg(not(feature = "_test-harness"))]
+mod aarch64;
+#[cfg(not(feature = "_test-harness"))]
+mod scalar;
+#[cfg(not(feature = "_test-harness"))]
+mod x86;
+
+mod validity;
+
+pub use validity::*;
+
+/// Base indices for the first 64 output bytes (lanes 0-7).
+/// Each entry indicates the starting input byte index for that output byte group.
+/// Pattern: [0*2, 4*2, 2*2, 6*2, 1*2, 5*2, 3*2, 7*2] = [0, 8, 4, 12, 2, 10, 6, 14]
+const BASE_PATTERN_FIRST: [usize; 8] = [0, 8, 4, 12, 2, 10, 6, 14];
+
+/// Base indices for the second 64 output bytes (lanes 8-15).
+/// Pattern: first pattern + 1 = [1, 9, 5, 13, 3, 11, 7, 15]
+const BASE_PATTERN_SECOND: [usize; 8] = [1, 9, 5, 13, 3, 11, 7, 15];
+
+/// Masks for transposing 8x8 bit blocks.
+const TRANSPOSE_2X2: u64 = 0x00AA_00AA_00AA_00AA;
+const TRANSPOSE_4X4: u64 = 0x0000_CCCC_0000_CCCC;
+const TRANSPOSE_8X8: u64 = 0x0000_0000_F0F0_F0F0;
+
+/// Transpose 1024-bits into FastLanes layout.
+///
+/// Dispatch to the best available implementation at runtime.
+#[inline]
+pub fn transpose_bits(input: &[u8; 128], output: &mut [u8; 128]) {
+    #[cfg(target_arch = "x86_64")]
+    {
+        // VBMI is fastest
+        if x86::has_vbmi() {
+            unsafe { x86::transpose_bits_vbmi(input, output) };
+            return;
+        }
+        if x86::has_bmi2() {
+            unsafe { x86::transpose_bits_bmi2(input, output) };
+            return;
+        }
+        // Fall back to scalar
+        scalar::transpose_bits_scalar(input, output);
+    }
+    #[cfg(target_arch = "aarch64")]
+    {
+        unsafe { aarch64::transpose_bits_neon(input, output) };
+    }
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+    scalar::transpose_bits_scalar(input, output);
+}
+
+/// Untranspose 1024-bits from FastLanes layout.
+///
+/// Dispatch untranspose to the best available implementation at runtime.
+#[inline]
+pub fn untranspose_bits(input: &[u8; 128], output: &mut [u8; 128]) {
+    #[cfg(target_arch = "x86_64")]
+    {
+        // VBMI is fastest
+        if x86::has_vbmi() {
+            unsafe { x86::untranspose_bits_vbmi(input, output) };
+            return;
+        }
+        if x86::has_bmi2() {
+            unsafe { x86::untranspose_bits_bmi2(input, output) };
+            return;
+        }
+        // Fall back to scalar
+        scalar::untranspose_bits_scalar(input, output);
+    }
+    #[cfg(target_arch = "aarch64")]
+    {
+        unsafe { aarch64::untranspose_bits_neon(input, output) };
+    }
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+    scalar::untranspose_bits_scalar(input, output);
+}
+
+#[cfg(test)]
+#[allow(clippy::cast_possible_truncation)]
+fn generate_test_data(seed: u8) -> [u8; 128] {
+    let mut data = [0u8; 128];
+    for (i, byte) in data.iter_mut().enumerate() {
+        *byte = seed.wrapping_mul(17).wrapping_add(i as u8).wrapping_mul(31);
+    }
+    data
+}
+
+#[cfg(test)]
+pub fn transpose_bits_baseline(input: &[u8; 128], output: &mut [u8; 128]) {
+    for in_bit in 0..1024 {
+        let out_bit = fastlanes::transpose(in_bit);
+        let in_byte = in_bit / 8;
+        let in_bit_pos = in_bit % 8;
+        let out_byte = out_bit / 8;
+        let out_bit_pos = out_bit % 8;
+        let bit_val = (input[in_byte] >> in_bit_pos) & 1;
+        output[out_byte] |= bit_val << out_bit_pos;
+    }
+}
+
+#[cfg(test)]
+pub fn untranspose_bits_baseline(input: &[u8; 128], output: &mut [u8; 128]) {
+    for out_bit in 0..1024 {
+        let in_bit = fastlanes::transpose(out_bit);
+        let in_byte = in_bit / 8;
+        let in_bit_pos = in_bit % 8;
+        let out_byte = out_bit / 8;
+        let out_bit_pos = out_bit % 8;
+        let bit_val = (input[in_byte] >> in_bit_pos) & 1;
+        output[out_byte] |= bit_val << out_bit_pos;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_transpose_baseline_roundtrip() {
+        let input = generate_test_data(42);
+        let mut transposed = [0u8; 128];
+        let mut roundtrip = [0u8; 128];
+
+        transpose_bits_baseline(&input, &mut transposed);
+        untranspose_bits_baseline(&transposed, &mut roundtrip);
+
+        assert_eq!(input, roundtrip);
+    }
+
+    #[test]
+    fn test_dispatch_matches_baseline() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut out = [0u8; 128];
+
+            transpose_bits_baseline(&input, &mut baseline_out);
+            transpose_bits(&input, &mut out);
+
+            assert_eq!(
+                baseline_out, out,
+                "best dispatch doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_untranspose_dispatch_matches_baseline() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut out = [0u8; 128];
+
+            untranspose_bits_baseline(&input, &mut baseline_out);
+            untranspose_bits(&input, &mut out);
+
+            assert_eq!(
+                baseline_out, out,
+                "best untranspose dispatch doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+}
diff --git a/encodings/fastlanes/src/bit_transpose/scalar.rs b/encodings/fastlanes/src/bit_transpose/scalar.rs
new file mode 100644
index 00000000000..425e74087ab
--- /dev/null
+++ b/encodings/fastlanes/src/bit_transpose/scalar.rs
@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use crate::bit_transpose::BASE_PATTERN_FIRST;
+use crate::bit_transpose::BASE_PATTERN_SECOND;
+use crate::bit_transpose::TRANSPOSE_2X2;
+use crate::bit_transpose::TRANSPOSE_4X4;
+use crate::bit_transpose::TRANSPOSE_8X8;
+
+/// Fast scalar transpose using the 8x8 bit matrix transpose algorithm.
+///
+/// This version uses 64-bit gather + parallel bit operations instead of
+/// extracting bits one by one. Typically 5-10x faster than the basic scalar version.
+#[inline(never)]
+#[allow(dead_code)]
+pub fn transpose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Helper to perform 8x8 bit transpose on a u64 (each byte becomes a row)
+    fn transpose_8x8(mut x: u64) -> u64 {
+        // Step 1: Transpose 2x2 bit blocks
+        let t = (x ^ (x >> 7)) & TRANSPOSE_2X2;
+        x = x ^ t ^ (t << 7);
+        // Step 2: Transpose 4x4 bit blocks
+        let t = (x ^ (x >> 14)) & TRANSPOSE_4X4;
+        x = x ^ t ^ (t << 14);
+        // Step 3: Transpose 8x8 bit blocks
+        let t = (x ^ (x >> 28)) & TRANSPOSE_8X8;
+        x ^ t ^ (t << 28)
+    }
+
+    // Helper to gather 8 bytes at stride 16 into a u64
+    fn gather(input: &[u8; 128], base: usize) -> u64 {
+        u64::from(input[base])
+            | (u64::from(input[base + 16]) << 8)
+            | (u64::from(input[base + 32]) << 16)
+            | (u64::from(input[base + 48]) << 24)
+            | (u64::from(input[base + 64]) << 32)
+            | (u64::from(input[base + 80]) << 40)
+            | (u64::from(input[base + 96]) << 48)
+            | (u64::from(input[base + 112]) << 56)
+    }
+
+    // Process first half (8 base groups, fully unrolled)
+    let r0 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[0]));
+    let r1 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[1]));
+    let r2 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[2]));
+    let r3 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[3]));
+    let r4 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[4]));
+    let r5 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[5]));
+    let r6 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[6]));
+    let r7 = transpose_8x8(gather(input, BASE_PATTERN_FIRST[7]));
+
+    // Write first 64 output bytes (unrolled)
+    for bit_pos in 0..8 {
+        output[bit_pos * 8] = (r0 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 1] = (r1 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 2] = (r2 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 3] = (r3 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 4] = (r4 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 5] = (r5 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 6] = (r6 >> (bit_pos * 8)) as u8;
+        output[bit_pos * 8 + 7] = (r7 >> (bit_pos * 8)) as u8;
+    }
+
+    // Process second half
+    let r0 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[0]));
+    let r1 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[1]));
+    let r2 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[2]));
+    let r3 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[3]));
+    let r4 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[4]));
+    let r5 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[5]));
+    let r6 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[6]));
+    let r7 = transpose_8x8(gather(input, BASE_PATTERN_SECOND[7]));
+
+    for bit_pos in 0..8 {
+        output[64 + bit_pos * 8] = (r0 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 1] = (r1 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 2] = (r2 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 3] = (r3 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 4] = (r4 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 5] = (r5 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 6] = (r6 >> (bit_pos * 8)) as u8;
+        output[64 + bit_pos * 8 + 7] = (r7 >> (bit_pos * 8)) as u8;
+    }
+}
+
+/// Fast scalar untranspose using the 8x8 bit matrix transpose algorithm.
+#[inline(never)]
+#[allow(dead_code)]
+pub fn untranspose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
+    fn transpose_8x8(mut x: u64) -> u64 {
+        let t = (x ^ (x >> 7)) & TRANSPOSE_2X2;
+        x = x ^ t ^ (t << 7);
+        let t = (x ^ (x >> 14)) & TRANSPOSE_4X4;
+        x = x ^ t ^ (t << 14);
+        let t = (x ^ (x >> 28)) & TRANSPOSE_8X8;
+        x ^ t ^ (t << 28)
+    }
+
+    fn gather_transposed(input: &[u8; 128], base_group: usize, offset: usize) -> u64 {
+        let mut result: u64 = 0;
+        for bit_pos in 0..8 {
+            result |= u64::from(input[offset + bit_pos * 8 + base_group]) << (bit_pos * 8);
+        }
+        result
+    }
+
+    fn scatter(output: &mut [u8; 128], base: usize, val: u64) {
+        output[base] = val as u8;
+        output[base + 16] = (val >> 8) as u8;
+        output[base + 32] = (val >> 16) as u8;
+        output[base + 48] = (val >> 24) as u8;
+        output[base + 64] = (val >> 32) as u8;
+        output[base + 80] = (val >> 40) as u8;
+        output[base + 96] = (val >> 48) as u8;
+        output[base + 112] = (val >> 56) as u8;
+    }
+
+    // First half (unrolled)
+    let r0 = transpose_8x8(gather_transposed(input, 0, 0));
+    let r1 = transpose_8x8(gather_transposed(input, 1, 0));
+    let r2 = transpose_8x8(gather_transposed(input, 2, 0));
+    let r3 = transpose_8x8(gather_transposed(input, 3, 0));
+    let r4 = transpose_8x8(gather_transposed(input, 4, 0));
+    let r5 = transpose_8x8(gather_transposed(input, 5, 0));
+    let r6 = transpose_8x8(gather_transposed(input, 6, 0));
+    let r7 = transpose_8x8(gather_transposed(input, 7, 0));
+
+    scatter(output, BASE_PATTERN_FIRST[0], r0);
+    scatter(output, BASE_PATTERN_FIRST[1], r1);
+    scatter(output, BASE_PATTERN_FIRST[2], r2);
+    scatter(output, BASE_PATTERN_FIRST[3], r3);
+    scatter(output, BASE_PATTERN_FIRST[4], r4);
+    scatter(output, BASE_PATTERN_FIRST[5], r5);
+    scatter(output, BASE_PATTERN_FIRST[6], r6);
+    scatter(output, BASE_PATTERN_FIRST[7], r7);
+
+    // Second half
+    let r0 = transpose_8x8(gather_transposed(input, 0, 64));
+    let r1 = transpose_8x8(gather_transposed(input, 1, 64));
+    let r2 = transpose_8x8(gather_transposed(input, 2, 64));
+    let r3 = transpose_8x8(gather_transposed(input, 3, 64));
+    let r4 = transpose_8x8(gather_transposed(input, 4, 64));
+    let r5 = transpose_8x8(gather_transposed(input, 5, 64));
+    let r6 = transpose_8x8(gather_transposed(input, 6, 64));
+    let r7 = transpose_8x8(gather_transposed(input, 7, 64));
+
+    scatter(output, BASE_PATTERN_SECOND[0], r0);
+    scatter(output, BASE_PATTERN_SECOND[1], r1);
+    scatter(output, BASE_PATTERN_SECOND[2], r2);
+    scatter(output, BASE_PATTERN_SECOND[3], r3);
+    scatter(output, BASE_PATTERN_SECOND[4], r4);
+    scatter(output, BASE_PATTERN_SECOND[5], r5);
+    scatter(output, BASE_PATTERN_SECOND[6], r6);
+    scatter(output, BASE_PATTERN_SECOND[7], r7);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bit_transpose::generate_test_data;
+
+    #[test]
+    fn test_scalar_matches_baseline() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut fast_out = [0u8; 128];
+
+            transpose_bits_scalar(&input, &mut baseline_out);
+            transpose_bits_scalar(&input, &mut fast_out);
+
+            assert_eq!(
+                baseline_out, fast_out,
+                "scalar_fast transpose doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_scalar_roundtrip() {
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut transposed = [0u8; 128];
+            let mut roundtrip = [0u8; 128];
+
+            transpose_bits_scalar(&input, &mut transposed);
+            untranspose_bits_scalar(&transposed, &mut roundtrip);
+
+            assert_eq!(
+                input, roundtrip,
+                "scalar_fast roundtrip failed for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_all_zeros() {
+        let input = [0u8; 128];
+        let mut output = [0xFFu8; 128];
+
+        transpose_bits_scalar(&input, &mut output);
+        assert_eq!(output, [0u8; 128]);
+
+        untranspose_bits_scalar(&input, &mut output);
+        assert_eq!(output, [0u8; 128]);
+    }
+
+    #[test]
+    fn test_all_ones() {
+        let input = [0xFFu8; 128];
+        let mut output = [0u8; 128];
+
+        transpose_bits_scalar(&input, &mut output);
+        assert_eq!(output, [0xFFu8; 128]);
+
+        untranspose_bits_scalar(&input, &mut output);
+        assert_eq!(output, [0xFFu8; 128]);
+    }
+}
diff --git a/encodings/fastlanes/src/bit_transpose/validity.rs b/encodings/fastlanes/src/bit_transpose/validity.rs
new file mode 100644
index 00000000000..826e1a2ad35
--- /dev/null
+++ b/encodings/fastlanes/src/bit_transpose/validity.rs
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::mem;
+use std::mem::MaybeUninit;
+
+use vortex_array::Canonical;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::BoolArray;
+use vortex_array::validity::Validity;
+use vortex_buffer::BitBuffer;
+use vortex_buffer::ByteBuffer;
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::bit_transpose::transpose_bits;
+use crate::bit_transpose::untranspose_bits;
+
+pub fn transpose_validity(validity: &Validity, ctx: &mut ExecutionCtx) -> VortexResult<Validity> {
+    match validity {
+        Validity::Array(mask) => {
+            let bools = mask
+                .clone()
+                .execute::<Canonical>(ctx)?
+                .into_bool()
+                .into_bit_buffer();
+
+            Ok(Validity::Array(
+                BoolArray::new(transpose_bitbuffer(bools), Validity::NonNullable).into_array(),
+            ))
+        }
+        v @ Validity::AllValid | v @ Validity::AllInvalid | v @ Validity::NonNullable => {
+            Ok(v.clone())
+        }
+    }
+}
+
+pub fn transpose_bitbuffer(bits: BitBuffer) -> BitBuffer {
+    let (offset, len, bytes) = bits.into_inner();
+
+    if bytes.len().is_multiple_of(128) {
+        match bytes.try_into_mut() {
+            Ok(mut bytes_mut) => {
+                // We can ignore the spare trailer capacity that can be an artifact of allocator as we requested 128 multiple chunks
+                let (chunks, _) = bytes_mut.as_chunks_mut::<128>();
+                let mut tmp = [0u8; 128];
+                for chunk in chunks {
+                    transpose_bits(chunk, &mut tmp);
+                    chunk.copy_from_slice(&tmp);
+                }
+                BitBuffer::new_with_offset(bytes_mut.freeze().into_byte_buffer(), len, offset)
+            }
+            Err(bytes) => bits_op_with_copy(bytes, len, offset, transpose_bits),
+        }
+    } else {
+        bits_op_with_copy(bytes, len, offset, transpose_bits)
+    }
+}
+
+pub fn untranspose_validity(validity: &Validity, ctx: &mut ExecutionCtx) -> VortexResult<Validity> {
+    match validity {
+        Validity::Array(mask) => {
+            let bools = mask
+                .clone()
+                .execute::<Canonical>(ctx)?
+                .into_bool()
+                .into_bit_buffer();
+
+            Ok(Validity::Array(
+                BoolArray::new(untranspose_bitbuffer(bools), Validity::NonNullable).into_array(),
+            ))
+        }
+        v @ Validity::AllValid | v @ Validity::AllInvalid | v @ Validity::NonNullable => {
+            Ok(v.clone())
+        }
+    }
+}
+
+pub fn untranspose_bitbuffer(bits: BitBuffer) -> BitBuffer {
+    assert!(
+        bits.inner().len().is_multiple_of(128),
+        "Transpose BitBuffer byte length must be a multiple of 128"
+    );
+    let (offset, len, bytes) = bits.into_inner();
+    match bytes.try_into_mut() {
+        Ok(mut bytes_mut) => {
+            let (chunks, _) = bytes_mut.as_chunks_mut::<128>();
+            let mut tmp = [0u8; 128];
+            for chunk in chunks {
+                untranspose_bits(chunk, &mut tmp);
+                chunk.copy_from_slice(&tmp);
+            }
+            BitBuffer::new_with_offset(bytes_mut.freeze().into_byte_buffer(), len, offset)
+        }
+        Err(bytes) => bits_op_with_copy(bytes, len, offset, untranspose_bits),
+    }
+}
+
+fn bits_op_with_copy<F: Fn(&[u8; 128], &mut [u8; 128])>(
+    bytes: ByteBuffer,
+    len: usize,
+    offset: usize,
+    op: F,
+) -> BitBuffer {
+    let output_len = bytes.len().next_multiple_of(128);
+    let mut output = ByteBufferMut::with_capacity(output_len);
+    let (input_chunks, input_trailer) = bytes.as_chunks::<128>();
+    // We can ignore the spare trailer capacity that can be an artifact of allocator as we requested 128 multiple chunks
+    let (output_chunks, _) = output.spare_capacity_mut().as_chunks_mut::<128>();
+
+    for (input, output) in input_chunks.iter().zip(output_chunks.iter_mut()) {
+        op(input, unsafe {
+            mem::transmute::<&mut [MaybeUninit<u8>; 128], &mut [u8; 128]>(output)
+        });
+    }
+
+    if !input_trailer.is_empty() {
+        let mut padded_input = [0u8; 128];
+        padded_input[0..input_trailer.len()].clone_from_slice(input_trailer);
+        op(&padded_input, unsafe {
+            mem::transmute::<&mut [MaybeUninit<u8>; 128], &mut [u8; 128]>(
+                output_chunks
+                    .last_mut()
+                    .vortex_expect("Output wasn't a multiple of 128 bytes"),
+            )
+        });
+    }
+
+    unsafe { output.set_len(output_len) };
+    BitBuffer::new_with_offset(
+        output.freeze().into_byte_buffer(),
+        len.next_multiple_of(1024),
+        offset,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::BitBuffer;
+    use vortex_buffer::BitBufferMut;
+    use vortex_buffer::ByteBuffer;
+
+    use super::*;
+
+    fn make_validity_bits(num_bits: usize) -> BitBuffer {
+        let mut builder = BitBufferMut::with_capacity(num_bits);
+        for i in 0..num_bits {
+            builder.append(i % 3 != 0);
+        }
+        builder.freeze()
+    }
+
+    fn force_copy_path(bits: BitBuffer) -> (BitBuffer, ByteBuffer) {
+        let (offset, len, bytes) = bits.into_inner();
+        let extra_ref = bytes.clone();
+        (BitBuffer::new_with_offset(bytes, len, offset), extra_ref)
+    }
+
+    #[test]
+    fn transpose_padding_copy_produces_same_bits() {
+        let bits = make_validity_bits(500);
+        let transposed = transpose_bitbuffer(bits.clone());
+        assert_eq!(transposed.len(), 1024);
+        let untransposed = untranspose_bitbuffer(transposed);
+        assert_eq!(untransposed.slice(0..500), bits)
+    }
+
+    #[test]
+    fn transpose_inplace_and_copy_produce_same_bits() {
+        let bits = make_validity_bits(2048);
+
+        let inplace_result = transpose_bitbuffer(bits.clone());
+
+        let (bits_shared, _hold) = force_copy_path(bits);
+        let copy_result = transpose_bitbuffer(bits_shared);
+
+        assert_eq!(inplace_result.len(), copy_result.len());
+        assert_eq!(inplace_result, copy_result);
+    }
+
+    #[test]
+    fn transpose_validity_roundtrip_non_aligned() {
+        let original_len = 1500;
+        let bits = make_validity_bits(original_len);
+
+        let transposed = transpose_bitbuffer(bits.clone());
+        let roundtripped = untranspose_bitbuffer(transposed);
+        assert_eq!(bits, roundtripped.slice(0..original_len));
+    }
+}
diff --git a/encodings/fastlanes/src/bit_transpose/x86.rs b/encodings/fastlanes/src/bit_transpose/x86.rs
new file mode 100644
index 00000000000..6277d76137f
--- /dev/null
+++ b/encodings/fastlanes/src/bit_transpose/x86.rs
@@ -0,0 +1,717 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#![cfg(target_arch = "x86_64")]
+
+use core::arch::x86_64::__m512i;
+use core::arch::x86_64::_mm512_and_si512;
+use core::arch::x86_64::_mm512_loadu_si512;
+use core::arch::x86_64::_mm512_permutex2var_epi8;
+use core::arch::x86_64::_mm512_permutexvar_epi8;
+use core::arch::x86_64::_mm512_set1_epi64;
+use core::arch::x86_64::_mm512_slli_epi64;
+use core::arch::x86_64::_mm512_srli_epi64;
+use core::arch::x86_64::_mm512_storeu_si512;
+use core::arch::x86_64::_mm512_xor_si512;
+use core::arch::x86_64::_pdep_u64;
+use core::arch::x86_64::_pext_u64;
+use std::is_x86_feature_detected;
+
+use crate::bit_transpose::BASE_PATTERN_FIRST;
+use crate::bit_transpose::BASE_PATTERN_SECOND;
+use crate::bit_transpose::TRANSPOSE_2X2;
+use crate::bit_transpose::TRANSPOSE_4X4;
+use crate::bit_transpose::TRANSPOSE_8X8;
+
+/// Check if BMI2 is available.
+#[inline]
+#[must_use]
+pub fn has_bmi2() -> bool {
+    is_x86_feature_detected!("bmi2")
+}
+
+/// Check if AVX-512 VBMI is available (for byte permutation).
+#[inline]
+#[must_use]
+pub fn has_vbmi() -> bool {
+    is_x86_feature_detected!("avx512vbmi")
+}
+
+/// Transpose 1024 bits using BMI2 PEXT instruction.
+///
+/// PEXT extracts bits at positions specified by a mask into contiguous low bits.
+/// Fully unrolled for ~12% better performance vs looped version.
+///
+/// # Safety
+/// Requires BMI2 support. Check with `has_bmi2()` before calling.
+#[target_feature(enable = "bmi2")]
+#[inline(never)]
+#[allow(clippy::too_many_lines)]
+#[allow(unsafe_op_in_unsafe_fn)]
+pub unsafe fn transpose_bits_bmi2(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Helper to gather 8 bytes at stride 16 into a u64
+    fn gather(input: &[u8; 128], base: usize) -> u64 {
+        (input[base] as u64)
+            | ((input[base + 16] as u64) << 8)
+            | ((input[base + 32] as u64) << 16)
+            | ((input[base + 48] as u64) << 24)
+            | ((input[base + 64] as u64) << 32)
+            | ((input[base + 80] as u64) << 40)
+            | ((input[base + 96] as u64) << 48)
+            | ((input[base + 112] as u64) << 56)
+    }
+
+    // Gather all 16 groups (fully unrolled)
+    // First half: BASE_PATTERN_FIRST = [0, 8, 4, 12, 2, 10, 6, 14]
+    let g0 = gather(input, 0);
+    let g1 = gather(input, 8);
+    let g2 = gather(input, 4);
+    let g3 = gather(input, 12);
+    let g4 = gather(input, 2);
+    let g5 = gather(input, 10);
+    let g6 = gather(input, 6);
+    let g7 = gather(input, 14);
+    // Second half: BASE_PATTERN_SECOND = [1, 9, 5, 13, 3, 11, 7, 15]
+    let g8 = gather(input, 1);
+    let g9 = gather(input, 9);
+    let g10 = gather(input, 5);
+    let g11 = gather(input, 13);
+    let g12 = gather(input, 3);
+    let g13 = gather(input, 11);
+    let g14 = gather(input, 7);
+    let g15 = gather(input, 15);
+
+    // Masks for each bit position
+    let m0: u64 = 0x0101_0101_0101_0101;
+    let m1: u64 = 0x0202_0202_0202_0202;
+    let m2: u64 = 0x0404_0404_0404_0404;
+    let m3: u64 = 0x0808_0808_0808_0808;
+    let m4: u64 = 0x1010_1010_1010_1010;
+    let m5: u64 = 0x2020_2020_2020_2020;
+    let m6: u64 = 0x4040_4040_4040_4040;
+    let m7: u64 = 0x8080_8080_8080_8080;
+
+    // First half - 64 PEXT operations (fully unrolled)
+    output[0] = _pext_u64(g0, m0) as u8;
+    output[1] = _pext_u64(g1, m0) as u8;
+    output[2] = _pext_u64(g2, m0) as u8;
+    output[3] = _pext_u64(g3, m0) as u8;
+    output[4] = _pext_u64(g4, m0) as u8;
+    output[5] = _pext_u64(g5, m0) as u8;
+    output[6] = _pext_u64(g6, m0) as u8;
+    output[7] = _pext_u64(g7, m0) as u8;
+    output[8] = _pext_u64(g0, m1) as u8;
+    output[9] = _pext_u64(g1, m1) as u8;
+    output[10] = _pext_u64(g2, m1) as u8;
+    output[11] = _pext_u64(g3, m1) as u8;
+    output[12] = _pext_u64(g4, m1) as u8;
+    output[13] = _pext_u64(g5, m1) as u8;
+    output[14] = _pext_u64(g6, m1) as u8;
+    output[15] = _pext_u64(g7, m1) as u8;
+    output[16] = _pext_u64(g0, m2) as u8;
+    output[17] = _pext_u64(g1, m2) as u8;
+    output[18] = _pext_u64(g2, m2) as u8;
+    output[19] = _pext_u64(g3, m2) as u8;
+    output[20] = _pext_u64(g4, m2) as u8;
+    output[21] = _pext_u64(g5, m2) as u8;
+    output[22] = _pext_u64(g6, m2) as u8;
+    output[23] = _pext_u64(g7, m2) as u8;
+    output[24] = _pext_u64(g0, m3) as u8;
+    output[25] = _pext_u64(g1, m3) as u8;
+    output[26] = _pext_u64(g2, m3) as u8;
+    output[27] = _pext_u64(g3, m3) as u8;
+    output[28] = _pext_u64(g4, m3) as u8;
+    output[29] = _pext_u64(g5, m3) as u8;
+    output[30] = _pext_u64(g6, m3) as u8;
+    output[31] = _pext_u64(g7, m3) as u8;
+    output[32] = _pext_u64(g0, m4) as u8;
+    output[33] = _pext_u64(g1, m4) as u8;
+    output[34] = _pext_u64(g2, m4) as u8;
+    output[35] = _pext_u64(g3, m4) as u8;
+    output[36] = _pext_u64(g4, m4) as u8;
+    output[37] = _pext_u64(g5, m4) as u8;
+    output[38] = _pext_u64(g6, m4) as u8;
+    output[39] = _pext_u64(g7, m4) as u8;
+    output[40] = _pext_u64(g0, m5) as u8;
+    output[41] = _pext_u64(g1, m5) as u8;
+    output[42] = _pext_u64(g2, m5) as u8;
+    output[43] = _pext_u64(g3, m5) as u8;
+    output[44] = _pext_u64(g4, m5) as u8;
+    output[45] = _pext_u64(g5, m5) as u8;
+    output[46] = _pext_u64(g6, m5) as u8;
+    output[47] = _pext_u64(g7, m5) as u8;
+    output[48] = _pext_u64(g0, m6) as u8;
+    output[49] = _pext_u64(g1, m6) as u8;
+    output[50] = _pext_u64(g2, m6) as u8;
+    output[51] = _pext_u64(g3, m6) as u8;
+    output[52] = _pext_u64(g4, m6) as u8;
+    output[53] = _pext_u64(g5, m6) as u8;
+    output[54] = _pext_u64(g6, m6) as u8;
+    output[55] = _pext_u64(g7, m6) as u8;
+    output[56] = _pext_u64(g0, m7) as u8;
+    output[57] = _pext_u64(g1, m7) as u8;
+    output[58] = _pext_u64(g2, m7) as u8;
+    output[59] = _pext_u64(g3, m7) as u8;
+    output[60] = _pext_u64(g4, m7) as u8;
+    output[61] = _pext_u64(g5, m7) as u8;
+    output[62] = _pext_u64(g6, m7) as u8;
+    output[63] = _pext_u64(g7, m7) as u8;
+
+    // Second half - 64 PEXT operations (fully unrolled)
+    output[64] = _pext_u64(g8, m0) as u8;
+    output[65] = _pext_u64(g9, m0) as u8;
+    output[66] = _pext_u64(g10, m0) as u8;
+    output[67] = _pext_u64(g11, m0) as u8;
+    output[68] = _pext_u64(g12, m0) as u8;
+    output[69] = _pext_u64(g13, m0) as u8;
+    output[70] = _pext_u64(g14, m0) as u8;
+    output[71] = _pext_u64(g15, m0) as u8;
+    output[72] = _pext_u64(g8, m1) as u8;
+    output[73] = _pext_u64(g9, m1) as u8;
+    output[74] = _pext_u64(g10, m1) as u8;
+    output[75] = _pext_u64(g11, m1) as u8;
+    output[76] = _pext_u64(g12, m1) as u8;
+    output[77] = _pext_u64(g13, m1) as u8;
+    output[78] = _pext_u64(g14, m1) as u8;
+    output[79] = _pext_u64(g15, m1) as u8;
+    output[80] = _pext_u64(g8, m2) as u8;
+    output[81] = _pext_u64(g9, m2) as u8;
+    output[82] = _pext_u64(g10, m2) as u8;
+    output[83] = _pext_u64(g11, m2) as u8;
+    output[84] = _pext_u64(g12, m2) as u8;
+    output[85] = _pext_u64(g13, m2) as u8;
+    output[86] = _pext_u64(g14, m2) as u8;
+    output[87] = _pext_u64(g15, m2) as u8;
+    output[88] = _pext_u64(g8, m3) as u8;
+    output[89] = _pext_u64(g9, m3) as u8;
+    output[90] = _pext_u64(g10, m3) as u8;
+    output[91] = _pext_u64(g11, m3) as u8;
+    output[92] = _pext_u64(g12, m3) as u8;
+    output[93] = _pext_u64(g13, m3) as u8;
+    output[94] = _pext_u64(g14, m3) as u8;
+    output[95] = _pext_u64(g15, m3) as u8;
+    output[96] = _pext_u64(g8, m4) as u8;
+    output[97] = _pext_u64(g9, m4) as u8;
+    output[98] = _pext_u64(g10, m4) as u8;
+    output[99] = _pext_u64(g11, m4) as u8;
+    output[100] = _pext_u64(g12, m4) as u8;
+    output[101] = _pext_u64(g13, m4) as u8;
+    output[102] = _pext_u64(g14, m4) as u8;
+    output[103] = _pext_u64(g15, m4) as u8;
+    output[104] = _pext_u64(g8, m5) as u8;
+    output[105] = _pext_u64(g9, m5) as u8;
+    output[106] = _pext_u64(g10, m5) as u8;
+    output[107] = _pext_u64(g11, m5) as u8;
+    output[108] = _pext_u64(g12, m5) as u8;
+    output[109] = _pext_u64(g13, m5) as u8;
+    output[110] = _pext_u64(g14, m5) as u8;
+    output[111] = _pext_u64(g15, m5) as u8;
+    output[112] = _pext_u64(g8, m6) as u8;
+    output[113] = _pext_u64(g9, m6) as u8;
+    output[114] = _pext_u64(g10, m6) as u8;
+    output[115] = _pext_u64(g11, m6) as u8;
+    output[116] = _pext_u64(g12, m6) as u8;
+    output[117] = _pext_u64(g13, m6) as u8;
+    output[118] = _pext_u64(g14, m6) as u8;
+    output[119] = _pext_u64(g15, m6) as u8;
+    output[120] = _pext_u64(g8, m7) as u8;
+    output[121] = _pext_u64(g9, m7) as u8;
+    output[122] = _pext_u64(g10, m7) as u8;
+    output[123] = _pext_u64(g11, m7) as u8;
+    output[124] = _pext_u64(g12, m7) as u8;
+    output[125] = _pext_u64(g13, m7) as u8;
+    output[126] = _pext_u64(g14, m7) as u8;
+    output[127] = _pext_u64(g15, m7) as u8;
+}
+
+/// Untranspose 1024 bits using BMI2 PDEP instruction.
+///
+/// Structured per-output-group: for each group of 8 output bytes at stride 16,
+/// PDEP 8 input bytes into different bit positions, OR in registers, then
+/// scatter-store once. Each output byte is written exactly once (no read-modify-write).
+///
+/// # Safety
+/// Requires BMI2 support. Check with `has_bmi2()` before calling.
+#[target_feature(enable = "bmi2")]
+#[inline(never)]
+#[allow(clippy::too_many_lines)]
+#[allow(unsafe_op_in_unsafe_fn)]
+pub unsafe fn untranspose_bits_bmi2(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Helper: scatter a u64 to 8 output bytes at stride 16
+    fn scatter(output: &mut [u8; 128], base: usize, val: u64) {
+        output[base] = val as u8;
+        output[base + 16] = (val >> 8) as u8;
+        output[base + 32] = (val >> 16) as u8;
+        output[base + 48] = (val >> 24) as u8;
+        output[base + 64] = (val >> 32) as u8;
+        output[base + 80] = (val >> 40) as u8;
+        output[base + 96] = (val >> 48) as u8;
+        output[base + 112] = (val >> 56) as u8;
+    }
+
+    // Masks for each bit position
+    let m0: u64 = 0x0101_0101_0101_0101;
+    let m1: u64 = 0x0202_0202_0202_0202;
+    let m2: u64 = 0x0404_0404_0404_0404;
+    let m3: u64 = 0x0808_0808_0808_0808;
+    let m4: u64 = 0x1010_1010_1010_1010;
+    let m5: u64 = 0x2020_2020_2020_2020;
+    let m6: u64 = 0x4040_4040_4040_4040;
+    let m7: u64 = 0x8080_8080_8080_8080;
+
+    // For each output group, the input bytes that contribute are at
+    // input[bit_pos * 8 + group_idx] for bit_pos 0..8.
+    // PDEP deposits the 8 bits of the input byte into the bit_pos position
+    // of each byte in the u64.
+
+    // First half: 8 groups using BASE_PATTERN_FIRST
+    // Group 0 (base=0): input bytes [0, 8, 16, 24, 32, 40, 48, 56]
+    let v = _pdep_u64(input[0] as u64, m0)
+        | _pdep_u64(input[8] as u64, m1)
+        | _pdep_u64(input[16] as u64, m2)
+        | _pdep_u64(input[24] as u64, m3)
+        | _pdep_u64(input[32] as u64, m4)
+        | _pdep_u64(input[40] as u64, m5)
+        | _pdep_u64(input[48] as u64, m6)
+        | _pdep_u64(input[56] as u64, m7);
+    scatter(output, 0, v);
+
+    // Group 1 (base=8)
+    let v = _pdep_u64(input[1] as u64, m0)
+        | _pdep_u64(input[9] as u64, m1)
+        | _pdep_u64(input[17] as u64, m2)
+        | _pdep_u64(input[25] as u64, m3)
+        | _pdep_u64(input[33] as u64, m4)
+        | _pdep_u64(input[41] as u64, m5)
+        | _pdep_u64(input[49] as u64, m6)
+        | _pdep_u64(input[57] as u64, m7);
+    scatter(output, 8, v);
+
+    // Group 2 (base=4)
+    let v = _pdep_u64(input[2] as u64, m0)
+        | _pdep_u64(input[10] as u64, m1)
+        | _pdep_u64(input[18] as u64, m2)
+        | _pdep_u64(input[26] as u64, m3)
+        | _pdep_u64(input[34] as u64, m4)
+        | _pdep_u64(input[42] as u64, m5)
+        | _pdep_u64(input[50] as u64, m6)
+        | _pdep_u64(input[58] as u64, m7);
+    scatter(output, 4, v);
+
+    // Group 3 (base=12)
+    let v = _pdep_u64(input[3] as u64, m0)
+        | _pdep_u64(input[11] as u64, m1)
+        | _pdep_u64(input[19] as u64, m2)
+        | _pdep_u64(input[27] as u64, m3)
+        | _pdep_u64(input[35] as u64, m4)
+        | _pdep_u64(input[43] as u64, m5)
+        | _pdep_u64(input[51] as u64, m6)
+        | _pdep_u64(input[59] as u64, m7);
+    scatter(output, 12, v);
+
+    // Group 4 (base=2)
+    let v = _pdep_u64(input[4] as u64, m0)
+        | _pdep_u64(input[12] as u64, m1)
+        | _pdep_u64(input[20] as u64, m2)
+        | _pdep_u64(input[28] as u64, m3)
+        | _pdep_u64(input[36] as u64, m4)
+        | _pdep_u64(input[44] as u64, m5)
+        | _pdep_u64(input[52] as u64, m6)
+        | _pdep_u64(input[60] as u64, m7);
+    scatter(output, 2, v);
+
+    // Group 5 (base=10)
+    let v = _pdep_u64(input[5] as u64, m0)
+        | _pdep_u64(input[13] as u64, m1)
+        | _pdep_u64(input[21] as u64, m2)
+        | _pdep_u64(input[29] as u64, m3)
+        | _pdep_u64(input[37] as u64, m4)
+        | _pdep_u64(input[45] as u64, m5)
+        | _pdep_u64(input[53] as u64, m6)
+        | _pdep_u64(input[61] as u64, m7);
+    scatter(output, 10, v);
+
+    // Group 6 (base=6)
+    let v = _pdep_u64(input[6] as u64, m0)
+        | _pdep_u64(input[14] as u64, m1)
+        | _pdep_u64(input[22] as u64, m2)
+        | _pdep_u64(input[30] as u64, m3)
+        | _pdep_u64(input[38] as u64, m4)
+        | _pdep_u64(input[46] as u64, m5)
+        | _pdep_u64(input[54] as u64, m6)
+        | _pdep_u64(input[62] as u64, m7);
+    scatter(output, 6, v);
+
+    // Group 7 (base=14)
+    let v = _pdep_u64(input[7] as u64, m0)
+        | _pdep_u64(input[15] as u64, m1)
+        | _pdep_u64(input[23] as u64, m2)
+        | _pdep_u64(input[31] as u64, m3)
+        | _pdep_u64(input[39] as u64, m4)
+        | _pdep_u64(input[47] as u64, m5)
+        | _pdep_u64(input[55] as u64, m6)
+        | _pdep_u64(input[63] as u64, m7);
+    scatter(output, 14, v);
+
+    // Second half: 8 groups using BASE_PATTERN_SECOND
+    // Group 0 (base=1)
+    let v = _pdep_u64(input[64] as u64, m0)
+        | _pdep_u64(input[72] as u64, m1)
+        | _pdep_u64(input[80] as u64, m2)
+        | _pdep_u64(input[88] as u64, m3)
+        | _pdep_u64(input[96] as u64, m4)
+        | _pdep_u64(input[104] as u64, m5)
+        | _pdep_u64(input[112] as u64, m6)
+        | _pdep_u64(input[120] as u64, m7);
+    scatter(output, 1, v);
+
+    // Group 1 (base=9)
+    let v = _pdep_u64(input[65] as u64, m0)
+        | _pdep_u64(input[73] as u64, m1)
+        | _pdep_u64(input[81] as u64, m2)
+        | _pdep_u64(input[89] as u64, m3)
+        | _pdep_u64(input[97] as u64, m4)
+        | _pdep_u64(input[105] as u64, m5)
+        | _pdep_u64(input[113] as u64, m6)
+        | _pdep_u64(input[121] as u64, m7);
+    scatter(output, 9, v);
+
+    // Group 2 (base=5)
+    let v = _pdep_u64(input[66] as u64, m0)
+        | _pdep_u64(input[74] as u64, m1)
+        | _pdep_u64(input[82] as u64, m2)
+        | _pdep_u64(input[90] as u64, m3)
+        | _pdep_u64(input[98] as u64, m4)
+        | _pdep_u64(input[106] as u64, m5)
+        | _pdep_u64(input[114] as u64, m6)
+        | _pdep_u64(input[122] as u64, m7);
+    scatter(output, 5, v);
+
+    // Group 3 (base=13)
+    let v = _pdep_u64(input[67] as u64, m0)
+        | _pdep_u64(input[75] as u64, m1)
+        | _pdep_u64(input[83] as u64, m2)
+        | _pdep_u64(input[91] as u64, m3)
+        | _pdep_u64(input[99] as u64, m4)
+        | _pdep_u64(input[107] as u64, m5)
+        | _pdep_u64(input[115] as u64, m6)
+        | _pdep_u64(input[123] as u64, m7);
+    scatter(output, 13, v);
+
+    // Group 4 (base=3)
+    let v = _pdep_u64(input[68] as u64, m0)
+        | _pdep_u64(input[76] as u64, m1)
+        | _pdep_u64(input[84] as u64, m2)
+        | _pdep_u64(input[92] as u64, m3)
+        | _pdep_u64(input[100] as u64, m4)
+        | _pdep_u64(input[108] as u64, m5)
+        | _pdep_u64(input[116] as u64, m6)
+        | _pdep_u64(input[124] as u64, m7);
+    scatter(output, 3, v);
+
+    // Group 5 (base=11)
+    let v = _pdep_u64(input[69] as u64, m0)
+        | _pdep_u64(input[77] as u64, m1)
+        | _pdep_u64(input[85] as u64, m2)
+        | _pdep_u64(input[93] as u64, m3)
+        | _pdep_u64(input[101] as u64, m4)
+        | _pdep_u64(input[109] as u64, m5)
+        | _pdep_u64(input[117] as u64, m6)
+        | _pdep_u64(input[125] as u64, m7);
+    scatter(output, 11, v);
+
+    // Group 6 (base=7)
+    let v = _pdep_u64(input[70] as u64, m0)
+        | _pdep_u64(input[78] as u64, m1)
+        | _pdep_u64(input[86] as u64, m2)
+        | _pdep_u64(input[94] as u64, m3)
+        | _pdep_u64(input[102] as u64, m4)
+        | _pdep_u64(input[110] as u64, m5)
+        | _pdep_u64(input[118] as u64, m6)
+        | _pdep_u64(input[126] as u64, m7);
+    scatter(output, 7, v);
+
+    // Group 7 (base=15)
+    let v = _pdep_u64(input[71] as u64, m0)
+        | _pdep_u64(input[79] as u64, m1)
+        | _pdep_u64(input[87] as u64, m2)
+        | _pdep_u64(input[95] as u64, m3)
+        | _pdep_u64(input[103] as u64, m4)
+        | _pdep_u64(input[111] as u64, m5)
+        | _pdep_u64(input[119] as u64, m6)
+        | _pdep_u64(input[127] as u64, m7);
+    scatter(output, 15, v);
+}
+
+// Static permutation tables for VBMI gather operations
+static GATHER_FIRST: [u8; 64] = [
+    // Gather bytes at stride 16 for first 8 groups (bases from BASE_PATTERN_FIRST)
+    // Group 0: base=0
+    0, 16, 32, 48, 64, 80, 96, 112, // Group 1: base=8
+    8, 24, 40, 56, 72, 88, 104, 120, // Group 2: base=4
+    4, 20, 36, 52, 68, 84, 100, 116, // Group 3: base=12
+    12, 28, 44, 60, 76, 92, 108, 124, // Group 4: base=2
+    2, 18, 34, 50, 66, 82, 98, 114, // Group 5: base=10
+    10, 26, 42, 58, 74, 90, 106, 122, // Group 6: base=6
+    6, 22, 38, 54, 70, 86, 102, 118, // Group 7: base=14
+    14, 30, 46, 62, 78, 94, 110, 126,
+];
+
+static GATHER_SECOND: [u8; 64] = [
+    // Gather bytes at stride 16 for second 8 groups (bases from BASE_PATTERN_SECOND)
+    // Group 0: base=1
+    1, 17, 33, 49, 65, 81, 97, 113, // Group 1: base=9
+    9, 25, 41, 57, 73, 89, 105, 121, // Group 2: base=5
+    5, 21, 37, 53, 69, 85, 101, 117, // Group 3: base=13
+    13, 29, 45, 61, 77, 93, 109, 125, // Group 4: base=3
+    3, 19, 35, 51, 67, 83, 99, 115, // Group 5: base=11
+    11, 27, 43, 59, 75, 91, 107, 123, // Group 6: base=7
+    7, 23, 39, 55, 71, 87, 103, 119, // Group 7: base=15
+    15, 31, 47, 63, 79, 95, 111, 127,
+];
+
+// 8x8 byte transpose permutation for scatter phase
+// Input:  [g0b0..g0b7, g1b0..g1b7, ..., g7b0..g7b7] (8 groups of 8 bytes)
+// Output: [g0b0,g1b0,..,g7b0, g0b1,g1b1,..,g7b1, ...] (8 rows of 8 bytes)
+static SCATTER_8X8: [u8; 64] = [
+    0, 8, 16, 24, 32, 40, 48, 56, // byte 0 from each group
+    1, 9, 17, 25, 33, 41, 49, 57, // byte 1 from each group
+    2, 10, 18, 26, 34, 42, 50, 58, // byte 2 from each group
+    3, 11, 19, 27, 35, 43, 51, 59, // byte 3 from each group
+    4, 12, 20, 28, 36, 44, 52, 60, // byte 4 from each group
+    5, 13, 21, 29, 37, 45, 53, 61, // byte 5 from each group
+    6, 14, 22, 30, 38, 46, 54, 62, // byte 6 from each group
+    7, 15, 23, 31, 39, 47, 55, 63, // byte 7 from each group
+];
+
+/// Transpose 1024 bits using AVX-512 VBMI for vectorized gather and scatter.
+///
+/// Uses vpermi2b to gather bytes from stride-16 positions in parallel,
+/// and vpermb for the final 8x8 byte transpose to output format.
+///
+/// # Safety
+/// Requires AVX-512F, AVX-512BW, and AVX-512VBMI support.
+#[target_feature(enable = "avx512f", enable = "avx512bw", enable = "avx512vbmi")]
+#[inline(never)]
+#[allow(clippy::cast_possible_wrap)]
+#[allow(clippy::cast_ptr_alignment)]
+#[allow(unsafe_op_in_unsafe_fn)]
+pub unsafe fn transpose_bits_vbmi(input: &[u8; 128], output: &mut [u8; 128]) {
+    // Load all 128 input bytes into two ZMM registers
+    let in_lo = _mm512_loadu_si512(input.as_ptr().cast::<__m512i>());
+    let in_hi = _mm512_loadu_si512(input.as_ptr().add(64).cast::<__m512i>());
+
+    // Load permutation indices (static tables)
+    let idx_first = _mm512_loadu_si512(GATHER_FIRST.as_ptr().cast::<__m512i>());
+    let idx_second = _mm512_loadu_si512(GATHER_SECOND.as_ptr().cast::<__m512i>());
+    let idx_scatter = _mm512_loadu_si512(SCATTER_8X8.as_ptr().cast::<__m512i>());
+
+    // Masks for 8x8 bit transpose
+    let mask1 = _mm512_set1_epi64(TRANSPOSE_2X2 as i64);
+    let mask2 = _mm512_set1_epi64(TRANSPOSE_4X4 as i64);
+    let mask3 = _mm512_set1_epi64(TRANSPOSE_8X8 as i64);
+
+    // Process first half
+    let gathered = _mm512_permutex2var_epi8(in_lo, idx_first, in_hi);
+
+    // 8x8 bit transpose on all 8 groups in parallel
+    let mut v = gathered;
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<7>(v)), mask1);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<7>(t));
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<14>(v)), mask2);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<14>(t));
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<28>(v)), mask3);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<28>(t));
+
+    // 8x8 byte transpose for scatter using vpermb
+    let scattered = _mm512_permutexvar_epi8(idx_scatter, v);
+    _mm512_storeu_si512(output.as_mut_ptr().cast::<__m512i>(), scattered);
+
+    // Process second half
+    let gathered = _mm512_permutex2var_epi8(in_lo, idx_second, in_hi);
+
+    let mut v = gathered;
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<7>(v)), mask1);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<7>(t));
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<14>(v)), mask2);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<14>(t));
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<28>(v)), mask3);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<28>(t));
+
+    let scattered = _mm512_permutexvar_epi8(idx_scatter, v);
+    _mm512_storeu_si512(output.as_mut_ptr().add(64).cast::<__m512i>(), scattered);
+}
+
+/// Untranspose 1024 bits using AVX-512 VBMI for vectorized scatter.
+///
+/// # Safety
+/// Requires AVX-512F, AVX-512BW, and AVX-512VBMI support.
+#[target_feature(enable = "avx512f", enable = "avx512bw", enable = "avx512vbmi")]
+#[inline(never)]
+#[allow(clippy::cast_possible_wrap)]
+#[allow(clippy::cast_ptr_alignment)]
+#[allow(unsafe_op_in_unsafe_fn)]
+pub unsafe fn untranspose_bits_vbmi(input: &[u8; 128], output: &mut [u8; 128]) {
+    // For untranspose, we gather consecutive bytes from transposed layout,
+    // then scatter back to stride-16 positions
+
+    // Gather indices for first half - collect 8 bytes per group from transposed layout
+    // In transposed layout, bytes for group 0 are at: [0, 8, 16, 24, 32, 40, 48, 56]
+    let gather_indices: [u8; 64] = [
+        0, 8, 16, 24, 32, 40, 48, 56, // Group 0
+        1, 9, 17, 25, 33, 41, 49, 57, // Group 1
+        2, 10, 18, 26, 34, 42, 50, 58, // Group 2
+        3, 11, 19, 27, 35, 43, 51, 59, // Group 3
+        4, 12, 20, 28, 36, 44, 52, 60, // Group 4
+        5, 13, 21, 29, 37, 45, 53, 61, // Group 5
+        6, 14, 22, 30, 38, 46, 54, 62, // Group 6
+        7, 15, 23, 31, 39, 47, 55, 63, // Group 7
+    ];
+
+    let in_first = _mm512_loadu_si512(input.as_ptr().cast::<__m512i>());
+    let idx = _mm512_loadu_si512(gather_indices.as_ptr().cast::<__m512i>());
+    let gathered = _mm512_permutexvar_epi8(idx, in_first);
+
+    // 8x8 bit transpose
+    let mask1 = _mm512_set1_epi64(TRANSPOSE_2X2 as i64);
+    let mask2 = _mm512_set1_epi64(TRANSPOSE_4X4 as i64);
+    let mask3 = _mm512_set1_epi64(TRANSPOSE_8X8 as i64);
+
+    let mut v = gathered;
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<7>(v)), mask1);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<7>(t));
+
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<14>(v)), mask2);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<14>(t));
+
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<28>(v)), mask3);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<28>(t));
+
+    // Scatter to output at stride 16 - need to use scalar stores for now
+    // (AVX-512 scatter is available but complex for this pattern)
+    let mut result = [0u64; 8];
+    _mm512_storeu_si512(result.as_mut_ptr().cast::<__m512i>(), v);
+
+    for base_group in 0..8 {
+        let out_base = BASE_PATTERN_FIRST[base_group];
+        for i in 0..8 {
+            output[out_base + i * 16] = (result[base_group] >> (i * 8)) as u8;
+        }
+    }
+
+    // Second half
+    let in_second = _mm512_loadu_si512(input.as_ptr().add(64).cast::<__m512i>());
+    let gathered = _mm512_permutexvar_epi8(idx, in_second);
+
+    let mut v = gathered;
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<7>(v)), mask1);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<7>(t));
+
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<14>(v)), mask2);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<14>(t));
+
+    let t = _mm512_and_si512(_mm512_xor_si512(v, _mm512_srli_epi64::<28>(v)), mask3);
+    v = _mm512_xor_si512(_mm512_xor_si512(v, t), _mm512_slli_epi64::<28>(t));
+
+    _mm512_storeu_si512(result.as_mut_ptr().cast::<__m512i>(), v);
+
+    for base_group in 0..8 {
+        let out_base = BASE_PATTERN_SECOND[base_group];
+        for i in 0..8 {
+            output[out_base + i * 16] = (result[base_group] >> (i * 8)) as u8;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::bit_transpose::generate_test_data;
+    use crate::bit_transpose::transpose_bits_baseline;
+    use crate::bit_transpose::x86::has_bmi2;
+    use crate::bit_transpose::x86::has_vbmi;
+    use crate::bit_transpose::x86::transpose_bits_bmi2;
+    use crate::bit_transpose::x86::transpose_bits_vbmi;
+    use crate::bit_transpose::x86::untranspose_bits_bmi2;
+    use crate::bit_transpose::x86::untranspose_bits_vbmi;
+
+    #[test]
+    fn test_bmi2_matches_baseline() {
+        if !has_bmi2() {
+            return;
+        }
+
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut bmi2_out = [0u8; 128];
+
+            transpose_bits_baseline(&input, &mut baseline_out);
+            unsafe { transpose_bits_bmi2(&input, &mut bmi2_out) };
+
+            assert_eq!(
+                baseline_out, bmi2_out,
+                "BMI2 transpose doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_bmi2_roundtrip() {
+        if !has_bmi2() {
+            return;
+        }
+
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut transposed = [0u8; 128];
+            let mut roundtrip = [0u8; 128];
+
+            unsafe {
+                transpose_bits_bmi2(&input, &mut transposed);
+                untranspose_bits_bmi2(&transposed, &mut roundtrip);
+            }
+
+            assert_eq!(input, roundtrip, "BMI2 roundtrip failed for seed {seed}");
+        }
+    }
+
+    #[test]
+    fn test_vbmi_matches_baseline() {
+        if !has_vbmi() {
+            return;
+        }
+
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut baseline_out = [0u8; 128];
+            let mut vbmi_out = [0u8; 128];
+
+            transpose_bits_baseline(&input, &mut baseline_out);
+            unsafe { transpose_bits_vbmi(&input, &mut vbmi_out) };
+
+            assert_eq!(
+                baseline_out, vbmi_out,
+                "VBMI transpose doesn't match baseline for seed {seed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_vbmi_roundtrip() {
+        if !has_vbmi() {
+            return;
+        }
+
+        for seed in [0, 42, 123, 255] {
+            let input = generate_test_data(seed);
+            let mut transposed = [0u8; 128];
+            let mut roundtrip = [0u8; 128];
+
+            unsafe {
+                transpose_bits_vbmi(&input, &mut transposed);
+                untranspose_bits_vbmi(&transposed, &mut roundtrip);
+            }
+
+            assert_eq!(input, roundtrip, "VBMI roundtrip failed for seed {seed}");
+        }
+    }
+}
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
index 91177a9c646..dfbb0ed7b17 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
+++ b/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
@@ -6,6 +6,7 @@ use itertools::Itertools;
 use num_traits::PrimInt;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::dtype::NativePType;
@@ -14,7 +15,6 @@ use vortex_array::match_each_integer_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::patches::Patches;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_buffer::ByteBuffer;
@@ -24,6 +24,7 @@ use vortex_error::vortex_bail;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 
+use crate::BitPacked;
 use crate::BitPackedArray;
 use crate::bitpack_decompress;
 
@@ -65,28 +66,22 @@ pub fn bitpack_encode(
     }
 
     // SAFETY: we check that array only contains non-negative values.
-    let packed = unsafe { bitpack_unchecked(array, bit_width)? };
+    let packed = unsafe { bitpack_unchecked(array, bit_width) };
     let patches = (num_exceptions > 0)
         .then(|| gather_patches(array, bit_width, num_exceptions))
         .transpose()?
         .flatten();
 
-    // SAFETY: all components validated above
-    let bitpacked = unsafe {
-        BitPackedArray::new_unchecked(
-            BufferHandle::new_host(packed),
-            array.dtype().clone(),
-            array.validity().clone(),
-            patches,
-            bit_width,
-            array.len(),
-            0,
-        )
-    };
-    bitpacked
-        .stats_set
-        .to_ref(bitpacked.as_ref())
-        .inherit_from(array.statistics());
+    let bitpacked = BitPacked::try_new(
+        BufferHandle::new_host(packed),
+        array.ptype(),
+        array.validity()?,
+        patches,
+        bit_width,
+        array.len(),
+        0,
+    )?;
+    bitpacked.statistics().inherit_from(array.statistics());
     Ok(bitpacked)
 }
 
@@ -103,24 +98,20 @@ pub unsafe fn bitpack_encode_unchecked(
     bit_width: u8,
 ) -> VortexResult<BitPackedArray> {
     // SAFETY: non-negativity of input checked by caller.
-    let packed = unsafe { bitpack_unchecked(&array, bit_width)? };
-
-    // SAFETY: checked by bitpack_unchecked
-    let bitpacked = unsafe {
-        BitPackedArray::new_unchecked(
-            BufferHandle::new_host(packed),
-            array.dtype().clone(),
-            array.validity().clone(),
-            None,
-            bit_width,
-            array.len(),
-            0,
-        )
-    };
-    bitpacked
-        .stats_set
-        .to_ref(bitpacked.as_ref())
-        .inherit_from(array.statistics());
+    let packed = unsafe { bitpack_unchecked(&array, bit_width) };
+
+    let arr_ref = array.clone().into_array();
+    let bitpacked = BitPacked::try_new(
+        BufferHandle::new_host(packed),
+        array.ptype(),
+        array.validity()?,
+        None,
+        bit_width,
+        array.len(),
+        0,
+    )
+    .vortex_expect("bitpacked array construction should succeed");
+    bitpacked.statistics().inherit_from(arr_ref.statistics());
     Ok(bitpacked)
 }
 
@@ -135,15 +126,11 @@ pub unsafe fn bitpack_encode_unchecked(
 ///
 /// It is the caller's responsibility to ensure that `parray` is non-negative before calling
 /// this function.
-pub unsafe fn bitpack_unchecked(
-    parray: &PrimitiveArray,
-    bit_width: u8,
-) -> VortexResult<ByteBuffer> {
+pub unsafe fn bitpack_unchecked(parray: &PrimitiveArray, bit_width: u8) -> ByteBuffer {
     let parray = parray.reinterpret_cast(parray.ptype().to_unsigned());
-    let packed = match_each_unsigned_integer_ptype!(parray.ptype(), |P| {
+    match_each_unsigned_integer_ptype!(parray.ptype(), |P| {
         bitpack_primitive(parray.as_slice::<P>(), bit_width).into_byte_buffer()
-    });
-    Ok(packed)
+    })
 }
 
 /// Bitpack a slice of primitives down to the given width.
@@ -205,7 +192,7 @@ pub fn gather_patches(
     bit_width: u8,
     num_exceptions_hint: usize,
 ) -> VortexResult<Option<Patches>> {
-    let patch_validity = match parray.validity() {
+    let patch_validity = match parray.validity()? {
         Validity::NonNullable => Validity::NonNullable,
         _ => Validity::AllValid,
     };
@@ -380,7 +367,7 @@ fn bytes_per_exception(ptype: PType) -> usize {
 
 #[cfg(feature = "_test-harness")]
 pub mod test_harness {
-    use rand::Rng as _;
+    use rand::RngExt;
     use rand::rngs::StdRng;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
@@ -437,7 +424,9 @@ mod test {
     use vortex_session::VortexSession;
 
     use super::*;
+    use crate::BitPackedData;
     use crate::bitpack_compress::test_harness::make_array;
+    use crate::bitpacking::array::BitPackedArrayExt;
 
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
@@ -461,7 +450,7 @@ mod test {
             Validity::from_iter(valid_values),
         );
         assert!(values.ptype().is_unsigned_int());
-        let compressed = BitPackedArray::encode(values.as_ref(), 4).unwrap();
+        let compressed = BitPackedData::encode(&values.into_array(), 4).unwrap();
         assert!(compressed.patches().is_none());
         assert_eq!(
             (0..(1 << 4)).collect::<Vec<_>>(),
@@ -480,7 +469,7 @@ mod test {
         let array = PrimitiveArray::new(values, Validity::AllValid);
         assert!(array.ptype().is_signed_int());
 
-        let err = BitPackedArray::encode(array.as_ref(), 1024u32.ilog2() as u8).unwrap_err();
+        let err = BitPackedData::encode(&array.into_array(), 1024u32.ilog2() as u8).unwrap_err();
         assert!(matches!(err, VortexError::InvalidArgument(_, _)));
     }
 
@@ -493,12 +482,10 @@ mod test {
             .collect::<Vec<_>>();
         let chunked = ChunkedArray::from_iter(chunks).into_array();
 
-        let into_ca = chunked.clone().to_primitive();
+        let into_ca = chunked.to_primitive();
         let mut primitive_builder =
             PrimitiveBuilder::<i32>::with_capacity(chunked.dtype().nullability(), 10 * 100);
-        chunked
-            .clone()
-            .append_to_builder(&mut primitive_builder, &mut SESSION.create_execution_ctx())?;
+        chunked.append_to_builder(&mut primitive_builder, &mut SESSION.create_execution_ctx())?;
         let ca_into = primitive_builder.finish();
 
         assert_arrays_eq!(into_ca, ca_into);
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
index 5846242b979..5ed8d6b89fa 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
+++ b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
@@ -3,89 +3,37 @@
 
 use fastlanes::BitPacking;
 use itertools::Itertools;
+use num_traits::AsPrimitive;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::PrimitiveBuilder;
 use vortex_array::builders::UninitRange;
-use vortex_array::dtype::IntegerPType;
 use vortex_array::dtype::NativePType;
-use vortex_array::dtype::Nullability;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::patches::Patches;
 use vortex_array::scalar::Scalar;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_panic;
-use vortex_mask::Mask;
 
-use crate::BitPackedArray;
-use crate::unpack_iter::BitPacked;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
+use crate::unpack_iter::BitPacked as BitPackedUnpack;
 
 /// Unpacks a bit-packed array into a primitive array.
-pub fn unpack_to_primitive(array: &BitPackedArray) -> PrimitiveArray {
-    match_each_integer_ptype!(array.ptype(), |P| { unpack_to_primitive_typed::<P>(array) })
-}
-
-/// Unpacks a bit-packed array into a typed [`PrimitiveArray`].
-pub fn unpack_to_primitive_typed<P: BitPacked>(array: &BitPackedArray) -> PrimitiveArray {
-    if array.is_empty() {
-        let nullability = array.dtype().nullability();
-        return PrimitiveArray::empty::<P>(nullability);
-    }
-
-    let len = array.len();
-    let mut elements = BufferMut::<P>::with_capacity(len);
-    let uninit_slice = &mut elements.spare_capacity_mut()[..len];
-
-    // Decode into an uninitialized slice.
-    let mut bit_packed_iter = array.unpacked_chunks();
-    bit_packed_iter.decode_into(uninit_slice);
-    // SAFETY: `decode_into` initialized exactly `len` elements into the spare (existing) capacity.
-    unsafe { elements.set_len(len) };
-
-    let mut validity = array
-        .validity_mask()
-        .vortex_expect("validity_mask")
-        .into_mut();
-    debug_assert_eq!(validity.len(), len);
-
-    // TODO(connor): Implement a fused version of patching instead.
-    if let Some(patches) = array.patches() {
-        // SAFETY:
-        // - `Patches` invariant guarantees indices are sorted and within array bounds.
-        // - `elements` and `validity` have equal length (both are `len` from the array).
-        // - All patch indices are valid after offset adjustment (guaranteed by `Patches`).
-        unsafe { patches.apply_to_buffer(&mut elements, &mut validity) };
-    }
-
-    // Convert MaskMut -> Mask -> Validity
-    let validity_mask = validity.freeze();
-    let nullability = array.dtype().nullability();
-    let validity = if nullability == Nullability::NonNullable {
-        Validity::NonNullable
-    } else {
-        Validity::from_mask(validity_mask, nullability)
-    };
-
-    // SAFETY: `elements` buffer has the correct length matching validity.
-    unsafe { PrimitiveArray::new_unchecked(elements.freeze(), validity) }
-}
-
 pub fn unpack_array(
-    array: &BitPackedArray,
+    array: ArrayView<'_, BitPacked>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<PrimitiveArray> {
-    match_each_integer_ptype!(array.ptype(), |P| {
+    match_each_integer_ptype!(array.dtype().as_ptype(), |P| {
         unpack_primitive_array::<P>(array, ctx)
     })
 }
 
-pub fn unpack_primitive_array<T: BitPacked>(
-    array: &BitPackedArray,
+pub fn unpack_primitive_array<T: BitPackedUnpack>(
+    array: ArrayView<'_, BitPacked>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<PrimitiveArray> {
     let mut builder = PrimitiveBuilder::with_capacity(array.dtype().nullability(), array.len());
@@ -94,8 +42,8 @@ pub fn unpack_primitive_array<T: BitPacked>(
     Ok(builder.finish_into_primitive())
 }
 
-pub(crate) fn unpack_into_primitive_builder<T: BitPacked>(
-    array: &BitPackedArray,
+pub(crate) fn unpack_into_primitive_builder<T: BitPackedUnpack>(
+    array: ArrayView<'_, BitPacked>,
     // TODO(ngates): do we want to use fastlanes alignment for this buffer?
     builder: &mut PrimitiveBuilder<T>,
     ctx: &mut ExecutionCtx,
@@ -110,16 +58,16 @@ pub(crate) fn unpack_into_primitive_builder<T: BitPacked>(
     // SAFETY: We later initialize the the uninitialized range of values with `copy_from_slice`.
     unsafe {
         // Append a dense null Mask.
-        uninit_range.append_mask(array.validity_mask()?);
+        uninit_range.append_mask(array.validity_mask());
     }
 
     // SAFETY: `decode_into` will initialize all values in this range.
     let uninit_slice = unsafe { uninit_range.slice_uninit_mut(0, array.len()) };
 
-    let mut bit_packed_iter = array.unpacked_chunks();
+    let mut bit_packed_iter = array.unpacked_chunks()?;
     bit_packed_iter.decode_into(uninit_slice);
 
-    if let Some(patches) = array.patches() {
+    if let Some(ref patches) = array.patches() {
         apply_patches_to_uninit_range(&mut uninit_range, patches, ctx)?;
     };
 
@@ -149,46 +97,23 @@ pub fn apply_patches_to_uninit_range_fn<T: NativePType, F: Fn(T) -> T>(
 
     let indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
     let values = patches.values().clone().execute::<PrimitiveArray>(ctx)?;
-    let validity = values.validity_mask()?;
+    assert!(values.all_valid()?, "Patch values must be all valid");
     let values = values.as_slice::<T>();
 
     match_each_unsigned_integer_ptype!(indices.ptype(), |P| {
-        insert_values_and_validity_at_indices_to_uninit_range(
-            dst,
-            indices.as_slice::<P>(),
-            values,
-            validity,
-            patches.offset(),
-            f,
-        )
+        for (index, &value) in indices.as_slice::<P>().iter().zip_eq(values) {
+            dst.set_value(
+                <P as AsPrimitive<usize>>::as_(*index) - patches.offset(),
+                f(value),
+            );
+        }
     });
     Ok(())
 }
 
-fn insert_values_and_validity_at_indices_to_uninit_range<
-    T: NativePType,
-    IndexT: IntegerPType,
-    F: Fn(T) -> T,
->(
-    dst: &mut UninitRange<T>,
-    indices: &[IndexT],
-    values: &[T],
-    values_validity: Mask,
-    indices_offset: usize,
-    f: F,
-) {
-    let Mask::AllTrue(_) = values_validity else {
-        vortex_panic!("BitPackedArray somehow had nullable patch values");
-    };
-
-    for (index, &value) in indices.iter().zip_eq(values) {
-        dst.set_value(index.as_() - indices_offset, f(value));
-    }
-}
-
-pub fn unpack_single(array: &BitPackedArray, index: usize) -> Scalar {
+pub fn unpack_single(array: ArrayView<'_, BitPacked>, index: usize) -> Scalar {
     let bit_width = array.bit_width() as usize;
-    let ptype = array.ptype();
+    let ptype = array.dtype().as_ptype();
     // let packed = array.packed().into_primitive()?;
     let index_in_encoded = index + array.offset() as usize;
     let scalar: Scalar = match_each_unsigned_integer_ptype!(ptype.to_unsigned(), |P| {
@@ -247,14 +172,24 @@ mod tests {
     use vortex_session::VortexSession;
 
     use super::*;
+    use crate::BitPackedArray;
+    use crate::BitPackedData;
     use crate::bitpack_compress::bitpack_encode;
 
+    fn encode(array: &PrimitiveArray, bit_width: u8) -> BitPackedArray {
+        bitpack_encode(array, bit_width, None).unwrap()
+    }
+
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
+    fn unpack(bitpacked: &BitPackedArray) -> VortexResult<PrimitiveArray> {
+        unpack_array(bitpacked.as_view(), &mut SESSION.create_execution_ctx())
+    }
+
     fn compression_roundtrip(n: usize) {
         let values = PrimitiveArray::from_iter((0..n).map(|i| (i % 2047) as u16));
-        let compressed = BitPackedArray::encode(values.as_ref(), 11).unwrap();
+        let compressed = BitPackedData::encode(&values.clone().into_array(), 11).unwrap();
         assert_arrays_eq!(compressed, values);
 
         values
@@ -262,7 +197,9 @@ mod tests {
             .iter()
             .enumerate()
             .for_each(|(i, v)| {
-                let scalar: u16 = (&unpack_single(&compressed, i)).try_into().unwrap();
+                let scalar: u16 = (&unpack_single(compressed.as_view(), i))
+                    .try_into()
+                    .unwrap();
                 assert_eq!(scalar, *v);
             });
     }
@@ -283,8 +220,8 @@ mod tests {
     #[test]
     fn test_all_zeros() -> VortexResult<()> {
         let zeros = buffer![0u16, 0, 0, 0].into_array().to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 0, None)?;
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let bitpacked = encode(&zeros, 0);
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(actual, PrimitiveArray::from_iter([0u16, 0, 0, 0]));
         Ok(())
     }
@@ -292,8 +229,8 @@ mod tests {
     #[test]
     fn test_simple_patches() -> VortexResult<()> {
         let zeros = buffer![0u16, 1, 0, 1].into_array().to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 0, None).unwrap();
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let bitpacked = encode(&zeros, 0);
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(actual, PrimitiveArray::from_iter([0u16, 1, 0, 1]));
         Ok(())
     }
@@ -301,8 +238,8 @@ mod tests {
     #[test]
     fn test_one_full_chunk() -> VortexResult<()> {
         let zeros = BufferMut::from_iter(0u16..1024).into_array().to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let bitpacked = encode(&zeros, 10);
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(actual, PrimitiveArray::from_iter(0u16..1024));
         Ok(())
     }
@@ -312,9 +249,9 @@ mod tests {
         let zeros = BufferMut::from_iter((5u16..1029).chain(5u16..1029).chain(5u16..1029))
             .into_array()
             .to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
+        let bitpacked = encode(&zeros, 10);
         assert!(bitpacked.patches().is_some());
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(
             actual,
             PrimitiveArray::from_iter((5u16..1029).chain(5u16..1029).chain(5u16..1029))
@@ -325,9 +262,9 @@ mod tests {
     #[test]
     fn test_one_full_chunk_and_one_short_chunk_no_patch() -> VortexResult<()> {
         let zeros = BufferMut::from_iter(0u16..1025).into_array().to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 11, None).unwrap();
+        let bitpacked = encode(&zeros, 11);
         assert!(bitpacked.patches().is_none());
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(actual, PrimitiveArray::from_iter(0u16..1025));
         Ok(())
     }
@@ -337,10 +274,10 @@ mod tests {
         let zeros = BufferMut::from_iter(512u16..1537)
             .into_array()
             .to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
+        let bitpacked = encode(&zeros, 10);
         assert_eq!(bitpacked.len(), 1025);
         assert!(bitpacked.patches().is_some());
-        let actual = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
+        let actual = unpack(&bitpacked)?;
         assert_arrays_eq!(actual, PrimitiveArray::from_iter(512u16..1537));
         Ok(())
     }
@@ -350,14 +287,13 @@ mod tests {
         let zeros = BufferMut::from_iter(512u16..1537)
             .into_array()
             .to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
+        let bitpacked = encode(&zeros, 10);
         assert_eq!(bitpacked.len(), 1025);
         assert!(bitpacked.patches().is_some());
         let slice_ref = bitpacked.into_array().slice(1023..1025).unwrap();
         let actual = {
             let mut ctx = SESSION.create_execution_ctx();
             slice_ref
-                .clone()
                 .execute::<Canonical>(&mut ctx)
                 .unwrap()
                 .into_primitive()
@@ -371,14 +307,13 @@ mod tests {
         let zeros = BufferMut::from_iter(512u16..2741)
             .into_array()
             .to_primitive();
-        let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
+        let bitpacked = encode(&zeros, 10);
         assert_eq!(bitpacked.len(), 2229);
         assert!(bitpacked.patches().is_some());
         let slice_ref = bitpacked.into_array().slice(1023..2049).unwrap();
         let actual = {
             let mut ctx = SESSION.create_execution_ctx();
             slice_ref
-                .clone()
                 .execute::<Canonical>(&mut ctx)
                 .unwrap()
                 .into_primitive()
@@ -393,11 +328,11 @@ mod tests {
     #[test]
     fn test_unpack_into_empty_array() -> VortexResult<()> {
         let empty: PrimitiveArray = PrimitiveArray::from_iter(Vec::<u32>::new());
-        let bitpacked = bitpack_encode(&empty, 0, None).unwrap();
+        let bitpacked = encode(&empty, 0);
 
         let mut builder = PrimitiveBuilder::<u32>::new(Nullability::NonNullable);
         unpack_into_primitive_builder(
-            &bitpacked,
+            bitpacked.as_view(),
             &mut builder,
             &mut SESSION.create_execution_ctx(),
         )?;
@@ -420,12 +355,12 @@ mod tests {
         let array = PrimitiveArray::new(values, validity);
 
         // Bitpack the array.
-        let bitpacked = bitpack_encode(&array, 3, None).unwrap();
+        let bitpacked = encode(&array, 3);
 
         // Unpack into a new builder.
         let mut builder = PrimitiveBuilder::<u32>::with_capacity(Nullability::Nullable, 5);
         unpack_into_primitive_builder(
-            &bitpacked,
+            bitpacked.as_view(),
             &mut builder,
             &mut SESSION.create_execution_ctx(),
         )?;
@@ -452,7 +387,7 @@ mod tests {
         let array = PrimitiveArray::from_iter(values.clone());
 
         // Bitpack with a bit width that will require patches.
-        let bitpacked = bitpack_encode(&array, 4, None).unwrap();
+        let bitpacked = encode(&array, 4);
         assert!(
             bitpacked.patches().is_some(),
             "Should have patches for values > 15"
@@ -461,7 +396,7 @@ mod tests {
         // Unpack into a new builder.
         let mut builder = PrimitiveBuilder::<u32>::with_capacity(Nullability::NonNullable, 100);
         unpack_into_primitive_builder(
-            &bitpacked,
+            bitpacked.as_view(),
             &mut builder,
             &mut SESSION.create_execution_ctx(),
         )?;
@@ -473,68 +408,21 @@ mod tests {
         Ok(())
     }
 
-    /// Test basic unpacking to primitive array for multiple types and sizes.
-    #[test]
-    fn test_unpack_to_primitive_basic() -> VortexResult<()> {
-        // Test with u8 values.
-        let u8_values = PrimitiveArray::from_iter([5u8, 10, 15, 20, 25]);
-        let u8_bitpacked = bitpack_encode(&u8_values, 5, None).unwrap();
-        let u8_result = unpack_to_primitive(&u8_bitpacked);
-        // Compare with existing unpack method.
-        let expected = unpack_array(&u8_bitpacked, &mut SESSION.create_execution_ctx())?;
-        assert_eq!(u8_result.len(), expected.len());
-        assert_arrays_eq!(u8_result, expected);
-
-        // Test with u32 values - empty array.
-        let u32_empty: PrimitiveArray = PrimitiveArray::from_iter(Vec::<u32>::new());
-        let u32_empty_bp = bitpack_encode(&u32_empty, 0, None).unwrap();
-        let u32_empty_result = unpack_to_primitive(&u32_empty_bp);
-        assert_eq!(u32_empty_result.len(), 0);
-
-        // Test with u16 values - exactly one chunk (1024 elements).
-        let u16_values = PrimitiveArray::from_iter(0u16..1024);
-        let u16_bitpacked = bitpack_encode(&u16_values, 10, None).unwrap();
-        let u16_result = unpack_to_primitive(&u16_bitpacked);
-        assert_eq!(u16_result.len(), 1024);
-
-        // Test with i32 values - partial chunk (1025 elements).
-        let i32_values = PrimitiveArray::from_iter((0i32..1025).map(|x| x % 512));
-        let i32_bitpacked = bitpack_encode(&i32_values, 9, None).unwrap();
-        let i32_result = unpack_to_primitive(&i32_bitpacked);
-        assert_eq!(i32_result.len(), 1025);
-
-        // Verify consistency: unpack_to_primitive and unpack_array should produce same values.
-        let i32_array = unpack_array(&i32_bitpacked, &mut SESSION.create_execution_ctx())?;
-        assert_eq!(i32_result.len(), i32_array.len());
-        assert_arrays_eq!(i32_result, i32_array);
-        Ok(())
-    }
-
     /// Test unpacking with patches at various positions.
     #[test]
     fn test_unpack_to_primitive_with_patches() -> VortexResult<()> {
         // Create an array where patches are needed at start, middle, and end.
-        let values: Vec<u32> = vec![
-            2000, // Patch at start
+        let values = buffer![
+            2000u32, // Patch at start
             5, 10, 15, 20, 25, 30, 3000, // Patch in middle
             35, 40, 45, 50, 55, 4000, // Patch at end
         ];
-        let array = PrimitiveArray::from_iter(values.clone());
+        let array = PrimitiveArray::new(values, Validity::NonNullable);
 
         // Bitpack with a small bit width to force patches.
-        let bitpacked = bitpack_encode(&array, 6, None).unwrap();
+        let bitpacked = encode(&array, 6);
         assert!(bitpacked.patches().is_some(), "Should have patches");
 
-        // Unpack to primitive array.
-        let result = unpack_to_primitive(&bitpacked);
-
-        // Verify length and that patches were applied.
-        assert_eq!(result.len(), values.len());
-        // The result should match what unpack_array also produces.
-        let expected = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
-        assert_eq!(result.len(), expected.len());
-        assert_arrays_eq!(result, expected);
-
         // Test with a larger array with multiple patches across chunks.
         let large_values: Vec<u16> = (0..3072)
             .map(|i| {
@@ -546,10 +434,10 @@ mod tests {
             })
             .collect();
         let large_array = PrimitiveArray::from_iter(large_values);
-        let large_bitpacked = bitpack_encode(&large_array, 8, None).unwrap();
+        let large_bitpacked = encode(&large_array, 8);
         assert!(large_bitpacked.patches().is_some());
 
-        let large_result = unpack_to_primitive(&large_bitpacked);
+        let large_result = unpack(&large_bitpacked)?;
         assert_eq!(large_result.len(), 3072);
         Ok(())
     }
@@ -562,8 +450,8 @@ mod tests {
         let validity = Validity::from_iter([true, false, true, false, true, false, true]);
         let array = PrimitiveArray::new(values, validity);
 
-        let bitpacked = bitpack_encode(&array, 9, None).unwrap();
-        let result = unpack_to_primitive(&bitpacked);
+        let bitpacked = encode(&array, 9);
+        let result = unpack(&bitpacked).vortex_expect("unpack");
 
         // Verify length.
         assert_eq!(result.len(), 7);
@@ -577,10 +465,10 @@ mod tests {
         let patch_validity = Validity::from_iter([true, false, true, false, true, true, false]);
         let patch_array = PrimitiveArray::new(patch_values, patch_validity);
 
-        let patch_bitpacked = bitpack_encode(&patch_array, 5, None).unwrap();
+        let patch_bitpacked = encode(&patch_array, 5);
         assert!(patch_bitpacked.patches().is_some());
 
-        let patch_result = unpack_to_primitive(&patch_bitpacked);
+        let patch_result = unpack(&patch_bitpacked).vortex_expect("unpack");
         assert_eq!(patch_result.len(), 7);
 
         // Test all nulls edge case.
@@ -588,8 +476,8 @@ mod tests {
             Buffer::from_iter([0u32, 0, 0, 0]),
             Validity::from_iter([false, false, false, false]),
         );
-        let all_nulls_bp = bitpack_encode(&all_nulls, 0, None).unwrap();
-        let all_nulls_result = unpack_to_primitive(&all_nulls_bp);
+        let all_nulls_bp = encode(&all_nulls, 0);
+        let all_nulls_result = unpack(&all_nulls_bp).vortex_expect("unpack");
         assert_eq!(all_nulls_result.len(), 4);
     }
 
@@ -598,15 +486,10 @@ mod tests {
     fn test_execute_method_consistency() -> VortexResult<()> {
         // Test that execute(), unpack_to_primitive(), and unpack_array() all produce consistent results.
         let test_consistency = |array: &PrimitiveArray, bit_width: u8| -> VortexResult<()> {
-            let bitpacked = bitpack_encode(array, bit_width, None).unwrap();
+            let bitpacked = encode(array, bit_width);
 
-            // Method 1: Using the new unpack_to_primitive.
-            let primitive_result = unpack_to_primitive(&bitpacked);
+            let unpacked_array = unpack(&bitpacked)?;
 
-            // Method 2: Using the old unpack_array.
-            let unpacked_array = unpack_array(&bitpacked, &mut SESSION.create_execution_ctx())?;
-
-            // Method 3: Using the execute() method (this is what would be used in production).
             let executed = {
                 let mut ctx = SESSION.create_execution_ctx();
                 bitpacked
@@ -615,12 +498,6 @@ mod tests {
                     .unwrap()
             };
 
-            // All three should produce the same length.
-            assert_eq!(
-                primitive_result.len(),
-                array.len(),
-                "primitive length mismatch"
-            );
             assert_eq!(
                 unpacked_array.len(),
                 array.len(),
@@ -670,7 +547,7 @@ mod tests {
 
         // Test with sliced array (offset > 0).
         let values = PrimitiveArray::from_iter(0u32..2048);
-        let bitpacked = bitpack_encode(&values, 11, None).unwrap();
+        let bitpacked = encode(&values, 11);
         let slice_ref = bitpacked.into_array().slice(500..1500).unwrap();
         let sliced = {
             let mut ctx = SESSION.create_execution_ctx();
@@ -686,7 +563,7 @@ mod tests {
         let unpacked_array = sliced;
         let executed = {
             let mut ctx = SESSION.create_execution_ctx();
-            slice_ref.clone().execute::<Canonical>(&mut ctx).unwrap()
+            slice_ref.execute::<Canonical>(&mut ctx).unwrap()
         };
 
         assert_eq!(
@@ -714,24 +591,24 @@ mod tests {
     fn test_unpack_edge_cases() -> VortexResult<()> {
         // Empty array.
         let empty: PrimitiveArray = PrimitiveArray::from_iter(Vec::<u64>::new());
-        let empty_bp = bitpack_encode(&empty, 0, None).unwrap();
-        let empty_result = unpack_to_primitive(&empty_bp);
+        let empty_bp = encode(&empty, 0);
+        let empty_result = unpack(&empty_bp)?;
         assert_eq!(empty_result.len(), 0);
 
         // All zeros (bit_width = 0).
         let zeros = PrimitiveArray::from_iter([0u32; 100]);
-        let zeros_bp = bitpack_encode(&zeros, 0, None).unwrap();
-        let zeros_result = unpack_to_primitive(&zeros_bp);
+        let zeros_bp = encode(&zeros, 0);
+        let zeros_result = unpack(&zeros_bp)?;
         assert_eq!(zeros_result.len(), 100);
         // Verify consistency with unpack_array.
-        let zeros_array = unpack_array(&zeros_bp, &mut SESSION.create_execution_ctx())?;
+        let zeros_array = unpack(&zeros_bp)?;
         assert_eq!(zeros_result.len(), zeros_array.len());
         assert_arrays_eq!(zeros_result, zeros_array);
 
         // Maximum bit width for u16 (15 bits, since bitpacking requires bit_width < type bit width).
         let max_values = PrimitiveArray::from_iter([32767u16; 50]); // 2^15 - 1
-        let max_bp = bitpack_encode(&max_values, 15, None).unwrap();
-        let max_result = unpack_to_primitive(&max_bp);
+        let max_bp = encode(&max_values, 15);
+        let max_result = unpack(&max_bp)?;
         assert_eq!(max_result.len(), 50);
 
         // Exactly 3072 elements with patches across chunks.
@@ -745,20 +622,20 @@ mod tests {
             })
             .collect();
         let boundary_array = PrimitiveArray::from_iter(boundary_values);
-        let boundary_bp = bitpack_encode(&boundary_array, 7, None).unwrap();
+        let boundary_bp = encode(&boundary_array, 7);
         assert!(boundary_bp.patches().is_some());
 
-        let boundary_result = unpack_to_primitive(&boundary_bp);
+        let boundary_result = unpack(&boundary_bp)?;
         assert_eq!(boundary_result.len(), 3072);
         // Verify consistency.
-        let boundary_unpacked = unpack_array(&boundary_bp, &mut SESSION.create_execution_ctx())?;
+        let boundary_unpacked = unpack(&boundary_bp)?;
         assert_eq!(boundary_result.len(), boundary_unpacked.len());
         assert_arrays_eq!(boundary_result, boundary_unpacked);
 
         // Single element.
         let single = PrimitiveArray::from_iter([42u8]);
-        let single_bp = bitpack_encode(&single, 6, None).unwrap();
-        let single_result = unpack_to_primitive(&single_bp);
+        let single_bp = encode(&single, 6);
+        let single_result = unpack(&single_bp)?;
         assert_eq!(single_result.len(), 1);
         Ok(())
     }
diff --git a/encodings/fastlanes/src/bitpacking/array/mod.rs b/encodings/fastlanes/src/bitpacking/array/mod.rs
index 8becb6a915a..ca86e78e148 100644
--- a/encodings/fastlanes/src/bitpacking/array/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/array/mod.rs
@@ -1,29 +1,49 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use fastlanes::BitPacking;
-use vortex_array::Array;
-use vortex_array::arrays::PrimitiveVTable;
+use vortex_array::ArrayRef;
+use vortex_array::TypedArrayRef;
+use vortex_array::array_slots;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::patches::Patches;
-use vortex_array::stats::ArrayStats;
 use vortex_array::validity::Validity;
+use vortex_array::vtable::child_to_validity;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
 
 pub mod bitpack_compress;
 pub mod bitpack_decompress;
 pub mod unpack_iter;
 
+use crate::BitPackedArray;
 use crate::bitpack_compress::bitpack_encode;
-use crate::unpack_iter::BitPacked;
+use crate::unpack_iter::BitPacked as BitPackedIter;
 use crate::unpack_iter::BitUnpackedChunks;
 
-pub struct BitPackedArrayParts {
+#[array_slots(crate::BitPacked)]
+pub struct BitPackedSlots {
+    /// The indices of exception values that don't fit in the bit-packed representation.
+    pub patch_indices: Option<ArrayRef>,
+    /// The exception values that don't fit in the bit-packed representation.
+    pub patch_values: Option<ArrayRef>,
+    /// Chunk offsets for the patch indices/values.
+    pub patch_chunk_offsets: Option<ArrayRef>,
+    /// The validity bitmap indicating which elements are non-null.
+    pub validity_child: Option<ArrayRef>,
+}
+
+pub struct BitPackedDataParts {
     pub offset: u16,
     pub bit_width: u8,
     pub len: usize,
@@ -33,20 +53,25 @@ pub struct BitPackedArrayParts {
 }
 
 #[derive(Clone, Debug)]
-pub struct BitPackedArray {
+pub struct BitPackedData {
     /// The offset within the first block (created with a slice).
     /// 0 <= offset < 1024
     pub(super) offset: u16,
-    pub(super) len: usize,
-    pub(super) dtype: DType,
     pub(super) bit_width: u8,
     pub(super) packed: BufferHandle,
-    pub(super) patches: Option<Patches>,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
+    /// The offset metadata from patches, needed to reconstruct Patches from slots.
+    pub(super) patch_offset: Option<usize>,
+    /// The offset_within_chunk metadata from patches.
+    pub(super) patch_offset_within_chunk: Option<usize>,
 }
 
-impl BitPackedArray {
+impl Display for BitPackedData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "bit_width: {}, offset: {}", self.bit_width, self.offset)
+    }
+}
+
+impl BitPackedData {
     /// Create a new bitpacked array using a buffer of packed data.
     ///
     /// The packed data should be interpreted as a sequence of values with size `bit_width`.
@@ -67,27 +92,6 @@ impl BitPackedArray {
     ///
     /// See also the [`encode`][Self::encode] method on this type for a safe path to create a new
     /// bit-packed array.
-    pub(crate) unsafe fn new_unchecked(
-        packed: BufferHandle,
-        dtype: DType,
-        validity: Validity,
-        patches: Option<Patches>,
-        bit_width: u8,
-        len: usize,
-        offset: u16,
-    ) -> Self {
-        Self {
-            offset,
-            len,
-            dtype,
-            bit_width,
-            packed,
-            patches,
-            validity,
-            stats_set: Default::default(),
-        }
-    }
-
     /// A safe constructor for a `BitPackedArray` from its components:
     ///
     /// * `packed` is ByteBuffer holding the compressed data that was packed with FastLanes
@@ -111,34 +115,31 @@ impl BitPackedArray {
     /// Any violation of these preconditions will result in an error.
     pub fn try_new(
         packed: BufferHandle,
-        ptype: PType,
-        validity: Validity,
         patches: Option<Patches>,
         bit_width: u8,
-        length: usize,
         offset: u16,
     ) -> VortexResult<Self> {
-        Self::validate(
-            &packed,
-            ptype,
-            &validity,
-            patches.as_ref(),
-            bit_width,
-            length,
-            offset,
-        )?;
+        vortex_ensure!(bit_width <= 64, "Unsupported bit width {bit_width}");
+        vortex_ensure!(
+            offset < 1024,
+            "Offset must be less than the full block i.e., 1024, got {offset}"
+        );
 
-        let dtype = DType::Primitive(ptype, validity.nullability());
+        let (patch_offset, patch_offset_within_chunk) = match &patches {
+            Some(p) => (Some(p.offset()), p.offset_within_chunk()),
+            None => (None, None),
+        };
 
-        // SAFETY: all components validated above
-        unsafe {
-            Ok(Self::new_unchecked(
-                packed, dtype, validity, patches, bit_width, length, offset,
-            ))
-        }
+        Ok(Self {
+            offset,
+            bit_width,
+            packed,
+            patch_offset,
+            patch_offset_within_chunk,
+        })
     }
 
-    fn validate(
+    pub(crate) fn validate(
         packed: &BufferHandle,
         ptype: PType,
         validity: &Validity,
@@ -157,12 +158,6 @@ impl BitPackedArray {
             );
         }
 
-        // Validate offset for sliced arrays
-        vortex_ensure!(
-            offset < 1024,
-            "Offset must be less than the full block i.e., 1024, got {offset}"
-        );
-
         // Validate patches
         if let Some(patches) = patches {
             Self::validate_patches(patches, ptype, length)?;
@@ -199,8 +194,8 @@ impl BitPackedArray {
         Ok(())
     }
 
-    pub fn ptype(&self) -> PType {
-        self.dtype.as_ptype()
+    pub fn ptype(&self, dtype: &DType) -> PType {
+        dtype.as_ptype()
     }
 
     /// Underlying bit packed values as byte array
@@ -224,13 +219,17 @@ impl BitPackedArray {
     }
 
     /// Accessor for bit unpacked chunks
-    pub fn unpacked_chunks<T: BitPacked>(&self) -> BitUnpackedChunks<T> {
+    pub fn unpacked_chunks<T: BitPackedIter>(
+        &self,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<BitUnpackedChunks<T>> {
         assert_eq!(
             T::PTYPE,
-            self.ptype(),
+            self.ptype(dtype),
             "Requested type doesn't match the array ptype"
         );
-        BitUnpackedChunks::new(self)
+        BitUnpackedChunks::try_new(self, len)
     }
 
     /// Bit-width of the packed values
@@ -239,19 +238,6 @@ impl BitPackedArray {
         self.bit_width
     }
 
-    /// Access the patches array.
-    ///
-    /// If present, patches MUST be a `SparseArray` with equal-length to this array, and whose
-    /// indices indicate the locations of patches. The indices must have non-zero length.
-    #[inline]
-    pub fn patches(&self) -> Option<&Patches> {
-        self.patches.as_ref()
-    }
-
-    pub fn replace_patches(&mut self, patches: Option<Patches>) {
-        self.patches = patches;
-    }
-
     #[inline]
     pub fn offset(&self) -> u16 {
         self.offset
@@ -268,13 +254,12 @@ impl BitPackedArray {
     ///
     /// If the requested bit-width for packing is larger than the array's native width, an
     /// error will be returned.
-    // FIXME(ngates): take a PrimitiveArray
-    pub fn encode(array: &dyn Array, bit_width: u8) -> VortexResult<Self> {
-        if let Some(parray) = array.as_opt::<PrimitiveVTable>() {
-            bitpack_encode(parray, bit_width, None)
-        } else {
-            vortex_bail!(InvalidArgument: "Bitpacking can only encode primitive arrays");
-        }
+    pub fn encode(array: &ArrayRef, bit_width: u8) -> VortexResult<BitPackedArray> {
+        let parray: PrimitiveArray = array
+            .clone()
+            .try_downcast::<Primitive>()
+            .map_err(|a| vortex_err!(InvalidArgument: "Bitpacking can only encode primitive arrays, got {}", a.encoding_id()))?;
+        bitpack_encode(&parray, bit_width, None)
     }
 
     /// Calculate the maximum value that **can** be contained by this array, given its bit-width.
@@ -284,19 +269,72 @@ impl BitPackedArray {
     pub fn max_packed_value(&self) -> usize {
         (1 << self.bit_width()) - 1
     }
+}
+
+pub trait BitPackedArrayExt: BitPackedArraySlotsExt {
+    #[inline]
+    fn packed(&self) -> &BufferHandle {
+        BitPackedData::packed(self)
+    }
 
-    pub fn into_parts(self) -> BitPackedArrayParts {
-        BitPackedArrayParts {
-            offset: self.offset,
-            bit_width: self.bit_width,
-            len: self.len,
-            packed: self.packed,
-            patches: self.patches,
-            validity: self.validity,
+    #[inline]
+    fn bit_width(&self) -> u8 {
+        BitPackedData::bit_width(self)
+    }
+
+    #[inline]
+    fn offset(&self) -> u16 {
+        BitPackedData::offset(self)
+    }
+
+    #[inline]
+    fn patches(&self) -> Option<Patches> {
+        match (self.patch_indices(), self.patch_values()) {
+            (Some(indices), Some(values)) => {
+                let patch_offset = self
+                    .patch_offset
+                    .vortex_expect("has patch slots but no patch_offset");
+                Some(unsafe {
+                    Patches::new_unchecked(
+                        self.as_ref().len(),
+                        patch_offset,
+                        indices.clone(),
+                        values.clone(),
+                        self.patch_chunk_offsets().cloned(),
+                        self.patch_offset_within_chunk,
+                    )
+                })
+            }
+            _ => None,
         }
     }
+
+    #[inline]
+    fn validity(&self) -> Validity {
+        child_to_validity(
+            &self.validity_child().cloned(),
+            self.as_ref().dtype().nullability(),
+        )
+    }
+
+    #[inline]
+    fn validity_mask(&self) -> vortex_mask::Mask {
+        self.validity().to_mask(self.as_ref().len())
+    }
+
+    #[inline]
+    fn packed_slice<T: NativePType + BitPacking>(&self) -> &[T] {
+        BitPackedData::packed_slice::<T>(self)
+    }
+
+    #[inline]
+    fn unpacked_chunks<T: BitPackedIter>(&self) -> VortexResult<BitUnpackedChunks<T>> {
+        BitPackedData::unpacked_chunks::<T>(self, self.as_ref().dtype(), self.as_ref().len())
+    }
 }
 
+impl<T: TypedArrayRef<crate::BitPacked>> BitPackedArrayExt for T {}
+
 #[cfg(test)]
 mod test {
     use vortex_array::IntoArray;
@@ -305,7 +343,8 @@ mod test {
     use vortex_array::assert_arrays_eq;
     use vortex_buffer::Buffer;
 
-    use crate::BitPackedArray;
+    use crate::BitPackedData;
+    use crate::bitpacking::array::BitPackedArrayExt;
 
     #[test]
     fn test_encode() {
@@ -319,18 +358,18 @@ mod test {
             Some(u64::MAX),
         ];
         let uncompressed = PrimitiveArray::from_option_iter(values);
-        let packed = BitPackedArray::encode(uncompressed.as_ref(), 1).unwrap();
+        let packed = BitPackedData::encode(&uncompressed.into_array(), 1).unwrap();
         let expected = PrimitiveArray::from_option_iter(values);
-        assert_arrays_eq!(packed.to_primitive(), expected);
+        assert_arrays_eq!(packed.as_array().to_primitive(), expected);
     }
 
     #[test]
     fn test_encode_too_wide() {
         let values = [Some(1u8), None, Some(1), None, Some(1), None];
         let uncompressed = PrimitiveArray::from_option_iter(values);
-        let _packed = BitPackedArray::encode(uncompressed.as_ref(), 8)
+        let _packed = BitPackedData::encode(&uncompressed.clone().into_array(), 8)
             .expect_err("Cannot pack value into the same width");
-        let _packed = BitPackedArray::encode(uncompressed.as_ref(), 9)
+        let _packed = BitPackedData::encode(&uncompressed.into_array(), 9)
             .expect_err("Cannot pack value into larger width");
     }
 
@@ -339,10 +378,10 @@ mod test {
         let values: Buffer<i32> = (0i32..=512).collect();
         let parray = values.clone().into_array();
 
-        let packed_with_patches = BitPackedArray::encode(&parray, 9).unwrap();
+        let packed_with_patches = BitPackedData::encode(&parray, 9).unwrap();
         assert!(packed_with_patches.patches().is_some());
         assert_arrays_eq!(
-            packed_with_patches.to_primitive(),
+            packed_with_patches.as_array().to_primitive(),
             PrimitiveArray::new(values, vortex_array::validity::Validity::NonNullable)
         );
     }
diff --git a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
index 93c44e59172..80a73f82678 100644
--- a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
+++ b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
@@ -11,8 +11,10 @@ use lending_iterator::prelude::Item;
 use lending_iterator::prelude::LendingIterator;
 use vortex_array::dtype::PhysicalPType;
 use vortex_buffer::ByteBuffer;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
 
-use crate::BitPackedArray;
+use crate::BitPackedData;
 
 const CHUNK_SIZE: usize = 1024;
 
@@ -54,11 +56,12 @@ impl<T: PhysicalPType<Physical: BitPacking>> UnpackStrategy<T> for BitPackingStr
 /// use lending_iterator::prelude::LendingIterator;
 /// use vortex_array::IntoArray;
 /// use vortex_buffer::buffer;
-/// use vortex_fastlanes::BitPackedArray;
+/// use vortex_fastlanes::BitPackedData;
+/// use vortex_fastlanes::BitPackedArrayExt;
 /// use vortex_fastlanes::unpack_iter::BitUnpackedChunks;
 ///
-/// let array = BitPackedArray::encode(&buffer![2, 3, 4, 5].into_array(), 2).unwrap();
-/// let mut unpacked_chunks: BitUnpackedChunks<i32> = array.unpacked_chunks();
+/// let array = BitPackedData::encode(&buffer![2, 3, 4, 5].into_array(), 2).unwrap();
+/// let mut unpacked_chunks: BitUnpackedChunks<i32> = array.unpacked_chunks().unwrap();
 ///
 /// if let Some(header) = unpacked_chunks.initial() {
 ///    // handle partial initial chunk
@@ -89,13 +92,13 @@ pub struct UnpackedChunks<T: PhysicalPType, S: UnpackStrategy<T>> {
 pub type BitUnpackedChunks<T> = UnpackedChunks<T, BitPackingStrategy>;
 
 impl<T: BitPacked> BitUnpackedChunks<T> {
-    pub fn new(array: &BitPackedArray) -> Self {
-        Self::new_with_strategy(
+    pub fn try_new(array: &BitPackedData, len: usize) -> VortexResult<Self> {
+        Self::try_new_with_strategy(
             BitPackingStrategy,
             array.packed().clone().unwrap_host(),
             array.bit_width() as usize,
             array.offset() as usize,
-            array.len(),
+            len,
         )
     }
 
@@ -115,26 +118,29 @@ impl<T: BitPacked> BitUnpackedChunks<T> {
 }
 
 impl<T: PhysicalPType, S: UnpackStrategy<T>> UnpackedChunks<T, S> {
-    pub fn new_with_strategy(
+    pub fn try_new_with_strategy(
         strategy: S,
         packed: ByteBuffer,
         bit_width: usize,
         offset: usize,
         len: usize,
-    ) -> Self {
+    ) -> VortexResult<Self> {
+        vortex_ensure!(
+            offset < CHUNK_SIZE,
+            "Invalid bit-packed offset {offset}, expected < {CHUNK_SIZE}"
+        );
         let elems_per_chunk = 128 * bit_width / size_of::<T>();
         let num_chunks = (offset + len).div_ceil(CHUNK_SIZE);
 
-        assert_eq!(
-            packed.len() / size_of::<T>(),
-            num_chunks * elems_per_chunk,
+        vortex_ensure!(
+            packed.len() / size_of::<T>() == num_chunks * elems_per_chunk,
             "Invalid packed length: got {}, expected {}",
             packed.len() / size_of::<T>(),
             num_chunks * elems_per_chunk
         );
 
         let last_chunk_length = (offset + len) % CHUNK_SIZE;
-        Self {
+        Ok(Self {
             strategy,
             bit_width,
             offset,
@@ -143,7 +149,7 @@ impl<T: PhysicalPType, S: UnpackStrategy<T>> UnpackedChunks<T, S> {
             buffer: [const { MaybeUninit::<T>::uninit() }; CHUNK_SIZE],
             num_chunks,
             last_chunk_length,
-        }
+        })
     }
 
     #[inline(always)]
@@ -256,12 +262,10 @@ impl<T: PhysicalPType, S: UnpackStrategy<T>> UnpackedChunks<T, S> {
         })
     }
 
-    #[inline]
     fn last_chunk_is_sliced(&self) -> bool {
         self.last_chunk_length != 0
     }
 
-    #[inline]
     fn first_chunk_is_sliced(&self) -> bool {
         self.offset != 0
     }
diff --git a/encodings/fastlanes/src/bitpacking/compute/cast.rs b/encodings/fastlanes/src/bitpacking/compute/cast.rs
index aab140ed898..fbcd48ce75b 100644
--- a/encodings/fastlanes/src/bitpacking/compute/cast.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/cast.rs
@@ -2,26 +2,24 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::patches::Patches;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
-use vortex_array::vtable::ValidityHelper;
 use vortex_error::VortexResult;
 
-use crate::bitpacking::BitPackedArray;
-use crate::bitpacking::BitPackedVTable;
-
-impl CastReduce for BitPackedVTable {
-    fn cast(array: &BitPackedArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::bitpacking::BitPacked;
+use crate::bitpacking::array::BitPackedArrayExt;
+impl CastReduce for BitPacked {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if array.dtype().eq_ignore_nullability(dtype) {
             let new_validity = array
-                .validity()
-                .clone()
+                .validity()?
                 .cast_nullability(dtype.nullability(), array.len())?;
             return Ok(Some(
-                BitPackedArray::try_new(
+                BitPacked::try_new(
                     array.packed().clone(),
                     dtype.as_ptype(),
                     new_validity,
@@ -53,6 +51,7 @@ impl CastReduce for BitPackedVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
@@ -64,15 +63,18 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::BitPackedArray;
+    use crate::BitPackedData;
+
+    fn bp(array: &ArrayRef, bit_width: u8) -> BitPackedArray {
+        BitPackedData::encode(array, bit_width).unwrap()
+    }
 
     #[test]
     fn test_cast_bitpacked_u8_to_u32() {
-        let packed =
-            BitPackedArray::encode(buffer![10u8, 20, 30, 40, 50, 60].into_array().as_ref(), 6)
-                .unwrap();
+        let packed = bp(&buffer![10u8, 20, 30, 40, 50, 60].into_array(), 6);
 
         let casted = packed
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -81,7 +83,7 @@ mod tests {
         );
 
         assert_arrays_eq!(
-            casted.as_ref(),
+            casted,
             PrimitiveArray::from_iter([10u32, 20, 30, 40, 50, 60])
         );
     }
@@ -89,10 +91,10 @@ mod tests {
     #[test]
     fn test_cast_bitpacked_nullable() {
         let values = PrimitiveArray::from_option_iter([Some(5u16), None, Some(10), Some(15), None]);
-        let packed = BitPackedArray::encode(values.as_ref(), 4).unwrap();
+        let packed = bp(&values.into_array(), 4);
 
         let casted = packed
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -102,11 +104,11 @@ mod tests {
     }
 
     #[rstest]
-    #[case(BitPackedArray::encode(buffer![0u8, 10, 20, 30, 40, 50, 60, 63].into_array().as_ref(), 6).unwrap())]
-    #[case(BitPackedArray::encode(buffer![0u16, 100, 200, 300, 400, 500].into_array().as_ref(), 9).unwrap())]
-    #[case(BitPackedArray::encode(buffer![0u32, 1000, 2000, 3000, 4000].into_array().as_ref(), 12).unwrap())]
-    #[case(BitPackedArray::encode(PrimitiveArray::from_option_iter([Some(1u32), None, Some(7), Some(15), None]).as_ref(), 4).unwrap())]
+    #[case(bp(&buffer![0u8, 10, 20, 30, 40, 50, 60, 63].into_array(), 6))]
+    #[case(bp(&buffer![0u16, 100, 200, 300, 400, 500].into_array(), 9))]
+    #[case(bp(&buffer![0u32, 1000, 2000, 3000, 4000].into_array(), 12))]
+    #[case(bp(&PrimitiveArray::from_option_iter([Some(1u32), None, Some(7), Some(15), None]).into_array(), 4))]
     fn test_cast_bitpacked_conformance(#[case] array: BitPackedArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/compute/filter.rs b/encodings/fastlanes/src/bitpacking/compute/filter.rs
index 11f61c923ec..aa3ca07d0b0 100644
--- a/encodings/fastlanes/src/bitpacking/compute/filter.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/filter.rs
@@ -6,10 +6,11 @@ use std::sync::Arc;
 
 use fastlanes::BitPacking;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterKernel;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::dtype::UnsignedPType;
@@ -23,8 +24,9 @@ use vortex_mask::MaskValues;
 
 use super::chunked_indices;
 use super::take::UNPACK_CHUNK_THRESHOLD;
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
+use crate::BitPackedData;
 
 /// The threshold over which it is faster to fully unpack the entire [`BitPackedArray`] and then
 /// filter the result than to unpack only specific bitpacked values into the output buffer.
@@ -42,11 +44,11 @@ pub const fn unpack_then_filter_threshold(ptype: PType) -> f64 {
 }
 
 /// Kernel to execute filtering directly on a bit-packed array.
-impl FilterKernel for BitPackedVTable {
+impl FilterKernel for BitPacked {
     fn filter(
-        array: &BitPackedArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let values = match mask {
             Mask::AllTrue(_) | Mask::AllFalse(_) => {
@@ -57,25 +59,37 @@ impl FilterKernel for BitPackedVTable {
 
         // If the density is high enough, then we would rather decompress the whole array and then apply
         // a filter over decompressing values one by one.
-        if values.density() > unpack_then_filter_threshold(array.ptype()) {
+        if values.density() > unpack_then_filter_threshold(array.dtype().as_ptype()) {
             return Ok(None);
         }
 
         // Filter and patch using the correct unsigned type for FastLanes, then cast to signed if needed.
-        let mut primitive = match_each_unsigned_integer_ptype!(array.ptype().to_unsigned(), |U| {
-            let (buffer, validity) = filter_primitive_without_patches::<U>(array, values)?;
-            // reinterpret_cast for signed types.
-            PrimitiveArray::new(buffer, validity).reinterpret_cast(array.ptype())
-        });
+        let primitive =
+            match_each_unsigned_integer_ptype!(array.dtype().as_ptype().to_unsigned(), |U| {
+                let (buffer, validity) = filter_primitive_without_patches::<U>(array, values)?;
+                // reinterpret_cast for signed types.
+                let primitive = PrimitiveArray::new(buffer, validity);
+                if array.dtype().as_ptype().is_signed_int() {
+                    PrimitiveArray::from_buffer_handle(
+                        primitive.buffer_handle().clone(),
+                        array.dtype().as_ptype(),
+                        primitive.validity()?,
+                    )
+                } else {
+                    primitive
+                }
+            });
 
         let patches = array
             .patches()
-            .map(|patches| patches.filter(&Mask::Values(values.clone())))
+            .map(|patches| patches.filter(&Mask::Values(Arc::clone(values)), ctx))
             .transpose()?
             .flatten();
 
         if let Some(patches) = patches {
-            primitive = primitive.patch(&patches)?;
+            let mut prim_array = primitive;
+            prim_array = prim_array.patch(&patches, ctx)?;
+            return Ok(Some(prim_array.into_array()));
         }
 
         Ok(Some(primitive.into_array()))
@@ -94,17 +108,19 @@ impl FilterKernel for BitPackedVTable {
 ///
 /// Returns a tuple of (values buffer, validity mask).
 fn filter_primitive_without_patches<U: UnsignedPType + BitPacking>(
-    array: &BitPackedArray,
+    array: ArrayView<'_, BitPacked>,
     selection: &Arc<MaskValues>,
 ) -> VortexResult<(Buffer<U>, Validity)> {
-    let values = filter_with_indices(array, selection.indices());
-    let validity = array.validity()?.filter(&Mask::Values(selection.clone()))?;
+    let values = filter_with_indices(array.data(), selection.indices());
+    let validity = array
+        .validity()?
+        .filter(&Mask::Values(Arc::clone(selection)))?;
 
     Ok((values.freeze(), validity))
 }
 
 fn filter_with_indices<T: NativePType + BitPacking>(
-    array: &BitPackedArray,
+    array: &BitPackedData,
     indices: &[usize],
 ) -> BufferMut<T> {
     let offset = array.offset() as usize;
@@ -161,7 +177,6 @@ fn filter_with_indices<T: NativePType + BitPacking>(
 
 #[cfg(test)]
 mod test {
-    use vortex_array::Array;
     use vortex_array::IntoArray as _;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
@@ -172,13 +187,14 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
-    use crate::BitPackedArray;
+    use crate::BitPackedData;
+    use crate::bitpacking::array::BitPackedArrayExt;
 
     #[test]
     fn take_indices() {
         // Create a u8 array modulo 63.
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 6).unwrap();
 
         let mask = Mask::from_indices(bitpacked.len(), vec![0, 125, 2047, 2049, 2151, 2790]);
 
@@ -193,7 +209,7 @@ mod test {
     fn take_sliced_indices() {
         // Create a u8 array modulo 63.
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 6).unwrap();
         let sliced = bitpacked.slice(128..2050).unwrap();
 
         let mask = Mask::from_indices(sliced.len(), vec![1919, 1921]);
@@ -205,7 +221,7 @@ mod test {
     #[test]
     fn filter_bitpacked() {
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 6).unwrap();
         let filtered = bitpacked
             .filter(Mask::from_indices(4096, (0..1024).collect()))
             .unwrap();
@@ -219,7 +235,7 @@ mod test {
     fn filter_bitpacked_signed() {
         let values: Buffer<i64> = (0..500).collect();
         let unpacked = PrimitiveArray::new(values.clone(), Validity::NonNullable);
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 9).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 9).unwrap();
         let filtered = bitpacked
             .filter(Mask::from_indices(values.len(), (0..250).collect()))
             .unwrap()
@@ -235,18 +251,18 @@ mod test {
     fn test_filter_bitpacked_conformance() {
         // Test with u8 values
         let unpacked = buffer![1u8, 2, 3, 4, 5].into_array();
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 3).unwrap();
-        test_filter_conformance(bitpacked.as_ref());
+        let bitpacked = BitPackedData::encode(&unpacked, 3).unwrap();
+        test_filter_conformance(&bitpacked.into_array());
 
         // Test with u32 values
         let unpacked = buffer![100u32, 200, 300, 400, 500].into_array();
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 9).unwrap();
-        test_filter_conformance(bitpacked.as_ref());
+        let bitpacked = BitPackedData::encode(&unpacked, 9).unwrap();
+        test_filter_conformance(&bitpacked.into_array());
 
         // Test with nullable values
         let unpacked = PrimitiveArray::from_option_iter([Some(1u16), None, Some(3), Some(4), None]);
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 3).unwrap();
-        test_filter_conformance(bitpacked.as_ref());
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 3).unwrap();
+        test_filter_conformance(&bitpacked.into_array());
     }
 
     /// Regression test for signed integers with patches.
@@ -260,7 +276,7 @@ mod test {
         // Values 0-127 fit in 7 bits, but 1000 and 2000 do not.
         let values: Vec<i32> = vec![0, 10, 1000, 20, 30, 2000, 40, 50, 60, 70];
         let unpacked = PrimitiveArray::from_iter(values.clone());
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 7).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 7).unwrap();
         assert!(
             bitpacked.patches().is_some(),
             "Expected patches for values exceeding bit width"
@@ -292,7 +308,7 @@ mod test {
             })
             .collect();
         let unpacked = PrimitiveArray::from_iter(values.clone());
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 7).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 7).unwrap();
         assert!(
             bitpacked.patches().is_some(),
             "Expected patches for values exceeding bit width"
diff --git a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
index 4af0bebe481..900284e926d 100644
--- a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
@@ -5,45 +5,57 @@ use std::ops::Range;
 
 use itertools::Itertools;
 use lending_iterator::LendingIterator;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::ToCanonical;
-use vortex_array::arrays::IS_CONST_LANE_WIDTH;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_constant::primitive::IS_CONST_LANE_WIDTH;
+use vortex_array::aggregate_fn::fns::is_constant::primitive::compute_is_constant;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::compute_is_constant;
-use vortex_array::compute::IsConstantKernel;
-use vortex_array::compute::IsConstantKernelAdapter;
-use vortex_array::compute::IsConstantOpts;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
-use vortex_array::register_kernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
-use crate::unpack_iter::BitPacked;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
+use crate::unpack_iter::BitPacked as BitPackedUnpack;
 
-impl IsConstantKernel for BitPackedVTable {
-    fn is_constant(
+/// BitPacked-specific is_constant kernel with SIMD support.
+#[derive(Debug)]
+pub(crate) struct BitPackedIsConstantKernel;
+
+impl DynAggregateKernel for BitPackedIsConstantKernel {
+    fn aggregate(
         &self,
-        array: &BitPackedArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        if opts.is_negligible_cost() {
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
             return Ok(None);
         }
-        match_each_integer_ptype!(array.ptype(), |P| {
-            bitpacked_is_constant::<P, { IS_CONST_LANE_WIDTH / size_of::<P>() }>(array)
-        })
-        .map(Some)
+
+        let Some(array) = batch.as_opt::<BitPacked>() else {
+            return Ok(None);
+        };
+
+        let result = match_each_integer_ptype!(array.dtype().as_ptype(), |P| {
+            bitpacked_is_constant::<P, { IS_CONST_LANE_WIDTH / size_of::<P>() }>(array)?
+        });
+
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
 
-register_kernel!(IsConstantKernelAdapter(BitPackedVTable).lift());
-
-fn bitpacked_is_constant<T: BitPacked, const WIDTH: usize>(
-    array: &BitPackedArray,
+fn bitpacked_is_constant<T: BitPackedUnpack, const WIDTH: usize>(
+    array: ArrayView<'_, BitPacked>,
 ) -> VortexResult<bool> {
-    let mut bit_unpack_iterator = array.unpacked_chunks::<T>();
+    let mut bit_unpack_iterator = array.unpacked_chunks::<T>()?;
     let patches = array.patches().map(|p| {
         let values = p.values().to_primitive();
         let indices = p.indices().to_primitive();
@@ -131,7 +143,7 @@ fn bitpacked_is_constant<T: BitPacked, const WIDTH: usize>(
     Ok(true)
 }
 
-fn apply_patches<T: BitPacked>(
+fn apply_patches<T: BitPackedUnpack>(
     values: &mut [T],
     values_range: Range<usize>,
     patch_indices: &PrimitiveArray,
@@ -149,7 +161,7 @@ fn apply_patches<T: BitPacked>(
     });
 }
 
-fn apply_patches_idx_typed<T: BitPacked, I: IntegerPType>(
+fn apply_patches_idx_typed<T: BitPackedUnpack, I: IntegerPType>(
     values: &mut [T],
     values_range: Range<usize>,
     patch_indices: &[I],
@@ -170,14 +182,19 @@ fn apply_patches_idx_typed<T: BitPacked, I: IntegerPType>(
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::compute::is_constant;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::aggregate_fn::fns::is_constant::is_constant;
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
 
-    use crate::BitPackedArray;
+    use crate::BitPackedData;
 
     #[test]
-    fn is_constant_with_patches() {
-        let array = BitPackedArray::encode(&buffer![4; 1025].into_array(), 2).unwrap();
-        assert!(is_constant(array.as_ref()).unwrap().unwrap());
+    fn is_constant_with_patches() -> VortexResult<()> {
+        let array = BitPackedData::encode(&buffer![4; 1025].into_array(), 2)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(is_constant(&array.into_array(), &mut ctx)?);
+        Ok(())
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/compute/mod.rs b/encodings/fastlanes/src/bitpacking/compute/mod.rs
index b14534cb1cc..f404102c019 100644
--- a/encodings/fastlanes/src/bitpacking/compute/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/mod.rs
@@ -3,7 +3,7 @@
 
 mod cast;
 mod filter;
-mod is_constant;
+pub(crate) mod is_constant;
 mod slice;
 mod take;
 
@@ -50,6 +50,10 @@ mod tests {
     use crate::bitpack_compress::bitpack_encode;
     use crate::bitpacking::compute::chunked_indices;
 
+    fn bp(array: &PrimitiveArray, bit_width: u8) -> BitPackedArray {
+        bitpack_encode(array, bit_width, None).unwrap()
+    }
+
     #[test]
     fn chunk_indices_repeated() {
         let mut called = false;
@@ -63,35 +67,35 @@ mod tests {
 
     #[rstest]
     // Basic integer arrays that can be bitpacked
-    #[case::u8_small(bitpack_encode(&PrimitiveArray::from_iter([1u8, 2, 3, 4, 5]), 3, None).unwrap())]
-    #[case::u16_array(bitpack_encode(&PrimitiveArray::from_iter([10u16, 20, 30, 40, 50]), 6, None).unwrap())]
-    #[case::u32_array(bitpack_encode(&PrimitiveArray::from_iter([100u32, 200, 300, 400, 500]), 9, None).unwrap())]
+    #[case::u8_small(bp(&PrimitiveArray::from_iter([1u8, 2, 3, 4, 5]), 3))]
+    #[case::u16_array(bp(&PrimitiveArray::from_iter([10u16, 20, 30, 40, 50]), 6))]
+    #[case::u32_array(bp(&PrimitiveArray::from_iter([100u32, 200, 300, 400, 500]), 9))]
     // Arrays with nulls
-    #[case::nullable_u8(bitpack_encode(&PrimitiveArray::from_option_iter([Some(1u8), None, Some(3), Some(4), None]), 3, None).unwrap())]
-    #[case::nullable_u32(bitpack_encode(&PrimitiveArray::from_option_iter([Some(100u32), None, Some(300), Some(400), None]), 9, None).unwrap())]
+    #[case::nullable_u8(bp(&PrimitiveArray::from_option_iter([Some(1u8), None, Some(3), Some(4), None]), 3))]
+    #[case::nullable_u32(bp(&PrimitiveArray::from_option_iter([Some(100u32), None, Some(300), Some(400), None]), 9))]
     // Edge cases
-    #[case::single_element(bitpack_encode(&PrimitiveArray::from_iter([42u32]), 6, None).unwrap())]
-    #[case::all_zeros(bitpack_encode(&PrimitiveArray::from_iter([0u16; 100]), 1, None).unwrap())]
+    #[case::single_element(bp(&PrimitiveArray::from_iter([42u32]), 6))]
+    #[case::all_zeros(bp(&PrimitiveArray::from_iter([0u16; 100]), 1))]
     // Large arrays (multiple chunks - fastlanes uses 1024-element chunks)
-    #[case::large_u16(bitpack_encode(&PrimitiveArray::from_iter((0..2048).map(|i| (i % 256) as u16)), 8, None).unwrap())]
-    #[case::large_u32(bitpack_encode(&PrimitiveArray::from_iter((0..3000).map(|i| (i % 1024) as u32)), 10, None).unwrap())]
-    #[case::large_u8_many_chunks(bitpack_encode(&PrimitiveArray::from_iter((0..5120).map(|i| (i % 128) as u8)), 7, None).unwrap())] // 5 chunks
-    #[case::large_nullable(bitpack_encode(&PrimitiveArray::from_option_iter((0..2500).map(|i| if i % 10 == 0 { None } else { Some((i % 512) as u16) })), 9, None).unwrap())]
+    #[case::large_u16(bp(&PrimitiveArray::from_iter((0..2048).map(|i| (i % 256) as u16)), 8))]
+    #[case::large_u32(bp(&PrimitiveArray::from_iter((0..3000).map(|i| (i % 1024) as u32)), 10))]
+    #[case::large_u8_many_chunks(bp(&PrimitiveArray::from_iter((0..5120).map(|i| (i % 128) as u8)), 7))] // 5 chunks
+    #[case::large_nullable(bp(&PrimitiveArray::from_option_iter((0..2500).map(|i| if i % 10 == 0 { None } else { Some((i % 512) as u16) })), 9))]
     // Arrays with specific bit patterns
-    #[case::max_value_for_bits(bitpack_encode(&PrimitiveArray::from_iter([7u8, 7, 7, 7, 7]), 3, None).unwrap())] // max value for 3 bits
-    #[case::alternating_bits(bitpack_encode(&PrimitiveArray::from_iter([0u16, 255, 0, 255, 0, 255]), 8, None).unwrap())]
+    #[case::max_value_for_bits(bp(&PrimitiveArray::from_iter([7u8, 7, 7, 7, 7]), 3))] // max value for 3 bits
+    #[case::alternating_bits(bp(&PrimitiveArray::from_iter([0u16, 255, 0, 255, 0, 255]), 8))]
 
     fn test_bitpacked_consistency(#[case] array: BitPackedArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
-    #[case::u8_basic(bitpack_encode(&PrimitiveArray::from_iter([1u8, 2, 3, 4, 5]), 3, None).unwrap())]
-    #[case::u16_basic(bitpack_encode(&PrimitiveArray::from_iter([10u16, 20, 30, 40, 50]), 6, None).unwrap())]
-    #[case::u32_basic(bitpack_encode(&PrimitiveArray::from_iter([100u32, 200, 300, 400, 500]), 9, None).unwrap())]
-    #[case::u64_basic(bitpack_encode(&PrimitiveArray::from_iter([1000u64, 2000, 3000, 4000, 5000]), 13, None).unwrap())]
-    #[case::i32_basic(bitpack_encode(&PrimitiveArray::from_iter([10i32, 20, 30, 40, 50]), 7, None).unwrap())]
-    #[case::large_u32(bitpack_encode(&PrimitiveArray::from_iter((0..100).map(|i| i as u32)), 7, None).unwrap())]
+    #[case::u8_basic(bp(&PrimitiveArray::from_iter([1u8, 2, 3, 4, 5]), 3))]
+    #[case::u16_basic(bp(&PrimitiveArray::from_iter([10u16, 20, 30, 40, 50]), 6))]
+    #[case::u32_basic(bp(&PrimitiveArray::from_iter([100u32, 200, 300, 400, 500]), 9))]
+    #[case::u64_basic(bp(&PrimitiveArray::from_iter([1000u64, 2000, 3000, 4000, 5000]), 13))]
+    #[case::i32_basic(bp(&PrimitiveArray::from_iter([10i32, 20, 30, 40, 50]), 7))]
+    #[case::large_u32(bp(&PrimitiveArray::from_iter((0..100).map(|i| i as u32)), 7))]
     fn test_bitpacked_binary_numeric(#[case] array: BitPackedArray) {
         test_binary_numeric_array(array.into_array());
     }
diff --git a/encodings/fastlanes/src/bitpacking/compute/slice.rs b/encodings/fastlanes/src/bitpacking/compute/slice.rs
index 55cd12b3975..93cb60353c6 100644
--- a/encodings/fastlanes/src/bitpacking/compute/slice.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/slice.rs
@@ -5,20 +5,16 @@ use std::cmp::max;
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceKernel;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
+use crate::BitPacked;
+use crate::bitpacking::array::BitPackedArrayExt;
 
-impl SliceKernel for BitPackedVTable {
-    fn slice(
-        array: &BitPackedArray,
-        range: Range<usize>,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for BitPacked {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let offset_start = range.start + array.offset() as usize;
         let offset_stop = range.end + array.offset() as usize;
         let offset = offset_start % 1024;
@@ -28,12 +24,10 @@ impl SliceKernel for BitPackedVTable {
         let encoded_start = (block_start / 8) * array.bit_width() as usize;
         let encoded_stop = (block_stop / 8) * array.bit_width() as usize;
 
-        // slice the buffer using the encoded start/stop values
-        // SAFETY: slicing packed values without decoding preserves invariants
-        Ok(Some(unsafe {
-            BitPackedArray::new_unchecked(
+        Ok(Some(
+            BitPacked::try_new(
                 array.packed().slice(encoded_start..encoded_stop),
-                array.dtype().clone(),
+                array.dtype().as_ptype(),
                 array.validity()?.slice(range.clone())?,
                 array
                     .patches()
@@ -43,49 +37,36 @@ impl SliceKernel for BitPackedVTable {
                 array.bit_width(),
                 range.len(),
                 offset as u16,
-            )
-            .into_array()
-        }))
+            )?
+            .into_array(),
+        ))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::sync::LazyLock;
-
-    use vortex_array::Array;
     use vortex_array::IntoArray;
-    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::SliceArray;
-    use vortex_array::session::ArraySession;
-    use vortex_array::vtable::VTable;
     use vortex_error::VortexResult;
-    use vortex_session::VortexSession;
 
-    use crate::BitPackedVTable;
+    use crate::BitPacked;
     use crate::bitpack_compress::bitpack_encode;
 
-    static SESSION: LazyLock<VortexSession> =
-        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
-
     #[test]
-    fn test_execute_parent_returns_bitpacked_slice() -> VortexResult<()> {
-        let values = vortex_array::arrays::PrimitiveArray::from_iter(0u32..2048);
+    fn test_reduce_parent_returns_bitpacked_slice() -> VortexResult<()> {
+        let values = PrimitiveArray::from_iter(0u32..2048);
         let bitpacked = bitpack_encode(&values, 11, None)?;
 
         let slice_array = SliceArray::new(bitpacked.clone().into_array(), 500..1500);
 
-        let mut ctx = SESSION.create_execution_ctx();
-        let reduced = <BitPackedVTable as VTable>::execute_parent(
-            &bitpacked,
-            &slice_array.into_array(),
-            0,
-            &mut ctx,
-        )?
-        .expect("expected slice kernel to execute");
+        let bitpacked_ref = bitpacked.into_array();
+        let reduced = bitpacked_ref
+            .reduce_parent(&slice_array.into_array(), 0)?
+            .expect("expected slice kernel to execute");
 
-        assert!(reduced.is::<BitPackedVTable>());
-        let reduced_bp = reduced.as_::<BitPackedVTable>();
+        assert!(reduced.is::<BitPacked>());
+        let reduced_bp = reduced.as_::<BitPacked>();
         assert_eq!(reduced_bp.offset(), 500);
         assert_eq!(reduced.len(), 1000);
 
diff --git a/encodings/fastlanes/src/bitpacking/compute/take.rs b/encodings/fastlanes/src/bitpacking/compute/take.rs
index 4ceea816296..9422b44be1b 100644
--- a/encodings/fastlanes/src/bitpacking/compute/take.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/take.rs
@@ -5,28 +5,26 @@ use std::mem;
 use std::mem::MaybeUninit;
 
 use fastlanes::BitPacking;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 
 use super::chunked_indices;
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
 use crate::bitpack_decompress;
 
 // TODO(connor): This is duplicated in `encodings/fastlanes/src/bitpacking/kernels/mod.rs`.
@@ -35,37 +33,48 @@ use crate::bitpack_decompress;
 /// see https://github.com/vortex-data/vortex/pull/190#issue-2223752833
 pub(super) const UNPACK_CHUNK_THRESHOLD: usize = 8;
 
-impl TakeExecute for BitPackedVTable {
+impl TakeExecute for BitPacked {
     fn take(
-        array: &BitPackedArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         // If the indices are large enough, it's faster to flatten and take the primitive array.
         if indices.len() * UNPACK_CHUNK_THRESHOLD > array.len() {
-            return array.to_primitive().take(indices.to_array()).map(Some);
+            let prim = array.array().clone().execute::<PrimitiveArray>(ctx)?;
+            return prim.into_array().take(indices.clone()).map(Some);
         }
 
         // NOTE: we use the unsigned PType because all values in the BitPackedArray must
         //  be non-negative (pre-condition of creating the BitPackedArray).
         let ptype: PType = PType::try_from(array.dtype())?;
-        let validity = array.validity();
+        let validity = array.validity()?;
         let taken_validity = validity.take(indices)?;
 
-        let indices = indices.to_primitive();
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
         let taken = match_each_unsigned_integer_ptype!(ptype.to_unsigned(), |T| {
             match_each_integer_ptype!(indices.ptype(), |I| {
-                take_primitive::<T, I>(array, &indices, taken_validity)?
+                take_primitive::<T, I>(array, &indices, taken_validity, ctx)?
             })
         });
-        Ok(Some(taken.reinterpret_cast(ptype).into_array()))
+        let taken = if ptype.is_signed_int() {
+            PrimitiveArray::from_buffer_handle(
+                taken.buffer_handle().clone(),
+                ptype,
+                taken.validity()?,
+            )
+        } else {
+            taken
+        };
+        Ok(Some(taken.into_array()))
     }
 }
 
 fn take_primitive<T: NativePType + BitPacking, I: IntegerPType>(
-    array: &BitPackedArray,
+    array: ArrayView<'_, BitPacked>,
     indices: &PrimitiveArray,
     taken_validity: Validity,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<PrimitiveArray> {
     if indices.is_empty() {
         return Ok(PrimitiveArray::new(Buffer::<T>::empty(), taken_validity));
@@ -128,16 +137,21 @@ fn take_primitive<T: NativePType + BitPacking, I: IntegerPType>(
         }
     });
 
-    let mut unpatched_taken = PrimitiveArray::new(output, taken_validity);
-    // Flip back to signed type before patching.
-    if array.ptype().is_signed_int() {
-        unpatched_taken = unpatched_taken.reinterpret_cast(array.ptype());
-    }
+    let unpatched_taken = if array.dtype().as_ptype().is_signed_int() {
+        let primitive = PrimitiveArray::new(output, taken_validity);
+        PrimitiveArray::from_buffer_handle(
+            primitive.buffer_handle().clone(),
+            array.dtype().as_ptype(),
+            primitive.validity()?,
+        )
+    } else {
+        PrimitiveArray::new(output, taken_validity)
+    };
     if let Some(patches) = array.patches()
-        && let Some(patches) = patches.take(indices.as_ref())?
+        && let Some(patches) = patches.take(&indices.clone().into_array(), ctx)?
     {
         let cast_patches = patches.cast_values(unpatched_taken.dtype())?;
-        return unpatched_taken.patch(&cast_patches);
+        return unpatched_taken.patch(&cast_patches, ctx);
     }
 
     Ok(unpatched_taken)
@@ -146,13 +160,14 @@ fn take_primitive<T: NativePType + BitPacking, I: IntegerPType>(
 #[cfg(test)]
 #[allow(clippy::cast_possible_truncation)]
 mod test {
-    use rand::Rng;
+    use rand::RngExt;
     use rand::distr::Uniform;
     use rand::rng;
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
@@ -160,6 +175,8 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::BitPackedArray;
+    use crate::BitPackedData;
+    use crate::bitpacking::array::BitPackedArrayExt;
     use crate::bitpacking::compute::take::take_primitive;
 
     #[test]
@@ -168,9 +185,9 @@ mod test {
 
         // Create a u8 array modulo 63.
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 6).unwrap();
 
-        let primitive_result = bitpacked.take(indices.to_array()).unwrap();
+        let primitive_result = bitpacked.take(indices).unwrap();
         assert_arrays_eq!(
             primitive_result,
             PrimitiveArray::from_iter([0u8, 62, 31, 33, 9, 18])
@@ -180,11 +197,11 @@ mod test {
     #[test]
     fn take_with_patches() {
         let unpacked = Buffer::from_iter(0u32..1024).into_array();
-        let bitpacked = BitPackedArray::encode(&unpacked, 2).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked, 2).unwrap();
 
         let indices = buffer![0, 2, 4, 6].into_array();
 
-        let primitive_result = bitpacked.take(indices.to_array()).unwrap();
+        let primitive_result = bitpacked.take(indices).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([0u32, 2, 4, 6]));
     }
 
@@ -194,10 +211,10 @@ mod test {
 
         // Create a u8 array modulo 63.
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
-        let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
+        let bitpacked = BitPackedData::encode(&unpacked.into_array(), 6).unwrap();
         let sliced = bitpacked.slice(128..2050).unwrap();
 
-        let primitive_result = sliced.take(indices.to_array()).unwrap();
+        let primitive_result = sliced.take(indices).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([31u8, 33]));
     }
 
@@ -207,14 +224,14 @@ mod test {
         let num_patches: usize = 128;
         let values = (0..u16::MAX as u32 + num_patches as u32).collect::<Buffer<_>>();
         let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
-        let packed = BitPackedArray::encode(uncompressed.as_ref(), 16).unwrap();
+        let packed = BitPackedData::encode(&uncompressed.into_array(), 16).unwrap();
         assert!(packed.patches().is_some());
 
         let rng = rng();
         let range = Uniform::new(0, values.len()).unwrap();
         let random_indices =
             PrimitiveArray::from_iter(rng.sample_iter(range).take(10_000).map(|i| i as u32));
-        let taken = packed.take(random_indices.to_array()).unwrap();
+        let taken = packed.take(random_indices.clone().into_array()).unwrap();
 
         // sanity check
         random_indices
@@ -237,12 +254,13 @@ mod test {
     #[cfg_attr(miri, ignore)]
     fn take_signed_with_patches() {
         let start =
-            BitPackedArray::encode(&buffer![1i32, 2i32, 3i32, 4i32].into_array(), 1).unwrap();
+            BitPackedData::encode(&buffer![1i32, 2i32, 3i32, 4i32].into_array(), 1).unwrap();
 
         let taken_primitive = take_primitive::<u32, u64>(
-            &start,
+            start.as_view(),
             &PrimitiveArray::from_iter([0u64, 1, 2, 3]),
             Validity::NonNullable,
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap();
         assert_arrays_eq!(taken_primitive, PrimitiveArray::from_iter([1i32, 2, 3, 4]));
@@ -251,10 +269,12 @@ mod test {
     #[test]
     fn take_nullable_with_nullables() {
         let start =
-            BitPackedArray::encode(&buffer![1i32, 2i32, 3i32, 4i32].into_array(), 1).unwrap();
+            BitPackedData::encode(&buffer![1i32, 2i32, 3i32, 4i32].into_array(), 1).unwrap();
 
         let taken_primitive = start
-            .take(PrimitiveArray::from_option_iter([Some(0u64), Some(1), None, Some(3)]).to_array())
+            .take(
+                PrimitiveArray::from_option_iter([Some(0u64), Some(1), None, Some(3)]).into_array(),
+            )
             .unwrap();
         assert_arrays_eq!(
             taken_primitive,
@@ -264,17 +284,17 @@ mod test {
     }
 
     #[rstest]
-    #[case(BitPackedArray::encode(PrimitiveArray::from_iter((0..100).map(|i| (i % 63) as u8)).as_ref(), 6).unwrap())]
-    #[case(BitPackedArray::encode(PrimitiveArray::from_iter((0..256).map(|i| i as u32)).as_ref(), 8).unwrap())]
-    #[case(BitPackedArray::encode(buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array().as_ref(), 3).unwrap())]
-    #[case(BitPackedArray::encode(
-        PrimitiveArray::from_option_iter([Some(10u16), None, Some(20), Some(30), None]).as_ref(),
+    #[case(BitPackedData::encode(&PrimitiveArray::from_iter((0..100).map(|i| (i % 63) as u8)).into_array(), 6).unwrap())]
+    #[case(BitPackedData::encode(&PrimitiveArray::from_iter((0..256).map(|i| i as u32)).into_array(), 8).unwrap())]
+    #[case(BitPackedData::encode(&buffer![1i32, 2, 3, 4, 5, 6, 7, 8].into_array(), 3).unwrap())]
+    #[case(BitPackedData::encode(
+        &PrimitiveArray::from_option_iter([Some(10u16), None, Some(20), Some(30), None]).into_array(),
         5
     ).unwrap())]
-    #[case(BitPackedArray::encode(buffer![42u32].into_array().as_ref(), 6).unwrap())]
-    #[case(BitPackedArray::encode(PrimitiveArray::from_iter((0..1024).map(|i| i as u32)).as_ref(), 8).unwrap())]
+    #[case(BitPackedData::encode(&buffer![42u32].into_array(), 6).unwrap())]
+    #[case(BitPackedData::encode(&PrimitiveArray::from_iter((0..1024).map(|i| i as u32)).into_array(), 8).unwrap())]
     fn test_take_bitpacked_conformance(#[case] bitpacked: BitPackedArray) {
         use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(bitpacked.as_ref());
+        test_take_conformance(&bitpacked.into_array());
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/mod.rs b/encodings/fastlanes/src/bitpacking/mod.rs
index d2b6c38f6e2..bc2304af657 100644
--- a/encodings/fastlanes/src/bitpacking/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/mod.rs
@@ -2,13 +2,20 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::BitPackedArray;
-pub use array::BitPackedArrayParts;
+pub use array::BitPackedArrayExt;
+pub use array::BitPackedArraySlotsExt;
+pub use array::BitPackedData;
+pub use array::BitPackedDataParts;
+pub use array::BitPackedSlots;
 pub use array::bitpack_compress;
 pub use array::bitpack_decompress;
 pub use array::unpack_iter;
 
-mod compute;
+pub(crate) mod compute;
 
+mod plugin;
 mod vtable;
-pub use vtable::BitPackedVTable;
+
+pub(crate) use plugin::BitPackedPatchedPlugin;
+pub use vtable::BitPacked;
+pub use vtable::BitPackedArray;
diff --git a/encodings/fastlanes/src/bitpacking/plugin.rs b/encodings/fastlanes/src/bitpacking/plugin.rs
new file mode 100644
index 00000000000..fc67714fedd
--- /dev/null
+++ b/encodings/fastlanes/src/bitpacking/plugin.rs
@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! A custom [`ArrayPlugin`] that lets you load in and deserialize a `BitPacked` array with interior
+//! patches as a `PatchedArray` that wraps a patchless `BitPacked` array.
+//!
+//! This enables zero-cost backward compatibility with previously written datasets.
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayPlugin;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::Patched;
+use vortex_array::buffer::BufferHandle;
+use vortex_array::dtype::DType;
+use vortex_array::serde::ArrayChildren;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+use vortex_session::VortexSession;
+
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
+
+/// Custom deserialization plugin that converts a BitPacked array with interior
+/// Patches into a PatchedArray holding a BitPacked array.
+#[derive(Debug, Clone)]
+pub(crate) struct BitPackedPatchedPlugin;
+
+impl ArrayPlugin for BitPackedPatchedPlugin {
+    fn id(&self) -> ArrayId {
+        // We reuse the existing `BitPacked` ID so that we can take over its
+        // deserialization pathway.
+        BitPacked::ID
+    }
+
+    fn serialize(
+        &self,
+        array: &ArrayRef,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        // delegate to BitPacked VTable for serialization
+        BitPacked.serialize(array, session)
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayRef> {
+        let bitpacked = BitPacked
+            .deserialize(dtype, len, metadata, buffers, children, session)?
+            .try_downcast::<BitPacked>()
+            .map_err(|_| {
+                vortex_err!("BitPacked plugin should only deserialize fastlanes.bitpacked")
+            })?;
+
+        // Create a new BitPackedArray without the interior patches installed.
+        let Some(patches) = bitpacked.patches() else {
+            return Ok(bitpacked.into_array());
+        };
+
+        let packed = bitpacked.packed().clone();
+        let ptype = bitpacked.dtype().as_ptype();
+        let validity = bitpacked.validity()?;
+        let bw = bitpacked.bit_width;
+        let len = bitpacked.len();
+        let offset = bitpacked.offset();
+
+        let bitpacked_without_patches =
+            BitPacked::try_new(packed, ptype, validity, None, bw, len, offset)?.into_array();
+
+        let patched = Patched::from_array_and_patches(
+            bitpacked_without_patches,
+            &patches,
+            &mut session.create_execution_ctx(),
+        )?;
+
+        Ok(patched.into_array())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use vortex_array::ArrayPlugin;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::PatchedArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::patched::PatchedArraySlotsExt;
+    use vortex_array::buffer::BufferHandle;
+    use vortex_array::session::ArraySession;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+    use vortex_error::vortex_err;
+    use vortex_session::VortexSession;
+
+    use super::BitPackedPatchedPlugin;
+    use crate::BitPacked;
+    use crate::BitPackedArray;
+    use crate::BitPackedArrayExt;
+    use crate::BitPackedData;
+
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = VortexSession::empty().with::<ArraySession>();
+        session.arrays().register(BitPackedPatchedPlugin);
+        session
+    });
+
+    #[test]
+    fn test_decode_bitpacked_patches() -> VortexResult<()> {
+        // Create values where some exceed the bit width, causing patches.
+        // With bit_width=9, max value is 511. Values >=512 become patches.
+        let values: Buffer<i32> = (0i32..=512).collect();
+        let parray = values.into_array();
+        let bitpacked = BitPackedData::encode(&parray, 9)?;
+
+        assert!(
+            bitpacked.patches().is_some(),
+            "Expected BitPacked array to have patches"
+        );
+
+        let array = bitpacked.as_array();
+
+        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let deserialized = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION,
+        )?;
+
+        let patched: PatchedArray = deserialized
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected Patched, got {}", a.encoding_id()))?;
+
+        let inner_bitpacked: BitPackedArray = patched
+            .inner()
+            .clone()
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected inner BitPacked, got {}", a.encoding_id()))?;
+
+        assert!(
+            inner_bitpacked.patches().is_none(),
+            "Inner BitPacked should NOT have patches"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn bitpacked_without_patches_stays_bitpacked() -> VortexResult<()> {
+        // With bit_width=16, max value is 65535. All values 0..100 fit.
+        let values: Buffer<i32> = (0i32..100).collect();
+        let parray = values.into_array();
+        let bitpacked = BitPackedData::encode(&parray, 16)?;
+
+        assert!(
+            bitpacked.patches().is_none(),
+            "Expected BitPacked array without patches"
+        );
+
+        let array = bitpacked.as_array();
+
+        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let deserialized = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION,
+        )?;
+
+        let result = deserialized
+            .try_downcast::<BitPacked>()
+            .map_err(|a| vortex_err!("Expected deserialize BitPacked, got {}", a.encoding_id()))?;
+
+        assert!(result.patches().is_none(), "Result should not have patches");
+
+        Ok(())
+    }
+
+    #[test]
+    fn primitive_array_returns_error() -> VortexResult<()> {
+        let array = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
+
+        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let children = array.children();
+        let buffers = array
+            .buffers()
+            .into_iter()
+            .map(BufferHandle::new_host)
+            .collect::<Vec<_>>();
+
+        let result = BitPackedPatchedPlugin.deserialize(
+            array.dtype(),
+            array.len(),
+            &metadata,
+            &buffers,
+            &children,
+            &SESSION,
+        );
+
+        assert!(
+            result.is_err(),
+            "Expected error when deserializing PrimitiveArray with BitPackedPatchedPlugin"
+        );
+
+        Ok(())
+    }
+}
diff --git a/encodings/fastlanes/src/bitpacking/vtable/array.rs b/encodings/fastlanes/src/bitpacking/vtable/array.rs
deleted file mode 100644
index 72fefcf4e24..00000000000
--- a/encodings/fastlanes/src/bitpacking/vtable/array.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use vortex_array::ArrayEq;
-use vortex_array::ArrayHash;
-use vortex_array::Precision;
-use vortex_array::dtype::DType;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable::BaseArrayVTable;
-
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
-
-impl BaseArrayVTable<BitPackedVTable> for BitPackedVTable {
-    fn len(array: &BitPackedArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &BitPackedArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &BitPackedArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &BitPackedArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.offset.hash(state);
-        array.len.hash(state);
-        array.dtype.hash(state);
-        array.bit_width.hash(state);
-        array.packed.array_hash(state, precision);
-        array.patches.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &BitPackedArray, other: &BitPackedArray, precision: Precision) -> bool {
-        array.offset == other.offset
-            && array.len == other.len
-            && array.dtype == other.dtype
-            && array.bit_width == other.bit_width
-            && array.packed.array_eq(&other.packed, precision)
-            && array.patches.array_eq(&other.patches, precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/encodings/fastlanes/src/bitpacking/vtable/kernels.rs b/encodings/fastlanes/src/bitpacking/vtable/kernels.rs
index ca9b98c09db..128ff77d99c 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/kernels.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/kernels.rs
@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::SliceExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::BitPackedVTable;
+use crate::BitPacked;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<BitPackedVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(BitPackedVTable)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(BitPackedVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(BitPackedVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<BitPacked> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FilterExecuteAdaptor(BitPacked)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(BitPacked)),
 ]);
diff --git a/encodings/fastlanes/src/bitpacking/vtable/mod.rs b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
index e09e3db0152..93c5d116fdc 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
@@ -1,12 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::dtype::DType;
@@ -14,32 +23,36 @@ use vortex_array::dtype::PType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::patches::Patches;
 use vortex_array::patches::PatchesMetadata;
+use vortex_array::require_patches;
+use vortex_array::require_validity;
 use vortex_array::serde::ArrayChildren;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityVTableFromValidityHelper;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
 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_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::BitPackedArray;
+use crate::BitPackedArrayExt;
+use crate::BitPackedData;
+use crate::BitPackedDataParts;
 use crate::bitpack_decompress::unpack_array;
 use crate::bitpack_decompress::unpack_into_primitive_builder;
+use crate::bitpacking::array::BitPackedSlots;
+use crate::bitpacking::array::BitPackedSlotsView;
 use crate::bitpacking::vtable::kernels::PARENT_KERNELS;
 use crate::bitpacking::vtable::rules::RULES;
-mod array;
 mod kernels;
 mod operations;
 mod rules;
 mod validity;
-mod visitor;
 
-vtable!(BitPacked);
+/// A [`BitPacked`]-encoded Vortex array.
+pub type BitPackedArray = Array<BitPacked>;
 
 #[derive(Clone, prost::Message)]
 pub struct BitPackedMetadata {
@@ -51,135 +64,132 @@ pub struct BitPackedMetadata {
     pub(crate) patches: Option<PatchesMetadata>,
 }
 
-impl VTable for BitPackedVTable {
-    type Array = BitPackedArray;
+impl ArrayHash for BitPackedData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.offset.hash(state);
+        self.bit_width.hash(state);
+        self.packed.array_hash(state, precision);
+        self.patch_offset.hash(state);
+        self.patch_offset_within_chunk.hash(state);
+    }
+}
+
+impl ArrayEq for BitPackedData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.offset == other.offset
+            && self.bit_width == other.bit_width
+            && self.packed.array_eq(&other.packed, precision)
+            && self.patch_offset == other.patch_offset
+            && self.patch_offset_within_chunk == other.patch_offset_within_chunk
+    }
+}
 
-    type Metadata = ProstMetadata<BitPackedMetadata>;
+impl VTable for BitPacked {
+    type ArrayData = BitPackedData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn reduce_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>> {
-        RULES.evaluate(array, parent, child_idx)
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // Children: patches (if present): indices, values, chunk_offsets; then validity (if present)
-        let patches_info = array
-            .patches()
-            .map(|p| (p.offset(), p.chunk_offsets().is_some()));
-
-        let mut child_idx = 0;
-        let patches = if let Some((patch_offset, has_chunk_offsets)) = patches_info {
-            let patch_indices = children
-                .get(child_idx)
-                .ok_or_else(|| vortex_err!("Expected patch_indices child at index {}", child_idx))?
-                .clone();
-            child_idx += 1;
-
-            let patch_values = children
-                .get(child_idx)
-                .ok_or_else(|| vortex_err!("Expected patch_values child at index {}", child_idx))?
-                .clone();
-            child_idx += 1;
-
-            let patch_chunk_offsets = if has_chunk_offsets {
-                let offsets = children
-                    .get(child_idx)
-                    .ok_or_else(|| {
-                        vortex_err!("Expected patch_chunk_offsets child at index {}", child_idx)
-                    })?
-                    .clone();
-                child_idx += 1;
-                Some(offsets)
-            } else {
-                None
-            };
-
-            Some(Patches::new(
-                array.len(),
-                patch_offset,
-                patch_indices,
-                patch_values,
-                patch_chunk_offsets,
-            )?)
-        } else {
-            None
-        };
-
-        let validity = if child_idx < children.len() {
-            Validity::Array(children[child_idx].clone())
-        } else {
-            Validity::from(array.dtype().nullability())
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let slots = BitPackedSlotsView::from_slots(slots);
+
+        let validity = child_to_validity(&slots.validity_child.cloned(), dtype.nullability());
+        let patches = match (slots.patch_indices, slots.patch_values) {
+            (Some(indices), Some(values)) => {
+                let patch_offset = data
+                    .patch_offset
+                    .vortex_expect("has patch slots but no patch_offset");
+                Some(unsafe {
+                    Patches::new_unchecked(
+                        len,
+                        patch_offset,
+                        indices.clone(),
+                        values.clone(),
+                        slots.patch_chunk_offsets.cloned(),
+                        data.patch_offset_within_chunk,
+                    )
+                })
+            }
+            _ => None,
         };
+        BitPackedData::validate(
+            &data.packed,
+            dtype.as_ptype(),
+            &validity,
+            patches.as_ref(),
+            data.bit_width,
+            len,
+            data.offset,
+        )
+    }
 
-        let expected_children = child_idx
-            + if matches!(validity, Validity::Array(_)) {
-                1
-            } else {
-                0
-            };
-        vortex_ensure!(
-            children.len() == expected_children,
-            "Expected {} children, got {}",
-            expected_children,
-            children.len()
-        );
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
+    }
 
-        array.patches = patches;
-        array.validity = validity;
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.packed().clone(),
+            _ => vortex_panic!("BitPackedArray buffer index {idx} out of bounds"),
+        }
+    }
 
-        Ok(())
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("packed".to_string()),
+            _ => None,
+        }
     }
 
-    fn metadata(array: &BitPackedArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(BitPackedMetadata {
-            bit_width: array.bit_width() as u32,
-            offset: array.offset() as u32,
-            patches: array
-                .patches()
-                .map(|p| p.to_metadata(array.len(), array.dtype()))
-                .transpose()?,
-        }))
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        RULES.evaluate(array, parent, child_idx)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        BitPackedSlots::NAMES[idx].to_string()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let inner = <ProstMetadata<BitPackedMetadata> as DeserializeMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(inner))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            BitPackedMetadata {
+                bit_width: array.bit_width() as u32,
+                offset: array.offset() as u32,
+                patches: array
+                    .patches()
+                    .map(|p| p.to_metadata(array.len(), array.dtype()))
+                    .transpose()?,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    /// Deserialize a BitPackedArray from its components.
-    ///
-    /// Note that the layout depends on whether patches and chunk_offsets are present:
-    /// - No patches: `[validity?]`
-    /// - With patches: `[patch_indices, patch_values, chunk_offsets?, validity?]`
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<BitPackedArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = BitPackedMetadata::decode(metadata)?;
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
@@ -223,10 +233,20 @@ impl VTable for BitPackedVTable {
             })
             .transpose()?;
 
-        BitPackedArray::try_new(
+        let slots = {
+            let (pi, pv, pco) = match &patches {
+                Some(p) => (
+                    Some(p.indices().clone()),
+                    Some(p.values().clone()),
+                    p.chunk_offsets().clone(),
+                ),
+                None => (None, None, None),
+            };
+            let validity_slot = validity_to_child(&validity, len);
+            vec![pi, pv, pco, validity_slot]
+        };
+        let data = BitPackedData::try_new(
             packed,
-            PType::try_from(dtype)?,
-            validity,
             patches,
             u8::try_from(metadata.bit_width).map_err(|_| {
                 vortex_err!(
@@ -234,22 +254,22 @@ impl VTable for BitPackedVTable {
                     metadata.bit_width
                 )
             })?,
-            len,
             u16::try_from(metadata.offset).map_err(|_| {
                 vortex_err!(
                     "BitPackedMetadata offset {} does not fit in u16",
                     metadata.offset
                 )
             })?,
-        )
+        )?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
     fn append_to_builder(
-        array: &BitPackedArray,
+        array: ArrayView<'_, Self>,
         builder: &mut dyn ArrayBuilder,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
-        match_each_integer_ptype!(array.ptype(), |T| {
+        match_each_integer_ptype!(array.dtype().as_ptype(), |T| {
             unpack_into_primitive_builder::<T>(
                 array,
                 builder
@@ -261,12 +281,22 @@ impl VTable for BitPackedVTable {
         })
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(unpack_array(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        require_patches!(
+            array,
+            BitPackedSlots::PATCH_INDICES,
+            BitPackedSlots::PATCH_VALUES,
+            BitPackedSlots::PATCH_CHUNK_OFFSETS
+        );
+        require_validity!(array, BitPackedSlots::VALIDITY_CHILD);
+
+        Ok(ExecutionResult::done(
+            unpack_array(array.as_view(), ctx)?.into_array(),
+        ))
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -275,9 +305,55 @@ impl VTable for BitPackedVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct BitPackedVTable;
+#[derive(Clone, Debug)]
+pub struct BitPacked;
 
-impl BitPackedVTable {
+impl BitPacked {
     pub const ID: ArrayId = ArrayId::new_ref("fastlanes.bitpacked");
+
+    pub fn try_new(
+        packed: BufferHandle,
+        ptype: PType,
+        validity: Validity,
+        patches: Option<Patches>,
+        bit_width: u8,
+        len: usize,
+        offset: u16,
+    ) -> VortexResult<BitPackedArray> {
+        let dtype = DType::Primitive(ptype, validity.nullability());
+        let slots = {
+            let (pi, pv, pco) = match &patches {
+                Some(p) => (
+                    Some(p.indices().clone()),
+                    Some(p.values().clone()),
+                    p.chunk_offsets().clone(),
+                ),
+                None => (None, None, None),
+            };
+            let validity_slot = validity_to_child(&validity, len);
+            vec![pi, pv, pco, validity_slot]
+        };
+        let data = BitPackedData::try_new(packed, patches, bit_width, offset)?;
+        Array::try_from_parts(ArrayParts::new(BitPacked, dtype, len, data).with_slots(slots))
+    }
+
+    pub fn into_parts(array: BitPackedArray) -> BitPackedDataParts {
+        let len = array.len();
+        let patches = array.patches();
+        let validity = array.validity().vortex_expect("BitPacked validity");
+        let data = array.into_data();
+        BitPackedDataParts {
+            offset: data.offset,
+            bit_width: data.bit_width,
+            len,
+            packed: data.packed,
+            patches,
+            validity,
+        }
+    }
+
+    /// Encode an array into a bitpacked representation with the given bit width.
+    pub fn encode(array: &ArrayRef, bit_width: u8) -> VortexResult<BitPackedArray> {
+        BitPackedData::encode(array, bit_width)
+    }
 }
diff --git a/encodings/fastlanes/src/bitpacking/vtable/operations.rs b/encodings/fastlanes/src/bitpacking/vtable/operations.rs
index 2dcf62ceac3..13e22a2f11c 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/operations.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/operations.rs
@@ -1,16 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexResult;
 
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
+use crate::BitPacked;
 use crate::bitpack_decompress;
-
-impl OperationsVTable<BitPackedVTable> for BitPackedVTable {
-    fn scalar_at(array: &BitPackedArray, index: usize) -> VortexResult<Scalar> {
+use crate::bitpacking::array::BitPackedArrayExt;
+impl OperationsVTable<BitPacked> for BitPacked {
+    fn scalar_at(
+        array: ArrayView<'_, BitPacked>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(
             if let Some(patches) = array.patches()
                 && let Some(patch) = patches.get_patched(index)?
@@ -26,11 +31,9 @@ impl OperationsVTable<BitPackedVTable> for BitPackedVTable {
 #[cfg(test)]
 mod test {
     use std::ops::Range;
-    use std::sync::LazyLock;
 
-    use vortex_array::Array;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::SliceArray;
     use vortex_array::assert_arrays_eq;
@@ -41,42 +44,38 @@ mod test {
     use vortex_array::dtype::PType;
     use vortex_array::patches::Patches;
     use vortex_array::scalar::Scalar;
-    use vortex_array::session::ArraySession;
     use vortex_array::validity::Validity;
-    use vortex_array::vtable::VTable;
     use vortex_buffer::Alignment;
     use vortex_buffer::Buffer;
     use vortex_buffer::ByteBuffer;
     use vortex_buffer::buffer;
 
+    use crate::BitPacked;
     use crate::BitPackedArray;
-    use crate::BitPackedVTable;
+    use crate::BitPackedData;
+    use crate::bitpacking::array::BitPackedArrayExt;
 
-    static SESSION: LazyLock<vortex_session::VortexSession> =
-        LazyLock::new(|| vortex_session::VortexSession::empty().with::<ArraySession>());
+    fn bp(array: &ArrayRef, bit_width: u8) -> BitPackedArray {
+        BitPackedData::encode(array, bit_width).unwrap()
+    }
 
-    fn slice_via_kernel(array: &BitPackedArray, range: Range<usize>) -> BitPackedArray {
-        let slice_array = SliceArray::new(array.clone().into_array(), range);
-        let mut ctx = SESSION.create_execution_ctx();
-        let sliced = <BitPackedVTable as VTable>::execute_parent(
-            array,
-            &slice_array.into_array(),
-            0,
-            &mut ctx,
-        )
-        .expect("execute_parent failed")
-        .expect("expected slice kernel to execute");
-        sliced.as_::<BitPackedVTable>().clone()
+    fn slice_via_reduce(array: &BitPackedArray, range: Range<usize>) -> BitPackedArray {
+        let array_ref = array.clone().into_array();
+        let slice_array = SliceArray::new(array_ref.clone(), range);
+        let sliced = array_ref
+            .reduce_parent(&slice_array.into_array(), 0)
+            .expect("execute_parent failed")
+            .expect("expected slice kernel to execute");
+        sliced.as_::<BitPacked>().into_owned()
     }
 
     #[test]
     pub fn slice_block() {
-        let arr = BitPackedArray::encode(
-            PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).as_ref(),
+        let arr = bp(
+            &PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).into_array(),
             6,
-        )
-        .unwrap();
-        let sliced = slice_via_kernel(&arr, 1024..2048);
+        );
+        let sliced = slice_via_reduce(&arr, 1024..2048);
         assert_nth_scalar!(sliced, 0, 1024u32 % 64);
         assert_nth_scalar!(sliced, 1023, 2047u32 % 64);
         assert_eq!(sliced.offset(), 0);
@@ -85,12 +84,11 @@ mod test {
 
     #[test]
     pub fn slice_within_block() {
-        let arr = BitPackedArray::encode(
-            PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).as_ref(),
+        let arr = bp(
+            &PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).into_array(),
             6,
-        )
-        .unwrap();
-        let sliced = slice_via_kernel(&arr, 512..1434);
+        );
+        let sliced = slice_via_reduce(&arr, 512..1434);
         assert_nth_scalar!(sliced, 0, 512u32 % 64);
         assert_nth_scalar!(sliced, 921, 1433u32 % 64);
         assert_eq!(sliced.offset(), 512);
@@ -99,11 +97,10 @@ mod test {
 
     #[test]
     fn slice_within_block_u8s() {
-        let packed = BitPackedArray::encode(
-            PrimitiveArray::from_iter((0..10_000).map(|i| (i % 63) as u8)).as_ref(),
+        let packed = bp(
+            &PrimitiveArray::from_iter((0..10_000).map(|i| (i % 63) as u8)).into_array(),
             7,
-        )
-        .unwrap();
+        );
 
         let compressed = packed.slice(768..9999).unwrap();
         assert_nth_scalar!(compressed, 0, (768 % 63) as u8);
@@ -112,11 +109,10 @@ mod test {
 
     #[test]
     fn slice_block_boundary_u8s() {
-        let packed = BitPackedArray::encode(
-            PrimitiveArray::from_iter((0..10_000).map(|i| (i % 63) as u8)).as_ref(),
+        let packed = bp(
+            &PrimitiveArray::from_iter((0..10_000).map(|i| (i % 63) as u8)).into_array(),
             7,
-        )
-        .unwrap();
+        );
 
         let compressed = packed.slice(7168..9216).unwrap();
         assert_nth_scalar!(compressed, 0, (7168 % 63) as u8);
@@ -125,17 +121,16 @@ mod test {
 
     #[test]
     fn double_slice_within_block() {
-        let arr = BitPackedArray::encode(
-            PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).as_ref(),
+        let arr = bp(
+            &PrimitiveArray::from_iter((0u32..2048).map(|v| v % 64)).into_array(),
             6,
-        )
-        .unwrap();
-        let sliced = slice_via_kernel(&arr, 512..1434);
+        );
+        let sliced = slice_via_reduce(&arr, 512..1434);
         assert_nth_scalar!(sliced, 0, 512u32 % 64);
         assert_nth_scalar!(sliced, 921, 1433u32 % 64);
         assert_eq!(sliced.offset(), 512);
         assert_eq!(sliced.len(), 922);
-        let doubly_sliced = slice_via_kernel(&sliced, 127..911);
+        let doubly_sliced = slice_via_reduce(&sliced, 127..911);
         assert_nth_scalar!(doubly_sliced, 0, (512u32 + 127) % 64);
         assert_nth_scalar!(doubly_sliced, 783, (512u32 + 910) % 64);
         assert_eq!(doubly_sliced.offset(), 639);
@@ -145,7 +140,7 @@ mod test {
     #[test]
     fn slice_empty_patches() {
         // We create an array that has 1 element that does not fit in the 6-bit range.
-        let array = BitPackedArray::encode(&buffer![0u32..=64].into_array(), 6).unwrap();
+        let array = BitPackedData::encode(&buffer![0u32..=64].into_array(), 6).unwrap();
 
         assert!(array.patches().is_some());
 
@@ -153,7 +148,7 @@ mod test {
         assert_eq!(patch_indices.len(), 1);
 
         // Slicing drops the empty patches array.
-        let sliced_bp = slice_via_kernel(&array, 0..64);
+        let sliced_bp = slice_via_reduce(&array, 0..64);
         assert!(sliced_bp.patches().is_none());
     }
 
@@ -161,9 +156,10 @@ mod test {
     fn take_after_slice() {
         // Check that our take implementation respects the offsets applied after slicing.
 
-        let array =
-            BitPackedArray::encode(PrimitiveArray::from_iter((63u32..).take(3072)).as_ref(), 6)
-                .unwrap();
+        let array = bp(
+            &PrimitiveArray::from_iter((63u32..).take(3072)).into_array(),
+            6,
+        );
 
         // Slice the array.
         // The resulting array will still have 3 1024-element chunks.
@@ -182,30 +178,29 @@ mod test {
 
     #[test]
     fn scalar_at_invalid_patches() {
-        let packed_array = unsafe {
-            BitPackedArray::new_unchecked(
-                BufferHandle::new_host(ByteBuffer::copy_from_aligned(
-                    [0u8; 128],
-                    Alignment::of::<u32>(),
-                )),
-                DType::Primitive(PType::U32, true.into()),
-                Validity::AllInvalid,
-                Some(
-                    Patches::new(
-                        8,
-                        0,
-                        buffer![1u32].into_array(),
-                        PrimitiveArray::new(buffer![999u32], Validity::AllValid).to_array(),
-                        None,
-                    )
-                    .unwrap(),
-                ),
-                1,
-                8,
-                0,
-            )
-            .into_array()
-        };
+        let packed_array = BitPacked::try_new(
+            BufferHandle::new_host(ByteBuffer::copy_from_aligned(
+                [0u8; 128],
+                Alignment::of::<u32>(),
+            )),
+            PType::U32,
+            Validity::AllInvalid,
+            Some(
+                Patches::new(
+                    8,
+                    0,
+                    buffer![1u32].into_array(),
+                    PrimitiveArray::new(buffer![999u32], Validity::AllValid).into_array(),
+                    None,
+                )
+                .unwrap(),
+            ),
+            1,
+            8,
+            0,
+        )
+        .unwrap()
+        .into_array();
         assert_eq!(
             packed_array.scalar_at(1).unwrap(),
             Scalar::null(DType::Primitive(PType::U32, Nullability::Nullable))
@@ -216,7 +211,7 @@ mod test {
     fn scalar_at() {
         let values = (0u32..257).collect::<Buffer<_>>();
         let uncompressed = values.clone().into_array();
-        let packed = BitPackedArray::encode(&uncompressed, 8).unwrap();
+        let packed = BitPackedData::encode(&uncompressed, 8).unwrap();
         assert!(packed.patches().is_some());
 
         let patches = packed.patches().unwrap().indices().clone();
diff --git a/encodings/fastlanes/src/bitpacking/vtable/rules.rs b/encodings/fastlanes/src/bitpacking/vtable/rules.rs
index 35c4a388f6a..a26989569b2 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/rules.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/rules.rs
@@ -1,10 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::BitPackedVTable;
+use crate::BitPacked;
 
-pub(crate) const RULES: ParentRuleSet<BitPackedVTable> =
-    ParentRuleSet::new(&[ParentRuleSet::lift(&CastReduceAdaptor(BitPackedVTable))]);
+pub(crate) const RULES: ParentRuleSet<BitPacked> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(BitPacked)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(BitPacked)),
+]);
diff --git a/encodings/fastlanes/src/bitpacking/vtable/validity.rs b/encodings/fastlanes/src/bitpacking/vtable/validity.rs
index feafa6fbc44..b3d61324af5 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/validity.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/validity.rs
@@ -1,13 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
+use vortex_array::vtable::ValidityVTable;
+use vortex_error::VortexResult;
 
-use crate::BitPackedArray;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
 
-impl ValidityHelper for BitPackedArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<BitPacked> for BitPacked {
+    fn validity(array: ArrayView<'_, BitPacked>) -> VortexResult<Validity> {
+        Ok(BitPackedArrayExt::validity(&array))
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/vtable/visitor.rs b/encodings/fastlanes/src/bitpacking/vtable/visitor.rs
deleted file mode 100644
index 74254f7389e..00000000000
--- a/encodings/fastlanes/src/bitpacking/vtable/visitor.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
-use vortex_array::vtable::ValidityHelper;
-use vortex_array::vtable::VisitorVTable;
-use vortex_array::vtable::validity_nchildren;
-
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
-
-impl VisitorVTable<BitPackedVTable> for BitPackedVTable {
-    fn visit_buffers(array: &BitPackedArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle("packed", array.packed());
-    }
-
-    fn nbuffers(_array: &BitPackedArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &BitPackedArray, visitor: &mut dyn ArrayChildVisitor) {
-        if let Some(patches) = array.patches() {
-            visitor.visit_patches(patches);
-        }
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &BitPackedArray) -> usize {
-        // optional patches (indices + values + optional chunk_offsets) + optional validity
-        array
-            .patches()
-            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
-            + validity_nchildren(array.validity())
-    }
-}
diff --git a/encodings/fastlanes/src/delta/array/delta_compress.rs b/encodings/fastlanes/src/delta/array/delta_compress.rs
index f15c3ad8d58..105004c0c71 100644
--- a/encodings/fastlanes/src/delta/array/delta_compress.rs
+++ b/encodings/fastlanes/src/delta/array/delta_compress.rs
@@ -1,91 +1,91 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use arrayref::array_mut_ref;
-use arrayref::array_ref;
+use std::mem;
+use std::mem::MaybeUninit;
+
 use fastlanes::Delta;
 use fastlanes::FastLanes;
 use fastlanes::Transpose;
-use num_traits::WrappingSub;
+use vortex_array::ExecutionCtx;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_unsigned_integer_ptype;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
 
-pub fn delta_compress(array: &PrimitiveArray) -> VortexResult<(PrimitiveArray, PrimitiveArray)> {
-    // TODO(ngates): fill forward nulls?
-    // let filled = fill_forward(array)?.to_primitive()?;
-
-    // Compress the filled array
+use crate::FL_CHUNK_SIZE;
+use crate::bit_transpose::transpose_validity;
+use crate::fill_forward_nulls;
+pub fn delta_compress(
+    array: &PrimitiveArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<(PrimitiveArray, PrimitiveArray)> {
+    let validity = array.validity()?;
     let (bases, deltas) = match_each_unsigned_integer_ptype!(array.ptype(), |T| {
-        const LANES: usize = T::LANES;
-        let (bases, deltas) = compress_primitive::<T, LANES>(array.as_slice::<T>());
+        // Fill-forward null values so that transposed deltas at null positions remain
+        // small. Without this, bitpacking may skip patches for null positions, and the
+        // corrupted delta values propagate through the cumulative sum during decompression.
+        let filled = fill_forward_nulls(array.to_buffer::<T>(), &validity);
+        let (bases, deltas) = compress_primitive::<T, { T::LANES }>(&filled);
+        // TODO(robert): This can be avoided if we add TransposedBoolArray that performs index translation when necessary.
+        let validity = transpose_validity(&validity, ctx)?;
         (
-            // To preserve nullability, we include Validity
             PrimitiveArray::new(bases, array.dtype().nullability().into()),
-            PrimitiveArray::new(deltas, array.validity().clone()),
+            PrimitiveArray::new(deltas, validity),
         )
     });
 
     Ok((bases, deltas))
 }
 
-fn compress_primitive<T: NativePType + Delta + Transpose + WrappingSub, const LANES: usize>(
-    array: &[T],
-) -> (Buffer<T>, Buffer<T>) {
-    // How many fastlanes vectors we will process.
-    let num_chunks = array.len() / 1024;
+fn compress_primitive<T, const LANES: usize>(array: &[T]) -> (Buffer<T>, Buffer<T>)
+where
+    T: NativePType + Delta + Transpose,
+{
+    let padded_len = array.len().next_multiple_of(FL_CHUNK_SIZE);
+    let bases_len = (padded_len / FL_CHUNK_SIZE) * LANES;
+
+    // Split into full 1024-element chunks and a remainder.
+    let (full_chunks, remainder) = array.as_chunks::<FL_CHUNK_SIZE>();
 
     // Allocate result arrays.
-    let mut bases = BufferMut::with_capacity(num_chunks * T::LANES + 1);
-    let mut deltas = BufferMut::with_capacity(array.len());
-
-    // Loop over all the 1024-element chunks.
-    if num_chunks > 0 {
-        let mut transposed: [T; 1024] = [T::default(); 1024];
-
-        for i in 0..num_chunks {
-            let start_elem = i * 1024;
-            let chunk: &[T; 1024] = array_ref![array, start_elem, 1024];
-            Transpose::transpose(chunk, &mut transposed);
-
-            // Initialize and store the base vector for each chunk
-            bases.extend_from_slice(&transposed[0..T::LANES]);
-
-            deltas.reserve(1024);
-            let delta_len = deltas.len();
-            unsafe {
-                deltas.set_len(delta_len + 1024);
-                Delta::delta::<LANES>(
-                    &transposed,
-                    &*(transposed[0..T::LANES].as_ptr().cast()),
-                    array_mut_ref![deltas[delta_len..], 0, 1024],
-                );
-            }
+    let mut bases = BufferMut::with_capacity(bases_len);
+    let mut deltas = BufferMut::with_capacity(padded_len);
+    let (output_deltas, _) = deltas.spare_capacity_mut().as_chunks_mut::<FL_CHUNK_SIZE>();
+
+    // Loop over all full 1024-element chunks.
+    let mut transposed: [T; FL_CHUNK_SIZE] = [T::default(); FL_CHUNK_SIZE];
+    let mut process_chunk = |input: &[T; FL_CHUNK_SIZE], output: &mut [MaybeUninit<T>; 1024]| {
+        Transpose::transpose(input, &mut transposed);
+        bases.extend_from_slice(&transposed[0..T::LANES]);
+
+        unsafe {
+            Delta::delta::<LANES>(
+                &transposed,
+                &*(transposed[0..T::LANES].as_ptr().cast()),
+                mem::transmute::<&mut [MaybeUninit<T>; FL_CHUNK_SIZE], &mut [T; FL_CHUNK_SIZE]>(
+                    output,
+                ),
+            );
         }
+    };
+    for (chunk, output) in full_chunks.iter().zip(output_deltas.iter_mut()) {
+        process_chunk(chunk, output);
     }
 
-    // To avoid padding, the remainder is encoded with scalar logic.
-    let remainder_size = array.len() % 1024;
-    if remainder_size > 0 {
-        let chunk = &array[array.len() - remainder_size..];
-        let mut base_scalar = chunk[0];
-        bases.push(base_scalar);
-        for next in chunk {
-            let diff = next.wrapping_sub(&base_scalar);
-            deltas.push(diff);
-            base_scalar = *next;
-        }
+    // Pad the remainder to 1024 elements and process as a full chunk.
+    if !remainder.is_empty() {
+        let mut padded_chunk = [T::default(); FL_CHUNK_SIZE];
+        padded_chunk[..remainder.len()].copy_from_slice(remainder);
+        process_chunk(&padded_chunk, &mut output_deltas[full_chunks.len()]);
     }
 
-    assert_eq!(
-        bases.len(),
-        num_chunks * T::LANES + (if remainder_size > 0 { 1 } else { 0 })
-    );
-    assert_eq!(deltas.len(), array.len());
+    unsafe { deltas.set_len(padded_len) };
+
+    assert_eq!(bases.len(), bases_len);
+    assert_eq!(deltas.len(), padded_len);
 
     (bases.freeze(), deltas.freeze())
 }
@@ -94,41 +94,56 @@ fn compress_primitive<T: NativePType + Delta + Transpose + WrappingSub, const LA
 mod tests {
     use std::sync::LazyLock;
 
+    use rstest::rstest;
+    use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::session::ArraySession;
+    use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
-    use crate::DeltaArray;
+    use crate::Delta;
+    use crate::bitpack_compress::bitpack_encode;
     use crate::delta::array::delta_decompress::delta_decompress;
+    use crate::delta_compress;
 
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
-    #[test]
-    fn test_compress() -> VortexResult<()> {
-        do_roundtrip_test((0u32..10_000).collect())
-    }
-
-    #[test]
-    fn test_compress_nullable() -> VortexResult<()> {
-        do_roundtrip_test(PrimitiveArray::from_option_iter(
+    #[rstest]
+    #[case((0u32..10_000).collect())]
+    #[case((0..10_000).map(|i| (i % (u8::MAX as i32)) as u8).collect())]
+    #[case(PrimitiveArray::from_option_iter(
             (0u32..10_000).map(|i| (i % 2 == 0).then_some(i)),
-        ))
+    ))]
+    fn test_compress(#[case] array: PrimitiveArray) -> VortexResult<()> {
+        let delta = Delta::try_from_primitive_array(&array, &mut SESSION.create_execution_ctx())?;
+        assert_eq!(delta.len(), array.len());
+        let decompressed = delta_decompress(&delta, &mut SESSION.create_execution_ctx())?;
+        assert_arrays_eq!(decompressed, array);
+        Ok(())
     }
 
+    /// Regression test: delta + bitpacked encoding must correctly round-trip nullable arrays
+    /// where null positions contain arbitrary values. Without fill-forward, the delta cumulative
+    /// sum propagates corrupted values from null positions.
     #[test]
-    fn test_compress_overflow() -> VortexResult<()> {
-        do_roundtrip_test((0..10_000).map(|i| (i % (u8::MAX as i32)) as u8).collect())
-    }
-
-    fn do_roundtrip_test(input: PrimitiveArray) -> VortexResult<()> {
-        let delta = DeltaArray::try_from_primitive_array(&input)?;
-        assert_eq!(delta.len(), input.len());
-        let decompressed = delta_decompress(&delta, &mut SESSION.create_execution_ctx())?;
-        assert_arrays_eq!(decompressed, input);
-        Ok(())
+    fn delta_bitpacked_trailing_nulls() {
+        let array = PrimitiveArray::from_option_iter(
+            (0u8..200).map(|i| (!(50..100).contains(&i)).then_some(i)),
+        );
+        let (bases, deltas) = delta_compress(&array, &mut SESSION.create_execution_ctx()).unwrap();
+        let bitpacked_deltas = bitpack_encode(&deltas, 1, None).unwrap();
+        let packed_delta = Delta::try_new(
+            bases.into_array(),
+            bitpacked_deltas.into_array(),
+            0,
+            array.len(),
+        )
+        .vortex_expect("Delta array construction should succeed");
+        assert_arrays_eq!(packed_delta.as_array().to_primitive(), array);
     }
 }
diff --git a/encodings/fastlanes/src/delta/array/delta_decompress.rs b/encodings/fastlanes/src/delta/array/delta_decompress.rs
index f3b3868fde7..d6404dfb905 100644
--- a/encodings/fastlanes/src/delta/array/delta_decompress.rs
+++ b/encodings/fastlanes/src/delta/array/delta_decompress.rs
@@ -1,22 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use arrayref::array_mut_ref;
-use arrayref::array_ref;
+use std::mem;
+use std::mem::MaybeUninit;
+
 use fastlanes::Delta;
 use fastlanes::FastLanes;
 use fastlanes::Transpose;
-use num_traits::WrappingAdd;
+use itertools::Itertools;
 use vortex_array::ExecutionCtx;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_unsigned_integer_ptype;
-use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
 
 use crate::DeltaArray;
+use crate::bit_transpose::untranspose_validity;
+use crate::delta::array::DeltaArrayExt;
 
 pub fn delta_decompress(
     array: &DeltaArray,
@@ -28,10 +30,7 @@ pub fn delta_decompress(
     let start = array.offset();
     let end = start + array.len();
 
-    // TODO(connor): This is incorrect, we need to untranspose the validity!!!
-
-    let validity =
-        Validity::from_mask(array.deltas().validity_mask()?, array.dtype().nullability());
+    let validity = untranspose_validity(&deltas.validity()?, ctx)?;
     let validity = validity.slice(start..end)?;
 
     Ok(match_each_unsigned_integer_ptype!(deltas.ptype(), |T| {
@@ -44,53 +43,41 @@ pub fn delta_decompress(
     }))
 }
 
-// TODO(ngates): can we re-use the deltas buffer for the result? Might be tricky given the
-//  traversal ordering, but possibly doable.
 /// Performs the low-level delta decompression on primitive values.
+///
+/// All chunks must be full 1024-element chunks (deltas length must be a multiple of 1024).
 pub(crate) fn decompress_primitive<T, const LANES: usize>(bases: &[T], deltas: &[T]) -> Buffer<T>
 where
-    T: NativePType + Delta + Transpose + WrappingAdd,
+    T: NativePType + Delta + Transpose,
 {
-    // How many fastlanes vectors we will process.
-    let num_chunks = deltas.len() / 1024;
+    let (chunks, remainder) = deltas.as_chunks::<1024>();
+    debug_assert!(
+        remainder.is_empty(),
+        "deltas must be padded to a multiple of 1024"
+    );
+    // Use >= because cross-type casts (e.g. u32→u64) may produce more bases than the
+    // target LANES requires. Only the first chunks.len() * LANES bases are used.
+    assert!(bases.len() >= chunks.len() * LANES);
 
     // Allocate a result array.
     let mut output = BufferMut::with_capacity(deltas.len());
+    let (output_chunks, _) = output.spare_capacity_mut().as_chunks_mut::<1024>();
 
     // Loop over all the chunks
-    if num_chunks > 0 {
-        let mut transposed: [T; 1024] = [T::default(); 1024];
-
-        for i in 0..num_chunks {
-            let start_elem = i * 1024;
-            let chunk: &[T; 1024] = array_ref![deltas, start_elem, 1024];
-
-            // Initialize the base vector for this chunk
-            Delta::undelta::<LANES>(
-                chunk,
-                unsafe { &*(bases[i * LANES..(i + 1) * LANES].as_ptr().cast()) },
-                &mut transposed,
-            );
-
-            let output_len = output.len();
-            unsafe { output.set_len(output_len + 1024) }
-            Transpose::untranspose(&transposed, array_mut_ref![output[output_len..], 0, 1024]);
-        }
+    let mut transposed: [T; 1024] = [T::default(); 1024];
+    for ((i, chunk), output_chunk) in chunks.iter().enumerate().zip_eq(output_chunks.iter_mut()) {
+        Delta::undelta::<LANES>(
+            chunk,
+            unsafe { &*(bases[i * LANES..(i + 1) * LANES].as_ptr().cast()) },
+            &mut transposed,
+        );
+
+        Transpose::untranspose(&transposed, unsafe {
+            mem::transmute::<&mut [MaybeUninit<T>; 1024], &mut [T; 1024]>(output_chunk)
+        });
     }
-    assert_eq!(output.len() % 1024, 0);
 
-    // The remainder was encoded with scalar logic, so we need to scalar decode it.
-    let remainder_size = deltas.len() % 1024;
-    if remainder_size > 0 {
-        let chunk = &deltas[num_chunks * 1024..];
-        assert_eq!(bases.len(), num_chunks * LANES + 1);
-        let mut base_scalar = bases[num_chunks * LANES];
-        for next_diff in chunk {
-            let next = next_diff.wrapping_add(&base_scalar);
-            output.push(next);
-            base_scalar = next;
-        }
-    }
+    unsafe { output.set_len(deltas.len()) };
 
     output.freeze()
 }
diff --git a/encodings/fastlanes/src/delta/array/mod.rs b/encodings/fastlanes/src/delta/array/mod.rs
index 66e3208c926..4e96edc59ca 100644
--- a/encodings/fastlanes/src/delta/array/mod.rs
+++ b/encodings/fastlanes/src/delta/array/mod.rs
@@ -1,34 +1,46 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use fastlanes::FastLanes;
 use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::NativePType;
+use vortex_array::TypedArrayRef;
 use vortex_array::dtype::PType;
 use vortex_array::match_each_unsigned_integer_ptype;
-use vortex_array::stats::ArrayStats;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_error::VortexExpect as _;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
 
 pub mod delta_compress;
 pub mod delta_decompress;
 
+/// The base values for each block of deltas.
+pub(super) const BASES_SLOT: usize = 0;
+/// The delta-encoded values relative to the base values.
+pub(super) const DELTAS_SLOT: usize = 1;
+pub(super) const NUM_SLOTS: usize = 2;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["bases", "deltas"];
+
 /// A FastLanes-style delta-encoded array of primitive values.
 ///
-/// A [`DeltaArray`] comprises a sequence of _chunks_ each representing 1,024 delta-encoded values,
-/// except the last chunk which may represent from one to 1,024 values.
+/// A DeltaArray comprises a sequence of _chunks_ each representing exactly 1,024
+/// delta-encoded values. If the input array length is not a multiple of 1,024, the last chunk
+/// is padded with zeros to fill a complete 1,024-element chunk.
 ///
 /// # Examples
 ///
 /// ```
-/// use vortex_fastlanes::DeltaArray;
-/// let array = DeltaArray::try_from_vec(vec![1_u32, 2, 3, 5, 10, 11]).unwrap();
+/// use vortex_array::arrays::PrimitiveArray;
+/// use vortex_array::VortexSessionExecute;
+/// use vortex_array::session::ArraySession;
+/// use vortex_session::VortexSession;
+/// use vortex_fastlanes::Delta;
+///
+/// let session = VortexSession::empty().with::<ArraySession>();
+/// let primitive = PrimitiveArray::from_iter([1_u32, 2, 3, 5, 10, 11]);
+/// let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap();
 /// ```
 ///
 /// # Details
@@ -41,167 +53,50 @@ pub mod delta_decompress;
 /// 1,024 values. The `logical_len` is the number of logical values following the `offset`, which
 /// may be less than the number of physically stored values.
 ///
-/// Each chunk is stored as a vector of bases and a vector of deltas. If the chunk physically
-/// contains 1,024 values, then there are as many bases as there are _lanes_ of this type in a
-/// 1024-bit register. For example, for 64-bit values, there are 16 bases because there are 16
-/// _lanes_. Each lane is a [delta-encoding](https://en.wikipedia.org/wiki/Delta_encoding) `1024 /
-/// bit_width` long vector of values. The deltas are stored in the
+/// Each chunk is stored as a vector of bases and a vector of deltas. There are as many bases as
+/// there are _lanes_ of this type in a 1024-bit register. For example, for 64-bit values, there
+/// are 16 bases because there are 16 _lanes_. Each lane is a
+/// [delta-encoding](https://en.wikipedia.org/wiki/Delta_encoding) `1024 / bit_width` long vector
+/// of values. The deltas are stored in the
 /// [FastLanes](https://www.vldb.org/pvldb/vol16/p2132-afroozeh.pdf) order which splits the 1,024
 /// values into one contiguous sub-sequence per-lane, thus permitting delta encoding.
 ///
-/// If the chunk physically has fewer than 1,024 values, then it is stored as a traditional,
-/// non-SIMD-amenable, delta-encoded vector.
-///
 /// Note the validity is stored in the deltas array.
 #[derive(Clone, Debug)]
-pub struct DeltaArray {
+pub struct DeltaData {
     pub(super) offset: usize,
-    pub(super) len: usize,
-    pub(super) dtype: DType,
-    pub(super) bases: ArrayRef,
-    pub(super) deltas: ArrayRef,
-    pub(super) stats_set: ArrayStats,
 }
 
-impl DeltaArray {
-    // TODO(ngates): remove constructing from vec
-    pub fn try_from_vec<T: NativePType>(vec: Vec<T>) -> VortexResult<Self> {
-        Self::try_from_primitive_array(&PrimitiveArray::new(
-            Buffer::copy_from(vec),
-            Validity::NonNullable,
-        ))
-    }
-
-    pub fn try_from_primitive_array(array: &PrimitiveArray) -> VortexResult<Self> {
-        let (bases, deltas) = delta_compress::delta_compress(array)?;
-
-        Self::try_from_delta_compress_parts(bases.into_array(), deltas.into_array())
-    }
-
-    /// Create a [`DeltaArray`] from the given `bases` and `deltas` arrays.
-    /// Note the `deltas` might be nullable
-    pub fn try_from_delta_compress_parts(bases: ArrayRef, deltas: ArrayRef) -> VortexResult<Self> {
-        let logical_len = deltas.len();
-        Self::try_new(bases, deltas, 0, logical_len)
-    }
-
-    pub fn try_new(
-        bases: ArrayRef,
-        deltas: ArrayRef,
-        offset: usize,
-        logical_len: usize,
-    ) -> VortexResult<Self> {
-        if offset >= 1024 {
-            vortex_bail!("offset must be less than 1024: {}", offset);
-        }
-        if offset + logical_len > deltas.len() {
-            vortex_bail!(
-                "offset + logical_len, {} + {}, must be less than or equal to the size of deltas: {}",
-                offset,
-                logical_len,
-                deltas.len()
-            )
-        }
-        if !bases.dtype().eq_ignore_nullability(deltas.dtype()) {
-            vortex_bail!(
-                "DeltaArray: bases and deltas must have the same dtype, got {:?} and {:?}",
-                bases.dtype(),
-                deltas.dtype()
-            );
-        }
-        let DType::Primitive(ptype, _) = bases.dtype().clone() else {
-            vortex_bail!(
-                "DeltaArray: dtype must be an integer, got {}",
-                bases.dtype()
-            );
-        };
-
-        if !ptype.is_int() {
-            vortex_bail!("DeltaArray: ptype must be an integer, got {}", ptype);
-        }
-
-        let lanes = lane_count(ptype);
-
-        if deltas.len().is_multiple_of(1024) != bases.len().is_multiple_of(lanes) {
-            vortex_bail!(
-                "deltas length ({}) is a multiple of 1024 iff bases length ({}) is a multiple of LANES ({})",
-                deltas.len(),
-                bases.len(),
-                lanes,
-            );
-        }
-
-        // SAFETY: validation done above
-        Ok(unsafe { Self::new_unchecked(bases, deltas, offset, logical_len) })
-    }
-
-    pub(crate) unsafe fn new_unchecked(
-        bases: ArrayRef,
-        deltas: ArrayRef,
-        offset: usize,
-        logical_len: usize,
-    ) -> Self {
-        Self {
-            offset,
-            len: logical_len,
-            dtype: bases.dtype().with_nullability(deltas.dtype().nullability()),
-            bases,
-            deltas,
-            stats_set: Default::default(),
-        }
-    }
-
-    #[inline]
-    pub fn bases(&self) -> &ArrayRef {
-        &self.bases
-    }
-
-    #[inline]
-    pub fn deltas(&self) -> &ArrayRef {
-        &self.deltas
-    }
-
-    #[inline]
-    pub(crate) fn lanes(&self) -> usize {
-        let ptype =
-            PType::try_from(self.dtype()).vortex_expect("DeltaArray DType must be primitive");
-        lane_count(ptype)
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len
+impl Display for DeltaData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "offset: {}", self.offset)
     }
+}
 
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
+pub trait DeltaArrayExt: TypedArrayRef<crate::Delta> {
+    fn bases(&self) -> &ArrayRef {
+        self.as_ref().slots()[BASES_SLOT]
+            .as_ref()
+            .vortex_expect("DeltaArray bases slot")
     }
 
-    #[inline]
-    pub fn dtype(&self) -> &DType {
-        &self.dtype
+    fn deltas(&self) -> &ArrayRef {
+        self.as_ref().slots()[DELTAS_SLOT]
+            .as_ref()
+            .vortex_expect("DeltaArray deltas slot")
     }
 
-    #[inline]
-    /// The logical offset into the first chunk of [`Self::deltas`].
-    pub fn offset(&self) -> usize {
+    fn offset(&self) -> usize {
         self.offset
     }
+}
 
-    #[inline]
-    pub(crate) fn bases_len(&self) -> usize {
-        self.bases.len()
-    }
-
-    #[inline]
-    pub(crate) fn deltas_len(&self) -> usize {
-        self.deltas.len()
-    }
+impl<T: TypedArrayRef<crate::Delta>> DeltaArrayExt for T {}
 
-    #[inline]
-    pub(crate) fn stats_set(&self) -> &ArrayStats {
-        &self.stats_set
+impl DeltaData {
+    pub fn try_new(offset: usize) -> VortexResult<Self> {
+        vortex_ensure!(offset < 1024, "offset must be less than 1024: {offset}");
+        Ok(Self { offset })
     }
 }
 
diff --git a/encodings/fastlanes/src/delta/compute/cast.rs b/encodings/fastlanes/src/delta/compute/cast.rs
index 52d3803f1c2..4beb558dca0 100644
--- a/encodings/fastlanes/src/delta/compute/cast.rs
+++ b/encodings/fastlanes/src/delta/compute/cast.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
@@ -10,11 +11,10 @@ use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::delta::DeltaArray;
-use crate::delta::DeltaVTable;
-
-impl CastReduce for DeltaVTable {
-    fn cast(array: &DeltaArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::delta::Delta;
+use crate::delta::array::DeltaArrayExt;
+impl CastReduce for Delta {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Delta encoding stores differences between consecutive values, which requires
         // unsigned integers to avoid overflow issues. Signed integers could produce
         // negative deltas that wouldn't fit in the unsigned delta representation.
@@ -36,16 +36,20 @@ impl CastReduce for DeltaVTable {
         let casted_bases = array.bases().cast(dtype.with_nullability(NonNullable))?;
         let casted_deltas = array.deltas().cast(dtype.clone())?;
 
-        // Create a new DeltaArray with the casted components
+        // Create a new DeltaArray with the casted components, preserving offset and logical length
         Ok(Some(
-            DeltaArray::try_from_delta_compress_parts(casted_bases, casted_deltas)?.into_array(),
+            Delta::try_new(casted_bases, casted_deltas, array.offset(), array.len())?.into_array(),
         ))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
@@ -53,20 +57,23 @@ mod tests {
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
-    use vortex_buffer::Buffer;
+    use vortex_array::session::ArraySession;
+    use vortex_buffer::buffer;
+    use vortex_session::VortexSession;
 
-    use crate::delta::DeltaArray;
+    use crate::Delta;
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
     #[test]
     fn test_cast_delta_u8_to_u32() {
-        let primitive = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u8, 20, 30, 40, 50]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        let array = DeltaArray::try_from_primitive_array(&primitive).unwrap();
+        let primitive = PrimitiveArray::from_iter([10u8, 20, 30, 40, 50]);
+        let array =
+            Delta::try_from_primitive_array(&primitive, &mut SESSION.create_execution_ctx())
+                .unwrap();
 
         let casted = array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -83,13 +90,14 @@ mod tests {
         // DeltaArray doesn't support nullable arrays - the validity is handled at the DeltaArray level
         // Create a non-nullable array and then add validity to the DeltaArray
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![100u16, 0, 200, 300, 0]),
+            buffer![100u16, 0, 200, 300, 0],
             vortex_array::validity::Validity::NonNullable,
         );
-        let array = DeltaArray::try_from_primitive_array(&values).unwrap();
+        let array =
+            Delta::try_from_primitive_array(&values, &mut SESSION.create_execution_ctx()).unwrap();
 
         let casted = array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -101,30 +109,32 @@ mod tests {
     #[rstest]
     #[case::u8(
         PrimitiveArray::new(
-            Buffer::copy_from(vec![0u8, 10, 20, 30, 40, 50]),
+            buffer![0u8, 10, 20, 30, 40, 50],
             vortex_array::validity::Validity::NonNullable,
         )
     )]
     #[case::u16(
         PrimitiveArray::new(
-            Buffer::copy_from(vec![0u16, 100, 200, 300, 400, 500]),
+            buffer![0u16, 100, 200, 300, 400, 500],
             vortex_array::validity::Validity::NonNullable,
         )
     )]
     #[case::u32(
         PrimitiveArray::new(
-            Buffer::copy_from(vec![0u32, 1000, 2000, 3000, 4000]),
+            buffer![0u32, 1000, 2000, 3000, 4000],
             vortex_array::validity::Validity::NonNullable,
         )
     )]
     #[case::u64(
         PrimitiveArray::new(
-            Buffer::copy_from(vec![0u64, 10000, 20000, 30000]),
+            buffer![0u64, 10000, 20000, 30000],
             vortex_array::validity::Validity::NonNullable,
         )
     )]
     fn test_cast_delta_conformance(#[case] primitive: PrimitiveArray) {
-        let delta_array = DeltaArray::try_from_primitive_array(&primitive).unwrap();
-        test_cast_conformance(delta_array.as_ref());
+        let delta_array =
+            Delta::try_from_primitive_array(&primitive, &mut SESSION.create_execution_ctx())
+                .unwrap();
+        test_cast_conformance(&delta_array.into_array());
     }
 }
diff --git a/encodings/fastlanes/src/delta/mod.rs b/encodings/fastlanes/src/delta/mod.rs
index 3a8e08bbde5..52ea9b33574 100644
--- a/encodings/fastlanes/src/delta/mod.rs
+++ b/encodings/fastlanes/src/delta/mod.rs
@@ -2,10 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::DeltaArray;
+pub use array::DeltaData;
 pub use array::delta_compress::delta_compress;
 
 mod compute;
 
 mod vtable;
-pub use vtable::DeltaVTable;
+pub use vtable::Delta;
+pub use vtable::DeltaArray;
diff --git a/encodings/fastlanes/src/delta/vtable/array.rs b/encodings/fastlanes/src/delta/vtable/array.rs
deleted file mode 100644
index 9232edf4137..00000000000
--- a/encodings/fastlanes/src/delta/vtable/array.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use vortex_array::ArrayEq;
-use vortex_array::ArrayHash;
-use vortex_array::Precision;
-use vortex_array::dtype::DType;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable::BaseArrayVTable;
-
-use super::DeltaVTable;
-use crate::DeltaArray;
-
-impl BaseArrayVTable<DeltaVTable> for DeltaVTable {
-    fn len(array: &DeltaArray) -> usize {
-        array.len()
-    }
-
-    fn dtype(array: &DeltaArray) -> &DType {
-        array.dtype()
-    }
-
-    fn stats(array: &DeltaArray) -> StatsSetRef<'_> {
-        array.stats_set().to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &DeltaArray, state: &mut H, precision: Precision) {
-        array.offset().hash(state);
-        array.len().hash(state);
-        array.dtype().hash(state);
-        array.bases().array_hash(state, precision);
-        array.deltas().array_hash(state, precision);
-    }
-
-    fn array_eq(array: &DeltaArray, other: &DeltaArray, precision: Precision) -> bool {
-        array.offset() == other.offset()
-            && array.len() == other.len()
-            && array.dtype() == other.dtype()
-            && array.bases().array_eq(other.bases(), precision)
-            && array.deltas().array_eq(other.deltas(), precision)
-    }
-}
diff --git a/encodings/fastlanes/src/delta/vtable/mod.rs b/encodings/fastlanes/src/delta/vtable/mod.rs
index 32cac653c1b..e74243b4050 100644
--- a/encodings/fastlanes/src/delta/vtable/mod.rs
+++ b/encodings/fastlanes/src/delta/vtable/mod.rs
@@ -1,37 +1,51 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hash;
+use std::hash::Hasher;
+
 use fastlanes::FastLanes;
 use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::ProstMetadata;
+use vortex_array::Precision;
+use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::PType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityVTableFromChildSliceHelper;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::DeltaArray;
+use crate::DeltaData;
+use crate::delta::array::BASES_SLOT;
+use crate::delta::array::DELTAS_SLOT;
+use crate::delta::array::DeltaArrayExt;
+use crate::delta::array::SLOT_NAMES;
 use crate::delta::array::delta_decompress::delta_decompress;
+use crate::delta::array::lane_count;
 
-mod array;
 mod operations;
 mod rules;
 mod slice;
 mod validity;
-mod visitor;
 
-vtable!(Delta);
+/// A [`Delta`]-encoded Vortex array.
+pub type DeltaArray = Array<Delta>;
 
 #[derive(Clone, prost::Message)]
 #[repr(C)]
@@ -42,80 +56,107 @@ pub struct DeltaMetadata {
     offset: u32, // must be <1024
 }
 
-impl VTable for DeltaVTable {
-    type Array = DeltaArray;
+impl ArrayHash for DeltaData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.offset.hash(state);
+    }
+}
+
+impl ArrayEq for DeltaData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.offset == other.offset
+    }
+}
 
-    type Metadata = ProstMetadata<DeltaMetadata>;
+impl VTable for Delta {
+    type ArrayData = DeltaData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromChildSliceHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn reduce_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>> {
-        rules::RULES.evaluate(array, parent, child_idx)
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let bases = slots[BASES_SLOT]
+            .as_ref()
+            .vortex_expect("DeltaArray bases slot");
+        let deltas = slots[DELTAS_SLOT]
+            .as_ref()
+            .vortex_expect("DeltaArray deltas slot");
+        validate_parts(bases, deltas, data.offset, dtype, len)
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // DeltaArray children order (from visit_children):
-        // 1. bases
-        // 2. deltas
-
-        vortex_ensure!(
-            children.len() == 2,
-            "Expected 2 children for Delta encoding, got {}",
-            children.len()
-        );
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
 
-        array.bases = children[0].clone();
-        array.deltas = children[1].clone();
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("DeltaArray buffer index {idx} out of bounds")
+    }
 
-        Ok(())
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn metadata(array: &DeltaArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DeltaMetadata {
-            deltas_len: array.deltas().len() as u64,
-            offset: array.offset() as u32,
-        }))
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        rules::RULES.evaluate(array, parent, child_idx)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DeltaMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            DeltaMetadata {
+                deltas_len: array.deltas().len() as u64,
+                offset: array.offset() as u32,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
+        metadata: &[u8],
+        buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<DeltaArray> {
-        assert_eq!(children.len(), 2);
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_ensure!(
+            buffers.is_empty(),
+            "DeltaArray expects 0 buffers, got {}",
+            buffers.len()
+        );
+        vortex_ensure!(
+            children.len() == 2,
+            "DeltaArray expects 2 children, got {}",
+            children.len()
+        );
+        let metadata = DeltaMetadata::decode(metadata)?;
         let ptype = PType::try_from(dtype)?;
         let lanes = match_each_unsigned_integer_ptype!(ptype, |T| { <T as FastLanes>::LANES });
 
         // Compute the length of the bases array
-        let deltas_len = usize::try_from(metadata.0.deltas_len)
-            .map_err(|_| vortex_err!("deltas_len {} overflowed usize", metadata.0.deltas_len))?;
+        let deltas_len = usize::try_from(metadata.deltas_len)
+            .map_err(|_| vortex_err!("deltas_len {} overflowed usize", metadata.deltas_len))?;
         let num_chunks = deltas_len / 1024;
         let remainder_base_size = if deltas_len % 1024 > 0 { 1 } else { 0 };
         let bases_len = num_chunks * lanes + remainder_base_size;
@@ -123,37 +164,110 @@ impl VTable for DeltaVTable {
         let bases = children.get(0, dtype, bases_len)?;
         let deltas = children.get(1, dtype, deltas_len)?;
 
-        DeltaArray::try_new(bases, deltas, metadata.0.offset as usize, len)
+        let data = DeltaData::try_new(metadata.offset as usize)?;
+        let slots = vec![Some(bases), Some(deltas)];
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(delta_decompress(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            delta_decompress(&array, ctx)?.into_array(),
+        ))
     }
 }
 
-#[derive(Debug)]
-pub struct DeltaVTable;
+#[derive(Clone, Debug)]
+pub struct Delta;
 
-impl DeltaVTable {
+impl Delta {
     pub const ID: ArrayId = ArrayId::new_ref("fastlanes.delta");
+
+    pub fn try_new(
+        bases: ArrayRef,
+        deltas: ArrayRef,
+        offset: usize,
+        len: usize,
+    ) -> VortexResult<DeltaArray> {
+        let dtype = bases.dtype().with_nullability(deltas.dtype().nullability());
+        let data = DeltaData::try_new(offset)?;
+        let slots = vec![Some(bases), Some(deltas)];
+        Array::try_from_parts(ArrayParts::new(Delta, dtype, len, data).with_slots(slots))
+    }
+
+    /// Compress a primitive array using Delta encoding.
+    pub fn try_from_primitive_array(
+        array: &PrimitiveArray,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<DeltaArray> {
+        let logical_len = array.len();
+        let (bases, deltas) = crate::delta::array::delta_compress::delta_compress(array, ctx)?;
+        Self::try_new(bases.into_array(), deltas.into_array(), 0, logical_len)
+    }
+}
+
+fn validate_parts(
+    bases: &ArrayRef,
+    deltas: &ArrayRef,
+    offset: usize,
+    dtype: &DType,
+    len: usize,
+) -> VortexResult<()> {
+    vortex_ensure!(
+        offset + len <= deltas.len(),
+        "offset + len, {offset} + {len}, must be less than or equal to the size of deltas: {}",
+        deltas.len()
+    );
+    vortex_ensure!(
+        bases.dtype().eq_ignore_nullability(deltas.dtype()),
+        "DeltaArray: bases and deltas must have the same dtype, got {} and {}",
+        bases.dtype(),
+        deltas.dtype()
+    );
+
+    vortex_ensure!(
+        bases.dtype().is_unsigned_int(),
+        "DeltaArray: dtype must be an unsigned integer, got {}",
+        bases.dtype()
+    );
+
+    let expected_dtype = bases.dtype().with_nullability(deltas.dtype().nullability());
+    vortex_ensure!(
+        dtype == &expected_dtype,
+        "DeltaArray dtype mismatch: expected {expected_dtype}, got {dtype}"
+    );
+
+    let lanes = lane_count(bases.dtype().as_ptype());
+
+    vortex_ensure!(
+        deltas.len().is_multiple_of(1024),
+        "deltas length ({}) must be a multiple of 1024",
+        deltas.len(),
+    );
+    vortex_ensure!(
+        bases.len().is_multiple_of(lanes),
+        "bases length ({}) must be a multiple of LANES ({lanes})",
+        bases.len(),
+    );
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
+    use prost::Message;
     use vortex_array::test_harness::check_metadata;
 
     use super::DeltaMetadata;
-    use super::ProstMetadata;
 
     #[cfg_attr(miri, ignore)]
     #[test]
     fn test_delta_metadata() {
         check_metadata(
             "delta.metadata",
-            ProstMetadata(DeltaMetadata {
+            &DeltaMetadata {
                 offset: u32::MAX,
                 deltas_len: u64::MAX,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/fastlanes/src/delta/vtable/operations.rs b/encodings/fastlanes/src/delta/vtable/operations.rs
index 06cb41b9e5f..731588a67bb 100644
--- a/encodings/fastlanes/src/delta/vtable/operations.rs
+++ b/encodings/fastlanes/src/delta/vtable/operations.rs
@@ -1,35 +1,57 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexResult;
 
-use super::DeltaVTable;
-use crate::DeltaArray;
-
-impl OperationsVTable<DeltaVTable> for DeltaVTable {
-    fn scalar_at(array: &DeltaArray, index: usize) -> VortexResult<Scalar> {
-        let decompressed = array.slice(index..index + 1)?.to_primitive();
-        decompressed.scalar_at(0)
+use super::Delta;
+impl OperationsVTable<Delta> for Delta {
+    fn scalar_at(
+        array: ArrayView<'_, Delta>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        let decompressed = array.array().slice(index..index + 1)?.to_primitive();
+        decompressed.into_array().scalar_at(0)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_session::VortexSession;
 
+    use crate::Delta;
     use crate::DeltaArray;
 
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    fn da(array: &PrimitiveArray) -> DeltaArray {
+        Delta::try_from_primitive_array(array, &mut SESSION.create_execution_ctx())
+            .vortex_expect("Delta array construction should succeed")
+    }
+
     #[test]
     fn test_slice_non_jagged_array_first_chunk_of_two() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let actual = delta.slice(10..250).unwrap();
         let expected = PrimitiveArray::from_iter(10u32..250).into_array();
@@ -38,7 +60,7 @@ mod tests {
 
     #[test]
     fn test_slice_non_jagged_array_second_chunk_of_two() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let actual = delta.slice(1024 + 10..1024 + 250).unwrap();
         let expected = PrimitiveArray::from_iter((1024 + 10u32)..(1024 + 250)).into_array();
@@ -47,7 +69,7 @@ mod tests {
 
     #[test]
     fn test_slice_non_jagged_array_span_two_chunks_chunk_of_two() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let actual = delta.slice(1000..1048).unwrap();
         let expected = PrimitiveArray::from_iter(1000u32..1048).into_array();
@@ -56,7 +78,7 @@ mod tests {
 
     #[test]
     fn test_slice_non_jagged_array_span_two_chunks_chunk_of_four() {
-        let delta = DeltaArray::try_from_vec((0u32..4096).collect()).unwrap();
+        let delta = da(&(0u32..4096).collect());
 
         let actual = delta.slice(2040..2050).unwrap();
         let expected = PrimitiveArray::from_iter(2040u32..2050).into_array();
@@ -65,7 +87,7 @@ mod tests {
 
     #[test]
     fn test_slice_non_jagged_array_whole() {
-        let delta = DeltaArray::try_from_vec((0u32..4096).collect()).unwrap();
+        let delta = da(&(0u32..4096).collect());
 
         let actual = delta.slice(0..4096).unwrap();
         let expected = PrimitiveArray::from_iter(0u32..4096).into_array();
@@ -74,7 +96,7 @@ mod tests {
 
     #[test]
     fn test_slice_non_jagged_array_empty() {
-        let delta = DeltaArray::try_from_vec((0u32..4096).collect()).unwrap();
+        let delta = da(&(0u32..4096).collect());
 
         let actual = delta.slice(0..0).unwrap();
         let expected = PrimitiveArray::from_iter(Vec::<u32>::new()).into_array();
@@ -91,7 +113,7 @@ mod tests {
 
     #[test]
     fn test_slice_jagged_array_second_chunk_of_two() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect()).unwrap();
+        let delta = da(&(0u32..2000).collect());
 
         let actual = delta.slice(1024 + 10..1024 + 250).unwrap();
         let expected = PrimitiveArray::from_iter((1024 + 10u32)..(1024 + 250)).into_array();
@@ -100,7 +122,7 @@ mod tests {
 
     #[test]
     fn test_slice_jagged_array_empty() {
-        let delta = DeltaArray::try_from_vec((0u32..4000).collect()).unwrap();
+        let delta = da(&(0u32..4000).collect());
 
         let actual = delta.slice(0..0).unwrap();
         let expected = PrimitiveArray::from_iter(Vec::<u32>::new()).into_array();
@@ -117,7 +139,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_of_non_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let sliced = delta.slice(10..1013).unwrap();
         let sliced_again = sliced.slice(0..2).unwrap();
@@ -128,7 +150,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_of_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect()).unwrap();
+        let delta = da(&(0u32..2000).collect());
 
         let sliced = delta.slice(10..1013).unwrap();
         let sliced_again = sliced.slice(0..2).unwrap();
@@ -139,7 +161,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_second_chunk_of_non_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let sliced = delta.slice(1034..1050).unwrap();
         let sliced_again = sliced.slice(0..2).unwrap();
@@ -150,7 +172,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_second_chunk_of_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect()).unwrap();
+        let delta = da(&(0u32..2000).collect());
 
         let sliced = delta.slice(1034..1050).unwrap();
         let sliced_again = sliced.slice(0..2).unwrap();
@@ -161,7 +183,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_spanning_two_chunks_of_non_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect()).unwrap();
+        let delta = da(&(0u32..2048).collect());
 
         let sliced = delta.slice(1010..1050).unwrap();
         let sliced_again = sliced.slice(5..20).unwrap();
@@ -172,7 +194,7 @@ mod tests {
 
     #[test]
     fn test_slice_of_slice_spanning_two_chunks_of_jagged() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect()).unwrap();
+        let delta = da(&(0u32..2000).collect());
 
         let sliced = delta.slice(1010..1050).unwrap();
         let sliced_again = sliced.slice(5..20).unwrap();
@@ -183,9 +205,7 @@ mod tests {
 
     #[test]
     fn test_scalar_at_non_jagged_array() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect())
-            .unwrap()
-            .into_array();
+        let delta = da(&(0u32..2048).collect()).into_array();
 
         let expected = PrimitiveArray::from_iter(0u32..2048).into_array();
         assert_arrays_eq!(delta, expected);
@@ -194,16 +214,12 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_scalar_at_non_jagged_array_oob() {
-        let delta = DeltaArray::try_from_vec((0u32..2048).collect())
-            .unwrap()
-            .into_array();
+        let delta = da(&(0u32..2048).collect()).into_array();
         delta.scalar_at(2048).unwrap();
     }
     #[test]
     fn test_scalar_at_jagged_array() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect())
-            .unwrap()
-            .into_array();
+        let delta = da(&(0u32..2000).collect()).into_array();
 
         let expected = PrimitiveArray::from_iter(0u32..2000).into_array();
         assert_arrays_eq!(delta, expected);
@@ -212,32 +228,30 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_scalar_at_jagged_array_oob() {
-        let delta = DeltaArray::try_from_vec((0u32..2000).collect())
-            .unwrap()
-            .into_array();
+        let delta = da(&(0u32..2000).collect()).into_array();
         delta.scalar_at(2000).unwrap();
     }
 
     #[rstest]
     // Basic delta arrays
-    #[case::delta_u32(DeltaArray::try_from_vec((0u32..100).collect()).unwrap())]
-    #[case::delta_u64(DeltaArray::try_from_vec((0..100).map(|i| i as u64 * 10).collect()).unwrap())]
+    #[case::delta_u32((0u32..100).collect())]
+    #[case::delta_u64((0..100).map(|i| i as u64 * 10).collect())]
     // Large arrays (multiple chunks)
-    #[case::delta_large_u32(DeltaArray::try_from_vec((0u32..2048).collect()).unwrap())]
-    #[case::delta_large_u64(DeltaArray::try_from_vec((0u64..2048).collect()).unwrap())]
+    #[case::delta_large_u32((0u32..2048).collect())]
+    #[case::delta_large_u64((0u64..2048).collect())]
     // Single element
-    #[case::delta_single(DeltaArray::try_from_vec(vec![42u32]).unwrap())]
-    fn test_delta_consistency(#[case] array: DeltaArray) {
-        test_array_consistency(array.as_ref());
+    #[case::delta_single(PrimitiveArray::new(buffer![42u32], Validity::NonNullable))]
+    fn test_delta_consistency(#[case] array: PrimitiveArray) {
+        test_array_consistency(&da(&array).into_array());
     }
 
     #[rstest]
-    #[case::delta_u8_basic(DeltaArray::try_from_vec(vec![1u8, 1, 1, 1, 1]).unwrap())]
-    #[case::delta_u16_basic(DeltaArray::try_from_vec(vec![1u16, 1, 1, 1, 1]).unwrap())]
-    #[case::delta_u32_basic(DeltaArray::try_from_vec(vec![1u32, 1, 1, 1, 1]).unwrap())]
-    #[case::delta_u64_basic(DeltaArray::try_from_vec(vec![1u64, 1, 1, 1, 1]).unwrap())]
-    #[case::delta_u32_large(DeltaArray::try_from_vec(vec![1u32; 100]).unwrap())]
-    fn test_delta_binary_numeric(#[case] array: DeltaArray) {
-        test_binary_numeric_array(array.into_array());
+    #[case::delta_u8_basic(PrimitiveArray::new(buffer![1u8, 1, 1, 1, 1], Validity::NonNullable))]
+    #[case::delta_u16_basic(PrimitiveArray::new(buffer![1u16, 1, 1, 1, 1], Validity::NonNullable))]
+    #[case::delta_u32_basic(PrimitiveArray::new(buffer![1u32, 1, 1, 1, 1], Validity::NonNullable))]
+    #[case::delta_u64_basic(PrimitiveArray::new(buffer![1u64, 1, 1, 1, 1], Validity::NonNullable))]
+    #[case::delta_u32_large(PrimitiveArray::new(buffer![1u32; 100], Validity::NonNullable))]
+    fn test_delta_binary_numeric(#[case] array: PrimitiveArray) {
+        test_binary_numeric_array(da(&array).into_array());
     }
 }
diff --git a/encodings/fastlanes/src/delta/vtable/rules.rs b/encodings/fastlanes/src/delta/vtable/rules.rs
index 47dd4da51eb..d6892897ab5 100644
--- a/encodings/fastlanes/src/delta/vtable/rules.rs
+++ b/encodings/fastlanes/src/delta/vtable/rules.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::delta::vtable::DeltaVTable;
+use crate::delta::vtable::Delta;
 
-pub(crate) static RULES: ParentRuleSet<DeltaVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&SliceReduceAdaptor(DeltaVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(DeltaVTable)),
+pub(crate) static RULES: ParentRuleSet<Delta> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&SliceReduceAdaptor(Delta)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Delta)),
 ]);
diff --git a/encodings/fastlanes/src/delta/vtable/slice.rs b/encodings/fastlanes/src/delta/vtable/slice.rs
index b5d61a386af..17b088dac92 100644
--- a/encodings/fastlanes/src/delta/vtable/slice.rs
+++ b/encodings/fastlanes/src/delta/vtable/slice.rs
@@ -5,15 +5,17 @@ use std::cmp::min;
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::DeltaArray;
-use crate::delta::vtable::DeltaVTable;
+use crate::delta::array::DeltaArrayExt;
+use crate::delta::array::lane_count;
+use crate::delta::vtable::Delta;
 
-impl SliceReduce for DeltaVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Delta {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let physical_start = range.start + array.offset();
         let physical_stop = range.end + array.offset();
 
@@ -22,20 +24,16 @@ impl SliceReduce for DeltaVTable {
 
         let bases = array.bases();
         let deltas = array.deltas();
-        let lanes = array.lanes();
+        let lanes = lane_count(array.dtype().as_ptype());
 
-        let new_bases = bases.slice(
-            min(start_chunk * lanes, array.bases_len())..min(stop_chunk * lanes, array.bases_len()),
-        )?;
+        let new_bases = bases
+            .slice(min(start_chunk * lanes, bases.len())..min(stop_chunk * lanes, bases.len()))?;
 
-        let new_deltas = deltas.slice(
-            min(start_chunk * 1024, array.deltas_len())..min(stop_chunk * 1024, array.deltas_len()),
-        )?;
+        let new_deltas = deltas
+            .slice(min(start_chunk * 1024, deltas.len())..min(stop_chunk * 1024, deltas.len()))?;
 
-        // SAFETY: slicing valid bases/deltas preserves correctness
-        Ok(Some(unsafe {
-            DeltaArray::new_unchecked(new_bases, new_deltas, physical_start % 1024, range.len())
-                .into_array()
-        }))
+        Ok(Some(
+            Delta::try_new(new_bases, new_deltas, physical_start % 1024, range.len())?.into_array(),
+        ))
     }
 }
diff --git a/encodings/fastlanes/src/delta/vtable/validity.rs b/encodings/fastlanes/src/delta/vtable/validity.rs
index 71b930025c6..d6a87ff5956 100644
--- a/encodings/fastlanes/src/delta/vtable/validity.rs
+++ b/encodings/fastlanes/src/delta/vtable/validity.rs
@@ -1,14 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::ArrayRef;
-use vortex_array::vtable::ValidityChildSliceHelper;
+use vortex_array::ArrayView;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::VortexSessionExecute;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::ValidityVTable;
+use vortex_error::VortexResult;
 
-use crate::DeltaArray;
+use crate::Delta;
+use crate::bit_transpose::untranspose_validity;
+use crate::delta::array::DeltaArrayExt;
 
-impl ValidityChildSliceHelper for DeltaArray {
-    fn unsliced_child_and_slice(&self) -> (&ArrayRef, usize, usize) {
-        let (start, len) = (self.offset(), self.len());
-        (self.deltas(), start, start + len)
+impl ValidityVTable<Delta> for Delta {
+    fn validity(array: ArrayView<'_, Delta>) -> VortexResult<Validity> {
+        let start = array.offset();
+        let end = start + array.len();
+
+        let validity = untranspose_validity(
+            &array.deltas().validity()?,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        validity.slice(start..end)
     }
 }
diff --git a/encodings/fastlanes/src/delta/vtable/visitor.rs b/encodings/fastlanes/src/delta/vtable/visitor.rs
deleted file mode 100644
index 66979b6d552..00000000000
--- a/encodings/fastlanes/src/delta/vtable/visitor.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
-use vortex_array::vtable::VisitorVTable;
-
-use super::DeltaVTable;
-use crate::DeltaArray;
-
-impl VisitorVTable<DeltaVTable> for DeltaVTable {
-    fn visit_buffers(_array: &DeltaArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &DeltaArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &DeltaArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("bases", array.bases());
-        visitor.visit_child("deltas", array.deltas());
-    }
-
-    fn nchildren(_array: &DeltaArray) -> usize {
-        2
-    }
-}
diff --git a/encodings/fastlanes/src/for/array/for_compress.rs b/encodings/fastlanes/src/for/array/for_compress.rs
index 66853a14e91..266e6306a9c 100644
--- a/encodings/fastlanes/src/for/array/for_compress.rs
+++ b/encodings/fastlanes/src/for/array/for_compress.rs
@@ -8,16 +8,16 @@ use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::expr::stats::Stat;
 use vortex_array::match_each_integer_ptype;
-use vortex_array::stats::ArrayStats;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
+use crate::FoR;
 use crate::FoRArray;
-
-impl FoRArray {
+use crate::FoRData;
+impl FoRData {
     pub fn encode(array: PrimitiveArray) -> VortexResult<FoRArray> {
-        let stats = ArrayStats::from(array.statistics().to_owned());
-        let min = array
+        let array_ref = array.clone().into_array();
+        let min = array_ref
             .statistics()
             .compute_stat(Stat::Min)?
             .ok_or_else(|| vortex_err!("Min stat not found"))?;
@@ -25,12 +25,7 @@ impl FoRArray {
         let encoded = match_each_integer_ptype!(array.ptype(), |T| {
             compress_primitive::<T>(array, T::try_from(&min)?)?.into_array()
         });
-        let for_array = FoRArray::try_new(encoded, min)?;
-        for_array
-            .stats_set()
-            .to_ref(for_array.as_ref())
-            .inherit_from(stats.to_ref(for_array.as_ref()));
-        Ok(for_array)
+        FoR::try_new(encoded, min)
     }
 }
 
@@ -40,13 +35,14 @@ fn compress_primitive<T: NativePType + WrappingSub + PrimInt>(
 ) -> VortexResult<PrimitiveArray> {
     // Set null values to the min value, ensuring that decompress into a value in the primitive
     // range (and stop them wrapping around).
-    parray.map_each_with_validity::<T, _, _>(|(v, bool)| {
+    let encoded = parray.map_each_with_validity::<T, _, _>(|(v, bool)| {
         if bool {
             v.wrapping_sub(&min)
         } else {
             T::zero()
         }
-    })
+    })?;
+    Ok(encoded)
 }
 
 #[cfg(test)]
@@ -54,9 +50,9 @@ mod test {
     use std::sync::LazyLock;
 
     use itertools::Itertools;
-    use vortex_array::Array;
     use vortex_array::ToCanonical;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::primitive::PrimitiveArrayExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::PType;
     use vortex_array::expr::stats::StatsProvider;
@@ -67,7 +63,8 @@ mod test {
     use vortex_session::VortexSession;
 
     use super::*;
-    use crate::BitPackedArray;
+    use crate::BitPackedData;
+    use crate::r#for::array::FoRArrayExt;
     use crate::r#for::array::for_decompress::decompress;
     use crate::r#for::array::for_decompress::fused_decompress;
 
@@ -80,7 +77,7 @@ mod test {
             (1i32..10).collect::<vortex_buffer::Buffer<_>>(),
             Validity::NonNullable,
         );
-        let compressed = FoRArray::encode(array.clone()).unwrap();
+        let compressed = FoRData::encode(array.clone()).unwrap();
         assert_eq!(i32::try_from(compressed.reference_scalar()).unwrap(), 1);
 
         assert_arrays_eq!(compressed, array);
@@ -95,7 +92,7 @@ mod test {
                 .collect::<vortex_buffer::Buffer<_>>(),
             Validity::NonNullable,
         );
-        let compressed = FoRArray::encode(array).unwrap();
+        let compressed = FoRData::encode(array).unwrap();
         assert_eq!(
             u32::try_from(compressed.reference_scalar()).unwrap(),
             1_000_000u32
@@ -108,7 +105,7 @@ mod test {
         assert_eq!(array.statistics().len(), 0);
 
         let dtype = array.dtype().clone();
-        let compressed = FoRArray::encode(array).unwrap();
+        let compressed = FoRData::encode(array).unwrap();
         assert_eq!(compressed.reference_scalar().dtype(), &dtype);
         assert!(compressed.reference_scalar().dtype().is_signed_int());
         assert!(compressed.encoded().dtype().is_signed_int());
@@ -121,7 +118,7 @@ mod test {
     fn test_decompress() {
         // Create a range offset by a million.
         let array = PrimitiveArray::from_iter((0u32..100_000).step_by(1024).map(|v| v + 1_000_000));
-        let compressed = FoRArray::encode(array.clone()).unwrap();
+        let compressed = FoRData::encode(array.clone()).unwrap();
         assert_arrays_eq!(compressed, array);
     }
 
@@ -130,8 +127,8 @@ mod test {
         // Create a range offset by a million.
         let expect = PrimitiveArray::from_iter((0u32..1024).map(|x| x % 7 + 10));
         let array = PrimitiveArray::from_iter((0u32..1024).map(|x| x % 7));
-        let bp = BitPackedArray::encode(array.as_ref(), 3).unwrap();
-        let compressed = FoRArray::try_new(bp.into_array(), 10u32.into()).unwrap();
+        let bp = BitPackedData::encode(&array.into_array(), 3).unwrap();
+        let compressed = FoR::try_new(bp.into_array(), 10u32.into()).unwrap();
         assert_arrays_eq!(compressed, expect);
     }
 
@@ -140,10 +137,13 @@ mod test {
         // Create a range offset by a million.
         let expect = PrimitiveArray::from_iter((0u32..1024).map(|x| x % 7 + 10));
         let array = PrimitiveArray::from_iter((0u32..1024).map(|x| x % 7));
-        let bp = BitPackedArray::encode(array.as_ref(), 2).unwrap();
-        let compressed = FoRArray::try_new(bp.clone().into_array(), 10u32.into()).unwrap();
-        let decompressed =
-            fused_decompress::<u32>(&compressed, &bp, &mut SESSION.create_execution_ctx())?;
+        let bp = BitPackedData::encode(&array.into_array(), 2).unwrap();
+        let compressed = FoR::try_new(bp.clone().into_array(), 10u32.into())?;
+        let decompressed = fused_decompress::<u32>(
+            &compressed,
+            bp.as_view(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
         assert_arrays_eq!(decompressed, expect);
         Ok(())
     }
@@ -151,7 +151,7 @@ mod test {
     #[test]
     fn test_overflow() -> VortexResult<()> {
         let array = PrimitiveArray::from_iter(i8::MIN..=i8::MAX);
-        let compressed = FoRArray::encode(array.clone()).unwrap();
+        let compressed = FoRData::encode(array.clone()).unwrap();
         assert_eq!(
             i8::MIN,
             compressed
@@ -167,7 +167,7 @@ mod test {
             .reinterpret_cast(PType::U8);
         let unsigned: Vec<u8> = (0..=u8::MAX).collect_vec();
         let expected_unsigned = PrimitiveArray::from_iter(unsigned);
-        assert_arrays_eq!(encoded, expected_unsigned);
+        assert_eq!(encoded.as_slice::<u8>(), expected_unsigned.as_slice::<u8>());
 
         let decompressed = decompress(&compressed, &mut SESSION.create_execution_ctx())?;
         array
diff --git a/encodings/fastlanes/src/for/array/for_decompress.rs b/encodings/fastlanes/src/for/array/for_decompress.rs
index f7292a5a06e..e19ef8d0ff3 100644
--- a/encodings/fastlanes/src/for/array/for_decompress.rs
+++ b/encodings/fastlanes/src/for/array/for_decompress.rs
@@ -4,6 +4,7 @@
 use fastlanes::FoR;
 use num_traits::PrimInt;
 use num_traits::WrappingAdd;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builders::PrimitiveBuilder;
@@ -12,16 +13,15 @@ use vortex_array::dtype::PhysicalPType;
 use vortex_array::dtype::UnsignedPType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
-use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::BitPackedArray;
-use crate::BitPackedVTable;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
 use crate::FoRArray;
 use crate::bitpack_decompress;
+use crate::r#for::array::FoRArrayExt;
 use crate::unpack_iter::UnpackStrategy;
 use crate::unpack_iter::UnpackedChunks;
 
@@ -50,7 +50,7 @@ pub fn decompress(array: &FoRArray, ctx: &mut ExecutionCtx) -> VortexResult<Prim
 
     // Try to do fused unpack.
     if array.reference_scalar().dtype().is_unsigned_int()
-        && let Some(bp) = array.encoded().as_opt::<BitPackedVTable>()
+        && let Some(bp) = array.encoded().as_opt::<BitPacked>()
     {
         return match_each_unsigned_integer_ptype!(array.ptype(), |T| {
             fused_decompress::<T>(array, bp, ctx)
@@ -59,7 +59,7 @@ pub fn decompress(array: &FoRArray, ctx: &mut ExecutionCtx) -> VortexResult<Prim
 
     // TODO(ngates): Do we need this to be into_encoded() somehow?
     let encoded = array.encoded().clone().execute::<PrimitiveArray>(ctx)?;
-    let validity = encoded.validity().clone();
+    let validity = encoded.validity()?;
 
     Ok(match_each_integer_ptype!(ptype, |T| {
         let min = array
@@ -71,7 +71,7 @@ pub fn decompress(array: &FoRArray, ctx: &mut ExecutionCtx) -> VortexResult<Prim
             encoded
         } else {
             PrimitiveArray::new(
-                decompress_primitive(encoded.into_buffer_mut::<T>(), min),
+                decompress_primitive(encoded.into_buffer::<T>(), min),
                 validity,
             )
         }
@@ -82,7 +82,7 @@ pub(crate) fn fused_decompress<
     T: PhysicalPType<Physical = T> + UnsignedPType + FoR + WrappingAdd,
 >(
     for_: &FoRArray,
-    bp: &BitPackedArray,
+    bp: ArrayView<'_, BitPacked>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<PrimitiveArray> {
     let ref_ = for_
@@ -94,13 +94,13 @@ pub(crate) fn fused_decompress<
     let strategy = FoRStrategy { reference: ref_ };
 
     // Create [`UnpackedChunks`] with FoR strategy.
-    let mut unpacked = UnpackedChunks::new_with_strategy(
+    let mut unpacked = UnpackedChunks::try_new_with_strategy(
         strategy,
         bp.packed().as_host().clone(),
         bp.bit_width() as usize,
         bp.offset() as usize,
         bp.len(),
-    );
+    )?;
 
     let mut builder = PrimitiveBuilder::<T>::with_capacity(
         for_.reference_scalar().dtype().nullability(),
@@ -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_mask()?);
+        uninit_range.append_mask(bp.validity_mask());
     }
 
     // SAFETY: `decode_into` will initialize all values in this range.
@@ -118,7 +118,7 @@ pub(crate) fn fused_decompress<
     // Decode all chunks (initial, full, and trailer) in one call.
     unpacked.decode_into(uninit_slice);
 
-    if let Some(patches) = bp.patches() {
+    if let Some(ref patches) = bp.patches() {
         bitpack_decompress::apply_patches_to_uninit_range_fn(
             &mut uninit_range,
             patches,
@@ -137,7 +137,7 @@ pub(crate) fn fused_decompress<
 }
 
 fn decompress_primitive<T: NativePType + WrappingAdd + PrimInt>(
-    values: BufferMut<T>,
+    values: Buffer<T>,
     min: T,
 ) -> Buffer<T> {
     values
diff --git a/encodings/fastlanes/src/for/array/mod.rs b/encodings/fastlanes/src/for/array/mod.rs
index 18f4e6ee415..691888ef5da 100644
--- a/encodings/fastlanes/src/for/array/mod.rs
+++ b/encodings/fastlanes/src/for/array/mod.rs
@@ -1,70 +1,67 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use vortex_array::ArrayRef;
+use vortex_array::TypedArrayRef;
 use vortex_array::dtype::PType;
 use vortex_array::scalar::Scalar;
-use vortex_array::stats::ArrayStats;
+use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
 
 pub mod for_compress;
 pub mod for_decompress;
 
+/// The encoded array with the frame-of-reference (minimum value) subtracted.
+pub(super) const ENCODED_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["encoded"];
+
 /// Frame of Reference (FoR) encoded array.
 ///
 /// This encoding stores values as offsets from a reference value, which can significantly reduce
 /// storage requirements when values are clustered around a specific point.
 #[derive(Clone, Debug)]
-pub struct FoRArray {
-    pub(super) encoded: ArrayRef,
+pub struct FoRData {
     pub(super) reference: Scalar,
-    pub(super) stats_set: ArrayStats,
 }
 
-impl FoRArray {
-    pub fn try_new(encoded: ArrayRef, reference: Scalar) -> VortexResult<Self> {
-        if reference.is_null() {
-            vortex_bail!("Reference value cannot be null");
-        }
-        let reference = reference.cast(
-            &reference
-                .dtype()
-                .with_nullability(encoded.dtype().nullability()),
-        )?;
-
-        Ok(Self {
-            encoded,
-            reference,
-            stats_set: Default::default(),
-        })
+pub trait FoRArrayExt: TypedArrayRef<crate::FoR> {
+    fn encoded(&self) -> &ArrayRef {
+        self.as_ref().slots()[ENCODED_SLOT]
+            .as_ref()
+            .vortex_expect("FoRArray encoded slot")
     }
 
-    pub(crate) unsafe fn new_unchecked(encoded: ArrayRef, reference: Scalar) -> Self {
-        Self {
-            encoded,
-            reference,
-            stats_set: Default::default(),
-        }
+    fn reference_scalar(&self) -> &Scalar {
+        &self.reference
     }
+}
 
-    #[inline]
-    pub fn ptype(&self) -> PType {
-        self.dtype().as_ptype()
-    }
+impl<T: TypedArrayRef<crate::FoR>> FoRArrayExt for T {}
 
-    #[inline]
-    pub fn encoded(&self) -> &ArrayRef {
-        &self.encoded
+impl Display for FoRData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "reference: {}", self.reference)
     }
+}
 
-    #[inline]
-    pub fn reference_scalar(&self) -> &Scalar {
-        &self.reference
+impl FoRData {
+    pub(crate) fn try_new(reference: Scalar) -> VortexResult<Self> {
+        vortex_ensure!(!reference.is_null(), "Reference value cannot be null");
+        vortex_ensure!(
+            reference.dtype().is_int(),
+            "FoR requires an integer reference dtype, got {}",
+            reference.dtype()
+        );
+        Ok(Self { reference })
     }
 
     #[inline]
-    pub(crate) fn stats_set(&self) -> &ArrayStats {
-        &self.stats_set
+    pub fn ptype(&self) -> PType {
+        self.reference.dtype().as_ptype()
     }
 }
diff --git a/encodings/fastlanes/src/for/compute/cast.rs b/encodings/fastlanes/src/for/compute/cast.rs
index acc0cd88543..e534f3c76fa 100644
--- a/encodings/fastlanes/src/for/compute/cast.rs
+++ b/encodings/fastlanes/src/for/compute/cast.rs
@@ -2,17 +2,17 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::r#for::FoRArray;
-use crate::r#for::FoRVTable;
-
-impl CastReduce for FoRVTable {
-    fn cast(array: &FoRArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::r#for::FoR;
+use crate::r#for::array::FoRArrayExt;
+impl CastReduce for FoR {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // FoR only supports integer types
         if !dtype.is_int() {
             return Ok(None);
@@ -23,7 +23,7 @@ impl CastReduce for FoRVTable {
         let casted_reference = array.reference_scalar().cast(dtype)?;
 
         Ok(Some(
-            FoRArray::try_new(casted_child, casted_reference)?.into_array(),
+            FoR::try_new(casted_child, casted_reference)?.into_array(),
         ))
     }
 }
@@ -31,6 +31,7 @@ impl CastReduce for FoRVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
@@ -41,19 +42,24 @@ mod tests {
     use vortex_array::dtype::PType;
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
+    use crate::FoR;
     use crate::FoRArray;
 
+    fn for_arr(encoded: ArrayRef, reference: Scalar) -> FoRArray {
+        FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed")
+    }
+
     #[test]
     fn test_cast_for_i32_to_i64() {
-        let for_array = FoRArray::try_new(
+        let for_array = for_arr(
             buffer![0i32, 10, 20, 30, 40].into_array(),
             Scalar::from(100i32),
-        )
-        .unwrap();
+        );
 
         let casted = for_array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -71,10 +77,10 @@ mod tests {
     #[test]
     fn test_cast_for_nullable() {
         let values = PrimitiveArray::from_option_iter([Some(0i32), None, Some(20), Some(30), None]);
-        let for_array = FoRArray::try_new(values.into_array(), Scalar::from(50i32)).unwrap();
+        let for_array = for_arr(values.into_array(), Scalar::from(50i32));
 
         let casted = for_array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -84,23 +90,23 @@ mod tests {
     }
 
     #[rstest]
-    #[case(FoRArray::try_new(
+    #[case(for_arr(
         buffer![0i32, 1, 2, 3, 4].into_array(),
         Scalar::from(100i32)
-    ).unwrap())]
-    #[case(FoRArray::try_new(
+    ))]
+    #[case(for_arr(
         buffer![0u64, 10, 20, 30].into_array(),
         Scalar::from(1000u64)
-    ).unwrap())]
-    #[case(FoRArray::try_new(
+    ))]
+    #[case(for_arr(
         PrimitiveArray::from_option_iter([Some(0i16), None, Some(5), Some(10), None]).into_array(),
         Scalar::from(50i16)
-    ).unwrap())]
-    #[case(FoRArray::try_new(
+    ))]
+    #[case(for_arr(
         buffer![-10i32, -5, 0, 5, 10].into_array(),
         Scalar::from(-100i32)
-    ).unwrap())]
+    ))]
     fn test_cast_for_conformance(#[case] array: FoRArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/fastlanes/src/for/compute/compare.rs b/encodings/fastlanes/src/for/compute/compare.rs
index f440cebf331..e5eae1b90b0 100644
--- a/encodings/fastlanes/src/for/compute/compare.rs
+++ b/encodings/fastlanes/src/for/compute/compare.rs
@@ -4,8 +4,8 @@
 use std::ops::Shr;
 
 use num_traits::WrappingSub;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
@@ -22,13 +22,13 @@ use vortex_error::VortexError;
 use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 
-use crate::FoRArray;
-use crate::FoRVTable;
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-impl CompareKernel for FoRVTable {
+impl CompareKernel for FoR {
     fn compare(
-        lhs: &FoRArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -52,7 +52,7 @@ impl CompareKernel for FoRVTable {
 }
 
 fn compare_constant<T>(
-    lhs: &FoRArray,
+    lhs: ArrayView<'_, FoR>,
     mut rhs: T,
     nullability: Nullability,
     operator: CompareOperator,
@@ -99,24 +99,34 @@ mod tests {
     use vortex_buffer::buffer;
 
     use super::*;
+    use crate::FoR;
+    use crate::FoRArray;
+
+    fn for_arr(encoded: ArrayRef, reference: Scalar) -> FoRArray {
+        FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed")
+    }
 
     #[test]
     fn test_compare_constant() {
         let reference = Scalar::from(10);
         // 10, 30, 12
-        let lhs = FoRArray::try_new(
+        let lhs = for_arr(
             PrimitiveArray::new(buffer!(0i32, 20, 2), Validity::AllValid).into_array(),
             reference,
+        );
+
+        let result = compare_constant(
+            lhs.as_view(),
+            30i32,
+            Nullability::NonNullable,
+            CompareOperator::Eq,
         )
+        .unwrap()
         .unwrap();
-
-        let result = compare_constant(&lhs, 30i32, Nullability::NonNullable, CompareOperator::Eq)
-            .unwrap()
-            .unwrap();
         assert_arrays_eq!(result, BoolArray::from_iter([false, true, false].map(Some)));
 
         let result = compare_constant(
-            &lhs,
+            lhs.as_view(),
             12i32,
             Nullability::NonNullable,
             CompareOperator::NotEq,
@@ -132,7 +142,7 @@ mod tests {
             CompareOperator::Gte,
         ] {
             assert!(
-                compare_constant(&lhs, 30i32, Nullability::NonNullable, op)
+                compare_constant(lhs.as_view(), 30i32, Nullability::NonNullable, op)
                     .unwrap()
                     .is_none()
             );
@@ -143,24 +153,33 @@ mod tests {
     fn test_compare_nullable_constant() {
         let reference = Scalar::from(0);
         // 10, 30, 12
-        let lhs = FoRArray::try_new(
+        let lhs = for_arr(
             PrimitiveArray::new(buffer!(0i32, 20, 2), Validity::NonNullable).into_array(),
             reference,
-        )
-        .unwrap();
+        );
 
         assert_eq!(
-            compare_constant(&lhs, 30i32, Nullability::Nullable, CompareOperator::Eq)
-                .unwrap()
-                .unwrap()
-                .dtype(),
+            compare_constant(
+                lhs.as_view(),
+                30i32,
+                Nullability::Nullable,
+                CompareOperator::Eq,
+            )
+            .unwrap()
+            .unwrap()
+            .dtype(),
             &DType::Bool(Nullability::Nullable)
         );
         assert_eq!(
-            compare_constant(&lhs, 30i32, Nullability::NonNullable, CompareOperator::Eq)
-                .unwrap()
-                .unwrap()
-                .dtype(),
+            compare_constant(
+                lhs.as_view(),
+                30i32,
+                Nullability::NonNullable,
+                CompareOperator::Eq,
+            )
+            .unwrap()
+            .unwrap()
+            .dtype(),
             &DType::Bool(Nullability::NonNullable)
         );
     }
@@ -169,22 +188,26 @@ mod tests {
     fn compare_non_encodable_constant() {
         let reference = Scalar::from(10);
         // 10, 30, 12
-        let lhs = FoRArray::try_new(
+        let lhs = for_arr(
             PrimitiveArray::new(buffer!(0i32, 10, 1), Validity::AllValid).into_array(),
             reference,
+        );
+
+        let result = compare_constant(
+            lhs.as_view(),
+            -1i32,
+            Nullability::NonNullable,
+            CompareOperator::Eq,
         )
+        .unwrap()
         .unwrap();
-
-        let result = compare_constant(&lhs, -1i32, Nullability::NonNullable, CompareOperator::Eq)
-            .unwrap()
-            .unwrap();
         assert_arrays_eq!(
             result,
             BoolArray::from_iter([false, false, false].map(Some))
         );
 
         let result = compare_constant(
-            &lhs,
+            lhs.as_view(),
             -1i32,
             Nullability::NonNullable,
             CompareOperator::NotEq,
@@ -198,18 +221,17 @@ mod tests {
     fn compare_large_constant() {
         let reference = Scalar::from(-9219218377546224477i64);
         #[allow(clippy::cast_possible_truncation)]
-        let lhs = FoRArray::try_new(
+        let lhs = for_arr(
             PrimitiveArray::new(
                 buffer![0i64, 9654309310445864926u64 as i64],
                 Validity::AllValid,
             )
             .into_array(),
             reference,
-        )
-        .unwrap();
+        );
 
         let result = compare_constant(
-            &lhs,
+            lhs.as_view(),
             435090932899640449i64,
             Nullability::Nullable,
             CompareOperator::Eq,
@@ -219,7 +241,7 @@ mod tests {
         assert_arrays_eq!(result, BoolArray::from_iter([Some(false), Some(true)]));
 
         let result = compare_constant(
-            &lhs,
+            lhs.as_view(),
             435090932899640449i64,
             Nullability::Nullable,
             CompareOperator::NotEq,
diff --git a/encodings/fastlanes/src/for/compute/is_constant.rs b/encodings/fastlanes/src/for/compute/is_constant.rs
index 534daaede05..246a9c93226 100644
--- a/encodings/fastlanes/src/for/compute/is_constant.rs
+++ b/encodings/fastlanes/src/for/compute/is_constant.rs
@@ -1,20 +1,40 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::IsConstantKernel;
-use vortex_array::compute::IsConstantKernelAdapter;
-use vortex_array::compute::IsConstantOpts;
-use vortex_array::compute::is_constant_opts;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::FoRArray;
-use crate::FoRVTable;
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-impl IsConstantKernel for FoRVTable {
-    fn is_constant(&self, array: &FoRArray, opts: &IsConstantOpts) -> VortexResult<Option<bool>> {
-        is_constant_opts(array.encoded(), opts)
+/// FoR-specific is_constant kernel.
+///
+/// Delegates to checking if the encoded array is constant.
+#[derive(Debug)]
+pub(crate) struct FoRIsConstantKernel;
+
+impl DynAggregateKernel for FoRIsConstantKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
+            return Ok(None);
+        }
+
+        let Some(array) = batch.as_opt::<FoR>() else {
+            return Ok(None);
+        };
+
+        let result = is_constant(array.encoded(), ctx)?;
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
-
-register_kernel!(IsConstantKernelAdapter(FoRVTable).lift());
diff --git a/encodings/fastlanes/src/for/compute/is_sorted.rs b/encodings/fastlanes/src/for/compute/is_sorted.rs
index ed5c476c561..3b81c45c03d 100644
--- a/encodings/fastlanes/src/for/compute/is_sorted.rs
+++ b/encodings/fastlanes/src/for/compute/is_sorted.rs
@@ -1,161 +1,127 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
-use vortex_array::compute::IsSortedKernel;
-use vortex_array::compute::IsSortedKernelAdapter;
-use vortex_array::compute::is_sorted;
-use vortex_array::compute::is_strict_sorted;
-use vortex_array::register_kernel;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::fns::is_sorted::is_sorted;
+use vortex_array::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::FoRArray;
-use crate::FoRVTable;
-
-/// FoR can express sortedness directly on its encoded form.
-///
-/// If the minimum is greater than or equal to zero, subtracting it from the other values does not
-/// wrap (the value always decreases and the smallest value is zero because min - min = 0).
-///
-/// Subtraction without wrapping is order-preserving, so we only need to consider what happens to
-/// wrapped numbers.
-///
-/// Non-negative minimum values can't wrap. For a negative minimum value, wrapping means that
-///
-/// ```text
-/// a + abs(min) > 127
-/// ```
-///
-/// There's some residue r,
-///
-/// ```text
-/// r < 128
-/// ```
-///
-/// such that
-///
-/// ```text
-/// a + abs(min) mod 128 = r
-/// ```
-///
-/// For example,
-///
-/// ```text
-/// min = -128
-/// a = 1
-///
-/// 1 - -128 = 129
-/// ```
-///
-/// And 129's residue is 1. 129 is represented as
-///
-/// ```text
-/// -128 + 1 = -127
-/// ```
-///
-/// The unsigned representation is
-///
-/// ```text
-/// 2^8 - 127
-/// ```
-///
-/// More directly, for some residue r:
-///
-/// ```text
-/// 2^8 + (-128 + r)
-///   = 2^8 - 128 + r
-///   = 128 + r
-/// ```
-///
-/// Addition is order-preserving, so all the wrapped values preserve their order and they're all
-/// represented as unsigned values larger than 127 so they also preserve their order with the
-/// unwrapped values.
-impl IsSortedKernel for FoRVTable {
-    fn is_sorted(&self, array: &FoRArray) -> VortexResult<Option<bool>> {
-        let encoded = array.encoded().to_primitive();
-        is_sorted(
-            &encoded
-                .reinterpret_cast(encoded.ptype().to_unsigned())
-                .to_array(),
-        )
-    }
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
+
+#[derive(Debug)]
+pub(crate) struct FoRIsSortedKernel;
+
+impl DynAggregateKernel for FoRIsSortedKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let Some(options) = aggregate_fn.as_opt::<IsSorted>() else {
+            return Ok(None);
+        };
+
+        let Some(array) = batch.as_opt::<FoR>() else {
+            return Ok(None);
+        };
 
-    fn is_strict_sorted(&self, array: &FoRArray) -> VortexResult<Option<bool>> {
         let encoded = array.encoded().to_primitive();
-        is_strict_sorted(
-            &encoded
-                .reinterpret_cast(encoded.ptype().to_unsigned())
-                .to_array(),
+        let unsigned_array = PrimitiveArray::from_buffer_handle(
+            encoded.buffer_handle().clone(),
+            encoded.ptype().to_unsigned(),
+            encoded.validity()?,
         )
+        .into_array();
+
+        let result = if options.strict {
+            is_strict_sorted(&unsigned_array, ctx)?
+        } else {
+            is_sorted(&unsigned_array, ctx)?
+        };
+
+        Ok(Some(IsSorted::make_partial(batch, result, options.strict)?))
     }
 }
 
-register_kernel!(IsSortedKernelAdapter(FoRVTable).lift());
-
 #[cfg(test)]
 mod test {
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::aggregate_fn::fns::is_sorted::is_sorted;
     use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::compute::is_sorted;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
-    use crate::FoRArray;
+    use crate::FoRData;
+    use crate::r#for::array::FoRArrayExt;
 
     #[test]
     fn test_sorted() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
         let a = PrimitiveArray::new(buffer![-1, 0, i8::MAX], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![i8::MIN, 0, i8::MAX], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![i8::MIN, 0, 30, 127], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![i8::MIN, -3, -1], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![-10, -3, -1], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![-10, -11, -1], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            !is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            !is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
 
         let a = PrimitiveArray::new(buffer![-10, i8::MIN, -1], Validity::NonNullable);
-        let b = FoRArray::encode(a).unwrap();
+        let b = FoRData::encode(a).unwrap();
         assert!(
-            !is_sorted(&b.clone().into_array()).unwrap().unwrap(),
+            !is_sorted(&b.clone().into_array(), &mut ctx).unwrap(),
             "{}",
             b.encoded().display_values()
         );
diff --git a/encodings/fastlanes/src/for/compute/mod.rs b/encodings/fastlanes/src/for/compute/mod.rs
index 363f98c8efe..7307b50d776 100644
--- a/encodings/fastlanes/src/for/compute/mod.rs
+++ b/encodings/fastlanes/src/for/compute/mod.rs
@@ -3,30 +3,30 @@
 
 mod cast;
 mod compare;
-mod is_constant;
-mod is_sorted;
+pub(crate) mod is_constant;
+pub(crate) mod is_sorted;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterReduce;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
+use vortex_array::arrays::filter::FilterReduce;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::FoRArray;
-use crate::FoRVTable;
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-impl TakeExecute for FoRVTable {
+impl TakeExecute for FoR {
     fn take(
-        array: &FoRArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            FoRArray::try_new(
-                array.encoded().take(indices.to_array())?,
+            FoR::try_new(
+                array.encoded().take(indices.clone())?,
                 array.reference_scalar().clone(),
             )?
             .into_array(),
@@ -34,9 +34,9 @@ impl TakeExecute for FoRVTable {
     }
 }
 
-impl FilterReduce for FoRVTable {
-    fn filter(array: &FoRArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
-        FoRArray::try_new(
+impl FilterReduce for FoR {
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+        FoR::try_new(
             array.encoded().filter(mask.clone())?,
             array.reference_scalar().clone(),
         )
@@ -47,140 +47,116 @@ impl FilterReduce for FoRVTable {
 #[cfg(test)]
 mod test {
     use rstest::rstest;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
+    use crate::FoR;
     use crate::FoRArray;
 
+    fn fa(encoded: ArrayRef, reference: Scalar) -> FoRArray {
+        FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed")
+    }
+
     #[test]
     fn test_filter_for_array() {
-        // Test with i32 values
-        let values = buffer![100i32, 101, 102, 103, 104].into_array();
-        let reference = Scalar::from(100i32);
-        let for_array = FoRArray::try_new(values, reference).unwrap();
-        test_filter_conformance(for_array.as_ref());
-
-        // Test with u64 values
-        let values = buffer![1000u64, 1001, 1002, 1003, 1004].into_array();
-        let reference = Scalar::from(1000u64);
-        let for_array = FoRArray::try_new(values, reference).unwrap();
-        test_filter_conformance(for_array.as_ref());
-
-        // Test with nullable values
+        let for_array = fa(
+            buffer![100i32, 101, 102, 103, 104].into_array(),
+            Scalar::from(100i32),
+        );
+        test_filter_conformance(&for_array.into_array());
+
+        let for_array = fa(
+            buffer![1000u64, 1001, 1002, 1003, 1004].into_array(),
+            Scalar::from(1000u64),
+        );
+        test_filter_conformance(&for_array.into_array());
+
         let values =
             PrimitiveArray::from_option_iter([Some(50i16), None, Some(52), Some(53), None]);
-        let reference = Scalar::from(50i16);
-        let for_array = FoRArray::try_new(values.into_array(), reference).unwrap();
-        test_filter_conformance(for_array.as_ref());
+        let for_array = fa(values.into_array(), Scalar::from(50i16));
+        test_filter_conformance(&for_array.into_array());
     }
 
     #[rstest]
-    #[case(FoRArray::try_new(buffer![100i32, 101, 102, 103, 104].into_array(), Scalar::from(100i32)).unwrap())]
-    #[case(FoRArray::try_new(buffer![1000u64, 1001, 1002, 1003, 1004].into_array(), Scalar::from(1000u64)).unwrap())]
-    #[case(FoRArray::try_new(
+    #[case(fa(buffer![100i32, 101, 102, 103, 104].into_array(), Scalar::from(100i32)))]
+    #[case(fa(buffer![1000u64, 1001, 1002, 1003, 1004].into_array(), Scalar::from(1000u64)))]
+    #[case(fa(
         PrimitiveArray::from_option_iter([Some(50i16), None, Some(52), Some(53), None]).into_array(),
         Scalar::from(50i16)
-    ).unwrap())]
-    #[case(FoRArray::try_new(buffer![-100i32, -99, -98, -97, -96].into_array(), Scalar::from(-100i32)).unwrap())]
-    #[case(FoRArray::try_new(buffer![42i64].into_array(), Scalar::from(40i64)).unwrap())]
+    ))]
+    #[case(fa(buffer![-100i32, -99, -98, -97, -96].into_array(), Scalar::from(-100i32)))]
+    #[case(fa(buffer![42i64].into_array(), Scalar::from(40i64)))]
     fn test_take_for_conformance(#[case] for_array: FoRArray) {
         use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(for_array.as_ref());
+        test_take_conformance(&for_array.into_array());
     }
 }
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
+    use crate::FoR;
     use crate::FoRArray;
 
+    fn fa(encoded: ArrayRef, reference: Scalar) -> FoRArray {
+        FoR::try_new(encoded, reference).vortex_expect("FoR array construction should succeed")
+    }
+
     #[rstest]
-    // Basic FoR arrays
-    #[case::for_i32(FoRArray::try_new(
-        buffer![100i32, 101, 102, 103, 104].into_array(),
-        Scalar::from(100i32)
-    ).unwrap())]
-    #[case::for_u64(FoRArray::try_new(
-        buffer![1000u64, 1001, 1002, 1003, 1004].into_array(),
-        Scalar::from(1000u64)
-    ).unwrap())]
-    // Nullable arrays
-    #[case::for_nullable_i16(FoRArray::try_new(
+    #[case::for_i32(fa(buffer![100i32, 101, 102, 103, 104].into_array(), Scalar::from(100i32)))]
+    #[case::for_u64(fa(buffer![1000u64, 1001, 1002, 1003, 1004].into_array(), Scalar::from(1000u64)))]
+    #[case::for_nullable_i16(fa(
         PrimitiveArray::from_option_iter([Some(50i16), None, Some(52), Some(53), None]).into_array(),
         Scalar::from(50i16)
-    ).unwrap())]
-    #[case::for_nullable_i32(FoRArray::try_new(
+    ))]
+    #[case::for_nullable_i32(fa(
         PrimitiveArray::from_option_iter([Some(200i32), None, Some(202), Some(203), None]).into_array(),
         Scalar::from(200i32)
-    ).unwrap())]
-    // Negative values
-    #[case::for_negative(FoRArray::try_new(
-        buffer![-100i32, -99, -98, -97, -96].into_array(),
-        Scalar::from(-100i32)
-    ).unwrap())]
-    // Edge cases
-    #[case::for_single(FoRArray::try_new(
-        buffer![42i64].into_array(),
-        Scalar::from(40i64)
-    ).unwrap())]
-    #[case::for_zero_ref(FoRArray::try_new(
-        buffer![0u32, 1, 2, 3, 4].into_array(),
-        Scalar::from(0u32)
-    ).unwrap())]
-    // Large arrays (> 1024 elements for fastlanes chunking)
-    #[case::for_large(FoRArray::try_new(
+    ))]
+    #[case::for_negative(fa(buffer![-100i32, -99, -98, -97, -96].into_array(), Scalar::from(-100i32)))]
+    #[case::for_single(fa(buffer![42i64].into_array(), Scalar::from(40i64)))]
+    #[case::for_zero_ref(fa(buffer![0u32, 1, 2, 3, 4].into_array(), Scalar::from(0u32)))]
+    #[case::for_large(fa(
         PrimitiveArray::from_iter((0..1500).map(|i| 5000 + i)).into_array(),
         Scalar::from(5000i32)
-    ).unwrap())]
-    #[case::for_very_large(FoRArray::try_new(
+    ))]
+    #[case::for_very_large(fa(
         PrimitiveArray::from_iter((0..3072).map(|i| 10000 + i as i64)).into_array(),
         Scalar::from(10000i64)
-    ).unwrap())]
-    #[case::for_large_nullable(FoRArray::try_new(
+    ))]
+    #[case::for_large_nullable(fa(
         PrimitiveArray::from_option_iter((0..2048).map(|i| (i % 15 == 0).then_some(1000 + i))).into_array(),
         Scalar::from(1000i32)
-    ).unwrap())]
-    // Arrays with large deltas from reference
-    #[case::for_large_deltas(FoRArray::try_new(
-        buffer![100i64, 200, 300, 400, 500].into_array(),
-        Scalar::from(100i64)
-    ).unwrap())]
+    ))]
+    #[case::for_large_deltas(fa(buffer![100i64, 200, 300, 400, 500].into_array(), Scalar::from(100i64)))]
 
     fn test_for_consistency(#[case] array: FoRArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
-    #[case::for_i32_basic(FoRArray::try_new(
-        buffer![100i32, 101, 102, 103, 104].into_array(),
-        Scalar::from(100i32)
-    ).unwrap())]
-    #[case::for_u32_basic(FoRArray::try_new(
-        buffer![1000u32, 1001, 1002, 1003, 1004].into_array(),
-        Scalar::from(1000u32)
-    ).unwrap())]
-    #[case::for_i64_basic(FoRArray::try_new(
-        buffer![5000i64, 5001, 5002, 5003, 5004].into_array(),
-        Scalar::from(5000i64)
-    ).unwrap())]
-    #[case::for_u64_basic(FoRArray::try_new(
-        buffer![10000u64, 10001, 10002, 10003, 10004].into_array(),
-        Scalar::from(10000u64)
-    ).unwrap())]
-    #[case::for_i32_large(FoRArray::try_new(
+    #[case::for_i32_basic(fa(buffer![100i32, 101, 102, 103, 104].into_array(), Scalar::from(100i32)))]
+    #[case::for_u32_basic(fa(buffer![1000u32, 1001, 1002, 1003, 1004].into_array(), Scalar::from(1000u32)))]
+    #[case::for_i64_basic(fa(buffer![5000i64, 5001, 5002, 5003, 5004].into_array(), Scalar::from(5000i64)))]
+    #[case::for_u64_basic(fa(buffer![10000u64, 10001, 10002, 10003, 10004].into_array(), Scalar::from(10000u64)))]
+    #[case::for_i32_large(fa(
         PrimitiveArray::from_iter((0..100).map(|i| 2000 + i)).into_array(),
         Scalar::from(2000i32)
-    ).unwrap())]
+    ))]
     fn test_for_binary_numeric(#[case] array: FoRArray) {
         test_binary_numeric_array(array.into_array());
     }
diff --git a/encodings/fastlanes/src/for/mod.rs b/encodings/fastlanes/src/for/mod.rs
index d192690a3e3..8a70fe30499 100644
--- a/encodings/fastlanes/src/for/mod.rs
+++ b/encodings/fastlanes/src/for/mod.rs
@@ -2,9 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::FoRArray;
+pub use array::FoRArrayExt;
+pub use array::FoRData;
 
-mod compute;
+pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::FoRVTable;
+pub use vtable::FoR;
+pub use vtable::FoRArray;
diff --git a/encodings/fastlanes/src/for/vtable/array.rs b/encodings/fastlanes/src/for/vtable/array.rs
deleted file mode 100644
index 33c5cda8380..00000000000
--- a/encodings/fastlanes/src/for/vtable/array.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use vortex_array::ArrayEq;
-use vortex_array::ArrayHash;
-use vortex_array::Precision;
-use vortex_array::dtype::DType;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable::BaseArrayVTable;
-
-use super::FoRVTable;
-use crate::FoRArray;
-
-impl BaseArrayVTable<FoRVTable> for FoRVTable {
-    fn len(array: &FoRArray) -> usize {
-        array.encoded().len()
-    }
-
-    fn dtype(array: &FoRArray) -> &DType {
-        array.reference_scalar().dtype()
-    }
-
-    fn stats(array: &FoRArray) -> StatsSetRef<'_> {
-        array.stats_set().to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &FoRArray, state: &mut H, precision: Precision) {
-        array.encoded().array_hash(state, precision);
-        array.reference_scalar().hash(state);
-    }
-
-    fn array_eq(array: &FoRArray, other: &FoRArray, precision: Precision) -> bool {
-        array.encoded().array_eq(other.encoded(), precision)
-            && array.reference_scalar() == other.reference_scalar()
-    }
-}
diff --git a/encodings/fastlanes/src/for/vtable/kernels.rs b/encodings/fastlanes/src/for/vtable/kernels.rs
index 9641cde403f..331b13eceef 100644
--- a/encodings/fastlanes/src/for/vtable/kernels.rs
+++ b/encodings/fastlanes/src/for/vtable/kernels.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
 
-use crate::FoRVTable;
+use crate::FoR;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<FoRVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(FoRVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(FoRVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<FoR> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(FoR)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(FoR)),
 ]);
diff --git a/encodings/fastlanes/src/for/vtable/mod.rs b/encodings/fastlanes/src/for/vtable/mod.rs
index 883231324a8..3f3207a8e24 100644
--- a/encodings/fastlanes/src/for/vtable/mod.rs
+++ b/encodings/fastlanes/src/for/vtable/mod.rs
@@ -2,95 +2,124 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
-
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 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;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTableFromChild;
+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 crate::FoRArray;
+use crate::FoRData;
+use crate::r#for::array::FoRArrayExt;
+use crate::r#for::array::SLOT_NAMES;
 use crate::r#for::array::for_decompress::decompress;
 use crate::r#for::vtable::kernels::PARENT_KERNELS;
 use crate::r#for::vtable::rules::PARENT_RULES;
 
-mod array;
 mod kernels;
 mod operations;
 mod rules;
 mod slice;
 mod validity;
-mod visitor;
 
-vtable!(FoR);
+/// A [`FoR`]-encoded Vortex array.
+pub type FoRArray = Array<FoR>;
+
+impl ArrayHash for FoRData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.reference.hash(state);
+    }
+}
 
-impl VTable for FoRVTable {
-    type Array = FoRArray;
+impl ArrayEq for FoRData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.reference == other.reference
+    }
+}
 
-    type Metadata = Scalar;
+impl VTable for FoR {
+    type ArrayData = FoRData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // FoRArray children order (from visit_children):
-        // 1. encoded
-
-        vortex_ensure!(
-            children.len() == 1,
-            "Expected 1 child for FoR encoding, got {}",
-            children.len()
-        );
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let encoded = slots[0].as_ref().vortex_expect("FoRArray encoded slot");
+        validate_parts(encoded.dtype(), encoded.len(), &data.reference, dtype, len)
+    }
 
-        array.encoded = children[0].clone();
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
 
-        Ok(())
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("FoRArray buffer index {idx} out of bounds")
     }
 
-    fn metadata(array: &FoRArray) -> VortexResult<Self::Metadata> {
-        Ok(array.reference_scalar().clone())
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        // Note that we **only** serialize the optional scalar value (not including the dtype).
-        Ok(Some(ScalarValue::to_proto_bytes(metadata.value())))
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let scalar_value = ScalarValue::from_proto_bytes(bytes, dtype)?;
-        Scalar::try_new(dtype.clone(), scalar_value)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        // Note that we **only** serialize the optional scalar value (not including the dtype).
+        Ok(Some(ScalarValue::to_proto_bytes(
+            array.reference_scalar().value(),
+        )))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
+        metadata: &[u8],
+        buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<FoRArray> {
+        session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_ensure!(
+            buffers.is_empty(),
+            "FoRArray expects 0 buffers, got {}",
+            buffers.len()
+        );
         if children.len() != 1 {
             vortex_bail!(
                 "Expected 1 child for FoR encoding, found {}",
@@ -98,25 +127,29 @@ impl VTable for FoRVTable {
             )
         }
 
+        let scalar_value = ScalarValue::from_proto_bytes(metadata, dtype, session)?;
+        let reference = Scalar::try_new(dtype.clone(), scalar_value)?;
         let encoded = children.get(0, dtype, len)?;
+        let slots = vec![Some(encoded)];
 
-        FoRArray::try_new(encoded, metadata.clone())
+        let data = FoRData::try_new(reference)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(decompress(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(decompress(&array, ctx)?.into_array()))
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -125,9 +158,66 @@ impl VTable for FoRVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct FoRVTable;
+#[derive(Clone, Debug)]
+pub struct FoR;
 
-impl FoRVTable {
+impl FoR {
     pub const ID: ArrayId = ArrayId::new_ref("fastlanes.for");
+
+    /// Construct a new FoR array from an encoded array and a reference scalar.
+    pub fn try_new(encoded: ArrayRef, reference: Scalar) -> VortexResult<FoRArray> {
+        vortex_ensure!(!reference.is_null(), "Reference value cannot be null");
+        let dtype = reference
+            .dtype()
+            .with_nullability(encoded.dtype().nullability());
+        let reference = reference.cast(&dtype)?;
+        let len = encoded.len();
+        let data = FoRData::try_new(reference)?;
+        let slots = vec![Some(encoded)];
+        Array::try_from_parts(ArrayParts::new(FoR, dtype, len, data).with_slots(slots))
+    }
+
+    /// Encode a primitive array using Frame of Reference encoding.
+    pub fn encode(array: PrimitiveArray) -> VortexResult<FoRArray> {
+        FoRData::encode(array)
+    }
+}
+
+fn validate_parts(
+    encoded_dtype: &DType,
+    encoded_len: usize,
+    reference: &Scalar,
+    dtype: &DType,
+    len: usize,
+) -> VortexResult<()> {
+    vortex_ensure!(dtype.is_int(), "FoR requires an integer dtype, got {dtype}");
+    vortex_ensure!(
+        reference.dtype() == dtype,
+        "FoR reference dtype mismatch: expected {dtype}, got {}",
+        reference.dtype()
+    );
+    vortex_ensure!(
+        encoded_dtype == dtype,
+        "FoR encoded dtype mismatch: expected {dtype}, got {}",
+        encoded_dtype
+    );
+    vortex_ensure!(
+        encoded_len == len,
+        "FoR encoded length mismatch: expected {len}, got {}",
+        encoded_len
+    );
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::scalar::ScalarValue;
+    use vortex_array::test_harness::check_metadata;
+
+    #[cfg_attr(miri, ignore)]
+    #[test]
+    fn test_for_metadata() {
+        let metadata: Vec<u8> = ScalarValue::to_proto_bytes(Some(&ScalarValue::from(i64::MAX)));
+        check_metadata("for.metadata", &metadata);
+    }
 }
diff --git a/encodings/fastlanes/src/for/vtable/operations.rs b/encodings/fastlanes/src/for/vtable/operations.rs
index 1277a2f7be1..e90ff7f4ad2 100644
--- a/encodings/fastlanes/src/for/vtable/operations.rs
+++ b/encodings/fastlanes/src/for/vtable/operations.rs
@@ -1,17 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use super::FoRVTable;
-use crate::FoRArray;
-
-impl OperationsVTable<FoRVTable> for FoRVTable {
-    fn scalar_at(array: &FoRArray, index: usize) -> VortexResult<Scalar> {
+use super::FoR;
+use crate::r#for::array::FoRArrayExt;
+impl OperationsVTable<FoR> for FoR {
+    fn scalar_at(
+        array: ArrayView<'_, FoR>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let encoded_pvalue = array.encoded().scalar_at(index)?;
         let encoded_pvalue = encoded_pvalue.as_primitive();
         let reference = array.reference_scalar();
@@ -38,12 +43,11 @@ mod test {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
 
-    use crate::FoRArray;
+    use crate::FoRData;
 
     #[test]
     fn for_scalar_at() {
-        let for_arr =
-            FoRArray::encode(PrimitiveArray::from_iter([-100, 1100, 1500, 1900])).unwrap();
+        let for_arr = FoRData::encode(PrimitiveArray::from_iter([-100, 1100, 1500, 1900])).unwrap();
         let expected = PrimitiveArray::from_iter([-100, 1100, 1500, 1900]);
         assert_arrays_eq!(for_arr, expected);
     }
diff --git a/encodings/fastlanes/src/for/vtable/rules.rs b/encodings/fastlanes/src/for/vtable/rules.rs
index 131827c24b3..8d220a86d7f 100644
--- a/encodings/fastlanes/src/for/vtable/rules.rs
+++ b/encodings/fastlanes/src/for/vtable/rules.rs
@@ -1,47 +1,46 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterArray;
-use vortex_array::arrays::FilterReduceAdaptor;
-use vortex_array::arrays::FilterVTable;
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::Filter;
+use vortex_array::arrays::filter::FilterReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ArrayParentReduceRule;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_error::VortexResult;
 
-use crate::FoRArray;
-use crate::FoRVTable;
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-pub(super) const PARENT_RULES: ParentRuleSet<FoRVTable> = ParentRuleSet::new(&[
-    // TODO: add BetweenReduceAdaptor(FoRVTable)
+pub(super) const PARENT_RULES: ParentRuleSet<FoR> = ParentRuleSet::new(&[
+    // TODO: add BetweenReduceAdaptor(FoR)
     ParentRuleSet::lift(&FoRFilterPushDownRule),
-    ParentRuleSet::lift(&FilterReduceAdaptor(FoRVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(FoRVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(FoRVTable)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(FoR)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(FoR)),
+    ParentRuleSet::lift(&CastReduceAdaptor(FoR)),
 ]);
 
 #[derive(Debug)]
 struct FoRFilterPushDownRule;
 
-impl ArrayParentReduceRule<FoRVTable> for FoRFilterPushDownRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<FoR> for FoRFilterPushDownRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &FoRArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, FoR>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
-        let new_array = unsafe {
-            FoRArray::new_unchecked(
-                child.encoded.filter(parent.filter_mask().clone())?,
-                child.reference.clone(),
-            )
-        };
-        Ok(Some(new_array.into_array()))
+        Ok(Some(
+            FoR::try_new(
+                child.encoded().filter(parent.filter_mask().clone())?,
+                child.reference_scalar().clone(),
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/fastlanes/src/for/vtable/slice.rs b/encodings/fastlanes/src/for/vtable/slice.rs
index 767c01eb34c..206c47ef509 100644
--- a/encodings/fastlanes/src/for/vtable/slice.rs
+++ b/encodings/fastlanes/src/for/vtable/slice.rs
@@ -4,22 +4,22 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::FoRArray;
-use crate::FoRVTable;
+use crate::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-impl SliceReduce for FoRVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        // SAFETY: Just slicing encoded data does not affect FOR.
-        Ok(Some(unsafe {
-            FoRArray::new_unchecked(
+impl SliceReduce for FoR {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        Ok(Some(
+            FoR::try_new(
                 array.encoded().slice(range)?,
                 array.reference_scalar().clone(),
-            )
-            .into_array()
-        }))
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/fastlanes/src/for/vtable/validity.rs b/encodings/fastlanes/src/for/vtable/validity.rs
index 210a7f4b095..dd2d28802ae 100644
--- a/encodings/fastlanes/src/for/vtable/validity.rs
+++ b/encodings/fastlanes/src/for/vtable/validity.rs
@@ -2,13 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::vtable::ValidityChild;
 
-use super::FoRVTable;
-use crate::FoRArray;
+use super::FoR;
+use crate::r#for::array::FoRArrayExt;
 
-impl ValidityChild<FoRVTable> for FoRVTable {
-    fn validity_child(array: &FoRArray) -> &ArrayRef {
-        array.encoded()
+impl ValidityChild<FoR> for FoR {
+    fn validity_child(array: ArrayView<'_, FoR>) -> ArrayRef {
+        array.encoded().clone()
     }
 }
diff --git a/encodings/fastlanes/src/for/vtable/visitor.rs b/encodings/fastlanes/src/for/vtable/visitor.rs
deleted file mode 100644
index 5c51377cab4..00000000000
--- a/encodings/fastlanes/src/for/vtable/visitor.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
-use vortex_array::vtable::VisitorVTable;
-
-use super::FoRVTable;
-use crate::FoRArray;
-
-impl VisitorVTable<FoRVTable> for FoRVTable {
-    fn visit_buffers(_array: &FoRArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &FoRArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &FoRArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("encoded", array.encoded())
-    }
-
-    fn nchildren(_array: &FoRArray) -> usize {
-        1
-    }
-}
diff --git a/encodings/fastlanes/src/lib.rs b/encodings/fastlanes/src/lib.rs
index 5db286615ec..9a9f37d9af8 100644
--- a/encodings/fastlanes/src/lib.rs
+++ b/encodings/fastlanes/src/lib.rs
@@ -3,11 +3,20 @@
 
 #![allow(clippy::cast_possible_truncation)]
 
+use std::env;
+use std::sync::LazyLock;
+
 pub use bitpacking::*;
 pub use delta::*;
 pub use r#for::*;
 pub use rle::*;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_buffer::BufferMut;
 
+pub mod bit_transpose;
 mod bitpacking;
 mod delta;
 mod r#for;
@@ -15,23 +24,164 @@ mod rle;
 
 pub(crate) const FL_CHUNK_SIZE: usize = 1024;
 
+use bitpacking::compute::is_constant::BitPackedIsConstantKernel;
+use r#for::compute::is_constant::FoRIsConstantKernel;
+use r#for::compute::is_sorted::FoRIsSortedKernel;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
+
+/// Flag indicating if experimental patched array support is enabled.
+///
+/// This is set using the environment variable `VORTEX_EXPERIMENTAL_PATCHED_ARRAY`.
+///
+/// When this is true, any BitPacked array with interior patches will be read as a `Patched`
+/// array, and the builtin compressor will use Patched array with BitPacked instead of
+/// BitPacked array with interior patches.
+pub static USE_EXPERIMENTAL_PATCHES: LazyLock<bool> =
+    LazyLock::new(|| env::var("VORTEX_EXPERIMENTAL_PATCHED_ARRAY").is_ok());
+
+/// Initialize fastlanes encodings in the given session.
+pub fn initialize(session: &VortexSession) {
+    // If we're using the experimental Patched encoding, register a shim
+    // for BitPacked with interior patches decode as Patched array.
+    if *USE_EXPERIMENTAL_PATCHES {
+        session.arrays().register(BitPackedPatchedPlugin);
+    } else {
+        session.arrays().register(BitPacked);
+    }
+    session.arrays().register(Delta);
+    session.arrays().register(FoR);
+    session.arrays().register(RLE);
+
+    // Register the encoding-specific aggregate kernels.
+    session.aggregate_fns().register_aggregate_kernel(
+        BitPacked::ID,
+        Some(IsConstant.id()),
+        &BitPackedIsConstantKernel,
+    );
+    session.aggregate_fns().register_aggregate_kernel(
+        FoR::ID,
+        Some(IsConstant.id()),
+        &FoRIsConstantKernel,
+    );
+    session.aggregate_fns().register_aggregate_kernel(
+        FoR::ID,
+        Some(IsSorted.id()),
+        &FoRIsSortedKernel,
+    );
+}
+
+/// Fill-forward null values in a buffer, replacing each null with the last valid value seen.
+///
+/// The fill-forward state resets to `T::default()` at every [`FL_CHUNK_SIZE`] boundary
+/// so that values from one chunk never leak into the next. This is important because
+/// both RLE and Delta encodings treat each chunk independently: a fill-forwarded value
+/// that crosses a chunk boundary can become an invalid chunk-local index (for RLE) or
+/// an incorrect delta base (for Delta).
+///
+/// Returns the original buffer if there are no nulls (i.e. the validity is
+/// `NonNullable` or `AllValid`), avoiding any allocation or copy.
+pub(crate) fn fill_forward_nulls<T: Copy + Default>(
+    values: Buffer<T>,
+    validity: &Validity,
+) -> Buffer<T> {
+    match validity {
+        Validity::NonNullable | Validity::AllValid => values,
+        Validity::AllInvalid => Buffer::zeroed(values.len()),
+        Validity::Array(validity_array) => {
+            let bit_buffer = validity_array.to_bool().to_bit_buffer();
+            let mut last_valid = T::default();
+            match values.try_into_mut() {
+                Ok(mut to_fill_mut) => {
+                    for (i, (v, is_valid)) in
+                        to_fill_mut.iter_mut().zip(bit_buffer.iter()).enumerate()
+                    {
+                        if is_valid {
+                            last_valid = *v;
+                        } else if i.is_multiple_of(FL_CHUNK_SIZE) {
+                            last_valid = T::default();
+                        } else {
+                            *v = last_valid;
+                        }
+                    }
+                    to_fill_mut.freeze()
+                }
+                Err(to_fill) => {
+                    let mut to_fill_mut = BufferMut::<T>::with_capacity(to_fill.len());
+                    for (i, (v, (out, is_valid))) in to_fill
+                        .iter()
+                        .zip(
+                            to_fill_mut
+                                .spare_capacity_mut()
+                                .iter_mut()
+                                .zip(bit_buffer.iter()),
+                        )
+                        .enumerate()
+                    {
+                        if is_valid {
+                            last_valid = *v;
+                        } else if i.is_multiple_of(FL_CHUNK_SIZE) {
+                            last_valid = T::default();
+                        }
+                        out.write(last_valid);
+                    }
+                    unsafe { to_fill_mut.set_len(to_fill.len()) };
+                    to_fill_mut.freeze()
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::sync::LazyLock;
 
     use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::BitBufferMut;
     use vortex_session::VortexSession;
 
     use super::*;
 
     pub static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
         let session = VortexSession::empty();
-        session
-            .arrays()
-            .register(BitPackedVTable::ID, BitPackedVTable);
-        session.arrays().register(DeltaVTable::ID, DeltaVTable);
-        session.arrays().register(FoRVTable::ID, FoRVTable);
-        session.arrays().register(RLEVTable::ID, RLEVTable);
+        session.arrays().register(BitPacked);
+        session.arrays().register(Delta);
+        session.arrays().register(FoR);
+        session.arrays().register(RLE);
         session
     });
+
+    #[test]
+    fn fill_forward_nulls_resets_at_chunk_boundary() {
+        // Build a buffer spanning two chunks where the last valid value in chunk 0
+        // is non-zero. Null positions at the start of chunk 1 must get T::default()
+        // (0), not the carry-over from chunk 0.
+        let mut values = BufferMut::zeroed(2 * FL_CHUNK_SIZE);
+        // Place a non-zero valid value near the end of chunk 0.
+        values[FL_CHUNK_SIZE - 1] = 42;
+
+        let mut validity_bits = BitBufferMut::new_unset(2 * FL_CHUNK_SIZE);
+        validity_bits.set(FL_CHUNK_SIZE - 1); // only this position is valid
+
+        let validity = Validity::from(validity_bits.freeze());
+        let result = fill_forward_nulls(values.freeze(), &validity);
+
+        // Within chunk 0, nulls before the valid element get 0 (default), and the
+        // valid element itself is 42.
+        assert_eq!(result[FL_CHUNK_SIZE - 1], 42);
+
+        // Chunk 1 has no valid elements. Every position must be T::default() (0),
+        // NOT 42 carried over from chunk 0.
+        for i in FL_CHUNK_SIZE..2 * FL_CHUNK_SIZE {
+            assert_eq!(
+                result[i], 0,
+                "position {i} should be 0, not carried from chunk 0"
+            );
+        }
+    }
 }
diff --git a/encodings/fastlanes/src/rle/array/mod.rs b/encodings/fastlanes/src/rle/array/mod.rs
index 9cf49ee5a3b..cf418ea114e 100644
--- a/encodings/fastlanes/src/rle/array/mod.rs
+++ b/encodings/fastlanes/src/rle/array/mod.rs
@@ -1,90 +1,48 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use vortex_array::ArrayRef;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::PType;
-use vortex_array::stats::ArrayStats;
+use vortex_array::TypedArrayRef;
+use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
-use crate::FL_CHUNK_SIZE;
-
 pub mod rle_compress;
 pub mod rle_decompress;
 
+/// Run values in the dictionary.
+pub(super) const VALUES_SLOT: usize = 0;
+/// Chunk-local indices from all chunks. The start of each chunk is looked up in `values_idx_offsets`.
+pub(super) const INDICES_SLOT: usize = 1;
+/// Index start positions of each value chunk.
+///
+/// # Example
+/// ```text
+/// // Chunk 0: [10, 20] (starts at index 0)
+/// // Chunk 1: [30, 40] (starts at index 2)
+/// let values = [10, 20, 30, 40];           // Global values array
+/// let values_idx_offsets = [0, 2];         // Chunk 0 starts at index 0, Chunk 1 starts at index 2
+/// ```
+pub(super) const VALUES_IDX_OFFSETS_SLOT: usize = 2;
+pub(super) const NUM_SLOTS: usize = 3;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["values", "indices", "values_idx_offsets"];
+
 #[derive(Clone, Debug)]
-pub struct RLEArray {
-    pub(super) dtype: DType,
-    /// Run value in the dictionary.
-    pub(super) values: ArrayRef,
-    /// Chunk-local indices from all chunks. The start of each chunk is looked up in `values_idx_offsets`.
-    pub(super) indices: ArrayRef,
-    /// Index start positions of each value chunk.
-    ///
-    /// # Example
-    /// ```
-    /// // Chunk 0: [10, 20] (starts at index 0)
-    /// // Chunk 1: [30, 40] (starts at index 2)
-    /// let values = [10, 20, 30, 40];           // Global values array
-    /// let values_idx_offsets = [0, 2];         // Chunk 0 starts at index 0, Chunk 1 starts at index 2
-    /// ```
-    pub(super) values_idx_offsets: ArrayRef,
-
-    pub(super) stats_set: ArrayStats,
+pub struct RLEData {
     // Offset relative to the start of the chunk.
     pub(super) offset: usize,
-    pub(super) length: usize,
 }
 
-impl RLEArray {
-    fn validate(
-        values: &dyn Array,
-        indices: &dyn Array,
-        value_idx_offsets: &dyn Array,
-        offset: usize,
-    ) -> VortexResult<()> {
-        vortex_ensure!(
-            offset < 1024,
-            "Offset must be smaller than 1024, got {}",
-            offset
-        );
-
-        vortex_ensure!(
-            values.dtype().is_primitive(),
-            "RLE values must be a primitive type, got {}",
-            values.dtype()
-        );
-
-        vortex_ensure!(
-            matches!(indices.dtype().as_ptype(), PType::U8 | PType::U16),
-            "RLE indices must be u8 or u16, got {}",
-            indices.dtype()
-        );
-
-        vortex_ensure!(
-            value_idx_offsets.dtype().is_unsigned_int() && !value_idx_offsets.dtype().is_nullable(),
-            "RLE value idx offsets must be non-nullable unsigned integer, got {}",
-            value_idx_offsets.dtype()
-        );
-
-        vortex_ensure!(
-            indices.len().div_ceil(FL_CHUNK_SIZE) == value_idx_offsets.len(),
-            "RLE must have one value idx offset per chunk, got {}",
-            value_idx_offsets.len()
-        );
-
-        vortex_ensure!(
-            indices.len() >= values.len(),
-            "RLE must have at least as many indices as values, got {} indices and {} values",
-            indices.len(),
-            values.len()
-        );
-
-        Ok(())
+impl Display for RLEData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "offset: {}", self.offset)
     }
+}
 
+impl RLEData {
     /// Create a new chunk-based RLE array from its components.
     ///
     /// # Arguments
@@ -94,28 +52,13 @@ impl RLEArray {
     /// * `values_idx_offsets` - Start indices for each value chunk.
     /// * `offset` - Offset into the first chunk
     /// * `length` - Array length
-    pub fn try_new(
-        values: ArrayRef,
-        indices: ArrayRef,
-        values_idx_offsets: ArrayRef,
-        offset: usize,
-        length: usize,
-    ) -> VortexResult<Self> {
-        assert_eq!(indices.len() % FL_CHUNK_SIZE, 0);
-        Self::validate(&values, &indices, &values_idx_offsets, offset)?;
-
-        // Ensure that the DType has the same nullability as the indices array.
-        let dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
-
-        Ok(Self {
-            dtype,
-            values,
-            indices,
-            values_idx_offsets,
-            stats_set: ArrayStats::default(),
-            offset,
-            length,
-        })
+    pub fn try_new(offset: usize) -> VortexResult<Self> {
+        vortex_ensure!(
+            offset < 1024,
+            "Offset must be smaller than 1024, got {}",
+            offset
+        );
+        Ok(Self { offset })
     }
 
     /// Create a new RLEArray without validation.
@@ -123,57 +66,38 @@ impl RLEArray {
     /// # Safety
     /// The caller must ensure that:
     /// - `offset + length` does not exceed the length of the indices array
-    /// - The `dtype` is consistent with the values array's primitive type and validity nullability
     /// - The `indices` array contains valid indices into chunks of the `values` array
     /// - The `values_idx_offsets` array contains valid chunk start offsets
-    /// - The `validity` array has the same length as `length`
-    pub unsafe fn new_unchecked(
-        values: ArrayRef,
-        indices: ArrayRef,
-        values_idx_offsets: ArrayRef,
-        dtype: DType,
-        offset: usize,
-        length: usize,
-    ) -> Self {
-        Self {
-            dtype,
-            values,
-            indices,
-            values_idx_offsets,
-            stats_set: ArrayStats::default(),
-            offset,
-            length,
-        }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.length
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.length == 0
+    pub unsafe fn new_unchecked(offset: usize) -> Self {
+        Self { offset }
     }
 
     #[inline]
-    pub fn dtype(&self) -> &DType {
-        &self.dtype
+    pub fn offset(&self) -> usize {
+        self.offset
     }
+}
 
+pub trait RLEArrayExt: TypedArrayRef<crate::RLE> {
     #[inline]
-    pub fn values(&self) -> &ArrayRef {
-        &self.values
+    fn values(&self) -> &ArrayRef {
+        self.as_ref().slots()[VALUES_SLOT]
+            .as_ref()
+            .vortex_expect("RLEArray values slot must be populated")
     }
 
     #[inline]
-    pub fn indices(&self) -> &ArrayRef {
-        &self.indices
+    fn indices(&self) -> &ArrayRef {
+        self.as_ref().slots()[INDICES_SLOT]
+            .as_ref()
+            .vortex_expect("RLEArray indices slot must be populated")
     }
 
     #[inline]
-    pub fn values_idx_offsets(&self) -> &ArrayRef {
-        &self.values_idx_offsets
+    fn values_idx_offsets(&self) -> &ArrayRef {
+        self.as_ref().slots()[VALUES_IDX_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("RLEArray values_idx_offsets slot must be populated")
     }
 
     /// Values index offset relative to the first chunk.
@@ -185,15 +109,15 @@ impl RLEArray {
         clippy::expect_used,
         reason = "expect is safe here as scalar_at returns a valid primitive"
     )]
-    pub(crate) fn values_idx_offset(&self, chunk_idx: usize) -> usize {
-        self.values_idx_offsets
+    fn values_idx_offset(&self, chunk_idx: usize) -> usize {
+        self.values_idx_offsets()
             .scalar_at(chunk_idx)
             .expect("index must be in bounds")
             .as_primitive()
             .as_::<usize>()
             .expect("index must be of type usize")
             - self
-                .values_idx_offsets
+                .values_idx_offsets()
                 .scalar_at(0)
                 .expect("index must be in bounds")
                 .as_primitive()
@@ -203,34 +127,39 @@ impl RLEArray {
 
     /// Index offset into the array
     #[inline]
-    pub fn offset(&self) -> usize {
+    fn offset(&self) -> usize {
         self.offset
     }
-
-    #[inline]
-    pub(crate) fn stats_set(&self) -> &ArrayStats {
-        &self.stats_set
-    }
 }
 
+impl<T: TypedArrayRef<crate::RLE>> RLEArrayExt for T {}
+
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
     use vortex_array::ToCanonical;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::primitive::PrimitiveArrayExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
-    use vortex_array::serde::ArrayParts;
     use vortex_array::serde::SerializeOptions;
+    use vortex_array::serde::SerializedArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::ByteBufferMut;
-
-    use crate::RLEArray;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+    use vortex_session::registry::ReadContext;
+
+    use crate::FL_CHUNK_SIZE;
+    use crate::RLE;
+    use crate::RLEData;
+    use crate::rle::array::RLEArrayExt;
     use crate::test::SESSION;
 
     #[test]
@@ -242,7 +171,8 @@ mod tests {
             PrimitiveArray::from_iter([0u16, 0, 1, 1, 2].iter().cycle().take(1024).copied())
                 .into_array();
         let values_idx_offsets = PrimitiveArray::from_iter([0u64]).into_array();
-        let rle_array = RLEArray::try_new(values, indices, values_idx_offsets, 0, 5).unwrap();
+        let rle_array = RLE::try_new(values, indices, values_idx_offsets, 0, 5)
+            .vortex_expect("RLEData is always valid");
 
         assert_eq!(rle_array.len(), 5);
         assert_eq!(rle_array.values().len(), 3);
@@ -269,14 +199,8 @@ mod tests {
         )
         .into_array();
 
-        let rle_array = RLEArray::try_new(
-            values.clone(),
-            indices_with_validity,
-            values_idx_offsets,
-            0,
-            3,
-        )
-        .unwrap();
+        let rle_array = RLE::try_new(values, indices_with_validity, values_idx_offsets, 0, 3)
+            .vortex_expect("RLEData is always valid");
 
         assert_eq!(rle_array.len(), 3);
         assert_eq!(rle_array.values().len(), 2);
@@ -305,14 +229,8 @@ mod tests {
         )
         .into_array();
 
-        let rle_array = RLEArray::try_new(
-            values.clone(),
-            indices_with_validity,
-            values_idx_offsets,
-            0,
-            5,
-        )
-        .unwrap();
+        let rle_array = RLE::try_new(values, indices_with_validity, values_idx_offsets, 0, 5)
+            .vortex_expect("RLEData is always valid");
 
         let valid_slice = rle_array.slice(0..3).unwrap().to_primitive();
         // TODO(joe): replace with compute null count
@@ -342,14 +260,8 @@ mod tests {
         )
         .into_array();
 
-        let rle_array = RLEArray::try_new(
-            values.clone(),
-            indices_with_validity,
-            values_idx_offsets,
-            0,
-            5,
-        )
-        .unwrap();
+        let rle_array = RLE::try_new(values, indices_with_validity, values_idx_offsets, 0, 5)
+            .vortex_expect("RLEData is always valid");
 
         // TODO(joe): replace with compute null count
         let invalid_slice = rle_array
@@ -384,19 +296,18 @@ mod tests {
         )
         .into_array();
 
-        let rle_array = RLEArray::try_new(
-            values.clone(),
-            indices_with_validity,
-            values_idx_offsets,
-            0,
-            4,
-        )
-        .unwrap();
+        let rle_array = RLE::try_new(values, indices_with_validity, values_idx_offsets, 0, 4)
+            .vortex_expect("RLEData is always valid");
 
         let sliced_array = rle_array.slice(1..4).unwrap();
         let validity_mask = sliced_array.validity_mask().unwrap();
 
-        let expected_mask = Validity::from_iter([false, true, false]).to_mask(3);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let expected_mask = Validity::from_iter([false, true, false])
+            .execute_mask(3, &mut ctx)
+            .unwrap();
+        assert_eq!(validity_mask.len(), expected_mask.len());
+        assert_eq!(validity_mask, expected_mask);
         assert_eq!(validity_mask.len(), expected_mask.len());
         assert_eq!(validity_mask, expected_mask);
     }
@@ -406,14 +317,14 @@ mod tests {
         let values = PrimitiveArray::from_iter(Vec::<u32>::new()).into_array();
         let indices = PrimitiveArray::from_iter(Vec::<u16>::new()).into_array();
         let values_idx_offsets = PrimitiveArray::from_iter(Vec::<u64>::new()).into_array();
-        let rle_array = RLEArray::try_new(
+        let rle_array = RLE::try_new(
             values,
             indices.clone(),
             values_idx_offsets,
             0,
             indices.len(),
         )
-        .unwrap();
+        .vortex_expect("RLEData is always valid");
 
         assert_eq!(rle_array.len(), 0);
         assert_eq!(rle_array.values().len(), 0);
@@ -424,7 +335,8 @@ mod tests {
         let values = PrimitiveArray::from_iter([10u32, 20, 30, 40]).into_array();
         let indices = PrimitiveArray::from_iter([0u16, 1].repeat(1024)).into_array();
         let values_idx_offsets = PrimitiveArray::from_iter([0u64, 2]).into_array();
-        let rle_array = RLEArray::try_new(values, indices, values_idx_offsets, 0, 2048).unwrap();
+        let rle_array = RLE::try_new(values, indices, values_idx_offsets, 0, 2048)
+            .vortex_expect("RLEData is always valid");
 
         assert_eq!(rle_array.len(), 2048);
         assert_eq!(rle_array.values().len(), 4);
@@ -436,15 +348,15 @@ mod tests {
     #[test]
     fn test_rle_serialization() {
         let primitive = PrimitiveArray::from_iter((0..2048).map(|i| (i / 100) as u32));
-        let rle_array = RLEArray::encode(&primitive).unwrap();
+        let rle_array = RLEData::encode(&primitive).unwrap();
         assert_eq!(rle_array.len(), 2048);
 
-        let original_data = rle_array.to_primitive();
+        let original_data = rle_array.as_array().to_primitive();
 
         let ctx = ArrayContext::empty();
         let serialized = rle_array
-            .to_array()
-            .serialize(&ctx, &SerializeOptions::default())
+            .into_array()
+            .serialize(&ctx, &SESSION, &SerializeOptions::default())
             .unwrap();
 
         let mut concat = ByteBufferMut::empty();
@@ -453,12 +365,12 @@ mod tests {
         }
         let concat = concat.freeze();
 
-        let parts = ArrayParts::try_from(concat).unwrap();
+        let parts = SerializedArray::try_from(concat).unwrap();
         let decoded = parts
             .decode(
                 &DType::Primitive(PType::U32, Nullability::NonNullable),
                 2048,
-                &ctx,
+                &ReadContext::new(ctx.to_ids()),
                 &SESSION,
             )
             .unwrap();
@@ -471,22 +383,23 @@ mod tests {
     #[test]
     fn test_rle_serialization_slice() {
         let primitive = PrimitiveArray::from_iter((0..2048).map(|i| (i / 100) as u32));
-        let rle_array = RLEArray::encode(&primitive).unwrap();
+        let rle_array = RLEData::encode(&primitive).unwrap();
 
-        let sliced = RLEArray::try_new(
+        let sliced = RLE::try_new(
             rle_array.values().clone(),
             rle_array.indices().clone(),
             rle_array.values_idx_offsets().clone(),
             100,
             100,
         )
-        .unwrap();
+        .vortex_expect("RLEData is always valid");
         assert_eq!(sliced.len(), 100);
 
         let ctx = ArrayContext::empty();
         let serialized = sliced
-            .to_array()
-            .serialize(&ctx, &SerializeOptions::default())
+            .clone()
+            .into_array()
+            .serialize(&ctx, &SESSION, &SerializeOptions::default())
             .unwrap();
 
         let mut concat = ByteBufferMut::empty();
@@ -495,14 +408,62 @@ mod tests {
         }
         let concat = concat.freeze();
 
-        let parts = ArrayParts::try_from(concat).unwrap();
+        let parts = SerializedArray::try_from(concat).unwrap();
         let decoded = parts
-            .decode(sliced.dtype(), sliced.len(), &ctx, &SESSION)
+            .decode(
+                sliced.dtype(),
+                sliced.len(),
+                &ReadContext::new(ctx.to_ids()),
+                &SESSION,
+            )
             .unwrap();
 
-        let original_data = sliced.to_primitive();
+        let original_data = sliced.as_array().to_primitive();
         let decoded_data = decoded.to_primitive();
 
         assert_arrays_eq!(original_data, decoded_data);
     }
+
+    /// Regression test: re-encoding RLE indices with RLE must not corrupt
+    /// chunk-local index values via cross-chunk fill-forward.
+    ///
+    /// The scenario: an array spanning 2 chunks where chunk 0 has 2 distinct
+    /// non-null values (producing chunk-local indices 0 and 1) and chunk 1 is
+    /// entirely null. When fill_forward_nulls propagated the last valid index
+    /// (1) from chunk 0 into chunk 1 during re-encoding, decoding panicked
+    /// because chunk 1 only had 1 unique value and index 1 was out of bounds.
+    #[test]
+    fn test_recompress_indices_no_cross_chunk_leak() -> VortexResult<()> {
+        let len = FL_CHUNK_SIZE + 100;
+        let mut values: Vec<Option<i16>> = vec![None; len];
+        // Two distinct values in chunk 0 → indices 0 and 1.
+        values[0] = Some(10);
+        values[500] = Some(20);
+        // Chunk 1 (positions 1024..) is all-null.
+
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+
+        // Simulate cascading compression: narrow u16→u8 then re-encode with RLE,
+        // matching the path taken by the BtrBlocks compressor.
+        let indices_prim = rle.indices().to_primitive().narrow()?;
+        let re_encoded = RLEData::encode(&indices_prim)?;
+
+        // Reconstruct the outer RLE with re-encoded indices.
+        // SAFETY: we only replace the indices child; all other invariants hold.
+        let reconstructed = unsafe {
+            RLE::new_unchecked(
+                rle.values().clone(),
+                re_encoded.into_array(),
+                rle.values_idx_offsets().clone(),
+                rle.offset(),
+                rle.len(),
+            )
+        };
+
+        // Decompress — panicked before the fill_forward_nulls chunk-boundary fix.
+        let decoded = reconstructed.as_array().to_primitive();
+        assert_arrays_eq!(decoded, original);
+        Ok(())
+    }
 }
diff --git a/encodings/fastlanes/src/rle/array/rle_compress.rs b/encodings/fastlanes/src/rle/array/rle_compress.rs
index 33185dcebbf..36ec3a22a03 100644
--- a/encodings/fastlanes/src/rle/array/rle_compress.rs
+++ b/encodings/fastlanes/src/rle/array/rle_compress.rs
@@ -1,27 +1,31 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use arrayref::array_mut_ref;
-use arrayref::array_ref;
-use fastlanes::RLE;
+use std::mem;
+
+use fastlanes::RLE as FastLanesRLE;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
-use vortex_array::arrays::NativeValue;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::primitive::NativeValue;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_native_ptype;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BitBufferMut;
 use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::FL_CHUNK_SIZE;
+use crate::RLE;
 use crate::RLEArray;
+use crate::RLEData;
+use crate::fill_forward_nulls;
 
-impl RLEArray {
+impl RLEData {
     /// Encodes a primitive array of unsigned integers using FastLanes RLE.
-    pub fn encode(array: &PrimitiveArray) -> VortexResult<Self> {
+    pub fn encode(array: &PrimitiveArray) -> VortexResult<RLEArray> {
         match_each_native_ptype!(array.ptype(), |T| { rle_encode_typed::<T>(array) })
     }
 }
@@ -31,10 +35,12 @@ impl RLEArray {
 /// In case the input array length is % 1024 != 0, the last chunk is padded.
 fn rle_encode_typed<T>(array: &PrimitiveArray) -> VortexResult<RLEArray>
 where
-    T: NativePType + RLE,
-    NativeValue<T>: RLE,
+    T: NativePType + FastLanesRLE,
+    NativeValue<T>: FastLanesRLE,
 {
-    let values = array.as_slice::<T>();
+    // Fill-forward null values so the RLE encoder doesn't see garbage at null positions,
+    // which would create spurious run boundaries and inflate the dictionary.
+    let values = fill_forward_nulls(array.to_buffer::<T>(), &array.validity()?);
     let len = values.len();
     let padded_len = len.next_multiple_of(FL_CHUNK_SIZE);
 
@@ -46,50 +52,51 @@ where
     let mut values_idx_offsets = BufferMut::<u64>::with_capacity(len.div_ceil(FL_CHUNK_SIZE));
 
     let values_uninit = values_buf.spare_capacity_mut();
-    let indices_uninit = indices_buf.spare_capacity_mut();
+    // We don't care about the trailing chunk that exists due to overallocation by the underlying allocator.
+    let (indices_uninit, _) = indices_buf
+        .spare_capacity_mut()
+        .as_chunks_mut::<FL_CHUNK_SIZE>();
     let mut value_count_acc = 0; // Chunk value count prefix sum.
 
-    let mut chunks = values.chunks_exact(FL_CHUNK_SIZE);
-
-    let mut process_chunk = |chunk_start_idx: usize, input: &[T; FL_CHUNK_SIZE]| {
-        // SAFETY: NativeValue is repr(transparent)
-        let input: &[NativeValue<T>; FL_CHUNK_SIZE] = unsafe { std::mem::transmute(input) };
+    let (chunks, remainder) = values.as_chunks::<FL_CHUNK_SIZE>();
 
-        // SAFETY: `MaybeUninit<NativeValue<T>>` and `NativeValue<T>` have the same layout.
-        let rle_vals: &mut [NativeValue<T>] =
-            unsafe { std::mem::transmute(&mut values_uninit[value_count_acc..][..FL_CHUNK_SIZE]) };
+    let mut process_chunk =
+        |input: &[T; FL_CHUNK_SIZE], rle_idxs: &mut [mem::MaybeUninit<u16>; FL_CHUNK_SIZE]| {
+            // SAFETY: NativeValue is repr(transparent)
+            let input: &[NativeValue<T>; FL_CHUNK_SIZE] = unsafe { mem::transmute(input) };
+            let rle_idxs: &mut [u16; FL_CHUNK_SIZE] = unsafe { mem::transmute(rle_idxs) };
 
-        // SAFETY: `MaybeUninit<u16>` and `u16` have the same layout.
-        let rle_idxs: &mut [u16] =
-            unsafe { std::mem::transmute(&mut indices_uninit[chunk_start_idx..][..FL_CHUNK_SIZE]) };
+            // SAFETY: `MaybeUninit<NativeValue<T>>` and `NativeValue<T>` have the same layout.
+            let rle_vals: &mut [NativeValue<T>] =
+                unsafe { mem::transmute(&mut values_uninit[value_count_acc..][..FL_CHUNK_SIZE]) };
 
-        // Capture chunk start indices. This is necessary as indices
-        // returned from `T::encode` are relative to the chunk.
-        values_idx_offsets.push(value_count_acc as u64);
+            // Capture chunk start indices. This is necessary as indices
+            // returned from `T::encode` are relative to the chunk.
+            values_idx_offsets.push(value_count_acc as u64);
 
-        let value_count = NativeValue::<T>::encode(
-            input,
-            array_mut_ref![rle_vals, 0, FL_CHUNK_SIZE],
-            array_mut_ref![rle_idxs, 0, FL_CHUNK_SIZE],
-        );
+            let value_count = NativeValue::<T>::encode(
+                input,
+                unsafe { &mut *(rle_vals.as_mut_ptr() as *mut [_; FL_CHUNK_SIZE]) },
+                rle_idxs,
+            );
 
-        value_count_acc += value_count;
-    };
+            value_count_acc += value_count;
+        };
 
-    for (chunk_idx, chunk_slice) in chunks.by_ref().enumerate() {
-        process_chunk(
-            chunk_idx * FL_CHUNK_SIZE,
-            array_ref![chunk_slice, 0, FL_CHUNK_SIZE],
-        );
+    for (chunk_slice, rle_idxs) in chunks.iter().zip(indices_uninit.iter_mut()) {
+        // SAFETY: `MaybeUninit<u16>` and `u16` have the same layout.
+        process_chunk(chunk_slice, rle_idxs);
     }
 
-    let remainder = chunks.remainder();
     if !remainder.is_empty() {
         // Repeat the last value for padding to prevent
         // accounting for an additional value change.
         let mut padded_chunk = [values[len - 1]; FL_CHUNK_SIZE];
         padded_chunk[..remainder.len()].copy_from_slice(remainder);
-        process_chunk((len / FL_CHUNK_SIZE) * FL_CHUNK_SIZE, &padded_chunk);
+        // There might be more entries in indices_uninit than necessary if the allocator gave us extra memory.
+        // Remainder has to go to the last chunk after full chunks have been processed.
+        let last_idx_chunk = &mut indices_uninit[chunks.len()];
+        process_chunk(&padded_chunk, last_idx_chunk);
     }
 
     unsafe {
@@ -100,7 +107,7 @@ where
     // SAFETY: NativeValue<T> is repr(transparent) to T.
     let values_buf = unsafe { values_buf.transmute::<T>().freeze() };
 
-    RLEArray::try_new(
+    RLE::try_new(
         values_buf.into_array(),
         PrimitiveArray::new(indices_buf.freeze(), padded_validity(array)).into_array(),
         values_idx_offsets.into_array(),
@@ -111,7 +118,10 @@ where
 
 /// Returns validity padded to the next 1024 chunk for a given array.
 fn padded_validity(array: &PrimitiveArray) -> Validity {
-    match array.validity() {
+    match array
+        .validity()
+        .vortex_expect("RLE validity should be derivable")
+    {
         Validity::NonNullable => Validity::NonNullable,
         Validity::AllValid => Validity::AllValid,
         Validity::AllInvalid => Validity::AllInvalid,
@@ -120,7 +130,7 @@ fn padded_validity(array: &PrimitiveArray) -> Validity {
             let padded_len = len.next_multiple_of(FL_CHUNK_SIZE);
 
             if len == padded_len {
-                return Validity::Array(validity_array.clone());
+                return Validity::Array(validity_array);
             }
 
             let mut builder = BitBufferMut::with_capacity(padded_len);
@@ -139,52 +149,56 @@ mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
+    use vortex_array::arrays::ConstantArray;
+    use vortex_array::arrays::MaskedArray;
+    use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::half::f16;
     use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
 
     use super::*;
+    use crate::rle::array::RLEArrayExt;
 
     #[test]
     fn test_encode_decode() {
         // u8
-        let values_u8: Buffer<u8> = [1, 1, 2, 2, 3, 3].iter().copied().collect();
-        let array_u8 = values_u8.into_array();
-        let encoded_u8 = RLEArray::encode(&array_u8.to_primitive()).unwrap();
-        let decoded_u8 = encoded_u8.to_primitive();
+        let array_u8: Buffer<u8> = buffer![1, 1, 2, 2, 3, 3];
+        let encoded_u8 =
+            RLEData::encode(&PrimitiveArray::new(array_u8, Validity::NonNullable)).unwrap();
+        let decoded_u8 = encoded_u8.as_array().to_primitive();
         let expected_u8 = PrimitiveArray::from_iter(vec![1u8, 1, 2, 2, 3, 3]);
         assert_arrays_eq!(decoded_u8, expected_u8);
 
         // u16
-        let values_u16: Buffer<u16> = [100, 100, 200, 200].iter().copied().collect();
-        let array_u16 = values_u16.into_array();
-        let encoded_u16 = RLEArray::encode(&array_u16.to_primitive()).unwrap();
-        let decoded_u16 = encoded_u16.to_primitive();
+        let array_u16: Buffer<u16> = buffer![100, 100, 200, 200];
+        let encoded_u16 =
+            RLEData::encode(&PrimitiveArray::new(array_u16, Validity::NonNullable)).unwrap();
+        let decoded_u16 = encoded_u16.as_array().to_primitive();
         let expected_u16 = PrimitiveArray::from_iter(vec![100u16, 100, 200, 200]);
         assert_arrays_eq!(decoded_u16, expected_u16);
 
         // u64
-        let values_u64: Buffer<u64> = [1000, 1000, 2000].iter().copied().collect();
-        let array_u64 = values_u64.into_array();
-        let encoded_u64 = RLEArray::encode(&array_u64.to_primitive()).unwrap();
-        let decoded_u64 = encoded_u64.to_primitive();
+        let array_u64: Buffer<u64> = buffer![1000, 1000, 2000];
+        let encoded_u64 =
+            RLEData::encode(&PrimitiveArray::new(array_u64, Validity::NonNullable)).unwrap();
+        let decoded_u64 = encoded_u64.as_array().to_primitive();
         let expected_u64 = PrimitiveArray::from_iter(vec![1000u64, 1000, 2000]);
         assert_arrays_eq!(decoded_u64, expected_u64);
     }
 
     #[test]
     fn test_length() {
-        let values: Buffer<u32> = [1, 1, 2, 2, 2, 3].iter().copied().collect();
-        let array = values.into_array();
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let values: Buffer<u32> = buffer![1, 1, 2, 2, 2, 3];
+        let encoded = RLEData::encode(&PrimitiveArray::new(values, Validity::NonNullable)).unwrap();
         assert_eq!(encoded.len(), 6);
     }
 
     #[test]
     fn test_empty_length() {
         let values: Buffer<u32> = Buffer::empty();
-        let array = values.into_array();
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&PrimitiveArray::new(values, Validity::NonNullable)).unwrap();
 
         assert_eq!(encoded.len(), 0);
         assert_eq!(encoded.values().len(), 0);
@@ -193,12 +207,11 @@ mod tests {
     #[test]
     fn test_single_value() {
         let values: Buffer<u16> = vec![42; 2000].into_iter().collect();
-        let array = values.into_array();
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&PrimitiveArray::new(values, Validity::NonNullable)).unwrap();
         assert_eq!(encoded.values().len(), 2); // 2 chunks, each storing value 42
 
-        let decoded = encoded.to_primitive(); // Verify round-trip
+        let decoded = encoded.as_array().to_primitive(); // Verify round-trip
         let expected = PrimitiveArray::from_iter(vec![42u16; 2000]);
         assert_arrays_eq!(decoded, expected);
     }
@@ -206,12 +219,11 @@ mod tests {
     #[test]
     fn test_all_different() {
         let values: Buffer<u8> = (0u8..=255).collect();
-        let array = values.into_array();
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&PrimitiveArray::new(values, Validity::NonNullable)).unwrap();
         assert_eq!(encoded.values().len(), 256);
 
-        let decoded = encoded.to_primitive(); // Verify round-trip
+        let decoded = encoded.as_array().to_primitive(); // Verify round-trip
         let expected = PrimitiveArray::from_iter((0u8..=255).collect::<Vec<_>>());
         assert_arrays_eq!(decoded, expected);
     }
@@ -220,9 +232,9 @@ mod tests {
     fn test_partial_last_chunk() {
         // Test array with partial last chunk (not divisible by 1024)
         let values: Buffer<u32> = (0..1500).map(|i| (i / 100) as u32).collect();
-        let array = values.into_array();
+        let array = PrimitiveArray::new(values, Validity::NonNullable);
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&array).unwrap();
 
         assert_eq!(encoded.len(), 1500);
         assert_arrays_eq!(encoded, array);
@@ -234,9 +246,9 @@ mod tests {
     fn test_two_full_chunks() {
         // Array that spans exactly 2 chunks (2048 elements)
         let values: Buffer<u32> = (0..2048).map(|i| (i / 100) as u32).collect();
-        let array = values.into_array();
+        let array = PrimitiveArray::new(values, Validity::NonNullable);
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&array).unwrap();
 
         assert_eq!(encoded.len(), 2048);
         assert_arrays_eq!(encoded, array);
@@ -257,22 +269,207 @@ mod tests {
     #[case::f64((-2000..2000).map(|i| i as f64).collect::<Buffer<f64>>())]
     fn test_roundtrip_primitive_types<T: NativePType>(#[case] values: Buffer<T>) {
         let primitive = values.clone().into_array().to_primitive();
-        let result = RLEArray::encode(&primitive).unwrap();
-        let decoded = result.to_primitive();
-        let expected = PrimitiveArray::new(values, primitive.validity().clone());
+        let result = RLEData::encode(&primitive).unwrap();
+        let decoded = result.as_array().to_primitive();
+        let expected = PrimitiveArray::new(
+            values,
+            primitive
+                .validity()
+                .vortex_expect("primitive validity should be derivable"),
+        );
         assert_arrays_eq!(decoded, expected);
     }
 
+    /// Replaces the indices of an RLE array with MaskedArray(ConstantArray(1u16), validity).
+    ///
+    /// Simulates a compressor that represents indices as a masked constant.
+    /// Valid when every chunk has at least two RLE dictionary entries (the
+    /// fill-forward default at index 0 and the actual value at index 1), which
+    /// holds whenever the first position of each chunk is null.
+    fn with_masked_constant_indices(rle: &RLEArray) -> VortexResult<RLEArray> {
+        let indices_prim = rle.indices().to_primitive();
+        let masked_indices = MaskedArray::try_new(
+            ConstantArray::new(1u16, indices_prim.len()).into_array(),
+            indices_prim.validity()?,
+        )?
+        .into_array();
+        RLE::try_new(
+            rle.values().clone(),
+            masked_indices,
+            rle.values_idx_offsets().clone(),
+            rle.offset(),
+            rle.len(),
+        )
+    }
+
+    #[test]
+    fn test_encode_all_null_chunk() -> VortexResult<()> {
+        let values: Vec<Option<u32>> = vec![None; FL_CHUNK_SIZE];
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let decoded = with_masked_constant_indices(&rle)?;
+        assert_arrays_eq!(decoded, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_encode_all_null_chunk_then_value_chunk() -> VortexResult<()> {
+        // First chunk is entirely null, second chunk has a value preceded by nulls.
+        let mut values: Vec<Option<u32>> = vec![None; 2 * FL_CHUNK_SIZE];
+        values[FL_CHUNK_SIZE + 100] = Some(42);
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let decoded = with_masked_constant_indices(&rle)?;
+        assert_arrays_eq!(decoded, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_encode_one_value_near_end() -> VortexResult<()> {
+        // Single distinct value near the end of the chunk.
+        let mut values: Vec<Option<u32>> = vec![None; FL_CHUNK_SIZE];
+        values[1000] = Some(42);
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let decoded = with_masked_constant_indices(&rle)?;
+        assert_arrays_eq!(decoded, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_encode_value_chunk_then_all_null_remainder() -> VortexResult<()> {
+        // 1085 elements (2 chunks: 1024 + 61 padded to 1024).
+        // Chunk 0 has -1i16 at scattered positions (273..=366), rest null.
+        // Chunk 1 (the remainder) is entirely null.
+        const NEG1_POSITIONS: &[usize] = &[
+            273, 276, 277, 278, 279, 281, 282, 284, 285, 286, 287, 288, 289, 291, 292, 293, 296,
+            298, 299, 302, 304, 308, 310, 311, 313, 314, 315, 317, 318, 322, 324, 325, 334, 335,
+            336, 337, 338, 339, 340, 341, 342, 343, 344, 346, 347, 348, 350, 352, 353, 355, 358,
+            359, 362, 363, 364, 366,
+        ];
+        let mut values: Vec<Option<i16>> = vec![None; 1085];
+        for &pos in NEG1_POSITIONS {
+            values[pos] = Some(-1);
+        }
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let decoded = with_masked_constant_indices(&rle)?;
+        assert_arrays_eq!(decoded, original);
+        Ok(())
+    }
+
+    /// Replaces indices at invalid (null) positions with random garbage values.
+    ///
+    /// This simulates a compressor that doesn't preserve index values at null
+    /// positions, which can happen when indices are further compressed and the
+    /// compressor clobbers invalid entries with arbitrary data.
+    fn with_random_invalid_indices(rle: &RLEArray) -> VortexResult<RLEArray> {
+        let indices_prim = rle.indices().to_primitive();
+        let mut indices_data: Vec<u16> = indices_prim.as_slice::<u16>().to_vec();
+
+        // Use a simple deterministic "random" sequence.
+        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) {
+                // xorshift32
+                rng_state ^= rng_state << 13;
+                rng_state ^= rng_state >> 17;
+                rng_state ^= rng_state << 5;
+                *idx = rng_state as u16;
+            }
+        }
+
+        let clobbered_indices =
+            PrimitiveArray::new(Buffer::from(indices_data), indices_prim.validity()?).into_array();
+
+        RLE::try_new(
+            rle.values().clone(),
+            clobbered_indices,
+            rle.values_idx_offsets().clone(),
+            rle.offset(),
+            rle.len(),
+        )
+    }
+
+    #[test]
+    fn test_random_invalid_indices_all_null_chunk() -> VortexResult<()> {
+        let values: Vec<Option<u32>> = vec![None; FL_CHUNK_SIZE];
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let clobbered = with_random_invalid_indices(&rle)?;
+        assert_arrays_eq!(clobbered, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_random_invalid_indices_sparse_values() -> VortexResult<()> {
+        let mut values: Vec<Option<u32>> = vec![None; FL_CHUNK_SIZE];
+        values[0] = Some(10);
+        values[500] = Some(20);
+        values[1000] = Some(30);
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let clobbered = with_random_invalid_indices(&rle)?;
+        assert_arrays_eq!(clobbered, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_random_invalid_indices_multi_chunk() -> VortexResult<()> {
+        // Two chunks: first has scattered values, second is all null.
+        let mut values: Vec<Option<i16>> = vec![None; 2 * FL_CHUNK_SIZE];
+        values[0] = Some(10);
+        values[500] = Some(20);
+        values[FL_CHUNK_SIZE + 100] = Some(42);
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let clobbered = with_random_invalid_indices(&rle)?;
+        assert_arrays_eq!(clobbered, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_random_invalid_indices_partial_last_chunk() -> VortexResult<()> {
+        // 1085 elements: chunk 0 has values at scattered positions, chunk 1 is
+        // a partial (61 elements padded to 1024) that is entirely null.
+        let mut values: Vec<Option<u32>> = vec![None; 1085];
+        for i in (100..200).step_by(7) {
+            values[i] = Some(i as u32);
+        }
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let clobbered = with_random_invalid_indices(&rle)?;
+        assert_arrays_eq!(clobbered, original);
+        Ok(())
+    }
+
+    #[test]
+    fn test_random_invalid_indices_mostly_valid() -> VortexResult<()> {
+        // Most positions are valid, only a few are null with garbage indices.
+        let mut values: Vec<Option<u64>> =
+            (0..FL_CHUNK_SIZE).map(|i| Some((i / 100) as u64)).collect();
+        // Sprinkle in some nulls.
+        for i in (0..FL_CHUNK_SIZE).step_by(37) {
+            values[i] = None;
+        }
+        let original = PrimitiveArray::from_option_iter(values);
+        let rle = RLEData::encode(&original)?;
+        let clobbered = with_random_invalid_indices(&rle)?;
+        assert_arrays_eq!(clobbered, original);
+        Ok(())
+    }
+
     // Regression test: RLE compression properly supports decoding pos/neg zeros
     // See <https://github.com/vortex-data/vortex/issues/6491>
     #[rstest]
     #[case(vec![f16::ZERO, f16::NEG_ZERO])]
     #[case(vec![0f32, -0f32])]
     #[case(vec![0f64, -0f64])]
-    fn test_float_zeros<T: NativePType + RLE>(#[case] values: Vec<T>) {
+    fn test_float_zeros<T: NativePType + fastlanes::RLE>(#[case] values: Vec<T>) {
         let primitive = PrimitiveArray::from_iter(values);
-        let rle = RLEArray::encode(&primitive).unwrap();
-        let decoded = rle.to_primitive();
+        let rle = RLEData::encode(&primitive).unwrap();
+        let decoded = rle.as_array().to_primitive();
         assert_arrays_eq!(primitive, decoded);
     }
 }
diff --git a/encodings/fastlanes/src/rle/array/rle_decompress.rs b/encodings/fastlanes/src/rle/array/rle_decompress.rs
index 1874269f8c3..d9c31b5de60 100644
--- a/encodings/fastlanes/src/rle/array/rle_decompress.rs
+++ b/encodings/fastlanes/src/rle/array/rle_decompress.rs
@@ -1,23 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use arrayref::array_mut_ref;
-use arrayref::array_ref;
 use fastlanes::RLE;
 use num_traits::AsPrimitive;
-use vortex_array::Array;
+use num_traits::NumCast;
 use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_native_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::validity::Validity;
 use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::FL_CHUNK_SIZE;
 use crate::RLEArray;
+use crate::rle::RLEArrayExt;
 
 /// Decompresses an RLE array back into a primitive array.
 #[expect(
@@ -54,15 +55,16 @@ where
     let values = values.as_slice::<V>();
 
     let indices = array.indices().clone().execute::<PrimitiveArray>(ctx)?;
-    let indices = indices.as_slice::<I>();
-    assert_eq!(indices.len() % FL_CHUNK_SIZE, 0);
+    assert!(indices.len().is_multiple_of(FL_CHUNK_SIZE));
+    let has_invalid = !indices.all_valid()?;
+    let (indices_sl, _) = indices.as_slice::<I>().as_chunks::<FL_CHUNK_SIZE>();
 
     let chunk_start_idx = array.offset() / FL_CHUNK_SIZE;
     let chunk_end_idx = (array.offset() + array.len()).div_ceil(FL_CHUNK_SIZE);
     let num_chunks = chunk_end_idx - chunk_start_idx;
 
     let mut buffer = BufferMut::<V>::with_capacity(num_chunks * FL_CHUNK_SIZE);
-    let buffer_uninit = buffer.spare_capacity_mut();
+    let (out_buf, _) = buffer.spare_capacity_mut().as_chunks_mut::<FL_CHUNK_SIZE>();
 
     let values_idx_offsets = array
         .values_idx_offsets()
@@ -70,26 +72,46 @@ where
         .execute::<PrimitiveArray>(ctx)?;
     let values_idx_offsets = values_idx_offsets.as_slice::<O>();
 
-    for chunk_idx in 0..num_chunks {
+    for (chunk_idx, (chunk_indices, chunk_out)) in
+        indices_sl.iter().zip(out_buf.iter_mut()).enumerate()
+    {
         // Offsets in `values_idx_offsets` are absolute and need to be shifted
-        // by the offset of the first chunk, respective the current slice, in
-        // order to make them relative.
+        // by the offset of the first chunk, respective of the current slice,
+        // to make them relative.
         let value_idx_offset =
             (values_idx_offsets[chunk_idx].as_() - values_idx_offsets[0].as_()) as usize;
 
-        let chunk_values = &values[value_idx_offset..];
-        let chunk_indices = &indices[chunk_idx * FL_CHUNK_SIZE..];
-
-        // SAFETY: `MaybeUninit<T>` and `T` have the same layout.
-        let buffer_values: &mut [V] = unsafe {
-            std::mem::transmute(&mut buffer_uninit[chunk_idx * FL_CHUNK_SIZE..][..FL_CHUNK_SIZE])
+        let next_value_idx_offset = if chunk_idx + 1 < num_chunks {
+            (values_idx_offsets[chunk_idx + 1].as_() - values_idx_offsets[0].as_()) as usize
+        } else {
+            values.len()
         };
+        let num_chunk_values = u16::try_from(next_value_idx_offset - value_idx_offset)
+            .vortex_expect("There can be at most 1024 values in RLE chunk");
 
-        V::decode(
-            chunk_values,
-            array_ref![chunk_indices, 0, FL_CHUNK_SIZE],
-            array_mut_ref![buffer_values, 0, FL_CHUNK_SIZE],
-        );
+        // SAFETY: `MaybeUninit<T>` and `T` have the same layout.
+        let buffer_values: &mut [V; FL_CHUNK_SIZE] = unsafe { std::mem::transmute(chunk_out) };
+        let chunk_values = &values[value_idx_offset..];
+        if num_chunk_values == 1 {
+            // Single-value chunk: fill directly to avoid out-of-bounds index
+            // access. The indices may contain values other than 0 when they
+            // have been further compressed (e.g., as a masked constant).
+            buffer_values.fill(chunk_values[0]);
+        } else if has_invalid {
+            // When the indices array has invalid (null) positions, those
+            // positions may contain arbitrary garbage values after further
+            // compression. Clamp all indices into [0, num_chunk_values) to
+            // prevent out-of-bounds access in the fastlanes decoder.
+            let mut sanitized: [u16; FL_CHUNK_SIZE] = [0; FL_CHUNK_SIZE];
+            for (idx_out, idx) in sanitized.iter_mut().zip(chunk_indices) {
+                let idx: u16 =
+                    NumCast::from(*idx).vortex_expect("RLE indices are always less than u16");
+                *idx_out = idx.min(num_chunk_values - 1);
+            }
+            V::decode(chunk_values, &sanitized, buffer_values);
+        } else {
+            V::decode(chunk_values, chunk_indices, buffer_values);
+        }
     }
 
     unsafe {
@@ -102,6 +124,6 @@ where
         buffer
             .freeze()
             .slice(offset_within_chunk..(offset_within_chunk + array.len())),
-        Validity::copy_from_array(array.as_ref())?,
+        Validity::copy_from_array(&array.clone().into_array())?,
     ))
 }
diff --git a/encodings/fastlanes/src/rle/compute/cast.rs b/encodings/fastlanes/src/rle/compute/cast.rs
index f6b34e9eef9..95286d2f3e7 100644
--- a/encodings/fastlanes/src/rle/compute/cast.rs
+++ b/encodings/fastlanes/src/rle/compute/cast.rs
@@ -1,20 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::rle::RLEArray;
-use crate::rle::RLEVTable;
-
-impl CastReduce for RLEVTable {
-    fn cast(array: &RLEArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::rle::RLE;
+use crate::rle::RLEArrayExt;
+impl CastReduce for RLE {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Cast RLE values.
-        let casted_values = array.values().cast(dtype.clone())?;
+        let casted_values = array
+            .values()
+            .cast(DType::Primitive(dtype.as_ptype(), Nullability::NonNullable))?;
 
         // Cast RLE indices such that validity matches the target dtype.
         let casted_indices = if array.indices().dtype().nullability() != dtype.nullability() {
@@ -26,26 +29,25 @@ impl CastReduce for RLEVTable {
             array.indices().clone()
         };
 
-        Ok(Some(unsafe {
-            RLEArray::new_unchecked(
+        Ok(Some(
+            RLE::try_new(
                 casted_values,
                 casted_indices,
                 array.values_idx_offsets().clone(),
-                dtype.clone(),
                 array.offset(),
                 array.len(),
-            )
-            .into()
-        }))
+            )?
+            .into_array(),
+        ))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
     use vortex_array::dtype::DType;
@@ -54,24 +56,26 @@ mod tests {
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
 
+    use crate::RLEData;
     use crate::rle::RLEArray;
 
+    fn rle(primitive: &PrimitiveArray) -> RLEArray {
+        RLEData::encode(primitive).unwrap()
+    }
+
     #[test]
     fn try_cast_rle_success() {
         let primitive = PrimitiveArray::new(
             Buffer::from_iter([10u8, 20, 30, 40, 50]),
             Validity::from_iter([true, true, true, true, true]),
         );
-        let rle = RLEArray::encode(&primitive).unwrap();
+        let encoded = rle(&primitive);
 
-        let res = rle
-            .to_array()
-            .cast(DType::Primitive(PType::U16, Nullability::NonNullable));
-        assert!(res.is_ok());
-        assert_eq!(
-            res.unwrap().dtype(),
-            &DType::Primitive(PType::U16, Nullability::NonNullable)
-        );
+        let casted = encoded
+            .into_array()
+            .cast(DType::Primitive(PType::U16, Nullability::NonNullable))
+            .unwrap();
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([10u16, 20, 30, 40, 50]));
     }
 
     #[test]
@@ -81,8 +85,9 @@ mod tests {
             Buffer::from_iter([10u8, 20, 30, 40, 50]),
             Validity::from_iter([true, false, true, true, false]),
         );
-        let rle = RLEArray::encode(&primitive).unwrap();
-        rle.to_array()
+        let encoded = rle(&primitive);
+        encoded
+            .into_array()
             .cast(DType::Primitive(PType::U8, Nullability::NonNullable))
             .and_then(|a| a.to_canonical().map(|c| c.into_array()))
             .unwrap();
@@ -138,7 +143,7 @@ mod tests {
         )
     )]
     fn test_cast_rle_conformance(#[case] primitive: PrimitiveArray) {
-        let rle_array = RLEArray::encode(&primitive).unwrap();
-        test_cast_conformance(rle_array.as_ref());
+        let rle_array = rle(&primitive);
+        test_cast_conformance(&rle_array.into_array());
     }
 }
diff --git a/encodings/fastlanes/src/rle/kernel.rs b/encodings/fastlanes/src/rle/kernel.rs
index a765755f4c3..14eaf6dda3d 100644
--- a/encodings/fastlanes/src/rle/kernel.rs
+++ b/encodings/fastlanes/src/rle/kernel.rs
@@ -4,23 +4,24 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceExecuteAdaptor;
-use vortex_array::arrays::SliceKernel;
+use vortex_array::arrays::slice::SliceExecuteAdaptor;
+use vortex_array::arrays::slice::SliceKernel;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_error::VortexResult;
 
 use crate::FL_CHUNK_SIZE;
-use crate::RLEArray;
-use crate::RLEVTable;
+use crate::RLE;
+use crate::rle::RLEArrayExt;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<RLEVTable> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&SliceExecuteAdaptor(RLEVTable))]);
+pub(crate) static PARENT_KERNELS: ParentKernelSet<RLE> =
+    ParentKernelSet::new(&[ParentKernelSet::lift(&SliceExecuteAdaptor(RLE))]);
 
-impl SliceKernel for RLEVTable {
+impl SliceKernel for RLE {
     fn slice(
-        array: &RLEArray,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -45,18 +46,16 @@ impl SliceKernel for RLEVTable {
             .indices()
             .slice(chunk_start_idx * FL_CHUNK_SIZE..chunk_end_idx * FL_CHUNK_SIZE)?;
 
-        // SAFETY: Slicing preserves all invariants.
-        Ok(Some(unsafe {
-            RLEArray::new_unchecked(
+        Ok(Some(
+            RLE::try_new(
                 sliced_values,
                 sliced_indices,
                 sliced_values_idx_offsets,
-                array.dtype().clone(),
                 // Keep the offset relative to the first chunk.
                 (array.offset() + range.start) % FL_CHUNK_SIZE,
                 range.len(),
-            )
-            .into_array()
-        }))
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/fastlanes/src/rle/mod.rs b/encodings/fastlanes/src/rle/mod.rs
index f3400fcfe21..1c580683908 100644
--- a/encodings/fastlanes/src/rle/mod.rs
+++ b/encodings/fastlanes/src/rle/mod.rs
@@ -2,10 +2,12 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::RLEArray;
+pub use array::RLEArrayExt;
+pub use array::RLEData;
 
 mod compute;
 mod kernel;
 
 mod vtable;
-pub use vtable::RLEVTable;
+pub use vtable::RLE;
+pub use vtable::RLEArray;
diff --git a/encodings/fastlanes/src/rle/vtable/array.rs b/encodings/fastlanes/src/rle/vtable/array.rs
deleted file mode 100644
index 8dfced11793..00000000000
--- a/encodings/fastlanes/src/rle/vtable/array.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use vortex_array::ArrayEq;
-use vortex_array::ArrayHash;
-use vortex_array::Precision;
-use vortex_array::dtype::DType;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable::BaseArrayVTable;
-
-use super::RLEVTable;
-use crate::RLEArray;
-
-impl BaseArrayVTable<RLEVTable> for RLEVTable {
-    fn len(array: &RLEArray) -> usize {
-        array.len()
-    }
-
-    fn dtype(array: &RLEArray) -> &DType {
-        array.dtype()
-    }
-
-    fn stats(array: &RLEArray) -> StatsSetRef<'_> {
-        array.stats_set().to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &RLEArray, state: &mut H, precision: Precision) {
-        array.dtype().hash(state);
-        array.values().array_hash(state, precision);
-        array.indices().array_hash(state, precision);
-        array.values_idx_offsets().array_hash(state, precision);
-        array.offset().hash(state);
-        array.len().hash(state);
-    }
-
-    fn array_eq(array: &RLEArray, other: &RLEArray, precision: Precision) -> bool {
-        array.dtype() == other.dtype()
-            && array.values().array_eq(other.values(), precision)
-            && array.indices().array_eq(other.indices(), precision)
-            && array
-                .values_idx_offsets()
-                .array_eq(other.values_idx_offsets(), precision)
-            && array.offset() == other.offset()
-            && array.len() == other.len()
-    }
-}
diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs
index 01527545134..c0e19efd3af 100644
--- a/encodings/fastlanes/src/rle/vtable/mod.rs
+++ b/encodings/fastlanes/src/rle/vtable/mod.rs
@@ -1,36 +1,49 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hash;
+use std::hash::Hasher;
+
 use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::ProstMetadata;
+use vortex_array::Precision;
+use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityVTableFromChildSliceHelper;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::RLEArray;
+use crate::RLEData;
+use crate::rle::array::INDICES_SLOT;
+use crate::rle::array::RLEArrayExt;
+use crate::rle::array::VALUES_IDX_OFFSETS_SLOT;
+use crate::rle::array::VALUES_SLOT;
 use crate::rle::array::rle_decompress::rle_decompress;
 use crate::rle::kernel::PARENT_KERNELS;
 use crate::rle::vtable::rules::RULES;
 
-mod array;
 mod operations;
 mod rules;
 mod validity;
-mod visitor;
 
-vtable!(RLE);
+/// A [`RLE`]-encoded Vortex array.
+pub type RLEArray = Array<RLE>;
 
 #[derive(Clone, prost::Message)]
 pub struct RLEMetadata {
@@ -48,80 +61,108 @@ pub struct RLEMetadata {
     pub offset: u64,
 }
 
-impl VTable for RLEVTable {
-    type Array = RLEArray;
+impl ArrayHash for RLEData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.offset.hash(state);
+    }
+}
 
-    type Metadata = ProstMetadata<RLEMetadata>;
+impl ArrayEq for RLEData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.offset == other.offset
+    }
+}
+
+impl VTable for RLE {
+    type ArrayData = RLEData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromChildSliceHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn reduce_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>> {
-        RULES.evaluate(array, parent, child_idx)
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        validate_parts(
+            slots[VALUES_SLOT]
+                .as_ref()
+                .vortex_expect("RLEArray values slot must be populated"),
+            slots[INDICES_SLOT]
+                .as_ref()
+                .vortex_expect("RLEArray indices slot must be populated"),
+            slots[VALUES_IDX_OFFSETS_SLOT]
+                .as_ref()
+                .vortex_expect("RLEArray values_idx_offsets slot must be populated"),
+            data.offset,
+            dtype,
+            len,
+        )
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // RLEArray children order (from visit_children):
-        // 1. values
-        // 2. indices
-        // 3. values_idx_offsets
-
-        vortex_ensure!(
-            children.len() == 3,
-            "Expected 3 children for RLE encoding, got {}",
-            children.len()
-        );
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
 
-        array.values = children[0].clone();
-        array.indices = children[1].clone();
-        array.values_idx_offsets = children[2].clone();
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("RLEArray buffer index {idx} out of bounds")
+    }
 
-        Ok(())
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn metadata(array: &RLEArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(RLEMetadata {
-            values_len: array.values().len() as u64,
-            indices_len: array.indices().len() as u64,
-            indices_ptype: PType::try_from(array.indices().dtype())? as i32,
-            values_idx_offsets_len: array.values_idx_offsets().len() as u64,
-            values_idx_offsets_ptype: PType::try_from(array.values_idx_offsets().dtype())? as i32,
-            offset: array.offset() as u64,
-        }))
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        RULES.evaluate(array, parent, child_idx)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        crate::rle::array::SLOT_NAMES[idx].to_string()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(RLEMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            RLEMetadata {
+                values_len: array.values().len() as u64,
+                indices_len: array.indices().len() as u64,
+                indices_ptype: PType::try_from(array.indices().dtype())? as i32,
+                values_idx_offsets_len: array.values_idx_offsets().len() as u64,
+                values_idx_offsets_ptype: PType::try_from(array.values_idx_offsets().dtype())?
+                    as i32,
+                offset: array.offset() as u64,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
+        metadata: &[u8],
+        buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<RLEArray> {
-        let metadata = &metadata.0;
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_ensure!(
+            buffers.is_empty(),
+            "RLEArray expects 0 buffers, got {}",
+            buffers.len()
+        );
+        let metadata = RLEMetadata::decode(metadata)?;
         let values = children.get(
             0,
             &DType::Primitive(dtype.as_ptype(), Nullability::NonNullable),
@@ -143,17 +184,13 @@ impl VTable for RLEVTable {
             usize::try_from(metadata.values_idx_offsets_len)?,
         )?;
 
-        RLEArray::try_new(
-            values,
-            indices,
-            values_idx_offsets,
-            metadata.offset as usize,
-            len,
-        )
+        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let data = RLEData::try_new(metadata.offset as usize)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -161,23 +198,126 @@ impl VTable for RLEVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(rle_decompress(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            rle_decompress(&array, ctx)?.into_array(),
+        ))
     }
 }
 
-#[derive(Debug)]
-pub struct RLEVTable;
+#[derive(Clone, Debug)]
+pub struct RLE;
 
-impl RLEVTable {
+impl RLE {
     pub const ID: ArrayId = ArrayId::new_ref("fastlanes.rle");
+
+    pub fn try_new(
+        values: ArrayRef,
+        indices: ArrayRef,
+        values_idx_offsets: ArrayRef,
+        offset: usize,
+        length: usize,
+    ) -> VortexResult<RLEArray> {
+        let dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
+        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let data = RLEData::try_new(offset)?;
+        Array::try_from_parts(ArrayParts::new(RLE, dtype, length, data).with_slots(slots))
+    }
+
+    /// Create a new RLE array without validation.
+    ///
+    /// # Safety
+    /// See [`RLE::validate`] for preconditions.
+    pub unsafe fn new_unchecked(
+        values: ArrayRef,
+        indices: ArrayRef,
+        values_idx_offsets: ArrayRef,
+        offset: usize,
+        length: usize,
+    ) -> RLEArray {
+        let dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
+        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let data = unsafe { RLEData::new_unchecked(offset) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(RLE, dtype, length, data).with_slots(slots))
+        }
+    }
+
+    /// Encode a primitive array using FastLanes RLE.
+    pub fn encode(array: &PrimitiveArray) -> VortexResult<RLEArray> {
+        RLEData::encode(array)
+    }
+}
+
+fn validate_parts(
+    values: &ArrayRef,
+    indices: &ArrayRef,
+    values_idx_offsets: &ArrayRef,
+    offset: usize,
+    dtype: &DType,
+    length: usize,
+) -> VortexResult<()> {
+    vortex_ensure!(
+        matches!(
+            values.dtype(),
+            DType::Primitive(_, Nullability::NonNullable)
+        ),
+        "RLE values must be a non-nullable primitive type, got {}",
+        values.dtype()
+    );
+
+    vortex_ensure!(
+        matches!(indices.dtype().as_ptype(), PType::U8 | PType::U16),
+        "RLE indices must be u8 or u16, got {}",
+        indices.dtype()
+    );
+
+    vortex_ensure!(
+        values_idx_offsets.dtype().is_unsigned_int() && !values_idx_offsets.dtype().is_nullable(),
+        "RLE value idx offsets must be non-nullable unsigned integer, got {}",
+        values_idx_offsets.dtype()
+    );
+
+    vortex_ensure!(
+        indices.len().is_multiple_of(crate::FL_CHUNK_SIZE),
+        "RLE indices length must be a multiple of {}, got {}",
+        crate::FL_CHUNK_SIZE,
+        indices.len()
+    );
+
+    vortex_ensure!(
+        offset + length <= indices.len(),
+        "RLE offset + length, {offset} + {length}, must not exceed the indices length {}",
+        indices.len()
+    );
+
+    vortex_ensure!(
+        indices.len().div_ceil(crate::FL_CHUNK_SIZE) == values_idx_offsets.len(),
+        "RLE must have one value idx offset per chunk, got {}",
+        values_idx_offsets.len()
+    );
+
+    vortex_ensure!(
+        indices.len() >= values.len(),
+        "RLE must have at least as many indices as values, got {} indices and {} values",
+        indices.len(),
+        values.len()
+    );
+
+    let expected_dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
+    vortex_ensure!(
+        dtype == &expected_dtype,
+        "RLE dtype mismatch: expected {expected_dtype}, got {dtype}"
+    );
+
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
+    use prost::Message;
     use vortex_array::test_harness::check_metadata;
 
-    use super::ProstMetadata;
     use super::RLEMetadata;
 
     #[cfg_attr(miri, ignore)]
@@ -185,14 +325,15 @@ mod tests {
     fn test_rle_metadata() {
         check_metadata(
             "rle.metadata",
-            ProstMetadata(RLEMetadata {
+            &RLEMetadata {
                 values_len: u64::MAX,
                 indices_len: u64::MAX,
                 indices_ptype: i32::MAX,
                 values_idx_offsets_len: u64::MAX,
                 values_idx_offsets_ptype: i32::MAX,
                 offset: u64::MAX,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/fastlanes/src/rle/vtable/operations.rs b/encodings/fastlanes/src/rle/vtable/operations.rs
index 6e45f8f949e..25069ecccc1 100644
--- a/encodings/fastlanes/src/rle/vtable/operations.rs
+++ b/encodings/fastlanes/src/rle/vtable/operations.rs
@@ -1,17 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use super::RLEVTable;
+use super::RLE;
 use crate::FL_CHUNK_SIZE;
-use crate::RLEArray;
-
-impl OperationsVTable<RLEVTable> for RLEVTable {
-    fn scalar_at(array: &RLEArray, index: usize) -> VortexResult<Scalar> {
+use crate::rle::RLEArrayExt;
+
+impl OperationsVTable<RLE> for RLE {
+    fn scalar_at(
+        array: ArrayView<'_, RLE>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let offset_in_chunk = array.offset();
         let chunk_relative_idx = array.indices().scalar_at(offset_in_chunk + index)?;
 
@@ -33,7 +39,6 @@ impl OperationsVTable<RLEVTable> for RLEVTable {
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
@@ -43,6 +48,9 @@ mod tests {
     use vortex_buffer::buffer;
 
     use super::*;
+    use crate::RLE;
+    use crate::RLEArray;
+    use crate::RLEData;
 
     mod fixture {
         use super::*;
@@ -59,14 +67,14 @@ mod tests {
             .into_array();
             let values_idx_offsets = PrimitiveArray::from_iter([0u64]).into_array();
 
-            RLEArray::try_new(
+            RLE::try_new(
                 values,
                 indices.clone(),
                 values_idx_offsets,
                 0,
                 indices.len(),
             )
-            .unwrap()
+            .vortex_expect("RLEData is always valid")
         }
 
         pub(super) fn rle_array_with_nulls() -> RLEArray {
@@ -94,14 +102,14 @@ mod tests {
             )
             .into_array();
 
-            RLEArray::try_new(
+            RLE::try_new(
                 values,
                 indices.clone(),
                 values_idx_offsets,
                 0,
                 indices.len(),
             )
-            .unwrap()
+            .vortex_expect("RLEData is always valid")
         }
     }
 
@@ -162,7 +170,7 @@ mod tests {
         let expected: Vec<u16> = (0..3000).map(|i| (i / 50) as u16).collect();
         let array = values.into_array();
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&array.to_primitive()).unwrap();
 
         // Access scalars from multiple chunks.
         for &idx in &[1023, 1024, 1025, 2047, 2048, 2049] {
@@ -207,7 +215,7 @@ mod tests {
             Some(30),
             Some(10),
         ]);
-        assert_arrays_eq!(sliced.to_array(), expected.to_array());
+        assert_arrays_eq!(sliced.into_array(), expected.into_array());
     }
 
     #[test]
@@ -216,7 +224,7 @@ mod tests {
         let sliced = array.slice(4..6).unwrap(); // [20, 30]
 
         let expected = buffer![20u32, 30].into_array();
-        assert_arrays_eq!(sliced.to_array(), expected);
+        assert_arrays_eq!(sliced, expected);
     }
 
     #[test]
@@ -225,7 +233,7 @@ mod tests {
         let sliced = array.slice(5..6).unwrap(); // [30]
 
         let expected = buffer![30u32].into_array();
-        assert_arrays_eq!(sliced.to_array(), expected);
+        assert_arrays_eq!(sliced, expected);
     }
 
     #[test]
@@ -242,16 +250,16 @@ mod tests {
         let sliced = array.slice(1..4).unwrap(); // [null, 20, 20]
 
         let expected = PrimitiveArray::from_option_iter([Option::<u32>::None, Some(20), Some(20)]);
-        assert_arrays_eq!(sliced.to_array(), expected.to_array());
+        assert_arrays_eq!(sliced.into_array(), expected.into_array());
     }
 
     #[test]
     fn test_slice_decode_with_nulls() {
         let array = fixture::rle_array_with_nulls();
-        let sliced = array.slice(1..4).unwrap().to_array().to_primitive(); // [null, 20, 20]
+        let sliced = array.slice(1..4).unwrap().to_primitive(); // [null, 20, 20]
 
         let expected = PrimitiveArray::from_option_iter([Option::<u32>::None, Some(20), Some(20)]);
-        assert_arrays_eq!(sliced.to_array(), expected.to_array());
+        assert_arrays_eq!(sliced.into_array(), expected.into_array());
     }
 
     #[test]
@@ -268,7 +276,7 @@ mod tests {
         let expected: Vec<u32> = (0..2100).map(|i| (i / 100) as u32).collect();
         let array = values.into_array();
 
-        let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
+        let encoded = RLEData::encode(&array.to_primitive()).unwrap();
 
         // Slice across first and second chunk.
         let slice = encoded.slice(500..1500).unwrap();
diff --git a/encodings/fastlanes/src/rle/vtable/rules.rs b/encodings/fastlanes/src/rle/vtable/rules.rs
index c20cd67c64b..50dd1f16a5a 100644
--- a/encodings/fastlanes/src/rle/vtable/rules.rs
+++ b/encodings/fastlanes/src/rle/vtable/rules.rs
@@ -4,7 +4,7 @@
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::RLEVTable;
+use crate::RLE;
 
-pub(crate) const RULES: ParentRuleSet<RLEVTable> =
-    ParentRuleSet::new(&[ParentRuleSet::lift(&CastReduceAdaptor(RLEVTable))]);
+pub(crate) const RULES: ParentRuleSet<RLE> =
+    ParentRuleSet::new(&[ParentRuleSet::lift(&CastReduceAdaptor(RLE))]);
diff --git a/encodings/fastlanes/src/rle/vtable/validity.rs b/encodings/fastlanes/src/rle/vtable/validity.rs
index 893a0677766..917b43da996 100644
--- a/encodings/fastlanes/src/rle/vtable/validity.rs
+++ b/encodings/fastlanes/src/rle/vtable/validity.rs
@@ -1,22 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::ArrayRef;
-use vortex_array::vtable::ValidityChild;
-use vortex_array::vtable::ValidityChildSliceHelper;
+use vortex_array::ArrayView;
+use vortex_array::vtable::ValidityVTable;
+use vortex_error::VortexResult;
 
-use super::RLEVTable;
-use crate::RLEArray;
+use crate::rle::RLE;
+use crate::rle::RLEArrayExt;
 
-impl ValidityChild<RLEVTable> for RLEVTable {
-    fn validity_child(array: &RLEArray) -> &ArrayRef {
-        array.indices()
-    }
-}
-
-impl ValidityChildSliceHelper for RLEArray {
-    fn unsliced_child_and_slice(&self) -> (&ArrayRef, usize, usize) {
-        let (start, len) = (self.offset(), self.len());
-        (self.indices(), start, start + len)
+impl ValidityVTable<RLE> for RLE {
+    fn validity(array: ArrayView<'_, RLE>) -> VortexResult<vortex_array::validity::Validity> {
+        let start = array.offset();
+        let stop = start + array.len();
+        array.indices().slice(start..stop)?.validity()
     }
 }
diff --git a/encodings/fastlanes/src/rle/vtable/visitor.rs b/encodings/fastlanes/src/rle/vtable/visitor.rs
deleted file mode 100644
index 36e7bcb993e..00000000000
--- a/encodings/fastlanes/src/rle/vtable/visitor.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
-use vortex_array::vtable::VisitorVTable;
-
-use super::RLEVTable;
-use crate::RLEArray;
-
-impl VisitorVTable<RLEVTable> for RLEVTable {
-    fn visit_buffers(_array: &RLEArray, _visitor: &mut dyn ArrayBufferVisitor) {
-        // RLE stores all data in child arrays, no direct buffers
-    }
-
-    fn nbuffers(_array: &RLEArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &RLEArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("values", array.values());
-        visitor.visit_child("indices", array.indices());
-        visitor.visit_child("values_idx_offsets", array.values_idx_offsets());
-        // Don't call visit_validity since the nullability is stored in the indices array.
-    }
-
-    fn nchildren(_array: &RLEArray) -> usize {
-        3
-    }
-}
diff --git a/encodings/fsst/Cargo.toml b/encodings/fsst/Cargo.toml
index f271d392e51..b95eeb1f444 100644
--- a/encodings/fsst/Cargo.toml
+++ b/encodings/fsst/Cargo.toml
@@ -38,6 +38,17 @@ vortex-array = { workspace = true, features = ["_test-harness"] }
 [[bench]]
 name = "fsst_compress"
 harness = false
+required-features = ["_test-harness"]
+
+[[bench]]
+name = "fsst_like"
+harness = false
+required-features = ["_test-harness"]
+
+[[bench]]
+name = "fsst_url_compare"
+harness = false
+required-features = ["_test-harness"]
 
 [[bench]]
 name = "chunked_dict_fsst_builder"
diff --git a/encodings/fsst/README.md b/encodings/fsst/README.md
index 0e08c6e7fc8..7cc53ba07f9 100644
--- a/encodings/fsst/README.md
+++ b/encodings/fsst/README.md
@@ -2,3 +2,23 @@
 
 A Vortex Encoding for Binary and Utf8 data that utilizes the [Fast Static Symbol Table](https://github.com/spiraldb/fsst)
 compression algorithm.
+
+## LIKE Pushdown
+
+The FSST encoding has a specialized LIKE fast path for a narrow subset of
+patterns:
+
+- `prefix%`
+- `%needle%`
+
+Unsupported shapes, including `_`, `%suffix`, or patterns with interior
+wildcards, fall back to ordinary decompression-based LIKE evaluation.
+
+There are also two implementation limits on the pushdown path, both measured in
+pattern bytes:
+
+- `prefix%` supports up to 253 bytes.
+- `%needle%` supports up to 254 bytes.
+
+Patterns beyond those limits are still evaluated correctly, but they do so via
+the fallback path instead of the DFA matcher.
diff --git a/encodings/fsst/benches/chunked_dict_fsst_builder.rs b/encodings/fsst/benches/chunked_dict_fsst_builder.rs
index 893dd7e6f3b..50e2488d360 100644
--- a/encodings/fsst/benches/chunked_dict_fsst_builder.rs
+++ b/encodings/fsst/benches/chunked_dict_fsst_builder.rs
@@ -4,13 +4,11 @@
 use std::sync::LazyLock;
 
 use divan::Bencher;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::builders::builder_with_capacity;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::dtype::NativePType;
 use vortex_array::session::ArraySession;
 use vortex_error::VortexExpect;
@@ -18,7 +16,6 @@ use vortex_fsst::test_utils::gen_dict_fsst_test_data;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
diff --git a/encodings/fsst/benches/fsst_compress.rs b/encodings/fsst/benches/fsst_compress.rs
index fc5b0016a17..e84eef9cbce 100644
--- a/encodings/fsst/benches/fsst_compress.rs
+++ b/encodings/fsst/benches/fsst_compress.rs
@@ -6,7 +6,7 @@
 use std::sync::LazyLock;
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
@@ -19,7 +19,6 @@ use vortex_array::arrays::VarBinArray;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::VarBinViewBuilder;
 use vortex_array::builtins::ArrayBuiltins;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::scalar::Scalar;
@@ -30,7 +29,6 @@ use vortex_fsst::fsst_train_compressor;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -59,14 +57,18 @@ fn compress_fsst(bencher: Bencher, (string_count, avg_len, unique_chars): (usize
     let compressor = fsst_train_compressor(&array);
     bencher
         .with_inputs(|| (&array, &compressor))
-        .bench_refs(|(array, compressor)| fsst_compress(*array, compressor))
+        .bench_refs(|(array, compressor)| {
+            fsst_compress(*array, array.len(), array.dtype(), compressor)
+        })
 }
 
 #[divan::bench(args = BENCH_ARGS)]
 fn decompress_fsst(bencher: Bencher, (string_count, avg_len, unique_chars): (usize, usize, u8)) {
     let array = generate_test_data(string_count, avg_len, unique_chars);
     let compressor = fsst_train_compressor(&array);
-    let encoded = fsst_compress(array, &compressor);
+    let len = array.len();
+    let dtype = array.dtype().clone();
+    let encoded = fsst_compress(array, len, &dtype, &compressor);
 
     bencher
         .with_inputs(|| &encoded)
@@ -85,7 +87,7 @@ fn train_compressor(bencher: Bencher, (string_count, avg_len, unique_chars): (us
 fn pushdown_compare(bencher: Bencher, (string_count, avg_len, unique_chars): (usize, usize, u8)) {
     let array = generate_test_data(string_count, avg_len, unique_chars);
     let compressor = fsst_train_compressor(&array);
-    let fsst_array = fsst_compress(&array, &compressor);
+    let fsst_array = fsst_compress(&array, array.len(), array.dtype(), &compressor);
     let constant = ConstantArray::new(Scalar::from(&b"const"[..]), array.len());
 
     bencher
@@ -98,8 +100,9 @@ fn pushdown_compare(bencher: Bencher, (string_count, avg_len, unique_chars): (us
         })
         .bench_refs(|(fsst_array, constant, ctx)| {
             fsst_array
-                .to_array()
-                .binary(constant.to_array(), Operator::Eq)
+                .clone()
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap();
@@ -113,7 +116,7 @@ fn canonicalize_compare(
 ) {
     let array = generate_test_data(string_count, avg_len, unique_chars);
     let compressor = fsst_train_compressor(&array);
-    let fsst_array = fsst_compress(&array, &compressor);
+    let fsst_array = fsst_compress(&array, array.len(), array.dtype(), &compressor);
     let constant = ConstantArray::new(Scalar::from(&b"const"[..]), array.len());
 
     bencher
@@ -128,9 +131,8 @@ fn canonicalize_compare(
             fsst_array
                 .to_canonical()
                 .unwrap()
-                .as_ref()
-                .to_array()
-                .binary(constant.to_array(), Operator::Eq)
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap();
@@ -216,7 +218,9 @@ fn generate_chunked_test_data(
         .map(|_| {
             let array = generate_test_data(string_count, avg_len, unique_chars);
             let compressor = fsst_train_compressor(&array);
-            fsst_compress(array, &compressor).into_array()
+            let len = array.len();
+            let dtype = array.dtype().clone();
+            fsst_compress(array, len, &dtype, &compressor).into_array()
         })
         .collect::<ChunkedArray>()
 }
diff --git a/encodings/fsst/benches/fsst_like.rs b/encodings/fsst/benches/fsst_like.rs
new file mode 100644
index 00000000000..b4b0e959351
--- /dev/null
+++ b/encodings/fsst/benches/fsst_like.rs
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+
+use std::fmt;
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::scalar_fn::fns::like::Like;
+use vortex_array::scalar_fn::fns::like::LikeOptions;
+use vortex_array::session::ArraySession;
+use vortex_fsst::FSSTArray;
+use vortex_fsst::test_utils::NUM_STRINGS;
+use vortex_fsst::test_utils::make_fsst_clickbench_urls;
+use vortex_fsst::test_utils::make_fsst_emails;
+use vortex_fsst::test_utils::make_fsst_file_paths;
+use vortex_fsst::test_utils::make_fsst_json_strings;
+use vortex_fsst::test_utils::make_fsst_log_lines;
+use vortex_fsst::test_utils::make_fsst_rare_match;
+use vortex_fsst::test_utils::make_fsst_short_urls;
+use vortex_session::VortexSession;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+const N: usize = NUM_STRINGS;
+
+static FSST_URLS: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_short_urls(N));
+static FSST_CB_URLS: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_clickbench_urls(N));
+static FSST_LOG_LINES: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_log_lines(N));
+static FSST_JSON_STRINGS: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_json_strings(N));
+static FSST_FILE_PATHS: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_file_paths(N));
+static FSST_EMAILS: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_emails(N));
+static FSST_RARE_MATCH: LazyLock<FSSTArray> = LazyLock::new(|| make_fsst_rare_match(N));
+
+enum Dataset {
+    Urls,
+    Cb,
+    Log,
+    Json,
+    Path,
+    Email,
+    Rare,
+}
+
+impl fmt::Display for Dataset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Urls => f.write_str("urls"),
+            Self::Cb => f.write_str("cb"),
+            Self::Log => f.write_str("log"),
+            Self::Json => f.write_str("json"),
+            Self::Path => f.write_str("path"),
+            Self::Email => f.write_str("email"),
+            Self::Rare => f.write_str("rare"),
+        }
+    }
+}
+
+impl Dataset {
+    fn fsst_array(&self) -> &'static FSSTArray {
+        match self {
+            Self::Urls => &FSST_URLS,
+            Self::Cb => &FSST_CB_URLS,
+            Self::Log => &FSST_LOG_LINES,
+            Self::Json => &FSST_JSON_STRINGS,
+            Self::Path => &FSST_FILE_PATHS,
+            Self::Email => &FSST_EMAILS,
+            Self::Rare => &FSST_RARE_MATCH,
+        }
+    }
+
+    fn prefix_pattern(&self) -> &'static str {
+        match self {
+            Self::Urls => "https%",
+            Self::Cb => "https://www.%",
+            Self::Log => "192.168%",
+            Self::Json => r#"{"id%"#,
+            Self::Path => "/home%",
+            Self::Email => "john%",
+            Self::Rare => "xyz%",
+        }
+    }
+
+    fn contains_pattern(&self) -> &'static str {
+        match self {
+            Self::Urls => "%google%",
+            Self::Cb => "%yandex%",
+            Self::Log => "%Googlebot%",
+            Self::Json => "%enterprise%",
+            Self::Path => "%target/release%",
+            Self::Email => "%gmail%",
+            Self::Rare => "%xyzzy%",
+        }
+    }
+}
+
+fn bench_like(bencher: Bencher, fsst: &FSSTArray, pattern: &str) {
+    let len = fsst.len();
+    let arr = fsst.clone().into_array();
+    let pattern = ConstantArray::new(pattern, len).into_array();
+    bencher.bench_local(|| {
+        Like.try_new_array(len, LikeOptions::default(), [arr.clone(), pattern.clone()])
+            .unwrap()
+            .into_array()
+            .execute::<Canonical>(&mut SESSION.create_execution_ctx())
+            .unwrap()
+    });
+}
+
+#[divan::bench(args = [
+    Dataset::Urls, Dataset::Cb, Dataset::Log, Dataset::Json,
+    Dataset::Path, Dataset::Email, Dataset::Rare,
+])]
+fn fsst_prefix(bencher: Bencher, dataset: &Dataset) {
+    bench_like(bencher, dataset.fsst_array(), dataset.prefix_pattern());
+}
+
+#[divan::bench(args = [
+    Dataset::Urls, Dataset::Cb, Dataset::Log, Dataset::Json,
+    Dataset::Path, Dataset::Email, Dataset::Rare,
+])]
+fn fsst_contains(bencher: Bencher, dataset: &Dataset) {
+    bench_like(bencher, dataset.fsst_array(), dataset.contains_pattern());
+}
diff --git a/encodings/fsst/benches/fsst_url_compare.rs b/encodings/fsst/benches/fsst_url_compare.rs
new file mode 100644
index 00000000000..a8572650efb
--- /dev/null
+++ b/encodings/fsst/benches/fsst_url_compare.rs
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use vortex_array::IntoArray;
+use vortex_array::RecursiveCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::expr::like;
+use vortex_array::expr::lit;
+use vortex_array::expr::root;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
+use vortex_fsst::fsst_compress;
+use vortex_fsst::fsst_train_compressor;
+use vortex_fsst::test_utils::HIGH_MATCH_DOMAIN;
+use vortex_fsst::test_utils::LOW_MATCH_DOMAIN;
+use vortex_fsst::test_utils::NUM_STRINGS;
+use vortex_fsst::test_utils::generate_url_data;
+use vortex_session::VortexSession;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+const NUM_URLS: usize = NUM_STRINGS;
+
+static URL_DATA: LazyLock<VarBinArray> = LazyLock::new(generate_url_data);
+
+// ---------------------------------------------------------------------------
+// Eq compare benchmarks (FSST pushdown vs canonicalize)
+// ---------------------------------------------------------------------------
+
+/// Pick a concrete URL from the dataset that uses the given domain.
+fn pick_url_with_domain(data: &VarBinArray, domain: &str) -> String {
+    use vortex_array::accessor::ArrayAccessor;
+    data.with_iterator(|iter| {
+        iter.flatten()
+            .map(|b| std::str::from_utf8(b).unwrap().to_string())
+            .find(|u| u.contains(domain))
+            .unwrap_or_else(|| format!("http://{domain}/missing"))
+    })
+}
+
+#[divan::bench]
+fn eq_pushdown_high_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let match_url = pick_url_with_domain(data, HIGH_MATCH_DOMAIN);
+    let constant = ConstantArray::new(Scalar::from(match_url.as_str()), NUM_URLS);
+
+    bencher
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, constant, ctx)| {
+            fsst_array
+                .clone()
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
+
+#[divan::bench]
+fn eq_pushdown_low_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let match_url = pick_url_with_domain(data, LOW_MATCH_DOMAIN);
+    let constant = ConstantArray::new(Scalar::from(match_url.as_str()), NUM_URLS);
+
+    bencher
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, constant, ctx)| {
+            fsst_array
+                .clone()
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
+
+#[divan::bench]
+fn eq_canonicalize_high_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let match_url = pick_url_with_domain(data, HIGH_MATCH_DOMAIN);
+    let constant = ConstantArray::new(Scalar::from(match_url.as_str()), NUM_URLS);
+
+    bencher
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, constant, ctx)| {
+            fsst_array
+                .to_canonical()
+                .unwrap()
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
+
+#[divan::bench]
+fn eq_canonicalize_low_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let match_url = pick_url_with_domain(data, LOW_MATCH_DOMAIN);
+    let constant = ConstantArray::new(Scalar::from(match_url.as_str()), NUM_URLS);
+
+    bencher
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, constant, ctx)| {
+            fsst_array
+                .to_canonical()
+                .unwrap()
+                .into_array()
+                .binary(constant.clone().into_array(), Operator::Eq)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
+
+// ---------------------------------------------------------------------------
+// LIKE substring benchmarks (always goes through canonicalization for FSST)
+// ---------------------------------------------------------------------------
+
+#[divan::bench]
+fn like_substr_high_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let pattern = format!("%{HIGH_MATCH_DOMAIN}%");
+    let expr = like(root(), lit(pattern.as_str()));
+
+    bencher
+        .with_inputs(|| (&fsst_array, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, ctx)| {
+            fsst_array
+                .clone()
+                .into_array()
+                .apply(&expr)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
+
+#[divan::bench]
+fn like_substr_low_match(bencher: Bencher) {
+    let data = &*URL_DATA;
+    let compressor = fsst_train_compressor(data);
+    let fsst_array = fsst_compress(data, data.len(), data.dtype(), &compressor);
+    let pattern = format!("%{LOW_MATCH_DOMAIN}%");
+    let expr = like(root(), lit(pattern.as_str()));
+
+    bencher
+        .with_inputs(|| (&fsst_array, SESSION.create_execution_ctx()))
+        .bench_refs(|(fsst_array, ctx)| {
+            fsst_array
+                .clone()
+                .into_array()
+                .apply(&expr)
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap()
+        });
+}
diff --git a/encodings/fsst/public-api.lock b/encodings/fsst/public-api.lock
index 86f4f2d75f9..341a2fd8222 100644
--- a/encodings/fsst/public-api.lock
+++ b/encodings/fsst/public-api.lock
@@ -1,183 +1,187 @@
 pub mod vortex_fsst
 
-pub struct vortex_fsst::FSSTArray
+pub struct vortex_fsst::FSST
 
-impl vortex_fsst::FSSTArray
+impl vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::codes(&self) -> &vortex_array::arrays::varbin::array::VarBinArray
+pub const vortex_fsst::FSST::ID: vortex_array::array::ArrayId
 
-pub fn vortex_fsst::FSSTArray::codes_dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_fsst::FSST::try_new(dtype: vortex_array::dtype::DType, symbols: vortex_buffer::buffer::Buffer<fsst::Symbol>, symbol_lengths: vortex_buffer::buffer::Buffer<u8>, codes: vortex_array::arrays::varbin::vtable::VarBinArray, uncompressed_lengths: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_fsst::FSSTArray>
 
-pub fn vortex_fsst::FSSTArray::compressor(&self) -> &fsst::Compressor
+impl core::clone::Clone for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::decompressor(&self) -> fsst::Decompressor<'_>
+pub fn vortex_fsst::FSST::clone(&self) -> vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::symbol_lengths(&self) -> &vortex_buffer::buffer::Buffer<u8>
+impl core::fmt::Debug for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::symbols(&self) -> &vortex_buffer::buffer::Buffer<fsst::Symbol>
+pub fn vortex_fsst::FSST::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fsst::FSSTArray::try_new(dtype: vortex_array::dtype::DType, symbols: vortex_buffer::buffer::Buffer<fsst::Symbol>, symbol_lengths: vortex_buffer::buffer::Buffer<u8>, codes: vortex_array::arrays::varbin::array::VarBinArray, uncompressed_lengths: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+impl vortex_array::array::vtable::VTable for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::uncompressed_lengths(&self) -> &vortex_array::array::ArrayRef
+pub type vortex_fsst::FSST::ArrayData = vortex_fsst::FSSTData
 
-pub fn vortex_fsst::FSSTArray::uncompressed_lengths_dtype(&self) -> &vortex_array::dtype::DType
+pub type vortex_fsst::FSST::OperationsVTable = vortex_fsst::FSST
 
-impl core::clone::Clone for vortex_fsst::FSSTArray
+pub type vortex_fsst::FSST::ValidityVTable = vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTArray::clone(&self) -> vortex_fsst::FSSTArray
+pub fn vortex_fsst::FSST::append_to_builder(array: vortex_array::array::view::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_fsst::FSSTArray
+pub fn vortex_fsst::FSST::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_fsst::FSSTArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub fn vortex_fsst::FSST::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::convert::From<vortex_fsst::FSSTArray> for vortex_array::array::ArrayRef
+pub fn vortex_fsst::FSST::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_fsst::FSSTArray) -> vortex_array::array::ArrayRef
+pub fn vortex_fsst::FSST::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-impl core::fmt::Debug for vortex_fsst::FSSTArray
+pub fn vortex_fsst::FSST::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fsst::FSSTArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fsst::FSST::id(&self) -> vortex_array::array::ArrayId
 
-impl core::ops::deref::Deref for vortex_fsst::FSSTArray
+pub fn vortex_fsst::FSST::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub type vortex_fsst::FSSTArray::Target = dyn vortex_array::array::Array
+pub fn vortex_fsst::FSST::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fsst::FSSTArray::deref(&self) -> &Self::Target
+pub fn vortex_fsst::FSST::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::array::IntoArray for vortex_fsst::FSSTArray
+pub fn vortex_fsst::FSST::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_fsst::FSSTArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_fsst::FSST::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_fsst::FSSTMetadata
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_fsst::FSST> for vortex_fsst::FSST
 
-impl vortex_fsst::FSSTMetadata
+pub fn vortex_fsst::FSST::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_fsst::FSST>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_fsst::FSSTMetadata::codes_offsets_ptype(&self) -> vortex_array::dtype::ptype::PType
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_fsst::FSST> for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::set_codes_offsets_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
+pub fn vortex_fsst::FSST::validity(array: vortex_array::array::view::ArrayView<'_, vortex_fsst::FSST>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_fsst::FSSTMetadata::set_uncompressed_lengths_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::uncompressed_lengths_ptype(&self) -> vortex_array::dtype::ptype::PType
+pub fn vortex_fsst::FSST::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_fsst::FSSTMetadata
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::get_uncompressed_lengths_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
+pub fn vortex_fsst::FSST::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::clone::Clone for vortex_fsst::FSSTMetadata
+impl vortex_array::arrays::slice::SliceReduce for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::clone(&self) -> vortex_fsst::FSSTMetadata
+pub fn vortex_fsst::FSST::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::default::Default for vortex_fsst::FSSTMetadata
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::default() -> Self
+pub fn vortex_fsst::FSST::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::fmt::Debug for vortex_fsst::FSSTMetadata
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fsst::FSST::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl prost::message::Message for vortex_fsst::FSSTMetadata
+impl vortex_array::scalar_fn::fns::like::kernel::LikeKernel for vortex_fsst::FSST
 
-pub fn vortex_fsst::FSSTMetadata::clear(&mut self)
+pub fn vortex_fsst::FSST::like(array: vortex_array::array::view::ArrayView<'_, Self>, pattern: &vortex_array::array::erased::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_fsst::FSSTMetadata::encoded_len(&self) -> usize
+pub struct vortex_fsst::FSSTData
+
+impl vortex_fsst::FSSTData
 
-pub struct vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::codes_bytes(&self) -> &vortex_buffer::ByteBuffer
 
-impl vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::codes_bytes_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub const vortex_fsst::FSSTVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fsst::FSSTData::compressor(&self) -> &fsst::Compressor
 
-impl core::fmt::Debug for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::decompressor(&self) -> fsst::Decompressor<'_>
 
-pub fn vortex_fsst::FSSTVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_fsst::FSSTData::is_empty(&self) -> bool
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::len(&self) -> usize
 
-pub fn vortex_fsst::FSSTVTable::take(array: &vortex_fsst::FSSTArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fsst::FSSTData::symbol_lengths(&self) -> &vortex_buffer::buffer::Buffer<u8>
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::symbols(&self) -> &vortex_buffer::buffer::Buffer<fsst::Symbol>
 
-pub fn vortex_fsst::FSSTVTable::filter(array: &vortex_fsst::FSSTArray, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fsst::FSSTData::try_new(symbols: vortex_buffer::buffer::Buffer<fsst::Symbol>, symbol_lengths: vortex_buffer::buffer::Buffer<u8>, codes_bytes: vortex_array::buffer::BufferHandle, len: usize) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::validate(&self, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_fsst::FSSTVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_fsst::FSSTData
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::clone(&self) -> vortex_fsst::FSSTData
 
-pub fn vortex_fsst::FSSTVTable::compare(lhs: &vortex_fsst::FSSTArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Debug for vortex_fsst::FSSTData
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fsst::FSSTVTable::cast(array: &vortex_fsst::FSSTArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Display for vortex_fsst::FSSTData
 
-impl vortex_array::vtable::VTable for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_fsst::FSSTVTable::Array = vortex_fsst::FSSTArray
+impl vortex_array::hash::ArrayEq for vortex_fsst::FSSTData
 
-pub type vortex_fsst::FSSTVTable::ArrayVTable = vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-pub type vortex_fsst::FSSTVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_fsst::FSSTMetadata>
+impl vortex_array::hash::ArrayHash for vortex_fsst::FSSTData
 
-pub type vortex_fsst::FSSTVTable::OperationsVTable = vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-pub type vortex_fsst::FSSTVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub struct vortex_fsst::FSSTMetadata
 
-pub type vortex_fsst::FSSTVTable::VisitorVTable = vortex_fsst::FSSTVTable
+impl vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::append_to_builder(array: &vortex_fsst::FSSTArray, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_fsst::FSSTMetadata::codes_offsets_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_fsst::FSSTVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_fsst::FSSTArray>
+pub fn vortex_fsst::FSSTMetadata::set_codes_offsets_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub fn vortex_fsst::FSSTVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_fsst::FSSTMetadata::set_uncompressed_lengths_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub fn vortex_fsst::FSSTVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_fsst::FSSTMetadata::uncompressed_lengths_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_fsst::FSSTVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_fsst::FSSTMetadata::get_uncompressed_lengths_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::ptype::PType>
 
-pub fn vortex_fsst::FSSTVTable::metadata(array: &vortex_fsst::FSSTArray) -> vortex_error::VortexResult<Self::Metadata>
+impl core::clone::Clone for vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_fsst::FSSTMetadata::clone(&self) -> vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::default::Default for vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_fsst::FSSTMetadata::default() -> Self
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_fsst::FSSTVTable> for vortex_fsst::FSSTVTable
+impl core::fmt::Debug for vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::array_eq(array: &vortex_fsst::FSSTArray, other: &vortex_fsst::FSSTArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_fsst::FSSTMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_fsst::FSSTVTable::array_hash<H: core::hash::Hasher>(array: &vortex_fsst::FSSTArray, state: &mut H, precision: vortex_array::hash::Precision)
+impl prost::message::Message for vortex_fsst::FSSTMetadata
 
-pub fn vortex_fsst::FSSTVTable::dtype(array: &vortex_fsst::FSSTArray) -> &vortex_array::dtype::DType
+pub fn vortex_fsst::FSSTMetadata::clear(&mut self)
 
-pub fn vortex_fsst::FSSTVTable::len(array: &vortex_fsst::FSSTArray) -> usize
+pub fn vortex_fsst::FSSTMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_fsst::FSSTVTable::stats(array: &vortex_fsst::FSSTArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub trait vortex_fsst::FSSTArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_fsst::FSST>
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_fsst::FSSTVTable> for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTArrayExt::codes(&self) -> vortex_array::arrays::varbin::vtable::VarBinArray
 
-pub fn vortex_fsst::FSSTVTable::scalar_at(array: &vortex_fsst::FSSTArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_fsst::FSSTArrayExt::codes_dtype(&self) -> vortex_array::dtype::DType
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_fsst::FSSTVTable> for vortex_fsst::FSSTVTable
+pub fn vortex_fsst::FSSTArrayExt::uncompressed_lengths(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fsst::FSSTVTable::validity_child(array: &vortex_fsst::FSSTArray) -> &vortex_array::array::ArrayRef
+pub fn vortex_fsst::FSSTArrayExt::uncompressed_lengths_dtype(&self) -> &vortex_array::dtype::DType
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_fsst::FSSTVTable> for vortex_fsst::FSSTVTable
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_fsst::FSST>> vortex_fsst::FSSTArrayExt for T
 
-pub fn vortex_fsst::FSSTVTable::nbuffers(_array: &vortex_fsst::FSSTArray) -> usize
+pub fn T::codes(&self) -> vortex_array::arrays::varbin::vtable::VarBinArray
 
-pub fn vortex_fsst::FSSTVTable::nchildren(array: &vortex_fsst::FSSTArray) -> usize
+pub fn T::codes_dtype(&self) -> vortex_array::dtype::DType
 
-pub fn vortex_fsst::FSSTVTable::visit_buffers(array: &vortex_fsst::FSSTArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn T::uncompressed_lengths(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_fsst::FSSTVTable::visit_children(array: &vortex_fsst::FSSTArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub fn T::uncompressed_lengths_dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_fsst::fsst_compress<A: vortex_array::accessor::ArrayAccessor<[u8]> + core::convert::AsRef<dyn vortex_array::array::Array>>(strings: A, compressor: &fsst::Compressor) -> vortex_fsst::FSSTArray
+pub fn vortex_fsst::fsst_compress<A: vortex_array::accessor::ArrayAccessor<[u8]>>(strings: A, len: usize, dtype: &vortex_array::dtype::DType, compressor: &fsst::Compressor) -> vortex_fsst::FSSTArray
 
 pub fn vortex_fsst::fsst_compress_iter<'a, I>(iter: I, len: usize, dtype: vortex_array::dtype::DType, compressor: &fsst::Compressor) -> vortex_fsst::FSSTArray where I: core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a [u8]>>
 
 pub fn vortex_fsst::fsst_train_compressor<A: vortex_array::accessor::ArrayAccessor<[u8]>>(array: &A) -> fsst::Compressor
+
+pub type vortex_fsst::FSSTArray = vortex_array::array::typed::Array<vortex_fsst::FSST>
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
index ec93ad8422a..1a5cc6ef02b 100644
--- a/encodings/fsst/src/array.rs
+++ b/encodings/fsst/src/array.rs
@@ -2,29 +2,32 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
 use std::fmt::Formatter;
-use std::hash::Hash;
+use std::hash::Hasher;
 use std::sync::Arc;
 use std::sync::LazyLock;
 
 use fsst::Compressor;
 use fsst::Decompressor;
 use fsst::Symbol;
+use prost::Message as _;
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::Canonical;
-use vortex_array::DeserializeMetadata;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
+use vortex_array::TypedArrayRef;
+use vortex_array::arrays::VarBin;
 use vortex_array::arrays::VarBinArray;
-use vortex_array::arrays::VarBinVTable;
+use vortex_array::arrays::varbin::VarBinArrayExt;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::VarBinViewBuilder;
@@ -32,24 +35,19 @@ use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityChild;
-use vortex_array::vtable::ValidityHelper;
-use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
-use vortex_array::vtable::validity_nchildren;
+use vortex_array::vtable::ValidityVTable;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
+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_error::vortex_panic;
 use vortex_session::VortexSession;
 
 use crate::canonical::canonicalize_fsst;
@@ -57,7 +55,8 @@ use crate::canonical::fsst_decode_views;
 use crate::kernel::PARENT_KERNELS;
 use crate::rules::RULES;
 
-vtable!(FSST);
+/// A [`FSST`]-encoded Vortex array.
+pub type FSSTArray = Array<FSST>;
 
 #[derive(Clone, prost::Message)]
 pub struct FSSTMetadata {
@@ -75,116 +74,144 @@ impl FSSTMetadata {
     }
 }
 
-impl VTable for FSSTVTable {
-    type Array = FSSTArray;
+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);
+        self.codes_bytes.as_host().array_hash(state, precision);
+    }
+}
 
-    type Metadata = ProstMetadata<FSSTMetadata>;
+impl ArrayEq for FSSTData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.symbols.array_eq(&other.symbols, precision)
+            && self
+                .symbol_lengths
+                .array_eq(&other.symbol_lengths, precision)
+            && self
+                .codes_bytes
+                .as_host()
+                .array_eq(other.codes_bytes.as_host(), precision)
+    }
+}
 
-    type ArrayVTable = Self;
+impl VTable for FSST {
+    type ArrayData = FSSTData;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &FSSTArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(FSSTMetadata {
-            uncompressed_lengths_ptype: array.uncompressed_lengths().dtype().as_ptype().into(),
-            codes_offsets_ptype: array.codes.offsets().dtype().as_ptype().into(),
-        }))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        data.validate(dtype, len, slots)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        3
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<FSSTMetadata> as DeserializeMetadata>::deserialize(bytes)?,
-        ))
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => BufferHandle::new_host(array.symbols().clone().into_byte_buffer()),
+            1 => BufferHandle::new_host(array.symbol_lengths().clone().into_byte_buffer()),
+            2 => array.codes_bytes_handle().clone(),
+            _ => vortex_panic!("FSSTArray buffer index {idx} out of bounds"),
+        }
     }
 
-    fn append_to_builder(
-        array: &FSSTArray,
-        builder: &mut dyn ArrayBuilder,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<()> {
-        let Some(builder) = builder.as_any_mut().downcast_mut::<VarBinViewBuilder>() else {
-            builder.extend_from_array(&array.to_array().execute::<Canonical>(ctx)?.into_array());
-            return Ok(());
-        };
-
-        // Decompress the whole block of data into a new buffer, and create some views
-        // from it instead.
-        let (buffers, views) = fsst_decode_views(array, builder.completed_block_count(), ctx)?;
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("symbols".to_string()),
+            1 => Some("symbol_lengths".to_string()),
+            2 => Some("compressed_codes".to_string()),
+            _ => vortex_panic!("FSSTArray buffer_name index {idx} out of bounds"),
+        }
+    }
 
-        builder.push_buffer_and_adjusted_views(&buffers, &views, array.validity_mask()?);
-        Ok(())
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let codes_offsets = array.as_ref().slots()[CODES_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("FSSTArray codes_offsets slot");
+        Ok(Some(
+            FSSTMetadata {
+                uncompressed_lengths_ptype: array.uncompressed_lengths().dtype().as_ptype().into(),
+                codes_offsets_ptype: codes_offsets.dtype().as_ptype().into(),
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    /// Deserializes an FSST array from its serialized components.
+    ///
+    /// Supports two serialization formats:
+    ///
+    /// ## Legacy format (2 buffers, 2 children)
+    ///
+    /// The original FSST layout stored the compressed codes as a full `VarBinArray` child.
+    /// - **Buffers**: `[symbols, symbol_lengths]`
+    /// - **Children**: `[codes (VarBinArray), uncompressed_lengths (Primitive)]`
+    ///
+    /// The codes VarBinArray child is decomposed: its bytes become the `codes_bytes` buffer,
+    /// and its offsets/validity are extracted into slots.
+    /// See `FSST::deserialize_legacy`.
+    ///
+    /// ## Current format (3 buffers, 2-3 children)
+    ///
+    /// The current layout stores the compressed bytes as a raw buffer alongside the symbol
+    /// table, with offsets and validity as separate children.
+    /// - **Buffers**: `[symbols, symbol_lengths, compressed_codes_bytes]`
+    /// - **Children**: `[uncompressed_lengths, codes_offsets, (optional) codes_validity]`
+    ///
+    /// The `codes_bytes` buffer is stored directly in `FSSTData`. A `VarBinArray` for the
+    /// codes can be reconstructed on demand via [`FSSTArrayExt::codes()`] using the bytes
+    /// from `FSSTData` combined with offsets and validity from the array's slots.
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<FSSTArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = FSSTMetadata::decode(metadata)?;
         let symbols = Buffer::<Symbol>::from_byte_buffer(buffers[0].clone().try_to_host_sync()?);
         let symbol_lengths = Buffer::<u8>::from_byte_buffer(buffers[1].clone().try_to_host_sync()?);
 
-        // Check for the legacy deserialization path.
         if buffers.len() == 2 {
-            if children.len() != 2 {
-                vortex_bail!(InvalidArgument: "Expected 2 children, got {}", children.len());
-            }
-            let codes = children.get(0, &DType::Binary(dtype.nullability()), len)?;
-            let codes = codes
-                .as_opt::<VarBinVTable>()
-                .ok_or_else(|| {
-                    vortex_err!(
-                        "Expected VarBinArray for codes, got {}",
-                        codes.encoding_id()
-                    )
-                })?
-                .clone();
-            let uncompressed_lengths = children.get(
-                1,
-                &DType::Primitive(
-                    metadata.0.get_uncompressed_lengths_ptype()?,
-                    Nullability::NonNullable,
-                ),
+            return Self::deserialize_legacy(
+                self,
+                dtype,
                 len,
-            )?;
-
-            return FSSTArray::try_new(
-                dtype.clone(),
-                symbols,
-                symbol_lengths,
-                codes,
-                uncompressed_lengths,
+                &metadata,
+                &symbols,
+                &symbol_lengths,
+                children,
             );
         }
 
-        // Check for the current deserialization path.
         if buffers.len() == 3 {
             let uncompressed_lengths = children.get(
                 0,
                 &DType::Primitive(
-                    metadata.0.get_uncompressed_lengths_ptype()?,
+                    metadata.get_uncompressed_lengths_ptype()?,
                     Nullability::NonNullable,
                 ),
                 len,
             )?;
 
-            let codes_buffer = ByteBuffer::from_byte_buffer(buffers[2].clone().try_to_host_sync()?);
+            let codes_bytes = buffers[2].clone();
             let codes_offsets = children.get(
                 1,
                 &DType::Primitive(
@@ -201,23 +228,26 @@ impl VTable for FSSTVTable {
                 let validity = children.get(2, &Validity::DTYPE, len)?;
                 Validity::Array(validity)
             } else {
-                vortex_bail!("Expected 0 or 1 child, got {}", children.len());
+                vortex_bail!("Expected 2 or 3 children, got {}", children.len());
             };
 
-            let codes = VarBinArray::try_new(
-                codes_offsets,
-                codes_buffer,
-                DType::Binary(dtype.nullability()),
-                codes_validity,
+            FSSTData::validate_parts(
+                &symbols,
+                &symbol_lengths,
+                &codes_bytes,
+                &codes_offsets,
+                dtype.nullability(),
+                &uncompressed_lengths,
+                dtype,
+                len,
             )?;
-
-            return FSSTArray::try_new(
-                dtype.clone(),
-                symbols,
-                symbol_lengths,
-                codes,
-                uncompressed_lengths,
-            );
+            let slots = vec![
+                Some(uncompressed_lengths),
+                Some(codes_offsets),
+                validity_to_child(&codes_validity, len),
+            ];
+            let data = FSSTData::try_new(symbols, symbol_lengths, codes_bytes, len)?;
+            return Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots));
         }
 
         vortex_bail!(
@@ -226,43 +256,42 @@ impl VTable for FSSTVTable {
         );
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 2,
-            "FSSTArray expects 2 children, got {}",
-            children.len()
-        );
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
 
-        let mut children_iter = children.into_iter();
-        let codes = children_iter
-            .next()
-            .ok_or_else(|| vortex_err!("FSSTArray with_children missing codes"))?;
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        canonicalize_fsst(array.as_view(), ctx).map(ExecutionResult::done)
+    }
 
-        let codes = codes
-            .as_opt::<VarBinVTable>()
-            .ok_or_else(|| {
-                vortex_err!(
-                    "Expected VarBinArray for codes, got {}",
-                    codes.encoding_id()
-                )
-            })?
-            .clone();
-        let uncompressed_lengths = children_iter
-            .next()
-            .ok_or_else(|| vortex_err!("FSSTArray with_children missing uncompressed_lengths"))?;
+    fn append_to_builder(
+        array: ArrayView<'_, Self>,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        let Some(builder) = builder.as_any_mut().downcast_mut::<VarBinViewBuilder>() else {
+            builder.extend_from_array(
+                &array
+                    .array()
+                    .clone()
+                    .execute::<Canonical>(ctx)?
+                    .into_array(),
+            );
+            return Ok(());
+        };
 
-        array.codes = codes;
-        array.uncompressed_lengths = uncompressed_lengths;
+        // Decompress the whole block of data into a new buffer, and create some views
+        // from it instead. The new buffer lands after any pending in-progress
+        // buffer that push_buffer_and_adjusted_views will flush first.
+        let next_buffer_index = builder.completed_block_count() + u32::from(builder.in_progress());
+        let (buffers, views) = fsst_decode_views(array, next_buffer_index, ctx)?;
 
+        builder.push_buffer_and_adjusted_views(&buffers, &views, array.array().validity_mask()?);
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        canonicalize_fsst(array, ctx)
-    }
-
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -271,7 +300,7 @@ impl VTable for FSSTVTable {
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -279,58 +308,240 @@ impl VTable for FSSTVTable {
     }
 }
 
+/// Lengths of the original values before compression, can be compressed.
+pub(crate) const UNCOMPRESSED_LENGTHS_SLOT: usize = 0;
+/// The offsets array for the FSST-compressed codes.
+#[allow(dead_code, reason = "reserved for back-compat slot numbering")]
+pub(crate) const CODES_OFFSETS_SLOT: usize = 1;
+/// The validity bitmap for the compressed codes.
+#[allow(dead_code, reason = "reserved for back-compat slot numbering")]
+pub(crate) const CODES_VALIDITY_SLOT: usize = 2;
+pub(crate) const NUM_SLOTS: usize = 3;
+pub(crate) const SLOT_NAMES: [&str; NUM_SLOTS] =
+    ["uncompressed_lengths", "codes_offsets", "codes_validity"];
+
+/// The inner data for an FSST-compressed array.
+///
+/// Holds the FSST symbol table (`symbols` + `symbol_lengths`) and the raw compressed
+/// codes bytes buffer. The codes offsets and validity live in the outer array's slots
+/// (slots 1 and 2 respectively).
+///
+/// A full [`VarBinArray`] representing the codes can be reconstructed on demand via
+/// [`FSSTArrayExt::codes()`], combining this buffer with the offsets/validity from slots.
 #[derive(Clone)]
-pub struct FSSTArray {
-    dtype: DType,
+pub struct FSSTData {
     symbols: Buffer<Symbol>,
     symbol_lengths: Buffer<u8>,
-    codes: VarBinArray,
-    /// NOTE(ngates): this === codes, but is stored as an ArrayRef so we can return &ArrayRef!
-    codes_array: ArrayRef,
-    /// Lengths of the original values before compression, can be compressed.
-    uncompressed_lengths: ArrayRef,
-    stats_set: ArrayStats,
+    /// 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 Debug for FSSTArray {
+impl Display for FSSTData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "len: {}, nsymbols: {}", self.len, self.symbols.len())
+    }
+}
+
+impl Debug for FSSTData {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("FSSTArray")
-            .field("dtype", &self.dtype)
             .field("symbols", &self.symbols)
             .field("symbol_lengths", &self.symbol_lengths)
-            .field("codes", &self.codes)
-            .field("uncompressed_lengths", &self.uncompressed_lengths)
+            .field("codes_bytes_len", &self.codes_bytes.len())
+            .field("len", &self.len)
+            .field("uncompressed_lengths", &"<outer slot>")
+            .field("codes_offsets", &"<outer slot>")
+            .field("codes_validity", &"<outer slot>")
             .finish()
     }
 }
 
-#[derive(Debug)]
-pub struct FSSTVTable;
+#[derive(Clone, Debug)]
+pub struct FSST;
 
-impl FSSTVTable {
+impl FSST {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.fsst");
-}
 
-impl FSSTArray {
     /// Build an FSST array from a set of `symbols` and `codes`.
     ///
-    /// Symbols are 8-bytes and can represent short strings, each of which is assigned
-    /// a code.
-    ///
-    /// The `codes` array is a Binary array where each binary datum is a sequence of 8-bit codes.
-    /// Each code corresponds either to a symbol, or to the "escape code",
-    /// which tells the decoder to emit the following byte without doing a table lookup.
+    /// The `codes` VarBinArray is decomposed: its bytes are stored in [`FSSTData`], while
+    /// its offsets and validity become array slots. The codes VarBinArray can be
+    /// reconstructed on demand via [`FSSTArrayExt::codes()`].
     pub fn try_new(
         dtype: DType,
         symbols: Buffer<Symbol>,
         symbol_lengths: Buffer<u8>,
         codes: VarBinArray,
         uncompressed_lengths: ArrayRef,
+    ) -> VortexResult<FSSTArray> {
+        let len = codes.len();
+        FSSTData::validate_parts_from_codes(
+            &symbols,
+            &symbol_lengths,
+            &codes,
+            &uncompressed_lengths,
+            &dtype,
+            len,
+        )?;
+        let slots = FSSTData::make_slots(&codes, &uncompressed_lengths);
+        let codes_bytes = codes.bytes_handle().clone();
+        let data = FSSTData::try_new(symbols, symbol_lengths, 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).
+    fn deserialize_legacy(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &FSSTMetadata,
+        symbols: &Buffer<Symbol>,
+        symbol_lengths: &Buffer<u8>,
+        children: &dyn ArrayChildren,
+    ) -> VortexResult<ArrayParts<Self>> {
+        if children.len() != 2 {
+            vortex_bail!(InvalidArgument: "Expected 2 children, got {}", children.len());
+        }
+        let codes = children.get(0, &DType::Binary(dtype.nullability()), len)?;
+        let codes: VarBinArray = codes
+            .as_opt::<VarBin>()
+            .ok_or_else(|| {
+                vortex_err!(
+                    "Expected VarBinArray for codes, got {}",
+                    codes.encoding_id()
+                )
+            })?
+            .into_owned();
+        let uncompressed_lengths = children.get(
+            1,
+            &DType::Primitive(
+                metadata.get_uncompressed_lengths_ptype()?,
+                Nullability::NonNullable,
+            ),
+            len,
+        )?;
+
+        FSSTData::validate_parts_from_codes(
+            symbols,
+            symbol_lengths,
+            &codes,
+            &uncompressed_lengths,
+            dtype,
+            len,
+        )?;
+        let slots = FSSTData::make_slots(&codes, &uncompressed_lengths);
+        let codes_bytes = codes.bytes_handle().clone();
+        let data = FSSTData::try_new(symbols.clone(), symbol_lengths.clone(), codes_bytes, len)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+    }
+
+    pub(crate) unsafe fn new_unchecked(
+        dtype: DType,
+        symbols: Buffer<Symbol>,
+        symbol_lengths: Buffer<u8>,
+        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) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(FSST, dtype, len, data).with_slots(slots))
+        }
+    }
+}
+
+impl FSSTData {
+    fn make_slots(codes: &VarBinArray, uncompressed_lengths: &ArrayRef) -> Vec<Option<ArrayRef>> {
+        vec![
+            Some(uncompressed_lengths.clone()),
+            Some(codes.offsets().clone()),
+            validity_to_child(
+                &codes
+                    .validity()
+                    .vortex_expect("FSST codes validity should be derivable"),
+                codes.len(),
+            ),
+        ]
+    }
+
+    /// Build FSST data from a set of `symbols`, `symbol_lengths`, and compressed codes bytes.
+    ///
+    /// Symbols are 8-bytes and can represent short strings, each of which is assigned
+    /// a code.
+    ///
+    /// The `codes_bytes` buffer contains the concatenated compressed bytecodes for all elements.
+    /// Each element's compressed bytecodes are a sequence of 8-bit codes, where each code
+    /// corresponds either to a symbol or to the "escape code" (which tells the decoder to
+    /// emit the following byte without doing a table lookup).
+    ///
+    /// The offsets and validity for the codes are stored in the array's slots, not here.
+    /// Use [`FSSTArrayExt::codes()`] to reconstruct a full `VarBinArray`.
+    pub fn try_new(
+        symbols: Buffer<Symbol>,
+        symbol_lengths: Buffer<u8>,
+        codes_bytes: BufferHandle,
+        len: usize,
     ) -> VortexResult<Self> {
-        // Check: symbols must not have length > MAX_CODE
+        // SAFETY: all components validated above
+        unsafe {
+            Ok(Self::new_unchecked(
+                symbols,
+                symbol_lengths,
+                codes_bytes,
+                len,
+            ))
+        }
+    }
+
+    pub fn validate(
+        &self,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let codes_offsets = slots[CODES_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("FSSTArray codes_offsets slot");
+        Self::validate_parts(
+            &self.symbols,
+            &self.symbol_lengths,
+            &self.codes_bytes,
+            codes_offsets,
+            dtype.nullability(),
+            uncompressed_lengths_from_slots(slots),
+            dtype,
+            len,
+        )
+    }
+
+    /// Validate using the decomposed components (codes bytes + offsets + nullability).
+    #[allow(clippy::too_many_arguments)]
+    fn validate_parts(
+        symbols: &Buffer<Symbol>,
+        symbol_lengths: &Buffer<u8>,
+        codes_bytes: &BufferHandle,
+        codes_offsets: &ArrayRef,
+        codes_nullability: Nullability,
+        uncompressed_lengths: &ArrayRef,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            matches!(dtype, DType::Binary(_) | DType::Utf8(_)),
+            "FSST arrays must be Binary or Utf8, found {dtype}"
+        );
+
         if symbols.len() > 255 {
             vortex_bail!(InvalidArgument: "symbols array must have length <= 255");
         }
@@ -338,7 +549,13 @@ impl FSSTArray {
             vortex_bail!(InvalidArgument: "symbols and symbol_lengths arrays must have same length");
         }
 
-        if uncompressed_lengths.len() != codes.len() {
+        // codes_offsets.len() - 1 == number of elements
+        let codes_len = codes_offsets.len().saturating_sub(1);
+        if codes_len != len {
+            vortex_bail!(InvalidArgument: "codes must have same len as outer array");
+        }
+
+        if uncompressed_lengths.len() != len {
             vortex_bail!(InvalidArgument: "uncompressed_lengths must be same len as codes");
         }
 
@@ -346,29 +563,59 @@ impl FSSTArray {
             vortex_bail!(InvalidArgument: "uncompressed_lengths must have integer type and cannot be nullable, found {}", uncompressed_lengths.dtype());
         }
 
-        // Check: strings must be a Binary array.
-        if !matches!(codes.dtype(), DType::Binary(_)) {
-            vortex_bail!(InvalidArgument: "codes array must be DType::Binary type");
+        // Offsets must be non-nullable integer.
+        if !codes_offsets.dtype().is_int() || codes_offsets.dtype().is_nullable() {
+            vortex_bail!(InvalidArgument: "codes offsets must be non-nullable integer type, found {}", codes_offsets.dtype());
         }
 
-        // SAFETY: all components validated above
-        unsafe {
-            Ok(Self::new_unchecked(
-                dtype,
-                symbols,
-                symbol_lengths,
-                codes,
-                uncompressed_lengths,
-            ))
+        if codes_nullability != dtype.nullability() {
+            vortex_bail!(InvalidArgument: "codes nullability must match outer dtype nullability");
         }
+
+        // Validate that last offset doesn't exceed bytes length (when host-resident).
+        if codes_bytes.is_on_host() && codes_offsets.is_host() && !codes_offsets.is_empty() {
+            let last_offset: usize = (&codes_offsets
+                .scalar_at(codes_offsets.len() - 1)
+                .vortex_expect("offsets must support scalar_at"))
+                .try_into()
+                .vortex_expect("Failed to convert offset to usize");
+            vortex_ensure!(
+                last_offset <= codes_bytes.len(),
+                InvalidArgument: "Last codes offset {} exceeds codes bytes length {}",
+                last_offset,
+                codes_bytes.len()
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Validate using a VarBinArray for the codes (convenience for construction paths).
+    fn validate_parts_from_codes(
+        symbols: &Buffer<Symbol>,
+        symbol_lengths: &Buffer<u8>,
+        codes: &VarBinArray,
+        uncompressed_lengths: &ArrayRef,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        Self::validate_parts(
+            symbols,
+            symbol_lengths,
+            codes.bytes_handle(),
+            codes.offsets(),
+            codes.dtype().nullability(),
+            uncompressed_lengths,
+            dtype,
+            len,
+        )
     }
 
     pub(crate) unsafe fn new_unchecked(
-        dtype: DType,
         symbols: Buffer<Symbol>,
         symbol_lengths: Buffer<u8>,
-        codes: VarBinArray,
-        uncompressed_lengths: ArrayRef,
+        codes_bytes: BufferHandle,
+        len: usize,
     ) -> Self {
         let symbols2 = symbols.clone();
         let symbol_lengths2 = symbol_lengths.clone();
@@ -376,50 +623,43 @@ impl FSSTArray {
             Compressor::rebuild_from(symbols2.as_slice(), symbol_lengths2.as_slice())
         })
             as Box<dyn Fn() -> Compressor + Send>));
-        let codes_array = codes.to_array();
-
         Self {
-            dtype,
             symbols,
             symbol_lengths,
-            codes,
-            codes_array,
-            uncompressed_lengths,
-            stats_set: Default::default(),
+            codes_bytes,
+            len,
             compressor,
         }
     }
 
-    /// Access the symbol table array
-    pub fn symbols(&self) -> &Buffer<Symbol> {
-        &self.symbols
+    /// Returns the number of elements in the array.
+    pub fn len(&self) -> usize {
+        self.len
     }
 
-    /// Access the symbol table array
-    pub fn symbol_lengths(&self) -> &Buffer<u8> {
-        &self.symbol_lengths
+    /// Returns `true` if the array contains no elements.
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
     }
 
-    /// Access the codes array
-    pub fn codes(&self) -> &VarBinArray {
-        &self.codes
+    /// Access the symbol table array.
+    pub fn symbols(&self) -> &Buffer<Symbol> {
+        &self.symbols
     }
 
-    /// Get the DType of the codes array
-    #[inline]
-    pub fn codes_dtype(&self) -> &DType {
-        self.codes.dtype()
+    /// Access the symbol lengths array.
+    pub fn symbol_lengths(&self) -> &Buffer<u8> {
+        &self.symbol_lengths
     }
 
-    /// Get the uncompressed length for each element in the array.
-    pub fn uncompressed_lengths(&self) -> &ArrayRef {
-        &self.uncompressed_lengths
+    /// Access the compressed codes bytes buffer handle (may be on host or device).
+    pub fn codes_bytes_handle(&self) -> &BufferHandle {
+        &self.codes_bytes
     }
 
-    /// Get the DType of the uncompressed lengths array
-    #[inline]
-    pub fn uncompressed_lengths_dtype(&self) -> &DType {
-        self.uncompressed_lengths.dtype()
+    /// Access the compressed codes bytes on the host.
+    pub fn codes_bytes(&self) -> &ByteBuffer {
+        self.codes_bytes.as_host()
     }
 
     /// Build a [`Decompressor`][fsst::Decompressor] that can be used to decompress values from
@@ -434,75 +674,58 @@ impl FSSTArray {
     }
 }
 
-impl BaseArrayVTable<FSSTVTable> for FSSTVTable {
-    fn len(array: &FSSTArray) -> usize {
-        array.codes().len()
-    }
-
-    fn dtype(array: &FSSTArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &FSSTArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &FSSTArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.symbols.array_hash(state, precision);
-        array.symbol_lengths.array_hash(state, precision);
-        array.codes.as_ref().array_hash(state, precision);
-        array.uncompressed_lengths.array_hash(state, precision);
-    }
+fn uncompressed_lengths_from_slots(slots: &[Option<ArrayRef>]) -> &ArrayRef {
+    slots[UNCOMPRESSED_LENGTHS_SLOT]
+        .as_ref()
+        .vortex_expect("FSSTArray uncompressed_lengths slot")
+}
 
-    fn array_eq(array: &FSSTArray, other: &FSSTArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.symbols.array_eq(&other.symbols, precision)
-            && array
-                .symbol_lengths
-                .array_eq(&other.symbol_lengths, precision)
-            && array
-                .codes
-                .as_ref()
-                .array_eq(other.codes.as_ref(), precision)
-            && array
-                .uncompressed_lengths
-                .array_eq(&other.uncompressed_lengths, precision)
+pub trait FSSTArrayExt: TypedArrayRef<FSST> {
+    fn uncompressed_lengths(&self) -> &ArrayRef {
+        uncompressed_lengths_from_slots(self.as_ref().slots())
     }
-}
 
-impl ValidityChild<FSSTVTable> for FSSTVTable {
-    fn validity_child(array: &FSSTArray) -> &ArrayRef {
-        &array.codes_array
+    fn uncompressed_lengths_dtype(&self) -> &DType {
+        self.uncompressed_lengths().dtype()
     }
-}
 
-impl VisitorVTable<FSSTVTable> for FSSTVTable {
-    fn visit_buffers(array: &FSSTArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle(
-            "symbols",
-            &BufferHandle::new_host(array.symbols().clone().into_byte_buffer()),
-        );
-        visitor.visit_buffer_handle(
-            "symbol_lengths",
-            &BufferHandle::new_host(array.symbol_lengths().clone().into_byte_buffer()),
+    /// Reconstruct a [`VarBinArray`] for the compressed codes by combining the bytes
+    /// from [`FSSTData`] with the offsets and validity stored in the array's slots.
+    fn codes(&self) -> VarBinArray {
+        let offsets = self.as_ref().slots()[CODES_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("FSSTArray codes_offsets slot")
+            .clone();
+        let validity = child_to_validity(
+            &self.as_ref().slots()[CODES_VALIDITY_SLOT],
+            self.as_ref().dtype().nullability(),
         );
-        visitor.visit_buffer_handle("compressed_codes", array.codes.bytes_handle())
+        let codes_bytes = self.codes_bytes_handle().clone();
+        // SAFETY: components were validated at construction time.
+        unsafe {
+            VarBinArray::new_unchecked_from_handle(
+                offsets,
+                codes_bytes,
+                DType::Binary(self.as_ref().dtype().nullability()),
+                validity,
+            )
+        }
     }
 
-    fn nbuffers(_array: &FSSTArray) -> usize {
-        3
+    /// Get the DType of the codes array.
+    fn codes_dtype(&self) -> DType {
+        DType::Binary(self.as_ref().dtype().nullability())
     }
+}
 
-    fn visit_children(array: &FSSTArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("uncompressed_lengths", array.uncompressed_lengths());
-        visitor.visit_child("codes_offsets", array.codes.offsets());
-        visitor.visit_validity(array.codes.validity(), array.codes.len());
-    }
+impl<T: TypedArrayRef<FSST>> FSSTArrayExt for T {}
 
-    fn nchildren(array: &FSSTArray) -> usize {
-        // uncompressed_lengths + codes_offsets + optional validity
-        2 + validity_nchildren(array.codes.validity())
+impl ValidityVTable<FSST> for FSST {
+    fn validity(array: ArrayView<'_, FSST>) -> VortexResult<Validity> {
+        Ok(child_to_validity(
+            &array.slots()[CODES_VALIDITY_SLOT],
+            array.dtype().nullability(),
+        ))
     }
 }
 
@@ -510,10 +733,10 @@ impl VisitorVTable<FSSTVTable> for FSSTVTable {
 mod test {
     use fsst::Compressor;
     use fsst::Symbol;
-    use vortex_array::Array;
+    use prost::Message;
+    use vortex_array::ArrayPlugin;
     use vortex_array::IntoArray;
     use vortex_array::LEGACY_SESSION;
-    use vortex_array::ProstMetadata;
     use vortex_array::VortexSessionExecute;
     use vortex_array::accessor::ArrayAccessor;
     use vortex_array::arrays::VarBinViewArray;
@@ -522,11 +745,11 @@ mod test {
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::test_harness::check_metadata;
-    use vortex_array::vtable::VTable;
     use vortex_buffer::Buffer;
     use vortex_error::VortexError;
 
-    use crate::FSSTVTable;
+    use crate::FSST;
+    use crate::array::FSSTArrayExt;
     use crate::array::FSSTMetadata;
     use crate::fsst_compress_iter;
 
@@ -535,10 +758,11 @@ mod test {
     fn test_fsst_metadata() {
         check_metadata(
             "fsst.metadata",
-            ProstMetadata(FSSTMetadata {
+            &FSSTMetadata {
                 uncompressed_lengths_ptype: PType::U64 as i32,
                 codes_offsets_ptype: PType::I32 as i32,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 
@@ -565,7 +789,7 @@ mod test {
             &compressor,
         );
 
-        let compressed_codes = fsst_array.codes().clone();
+        let compressed_codes = fsst_array.codes();
 
         // There were two buffers:
         // 1. The 8 byte symbols
@@ -583,10 +807,11 @@ mod test {
             fsst_array.uncompressed_lengths().clone(),
         ];
 
-        let fsst = FSSTVTable::build(
+        let fsst = ArrayPlugin::deserialize(
+            &FSST,
             &DType::Utf8(Nullability::NonNullable),
             2,
-            &ProstMetadata(FSSTMetadata {
+            &FSSTMetadata {
                 uncompressed_lengths_ptype: fsst_array
                     .uncompressed_lengths()
                     .dtype()
@@ -594,14 +819,15 @@ mod test {
                     .into(),
                 // Legacy array did not store this field, use Protobuf default of 0.
                 codes_offsets_ptype: 0,
-            }),
+            }
+            .encode_to_vec(),
             &buffers,
             &children.as_slice(),
+            &LEGACY_SESSION,
         )
         .unwrap();
 
         let decompressed = fsst
-            .into_array()
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
         decompressed
diff --git a/encodings/fsst/src/canonical.rs b/encodings/fsst/src/canonical.rs
index a4a7388fae0..14d06de20f4 100644
--- a/encodings/fsst/src/canonical.rs
+++ b/encodings/fsst/src/canonical.rs
@@ -4,24 +4,26 @@
 use std::sync::Arc;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::build_views::BinaryView;
-use vortex_array::arrays::build_views::MAX_BUFFER_LEN;
-use vortex_array::arrays::build_views::build_views;
+use vortex_array::arrays::varbin::VarBinArrayExt;
+use vortex_array::arrays::varbinview::build_views::BinaryView;
+use vortex_array::arrays::varbinview::build_views::MAX_BUFFER_LEN;
+use vortex_array::arrays::varbinview::build_views::build_views;
 use vortex_array::match_each_integer_ptype;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexResult;
 
-use crate::FSSTArray;
+use crate::FSST;
+use crate::FSSTArrayExt;
 
 pub(super) fn canonicalize_fsst(
-    array: &FSSTArray,
+    array: ArrayView<'_, FSST>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let (buffers, views) = fsst_decode_views(array, 0, ctx)?;
@@ -32,14 +34,14 @@ pub(super) fn canonicalize_fsst(
             views,
             Arc::from(buffers),
             array.dtype().clone(),
-            array.codes().validity().clone(),
+            array.codes().validity()?,
         )
         .into_array()
     })
 }
 
 pub(crate) fn fsst_decode_views(
-    fsst_array: &FSSTArray,
+    fsst_array: ArrayView<'_, FSST>,
     start_buf_index: u32,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<(Vec<ByteBuffer>, Buffer<BinaryView>)> {
@@ -88,7 +90,7 @@ pub(crate) fn fsst_decode_views(
 mod tests {
     use std::sync::LazyLock;
 
-    use rand::Rng;
+    use rand::RngExt;
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::ArrayRef;
@@ -151,7 +153,10 @@ mod tests {
             .map(|_| {
                 let (array, data) = make_data();
                 let compressor = fsst_train_compressor(&array);
-                (fsst_compress(&array, &compressor).into_array(), data)
+                (
+                    fsst_compress(&array, array.len(), array.dtype(), &compressor).into_array(),
+                    data,
+                )
             })
             .unzip();
 
@@ -167,7 +172,10 @@ mod tests {
 
         let mut builder =
             VarBinViewBuilder::with_capacity(chunked_arr.dtype().clone(), chunked_arr.len());
-        chunked_arr.append_to_builder(&mut builder, &mut SESSION.create_execution_ctx())?;
+        chunked_arr
+            .clone()
+            .into_array()
+            .append_to_builder(&mut builder, &mut SESSION.create_execution_ctx())?;
 
         {
             let arr = builder.finish_into_canonical().into_varbinview();
@@ -177,11 +185,34 @@ mod tests {
         };
 
         {
-            let arr2 = chunked_arr.to_varbinview();
+            let arr2 = chunked_arr.as_array().to_varbinview();
             let res2 =
                 arr2.with_iterator(|iter| iter.map(|b| b.map(|v| v.to_vec())).collect::<Vec<_>>());
             assert_eq!(data, res2)
         };
         Ok(())
     }
+
+    #[test]
+    fn test_append_after_in_progress_buffer() -> VortexResult<()> {
+        let dtype = DType::Binary(Nullability::NonNullable);
+        let mut builder = VarBinViewBuilder::with_capacity(dtype.clone(), 2);
+        builder.append_value(b"long enough!!!");
+
+        let varbin = VarBinArray::from_iter(
+            [Some(b"long enough too".to_vec().into_boxed_slice())],
+            dtype,
+        );
+        let fsst_array = fsst_compress(
+            &varbin,
+            varbin.len(),
+            varbin.dtype(),
+            &fsst_train_compressor(&varbin),
+        )
+        .into_array();
+        fsst_array.append_to_builder(&mut builder, &mut SESSION.create_execution_ctx())?;
+
+        let _result = builder.finish_into_varbinview();
+        Ok(())
+    }
 }
diff --git a/encodings/fsst/src/compress.rs b/encodings/fsst/src/compress.rs
index 4230ac34520..53772e82636 100644
--- a/encodings/fsst/src/compress.rs
+++ b/encodings/fsst/src/compress.rs
@@ -5,25 +5,24 @@
 
 use fsst::Compressor;
 use fsst::Symbol;
-use vortex_array::Array;
 use vortex_array::IntoArray;
 use vortex_array::accessor::ArrayAccessor;
-use vortex_array::arrays::builder::VarBinBuilder;
+use vortex_array::arrays::varbin::builder::VarBinBuilder;
 use vortex_array::dtype::DType;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 
-use crate::FSSTArray;
-
 /// Compress a string array using FSST.
-pub fn fsst_compress<A: ArrayAccessor<[u8]> + AsRef<dyn Array>>(
+use crate::FSST;
+use crate::FSSTArray;
+pub fn fsst_compress<A: ArrayAccessor<[u8]>>(
     strings: A,
+    len: usize,
+    dtype: &DType,
     compressor: &Compressor,
 ) -> FSSTArray {
-    let len = strings.as_ref().len();
-    let dtype = strings.as_ref().dtype().clone();
-    strings.with_iterator(|iter| fsst_compress_iter(iter, len, dtype, compressor))
+    strings.with_iterator(|iter| fsst_compress_iter(iter, len, dtype.clone(), compressor))
 }
 
 /// Train a compressor from an array.
@@ -103,8 +102,8 @@ where
 
     let uncompressed_lengths = uncompressed_lengths.into_array();
 
-    FSSTArray::try_new(dtype, symbols, symbol_lengths, codes, uncompressed_lengths)
-        .vortex_expect("building FSSTArray from parts")
+    FSST::try_new(dtype, symbols, symbol_lengths, codes, uncompressed_lengths)
+        .vortex_expect("FSST parts must be valid")
 }
 
 #[cfg(test)]
diff --git a/encodings/fsst/src/compute/cast.rs b/encodings/fsst/src/compute/cast.rs
index 60918cca52a..9553cb4d8a9 100644
--- a/encodings/fsst/src/compute/cast.rs
+++ b/encodings/fsst/src/compute/cast.rs
@@ -2,33 +2,33 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::VarBinVTable;
+use vortex_array::arrays::VarBin;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
-
-impl CastReduce for FSSTVTable {
-    fn cast(array: &FSSTArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::FSST;
+use crate::FSSTArrayExt;
+impl CastReduce for FSST {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // FSST is a string compression encoding.
         // For nullability changes, we can cast the codes and symbols arrays
         if array.dtype().eq_ignore_nullability(dtype) {
             // Cast codes array to handle nullability
             let new_codes = array
                 .codes()
-                .to_array()
-                .cast(array.codes().dtype().with_nullability(dtype.nullability()))?;
+                .into_array()
+                .cast(array.codes_dtype().with_nullability(dtype.nullability()))?;
 
             Ok(Some(
-                FSSTArray::try_new(
+                FSST::try_new(
                     dtype.clone(),
                     array.symbols().clone(),
                     array.symbol_lengths().clone(),
-                    new_codes.as_::<VarBinVTable>().clone(),
+                    new_codes.as_::<VarBin>().into_owned(),
                     array.uncompressed_lengths().clone(),
                 )?
                 .into_array(),
@@ -42,6 +42,7 @@ impl CastReduce for FSSTVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::VarBinArray;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
@@ -59,11 +60,13 @@ mod tests {
         );
 
         let compressor = fsst_train_compressor(&strings);
-        let fsst = fsst_compress(strings, &compressor);
+        let len = strings.len();
+        let dtype = strings.dtype().clone();
+        let fsst = fsst_compress(strings, len, &dtype, &compressor);
 
         // Cast to nullable
         let casted = fsst
-            .to_array()
+            .into_array()
             .cast(DType::Utf8(Nullability::Nullable))
             .unwrap();
         assert_eq!(casted.dtype(), &DType::Utf8(Nullability::Nullable));
@@ -84,7 +87,7 @@ mod tests {
     ))]
     fn test_cast_fsst_conformance(#[case] array: VarBinArray) {
         let compressor = fsst_train_compressor(&array);
-        let fsst = fsst_compress(&array, &compressor);
-        test_cast_conformance(fsst.as_ref());
+        let fsst = fsst_compress(&array, array.len(), array.dtype(), &compressor);
+        test_cast_conformance(&fsst.into_array());
     }
 }
diff --git a/encodings/fsst/src/compute/compare.rs b/encodings/fsst/src/compute/compare.rs
index b5418168457..2ae2cf0ff40 100644
--- a/encodings/fsst/src/compute/compare.rs
+++ b/encodings/fsst/src/compute/compare.rs
@@ -1,17 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::builtins::ArrayBuiltins;
-use vortex_array::compute::compare_lengths_to_empty;
 use vortex_array::dtype::DType;
-use vortex_array::match_each_integer_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar_fn::fns::binary::CompareKernel;
 use vortex_array::scalar_fn::fns::operators::CompareOperator;
@@ -23,18 +20,17 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
-
-impl CompareKernel for FSSTVTable {
+use crate::FSST;
+use crate::FSSTArrayExt;
+impl CompareKernel for FSST {
     fn compare(
-        lhs: &FSSTArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         match rhs.as_constant() {
-            Some(constant) => compare_fsst_constant(lhs, &constant, operator),
+            Some(constant) => compare_fsst_constant(lhs, &constant, operator, ctx),
             // Otherwise, fall back to the default comparison behavior.
             _ => Ok(None),
         }
@@ -43,9 +39,10 @@ impl CompareKernel for FSSTVTable {
 
 /// Specialized compare function implementation used when performing against a constant
 fn compare_fsst_constant(
-    left: &FSSTArray,
+    left: ArrayView<'_, FSST>,
     right: &Scalar,
     operator: CompareOperator,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<ArrayRef>> {
     let is_rhs_empty = match right.dtype() {
         DType::Binary(_) => right
@@ -64,21 +61,23 @@ fn compare_fsst_constant(
             CompareOperator::Gte => BitBuffer::new_set(left.len()),
             // No value is lt ""
             CompareOperator::Lt => BitBuffer::new_unset(left.len()),
-            _ => {
-                let uncompressed_lengths = left.uncompressed_lengths().to_primitive();
-                match_each_integer_ptype!(uncompressed_lengths.ptype(), |P| {
-                    compare_lengths_to_empty(
-                        uncompressed_lengths.as_slice::<P>().iter().copied(),
-                        operator,
+            _ => left
+                .uncompressed_lengths()
+                .binary(
+                    ConstantArray::new(
+                        Scalar::zero_value(left.uncompressed_lengths().dtype()),
+                        left.uncompressed_lengths().len(),
                     )
-                })
-            }
+                    .into_array(),
+                    operator.into(),
+                )?
+                .execute(ctx)?,
         };
 
         return Ok(Some(
             BoolArray::new(
                 buffer,
-                Validity::copy_from_array(left.as_ref())?
+                Validity::copy_from_array(left.array())?
                     .union_nullability(right.dtype().nullability()),
             )
             .into_array(),
@@ -116,14 +115,14 @@ fn compare_fsst_constant(
 
     let rhs = ConstantArray::new(encoded_scalar, left.len());
     left.codes()
-        .to_array()
+        .into_array()
         .binary(rhs.into_array(), Operator::from(operator))
         .map(Some)
 }
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::ConstantArray;
@@ -152,14 +151,17 @@ mod tests {
             DType::Utf8(Nullability::Nullable),
         );
         let compressor = fsst_train_compressor(&lhs);
-        let lhs = fsst_compress(lhs, &compressor);
+        let len = lhs.len();
+        let dtype = lhs.dtype().clone();
+        let lhs = fsst_compress(lhs, len, &dtype, &compressor);
 
         let rhs = ConstantArray::new("world", lhs.len());
 
         // Ensure fastpath for Eq exists, and returns correct answer
         let equals = lhs
-            .to_array()
-            .binary(rhs.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(rhs.clone().into_array(), Operator::Eq)
             .unwrap()
             .to_bool();
 
@@ -172,8 +174,9 @@ mod tests {
 
         // Ensure fastpath for Eq exists, and returns correct answer
         let not_equals = lhs
-            .to_array()
-            .binary(rhs.to_array(), Operator::NotEq)
+            .clone()
+            .into_array()
+            .binary(rhs.into_array(), Operator::NotEq)
             .unwrap()
             .to_bool();
 
@@ -187,8 +190,9 @@ mod tests {
         let null_rhs =
             ConstantArray::new(Scalar::null(DType::Utf8(Nullability::Nullable)), lhs.len());
         let equals_null = lhs
-            .to_array()
-            .binary(null_rhs.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(null_rhs.clone().into_array(), Operator::Eq)
             .unwrap();
         assert_arrays_eq!(
             &equals_null,
@@ -196,8 +200,8 @@ mod tests {
         );
 
         let noteq_null = lhs
-            .to_array()
-            .binary(null_rhs.to_array(), Operator::NotEq)
+            .into_array()
+            .binary(null_rhs.into_array(), Operator::NotEq)
             .unwrap();
         assert_arrays_eq!(
             &noteq_null,
diff --git a/encodings/fsst/src/compute/filter.rs b/encodings/fsst/src/compute/filter.rs
index 9fa190eb17d..9f60cb6c596 100644
--- a/encodings/fsst/src/compute/filter.rs
+++ b/encodings/fsst/src/compute/filter.rs
@@ -2,31 +2,36 @@
 // 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::arrays::FilterKernel;
-use vortex_array::arrays::VarBinVTable;
+use vortex_array::arrays::VarBin;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
+use crate::FSST;
+use crate::FSSTArrayExt;
 
-impl FilterKernel for FSSTVTable {
+impl FilterKernel for FSST {
     fn filter(
-        array: &FSSTArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        // Directly invoke VarBin's FilterKernel to get a concrete VarBinArray back.
-        let filtered_codes = <VarBinVTable as FilterKernel>::filter(array.codes(), mask, ctx)?
-            .vortex_expect("VarBin filter kernel always returns Some")
-            .as_::<VarBinVTable>()
-            .clone();
+        // Directly invoke VarBin's FilterKernel on the codes child.
+        let codes = array.codes();
+        let codes = codes.as_view();
+        let filtered_codes_ref = <VarBin as FilterKernel>::filter(codes, mask, ctx)?
+            .vortex_expect("VarBin filter kernel always returns Some");
+        let filtered_codes = filtered_codes_ref
+            .try_downcast::<VarBin>()
+            .ok()
+            .vortex_expect("must be VarBin");
 
         Ok(Some(
-            FSSTArray::try_new(
+            FSST::try_new(
                 array.dtype().clone(),
                 array.symbols().clone(),
                 array.symbol_lengths().clone(),
@@ -37,56 +42,3 @@ impl FilterKernel for FSSTVTable {
         ))
     }
 }
-
-#[cfg(test)]
-mod test {
-    use vortex_array::arrays::builder::VarBinBuilder;
-    use vortex_array::compute::conformance::filter::test_filter_conformance;
-    use vortex_array::dtype::DType;
-    use vortex_array::dtype::Nullability;
-
-    use crate::fsst_compress;
-    use crate::fsst_train_compressor;
-
-    #[test]
-    fn test_filter_fsst_array() {
-        // Test with small strings
-        let mut builder = VarBinBuilder::<i32>::with_capacity(5);
-        builder.append_value(b"hello");
-        builder.append_value(b"world");
-        builder.append_value(b"hello");
-        builder.append_value(b"rust");
-        builder.append_value(b"world");
-        let varbin = builder.finish(DType::Utf8(Nullability::NonNullable));
-
-        let compressor = fsst_train_compressor(&varbin);
-        let array = fsst_compress(&varbin, &compressor);
-        test_filter_conformance(array.as_ref());
-
-        // Test with longer strings that benefit from compression
-        let mut builder = VarBinBuilder::<i32>::with_capacity(5);
-        builder.append_value(b"the quick brown fox");
-        builder.append_value(b"the quick brown fox jumps");
-        builder.append_value(b"the lazy dog");
-        builder.append_value(b"the quick brown fox jumps over");
-        builder.append_value(b"the lazy dog sleeps");
-        let varbin = builder.finish(DType::Utf8(Nullability::NonNullable));
-
-        let compressor = fsst_train_compressor(&varbin);
-        let array = fsst_compress(&varbin, &compressor);
-        test_filter_conformance(array.as_ref());
-
-        // Test with nullable strings
-        let mut builder = VarBinBuilder::<i32>::with_capacity(5);
-        builder.append_value(b"compress");
-        builder.append_null();
-        builder.append_value(b"decompress");
-        builder.append_value(b"compress");
-        builder.append_null();
-        let varbin = builder.finish(DType::Utf8(Nullability::Nullable));
-
-        let compressor = fsst_train_compressor(&varbin);
-        let array = fsst_compress(&varbin, &compressor);
-        test_filter_conformance(array.as_ref());
-    }
-}
diff --git a/encodings/fsst/src/compute/like.rs b/encodings/fsst/src/compute/like.rs
new file mode 100644
index 00000000000..2e618ef6588
--- /dev/null
+++ b/encodings/fsst/src/compute/like.rs
@@ -0,0 +1,372 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::cast_possible_truncation)]
+
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::varbin::VarBinArrayExt;
+use vortex_array::match_each_integer_ptype;
+use vortex_array::scalar_fn::fns::like::LikeKernel;
+use vortex_array::scalar_fn::fns::like::LikeOptions;
+use vortex_error::VortexResult;
+
+use crate::FSST;
+use crate::FSSTArrayExt;
+use crate::dfa::FsstMatcher;
+use crate::dfa::dfa_scan_to_bitbuf;
+
+impl LikeKernel for FSST {
+    fn like(
+        array: ArrayView<'_, Self>,
+        pattern: &ArrayRef,
+        options: LikeOptions,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let Some(pattern_scalar) = pattern.as_constant() else {
+            return Ok(None);
+        };
+
+        if options.case_insensitive {
+            return Ok(None);
+        }
+
+        let pattern_bytes: &[u8] = if let Some(s) = pattern_scalar.as_utf8_opt() {
+            let Some(v) = s.value() else {
+                return Ok(None);
+            };
+            v.as_ref()
+        } else if let Some(b) = pattern_scalar.as_binary_opt() {
+            let Some(v) = b.value() else {
+                return Ok(None);
+            };
+            v
+        } else {
+            return Ok(None);
+        };
+
+        let symbols = array.symbols();
+        let symbol_lengths = array.symbol_lengths();
+
+        let Some(matcher) =
+            FsstMatcher::try_new(symbols.as_slice(), symbol_lengths.as_slice(), pattern_bytes)?
+        else {
+            return Ok(None);
+        };
+
+        let negated = options.negated;
+        let codes = array.codes();
+        let offsets = codes.offsets().to_primitive();
+        let all_bytes = codes.bytes();
+        let all_bytes = all_bytes.as_slice();
+        let n = codes.len();
+
+        let result = match_each_integer_ptype!(offsets.ptype(), |T| {
+            let off = offsets.as_slice::<T>();
+            dfa_scan_to_bitbuf(n, off, all_bytes, negated, |codes| matcher.matches(codes))
+        });
+
+        // FSST delegates validity to its codes array, so we can read it
+        // directly without cloning the entire FSSTArray into an ArrayRef.
+        let validity = array
+            .codes()
+            .validity()?
+            .union_nullability(pattern_scalar.dtype().nullability());
+
+        Ok(Some(BoolArray::new(result, validity).into_array()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use vortex_array::Canonical;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::ConstantArray;
+    use vortex_array::arrays::VarBinArray;
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::scalar_fn::fns::like::Like;
+    use vortex_array::scalar_fn::fns::like::LikeKernel;
+    use vortex_array::scalar_fn::fns::like::LikeOptions;
+    use vortex_array::session::ArraySession;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::FSST;
+    use crate::FSSTArray;
+    use crate::fsst_compress;
+    use crate::fsst_train_compressor;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    fn make_fsst(strings: &[Option<&str>], nullability: Nullability) -> FSSTArray {
+        let varbin = VarBinArray::from_iter(strings.iter().copied(), DType::Utf8(nullability));
+        let compressor = fsst_train_compressor(&varbin);
+        let len = varbin.len();
+        let dtype = varbin.dtype().clone();
+        fsst_compress(varbin, len, &dtype, &compressor)
+    }
+
+    fn run_like(array: FSSTArray, pattern: &str, opts: LikeOptions) -> VortexResult<BoolArray> {
+        let len = array.len();
+        let arr = array.into_array();
+        let pattern = ConstantArray::new(pattern, len).into_array();
+        let result = Like
+            .try_new_array(len, opts, [arr, pattern])?
+            .into_array()
+            .execute::<Canonical>(&mut SESSION.create_execution_ctx())?;
+        Ok(result.into_bool())
+    }
+
+    fn like(array: FSSTArray, pattern: &str) -> VortexResult<BoolArray> {
+        run_like(array, pattern, LikeOptions::default())
+    }
+
+    #[test]
+    fn test_like_prefix() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[
+                Some("http://example.com"),
+                Some("http://test.org"),
+                Some("ftp://files.net"),
+                Some("http://vortex.dev"),
+                Some("ssh://server.io"),
+            ],
+            Nullability::NonNullable,
+        );
+        let result = like(fsst, "http%")?;
+        assert_arrays_eq!(
+            &result,
+            &BoolArray::from_iter([true, true, false, true, false])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_prefix_with_nulls() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[Some("hello"), None, Some("help"), None, Some("goodbye")],
+            Nullability::Nullable,
+        );
+        let result = like(fsst, "hel%")?; // spellchecker:disable-line
+        assert_arrays_eq!(
+            &result,
+            &BoolArray::from_iter([Some(true), None, Some(true), None, Some(false)])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_contains() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[
+                Some("hello world"),
+                Some("say hello"),
+                Some("goodbye"),
+                Some("hellooo"),
+            ],
+            Nullability::NonNullable,
+        );
+        let result = like(fsst, "%hello%")?;
+        assert_arrays_eq!(&result, &BoolArray::from_iter([true, true, false, true]));
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_contains_cross_symbol() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[
+                Some("the quick brown fox jumps over the lazy dog"),
+                Some("a short string"),
+                Some("the lazy dog sleeps"),
+                Some("no match"),
+            ],
+            Nullability::NonNullable,
+        );
+        let result = like(fsst, "%lazy dog%")?;
+        assert_arrays_eq!(&result, &BoolArray::from_iter([true, false, true, false]));
+        Ok(())
+    }
+
+    #[test]
+    fn test_not_like_contains() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[Some("foobar_sdf"), Some("sdf_start"), Some("nothing")],
+            Nullability::NonNullable,
+        );
+        let opts = LikeOptions {
+            negated: true,
+            case_insensitive: false,
+        };
+        let result = run_like(fsst, "%sdf%", opts)?;
+        assert_arrays_eq!(&result, &BoolArray::from_iter([false, false, true]));
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_match_all() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[Some("abc"), Some(""), Some("xyz")],
+            Nullability::NonNullable,
+        );
+        let result = like(fsst, "%")?;
+        assert_arrays_eq!(&result, &BoolArray::from_iter([true, true, true]));
+        Ok(())
+    }
+
+    /// Call `LikeKernel::like` directly on the FSSTArray and verify it
+    /// returns `Some(...)` (i.e. the kernel handles it, rather than
+    /// returning `None` which would mean "fall back to decompress").
+    #[test]
+    fn test_like_prefix_kernel_handles() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[Some("http://a.com"), Some("ftp://b.com")],
+            Nullability::NonNullable,
+        );
+        let pattern = ConstantArray::new("http%", fsst.len()).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+
+        let fsst = fsst.as_view();
+        let result = <FSST as LikeKernel>::like(fsst, &pattern, LikeOptions::default(), &mut ctx)?;
+        assert!(result.is_some(), "FSST LikeKernel should handle prefix%");
+        assert_arrays_eq!(result.unwrap(), BoolArray::from_iter([true, false]));
+        Ok(())
+    }
+
+    /// Same direct-call check for the contains pattern `%needle%`.
+    #[test]
+    fn test_like_contains_kernel_handles() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[Some("hello world"), Some("goodbye")],
+            Nullability::NonNullable,
+        );
+        let pattern = ConstantArray::new("%world%", fsst.len()).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+
+        let fsst = fsst.as_view();
+        let result = <FSST as LikeKernel>::like(fsst, &pattern, LikeOptions::default(), &mut ctx)?;
+        assert!(result.is_some(), "FSST LikeKernel should handle %needle%");
+        assert_arrays_eq!(result.unwrap(), BoolArray::from_iter([true, false]));
+        Ok(())
+    }
+
+    /// Patterns we can't handle should return `None` (fall back).
+    #[test]
+    fn test_like_kernel_falls_back_for_complex_pattern() -> VortexResult<()> {
+        let fsst = make_fsst(&[Some("abc"), Some("def")], Nullability::NonNullable);
+        let mut ctx = SESSION.create_execution_ctx();
+
+        // Underscore wildcard -- not handled.
+        let pattern = ConstantArray::new("a_c", fsst.len()).into_array();
+        let fsst_v = fsst.as_view();
+        let result =
+            <FSST as LikeKernel>::like(fsst_v, &pattern, LikeOptions::default(), &mut ctx)?;
+        assert!(result.is_none(), "underscore pattern should fall back");
+
+        // Case-insensitive -- not handled.
+        let pattern = ConstantArray::new("abc%", fsst.len()).into_array();
+        let opts = LikeOptions {
+            negated: false,
+            case_insensitive: true,
+        };
+        let result = <FSST as LikeKernel>::like(fsst_v, &pattern, opts, &mut ctx)?;
+        assert!(result.is_none(), "ilike should fall back");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_long_prefix_handled_by_flat_dfa() -> VortexResult<()> {
+        let fsst = make_fsst(
+            &[
+                Some("abcdefghijklmn-tail"),
+                Some("abcdefghijklmx-tail"),
+                Some("abcdefghijklmn"),
+            ],
+            Nullability::NonNullable,
+        );
+        let pattern = "abcdefghijklmn%";
+
+        let fsst = fsst.as_view();
+        let direct = <FSST as LikeKernel>::like(
+            fsst,
+            &ConstantArray::new(pattern, fsst.len()).into_array(),
+            LikeOptions::default(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
+        assert!(
+            direct.is_some(),
+            "14-byte prefixes are now handled by the flat prefix DFA"
+        );
+        assert_arrays_eq!(direct.unwrap(), BoolArray::from_iter([true, false, true]));
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_long_contains_falls_back_but_still_matches() -> VortexResult<()> {
+        let needle = "a".repeat(255);
+        let matching = format!("xx{needle}yy");
+        let non_matching = format!("xx{}byy", "a".repeat(254));
+        let exact = needle.clone();
+        let pattern = format!("%{needle}%");
+
+        let fsst = make_fsst(
+            &[Some(&matching), Some(&non_matching), Some(&exact)],
+            Nullability::NonNullable,
+        );
+
+        let fsst_v = fsst.as_view();
+        let direct = <FSST as LikeKernel>::like(
+            fsst_v,
+            &ConstantArray::new(pattern.as_str(), fsst.len()).into_array(),
+            LikeOptions::default(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
+        assert!(
+            direct.is_none(),
+            "contains needles longer than 254 bytes exceed the DFA's u8 state space"
+        );
+
+        let result = like(fsst, &pattern)?;
+        assert_arrays_eq!(&result, &BoolArray::from_iter([true, false, true]));
+        Ok(())
+    }
+
+    #[test]
+    fn test_like_contains_len_254_kernel_handles() -> VortexResult<()> {
+        let needle = "a".repeat(254);
+        let matching = format!("xx{needle}yy");
+        let non_matching = format!("xx{}byy", "a".repeat(253));
+        let pattern = format!("%{needle}%");
+
+        let fsst = make_fsst(
+            &[Some(&matching), Some(&non_matching), Some(needle.as_str())],
+            Nullability::NonNullable,
+        );
+
+        let fsst = fsst.as_view();
+        let direct = <FSST as LikeKernel>::like(
+            fsst,
+            &ConstantArray::new(pattern.as_str(), fsst.len()).into_array(),
+            LikeOptions::default(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
+        assert!(
+            direct.is_some(),
+            "254-byte contains needle should stay on the DFA path"
+        );
+        assert_arrays_eq!(direct.unwrap(), BoolArray::from_iter([true, false, true]));
+        Ok(())
+    }
+}
diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs
index 775aeecce54..ac350e6186c 100644
--- a/encodings/fsst/src/compute/mod.rs
+++ b/encodings/fsst/src/compute/mod.rs
@@ -4,43 +4,48 @@
 mod cast;
 mod compare;
 mod filter;
+mod like;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::TakeExecute;
-use vortex_array::arrays::VarBinVTable;
+use vortex_array::arrays::VarBin;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar::Scalar;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
+use crate::FSST;
+use crate::FSSTArrayExt;
 
-impl TakeExecute for FSSTVTable {
+impl TakeExecute for FSST {
     fn take(
-        array: &FSSTArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            FSSTArray::try_new(
+            FSST::try_new(
                 array
                     .dtype()
                     .clone()
                     .union_nullability(indices.dtype().nullability()),
                 array.symbols().clone(),
                 array.symbol_lengths().clone(),
-                VarBinVTable::take(array.codes(), indices, _ctx)?
-                    .vortex_expect("cannot fail")
-                    .try_into::<VarBinVTable>()
-                    .map_err(|_| vortex_err!("take for codes must return varbin array"))?,
+                {
+                    let codes = array.codes();
+                    let codes = codes.as_view();
+                    <VarBin as TakeExecute>::take(codes, indices, _ctx)?
+                        .vortex_expect("VarBin take kernel always returns Some")
+                }
+                .try_downcast::<VarBin>()
+                .map_err(|_| vortex_err!("take for codes must return varbin array"))?,
                 array
                     .uncompressed_lengths()
-                    .take(indices.to_array())?
+                    .take(indices.clone())?
                     .fill_null(Scalar::zero_value(
                         &array.uncompressed_lengths_dtype().clone(),
                     ))?,
@@ -53,7 +58,7 @@ impl TakeExecute for FSSTVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::VarBinArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
@@ -69,19 +74,19 @@ mod tests {
     fn test_take_null() {
         let arr = VarBinArray::from_iter([Some("h")], DType::Utf8(Nullability::NonNullable));
         let compr = fsst_train_compressor(&arr);
-        let fsst = fsst_compress(&arr, &compr);
+        let fsst = fsst_compress(&arr, arr.len(), arr.dtype(), &compr);
 
         let idx1: PrimitiveArray = (0..1).collect();
 
         assert_eq!(
-            fsst.take(idx1.to_array()).unwrap().dtype(),
+            fsst.take(idx1.into_array()).unwrap().dtype(),
             &DType::Utf8(Nullability::NonNullable)
         );
 
         let idx2: PrimitiveArray = PrimitiveArray::from_option_iter(vec![Some(0)]);
 
         assert_eq!(
-            fsst.take(idx2.to_array()).unwrap().dtype(),
+            fsst.take(idx2.into_array()).unwrap().dtype(),
             &DType::Utf8(Nullability::Nullable)
         );
     }
@@ -101,8 +106,8 @@ mod tests {
     ))]
     fn test_take_fsst_conformance(#[case] varbin: VarBinArray) {
         let compressor = fsst_train_compressor(&varbin);
-        let array = fsst_compress(&varbin, &compressor);
-        test_take_conformance(array.as_ref());
+        let array = fsst_compress(&varbin, varbin.len(), varbin.dtype(), &compressor);
+        test_take_conformance(&array.into_array());
     }
 
     #[rstest]
@@ -113,7 +118,7 @@ mod tests {
             DType::Utf8(Nullability::NonNullable),
         );
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(&varbin, &compressor)
+        fsst_compress(&varbin, varbin.len(), varbin.dtype(), &compressor)
     })]
     // Nullable strings
     #[case::fsst_nullable({
@@ -122,7 +127,9 @@ mod tests {
             DType::Utf8(Nullability::Nullable),
         );
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(varbin, &compressor)
+        let len = varbin.len();
+        let dtype = varbin.dtype().clone();
+        fsst_compress(varbin, len, &dtype, &compressor)
     })]
     // Repetitive patterns (good for FSST compression)
     #[case::fsst_repetitive({
@@ -131,7 +138,7 @@ mod tests {
             DType::Utf8(Nullability::NonNullable),
         );
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(&varbin, &compressor)
+        fsst_compress(&varbin, varbin.len(), varbin.dtype(), &compressor)
     })]
     // Edge cases
     #[case::fsst_single({
@@ -140,7 +147,7 @@ mod tests {
             DType::Utf8(Nullability::NonNullable),
         );
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(&varbin, &compressor)
+        fsst_compress(&varbin, varbin.len(), varbin.dtype(), &compressor)
     })]
     #[case::fsst_empty_strings({
         let varbin = VarBinArray::from_iter(
@@ -148,7 +155,9 @@ mod tests {
             DType::Utf8(Nullability::NonNullable),
         );
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(varbin, &compressor)
+        let len = varbin.len();
+        let dtype = varbin.dtype().clone();
+        fsst_compress(varbin, len, &dtype, &compressor)
     })]
     // Large arrays
     #[case::fsst_large({
@@ -168,10 +177,12 @@ mod tests {
             .collect();
         let varbin = VarBinArray::from_iter(data, DType::Utf8(Nullability::NonNullable));
         let compressor = fsst_train_compressor(&varbin);
-        fsst_compress(varbin, &compressor)
+        let len = varbin.len();
+        let dtype = varbin.dtype().clone();
+        fsst_compress(varbin, len, &dtype, &compressor)
     })]
 
     fn test_fsst_consistency(#[case] array: FSSTArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/fsst/src/dfa/flat_contains.rs b/encodings/fsst/src/dfa/flat_contains.rs
new file mode 100644
index 00000000000..a33b82b4a0a
--- /dev/null
+++ b/encodings/fsst/src/dfa/flat_contains.rs
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Flat `u8` transition table DFA for contains matching (`LIKE '%needle%'`).
+//!
+//! Uses an escape-sentinel strategy: the FSST escape code maps to a sentinel
+//! state, and the next literal byte is looked up in a separate byte-level
+//! transition table.
+//! This is to support needles up to u8::MAX long.
+//!
+//! ## Construction (needle = `"aba"`, symbols = `[0:"ab", 1:"ba"]`)
+//!
+//! ### Step 1: KMP (Knuth–Morris–Pratt) byte-level transition table
+//!
+//! See: <https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm>
+//!
+//! Build a `(state × byte) → state` table using the KMP failure function.
+//! States 0..2 track match progress, state 3 is accept (sticky).
+//!
+//! ```text
+//!         Input byte
+//! State   'a'    'b'    other
+//! ─────   ────   ────   ─────
+//!   0      1      0      0      ← want 'a'
+//!   1      1      2      0      ← matched "a", want 'b' (KMP: 'a'→stay at 1)
+//!   2      3✓     0      0      ← matched "ab", want 'a'
+//!   3✓     3✓     3✓     3✓     ← accept (sticky)
+//! ```
+//!
+//! ### Step 2: Symbol-level transitions
+//!
+//! For each `(state, symbol)` pair, simulate feeding the symbol's bytes
+//! through the byte table:
+//!
+//! ```text
+//! Symbol 0 = "ab" (2 bytes):
+//!   state 0 + 'a' → 1, + 'b' → 2  ⟹ sym_trans[0][0] = 2
+//!   state 1 + 'a' → 1, + 'b' → 2  ⟹ sym_trans[1][0] = 2
+//!   state 2 + 'a' → 3✓             ⟹ sym_trans[2][0] = 3✓ (accept)
+//!
+//! Symbol 1 = "ba" (2 bytes):
+//!   state 0 + 'b' → 0, + 'a' → 1  ⟹ sym_trans[0][1] = 1
+//!   state 1 + 'b' → 2, + 'a' → 3✓ ⟹ sym_trans[1][1] = 3✓ (accept)
+//!   state 2 + 'b' → 0, + 'a' → 1  ⟹ sym_trans[2][1] = 1
+//! ```
+//!
+//! ### Step 3: Fused 256-wide table with escape sentinel
+//!
+//! Merge symbol transitions into a 256-wide table. Code bytes 0–1 use symbol
+//! transitions, code 255 (ESCAPE_CODE) maps to the sentinel (4), and
+//! unused code bytes default to 0:
+//!
+//! ```text
+//!              Code byte
+//! State   0("ab") 1("ba") 2..254  255(ESC)
+//! ─────   ─────── ─────── ──────  ────────
+//!   0       2       1       0       4(S)
+//!   1       2       3✓      0       4(S)
+//!   2       3✓      1       0       4(S)
+//!   3✓      3✓      3✓      3✓      3✓
+//! ```
+//!
+//! When the scanner sees sentinel (4), it reads the next byte and looks it
+//! up in the byte-level escape table (from step 1).
+//!
+//! TODO(joe): for short needles (≤7 bytes), a branchless escape-folded DFA
+//! with hierarchical 4-byte composition is ~2x faster. For needles ≤127 bytes,
+//! an escape-folded flat DFA (2N+1 states) avoids the sentinel branch.
+//! See commit 7faf9f36f for those implementations.
+
+use fsst::Symbol;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use super::build_fused_table;
+use super::build_symbol_transitions;
+use super::kmp_byte_transitions;
+
+/// Flat `u8` transition table DFA for contains matching.
+///
+/// The escape code maps to a sentinel state; the next literal byte is looked
+/// up in a separate byte-level escape table.
+pub(crate) struct FlatContainsDfa {
+    /// `transitions[state * 256 + byte]` -> next state.
+    transitions: Vec<u8>,
+    /// `escape_transitions[state * 256 + byte]` -> next state for escaped bytes.
+    escape_transitions: Vec<u8>,
+    accept_state: u8,
+    sentinel: u8,
+}
+
+impl FlatContainsDfa {
+    /// Maximum needle length: need accept + sentinel to fit in u8.
+    pub(crate) const MAX_NEEDLE_LEN: usize = u8::MAX as usize - 1;
+
+    pub(crate) fn new(
+        symbols: &[Symbol],
+        symbol_lengths: &[u8],
+        needle: &[u8],
+    ) -> VortexResult<Self> {
+        if needle.len() > Self::MAX_NEEDLE_LEN {
+            vortex_bail!(
+                "needle length {} exceeds maximum {} for flat contains DFA",
+                needle.len(),
+                Self::MAX_NEEDLE_LEN
+            );
+        }
+
+        let accept_state = u8::try_from(needle.len())
+            .vortex_expect("FlatContainsDfa: accept state must fit into u8");
+        let n_states = accept_state + 1;
+        let sentinel = n_states;
+
+        let byte_table = kmp_byte_transitions(needle);
+        let sym_trans =
+            build_symbol_transitions(symbols, symbol_lengths, &byte_table, n_states, accept_state);
+        let transitions = build_fused_table(&sym_trans, symbols.len(), n_states, |_| sentinel, 0);
+
+        Ok(Self {
+            transitions,
+            escape_transitions: byte_table,
+            accept_state,
+            sentinel,
+        })
+    }
+
+    pub(crate) fn matches(&self, codes: &[u8]) -> bool {
+        let mut state = 0u8;
+        let mut pos = 0;
+        while pos < codes.len() {
+            let code = codes[pos];
+            pos += 1;
+            let next = self.transitions[usize::from(state) * 256 + usize::from(code)];
+            if next == self.sentinel {
+                if pos >= codes.len() {
+                    return false;
+                }
+                let b = codes[pos];
+                pos += 1;
+                state = self.escape_transitions[usize::from(state) * 256 + usize::from(b)];
+            } else {
+                state = next;
+            }
+            if state == self.accept_state {
+                return true;
+            }
+        }
+        false
+    }
+}
diff --git a/encodings/fsst/src/dfa/mod.rs b/encodings/fsst/src/dfa/mod.rs
new file mode 100644
index 00000000000..358fd3a7ab5
--- /dev/null
+++ b/encodings/fsst/src/dfa/mod.rs
@@ -0,0 +1,367 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! # FSST LIKE Pushdown via DFA Construction
+//!
+//! This module implements DFA-based pattern matching directly on FSST-compressed
+//! strings, without decompressing them. It handles two pattern shapes:
+//!
+//! - **Prefix**: `'prefix%'`  — matches strings starting with a literal prefix.
+//! - **Contains**: `'%needle%'` — matches strings containing a literal substring.
+//!
+//! Pushdown is intentionally conservative. If the pattern shape is unsupported,
+//! or if the pattern exceeds the DFA's representable state space, construction
+//! returns `None` and the caller must fall back to ordinary decompression-based
+//! LIKE evaluation.
+//!
+//! TODO(joe): suffix (`'%suffix'`) pushdown. Two approaches:
+//! - **Forward DFA**: use a non-sticky accept state with KMP fallback transitions,
+//!   check `state == accept` after processing all codes. Branchless and vectorizable.
+//! - **Backward scan**: walk the compressed code stream in reverse, comparing symbol
+//!   bytes from the end. Simpler, no DFA construction, but requires reverse parsing
+//!   of the FSST escape mechanism.
+//!
+//! ## Background: FSST Encoding
+//!
+//! [FSST](https://www.vldb.org/pvldb/vol13/p2649-boncz.pdf) compresses strings by
+//! replacing frequent byte sequences with single-byte **symbol codes** (0–254). Code
+//! byte 255 is reserved as the **escape code**: the next byte is a literal (uncompressed)
+//! byte. So a compressed string is a stream of:
+//!
+//! ```text
+//! [symbol_code] ... [symbol_code] [ESCAPE literal_byte] [symbol_code] ...
+//! ```
+//!
+//! A single symbol can expand to 1–8 bytes. Matching on compressed codes requires
+//! the DFA to handle multi-byte symbol expansions and the escape mechanism.
+//!
+//! ## The Algorithm: KMP → Byte Table → Symbol Table → Flat DFA
+//!
+//! Construction proceeds through four stages:
+//!
+//! ### Stage 1: KMP Failure Function
+//!
+//! We compute the standard [KMP](https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm)
+//! failure function for the needle bytes. This tells us, on a mismatch at
+//! position `i`, the longest proper prefix of `needle[0..i]` that is also a
+//! suffix — i.e., where to resume matching instead of starting over.
+//!
+//! ```text
+//! Needle: "abcabd"
+//! Failure: [0, 0, 0, 1, 2, 0]
+//!                      ^  ^
+//!                      At position 3 ('a'), the prefix "a" matches suffix "a"
+//!                      At position 4 ('b'), the prefix "ab" matches suffix "ab"
+//! ```
+//!
+//! ### Stage 2: Byte-Level Transition Table
+//!
+//! From the failure function, we build a full `(state × byte) → state` transition
+//! table. State `i` means "we have matched `needle[0..i]`". State `n` (= needle
+//! length) is the **accept** state.
+//!
+//! ```text
+//! Needle: "aba"  (3 states + accept)
+//!
+//!         Input byte
+//! State   'a'    'b'    other
+//! ─────   ────   ────   ─────
+//!   0      1      0      0      ← looking for first 'a'
+//!   1      1      2      0      ← matched "a", want 'b'
+//!   2      3✓     0      0      ← matched "ab", want 'a'
+//!   3✓     3✓     3✓     3✓     ← accept (sticky)
+//! ```
+//!
+//! For prefix matching, a mismatch at any state goes to a **fail** state (no
+//! fallback). For contains matching, mismatches follow KMP fallback transitions
+//! so we can find the needle anywhere in the string.
+//!
+//! ### Stage 3: Symbol-Level Transition Table
+//!
+//! FSST symbols can be multi-byte. To compute the transition for symbol code `c`
+//! in state `s`, we simulate feeding each byte of the symbol through the byte
+//! table:
+//!
+//! ```text
+//! Symbol #42 = "the" (3 bytes)
+//! State 0 + 't' → 0, + 'h' → 0, + 'e' → 0  ⟹ sym_trans[0][42] = 0
+//!
+//! If needle = "them":
+//! State 0 + 't' → 1, + 'h' → 2, + 'e' → 3  ⟹ sym_trans[0][42] = 3
+//! ```
+//!
+//! We then build a **fused 256-wide table**: for code bytes 0–254, use the
+//! symbol transition; for code byte 255 (ESCAPE_CODE), transition to a
+//! special sentinel that tells the scanner to read the next literal byte.
+//!
+//! ### Stage 4: Flat `u8` Table
+//!
+//! The fused table is stored as a flat `Vec<u8>` indexed as
+//! `transitions[state * 256 + byte]`. Both the prefix and contains DFAs use
+//! escape-sentinel handling: when the scanner sees the sentinel value, it reads
+//! the next byte from a separate byte-level escape table.
+//!
+//! TODO(joe): for short contains needles (≤7 bytes), a branchless escape-folded
+//! DFA with hierarchical 4-byte composition is ~2x faster. For needles ≤127
+//! bytes, an escape-folded flat DFA (2N+1 states) avoids the sentinel branch.
+//! See commit 7faf9f36f for those implementations.
+//!
+//! ## State-Space Limits
+//!
+//! The public behavior is shaped by two implementation limits, both measured in
+//! pattern **bytes** rather than Unicode scalar values:
+//!
+//! - `prefix%` pushdown is limited to **253 bytes**. The flat prefix DFA uses
+//!   `u8` state ids and needs room for progress states, an accept state, a
+//!   fail state, and one escape sentinel (N+3 ≤ 256).
+//! - `%needle%` pushdown is limited to **254 bytes**. The contains DFA stores
+//!   states in `u8`, so it needs room for every match-progress state plus both
+//!   the accept state and the escape sentinel.
+//!
+//! Patterns beyond those limits are still valid LIKE patterns; they simply do
+//! not use FSST pushdown and must be evaluated through the fallback path.
+
+mod flat_contains;
+mod prefix;
+#[cfg(test)]
+mod tests;
+
+use flat_contains::FlatContainsDfa;
+use fsst::ESCAPE_CODE;
+use fsst::Symbol;
+use prefix::FlatPrefixDfa;
+use vortex_buffer::BitBuffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+// ---------------------------------------------------------------------------
+// FsstMatcher — unified public API
+// ---------------------------------------------------------------------------
+
+/// A compiled matcher for LIKE patterns on FSST-compressed strings.
+///
+/// Encapsulates pattern parsing and DFA variant selection. Returns `None` from
+/// [`try_new`](Self::try_new) for patterns that cannot be evaluated without
+/// decompression (e.g., `_` wildcards, multiple `%` in non-standard positions,
+/// or patterns that exceed the DFA's representable byte-length limits).
+pub(crate) struct FsstMatcher {
+    inner: MatcherInner,
+}
+
+enum MatcherInner {
+    MatchAll,
+    Prefix(FlatPrefixDfa),
+    Contains(FlatContainsDfa),
+}
+
+impl FsstMatcher {
+    /// Try to build a matcher for the given LIKE pattern.
+    ///
+    /// Returns `Ok(None)` if the pattern shape is not supported for pushdown
+    /// (e.g. `_` wildcards, multiple non-bookend `%`, `prefix%` longer than
+    /// 253 bytes, or `%needle%` longer than 254 bytes).
+    pub(crate) fn try_new(
+        symbols: &[Symbol],
+        symbol_lengths: &[u8],
+        pattern: &[u8],
+    ) -> VortexResult<Option<Self>> {
+        let Some(like_kind) = LikeKind::parse(pattern) else {
+            return Ok(None);
+        };
+
+        let inner = match like_kind {
+            LikeKind::Prefix(b"") | LikeKind::Contains(b"") => MatcherInner::MatchAll,
+            LikeKind::Prefix(prefix) => {
+                if prefix.len() > FlatPrefixDfa::MAX_PREFIX_LEN {
+                    return Ok(None);
+                }
+                MatcherInner::Prefix(FlatPrefixDfa::new(symbols, symbol_lengths, prefix)?)
+            }
+            LikeKind::Contains(needle) => {
+                if needle.len() > FlatContainsDfa::MAX_NEEDLE_LEN {
+                    return Ok(None);
+                }
+                MatcherInner::Contains(FlatContainsDfa::new(symbols, symbol_lengths, needle)?)
+            }
+        };
+
+        Ok(Some(Self { inner }))
+    }
+
+    /// Run the matcher on a single FSST-compressed code sequence.
+    pub(crate) fn matches(&self, codes: &[u8]) -> bool {
+        match &self.inner {
+            MatcherInner::MatchAll => true,
+            MatcherInner::Prefix(dfa) => dfa.matches(codes),
+            MatcherInner::Contains(dfa) => dfa.matches(codes),
+        }
+    }
+}
+
+/// The subset of LIKE patterns we can handle without decompression.
+enum LikeKind<'a> {
+    /// `prefix%`
+    Prefix(&'a [u8]),
+    /// `%needle%`
+    Contains(&'a [u8]),
+}
+
+impl<'a> LikeKind<'a> {
+    fn parse(pattern: &'a [u8]) -> Option<Self> {
+        // `prefix%` (including just `%` where prefix is empty)
+        if let Some(prefix) = pattern.strip_suffix(b"%")
+            && !prefix.contains(&b'%')
+            && !prefix.contains(&b'_')
+        {
+            return Some(LikeKind::Prefix(prefix));
+        }
+
+        // `%needle%`
+        let inner = pattern.strip_prefix(b"%")?.strip_suffix(b"%")?;
+        if !inner.contains(&b'%') && !inner.contains(&b'_') {
+            return Some(LikeKind::Contains(inner));
+        }
+
+        None
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Scan helper
+// ---------------------------------------------------------------------------
+
+// TODO: add N-way ILP overrun scan for higher throughput on short strings.
+pub(crate) fn dfa_scan_to_bitbuf<T, F>(
+    n: usize,
+    offsets: &[T],
+    all_bytes: &[u8],
+    negated: bool,
+    matcher: F,
+) -> BitBuffer
+where
+    T: vortex_array::dtype::IntegerPType,
+    F: Fn(&[u8]) -> bool,
+{
+    let mut start: usize = offsets[0].as_();
+    BitBuffer::collect_bool(n, |i| {
+        let end: usize = offsets[i + 1].as_();
+        let result = matcher(&all_bytes[start..end]) != negated;
+        start = end;
+        result
+    })
+}
+
+// ---------------------------------------------------------------------------
+// DFA construction helpers
+// ---------------------------------------------------------------------------
+
+/// Builds the per-symbol transition table for FSST symbols.
+///
+/// For each `(state, symbol_code)` pair, simulates feeding the symbol's bytes
+/// through the byte-level transition table to compute the resulting state.
+///
+/// Returns a flat `Vec<u8>` indexed as `[state * n_symbols + code]`.
+fn build_symbol_transitions(
+    symbols: &[Symbol],
+    symbol_lengths: &[u8],
+    byte_table: &[u8],
+    n_states: u8,
+    accept_state: u8,
+) -> Vec<u8> {
+    let n_symbols = symbols.len();
+    let mut sym_trans = vec![0u8; n_states as usize * n_symbols];
+    for state in 0..n_states {
+        for code in 0..n_symbols {
+            if state == accept_state {
+                sym_trans[state as usize * n_symbols + code] = accept_state;
+                continue;
+            }
+            let sym = symbols[code].to_u64().to_le_bytes();
+            let sym_len = usize::from(symbol_lengths[code]);
+            let mut s = state;
+            for &b in &sym[..sym_len] {
+                if s == accept_state {
+                    break;
+                }
+                s = byte_table[s as usize * 256 + b as usize];
+            }
+            sym_trans[state as usize * n_symbols + code] = s;
+        }
+    }
+    sym_trans
+}
+
+/// Builds a fused 256-wide transition table from symbol transitions.
+///
+/// For each `(state, code_byte)`:
+/// - Code bytes `0..n_symbols`: use the symbol transition
+/// - `ESCAPE_CODE`: maps to `escape_value` (either a sentinel or escape state)
+/// - All others: use `default` (typically 0 for contains, fail_state for prefix)
+///
+/// Returns a flat `Vec<u8>` indexed as `[state * 256 + code_byte]`.
+fn build_fused_table(
+    sym_trans: &[u8],
+    n_symbols: usize,
+    n_states: u8,
+    escape_value_fn: impl Fn(u8) -> u8,
+    default: u8,
+) -> Vec<u8> {
+    let mut fused = vec![default; usize::from(n_states) * 256];
+    for state in 0..n_states {
+        let s = usize::from(state);
+        for code in 0..n_symbols {
+            fused[s * 256 + code] = sym_trans[s * n_symbols + code];
+        }
+        fused[s * 256 + usize::from(ESCAPE_CODE)] = escape_value_fn(state);
+    }
+    fused
+}
+
+// ---------------------------------------------------------------------------
+// KMP helpers
+// ---------------------------------------------------------------------------
+
+fn kmp_byte_transitions(needle: &[u8]) -> Vec<u8> {
+    let n_states = u8::try_from(needle.len() + 1)
+        .vortex_expect("kmp_byte_transitions: must have needle.len() ≤ 255");
+    let accept = n_states - 1;
+    let failure = kmp_failure_table(needle);
+
+    let mut table = vec![0u8; n_states as usize * 256];
+    for state in 0..n_states {
+        for byte in 0..256usize {
+            if state == accept {
+                table[state as usize * 256 + byte] = accept;
+                continue;
+            }
+            let mut s = state;
+            loop {
+                if byte == usize::from(needle[usize::from(s)]) {
+                    s += 1;
+                    break;
+                }
+                if s == 0 {
+                    break;
+                }
+                s = failure[usize::from(s) - 1];
+            }
+            table[state as usize * 256 + byte] = s;
+        }
+    }
+    table
+}
+
+fn kmp_failure_table(needle: &[u8]) -> Vec<u8> {
+    let mut failure = vec![0u8; needle.len()];
+    let mut k = 0u8;
+    for i in 1..needle.len() {
+        while k > 0 && needle[usize::from(k)] != needle[i] {
+            k = failure[usize::from(k) - 1];
+        }
+        if needle[usize::from(k)] == needle[i] {
+            k += 1;
+        }
+        failure[i] = k;
+    }
+    failure
+}
diff --git a/encodings/fsst/src/dfa/prefix.rs b/encodings/fsst/src/dfa/prefix.rs
new file mode 100644
index 00000000000..5c40affd7a1
--- /dev/null
+++ b/encodings/fsst/src/dfa/prefix.rs
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Flat `u8` transition table DFA for prefix matching (`LIKE 'prefix%'`).
+//!
+//! Supports prefixes up to 253 bytes (states: 0..N progress + accept + fail +
+//! sentinel ≤ 256).
+//!
+//! TODO(joe): for short prefixes (≤13 bytes), a shift-packed `[u64; 256]`
+//! representation would be simpler and easier to read — all state transitions
+//! for one input byte fit in a single `u64`. Benchmarks showed no meaningful
+//! perf difference, so we use flat-only for
+//! now to keep the code simple and support long prefixes.
+
+use fsst::Symbol;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use super::build_fused_table;
+use super::build_symbol_transitions;
+
+/// Flat `u8` transition table DFA for prefix matching on FSST codes.
+///
+/// States 0..prefix_len track match progress, plus ACCEPT, FAIL, and an
+/// escape SENTINEL. Transitions are stored in a flat `Vec<u8>` indexed as
+/// `[state * 256 + byte]`.
+///
+/// ```text
+/// Prefix: "http"  (4 progress states + accept + fail)
+///
+///          Input byte
+/// State    'h'    't'    'p'    other
+/// ─────    ────   ────   ────   ─────
+///   0       1      F      F      F     ← want 'h'
+///   1       F      2      F      F     ← want 't'
+///   2       F      3      F      F     ← want 't'
+///   3       F      F      4✓     F     ← want 'p'
+///   4✓      4✓     4✓     4✓     4✓    ← accept (sticky)
+///   F       F      F      F      F     ← fail (sticky)
+///
+/// Escape handling: code 255 → sentinel → read next literal byte → byte table
+/// ```
+pub(crate) struct FlatPrefixDfa {
+    /// `transitions[state * 256 + byte]` -> next state.
+    transitions: Vec<u8>,
+    /// `escape_transitions[state * 256 + byte]` -> next state for escaped bytes.
+    escape_transitions: Vec<u8>,
+    accept_state: u8,
+    fail_state: u8,
+    sentinel: u8,
+}
+
+impl FlatPrefixDfa {
+    pub(crate) const MAX_PREFIX_LEN: usize = (u8::MAX - 2) as usize;
+
+    pub(crate) fn new(
+        symbols: &[Symbol],
+        symbol_lengths: &[u8],
+        prefix: &[u8],
+    ) -> VortexResult<Self> {
+        if prefix.len() > Self::MAX_PREFIX_LEN {
+            vortex_bail!(
+                "prefix length {} exceeds maximum {} for flat prefix DFA",
+                prefix.len(),
+                Self::MAX_PREFIX_LEN
+            );
+        }
+
+        let accept_state = u8::try_from(prefix.len()).vortex_expect("prefix fits in u8");
+        let fail_state = accept_state + 1;
+        let n_states = fail_state + 1;
+        let sentinel = fail_state + 1;
+
+        let byte_table = build_prefix_byte_table(prefix, accept_state, fail_state);
+
+        let sym_trans =
+            build_symbol_transitions(symbols, symbol_lengths, &byte_table, n_states, accept_state);
+
+        let transitions = build_fused_table(
+            &sym_trans,
+            symbols.len(),
+            n_states,
+            |_| sentinel,
+            fail_state,
+        );
+
+        Ok(Self {
+            transitions,
+            escape_transitions: byte_table,
+            accept_state,
+            fail_state,
+            sentinel,
+        })
+    }
+
+    pub(crate) fn matches(&self, codes: &[u8]) -> bool {
+        let mut state = 0u8;
+        let mut pos = 0;
+        while pos < codes.len() {
+            let code = codes[pos];
+            pos += 1;
+            let next = self.transitions[usize::from(state) * 256 + usize::from(code)];
+            if next == self.sentinel {
+                if pos >= codes.len() {
+                    return false;
+                }
+                let b = codes[pos];
+                pos += 1;
+                state = self.escape_transitions[usize::from(state) * 256 + usize::from(b)];
+            } else {
+                state = next;
+            }
+            if state == self.accept_state {
+                return true;
+            }
+            if state == self.fail_state {
+                return false;
+            }
+        }
+        state == self.accept_state
+    }
+}
+
+/// Build a byte-level transition table for prefix matching.
+///
+/// For each state, only the correct next byte advances; everything else goes
+/// to the fail state.
+fn build_prefix_byte_table(prefix: &[u8], accept_state: u8, fail_state: u8) -> Vec<u8> {
+    let n_states = fail_state + 1;
+    let mut table = vec![fail_state; usize::from(n_states) * 256];
+
+    for state in 0..n_states {
+        let s = usize::from(state);
+        if state == accept_state {
+            for byte in 0..256 {
+                table[s * 256 + byte] = accept_state;
+            }
+        } else if state != fail_state {
+            // Only the correct next byte advances; everything else fails.
+            let next_byte = prefix[s];
+            let next_state = if s + 1 >= prefix.len() {
+                accept_state
+            } else {
+                state + 1
+            };
+            table[s * 256 + usize::from(next_byte)] = next_state;
+        }
+    }
+    table
+}
diff --git a/encodings/fsst/src/dfa/tests.rs b/encodings/fsst/src/dfa/tests.rs
new file mode 100644
index 00000000000..caf04adb3c6
--- /dev/null
+++ b/encodings/fsst/src/dfa/tests.rs
@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::LazyLock;
+
+use fsst::ESCAPE_CODE;
+use fsst::Symbol;
+use rstest::rstest;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::assert_arrays_eq;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::scalar_fn::fns::like::Like;
+use vortex_array::scalar_fn::fns::like::LikeOptions;
+use vortex_array::session::ArraySession;
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use super::FsstMatcher;
+use super::LikeKind;
+use super::flat_contains::FlatContainsDfa;
+use super::prefix::FlatPrefixDfa;
+use crate::FSSTArray;
+use crate::fsst_compress;
+use crate::fsst_train_compressor;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+/// Helper: make a Symbol from a byte string (up to 8 bytes, zero-padded).
+fn sym(bytes: &[u8]) -> Symbol {
+    let mut buf = [0u8; 8];
+    buf[..bytes.len()].copy_from_slice(bytes);
+    Symbol::from_slice(&buf)
+}
+
+fn escaped(bytes: &[u8]) -> Vec<u8> {
+    let mut codes = Vec::with_capacity(bytes.len() * 2);
+    for &b in bytes {
+        codes.push(ESCAPE_CODE);
+        codes.push(b);
+    }
+    codes
+}
+
+#[test]
+fn test_like_kind_parse() {
+    assert!(matches!(
+        LikeKind::parse(b"http%"),
+        Some(LikeKind::Prefix(b"http"))
+    ));
+    assert!(matches!(
+        LikeKind::parse(b"%needle%"),
+        Some(LikeKind::Contains(b"needle"))
+    ));
+    assert!(matches!(LikeKind::parse(b"%"), Some(LikeKind::Prefix(b""))));
+    // Suffix and underscore patterns are not supported.
+    assert!(LikeKind::parse(b"%suffix").is_none());
+    assert!(LikeKind::parse(b"a_c").is_none());
+}
+
+/// No symbols — all bytes escaped. Simplest case to see the two tables.
+#[test]
+fn test_prefix_dfa_no_symbols() -> VortexResult<()> {
+    let dfa = FlatPrefixDfa::new(&[], &[], b"ab")?;
+
+    assert!(dfa.matches(&escaped(b"abx")));
+    assert!(dfa.matches(&escaped(b"ab")));
+    assert!(!dfa.matches(&escaped(b"a")));
+    assert!(!dfa.matches(&escaped(b"ax")));
+    assert!(!dfa.matches(&escaped(b"ba")));
+    assert!(!dfa.matches(&[]));
+
+    Ok(())
+}
+
+/// With symbols — shows how multi-byte symbols interact with prefix matching.
+///
+/// Symbol table: code 0 = "ht", code 1 = "tp"
+/// Prefix: "http"
+///
+/// The string "http" can be encoded as:
+///   [0, 1]           — two symbols: "ht" + "tp"
+///   [ESC,h, ESC,t, ESC,t, ESC,p] — all escaped
+///   [0, ESC,t, ESC,p]            — symbol "ht" + escaped "t" + escaped "p"
+#[test]
+fn test_prefix_dfa_with_symbols() -> VortexResult<()> {
+    let symbols = [sym(b"ht"), sym(b"tp")];
+    let lengths = [2u8, 2];
+    let dfa = FlatPrefixDfa::new(&symbols, &lengths, b"http")?;
+
+    // "http" via two symbols: code 0 ("ht") + code 1 ("tp") → accept
+    assert!(dfa.matches(&[0, 1]));
+
+    // "http" all escaped
+    assert!(dfa.matches(&escaped(b"http")));
+
+    // "http" mixed: symbol "ht" + escaped "tp"
+    assert!(dfa.matches(&[0, ESCAPE_CODE, b't', ESCAPE_CODE, b'p']));
+
+    // "htxx" via symbol "ht" + escaped "xx" → fail after "ht" advances to state 2,
+    // then 'x' doesn't match 't'
+    assert!(!dfa.matches(&[0, ESCAPE_CODE, b'x', ESCAPE_CODE, b'x']));
+
+    // "tp" alone → symbol "tp" from state 0 feeds 't','p' through byte table:
+    // state 0 wants 'h', sees 't' → fail
+    assert!(!dfa.matches(&[1]));
+
+    Ok(())
+}
+
+/// Longer prefix showing more progress states.
+#[test]
+fn test_prefix_dfa_longer() -> VortexResult<()> {
+    // code 0 = "tp" (2 bytes), code 1 = "htt" (3 bytes), code 2 = "p:/" (3 bytes)
+    let symbols = [sym(b"tp"), sym(b"htt"), sym(b"p:/")];
+    let lengths = [2u8, 3, 3];
+    let dfa = FlatPrefixDfa::new(&symbols, &lengths, b"http://")?;
+
+    // "http://e" via symbols: "htt"(1) + "p:/"(2) + escaped "/" + escaped "e"
+    // "htt" = states 0→1→2→3, "p:/" = states 3→4→5→6, "/" = state 6→accept
+    assert!(dfa.matches(&[1, 2, ESCAPE_CODE, b'/', ESCAPE_CODE, b'e']));
+
+    // "http:/" — 6 chars, missing the 7th '/'
+    assert!(!dfa.matches(&[1, ESCAPE_CODE, b'p', ESCAPE_CODE, b':', ESCAPE_CODE, b'/',]));
+
+    // "http://" all escaped — 7 chars, exact match
+    assert!(dfa.matches(&escaped(b"http://")));
+
+    // "tp" alone (code 0) from state 0: feeds 't','p' → state 0 wants 'h', sees 't' → fail
+    assert!(!dfa.matches(&[0]));
+
+    // "htt" + "tp" = "httpp"? No — "htt" → states 0→1→2→3, then "tp":
+    // state 3 wants 'p', sees 't' → fail immediately
+    assert!(!dfa.matches(&[1, 0]));
+
+    Ok(())
+}
+
+#[test]
+fn test_prefix_pushdown_len_13_with_escapes() {
+    let matcher = FsstMatcher::try_new(&[], &[], b"abcdefghijklm%")
+        .unwrap()
+        .unwrap();
+
+    assert!(matcher.matches(&escaped(b"abcdefghijklm")));
+    assert!(!matcher.matches(&escaped(b"abcdefghijklx")));
+}
+
+#[test]
+fn test_prefix_pushdown_len_14_now_handled() {
+    // 14-byte prefix is now handled by FlatPrefixDfa (was rejected by shift-packed).
+    assert!(
+        FsstMatcher::try_new(&[], &[], b"abcdefghijklmn%")
+            .unwrap()
+            .is_some()
+    );
+}
+
+#[test]
+fn test_prefix_pushdown_long_prefix() -> VortexResult<()> {
+    let prefix = "a".repeat(FlatPrefixDfa::MAX_PREFIX_LEN);
+    let pattern = format!("{prefix}%");
+    let matcher = FsstMatcher::try_new(&[], &[], pattern.as_bytes())?.unwrap();
+
+    assert!(matcher.matches(&escaped(prefix.as_bytes())));
+
+    let mut mismatch = prefix.into_bytes();
+    mismatch[FlatPrefixDfa::MAX_PREFIX_LEN - 1] = b'b';
+    assert!(!matcher.matches(&escaped(&mismatch)));
+
+    Ok(())
+}
+
+#[test]
+fn test_prefix_pushdown_rejects_len_254() {
+    debug_assert_eq!(FlatPrefixDfa::MAX_PREFIX_LEN, 253);
+    let prefix = "a".repeat(254);
+    let pattern = format!("{prefix}%");
+    assert!(
+        FsstMatcher::try_new(&[], &[], pattern.as_bytes())
+            .unwrap()
+            .is_none()
+    );
+}
+
+#[test]
+fn test_contains_pushdown_len_254_with_escapes() {
+    let needle = "a".repeat(FlatContainsDfa::MAX_NEEDLE_LEN);
+    let pattern = format!("%{needle}%");
+    let matcher = FsstMatcher::try_new(&[], &[], pattern.as_bytes())
+        .unwrap()
+        .unwrap();
+
+    assert!(matcher.matches(&escaped(needle.as_bytes())));
+
+    let mut mismatch = needle.into_bytes();
+    mismatch[FlatContainsDfa::MAX_NEEDLE_LEN - 1] = b'b';
+    assert!(!matcher.matches(&escaped(&mismatch)));
+}
+
+#[test]
+fn test_contains_pushdown_rejects_len_255() {
+    let needle = "a".repeat(FlatContainsDfa::MAX_NEEDLE_LEN + 1);
+    let pattern = format!("%{needle}%");
+    assert!(
+        FsstMatcher::try_new(&[], &[], pattern.as_bytes())
+            .unwrap()
+            .is_none()
+    );
+}
+
+// ---------------------------------------------------------------------------
+// End-to-end edge cases: FSST compress → LIKE → compare booleans
+// ---------------------------------------------------------------------------
+
+fn make_fsst_str(strings: &[Option<&str>]) -> FSSTArray {
+    let varbin = VarBinArray::from_iter(
+        strings.iter().copied(),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+fn run_like(array: FSSTArray, pattern_arr: ArrayRef) -> VortexResult<BoolArray> {
+    let len = array.len();
+    let arr: ArrayRef = array.into_array();
+    let result = Like
+        .try_new_array(len, LikeOptions::default(), [arr, pattern_arr])?
+        .into_array()
+        .execute::<Canonical>(&mut SESSION.create_execution_ctx())?;
+    Ok(result.into_bool())
+}
+
+#[rstest]
+// Empty strings
+#[case(&[""], "aaaa%", &[false])]
+#[case(&[""], "%aaaa%", &[false])]
+#[case(&[""], "%", &[true])]
+#[case(&[""], "%%", &[true])]
+#[case(&["", "", ""], "%", &[true, true, true])]
+#[case(&["", "abc", ""], "%%", &[true, true, true])]
+// Single-char patterns
+#[case(&["a", "b", ""], "a%", &[true, false, false])]
+#[case(&["a", "b", ""], "%a%", &[true, false, false])]
+// Needle longer than every input string
+#[case(&["ab", "abc", ""], "%abcd%", &[false, false, false])]
+#[case(&["ab", "abc", ""], "abcd%", &[false, false, false])]
+// Exact match (prefix pattern = entire string + %)
+#[case(&["abc", "abcd", "ab"], "abc%", &[true, true, false])]
+#[case(&["abc", "abcd", "ab"], "%abc%", &[true, true, false])]
+// Repeated characters — KMP overlap
+#[case(&["aa", "aaa", "aaaa", "aba"], "%aaa%", &[false, true, true, false])]
+#[case(&["aab", "aaab", "a"], "aaa%", &[false, true, false])]
+// Needle at different positions
+#[case(&["xxabcyy", "abcyy", "xxabc", "abc", "xabx"], "%abc%", &[true, true, true, true, false])]
+// All identical strings
+#[case(&["aaa", "aaa", "aaa"], "%aaa%", &[true, true, true])]
+#[case(&["aaa", "aaa", "aaa"], "bbb%", &[false, false, false])]
+// Single element arrays
+#[case(&["hello"], "hello%", &[true])]
+#[case(&["hello"], "hellx%", &[false])]
+#[case(&["hello"], "%ello%", &[true])]
+#[case(&["hello"], "%ellx%", &[false])]
+// Overlapping KMP pattern "abab"
+#[case(&["ababab", "abab", "aba", "xababx"], "%abab%", &[true, true, false, true])]
+// Prefix that shares chars with rest of string
+#[case(&["abab", "abba", "abcd"], "ab%", &[true, true, true])]
+#[case(&["abab", "abba", "abcd", "ba"], "ab%", &[true, true, true, false])]
+// The string "aabaabaabaab" requires multi-level KMP fallback at the 'a' after "aabaabaab"
+#[case(&["aabaabaabaab", "aabaabaax", "xaabaabaab"], "%aabaabaab%", &[true, false, true])]
+#[case(&["café latte", "naïve approach", "café noir"], "café%", &[true, false, true])]
+#[case(&["日本語テスト", "日本語データ", "英語テスト"], "%日本語%", &[true, true, false])]
+// 10-byte needle, contains: match at start, middle, end, exact, and near-miss
+#[case(
+    &["abcdefghijxxx", "xxxabcdefghij", "xxabcdefghijxx", "abcdefghij", "abcdefghxx"],
+    "%abcdefghij%",
+    &[true, true, true, true, false]
+)]
+// 10-byte prefix: same needle but anchored at the start of the string
+#[case(
+    &["abcdefghijxxx", "abcdefghij", "xabcdefghij", "abcdefghxx"],
+    "abcdefghij%",
+    &[true, true, false, false]
+)]
+// 9-byte needle with KMP-relevant overlap ("abcabcabc"):
+// failure table = [0,0,0,1,2,3,4,5,6], so a partial match of "abcabcab"
+// followed by a mismatch must fall back to state 5 ("abcab"), not restart.
+// This exercises multi-level KMP backtracking across symbol boundaries.
+#[case(
+    &["xxabcabcabcxx", "abcabcabc", "abcabcabx", "abcabcxx"],
+    "%abcabcabc%",
+    &[true, true, false, false]
+)]
+fn test_like_edge_cases(
+    #[case] strings: &[&str],
+    #[case] pattern: &str,
+    #[case] expected: &[bool],
+) -> VortexResult<()> {
+    let opts: Vec<Option<&str>> = strings.iter().map(|s| Some(*s)).collect();
+    let fsst_arr = make_fsst_str(&opts);
+    let result = run_like(
+        fsst_arr,
+        ConstantArray::new(pattern, opts.len()).into_array(),
+    )?;
+    let expected_arr = BoolArray::from_iter(expected.iter().copied());
+    assert_arrays_eq!(&result, &expected_arr);
+    Ok(())
+}
diff --git a/encodings/fsst/src/kernel.rs b/encodings/fsst/src/kernel.rs
index eea4234b4ba..05b58e3215d 100644
--- a/encodings/fsst/src/kernel.rs
+++ b/encodings/fsst/src/kernel.rs
@@ -1,30 +1,31 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+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::like::LikeExecuteAdaptor;
 
-use crate::FSSTVTable;
+use crate::FSST;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<FSSTVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(FSSTVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(FSSTVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(FSSTVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<FSST> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(FSST)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(FSST)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(FSST)),
+    ParentKernelSet::lift(&LikeExecuteAdaptor(FSST)),
 ]);
 
 #[cfg(test)]
 mod tests {
     use std::sync::LazyLock;
 
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::FilterArray;
-    use vortex_array::arrays::builder::VarBinBuilder;
+    use vortex_array::arrays::varbin::builder::VarBinBuilder;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
@@ -33,7 +34,7 @@ mod tests {
     use vortex_mask::Mask;
     use vortex_session::VortexSession;
 
-    use crate::FSSTVTable;
+    use crate::FSST;
     use crate::fsst_compress;
     use crate::fsst_train_compressor;
 
@@ -55,13 +56,15 @@ mod tests {
         let input = builder.finish(DType::Utf8(Nullability::NonNullable));
 
         let compressor = fsst_train_compressor(&input);
-        fsst_compress(input, &compressor).into_array()
+        let len = input.len();
+        let dtype = input.dtype().clone();
+        fsst_compress(input, len, &dtype, &compressor).into_array()
     }
 
     #[test]
     fn test_fsst_filter_simple() -> VortexResult<()> {
         let fsst_array = build_test_fsst_array();
-        assert!(fsst_array.is::<FSSTVTable>());
+        assert!(fsst_array.is::<FSST>());
         assert_eq!(fsst_array.len(), 10);
 
         // Filter 1/5 elements (every 5th element: indices 0 and 5)
@@ -128,14 +131,15 @@ mod tests {
         let input = builder.finish(DType::Utf8(Nullability::Nullable));
 
         let compressor = fsst_train_compressor(&input);
-        let fsst_array: ArrayRef = fsst_compress(input.clone(), &compressor).into_array();
+        let fsst_array: ArrayRef =
+            fsst_compress(input.clone(), input.len(), input.dtype(), &compressor).into_array();
 
         // Filter: only select the last element (index 22)
         let mut mask = vec![false; 22];
         mask.push(true);
         let mask = Mask::from_iter(mask);
 
-        let filter_array = FilterArray::new(fsst_array.clone(), mask.clone()).into_array();
+        let filter_array = FilterArray::new(fsst_array, mask.clone()).into_array();
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
@@ -156,11 +160,12 @@ mod tests {
         let input = builder.finish(DType::Utf8(Nullability::Nullable));
 
         let compressor = fsst_train_compressor(&input);
-        let fsst_array: ArrayRef = fsst_compress(input.clone(), &compressor).into_array();
+        let fsst_array: ArrayRef =
+            fsst_compress(input.clone(), input.len(), input.dtype(), &compressor).into_array();
 
         let mask = Mask::from_iter([true, false, true]);
 
-        let filter_array = FilterArray::new(fsst_array.clone(), mask.clone()).into_array();
+        let filter_array = FilterArray::new(fsst_array, mask.clone()).into_array();
         let mut ctx = SESSION.create_execution_ctx();
         let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
diff --git a/encodings/fsst/src/lib.rs b/encodings/fsst/src/lib.rs
index 5cc75c59b2a..3305c0e66fc 100644
--- a/encodings/fsst/src/lib.rs
+++ b/encodings/fsst/src/lib.rs
@@ -15,6 +15,7 @@ mod array;
 mod canonical;
 mod compress;
 mod compute;
+mod dfa;
 mod kernel;
 mod ops;
 mod rules;
diff --git a/encodings/fsst/src/ops.rs b/encodings/fsst/src/ops.rs
index 368fe5d819b..86172377f7e 100644
--- a/encodings/fsst/src/ops.rs
+++ b/encodings/fsst/src/ops.rs
@@ -1,18 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::varbin_scalar;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::arrays::varbin::varbin_scalar;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
+use crate::FSST;
+use crate::FSSTArrayExt;
 
-impl OperationsVTable<FSSTVTable> for FSSTVTable {
-    fn scalar_at(array: &FSSTArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<FSST> for FSST {
+    fn scalar_at(
+        array: ArrayView<'_, FSST>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let compressed = array.codes().scalar_at(index)?;
         let binary_datum = compressed.as_binary().value().vortex_expect("non-null");
 
diff --git a/encodings/fsst/src/rules.rs b/encodings/fsst/src/rules.rs
index d878bb75db7..bec81c0fd3a 100644
--- a/encodings/fsst/src/rules.rs
+++ b/encodings/fsst/src/rules.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::FSSTVTable;
+use crate::FSST;
 
-pub(crate) static RULES: ParentRuleSet<FSSTVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&SliceReduceAdaptor(FSSTVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(FSSTVTable)),
+pub(crate) static RULES: ParentRuleSet<FSST> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&SliceReduceAdaptor(FSST)),
+    ParentRuleSet::lift(&CastReduceAdaptor(FSST)),
 ]);
diff --git a/encodings/fsst/src/slice.rs b/encodings/fsst/src/slice.rs
index cfb6d7ff3ae..9b7b2833d85 100644
--- a/encodings/fsst/src/slice.rs
+++ b/encodings/fsst/src/slice.rs
@@ -4,26 +4,29 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
-use vortex_array::arrays::VarBinVTable;
+use vortex_array::arrays::VarBin;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
-use crate::FSSTArray;
-use crate::FSSTVTable;
+use crate::FSST;
+use crate::FSSTArrayExt;
 
-impl SliceReduce for FSSTVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for FSST {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: slicing the `codes` leaves the symbol table intact
         Ok(Some(
             unsafe {
-                FSSTArray::new_unchecked(
+                FSST::new_unchecked(
                     array.dtype().clone(),
                     array.symbols().clone(),
                     array.symbol_lengths().clone(),
-                    VarBinVTable::_slice(array.codes().as_::<VarBinVTable>(), range.clone())?
-                        .try_into::<VarBinVTable>()
+                    array
+                        .codes()
+                        .slice(range.clone())?
+                        .try_downcast::<VarBin>()
                         .map_err(|_| vortex_err!("cannot fail conversion"))?,
                     array.uncompressed_lengths().slice(range)?,
                 )
diff --git a/encodings/fsst/src/test_utils.rs b/encodings/fsst/src/test_utils.rs
index fcf0d331c5e..421a5d4c3f5 100644
--- a/encodings/fsst/src/test_utils.rs
+++ b/encodings/fsst/src/test_utils.rs
@@ -3,7 +3,7 @@
 
 #![allow(clippy::unwrap_used)]
 
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::prelude::StdRng;
 use vortex_array::ArrayRef;
@@ -16,6 +16,7 @@ use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
 use vortex_error::VortexExpect;
 
+use crate::FSSTArray;
 use crate::fsst_compress;
 use crate::fsst_train_compressor;
 
@@ -42,7 +43,9 @@ pub fn gen_fsst_test_data(len: usize, avg_str_len: usize, unique_chars: u8) -> A
     );
     let compressor = fsst_train_compressor(&varbin);
 
-    fsst_compress(varbin, &compressor).into_array()
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor).into_array()
 }
 
 pub fn gen_dict_fsst_test_data<T: NativePType>(
@@ -59,3 +62,543 @@ pub fn gen_dict_fsst_test_data<T: NativePType>(
     DictArray::try_new(codes.into_array(), values)
         .vortex_expect("DictArray::try_new should succeed for test data")
 }
+
+// ---------------------------------------------------------------------------
+// Benchmark dataset generators
+// ---------------------------------------------------------------------------
+
+pub const NUM_STRINGS: usize = 100_000;
+
+// ---------------------------------------------------------------------------
+// URL generator (ClickBench-style weighted domains)
+// ---------------------------------------------------------------------------
+
+pub const HIGH_MATCH_DOMAIN: &str = "smeshariki.ru";
+pub const LOW_MATCH_DOMAIN: &str = "rare-example-domain.com";
+
+pub const URL_DOMAINS: &[(&str, u32)] = &[
+    ("smeshariki.ru", 500),
+    ("auto.ru", 150),
+    ("komme.ru", 100),
+    ("yandex.ru", 80),
+    ("mail.ru", 60),
+    ("livejournal.com", 40),
+    ("vk.com", 30),
+    ("avito.ru", 20),
+    ("kinopoisk.ru", 10),
+    ("rare-example-domain.com", 10),
+];
+
+pub const URL_PATHS: &[&str] = &[
+    "/GameMain.aspx",
+    "/index.php",
+    "/catalog/item",
+    "/search",
+    "/news/article",
+    "/user/profile",
+    "/collection/view",
+    "/cars/used/sale",
+    "/forum/thread",
+    "/photo/album",
+    "/video/watch",
+    "/download/file",
+    "/api/v1/resource",
+    "/shop/product",
+    "/blog/post",
+];
+
+pub fn generate_url_data() -> VarBinArray {
+    generate_url_data_n(NUM_STRINGS)
+}
+
+pub fn generate_url_data_n(n: usize) -> VarBinArray {
+    let mut rng = StdRng::seed_from_u64(42);
+    let total_weight: u32 = URL_DOMAINS.iter().map(|(_, w)| w).sum();
+    let urls: Vec<Option<Box<[u8]>>> = (0..n)
+        .map(|_| {
+            let domain_roll = rng.random_range(0..total_weight);
+            let mut cumulative = 0u32;
+            let mut domain = URL_DOMAINS[0].0;
+            for &(d, w) in URL_DOMAINS {
+                cumulative += w;
+                if domain_roll < cumulative {
+                    domain = d;
+                    break;
+                }
+            }
+            let path = URL_PATHS[rng.random_range(0..URL_PATHS.len())];
+            let query_id: u32 = rng.random_range(1..100_000);
+            let tab: u16 = rng.random_range(1..20);
+            let url = format!("http://{domain}{path}?id={query_id}&tab={tab}#ref={query_id}");
+            Some(url.into_bytes().into_boxed_slice())
+        })
+        .collect();
+    VarBinArray::from_iter(urls, DType::Utf8(Nullability::NonNullable))
+}
+
+pub fn make_fsst_urls(n: usize) -> FSSTArray {
+    let varbin = generate_url_data_n(n);
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// ClickBench-style URL generator (longer URLs with query params, fragments)
+// ---------------------------------------------------------------------------
+
+const CB_DOMAINS: &[&str] = &[
+    "www.google.com",
+    "yandex.ru",
+    "mail.ru",
+    "vk.com",
+    "www.youtube.com",
+    "www.facebook.com",
+    "ok.ru",
+    "go.mail.ru",
+    "www.avito.ru",
+    "pogoda.yandex.ru",
+    "news.yandex.ru",
+    "maps.yandex.ru",
+    "market.yandex.ru",
+    "afisha.yandex.ru",
+    "auto.ru",
+    "www.kinopoisk.ru",
+    "www.ozon.ru",
+    "www.wildberries.ru",
+    "aliexpress.ru",
+    "lenta.ru",
+];
+
+const CB_PATHS: &[&str] = &[
+    "/search",
+    "/catalog/electronics/smartphones",
+    "/product/item/123456789",
+    "/news/2024/03/15/article-about-technology",
+    "/user/profile/settings/notifications",
+    "/api/v2/catalog/search",
+    "/checkout/cart/summary",
+    "/blog/2024/how-to-optimize-database-queries-for-better-performance",
+    "/category/home-and-garden/furniture/tables",
+    "/",
+];
+
+const CB_PARAMS: &[&str] = &[
+    "?utm_source=google&utm_medium=cpc&utm_campaign=spring_sale_2024&utm_content=banner_v2",
+    "?q=buy+smartphone+online+cheap+free+shipping&category=electronics&sort=price_asc&page=3",
+    "?ref=main_page_carousel_block_position_4&sessionid=abc123def456",
+    "?from=tabbar&clid=2270455&text=weather+forecast+tomorrow",
+    "?lr=213&msid=1234567890.12345&suggest_reqid=abcdef&csg=12345",
+    "",
+    "",
+    "",
+    "?page=1&per_page=20",
+    "?source=serp&forceshow=1",
+];
+
+const CB_FRAGMENTS: &[&str] = &[
+    "",
+    "",
+    "",
+    "#section-reviews",
+    "#comments",
+    "#price-history",
+    "",
+    "",
+    "",
+    "",
+];
+
+pub fn generate_clickbench_urls(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(123);
+    (0..n)
+        .map(|_| {
+            let scheme = if rng.random_bool(0.7) {
+                "https"
+            } else {
+                "http"
+            };
+            let domain = CB_DOMAINS[rng.random_range(0..CB_DOMAINS.len())];
+            let path = CB_PATHS[rng.random_range(0..CB_PATHS.len())];
+            let params = CB_PARAMS[rng.random_range(0..CB_PARAMS.len())];
+            let fragment = CB_FRAGMENTS[rng.random_range(0..CB_FRAGMENTS.len())];
+            format!("{scheme}://{domain}{path}{params}{fragment}")
+        })
+        .collect()
+}
+
+pub fn make_fsst_clickbench_urls(n: usize) -> FSSTArray {
+    let urls = generate_clickbench_urls(n);
+    let varbin = VarBinArray::from_iter(
+        urls.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// Short URL generator (simple URLs for contains benchmarks)
+// ---------------------------------------------------------------------------
+
+const SHORT_URL_DOMAINS: &[&str] = &[
+    "google.com",
+    "facebook.com",
+    "github.com",
+    "stackoverflow.com",
+    "amazon.com",
+    "reddit.com",
+    "twitter.com",
+    "youtube.com",
+    "wikipedia.org",
+    "microsoft.com",
+    "apple.com",
+    "netflix.com",
+    "linkedin.com",
+    "cloudflare.com",
+    "google.co.uk",
+    "docs.google.com",
+    "mail.google.com",
+    "maps.google.com",
+    "news.ycombinator.com",
+    "arxiv.org",
+];
+
+const SHORT_URL_PATHS: &[&str] = &[
+    "/index.html",
+    "/about",
+    "/search?q=vortex",
+    "/user/profile/settings",
+    "/api/v2/data",
+    "/blog/2024/post",
+    "/products/item/12345",
+    "/docs/reference/guide",
+    "/login",
+    "/dashboard/analytics",
+];
+
+pub fn generate_short_urls(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(42);
+    (0..n)
+        .map(|_| {
+            let scheme = if rng.random_bool(0.8) {
+                "https"
+            } else {
+                "http"
+            };
+            let domain = SHORT_URL_DOMAINS[rng.random_range(0..SHORT_URL_DOMAINS.len())];
+            let path = SHORT_URL_PATHS[rng.random_range(0..SHORT_URL_PATHS.len())];
+            format!("{scheme}://{domain}{path}")
+        })
+        .collect()
+}
+
+pub fn make_fsst_short_urls(n: usize) -> FSSTArray {
+    let urls = generate_short_urls(n);
+    let varbin = VarBinArray::from_iter(
+        urls.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// Log lines generator (Apache/nginx-style access logs)
+// ---------------------------------------------------------------------------
+
+const LOG_METHODS: &[&str] = &["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"];
+const LOG_PATHS: &[&str] = &[
+    "/api/v1/users",
+    "/api/v2/products/search",
+    "/healthcheck",
+    "/static/js/app.bundle.min.js",
+    "/favicon.ico",
+    "/login",
+    "/dashboard/analytics",
+    "/api/v1/orders/12345/status",
+    "/graphql",
+    "/metrics",
+];
+const LOG_STATUS: &[u16] = &[
+    200, 200, 200, 200, 200, 201, 301, 302, 400, 403, 404, 500, 502,
+];
+const LOG_IPS: &[&str] = &[
+    "192.168.1.1",
+    "10.0.0.42",
+    "172.16.0.100",
+    "203.0.113.50",
+    "198.51.100.23",
+    "8.8.8.8",
+    "1.1.1.1",
+    "74.125.200.100",
+    "151.101.1.69",
+    "93.184.216.34",
+];
+const LOG_UAS: &[&str] = &[
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+    "curl/7.81.0",
+    "python-requests/2.28.1",
+    "Go-http-client/1.1",
+    "Googlebot/2.1 (+http://www.google.com/bot.html)",
+];
+
+pub fn generate_log_lines(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(456);
+    (0..n)
+        .map(|_| {
+            let ip = LOG_IPS[rng.random_range(0..LOG_IPS.len())];
+            let method = LOG_METHODS[rng.random_range(0..LOG_METHODS.len())];
+            let path = LOG_PATHS[rng.random_range(0..LOG_PATHS.len())];
+            let status = LOG_STATUS[rng.random_range(0..LOG_STATUS.len())];
+            let size = rng.random_range(100..50000);
+            let ua = LOG_UAS[rng.random_range(0..LOG_UAS.len())];
+            format!(
+                r#"{ip} - - [15/Mar/2024:10:{:02}:{:02} +0000] "{method} {path} HTTP/1.1" {status} {size} "-" "{ua}""#,
+                rng.random_range(0..60u32),
+                rng.random_range(0..60u32),
+            )
+        })
+        .collect()
+}
+
+pub fn make_fsst_log_lines(n: usize) -> FSSTArray {
+    let lines = generate_log_lines(n);
+    let varbin = VarBinArray::from_iter(
+        lines.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// JSON strings generator (typical API response payloads)
+// ---------------------------------------------------------------------------
+
+const JSON_NAMES: &[&str] = &[
+    "Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Hank", "Ivy", "Jack",
+];
+const JSON_CITIES: &[&str] = &[
+    "New York",
+    "London",
+    "Tokyo",
+    "Berlin",
+    "Sydney",
+    "Toronto",
+    "Paris",
+    "Mumbai",
+    "São Paulo",
+    "Seoul",
+];
+const JSON_TAGS: &[&str] = &[
+    "premium",
+    "verified",
+    "admin",
+    "moderator",
+    "subscriber",
+    "trial",
+    "enterprise",
+    "developer",
+];
+
+pub fn generate_json_strings(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(789);
+    (0..n)
+        .map(|_| {
+            let name = JSON_NAMES[rng.random_range(0..JSON_NAMES.len())];
+            let city = JSON_CITIES[rng.random_range(0..JSON_CITIES.len())];
+            let age = rng.random_range(18..80u32);
+            let tag1 = JSON_TAGS[rng.random_range(0..JSON_TAGS.len())];
+            let tag2 = JSON_TAGS[rng.random_range(0..JSON_TAGS.len())];
+            let id = rng.random_range(10000..99999u32);
+            format!(
+                r#"{{"id":{id},"name":"{name}","age":{age},"city":"{city}","tags":["{tag1}","{tag2}"],"active":true}}"#
+            )
+        })
+        .collect()
+}
+
+pub fn make_fsst_json_strings(n: usize) -> FSSTArray {
+    let jsons = generate_json_strings(n);
+    let varbin = VarBinArray::from_iter(
+        jsons.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// File paths generator (Unix-style paths with various depths)
+// ---------------------------------------------------------------------------
+
+const PATH_ROOTS: &[&str] = &[
+    "/home/user",
+    "/var/log",
+    "/etc",
+    "/usr/local/bin",
+    "/opt/app",
+    "/tmp",
+    "/srv/www",
+    "/data/warehouse",
+];
+const PATH_DIRS: &[&str] = &[
+    "src",
+    "build",
+    "dist",
+    "node_modules",
+    "target/release",
+    "config",
+    ".cache",
+    "logs/2024",
+    "backups/daily",
+    "migrations",
+];
+const PATH_FILES: &[&str] = &[
+    "main.rs",
+    "index.ts",
+    "config.yaml",
+    "Dockerfile",
+    "schema.sql",
+    "app.log",
+    "data.parquet",
+    "model.onnx",
+    "README.md",
+    "package.json",
+];
+
+pub fn generate_file_paths(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(321);
+    (0..n)
+        .map(|_| {
+            let root = PATH_ROOTS[rng.random_range(0..PATH_ROOTS.len())];
+            let dir = PATH_DIRS[rng.random_range(0..PATH_DIRS.len())];
+            let file = PATH_FILES[rng.random_range(0..PATH_FILES.len())];
+            let depth = rng.random_range(0..3u32);
+            let mut path = format!("{root}/{dir}");
+            for _ in 0..depth {
+                let subdir = PATH_DIRS[rng.random_range(0..PATH_DIRS.len())];
+                path.push('/');
+                path.push_str(subdir);
+            }
+            path.push('/');
+            path.push_str(file);
+            path
+        })
+        .collect()
+}
+
+pub fn make_fsst_file_paths(n: usize) -> FSSTArray {
+    let paths = generate_file_paths(n);
+    let varbin = VarBinArray::from_iter(
+        paths.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// Email addresses generator
+// ---------------------------------------------------------------------------
+
+const EMAIL_USERS: &[&str] = &[
+    "john.doe",
+    "jane.smith",
+    "admin",
+    "support",
+    "no-reply",
+    "sales.team",
+    "dev+test",
+    "marketing",
+    "info",
+    "contact.us",
+];
+const EMAIL_DOMAINS: &[&str] = &[
+    "gmail.com",
+    "yahoo.com",
+    "outlook.com",
+    "company.io",
+    "example.org",
+    "mail.ru",
+    "protonmail.com",
+    "fastmail.com",
+    "icloud.com",
+    "hey.com",
+];
+
+pub fn generate_emails(n: usize) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(654);
+    (0..n)
+        .map(|_| {
+            let user = EMAIL_USERS[rng.random_range(0..EMAIL_USERS.len())];
+            let domain = EMAIL_DOMAINS[rng.random_range(0..EMAIL_DOMAINS.len())];
+            let suffix = rng.random_range(0..1000u32);
+            format!("{user}{suffix}@{domain}")
+        })
+        .collect()
+}
+
+pub fn make_fsst_emails(n: usize) -> FSSTArray {
+    let emails = generate_emails(n);
+    let varbin = VarBinArray::from_iter(
+        emails.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
+
+// ---------------------------------------------------------------------------
+// Rare match strings generator
+// ---------------------------------------------------------------------------
+
+pub const RARE_NEEDLE: &[u8] = b"xyzzy";
+
+pub fn generate_rare_match_strings(n: usize, match_rate: f64) -> Vec<String> {
+    let mut rng = StdRng::seed_from_u64(999);
+    let charset: &[u8] = b"abcdefghijklmnopqrstuvwABCDEFGHIJKLMNOPQRSTUVW0123456789-_.:/";
+    (0..n)
+        .map(|_| {
+            let len = rng.random_range(30..60);
+            let mut s: String = (0..len)
+                .map(|_| charset[rng.random_range(0..charset.len())] as char)
+                .collect();
+            if rng.random_bool(match_rate) {
+                let pos = rng.random_range(0..s.len().saturating_sub(RARE_NEEDLE.len()) + 1);
+                s.replace_range(
+                    pos..pos + RARE_NEEDLE.len().min(s.len() - pos),
+                    std::str::from_utf8(RARE_NEEDLE).unwrap(),
+                );
+            }
+            s
+        })
+        .collect()
+}
+
+pub fn make_fsst_rare_match(n: usize) -> FSSTArray {
+    let strings = generate_rare_match_strings(n, 0.00001);
+    let varbin = VarBinArray::from_iter(
+        strings.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+    let compressor = fsst_train_compressor(&varbin);
+    let len = varbin.len();
+    let dtype = varbin.dtype().clone();
+    fsst_compress(varbin, len, &dtype, &compressor)
+}
diff --git a/encodings/fsst/src/tests.rs b/encodings/fsst/src/tests.rs
index c9a9a524652..fb45ed31629 100644
--- a/encodings/fsst/src/tests.rs
+++ b/encodings/fsst/src/tests.rs
@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
-use vortex_array::arrays::builder::VarBinBuilder;
+use vortex_array::arrays::varbin::builder::VarBinBuilder;
 use vortex_array::assert_arrays_eq;
 use vortex_array::assert_nth_scalar;
 use vortex_array::dtype::DType;
@@ -13,7 +12,7 @@ use vortex_array::dtype::Nullability;
 use vortex_buffer::buffer;
 use vortex_mask::Mask;
 
-use crate::FSSTVTable;
+use crate::FSST;
 use crate::fsst_compress;
 use crate::fsst_train_compressor;
 
@@ -28,7 +27,9 @@ pub(crate) fn build_fsst_array() -> ArrayRef {
     let input_array = input_array.finish(DType::Utf8(Nullability::NonNullable));
 
     let compressor = fsst_train_compressor(&input_array);
-    fsst_compress(input_array, &compressor).into_array()
+    let len = input_array.len();
+    let dtype = input_array.dtype().clone();
+    fsst_compress(input_array, len, &dtype, &compressor).into_array()
 }
 
 #[test]
@@ -53,7 +54,7 @@ fn test_fsst_array_ops() {
 
     // test slice
     let fsst_sliced = fsst_array.slice(1..3).unwrap();
-    assert!(fsst_sliced.is::<FSSTVTable>());
+    assert!(fsst_sliced.is::<FSST>());
     assert_eq!(fsst_sliced.len(), 2);
     assert_nth_scalar!(
         fsst_sliced,
@@ -96,5 +97,5 @@ fn test_fsst_array_ops() {
     // test to_canonical
     let canonical_array = fsst_array.to_varbinview().into_array();
 
-    assert_arrays_eq!(fsst_array.to_array(), canonical_array);
+    assert_arrays_eq!(fsst_array, canonical_array);
 }
diff --git a/encodings/parquet-variant/Cargo.toml b/encodings/parquet-variant/Cargo.toml
new file mode 100644
index 00000000000..cc554c85d10
--- /dev/null
+++ b/encodings/parquet-variant/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "vortex-parquet-variant"
+authors = { workspace = true }
+categories = { workspace = true }
+description = "Vortex Parquet Variant array"
+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
+
+[lints]
+workspace = true
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-schema = { workspace = true }
+chrono = { workspace = true }
+parquet-variant = { workspace = true }
+parquet-variant-compute = { workspace = true }
+prost = { workspace = true }
+vortex-array = { workspace = true }
+vortex-buffer = { workspace = true }
+vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
+vortex-proto = { workspace = true }
+vortex-session = { workspace = true }
+
+[dev-dependencies]
+rstest = { workspace = true }
+vortex-array = { workspace = true, features = ["_test-harness"] }
+
+[package.metadata.cargo-machete]
+ignored = ["getrandom_v03"]
diff --git a/encodings/parquet-variant/src/array.rs b/encodings/parquet-variant/src/array.rs
new file mode 100644
index 00000000000..ba13eb8e808
--- /dev/null
+++ b/encodings/parquet-variant/src/array.rs
@@ -0,0 +1,520 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use arrow_array::Array as ArrowArray;
+use arrow_array::ArrayRef as ArrowArrayRef;
+use arrow_schema::Field;
+use parquet_variant_compute::VariantArray as ArrowVariantArray;
+use vortex_array::Array;
+use vortex_array::ArrayParts;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::TypedArrayRef;
+use vortex_array::arrays::VariantArray;
+use vortex_array::arrow::ArrowArrayExecutor;
+use vortex_array::arrow::FromArrowArray;
+use vortex_array::arrow::to_arrow_null_buffer;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
+use vortex_buffer::BitBuffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+use crate::ParquetVariant;
+
+/// The validity bitmap indicating which elements are non-null.
+pub(crate) const VALIDITY_SLOT: usize = 0;
+/// The metadata array for the Parquet variant values.
+pub(crate) const METADATA_SLOT: usize = 1;
+/// The value array containing the Parquet variant data.
+pub(crate) const VALUE_SLOT: usize = 2;
+/// The typed value array for strongly-typed Parquet variant data.
+pub(crate) const TYPED_VALUE_SLOT: usize = 3;
+pub(crate) const NUM_SLOTS: usize = 4;
+pub(crate) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity", "metadata", "value", "typed_value"];
+
+/// Array storage for Arrow's canonical `arrow.parquet.variant` extension type.
+///
+/// `ParquetVariantArray` preserves semi-structured data stored as Parquet Variant values in a
+/// lossless form and supports both unshredded and shredded layouts. Its storage matches the
+/// canonical extension type contract:
+/// - `metadata` is always present and non-nullable.
+/// - `value` stores unshredded variant bytes when present
+/// - `typed_value` stores shredded data when present
+///
+/// At least one of `value` or `typed_value` must be present. `typed_value` may be a primitive,
+/// list, or struct, with nested shredded children following the same recursive rules as the
+/// Arrow canonical extension type docs.
+///
+/// # Nullability
+///
+/// There are three independent levels of nullability in this encoding:
+///
+/// 1. **Outer validity** (`validity`): controls which *rows* of the variant column are null.
+///    This drives the `DType::Variant(Nullable | NonNullable)` of the enclosing `VariantArray`.
+///
+/// 2. **Value child nullability**: the `value` child is `Binary` and may be nullable or
+///    non-nullable. In partially-shredded layouts some rows have their data in `typed_value`
+///    instead, so the corresponding `value` slot is null — making the child nullable.
+///
+/// 3. **Typed-value child nullability**: the `typed_value` child carries its own `DType`
+///    (which includes nullability).
+#[derive(Clone, Debug)]
+pub struct ParquetVariantData;
+
+impl Display for ParquetVariantData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+impl ParquetVariant {
+    pub fn try_new(
+        validity: Validity,
+        metadata: ArrayRef,
+        value: Option<ArrayRef>,
+        typed_value: Option<ArrayRef>,
+    ) -> VortexResult<Array<Self>> {
+        let len = metadata.len();
+        let dtype = DType::Variant(validity.nullability());
+        validate_parts(
+            &validity,
+            &metadata,
+            value.as_ref(),
+            typed_value.as_ref(),
+            &dtype,
+            len,
+        )?;
+        let slots = vec![
+            validity_to_child(&validity, len),
+            Some(metadata),
+            value,
+            typed_value,
+        ];
+        let data = ParquetVariantData;
+        Array::try_from_parts(ArrayParts::new(ParquetVariant, dtype, len, data).with_slots(slots))
+    }
+}
+
+impl ParquetVariantData {
+    pub(crate) fn validate_parts(
+        validity: &Validity,
+        metadata: &ArrayRef,
+        value: Option<&ArrayRef>,
+        typed_value: Option<&ArrayRef>,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            matches!(dtype, DType::Variant(_)),
+            "Expected Variant DType, found {dtype}"
+        );
+        vortex_ensure!(
+            value.is_some() || typed_value.is_some(),
+            "at least one of value or typed_value must be present"
+        );
+
+        vortex_ensure_eq!(
+            dtype.nullability(),
+            validity.nullability(),
+            "variant dtype nullability must match validity nullability"
+        );
+        vortex_ensure_eq!(
+            metadata.dtype(),
+            &DType::Binary(Nullability::NonNullable),
+            "metadata dtype must be non-nullable binary"
+        );
+        vortex_ensure_eq!(
+            metadata.len(),
+            len,
+            "metadata length must match array length"
+        );
+
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure_eq!(validity_len, len, "validity length must match array length");
+        }
+        if let Some(v) = value {
+            vortex_ensure!(
+                matches!(v.dtype(), DType::Binary(_)),
+                "value dtype must be binary, found {}",
+                v.dtype()
+            );
+            vortex_ensure_eq!(v.len(), len, "value length must match array length");
+        }
+        if let Some(tv) = typed_value {
+            vortex_ensure_eq!(tv.len(), len, "typed_value length must match array length");
+        }
+        Ok(())
+    }
+
+    /// Converts an Arrow `parquet_variant_compute::VariantArray` into a Vortex `ArrayRef`
+    /// wrapping `VariantArray(ParquetVariantArray(...))`.
+    pub fn from_arrow_variant(arrow_variant: &ArrowVariantArray) -> VortexResult<ArrayRef> {
+        let storage = arrow_variant.inner();
+        let value_nullable = storage
+            .fields()
+            .iter()
+            .find(|field| field.name() == "value")
+            .map(|field| field.is_nullable())
+            .unwrap_or(false);
+        let typed_value_nullable = storage
+            .fields()
+            .iter()
+            .find(|field| field.name() == "typed_value")
+            .map(|field| field.is_nullable())
+            .unwrap_or(false);
+        let validity = arrow_variant
+            .nulls()
+            .map(|nulls| {
+                if nulls.null_count() == nulls.len() {
+                    Validity::AllInvalid
+                } else {
+                    Validity::from(BitBuffer::from(nulls.inner().clone()))
+                }
+            })
+            .unwrap_or(Validity::NonNullable);
+        let metadata =
+            ArrayRef::from_arrow(arrow_variant.metadata_field() as &dyn ArrowArray, false)?;
+
+        let value = arrow_variant
+            .value_field()
+            .map(|v| ArrayRef::from_arrow(v as &dyn ArrowArray, value_nullable))
+            .transpose()?;
+
+        let typed_value = arrow_variant
+            .typed_value_field()
+            .map(|tv| ArrayRef::from_arrow(tv.as_ref(), typed_value_nullable))
+            .transpose()?;
+
+        let pv = ParquetVariant::try_new(validity, metadata, value, typed_value)?;
+        Ok(VariantArray::new(pv.into_array()).into_array())
+    }
+}
+
+pub(crate) fn validate_parts(
+    validity: &Validity,
+    metadata: &ArrayRef,
+    value: Option<&ArrayRef>,
+    typed_value: Option<&ArrayRef>,
+    dtype: &DType,
+    len: usize,
+) -> VortexResult<()> {
+    ParquetVariantData::validate_parts(validity, metadata, value, typed_value, dtype, len)
+}
+
+pub trait ParquetVariantArrayExt: TypedArrayRef<ParquetVariant> {
+    fn metadata_array(&self) -> &ArrayRef {
+        self.as_ref().slots()[METADATA_SLOT]
+            .as_ref()
+            .vortex_expect("ParquetVariantArray metadata slot")
+    }
+
+    fn validity(&self) -> Validity {
+        child_to_validity(
+            &self.as_ref().slots()[VALIDITY_SLOT],
+            self.as_ref().dtype().nullability(),
+        )
+    }
+
+    fn value_array(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[VALUE_SLOT].as_ref()
+    }
+
+    fn typed_value_array(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[TYPED_VALUE_SLOT].as_ref()
+    }
+
+    fn to_arrow(&self, ctx: &mut ExecutionCtx) -> VortexResult<ArrowVariantArray> {
+        let metadata = self.metadata_array();
+        let len = metadata.len();
+        let nulls = to_arrow_null_buffer(self.validity(), len, ctx)?;
+
+        let mut fields = Vec::with_capacity(3);
+        let mut arrays: Vec<ArrowArrayRef> = Vec::with_capacity(3);
+
+        let metadata_arrow = metadata.clone().execute_arrow(None, ctx)?;
+        fields.push(Arc::new(Field::new(
+            "metadata",
+            metadata_arrow.data_type().clone(),
+            false,
+        )));
+        arrays.push(metadata_arrow);
+
+        if let Some(value) = self.value_array() {
+            let value_arrow = value.clone().execute_arrow(None, ctx)?;
+            fields.push(Arc::new(Field::new(
+                "value",
+                value_arrow.data_type().clone(),
+                value.dtype().is_nullable(),
+            )));
+            arrays.push(value_arrow);
+        }
+
+        if let Some(typed_value) = self.typed_value_array() {
+            let tv_arrow = typed_value.clone().execute_arrow(None, ctx)?;
+            fields.push(Arc::new(Field::new(
+                "typed_value",
+                tv_arrow.data_type().clone(),
+                typed_value.dtype().is_nullable(),
+            )));
+            arrays.push(tv_arrow);
+        }
+
+        let struct_array = arrow_array::StructArray::try_new(fields.into(), arrays, nulls)?;
+        Ok(ArrowVariantArray::try_new(&struct_array)?)
+    }
+}
+
+impl<T: TypedArrayRef<ParquetVariant>> ParquetVariantArrayExt for T {}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::Array as _;
+    use arrow_array::ArrayRef as ArrowArrayRef;
+    use arrow_array::Int32Array;
+    use arrow_array::StructArray;
+    use arrow_array::builder::BinaryViewBuilder;
+    use arrow_buffer::NullBuffer;
+    use arrow_schema::DataType;
+    use arrow_schema::Field;
+    use arrow_schema::Fields;
+    use parquet_variant::Variant as PqVariant;
+    use parquet_variant_compute::VariantArray as ArrowVariantArray;
+    use parquet_variant_compute::VariantArrayBuilder;
+    use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::arrays::Variant;
+    use vortex_array::arrays::variant::VariantArrayExt;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::ParquetVariant;
+    use crate::ParquetVariantData;
+    use crate::array::ParquetVariantArrayExt;
+
+    fn assert_arrow_variant_storage_roundtrip(struct_array: StructArray) -> VortexResult<()> {
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+        let variant_view = vortex_arr.as_opt::<Variant>().unwrap();
+        let child = variant_view.child();
+        let inner = child.as_opt::<ParquetVariant>().unwrap();
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let roundtripped = inner.to_arrow(&mut ctx)?;
+        let roundtripped = roundtripped.inner();
+
+        assert_eq!(struct_array.len(), roundtripped.len());
+        assert_eq!(struct_array.column_names(), roundtripped.column_names());
+        assert_eq!(struct_array.nulls(), roundtripped.nulls());
+        assert_eq!(struct_array.fields().len(), roundtripped.fields().len());
+
+        for (expected, actual) in struct_array
+            .fields()
+            .iter()
+            .zip(roundtripped.fields().iter())
+        {
+            assert_eq!(expected.name(), actual.name());
+            assert_eq!(expected.data_type(), actual.data_type());
+            assert_eq!(expected.is_nullable(), actual.is_nullable());
+        }
+
+        for (expected, actual) in struct_array
+            .columns()
+            .iter()
+            .zip(roundtripped.columns().iter())
+        {
+            assert_eq!(expected.to_data(), actual.to_data());
+        }
+
+        Ok(())
+    }
+
+    fn binary_view_array<const N: usize>(values: [&[u8]; N]) -> ArrowArrayRef {
+        let mut builder = BinaryViewBuilder::new();
+        for value in values {
+            builder.append_value(value);
+        }
+        Arc::new(builder.finish())
+    }
+
+    #[test]
+    fn test_from_arrow_variant_basic() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(3);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+        let arrow_variant = builder.build();
+
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        assert_eq!(vortex_arr.len(), 3);
+        assert_eq!(
+            vortex_arr.dtype(),
+            &DType::Variant(Nullability::NonNullable)
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_arrow_variant_with_shredded_typed_value() -> VortexResult<()> {
+        let mut metadata_builder = BinaryViewBuilder::new();
+        let min_metadata = [1u8, 0];
+        for _ in 0..3 {
+            metadata_builder.append_value(min_metadata);
+        }
+        let metadata = metadata_builder.finish();
+
+        let typed_value: ArrowArrayRef = Arc::new(Int32Array::from(vec![10, 20, 30]));
+
+        let struct_fields: Fields = vec![
+            Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+            Arc::new(Field::new("typed_value", DataType::Int32, false)),
+        ]
+        .into();
+        let struct_array =
+            StructArray::try_new(struct_fields, vec![Arc::new(metadata), typed_value], None)
+                .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+        assert_eq!(vortex_arr.len(), 3);
+        assert_eq!(
+            vortex_arr.dtype(),
+            &DType::Variant(Nullability::NonNullable)
+        );
+
+        let variant_arr = vortex_arr.as_opt::<Variant>().unwrap();
+        let inner = variant_arr.child().as_opt::<ParquetVariant>().unwrap();
+        assert!(inner.typed_value_array().is_some());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_to_arrow_basic() -> VortexResult<()> {
+        let metadata = VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00"]).into_array();
+        let value = VarBinViewArray::from_iter_bin([b"\x10", b"\x11"]).into_array();
+        let pv_array = ParquetVariant::try_new(Validity::NonNullable, metadata, Some(value), None)?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let variant_arr = pv_array.to_arrow(&mut ctx)?;
+        let struct_arr = variant_arr.inner();
+
+        assert_eq!(struct_arr.num_columns(), 2);
+        assert_eq!(struct_arr.column_names(), &["metadata", "value"]);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_to_arrow_with_typed_value() -> VortexResult<()> {
+        let metadata = VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00"]).into_array();
+        let value = VarBinViewArray::from_iter_bin([b"\x10", b"\x11"]).into_array();
+        let typed_value = buffer![1i32, 2].into_array();
+        let pv_array = ParquetVariant::try_new(
+            Validity::NonNullable,
+            metadata,
+            Some(value),
+            Some(typed_value),
+        )?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let variant_arr = pv_array.to_arrow(&mut ctx)?;
+        let struct_arr = variant_arr.inner();
+
+        assert_eq!(struct_arr.num_columns(), 3);
+        assert_eq!(
+            struct_arr.column_names(),
+            &["metadata", "value", "typed_value"]
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_arrow_variant_roundtrip_unshredded_storage() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(3);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+
+        assert_arrow_variant_storage_roundtrip(builder.build().into_inner())
+    }
+
+    #[test]
+    fn test_arrow_variant_roundtrip_typed_value_only_storage() -> VortexResult<()> {
+        let metadata = binary_view_array([b"\x01\x00", b"\x01\x00", b"\x01\x00"]);
+        let typed_value: ArrowArrayRef = Arc::new(Int32Array::from(vec![10, 20, 30]));
+
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("typed_value", DataType::Int32, false)),
+            ]
+            .into(),
+            vec![metadata, typed_value],
+            None,
+        )
+        .unwrap();
+
+        assert_arrow_variant_storage_roundtrip(struct_array)
+    }
+
+    #[test]
+    fn test_arrow_variant_roundtrip_value_and_typed_value_storage() -> VortexResult<()> {
+        let metadata = binary_view_array([b"\x01\x00", b"\x01\x00"]);
+        let value = binary_view_array([b"\x10", b"\x11"]);
+        let typed_value: ArrowArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
+
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("value", DataType::BinaryView, true)),
+                Arc::new(Field::new("typed_value", DataType::Int32, false)),
+            ]
+            .into(),
+            vec![metadata, value, typed_value],
+            None,
+        )
+        .unwrap();
+
+        assert_arrow_variant_storage_roundtrip(struct_array)
+    }
+
+    #[test]
+    fn test_arrow_variant_roundtrip_with_outer_nulls() -> VortexResult<()> {
+        let metadata = binary_view_array([b"\x01\x00", b"\x01\x00", b"\x01\x00"]);
+        let value = binary_view_array([b"\x10", b"\x00", b"\x11"]);
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("value", DataType::BinaryView, true)),
+            ]
+            .into(),
+            vec![metadata, value],
+            Some(NullBuffer::from(vec![true, false, true])),
+        )
+        .unwrap();
+
+        assert_arrow_variant_storage_roundtrip(struct_array)
+    }
+}
diff --git a/encodings/parquet-variant/src/kernel.rs b/encodings/parquet-variant/src/kernel.rs
new file mode 100644
index 00000000000..d47d4e31267
--- /dev/null
+++ b/encodings/parquet-variant/src/kernel.rs
@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::Range;
+
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::dict::TakeExecute;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
+use vortex_array::arrays::filter::FilterKernel;
+use vortex_array::arrays::slice::SliceExecuteAdaptor;
+use vortex_array::arrays::slice::SliceKernel;
+use vortex_array::kernel::ParentKernelSet;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use crate::ParquetVariant;
+use crate::ParquetVariantArrayExt;
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<ParquetVariant> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FilterExecuteAdaptor(ParquetVariant)),
+    ParentKernelSet::lift(&SliceExecuteAdaptor(ParquetVariant)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(ParquetVariant)),
+]);
+
+impl SliceKernel for ParquetVariant {
+    fn slice(
+        array: ArrayView<'_, Self>,
+        range: Range<usize>,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let validity = array.validity()?.slice(range.clone())?;
+        let metadata = array.metadata_array().slice(range.clone())?;
+        let value = array
+            .value_array()
+            .map(|v| v.slice(range.clone()))
+            .transpose()?;
+        let typed_value = array
+            .typed_value_array()
+            .map(|tv| tv.slice(range))
+            .transpose()?;
+        Ok(Some(
+            ParquetVariant::try_new(validity, metadata, value, typed_value)?.into_array(),
+        ))
+    }
+}
+
+impl FilterKernel for ParquetVariant {
+    fn filter(
+        array: ArrayView<'_, Self>,
+        mask: &Mask,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let validity = array.validity()?.filter(mask)?;
+        let metadata = array.metadata_array().filter(mask.clone())?;
+        let value = array
+            .value_array()
+            .map(|v| v.filter(mask.clone()))
+            .transpose()?;
+        let typed_value = array
+            .typed_value_array()
+            .map(|tv| tv.filter(mask.clone()))
+            .transpose()?;
+        Ok(Some(
+            ParquetVariant::try_new(validity, metadata, value, typed_value)?.into_array(),
+        ))
+    }
+}
+
+impl TakeExecute for ParquetVariant {
+    fn take(
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let validity = array.validity()?.take(indices)?;
+        let metadata = array.metadata_array().take(indices.clone())?;
+        let value = array
+            .value_array()
+            .map(|v| v.take(indices.clone()))
+            .transpose()?;
+        let typed_value = array
+            .typed_value_array()
+            .map(|tv| tv.take(indices.clone()))
+            .transpose()?;
+        Ok(Some(
+            ParquetVariant::try_new(validity, metadata, value, typed_value)?.into_array(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::ArrayRef as ArrowArrayRef;
+    use arrow_array::StructArray;
+    use arrow_buffer::NullBuffer;
+    use arrow_schema::DataType;
+    use arrow_schema::Field;
+    use parquet_variant::Variant as PqVariant;
+    use parquet_variant_compute::VariantArray as ArrowVariantArray;
+    use parquet_variant_compute::VariantArrayBuilder;
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_error::VortexResult;
+    use vortex_mask::Mask;
+
+    use crate::ParquetVariantData;
+
+    fn make_unshredded_array() -> VortexResult<ArrayRef> {
+        let mut builder = VariantArrayBuilder::new(4);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+        builder.append_variant(PqVariant::from(99i64));
+        ParquetVariantData::from_arrow_variant(&builder.build())
+    }
+
+    fn make_nullable_array() -> VortexResult<ArrayRef> {
+        let mut builder = VariantArrayBuilder::new(4);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+        builder.append_variant(PqVariant::from(99i64));
+        let inner = builder.build().into_inner();
+
+        let null_struct = StructArray::try_new(
+            inner.fields().clone(),
+            inner.columns().to_vec(),
+            Some(NullBuffer::from(vec![true, false, true, false])),
+        )
+        .unwrap();
+        let arrow_variant = ArrowVariantArray::try_new(&null_struct).unwrap();
+        ParquetVariantData::from_arrow_variant(&arrow_variant)
+    }
+
+    #[test]
+    fn test_slice_basic() -> VortexResult<()> {
+        let arr = make_unshredded_array()?;
+        let sliced = arr.slice(1..3)?;
+
+        assert_eq!(sliced.len(), 2);
+        assert_eq!(sliced.scalar_at(0)?, arr.scalar_at(1)?);
+        assert_eq!(sliced.scalar_at(1)?, arr.scalar_at(2)?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_slice_preserves_validity() -> VortexResult<()> {
+        let arr = make_nullable_array()?;
+        let sliced = arr.slice(0..3)?;
+
+        assert_eq!(sliced.len(), 3);
+        assert!(!sliced.scalar_at(0)?.is_null());
+        assert!(sliced.scalar_at(1)?.is_null());
+        assert!(!sliced.scalar_at(2)?.is_null());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_basic() -> VortexResult<()> {
+        let arr = make_unshredded_array()?;
+        let mask = Mask::from_iter([true, false, true, false]);
+        let filtered = arr.filter(mask)?;
+
+        assert_eq!(filtered.len(), 2);
+        assert_eq!(filtered.scalar_at(0)?, arr.scalar_at(0)?);
+        assert_eq!(filtered.scalar_at(1)?, arr.scalar_at(2)?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_preserves_validity() -> VortexResult<()> {
+        let arr = make_nullable_array()?;
+        // Keep rows 0 (valid), 1 (null), 3 (null)
+        let mask = Mask::from_iter([true, true, false, true]);
+        let filtered = arr.filter(mask)?;
+
+        assert_eq!(filtered.len(), 3);
+        assert!(!filtered.scalar_at(0)?.is_null());
+        assert!(filtered.scalar_at(1)?.is_null());
+        assert!(filtered.scalar_at(2)?.is_null());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_basic() -> VortexResult<()> {
+        let arr = make_unshredded_array()?;
+        let indices = PrimitiveArray::from_iter([2u64, 0, 3]);
+        let taken = arr.take(indices.into_array())?;
+
+        assert_eq!(taken.len(), 3);
+        assert_eq!(taken.scalar_at(0)?, arr.scalar_at(2)?);
+        assert_eq!(taken.scalar_at(1)?, arr.scalar_at(0)?);
+        assert_eq!(taken.scalar_at(2)?, arr.scalar_at(3)?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_preserves_validity() -> VortexResult<()> {
+        let arr = make_nullable_array()?;
+        // Take: valid (0), null (1), null (3), valid (2)
+        let indices = PrimitiveArray::from_iter([0u64, 1, 3, 2]);
+        let taken = arr.take(indices.into_array())?;
+
+        assert_eq!(taken.len(), 4);
+        assert!(!taken.scalar_at(0)?.is_null());
+        assert!(taken.scalar_at(1)?.is_null());
+        assert!(taken.scalar_at(2)?.is_null());
+        assert!(!taken.scalar_at(3)?.is_null());
+
+        Ok(())
+    }
+
+    fn binary_view_array(values: &[&[u8]]) -> ArrowArrayRef {
+        let mut builder = arrow_array::builder::BinaryViewBuilder::new();
+        for value in values {
+            builder.append_value(*value);
+        }
+        Arc::new(builder.finish())
+    }
+
+    #[test]
+    fn test_slice_shredded_typed_value() -> VortexResult<()> {
+        let metadata = binary_view_array(&[b"\x01\x00", b"\x01\x00", b"\x01\x00"]);
+        let typed_value: ArrowArrayRef = Arc::new(arrow_array::Int32Array::from(vec![10, 20, 30]));
+
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("typed_value", DataType::Int32, false)),
+            ]
+            .into(),
+            vec![metadata, typed_value],
+            None,
+        )
+        .unwrap();
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        let arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        let sliced = arr.slice(1..3)?;
+        assert_eq!(sliced.len(), 2);
+        assert_eq!(sliced.scalar_at(0)?, arr.scalar_at(1)?);
+        assert_eq!(sliced.scalar_at(1)?, arr.scalar_at(2)?);
+
+        Ok(())
+    }
+}
diff --git a/encodings/parquet-variant/src/lib.rs b/encodings/parquet-variant/src/lib.rs
new file mode 100644
index 00000000000..9ecc9216daa
--- /dev/null
+++ b/encodings/parquet-variant/src/lib.rs
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Vortex support for Arrow's canonical `arrow.parquet.variant` extension type.
+//!
+//! This encoding provides a lossless representation of semi-structured data stored as
+//! [Parquet Variant values] inside Arrow columns. It also supports [shredded variant values],
+//! allowing systems to pass variant-encoded data around without special handling unless they
+//! need to inspect the encoded contents directly.
+//!
+//! The storage type is a `Struct` that follows the Arrow canonical extension contract:
+//! - `metadata` (required): a non-nullable binary child containing variant metadata
+//! - `value` (optional): a binary child containing unshredded variant bytes
+//! - `typed_value` (optional): a shredded child with a primitive, list, or struct layout
+//!
+//! At least one of `value` or `typed_value` must be present. Nested shredded values recurse
+//! through the same `value` and `typed_value` structure described by the canonical extension
+//! type documentation.
+//!
+//! See the Arrow canonical extension docs for the storage rules, and the Parquet format
+//! specification for the binary representation.
+//!
+//! [Parquet Variant values]: https://github.com/apache/parquet-format/blob/master/VariantEncoding.md
+//! [shredded variant values]: https://github.com/apache/parquet-format/blob/master/VariantShredding.md
+//! [Arrow canonical extension type]: https://arrow.apache.org/docs/format/CanonicalExtensions.html#parquet-variant
+
+mod array;
+mod kernel;
+mod operations;
+mod validity;
+mod vtable;
+
+pub use array::ParquetVariantArrayExt;
+pub use array::ParquetVariantData;
+pub use vtable::ParquetVariant;
+pub use vtable::ParquetVariantArray;
diff --git a/encodings/parquet-variant/src/operations.rs b/encodings/parquet-variant/src/operations.rs
new file mode 100644
index 00000000000..2efad44ae6e
--- /dev/null
+++ b/encodings/parquet-variant/src/operations.rs
@@ -0,0 +1,707 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use chrono::Timelike;
+use parquet_variant::Variant as PqVariant;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::DecimalDType;
+use vortex_array::dtype::FieldName;
+use vortex_array::dtype::FieldNames;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::StructFields;
+use vortex_array::extension::datetime::Date;
+use vortex_array::extension::datetime::Time;
+use vortex_array::extension::datetime::TimeUnit;
+use vortex_array::extension::datetime::Timestamp;
+use vortex_array::scalar::PValue;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar::ScalarValue;
+use vortex_array::vtable::OperationsVTable;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::ParquetVariantArrayExt;
+use crate::vtable::ParquetVariant;
+
+impl OperationsVTable<ParquetVariant> for ParquetVariant {
+    /// Resolves a single variant value according to the Parquet Variant shredding spec:
+    ///
+    /// | value    | typed_value | Meaning                                              |
+    /// |----------|-------------|------------------------------------------------------|
+    /// | NULL     | NULL        | Missing (only valid for shredded object fields)       |
+    /// | non-NULL | NULL        | Un-shredded: decode from metadata + value bytes       |
+    /// | NULL     | non-NULL    | Perfectly shredded: use typed_value directly           |
+    /// | non-NULL | non-NULL    | Partially shredded object (typed_value takes priority) |
+    fn scalar_at(
+        array: ArrayView<'_, ParquetVariant>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        if array.validity()?.is_null(index)? {
+            return Ok(Scalar::null(DType::Variant(Nullability::Nullable)));
+        }
+
+        let metadata = array
+            .metadata_array()
+            .scalar_at(index)?
+            .as_binary()
+            .value()
+            .cloned()
+            .vortex_expect("non-null metadata row must have binary value");
+        let inner = scalar_from_variant_storage(
+            metadata.as_ref(),
+            array.value_array(),
+            array.typed_value_array(),
+            index,
+        )?;
+
+        Scalar::try_new(
+            array.dtype().clone(),
+            Some(ScalarValue::Variant(Box::new(inner))),
+        )
+    }
+}
+
+fn scalar_from_variant_storage(
+    metadata: &[u8],
+    value: Option<&ArrayRef>,
+    typed_value: Option<&ArrayRef>,
+    index: usize,
+) -> VortexResult<Scalar> {
+    if let Some(typed_value) = typed_value
+        && typed_value.is_valid(index)?
+    {
+        return scalar_from_typed_value_array(metadata, value, typed_value, index);
+    }
+
+    if let Some(value) = value
+        && value.is_valid(index)?
+    {
+        return scalar_from_unshredded_value(metadata, &value.scalar_at(index)?);
+    }
+
+    Ok(Scalar::null(DType::Null))
+}
+
+fn scalar_from_typed_value_array(
+    metadata: &[u8],
+    value: Option<&ArrayRef>,
+    typed_value: &ArrayRef,
+    index: usize,
+) -> VortexResult<Scalar> {
+    let value_scalar = match value {
+        Some(value) if value.is_valid(index)? => Some(value.scalar_at(index)?),
+        _ => None,
+    };
+    scalar_from_typed_value_scalar(metadata, value_scalar, typed_value.scalar_at(index)?)
+}
+
+fn scalar_from_typed_value_scalar(
+    metadata: &[u8],
+    value: Option<Scalar>,
+    typed_value: Scalar,
+) -> VortexResult<Scalar> {
+    match typed_value.dtype() {
+        DType::List(..) => {
+            let list = typed_value.as_list();
+            let children = list
+                .elements()
+                .unwrap_or_default()
+                .into_iter()
+                .map(|element| {
+                    let nested = scalar_from_shredded_field_scalar(metadata, element)?;
+                    Ok(Scalar::variant(nested))
+                })
+                .collect::<VortexResult<Vec<_>>>()?;
+            Ok(Scalar::list(
+                DType::Variant(Nullability::NonNullable),
+                children,
+                Nullability::NonNullable,
+            ))
+        }
+        DType::Struct(..) => scalar_from_shredded_object_scalar(metadata, value, typed_value),
+        _ => Ok(typed_value),
+    }
+}
+
+fn scalar_from_shredded_field_scalar(
+    metadata: &[u8],
+    field_scalar: Scalar,
+) -> VortexResult<Scalar> {
+    if field_scalar.is_null() {
+        return Ok(Scalar::null(DType::Null));
+    }
+
+    let field = field_scalar.as_struct();
+    scalar_from_field_scalars(metadata, field.field("value"), field.field("typed_value"))
+}
+
+fn scalar_from_field_scalars(
+    metadata: &[u8],
+    value: Option<Scalar>,
+    typed_value: Option<Scalar>,
+) -> VortexResult<Scalar> {
+    if let Some(typed_value) = typed_value
+        && !typed_value.is_null()
+    {
+        return scalar_from_typed_value_scalar(metadata, value, typed_value);
+    }
+
+    if let Some(value) = value
+        && !value.is_null()
+    {
+        return scalar_from_unshredded_value(metadata, &value);
+    }
+
+    Ok(Scalar::null(DType::Null))
+}
+
+fn scalar_from_shredded_object_scalar(
+    metadata: &[u8],
+    value: Option<Scalar>,
+    typed_value: Scalar,
+) -> VortexResult<Scalar> {
+    let typed_value = typed_value.as_struct();
+    let mut names = Vec::new();
+    let mut dtypes = Vec::new();
+    let mut field_values = Vec::new();
+
+    for name in typed_value.names().iter() {
+        let nested = scalar_from_shredded_field_scalar(
+            metadata,
+            typed_value
+                .field(name.as_ref())
+                .vortex_expect("typed struct field must exist"),
+        )?;
+        names.push(FieldName::from(name.as_ref()));
+        dtypes.push(DType::Variant(Nullability::NonNullable));
+        field_values.push(Scalar::variant(nested).into_value());
+    }
+
+    if let Some(value) = value
+        && !value.is_null()
+    {
+        let unshredded = scalar_from_unshredded_value(metadata, &value)?;
+        if !unshredded.is_null() {
+            let unshredded = unshredded.as_struct();
+            for name in unshredded.names().iter() {
+                if typed_value.field(name.as_ref()).is_some() {
+                    continue;
+                }
+                let field = unshredded
+                    .field(name.as_ref())
+                    .vortex_expect("unshredded struct field must exist");
+                names.push(FieldName::from(name.as_ref()));
+                dtypes.push(DType::Variant(Nullability::NonNullable));
+                field_values.push(field.into_value());
+            }
+        }
+    }
+
+    let fields = StructFields::new(FieldNames::from(names), dtypes);
+    Scalar::try_new(
+        DType::Struct(fields, Nullability::NonNullable),
+        Some(ScalarValue::List(field_values)),
+    )
+}
+
+fn scalar_from_unshredded_value(metadata: &[u8], value: &Scalar) -> VortexResult<Scalar> {
+    let value = value
+        .as_binary()
+        .value()
+        .cloned()
+        .vortex_expect("non-null value row must have binary value");
+    parquet_variant_to_scalar(PqVariant::try_new(metadata, value.as_ref())?)
+}
+
+fn parquet_variant_to_scalar(variant: PqVariant<'_, '_>) -> VortexResult<Scalar> {
+    let nn = Nullability::NonNullable;
+
+    Ok(match variant {
+        PqVariant::Null => Scalar::null(DType::Null),
+        PqVariant::Int8(v) => Scalar::primitive(v, nn),
+        PqVariant::Int16(v) => Scalar::primitive(v, nn),
+        PqVariant::Int32(v) => Scalar::primitive(v, nn),
+        PqVariant::Int64(v) => Scalar::primitive(v, nn),
+        PqVariant::Float(v) => Scalar::primitive(v, nn),
+        PqVariant::Double(v) => Scalar::primitive(v, nn),
+        PqVariant::BooleanTrue => Scalar::bool(true, nn),
+        PqVariant::BooleanFalse => Scalar::bool(false, nn),
+        PqVariant::Decimal4(v) => Scalar::decimal(
+            v.integer().into(),
+            DecimalDType::new(9, v.scale() as i8),
+            nn,
+        ),
+        PqVariant::Decimal8(v) => Scalar::decimal(
+            v.integer().into(),
+            DecimalDType::new(18, v.scale() as i8),
+            nn,
+        ),
+        PqVariant::Decimal16(v) => Scalar::decimal(
+            v.integer().into(),
+            DecimalDType::new(38, v.scale() as i8),
+            nn,
+        ),
+        PqVariant::Binary(v) => Scalar::binary(v.to_vec(), nn),
+        PqVariant::String(v) => Scalar::utf8(v, nn),
+        PqVariant::ShortString(v) => Scalar::utf8(v.as_str(), nn),
+        PqVariant::Date(v) => {
+            let dtype = DType::Extension(Date::new(TimeUnit::Days, nn).erased());
+            Scalar::try_new(
+                dtype,
+                Some(ScalarValue::Primitive(PValue::I32(v.to_epoch_days()))),
+            )?
+        }
+        PqVariant::TimestampMicros(v) => {
+            let dtype = DType::Extension(
+                Timestamp::new_with_tz(TimeUnit::Microseconds, Some(Arc::from("UTC")), nn).erased(),
+            );
+            Scalar::try_new(
+                dtype,
+                Some(ScalarValue::Primitive(PValue::I64(v.timestamp_micros()))),
+            )?
+        }
+        PqVariant::TimestampNtzMicros(v) => {
+            let dtype = DType::Extension(Timestamp::new(TimeUnit::Microseconds, nn).erased());
+            Scalar::try_new(
+                dtype,
+                Some(ScalarValue::Primitive(PValue::I64(
+                    v.and_utc().timestamp_micros(),
+                ))),
+            )?
+        }
+        PqVariant::TimestampNanos(v) => {
+            let dtype = DType::Extension(
+                Timestamp::new_with_tz(TimeUnit::Nanoseconds, Some(Arc::from("UTC")), nn).erased(),
+            );
+            let nanos = v
+                .timestamp_nanos_opt()
+                .ok_or_else(|| vortex_err!("Timestamp nanoseconds value out of i64 range"))?;
+            Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(nanos))))?
+        }
+        PqVariant::TimestampNtzNanos(v) => {
+            let dtype = DType::Extension(Timestamp::new(TimeUnit::Nanoseconds, nn).erased());
+            let nanos = v
+                .and_utc()
+                .timestamp_nanos_opt()
+                .ok_or_else(|| vortex_err!("Timestamp nanoseconds value out of i64 range"))?;
+            Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(nanos))))?
+        }
+        PqVariant::Time(v) => {
+            // Parquet Variant spec stores Time as microseconds since midnight.
+            let micros =
+                v.num_seconds_from_midnight() as i64 * 1_000_000 + v.nanosecond() as i64 / 1_000;
+            let dtype = DType::Extension(Time::new(TimeUnit::Microseconds, nn).erased());
+            Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(micros))))?
+        }
+        // TODO: Should this depend on the new UUID-extension type? leaving this for now.
+        PqVariant::Uuid(v) => Scalar::utf8(v.to_string(), nn),
+        PqVariant::List(values) => {
+            let children = values
+                .iter()
+                .map(|v| parquet_variant_to_scalar(v).map(Scalar::variant))
+                .collect::<VortexResult<Vec<_>>>()?;
+            Scalar::list(DType::Variant(nn), children, nn)
+        }
+        PqVariant::Object(values) => {
+            let mut names = Vec::new();
+            let mut dtypes = Vec::new();
+            let mut field_values = Vec::new();
+            for (name, value) in values.iter() {
+                names.push(FieldName::from(name));
+                dtypes.push(DType::Variant(nn));
+                field_values.push(Some(ScalarValue::Variant(Box::new(
+                    parquet_variant_to_scalar(value)?,
+                ))));
+            }
+            let fields = StructFields::new(FieldNames::from(names), dtypes);
+            Scalar::try_new(
+                DType::Struct(fields, nn),
+                Some(ScalarValue::List(field_values)),
+            )?
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::Array as _;
+    use arrow_array::ArrayRef as ArrowArrayRef;
+    use arrow_array::Int32Array;
+    use arrow_array::ListArray;
+    use arrow_array::StructArray;
+    use arrow_array::builder::BinaryViewBuilder;
+    use arrow_buffer::NullBuffer;
+    use arrow_buffer::OffsetBuffer;
+    use arrow_schema::DataType;
+    use arrow_schema::Field;
+    use parquet_variant::Variant as PqVariant;
+    use parquet_variant::VariantBuilder;
+    use parquet_variant_compute::VariantArray as ArrowVariantArray;
+    use parquet_variant_compute::VariantArrayBuilder;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::Variant;
+    use vortex_array::arrays::variant::VariantArrayExt;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::scalar::Scalar;
+    use vortex_array::scalar::ScalarValue;
+    use vortex_error::VortexResult;
+
+    use crate::ParquetVariant;
+    use crate::ParquetVariantArrayExt;
+    use crate::ParquetVariantData;
+    use crate::operations::parquet_variant_to_scalar;
+
+    fn binary_view_array(values: &[&[u8]]) -> ArrowArrayRef {
+        let mut builder = BinaryViewBuilder::new();
+        for value in values {
+            builder.append_value(*value);
+        }
+        Arc::new(builder.finish())
+    }
+
+    fn assert_scalar_at_matches_arrow_try_value(
+        arrow_variant: &ArrowVariantArray,
+        rows: impl IntoIterator<Item = usize>,
+    ) -> VortexResult<()> {
+        let vortex_arr = ParquetVariantData::from_arrow_variant(arrow_variant)?;
+
+        for index in rows {
+            let expected_inner =
+                parquet_variant_to_scalar(arrow_variant.try_value(index).unwrap())?;
+            let expected = Scalar::try_new(
+                vortex_arr.dtype().clone(),
+                Some(ScalarValue::Variant(Box::new(expected_inner))),
+            )
+            .unwrap();
+            assert_eq!(vortex_arr.scalar_at(index)?, expected);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_arrow_variant_nullable_validity() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(3);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+        let inner = builder.build().into_inner();
+
+        let null_struct = StructArray::try_new(
+            inner.fields().clone(),
+            inner.columns().to_vec(),
+            Some(NullBuffer::from(vec![true, false, true])),
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&null_struct).unwrap();
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        assert_eq!(vortex_arr.dtype(), &DType::Variant(Nullability::Nullable));
+
+        let variant = vortex_arr.as_opt::<Variant>().unwrap();
+        assert!(variant.dtype().is_nullable());
+
+        assert!(vortex_arr.scalar_at(1)?.is_null());
+        assert!(!vortex_arr.scalar_at(0)?.is_null());
+        assert!(!vortex_arr.scalar_at(2)?.is_null());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_arrow_variant_all_nulls() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(2);
+        builder.append_variant(PqVariant::from(1i32));
+        builder.append_variant(PqVariant::from(2i32));
+        let inner = builder.build().into_inner();
+
+        let null_struct = StructArray::try_new(
+            inner.fields().clone(),
+            inner.columns().to_vec(),
+            Some(NullBuffer::from(vec![false, false])),
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&null_struct).unwrap();
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        assert_eq!(vortex_arr.dtype(), &DType::Variant(Nullability::Nullable));
+        assert!(vortex_arr.scalar_at(0)?.is_null());
+        assert!(vortex_arr.scalar_at(1)?.is_null());
+
+        let variant_view = vortex_arr.as_opt::<Variant>().unwrap();
+        let child = variant_view.child();
+        let inner_pv = child.as_opt::<ParquetVariant>().unwrap();
+        let mut ctx = vortex_array::LEGACY_SESSION.create_execution_ctx();
+        let roundtripped = inner_pv.to_arrow(&mut ctx)?;
+        assert_eq!(roundtripped.inner().null_count(), 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_arrow_variant_non_nullable() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(2);
+        builder.append_variant(PqVariant::from(1i32));
+        builder.append_variant(PqVariant::from(2i32));
+        let arrow_variant = builder.build();
+
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        assert_eq!(
+            vortex_arr.dtype(),
+            &DType::Variant(Nullability::NonNullable)
+        );
+        assert!(!vortex_arr.scalar_at(0)?.is_null());
+        assert!(!vortex_arr.scalar_at(1)?.is_null());
+        assert_scalar_at_matches_arrow_try_value(&arrow_variant, [0, 1])?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_scalar_at_matches_arrow_try_value_unshredded_mixed_values() -> VortexResult<()> {
+        let mut builder = VariantArrayBuilder::new(3);
+        builder.append_variant(PqVariant::from(42i32));
+        builder.append_variant(PqVariant::from("hello"));
+        builder.append_variant(PqVariant::from(true));
+        let arrow_variant = builder.build();
+
+        assert_scalar_at_matches_arrow_try_value(&arrow_variant, [0, 1, 2])
+    }
+
+    #[test]
+    fn test_scalar_at_matches_arrow_try_value_shredded_primitive() -> VortexResult<()> {
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("typed_value", DataType::Int32, false)),
+            ]
+            .into(),
+            vec![
+                binary_view_array(&[b"\x01\x00", b"\x01\x00", b"\x01\x00"]),
+                Arc::new(Int32Array::from(vec![10, 20, 30])),
+            ],
+            None,
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        assert_scalar_at_matches_arrow_try_value(&arrow_variant, [0, 1, 2])
+    }
+
+    #[test]
+    fn test_scalar_at_matches_arrow_try_value_imperfectly_shredded_primitive() -> VortexResult<()> {
+        let (metadata0, value0) = VariantBuilder::new().with_value("fallback-0").finish();
+        let (metadata1, _value1) = VariantBuilder::new().with_value(20i32).finish();
+        let (metadata2, value2) = VariantBuilder::new().with_value("fallback-2").finish();
+
+        let metadata = binary_view_array(&[
+            metadata0.as_slice(),
+            metadata1.as_slice(),
+            metadata2.as_slice(),
+        ]);
+        let mut value_builder = BinaryViewBuilder::new();
+        value_builder.append_value(value0.as_slice());
+        value_builder.append_null();
+        value_builder.append_value(value2.as_slice());
+        let value = Arc::new(value_builder.finish());
+
+        let typed_value = Arc::new(Int32Array::from(vec![None, Some(20), None]));
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("value", DataType::BinaryView, true)),
+                Arc::new(Field::new("typed_value", DataType::Int32, true)),
+            ]
+            .into(),
+            vec![metadata, value, typed_value],
+            None,
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        assert_scalar_at_matches_arrow_try_value(&arrow_variant, [0, 1, 2])
+    }
+
+    #[test]
+    fn test_scalar_at_recursive_shredded_list() -> VortexResult<()> {
+        // Spec basis: for arrays, "value must be null" when the value is an array, and array
+        // elements cannot be missing.
+        // Source: https://github.com/apache/parquet-format/blob/master/VariantShredding.md
+        let element_struct = StructArray::try_new(
+            vec![Arc::new(Field::new("typed_value", DataType::Int32, false))].into(),
+            vec![Arc::new(Int32Array::from(vec![10, 20, 30]))],
+            None,
+        )
+        .unwrap();
+
+        let typed_value: ArrowArrayRef = Arc::new(
+            ListArray::try_new(
+                Arc::new(Field::new(
+                    "element",
+                    element_struct.data_type().clone(),
+                    false,
+                )),
+                OffsetBuffer::from_lengths([2, 1]),
+                Arc::new(element_struct),
+                None,
+            )
+            .unwrap(),
+        );
+
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new(
+                    "typed_value",
+                    typed_value.data_type().clone(),
+                    false,
+                )),
+            ]
+            .into(),
+            vec![binary_view_array(&[b"\x01\x00", b"\x01\x00"]), typed_value],
+            None,
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+
+        let row0 = vortex_arr.scalar_at(0)?;
+        let row0 = row0.as_variant().value().unwrap().as_list();
+        assert_eq!(row0.len(), 2);
+        assert_eq!(
+            row0.element(0)
+                .unwrap()
+                .as_variant()
+                .value()
+                .unwrap()
+                .as_primitive()
+                .typed_value::<i32>(),
+            Some(10)
+        );
+        assert_eq!(
+            row0.element(1)
+                .unwrap()
+                .as_variant()
+                .value()
+                .unwrap()
+                .as_primitive()
+                .typed_value::<i32>(),
+            Some(20)
+        );
+
+        let row1 = vortex_arr.scalar_at(1)?;
+        let row1 = row1.as_variant().value().unwrap().as_list();
+        assert_eq!(row1.len(), 1);
+        assert_eq!(
+            row1.element(0)
+                .unwrap()
+                .as_variant()
+                .value()
+                .unwrap()
+                .as_primitive()
+                .typed_value::<i32>(),
+            Some(30)
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_scalar_at_partially_shredded_object_merges_fields() -> VortexResult<()> {
+        // Spec basis: non-null `value` + non-null `typed_value` means a "partially shredded
+        // object", so reconstruction must merge the shredded object with the fallback object.
+        // Source: https://github.com/apache/parquet-format/blob/master/VariantShredding.md
+        let mut builder = VariantBuilder::new();
+        builder
+            .new_object()
+            .with_field("a", 1i32)
+            .with_field("b", "leftover")
+            .finish();
+        let (metadata, value) = builder.finish();
+
+        let shredded_a = StructArray::try_new(
+            vec![Arc::new(Field::new("typed_value", DataType::Int32, false))].into(),
+            vec![Arc::new(Int32Array::from(vec![7]))],
+            None,
+        )
+        .unwrap();
+        let typed_value: ArrowArrayRef = Arc::new(
+            StructArray::try_new(
+                vec![Arc::new(Field::new(
+                    "a",
+                    shredded_a.data_type().clone(),
+                    false,
+                ))]
+                .into(),
+                vec![Arc::new(shredded_a)],
+                None,
+            )
+            .unwrap(),
+        );
+
+        let struct_array = StructArray::try_new(
+            vec![
+                Arc::new(Field::new("metadata", DataType::BinaryView, false)),
+                Arc::new(Field::new("value", DataType::BinaryView, true)),
+                Arc::new(Field::new(
+                    "typed_value",
+                    typed_value.data_type().clone(),
+                    false,
+                )),
+            ]
+            .into(),
+            vec![
+                binary_view_array(&[metadata.as_slice()]),
+                binary_view_array(&[value.as_slice()]),
+                typed_value,
+            ],
+            None,
+        )
+        .unwrap();
+
+        let arrow_variant = ArrowVariantArray::try_new(&struct_array).unwrap();
+        let vortex_arr = ParquetVariantData::from_arrow_variant(&arrow_variant)?;
+        let object = vortex_arr.scalar_at(0)?;
+        let object = object.as_variant().value().unwrap().as_struct();
+
+        assert_eq!(
+            object
+                .field("a")
+                .unwrap()
+                .as_variant()
+                .value()
+                .unwrap()
+                .as_primitive()
+                .typed_value::<i32>(),
+            Some(7)
+        );
+        assert_eq!(
+            object
+                .field("b")
+                .unwrap()
+                .as_variant()
+                .value()
+                .unwrap()
+                .as_utf8()
+                .value()
+                .map(|value| value.as_str()),
+            Some("leftover")
+        );
+
+        Ok(())
+    }
+}
diff --git a/encodings/parquet-variant/src/validity.rs b/encodings/parquet-variant/src/validity.rs
new file mode 100644
index 00000000000..b28c7102e22
--- /dev/null
+++ b/encodings/parquet-variant/src/validity.rs
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayView;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::ValidityVTable;
+use vortex_error::VortexResult;
+
+use crate::ParquetVariantArrayExt;
+use crate::vtable::ParquetVariant;
+
+impl ValidityVTable<ParquetVariant> for ParquetVariant {
+    fn validity(array: ArrayView<'_, ParquetVariant>) -> VortexResult<Validity> {
+        Ok(ParquetVariantArrayExt::validity(&array))
+    }
+}
diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs
new file mode 100644
index 00000000000..efc501cdac6
--- /dev/null
+++ b/encodings/parquet-variant/src/vtable.rs
@@ -0,0 +1,365 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::hash::Hasher;
+
+use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
+use vortex_array::IntoArray;
+use vortex_array::Precision;
+use vortex_array::arrays::VariantArray;
+use vortex_array::buffer::BufferHandle;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::serde::ArrayChildren;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::VTable;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
+use vortex_proto::dtype as pb;
+use vortex_session::VortexSession;
+
+use crate::array::METADATA_SLOT;
+use crate::array::ParquetVariantArrayExt;
+use crate::array::ParquetVariantData;
+use crate::array::SLOT_NAMES;
+use crate::array::TYPED_VALUE_SLOT;
+use crate::array::VALIDITY_SLOT;
+use crate::array::VALUE_SLOT;
+use crate::array::validate_parts;
+use crate::kernel::PARENT_KERNELS;
+
+/// VTable for [`ParquetVariantArray`].
+#[derive(Debug, Clone)]
+pub struct ParquetVariant;
+
+impl ParquetVariant {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.parquet.variant");
+}
+
+#[derive(Clone, prost::Message)]
+struct ParquetVariantMetadataProto {
+    /// Whether the un-shredded `value` child is present.
+    #[prost(bool, tag = "1")]
+    pub has_value: bool,
+    /// DType of the shredded `typed_value`, if present.
+    #[prost(message, optional, tag = "2")]
+    pub typed_value_dtype: Option<pb::DType>,
+    /// Whether the `value` child is nullable.
+    #[prost(bool, tag = "3")]
+    pub value_nullable: bool,
+}
+
+/// A [`ParquetVariant`]-encoded Vortex array.
+pub type ParquetVariantArray = Array<ParquetVariant>;
+
+impl VTable for ParquetVariant {
+    type ArrayData = ParquetVariantData;
+    type OperationsVTable = Self;
+    type ValidityVTable = Self;
+
+    fn id(&self) -> ArrayId {
+        Self::ID
+    }
+
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let _ = data;
+        let validity = child_to_validity(&slots[VALIDITY_SLOT], dtype.nullability());
+        let metadata = slots[METADATA_SLOT]
+            .as_ref()
+            .ok_or_else(|| vortex_err!("ParquetVariantArray metadata slot"))?;
+        validate_parts(
+            &validity,
+            metadata,
+            slots[VALUE_SLOT].as_ref(),
+            slots[TYPED_VALUE_SLOT].as_ref(),
+            dtype,
+            len,
+        )
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ParquetVariantArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let typed_value_dtype = array
+            .typed_value_array()
+            .map(|tv| tv.dtype().try_into())
+            .transpose()?;
+        Ok(Some(
+            ParquetVariantMetadataProto {
+                has_value: array.value_array().is_some(),
+                typed_value_dtype,
+                value_nullable: array.value_array().is_some_and(|v| v.dtype().is_nullable()),
+            }
+            .encode_to_vec(),
+        ))
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_ensure!(
+            buffers.is_empty(),
+            "ParquetVariantArray expects 0 buffers, got {}",
+            buffers.len()
+        );
+
+        let proto = ParquetVariantMetadataProto::decode(metadata)?;
+        let typed_value_dtype = match proto.typed_value_dtype.as_ref() {
+            Some(dtype) => Some(DType::from_proto(dtype, session)?),
+            None => None,
+        };
+
+        vortex_ensure!(matches!(dtype, DType::Variant(_)), "Expected Variant DType");
+        let has_typed_value = typed_value_dtype.is_some();
+        vortex_ensure!(
+            proto.has_value || has_typed_value,
+            "At least one of value or typed_value must be present"
+        );
+
+        let expected_children = 1 + proto.has_value as usize + has_typed_value as usize;
+        vortex_ensure!(
+            children.len() == expected_children || children.len() == expected_children + 1,
+            "Expected {} or {} children, got {}",
+            expected_children,
+            expected_children + 1,
+            children.len()
+        );
+
+        let (validity, mut child_idx) = if children.len() == expected_children {
+            (Validity::from(dtype.nullability()), 0)
+        } else {
+            (Validity::Array(children.get(0, &Validity::DTYPE, len)?), 1)
+        };
+        let variant_metadata =
+            children.get(child_idx, &DType::Binary(Nullability::NonNullable), len)?;
+        child_idx += 1;
+
+        let value = if proto.has_value {
+            let v = children.get(child_idx, &DType::Binary(proto.value_nullable.into()), len)?;
+            child_idx += 1;
+            Some(v)
+        } else {
+            None
+        };
+
+        let typed_value = if has_typed_value {
+            // typed_value can be any type — primitive, list, struct, etc.
+            let dtype = typed_value_dtype
+                .ok_or_else(|| vortex_err!("typed_value_dtype missing for typed_value child"))?;
+            let tv = children.get(child_idx, &dtype, len)?;
+            Some(tv)
+        } else {
+            None
+        };
+
+        ParquetVariantData::validate_parts(
+            &validity,
+            &variant_metadata,
+            value.as_ref(),
+            typed_value.as_ref(),
+            dtype,
+            len,
+        )?;
+        let slots = vec![
+            validity_to_child(&validity, len),
+            Some(variant_metadata),
+            value,
+            typed_value,
+        ];
+        let data = ParquetVariantData;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+    }
+
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            VariantArray::new(array.as_ref().clone().into_array()).into_array(),
+        ))
+    }
+
+    fn execute_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
+    }
+}
+
+impl ArrayHash for ParquetVariantData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
+
+impl ArrayEq for ParquetVariantData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::ArrayContext;
+    use vortex_array::ArrayEq;
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::Precision;
+    use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::arrays::Variant;
+    use vortex_array::arrays::VariantArray;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::dtype::PType;
+    use vortex_array::serde::SerializeOptions;
+    use vortex_array::serde::SerializedArray;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::BitBuffer;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_buffer::buffer;
+    use vortex_session::VortexSession;
+    use vortex_session::registry::ReadContext;
+
+    use crate::ParquetVariant;
+    use crate::array::ParquetVariantArrayExt;
+    fn roundtrip(array: ArrayRef) -> ArrayRef {
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let session = VortexSession::empty().with::<vortex_array::session::ArraySession>();
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .serialize(&ctx, &session, &SerializeOptions::default())
+            .unwrap();
+
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+        let concat = concat.freeze();
+        session.arrays().register(ParquetVariant);
+        session.arrays().register(Variant);
+
+        let parts = SerializedArray::try_from(concat).unwrap();
+        parts
+            .decode(&dtype, len, &ReadContext::new(ctx.to_ids()), &session)
+            .unwrap()
+    }
+
+    #[test]
+    fn test_serde_roundtrip_typed_value_variant() {
+        let outer_metadata =
+            VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00", b"\x01\x00"]).into_array();
+
+        let inner_metadata =
+            VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00", b"\x01\x00"]).into_array();
+        let inner_value = VarBinViewArray::from_iter_bin([b"\x02", b"\x03", b"\x04"]).into_array();
+        let inner_pv = ParquetVariant::try_new(
+            Validity::NonNullable,
+            inner_metadata,
+            Some(inner_value),
+            None,
+        )
+        .unwrap();
+        let typed_value = VariantArray::new(inner_pv.into_array()).into_array();
+
+        let outer_pv = ParquetVariant::try_new(
+            Validity::NonNullable,
+            outer_metadata,
+            None,
+            Some(typed_value),
+        )
+        .unwrap();
+        let array = outer_pv.into_array();
+        let decoded = roundtrip(array.clone());
+
+        assert!(array.array_eq(&decoded, Precision::Value));
+        let decoded_pv = decoded.as_opt::<ParquetVariant>().unwrap();
+        let typed = decoded_pv.typed_value_array().unwrap();
+        assert_eq!(typed.dtype(), &DType::Variant(Nullability::NonNullable));
+    }
+
+    #[test]
+    fn test_serde_roundtrip_with_nullable_validity() {
+        let metadata =
+            VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00", b"\x01\x00"]).into_array();
+        let value = VarBinViewArray::from_iter_bin([b"\x10", b"\x11", b"\x12"]).into_array();
+        let validity = Validity::from(BitBuffer::from_iter([true, false, true]));
+
+        let pv = ParquetVariant::try_new(validity, metadata, Some(value), None).unwrap();
+        let array = pv.into_array();
+        let decoded = roundtrip(array.clone());
+
+        assert!(array.array_eq(&decoded, Precision::Value));
+        assert_eq!(decoded.dtype(), &DType::Variant(Nullability::Nullable));
+        let decoded_pv = decoded.as_opt::<ParquetVariant>().unwrap();
+        assert!(decoded_pv.value_array().is_some());
+        assert!(decoded_pv.typed_value_array().is_none());
+    }
+
+    #[test]
+    fn test_serde_roundtrip_typed_value_int32() {
+        let outer_metadata =
+            VarBinViewArray::from_iter_bin([b"\x01\x00", b"\x01\x00", b"\x01\x00"]).into_array();
+        let typed_value = buffer![10i32, 20, 30].into_array();
+
+        let outer_pv = ParquetVariant::try_new(
+            Validity::NonNullable,
+            outer_metadata,
+            None,
+            Some(typed_value),
+        )
+        .unwrap();
+        let array = outer_pv.into_array();
+        let decoded = roundtrip(array.clone());
+
+        assert!(array.array_eq(&decoded, Precision::Value));
+        let decoded_pv = decoded.as_opt::<ParquetVariant>().unwrap();
+        let typed = decoded_pv.typed_value_array().unwrap();
+        assert_eq!(
+            typed.dtype(),
+            &DType::Primitive(PType::I32, Nullability::NonNullable)
+        );
+    }
+}
diff --git a/encodings/pco/public-api.lock b/encodings/pco/public-api.lock
index 847303308e7..2cf1233c7c2 100644
--- a/encodings/pco/public-api.lock
+++ b/encodings/pco/public-api.lock
@@ -1,46 +1,64 @@
 pub mod vortex_pco
 
-pub struct vortex_pco::PcoArray
+pub struct vortex_pco::Pco
 
-impl vortex_pco::PcoArray
+impl vortex_pco::Pco
 
-pub fn vortex_pco::PcoArray::decompress(&self) -> vortex_error::VortexResult<vortex_array::arrays::primitive::array::PrimitiveArray>
+pub const vortex_pco::Pco::ID: vortex_array::array::ArrayId
 
-pub fn vortex_pco::PcoArray::from_array(array: vortex_array::array::ArrayRef, level: usize, nums_per_page: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_pco::Pco::from_primitive(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, level: usize, values_per_page: usize) -> vortex_error::VortexResult<vortex_pco::PcoArray>
 
-pub fn vortex_pco::PcoArray::from_primitive(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, level: usize, values_per_page: usize) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_pco::Pco
 
-pub fn vortex_pco::PcoArray::new(chunk_metas: alloc::vec::Vec<vortex_buffer::ByteBuffer>, pages: alloc::vec::Vec<vortex_buffer::ByteBuffer>, dtype: vortex_array::dtype::DType, metadata: vortex_pco::PcoMetadata, len: usize, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_pco::Pco::clone(&self) -> vortex_pco::Pco
 
-impl core::clone::Clone for vortex_pco::PcoArray
+impl core::fmt::Debug for vortex_pco::Pco
 
-pub fn vortex_pco::PcoArray::clone(&self) -> vortex_pco::PcoArray
+pub fn vortex_pco::Pco::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_pco::PcoArray
+impl vortex_array::array::vtable::VTable for vortex_pco::Pco
 
-pub fn vortex_pco::PcoArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_pco::Pco::ArrayData = vortex_pco::PcoData
 
-impl core::convert::From<vortex_pco::PcoArray> for vortex_array::array::ArrayRef
+pub type vortex_pco::Pco::OperationsVTable = vortex_pco::Pco
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_pco::PcoArray) -> vortex_array::array::ArrayRef
+pub type vortex_pco::Pco::ValidityVTable = vortex_pco::Pco
 
-impl core::fmt::Debug for vortex_pco::PcoArray
+pub fn vortex_pco::Pco::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_pco::PcoArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_pco::Pco::buffer_name(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::ops::deref::Deref for vortex_pco::PcoArray
+pub fn vortex_pco::Pco::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_pco::PcoArray::Target = dyn vortex_array::array::Array
+pub fn vortex_pco::Pco::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_pco::PcoArray::deref(&self) -> &Self::Target
+pub fn vortex_pco::Pco::id(&self) -> vortex_array::array::ArrayId
 
-impl vortex_array::array::IntoArray for vortex_pco::PcoArray
+pub fn vortex_pco::Pco::nbuffers(array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_pco::PcoArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_pco::Pco::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::vtable::validity::ValiditySliceHelper for vortex_pco::PcoArray
+pub fn vortex_pco::Pco::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_pco::PcoArray::unsliced_validity_and_slice(&self) -> (&vortex_array::validity::Validity, usize, usize)
+pub fn vortex_pco::Pco::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
+
+pub fn vortex_pco::Pco::validate(&self, data: &vortex_pco::PcoData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
+
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_pco::Pco> for vortex_pco::Pco
+
+pub fn vortex_pco::Pco::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_pco::Pco>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_pco::Pco> for vortex_pco::Pco
+
+pub fn vortex_pco::Pco::validity(array: vortex_array::array::view::ArrayView<'_, vortex_pco::Pco>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+
+impl vortex_array::arrays::slice::SliceReduce for vortex_pco::Pco
+
+pub fn vortex_pco::Pco::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_pco::Pco
+
+pub fn vortex_pco::Pco::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
 pub struct vortex_pco::PcoChunkInfo
 
@@ -64,6 +82,44 @@ pub fn vortex_pco::PcoChunkInfo::clear(&mut self)
 
 pub fn vortex_pco::PcoChunkInfo::encoded_len(&self) -> usize
 
+pub struct vortex_pco::PcoData
+
+impl vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::decompress(&self, unsliced_validity: &vortex_array::validity::Validity, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::primitive::vtable::PrimitiveArray>
+
+pub fn vortex_pco::PcoData::from_array(array: vortex_array::array::erased::ArrayRef, level: usize, nums_per_page: usize) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_pco::PcoData::from_primitive(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, level: usize, values_per_page: usize) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_pco::PcoData::is_empty(&self) -> bool
+
+pub fn vortex_pco::PcoData::len(&self) -> usize
+
+pub fn vortex_pco::PcoData::new(chunk_metas: alloc::vec::Vec<vortex_buffer::ByteBuffer>, pages: alloc::vec::Vec<vortex_buffer::ByteBuffer>, ptype: vortex_array::dtype::ptype::PType, metadata: vortex_pco::PcoMetadata, len: usize) -> Self
+
+pub fn vortex_pco::PcoData::validate(&self, dtype: &vortex_array::dtype::DType, len: usize, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+
+impl core::clone::Clone for vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::clone(&self) -> vortex_pco::PcoData
+
+impl core::fmt::Debug for vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::hash::ArrayEq for vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
+
+impl vortex_array::hash::ArrayHash for vortex_pco::PcoData
+
+pub fn vortex_pco::PcoData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
+
 pub struct vortex_pco::PcoMetadata
 
 pub vortex_pco::PcoMetadata::chunks: alloc::vec::Vec<vortex_pco::PcoChunkInfo>
@@ -110,76 +166,4 @@ pub fn vortex_pco::PcoPageInfo::clear(&mut self)
 
 pub fn vortex_pco::PcoPageInfo::encoded_len(&self) -> usize
 
-pub struct vortex_pco::PcoVTable
-
-impl vortex_pco::PcoVTable
-
-pub const vortex_pco::PcoVTable::ID: vortex_array::vtable::dyn_::ArrayId
-
-impl core::fmt::Debug for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-impl vortex_array::arrays::slice::SliceReduce for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
-
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::cast(array: &vortex_pco::PcoArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
-
-impl vortex_array::vtable::VTable for vortex_pco::PcoVTable
-
-pub type vortex_pco::PcoVTable::Array = vortex_pco::PcoArray
-
-pub type vortex_pco::PcoVTable::ArrayVTable = vortex_pco::PcoVTable
-
-pub type vortex_pco::PcoVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_pco::PcoMetadata>
-
-pub type vortex_pco::PcoVTable::OperationsVTable = vortex_pco::PcoVTable
-
-pub type vortex_pco::PcoVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromValiditySliceHelper
-
-pub type vortex_pco::PcoVTable::VisitorVTable = vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_pco::PcoArray>
-
-pub fn vortex_pco::PcoVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
-
-pub fn vortex_pco::PcoVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
-
-pub fn vortex_pco::PcoVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
-
-pub fn vortex_pco::PcoVTable::metadata(array: &vortex_pco::PcoArray) -> vortex_error::VortexResult<Self::Metadata>
-
-pub fn vortex_pco::PcoVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
-
-pub fn vortex_pco::PcoVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
-pub fn vortex_pco::PcoVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
-
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_pco::PcoVTable> for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::array_eq(array: &vortex_pco::PcoArray, other: &vortex_pco::PcoArray, precision: vortex_array::hash::Precision) -> bool
-
-pub fn vortex_pco::PcoVTable::array_hash<H: core::hash::Hasher>(array: &vortex_pco::PcoArray, state: &mut H, precision: vortex_array::hash::Precision)
-
-pub fn vortex_pco::PcoVTable::dtype(array: &vortex_pco::PcoArray) -> &vortex_array::dtype::DType
-
-pub fn vortex_pco::PcoVTable::len(array: &vortex_pco::PcoArray) -> usize
-
-pub fn vortex_pco::PcoVTable::stats(array: &vortex_pco::PcoArray) -> vortex_array::stats::array::StatsSetRef<'_>
-
-impl vortex_array::vtable::operations::OperationsVTable<vortex_pco::PcoVTable> for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::scalar_at(array: &vortex_pco::PcoArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
-
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_pco::PcoVTable> for vortex_pco::PcoVTable
-
-pub fn vortex_pco::PcoVTable::nbuffers(array: &vortex_pco::PcoArray) -> usize
-
-pub fn vortex_pco::PcoVTable::nchildren(array: &vortex_pco::PcoArray) -> usize
-
-pub fn vortex_pco::PcoVTable::visit_buffers(array: &vortex_pco::PcoArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
-
-pub fn vortex_pco::PcoVTable::visit_children(array: &vortex_pco::PcoArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub type vortex_pco::PcoArray = vortex_array::array::typed::Array<vortex_pco::Pco>
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index 42b534d9963..861f80cc6eb 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -3,7 +3,10 @@
 
 use std::cmp;
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
 use pco::ChunkConfig;
 use pco::PagingSpec;
@@ -15,43 +18,38 @@ use pco::wrapped::ChunkDecompressor;
 use pco::wrapped::FileCompressor;
 use pco::wrapped::FileDecompressor;
 use prost::Message;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
 use vortex_array::ToCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::PrimitiveVTable;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::compute::filter;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::PType;
 use vortex_array::dtype::half;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_array::vtable::ValiditySliceHelper;
-use vortex_array::vtable::ValidityVTableFromValiditySliceHelper;
-use vortex_array::vtable::VisitorVTable;
-use vortex_array::vtable::validity_nchildren;
+use vortex_array::vtable::ValidityVTable;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
 use vortex_buffer::BufferMut;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexError;
-use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
@@ -82,47 +80,107 @@ use crate::PcoPageInfo;
 
 const VALUES_PER_CHUNK: usize = pco::DEFAULT_MAX_PAGE_N;
 
-vtable!(Pco);
+/// A [`Pco`]-encoded Vortex array.
+pub type PcoArray = Array<Pco>;
 
-impl VTable for PcoVTable {
-    type Array = PcoArray;
+impl ArrayHash for PcoData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        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);
+        }
+        for page in &self.pages {
+            page.array_hash(state, precision);
+        }
+    }
+}
+
+impl ArrayEq for PcoData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        if self.unsliced_n_rows != other.unsliced_n_rows
+            || self.slice_start != other.slice_start
+            || self.slice_stop != other.slice_stop
+            || self.chunk_metas.len() != other.chunk_metas.len()
+            || self.pages.len() != other.pages.len()
+        {
+            return false;
+        }
+        for (a, b) in self.chunk_metas.iter().zip(&other.chunk_metas) {
+            if !a.array_eq(b, precision) {
+                return false;
+            }
+        }
+        for (a, b) in self.pages.iter().zip(&other.pages) {
+            if !a.array_eq(b, precision) {
+                return false;
+            }
+        }
+        true
+    }
+}
 
-    type Metadata = ProstMetadata<PcoMetadata>;
+impl VTable for Pco {
+    type ArrayData = PcoData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValiditySliceHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &PcoArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(array.metadata.clone()))
+    fn validate(
+        &self,
+        data: &PcoData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let validity = child_to_validity(&slots[0], dtype.nullability());
+        data.validate(dtype, len, &validity)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize {
+        array.chunk_metas.len() + array.pages.len()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        if idx < array.chunk_metas.len() {
+            BufferHandle::new_host(array.chunk_metas[idx].clone())
+        } else {
+            let page_idx = idx - array.chunk_metas.len();
+            BufferHandle::new_host(array.pages[page_idx].clone())
+        }
+    }
+
+    fn buffer_name(array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        if idx < array.chunk_metas.len() {
+            Some(format!("chunk_meta_{idx}"))
+        } else {
+            Some(format!("page_{}", idx - array.chunk_metas.len()))
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(PcoMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(array.metadata.clone().encode_to_vec()))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<PcoArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = PcoMetadata::decode(metadata)?;
         let validity = if children.is_empty() {
             Validity::from(dtype.nullability())
         } else if children.len() == 1 {
@@ -132,57 +190,45 @@ impl VTable for PcoVTable {
             vortex_bail!("PcoArray expected 0 or 1 child, got {}", children.len());
         };
 
-        vortex_ensure!(buffers.len() >= metadata.0.chunks.len());
-        let chunk_metas = buffers[..metadata.0.chunks.len()]
+        vortex_ensure!(buffers.len() >= metadata.chunks.len());
+        let chunk_metas = buffers[..metadata.chunks.len()]
             .iter()
             .map(|b| b.clone().try_to_host_sync())
             .collect::<VortexResult<Vec<_>>>()?;
-        let pages = buffers[metadata.0.chunks.len()..]
+        let pages = buffers[metadata.chunks.len()..]
             .iter()
             .map(|b| b.clone().try_to_host_sync())
             .collect::<VortexResult<Vec<_>>>()?;
 
         let expected_n_pages = metadata
-            .0
             .chunks
             .iter()
             .map(|info| info.pages.len())
             .sum::<usize>();
         vortex_ensure!(pages.len() == expected_n_pages);
 
-        Ok(PcoArray::new(
-            chunk_metas,
-            pages,
-            dtype.clone(),
-            metadata.0.clone(),
-            len,
-            validity,
-        ))
+        let slots = vec![validity_to_child(&validity, len)];
+        let data = PcoData::new(chunk_metas, pages, dtype.as_ptype(), metadata, len);
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "PcoArray expects 0 or 1 children, got {}",
-            children.len()
-        );
-
-        if children.is_empty() {
-            array.unsliced_validity = Validity::from(array.dtype.nullability());
-        } else {
-            array.unsliced_validity =
-                Validity::Array(children.into_iter().next().vortex_expect("validity child"));
-        }
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.decompress()?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let unsliced_validity =
+            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        Ok(ExecutionResult::done(
+            array
+                .data()
+                .decompress(&unsliced_validity, ctx)?
+                .into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -191,7 +237,10 @@ impl VTable for PcoVTable {
 }
 
 pub(crate) fn number_type_from_dtype(dtype: &DType) -> NumberType {
-    let ptype = dtype.as_ptype();
+    number_type_from_ptype(dtype.as_ptype())
+}
+
+pub(crate) fn number_type_from_ptype(ptype: PType) -> NumberType {
     match ptype {
         PType::F16 => NumberType::F16,
         PType::F32 => NumberType::F32,
@@ -208,7 +257,7 @@ pub(crate) fn number_type_from_dtype(dtype: &DType) -> NumberType {
 
 fn collect_valid(parray: &PrimitiveArray) -> VortexResult<PrimitiveArray> {
     let mask = parray.validity_mask()?;
-    Ok(filter(&parray.to_array(), &mask)?.to_primitive())
+    Ok(parray.filter(mask)?.to_primitive())
 }
 
 pub(crate) fn vortex_err_from_pco(err: PcoError) -> VortexError {
@@ -220,43 +269,130 @@ pub(crate) fn vortex_err_from_pco(err: PcoError) -> VortexError {
     }
 }
 
-#[derive(Debug)]
-pub struct PcoVTable;
+#[derive(Clone, Debug)]
+pub struct Pco;
 
-impl PcoVTable {
+impl Pco {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.pco");
+
+    pub(crate) fn try_new(
+        dtype: DType,
+        data: PcoData,
+        validity: Validity,
+    ) -> VortexResult<PcoArray> {
+        let len = data.len();
+        data.validate(&dtype, len, &validity)?;
+        let slots = vec![validity_to_child(&validity, data.unsliced_n_rows())];
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Pco, dtype, len, data).with_slots(slots))
+        })
+    }
+
+    /// Compress a primitive array using pcodec.
+    pub fn from_primitive(
+        parray: &PrimitiveArray,
+        level: usize,
+        values_per_page: usize,
+    ) -> VortexResult<PcoArray> {
+        let dtype = parray.dtype().clone();
+        let validity = parray.validity()?;
+        let data = PcoData::from_primitive(parray, level, values_per_page)?;
+        Self::try_new(dtype, data, validity)
+    }
 }
 
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
+
 #[derive(Clone, Debug)]
-pub struct PcoArray {
+pub struct PcoData {
     pub(crate) chunk_metas: Vec<ByteBuffer>,
     pub(crate) pages: Vec<ByteBuffer>,
     pub(crate) metadata: PcoMetadata,
-    dtype: DType,
-    pub(crate) unsliced_validity: Validity,
+    ptype: PType,
     unsliced_n_rows: usize,
-    stats_set: ArrayStats,
     slice_start: usize,
     slice_stop: usize,
 }
 
-impl PcoArray {
+impl Display for PcoData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "ptype: {}, nrows: {}, slice: {}..{}",
+            self.ptype, self.unsliced_n_rows, self.slice_start, self.slice_stop
+        )
+    }
+}
+
+impl PcoData {
+    pub fn validate(&self, dtype: &DType, len: usize, validity: &Validity) -> VortexResult<()> {
+        let _ = number_type_from_ptype(self.ptype);
+        vortex_ensure!(
+            dtype.as_ptype() == self.ptype,
+            "expected ptype {}, got {}",
+            self.ptype,
+            dtype.as_ptype()
+        );
+        vortex_ensure!(
+            dtype.nullability() == validity.nullability(),
+            "expected nullability {}, got {}",
+            validity.nullability(),
+            dtype.nullability()
+        );
+        vortex_ensure!(
+            self.slice_start <= self.slice_stop && self.slice_stop <= self.unsliced_n_rows,
+            "invalid slice range {}..{} for {} rows",
+            self.slice_start,
+            self.slice_stop,
+            self.unsliced_n_rows
+        );
+        vortex_ensure!(
+            self.slice_stop - self.slice_start == len,
+            "expected len {len}, got {}",
+            self.slice_stop - self.slice_start
+        );
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure!(
+                validity_len == self.unsliced_n_rows,
+                "expected validity len {}, got {}",
+                self.unsliced_n_rows,
+                validity_len
+            );
+        }
+        vortex_ensure!(
+            self.chunk_metas.len() == self.metadata.chunks.len(),
+            "expected {} chunk metas, got {}",
+            self.metadata.chunks.len(),
+            self.chunk_metas.len()
+        );
+        vortex_ensure!(
+            self.pages.len()
+                == self
+                    .metadata
+                    .chunks
+                    .iter()
+                    .map(|chunk| chunk.pages.len())
+                    .sum::<usize>(),
+            "page count does not match metadata"
+        );
+        Ok(())
+    }
+
     pub fn new(
         chunk_metas: Vec<ByteBuffer>,
         pages: Vec<ByteBuffer>,
-        dtype: DType,
+        ptype: PType,
         metadata: PcoMetadata,
         len: usize,
-        validity: Validity,
     ) -> Self {
         Self {
             chunk_metas,
             pages,
             metadata,
-            dtype,
-            unsliced_validity: validity,
+            ptype,
             unsliced_n_rows: len,
-            stats_set: Default::default(),
             slice_start: 0,
             slice_stop: len,
         }
@@ -333,49 +469,56 @@ impl PcoArray {
             header,
             chunks: chunk_infos,
         };
-        Ok(PcoArray::new(
+        Ok(PcoData::new(
             chunk_meta_buffers,
             page_buffers,
-            parray.dtype().clone(),
+            parray.dtype().as_ptype(),
             metadata,
             parray.len(),
-            parray.validity().clone(),
         ))
     }
 
     pub fn from_array(array: ArrayRef, level: usize, nums_per_page: usize) -> VortexResult<Self> {
-        if let Some(parray) = array.as_opt::<PrimitiveVTable>() {
-            Self::from_primitive(parray, level, nums_per_page)
-        } else {
-            Err(vortex_err!("Pco can only encode primitive arrays"))
-        }
-    }
-
-    pub fn decompress(&self) -> VortexResult<PrimitiveArray> {
+        let parray = array.try_downcast::<Primitive>().map_err(|a| {
+            vortex_err!(
+                "Pco can only encode primitive arrays, got {}",
+                a.encoding_id()
+            )
+        })?;
+        Self::from_primitive(&parray, level, nums_per_page)
+    }
+
+    pub fn decompress(
+        &self,
+        unsliced_validity: &Validity,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<PrimitiveArray> {
         // To start, we figure out which chunks and pages we need to decompress, and with
         // what value offset into the first such page.
-        let number_type = number_type_from_dtype(&self.dtype);
+        let number_type = number_type_from_ptype(self.ptype);
         let values_byte_buffer = match_number_enum!(
             number_type,
             NumberType<T> => {
-              self.decompress_values_typed::<T>()?
+              self.decompress_values_typed::<T>(unsliced_validity, ctx)?
             }
         );
 
         Ok(PrimitiveArray::from_values_byte_buffer(
             values_byte_buffer,
-            self.dtype.as_ptype(),
-            self.unsliced_validity
-                .slice(self.slice_start..self.slice_stop)?,
+            self.ptype,
+            unsliced_validity.slice(self.slice_start..self.slice_stop)?,
             self.slice_stop - self.slice_start,
         ))
     }
 
-    fn decompress_values_typed<T: Number>(&self) -> VortexResult<ByteBuffer> {
+    fn decompress_values_typed<T: Number>(
+        &self,
+        unsliced_validity: &Validity,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ByteBuffer> {
         // To start, we figure out what range of values we need to decompress.
-        let slice_value_indices = self
-            .unsliced_validity
-            .to_mask(self.unsliced_n_rows)
+        let slice_value_indices = unsliced_validity
+            .execute_mask(self.unsliced_n_rows, ctx)?
             .valid_counts_for_indices(&[self.slice_start, self.slice_stop]);
         let slice_value_start = slice_value_indices[0];
         let slice_value_stop = slice_value_indices[1];
@@ -445,16 +588,21 @@ impl PcoArray {
     }
 
     pub(crate) fn _slice(&self, start: usize, stop: usize) -> Self {
-        PcoArray {
+        PcoData {
             slice_start: self.slice_start + start,
             slice_stop: self.slice_start + stop,
-            stats_set: Default::default(),
             ..self.clone()
         }
     }
 
-    pub(crate) fn dtype(&self) -> &DType {
-        &self.dtype
+    /// Returns the number of elements in the array.
+    pub fn len(&self) -> usize {
+        self.slice_stop - self.slice_start
+    }
+
+    /// Returns `true` if the array contains no elements.
+    pub fn is_empty(&self) -> bool {
+        self.slice_stop == self.slice_start
     }
 
     pub(crate) fn slice_start(&self) -> usize {
@@ -470,99 +618,26 @@ impl PcoArray {
     }
 }
 
-impl ValiditySliceHelper for PcoArray {
-    fn unsliced_validity_and_slice(&self) -> (&Validity, usize, usize) {
-        (&self.unsliced_validity, self.slice_start, self.slice_stop)
+impl ValidityVTable<Pco> for Pco {
+    fn validity(array: ArrayView<'_, Pco>) -> VortexResult<Validity> {
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        unsliced_validity.slice(array.slice_start()..array.slice_stop())
     }
 }
 
-impl BaseArrayVTable<PcoVTable> for PcoVTable {
-    fn len(array: &PcoArray) -> usize {
-        array.slice_stop - array.slice_start
-    }
-
-    fn dtype(array: &PcoArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &PcoArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &PcoArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.unsliced_validity.array_hash(state, precision);
-        array.unsliced_n_rows.hash(state);
-        array.slice_start.hash(state);
-        array.slice_stop.hash(state);
-        // Hash chunk_metas and pages using pointer-based hashing
-        for chunk_meta in &array.chunk_metas {
-            chunk_meta.array_hash(state, precision);
-        }
-        for page in &array.pages {
-            page.array_hash(state, precision);
-        }
-    }
-
-    fn array_eq(array: &PcoArray, other: &PcoArray, precision: Precision) -> bool {
-        if array.dtype != other.dtype
-            || !array
-                .unsliced_validity
-                .array_eq(&other.unsliced_validity, precision)
-            || array.unsliced_n_rows != other.unsliced_n_rows
-            || array.slice_start != other.slice_start
-            || array.slice_stop != other.slice_stop
-            || array.chunk_metas.len() != other.chunk_metas.len()
-            || array.pages.len() != other.pages.len()
-        {
-            return false;
-        }
-        for (a, b) in array.chunk_metas.iter().zip(&other.chunk_metas) {
-            if !a.array_eq(b, precision) {
-                return false;
-            }
-        }
-        for (a, b) in array.pages.iter().zip(&other.pages) {
-            if !a.array_eq(b, precision) {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl OperationsVTable<PcoVTable> for PcoVTable {
-    fn scalar_at(array: &PcoArray, index: usize) -> VortexResult<Scalar> {
-        array._slice(index, index + 1).decompress()?.scalar_at(0)
-    }
-}
-
-impl VisitorVTable<PcoVTable> for PcoVTable {
-    fn visit_buffers(array: &PcoArray, visitor: &mut dyn ArrayBufferVisitor) {
-        for (i, buffer) in array.chunk_metas.iter().enumerate() {
-            visitor.visit_buffer_handle(
-                &format!("chunk_meta_{i}"),
-                &BufferHandle::new_host(buffer.clone()),
-            );
-        }
-        for (i, buffer) in array.pages.iter().enumerate() {
-            visitor.visit_buffer_handle(
-                &format!("page_{i}"),
-                &BufferHandle::new_host(buffer.clone()),
-            );
-        }
-    }
-
-    fn nbuffers(array: &PcoArray) -> usize {
-        array.chunk_metas.len() + array.pages.len()
-    }
-
-    fn visit_children(array: &PcoArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(&array.unsliced_validity, array.unsliced_n_rows());
-    }
-
-    fn nchildren(array: &PcoArray) -> usize {
-        validity_nchildren(&array.unsliced_validity)
+impl OperationsVTable<Pco> for Pco {
+    fn scalar_at(
+        array: ArrayView<'_, Pco>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        array
+            ._slice(index, index + 1)
+            .decompress(&unsliced_validity, &mut ctx)?
+            .into_array()
+            .scalar_at(0)
     }
 }
 
@@ -572,18 +647,18 @@ mod tests {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
 
-    use crate::PcoArray;
+    use crate::Pco;
 
     #[test]
     fn test_slice_nullable() {
         // Create a nullable array with some nulls
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40, 50, 60]),
+            buffer![10u32, 20, 30, 40, 50, 60],
             Validity::from_iter([false, true, true, true, true, false]),
         );
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
         assert_arrays_eq!(
             pco,
             PrimitiveArray::from_option_iter([
diff --git a/encodings/pco/src/compute/cast.rs b/encodings/pco/src/compute/cast.rs
index 6b0b5dc97e7..21598191fec 100644
--- a/encodings/pco/src/compute/cast.rs
+++ b/encodings/pco/src/compute/cast.rs
@@ -2,17 +2,18 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
+use vortex_array::vtable::child_to_validity;
 use vortex_error::VortexResult;
 
-use crate::PcoArray;
-use crate::PcoVTable;
-
-impl CastReduce for PcoVTable {
-    fn cast(array: &PcoArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
-        if !dtype.is_nullable() || !array.all_valid()? {
+use crate::Pco;
+use crate::PcoData;
+impl CastReduce for Pco {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+        if !dtype.is_nullable() || !array.array().all_valid()? {
             // TODO(joe): fixme
             // We cannot cast to non-nullable since the validity containing nulls is used to decode
             // the PCO array, this would require rewriting tables.
@@ -24,22 +25,22 @@ impl CastReduce for PcoVTable {
         // PCO supports: F16, F32, F64, I16, I32, I64, U16, U32, U64
         if array.dtype().eq_ignore_nullability(dtype) {
             // Create a new validity with the target nullability
-            let new_validity = array
-                .unsliced_validity
-                .clone()
-                .cast_nullability(dtype.nullability(), array.len())?;
+            let unsliced_validity =
+                child_to_validity(&array.slots()[0], array.dtype().nullability());
+            let new_validity =
+                unsliced_validity.cast_nullability(dtype.nullability(), array.len())?;
+
+            let data = PcoData::new(
+                array.chunk_metas.clone(),
+                array.pages.clone(),
+                dtype.as_ptype(),
+                array.metadata.clone(),
+                array.unsliced_n_rows(),
+            )
+            ._slice(array.slice_start(), array.slice_stop());
 
             return Ok(Some(
-                PcoArray::new(
-                    array.chunk_metas.clone(),
-                    array.pages.clone(),
-                    dtype.clone(),
-                    array.metadata.clone(),
-                    array.unsliced_n_rows(),
-                    new_validity,
-                )
-                ._slice(array.slice_start(), array.slice_stop())
-                .into_array(),
+                Pco::try_new(dtype.clone(), data, new_validity)?.into_array(),
             ));
         }
 
@@ -51,6 +52,7 @@ impl CastReduce for PcoVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
@@ -59,20 +61,17 @@ mod tests {
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
 
-    use crate::PcoArray;
+    use crate::Pco;
 
     #[test]
     fn test_cast_pco_f32_to_f64() {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1.0f32, 2.0, 3.0, 4.0, 5.0]),
-            Validity::NonNullable,
-        );
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
+        let values = PrimitiveArray::from_iter([1.0f32, 2.0, 3.0, 4.0, 5.0]);
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
 
         let casted = pco
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -89,29 +88,26 @@ mod tests {
     #[test]
     fn test_cast_pco_nullability_change() {
         // Test casting from NonNullable to Nullable
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40]),
-            Validity::NonNullable,
-        );
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
+        let values = PrimitiveArray::from_iter([10u32, 20, 30, 40]);
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
 
         let casted = pco
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap();
-        assert_eq!(
-            casted.dtype(),
-            &DType::Primitive(PType::U32, Nullability::Nullable)
+        assert_arrays_eq!(
+            casted,
+            PrimitiveArray::new(buffer![10u32, 20, 30, 40], Validity::AllValid,)
         );
     }
 
     #[test]
     fn test_cast_sliced_pco_nullable_to_nonnullable() {
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40, 50, 60]),
+            buffer![10u32, 20, 30, 40, 50, 60],
             Validity::from_iter([true, true, true, true, true, true]),
         );
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
         let sliced = pco.slice(1..5).unwrap();
         let casted = sliced
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
@@ -134,7 +130,7 @@ mod tests {
             Some(50),
             Some(60),
         ]);
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
         let sliced = pco.slice(1..5).unwrap();
         let casted = sliced
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
@@ -148,27 +144,27 @@ mod tests {
 
     #[rstest]
     #[case::f32(PrimitiveArray::new(
-        Buffer::copy_from(vec![1.23f32, 4.56, 7.89, 10.11, 12.13]),
+        buffer![1.23f32, 4.56, 7.89, 10.11, 12.13],
         Validity::NonNullable,
     ))]
     #[case::f64(PrimitiveArray::new(
-        Buffer::copy_from(vec![100.1f64, 200.2, 300.3, 400.4, 500.5]),
+        buffer![100.1f64, 200.2, 300.3, 400.4, 500.5],
         Validity::NonNullable,
     ))]
     #[case::i32(PrimitiveArray::new(
-        Buffer::copy_from(vec![100i32, 200, 300, 400, 500]),
+        buffer![100i32, 200, 300, 400, 500],
         Validity::NonNullable,
     ))]
     #[case::u64(PrimitiveArray::new(
-        Buffer::copy_from(vec![1000u64, 2000, 3000, 4000]),
+        buffer![1000u64, 2000, 3000, 4000],
         Validity::NonNullable,
     ))]
     #[case::single(PrimitiveArray::new(
-        Buffer::copy_from(vec![42.42f64]),
+        buffer![42.42f64],
         Validity::NonNullable,
     ))]
     fn test_cast_pco_conformance(#[case] values: PrimitiveArray) {
-        let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
-        test_cast_conformance(pco.as_ref());
+        let pco = Pco::from_primitive(&values, 0, 128).unwrap();
+        test_cast_conformance(&pco.into_array());
     }
 }
diff --git a/encodings/pco/src/compute/mod.rs b/encodings/pco/src/compute/mod.rs
index 77207e7e3d7..990a54179ae 100644
--- a/encodings/pco/src/compute/mod.rs
+++ b/encodings/pco/src/compute/mod.rs
@@ -6,74 +6,51 @@ mod cast;
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
-    use vortex_buffer::Buffer;
 
+    use crate::Pco;
     use crate::PcoArray;
 
     fn pco_f32() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1.23f32, 4.56, 7.89, 10.11, 12.13]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_f64() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![100.1f64, 200.2, 300.3, 400.4, 500.5]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_i32() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![100i32, 200, 300, 400, 500]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([100i32, 200, 300, 400, 500]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_u64() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1000u64, 2000, 3000, 4000]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([1000u64, 2000, 3000, 4000]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_i16() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10i16, 20, 30, 40, 50]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([10i16, 20, 30, 40, 50]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_i32_alt() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1i32, 2, 3, 4, 5]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_single() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![42.42f64]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 0, 128).unwrap()
+        let values = PrimitiveArray::from_iter([42.42f64]);
+        Pco::from_primitive(&values, 0, 128).unwrap()
     }
 
     fn pco_large() -> PcoArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from((0..1000).map(|i| i as u32).collect::<Vec<_>>()),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        PcoArray::from_primitive(&values, 3, 128).unwrap()
+        let values = PrimitiveArray::from_iter(0u32..1000);
+        Pco::from_primitive(&values, 3, 128).unwrap()
     }
 
     #[rstest]
@@ -86,6 +63,6 @@ mod tests {
     #[case::single(pco_single())]
     #[case::large(pco_large())]
     fn test_pco_consistency(#[case] array: PcoArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/pco/src/rules.rs b/encodings/pco/src/rules.rs
index 5f342b9e45a..4d27392dc01 100644
--- a/encodings/pco/src/rules.rs
+++ b/encodings/pco/src/rules.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::PcoVTable;
+use crate::Pco;
 
-pub(crate) static RULES: ParentRuleSet<PcoVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&SliceReduceAdaptor(PcoVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(PcoVTable)),
+pub(crate) static RULES: ParentRuleSet<Pco> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&SliceReduceAdaptor(Pco)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Pco)),
 ]);
diff --git a/encodings/pco/src/slice.rs b/encodings/pco/src/slice.rs
index cff65bbb3e9..2f341f989b7 100644
--- a/encodings/pco/src/slice.rs
+++ b/encodings/pco/src/slice.rs
@@ -4,14 +4,24 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
+use vortex_array::vtable::child_to_validity;
 use vortex_error::VortexResult;
 
-use crate::PcoVTable;
+use crate::Pco;
 
-impl SliceReduce for PcoVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        Ok(Some(array._slice(range.start, range.end).into_array()))
+impl SliceReduce for Pco {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        Ok(Some(
+            Pco::try_new(
+                array.dtype().clone(),
+                array._slice(range.start, range.end),
+                unsliced_validity,
+            )?
+            .into_array(),
+        ))
     }
 }
diff --git a/encodings/pco/src/test.rs b/encodings/pco/src/test.rs
index 14cdb1ed213..a431037948a 100644
--- a/encodings/pco/src/test.rs
+++ b/encodings/pco/src/test.rs
@@ -6,6 +6,7 @@ use std::sync::LazyLock;
 
 use vortex_array::ArrayContext;
 use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::ToCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
@@ -16,37 +17,44 @@ use vortex_array::assert_nth_scalar;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
-use vortex_array::serde::ArrayParts;
 use vortex_array::serde::SerializeOptions;
+use vortex_array::serde::SerializedArray;
 use vortex_array::session::ArraySession;
 use vortex_array::session::ArraySessionExt;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
+use vortex_array::vtable::child_to_validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
+
+use crate::PcoData;
 
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     let session = VortexSession::empty().with::<ArraySession>();
-    session.arrays().register(PcoVTable::ID, PcoVTable);
+    session.arrays().register(Pco);
     session
 });
 
-use crate::PcoArray;
-use crate::PcoVTable;
-
+use crate::Pco;
 #[test]
 fn test_compress_decompress() {
     let data: Vec<i32> = (0..200).collect();
     let array = PrimitiveArray::from_iter(data.clone());
-    let compressed = PcoArray::from_primitive(&array, 3, 0).unwrap();
+    let compressed = Pco::from_primitive(&array, 3, 0).unwrap();
     // this data should be compressible
-    assert!(compressed.pages.len() < array.nbytes() as usize);
+    assert!(compressed.pages.len() < array.into_array().nbytes() as usize);
 
     // check full decompression works
-    let decompressed = compressed.decompress().unwrap();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let unsliced_validity = child_to_validity(
+        &compressed.as_ref().slots()[0],
+        compressed.dtype().nullability(),
+    );
+    let decompressed = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
     assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(data));
 
     // check slicing works
@@ -63,12 +71,17 @@ fn test_compress_decompress() {
 #[test]
 fn test_compress_decompress_small() {
     let array = PrimitiveArray::from_option_iter([None, Some(1)]);
-    let compressed = PcoArray::from_primitive(&array, 3, 0).unwrap();
+    let compressed = Pco::from_primitive(&array, 3, 0).unwrap();
 
     let expected = array.into_array();
     assert_arrays_eq!(compressed, expected);
 
-    let decompressed = compressed.decompress().unwrap();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let unsliced_validity = child_to_validity(
+        &compressed.as_ref().slots()[0],
+        compressed.dtype().nullability(),
+    );
+    let decompressed = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
     assert_arrays_eq!(decompressed, expected);
 }
 
@@ -76,8 +89,13 @@ fn test_compress_decompress_small() {
 fn test_empty() {
     let data: Vec<i32> = vec![];
     let array = PrimitiveArray::from_iter(data.clone());
-    let compressed = PcoArray::from_primitive(&array, 3, 100).unwrap();
-    let primitive = compressed.decompress().unwrap();
+    let compressed = Pco::from_primitive(&array, 3, 100).unwrap();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let unsliced_validity = child_to_validity(
+        &compressed.as_ref().slots()[0],
+        compressed.dtype().nullability(),
+    );
+    let primitive = compressed.decompress(&unsliced_validity, &mut ctx).unwrap();
     assert_arrays_eq!(primitive, PrimitiveArray::from_iter(data));
 }
 
@@ -89,18 +107,24 @@ fn test_validity_and_multiple_chunks_and_pages() {
     validity[101] = false;
     let array = PrimitiveArray::new(
         Buffer::from(data),
-        Validity::Array(BoolArray::from_iter(validity).to_array()),
+        Validity::Array(BoolArray::from_iter(validity).into_array()),
     );
     let compression_level = 3;
     let values_per_chunk = 33;
     let values_per_page = 10;
-    let compressed = PcoArray::from_primitive_with_values_per_chunk(
-        &array,
-        compression_level,
-        values_per_chunk,
-        values_per_page,
+    let validity = array.validity().unwrap();
+    let compressed = Pco::try_new(
+        array.dtype().clone(),
+        PcoData::from_primitive_with_values_per_chunk(
+            &array,
+            compression_level,
+            values_per_chunk,
+            values_per_page,
+        )
+        .unwrap(),
+        validity,
     )
-    .unwrap();
+    .vortex_expect("PcoData is always valid");
 
     assert_eq!(compressed.metadata.chunks.len(), 6); // 191 values / 33 rounds up to 6
     assert_eq!(compressed.metadata.chunks[0].pages.len(), 4); // 33 / 10 rounds up to 4
@@ -117,9 +141,17 @@ fn test_validity_and_multiple_chunks_and_pages() {
     assert_nth_scalar!(slice, 0, 100);
     assert_nth_scalar!(slice, 2, 102);
     let primitive = slice.to_primitive();
-    assert_eq!(
-        primitive.validity(),
-        &Validity::Array(BoolArray::from_iter(vec![true, false, true]).to_array())
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert!(
+        primitive
+            .validity()
+            .unwrap()
+            .mask_eq(
+                &Validity::Array(BoolArray::from_iter(vec![true, false, true]).into_array()),
+                &mut ctx,
+            )
+            .unwrap()
     );
 }
 
@@ -129,11 +161,11 @@ fn test_validity_vtable() {
     let mask_bools = vec![false, true, true, false, true];
     let array = PrimitiveArray::new(
         Buffer::from(data),
-        Validity::Array(BoolArray::from_iter(mask_bools.clone()).to_array()),
+        Validity::Array(BoolArray::from_iter(mask_bools.clone()).into_array()),
     );
-    let compressed = PcoArray::from_primitive(&array, 3, 0).unwrap();
+    let compressed = Pco::from_primitive(&array, 3, 0).unwrap();
     assert_eq!(
-        compressed.validity_mask().unwrap(),
+        compressed.as_array().validity_mask().unwrap(),
         Mask::from_iter(mask_bools)
     );
     assert_eq!(
@@ -145,13 +177,14 @@ fn test_validity_vtable() {
 #[test]
 fn test_serde() -> VortexResult<()> {
     let data: PrimitiveArray = (0i32..1_000_000).collect();
-    let pco = PcoArray::from_primitive(&data, 3, 100)?.to_array();
+    let pco = Pco::from_primitive(&data, 3, 100)?.into_array();
 
     let context = ArrayContext::empty();
 
     let bytes = pco
         .serialize(
             &context,
+            &LEGACY_SESSION,
             &SerializeOptions {
                 offset: 0,
                 include_padding: true,
@@ -162,11 +195,11 @@ fn test_serde() -> VortexResult<()> {
         .collect::<BufferMut<u8>>()
         .freeze();
 
-    let parts = ArrayParts::try_from(bytes)?;
+    let parts = SerializedArray::try_from(bytes)?;
     let decoded = parts.decode(
         &DType::Primitive(PType::I32, Nullability::NonNullable),
         1_000_000,
-        &context,
+        &ReadContext::new(context.to_ids()),
         &SESSION,
     )?;
     let mut ctx = SESSION.create_execution_ctx();
diff --git a/encodings/runend/Cargo.toml b/encodings/runend/Cargo.toml
index c6823f16bd3..01a5b8d7a3e 100644
--- a/encodings/runend/Cargo.toml
+++ b/encodings/runend/Cargo.toml
@@ -48,3 +48,7 @@ harness = false
 [[bench]]
 name = "run_end_compress"
 harness = false
+
+[[bench]]
+name = "run_end_decode"
+harness = false
diff --git a/encodings/runend/benches/run_end_compress.rs b/encodings/runend/benches/run_end_compress.rs
index cc57faf7c30..024f3281c36 100644
--- a/encodings/runend/benches/run_end_compress.rs
+++ b/encodings/runend/benches/run_end_compress.rs
@@ -5,21 +5,19 @@
 
 use divan::Bencher;
 use itertools::repeat_n;
-use vortex_array::Array;
 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::compute::warm_up_vtables;
+use vortex_array::arrays::VarBinViewArray;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
-use vortex_runend::RunEndArray;
+use vortex_runend::RunEnd;
 use vortex_runend::compress::runend_encode;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -36,12 +34,6 @@ const BENCH_ARGS: &[(usize, usize)] = &[
     (100_000, 256),
     (100_000, 1024),
     (100_000, 4096),
-    (1_000_000, 4),
-    (1_000_000, 16),
-    (1_000_000, 256),
-    (1_000_000, 1024),
-    (1_000_000, 4096),
-    (1_000_000, 8192),
 ];
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -56,7 +48,7 @@ fn compress(bencher: Bencher, (length, run_step): (usize, usize)) {
 
     bencher
         .with_inputs(|| &values)
-        .bench_refs(|values| runend_encode(values));
+        .bench_refs(|values| runend_encode(values.as_view()));
 }
 
 #[divan::bench(types = [u8, u16, u32, u64], args = BENCH_ARGS)]
@@ -72,12 +64,16 @@ fn decompress<T: IntegerPType>(bencher: Bencher, (length, run_step): (usize, usi
         .collect::<Buffer<_>>()
         .into_array();
 
-    let run_end_array = RunEndArray::new(ends, values);
-    let array = run_end_array.to_array();
+    let run_end_array = RunEnd::new(ends, values);
+    let array = run_end_array.into_array();
 
     bencher
-        .with_inputs(|| &array)
-        .bench_refs(|array| array.to_canonical());
+        .with_inputs(|| (array.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .bench_values(|(array, mut execution_ctx)| {
+            array
+                .execute::<RecursiveCanonical>(&mut execution_ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -92,10 +88,10 @@ fn take_indices(bencher: Bencher, (length, run_step): (usize, usize)) {
     );
 
     let source_array = PrimitiveArray::from_iter(0..(length as i32)).into_array();
-    let (ends, values) = runend_encode(&values);
-    let runend_array = RunEndArray::try_new(ends.into_array(), values)
+    let (ends, values) = runend_encode(values.as_view());
+    let runend_array = RunEnd::try_new(ends.into_array(), values)
         .unwrap()
-        .to_array();
+        .into_array();
 
     bencher
         .with_inputs(|| {
@@ -107,9 +103,32 @@ fn take_indices(bencher: Bencher, (length, run_step): (usize, usize)) {
         })
         .bench_refs(|(array, indices, execution_ctx)| {
             array
-                .take(indices.to_array())
+                .take(indices.clone())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
         });
 }
+
+#[divan::bench(args = BENCH_ARGS)]
+fn decompress_utf8(bencher: Bencher, (length, run_step): (usize, usize)) {
+    let num_runs = length.div_ceil(run_step);
+    let ends = (0..num_runs)
+        .map(|i| ((i + 1) * run_step).min(length) as u64)
+        .collect::<Buffer<_>>()
+        .into_array();
+
+    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);
+    let array = run_end_array.into_array();
+
+    bencher
+        .with_inputs(|| (array.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .bench_values(|(array, mut execution_ctx)| {
+            array
+                .execute::<RecursiveCanonical>(&mut execution_ctx)
+                .unwrap()
+        });
+}
diff --git a/encodings/runend/benches/run_end_decode.rs b/encodings/runend/benches/run_end_decode.rs
new file mode 100644
index 00000000000..b2ee2aaf3ab
--- /dev/null
+++ b/encodings/runend/benches/run_end_decode.rs
@@ -0,0 +1,378 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used, clippy::cast_possible_truncation)]
+
+use std::fmt;
+
+use divan::Bencher;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::validity::Validity;
+use vortex_buffer::BitBuffer;
+use vortex_buffer::BufferMut;
+use vortex_runend::decompress_bool::runend_decode_bools;
+
+fn main() {
+    divan::main();
+}
+
+/// Distribution types for bool benchmarks
+#[derive(Clone, Copy)]
+enum BoolDistribution {
+    /// Alternating true/false (50/50)
+    Alternating,
+    /// Mostly true (90% true runs)
+    MostlyTrue,
+    /// Mostly false (90% false runs)
+    MostlyFalse,
+    /// All true
+    AllTrue,
+    /// All false
+    AllFalse,
+}
+
+impl fmt::Display for BoolDistribution {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BoolDistribution::Alternating => write!(f, "alternating"),
+            BoolDistribution::MostlyTrue => write!(f, "mostly_true"),
+            BoolDistribution::MostlyFalse => write!(f, "mostly_false"),
+            BoolDistribution::AllTrue => write!(f, "all_true"),
+            BoolDistribution::AllFalse => write!(f, "all_false"),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct BoolBenchArgs {
+    total_length: usize,
+    avg_run_length: usize,
+    distribution: BoolDistribution,
+}
+
+impl fmt::Display for BoolBenchArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}_{}_{}",
+            self.total_length, self.avg_run_length, self.distribution
+        )
+    }
+}
+
+/// Creates bool test data with configurable distribution
+fn create_bool_test_data(
+    total_length: usize,
+    avg_run_length: usize,
+    distribution: BoolDistribution,
+) -> (PrimitiveArray, BoolArray) {
+    let mut ends = BufferMut::<u32>::with_capacity(total_length / avg_run_length + 1);
+    let mut values = Vec::with_capacity(total_length / avg_run_length + 1);
+
+    let mut pos = 0usize;
+    let mut run_index = 0usize;
+
+    while pos < total_length {
+        let run_len = avg_run_length.min(total_length - pos);
+        pos += run_len;
+        ends.push(pos as u32);
+
+        let val = match distribution {
+            BoolDistribution::Alternating => run_index.is_multiple_of(2),
+            BoolDistribution::MostlyTrue => !run_index.is_multiple_of(10), // 90% true
+            BoolDistribution::MostlyFalse => run_index.is_multiple_of(10), // 10% true (90% false)
+            BoolDistribution::AllTrue => true,
+            BoolDistribution::AllFalse => false,
+        };
+        values.push(val);
+        run_index += 1;
+    }
+
+    (
+        PrimitiveArray::new(ends.freeze(), Validity::NonNullable),
+        BoolArray::from(BitBuffer::from(values)),
+    )
+}
+
+// Medium size: 10k elements with various run lengths and distributions
+const BOOL_ARGS: &[BoolBenchArgs] = &[
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::Alternating,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::Alternating,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::Alternating,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::Alternating,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::MostlyTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::MostlyTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::MostlyTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::MostlyTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::MostlyFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::MostlyFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::MostlyFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::MostlyFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::AllTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::AllTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::AllTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::AllTrue,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::AllFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::AllFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::AllFalse,
+    },
+    BoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::AllFalse,
+    },
+];
+
+#[divan::bench(args = BOOL_ARGS)]
+fn decode_bool(bencher: Bencher, args: BoolBenchArgs) {
+    let BoolBenchArgs {
+        total_length,
+        avg_run_length,
+        distribution,
+    } = args;
+    let (ends, values) = create_bool_test_data(total_length, avg_run_length, distribution);
+    bencher
+        .with_inputs(|| (ends.clone(), values.clone()))
+        .bench_refs(|(ends, values)| {
+            runend_decode_bools(ends.clone(), values.clone(), 0, total_length)
+        });
+}
+
+/// Validity distribution for nullable benchmarks
+#[derive(Clone, Copy)]
+enum ValidityDistribution {
+    /// 90% valid
+    MostlyValid,
+    /// 50% valid
+    HalfValid,
+    /// 10% valid
+    MostlyNull,
+}
+
+impl fmt::Display for ValidityDistribution {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ValidityDistribution::MostlyValid => write!(f, "mostly_valid"),
+            ValidityDistribution::HalfValid => write!(f, "half_valid"),
+            ValidityDistribution::MostlyNull => write!(f, "mostly_null"),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+struct NullableBoolBenchArgs {
+    total_length: usize,
+    avg_run_length: usize,
+    distribution: BoolDistribution,
+    validity: ValidityDistribution,
+}
+
+impl fmt::Display for NullableBoolBenchArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}_{}_{}_{}",
+            self.total_length, self.avg_run_length, self.distribution, self.validity
+        )
+    }
+}
+
+/// Creates nullable bool test data with configurable distribution and validity
+fn create_nullable_bool_test_data(
+    total_length: usize,
+    avg_run_length: usize,
+    distribution: BoolDistribution,
+    validity: ValidityDistribution,
+) -> (PrimitiveArray, BoolArray) {
+    let mut ends = BufferMut::<u32>::with_capacity(total_length / avg_run_length + 1);
+    let mut values = Vec::with_capacity(total_length / avg_run_length + 1);
+    let mut validity_bits = Vec::with_capacity(total_length / avg_run_length + 1);
+
+    let mut pos = 0usize;
+    let mut run_index = 0usize;
+
+    while pos < total_length {
+        let run_len = avg_run_length.min(total_length - pos);
+        pos += run_len;
+        ends.push(pos as u32);
+
+        let val = match distribution {
+            BoolDistribution::Alternating => run_index.is_multiple_of(2),
+            BoolDistribution::MostlyTrue => !run_index.is_multiple_of(10),
+            BoolDistribution::MostlyFalse => run_index.is_multiple_of(10),
+            BoolDistribution::AllTrue => true,
+            BoolDistribution::AllFalse => false,
+        };
+        values.push(val);
+
+        let is_valid = match validity {
+            ValidityDistribution::MostlyValid => !run_index.is_multiple_of(10),
+            ValidityDistribution::HalfValid => run_index.is_multiple_of(2),
+            ValidityDistribution::MostlyNull => run_index.is_multiple_of(10),
+        };
+        validity_bits.push(is_valid);
+
+        run_index += 1;
+    }
+
+    (
+        PrimitiveArray::new(ends.freeze(), Validity::NonNullable),
+        BoolArray::new(
+            BitBuffer::from(values),
+            Validity::from(BitBuffer::from(validity_bits)),
+        ),
+    )
+}
+
+const NULLABLE_BOOL_ARGS: &[NullableBoolBenchArgs] = &[
+    // Alternating with different validity
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::MostlyValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::HalfValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::MostlyNull,
+    },
+    // MostlyTrue with different validity
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::MostlyTrue,
+        validity: ValidityDistribution::MostlyValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::MostlyTrue,
+        validity: ValidityDistribution::HalfValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 10,
+        distribution: BoolDistribution::MostlyTrue,
+        validity: ValidityDistribution::MostlyNull,
+    },
+    // Different run lengths with MostlyValid
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 2,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::MostlyValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 100,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::MostlyValid,
+    },
+    NullableBoolBenchArgs {
+        total_length: 10_000,
+        avg_run_length: 1000,
+        distribution: BoolDistribution::Alternating,
+        validity: ValidityDistribution::MostlyValid,
+    },
+];
+
+#[divan::bench(args = NULLABLE_BOOL_ARGS)]
+fn decode_bool_nullable(bencher: Bencher, args: NullableBoolBenchArgs) {
+    let NullableBoolBenchArgs {
+        total_length,
+        avg_run_length,
+        distribution,
+        validity,
+    } = args;
+    let (ends, values) =
+        create_nullable_bool_test_data(total_length, avg_run_length, distribution, validity);
+    bencher
+        .with_inputs(|| (ends.clone(), values.clone()))
+        .bench_refs(|(ends, values)| {
+            runend_decode_bools(ends.clone(), values.clone(), 0, total_length)
+        });
+}
diff --git a/encodings/runend/benches/run_end_null_count.rs b/encodings/runend/benches/run_end_null_count.rs
index d5613b01c18..e101abf6799 100644
--- a/encodings/runend/benches/run_end_null_count.rs
+++ b/encodings/runend/benches/run_end_null_count.rs
@@ -4,18 +4,16 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
-use vortex_array::Array;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::compute::warm_up_vtables;
 use vortex_buffer::Buffer;
+use vortex_runend::RunEnd;
 use vortex_runend::RunEndArray;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -70,5 +68,5 @@ fn fixture(n: usize, run_step: usize, valid_density: f64) -> RunEndArray {
     )
     .into_array();
 
-    RunEndArray::new(ends, values)
+    RunEnd::new(ends, values)
 }
diff --git a/encodings/runend/public-api.lock b/encodings/runend/public-api.lock
index e06d43ff10c..c746d4f54a4 100644
--- a/encodings/runend/public-api.lock
+++ b/encodings/runend/public-api.lock
@@ -2,214 +2,204 @@ pub mod vortex_runend
 
 pub mod vortex_runend::compress
 
-pub fn vortex_runend::compress::runend_decode_bools(ends: vortex_array::arrays::primitive::array::PrimitiveArray, values: vortex_array::arrays::bool::array::BoolArray, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_array::arrays::bool::array::BoolArray>
+pub fn vortex_runend::compress::runend_decode_primitive(ends: vortex_array::arrays::primitive::vtable::PrimitiveArray, values: vortex_array::arrays::primitive::vtable::PrimitiveArray, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_array::arrays::primitive::vtable::PrimitiveArray>
 
-pub fn vortex_runend::compress::runend_decode_primitive(ends: vortex_array::arrays::primitive::array::PrimitiveArray, values: vortex_array::arrays::primitive::array::PrimitiveArray, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_array::arrays::primitive::array::PrimitiveArray>
+pub fn vortex_runend::compress::runend_decode_typed_primitive<T: vortex_array::dtype::ptype::NativePType>(run_ends: impl core::iter::traits::iterator::Iterator<Item = usize>, values: &[T], values_validity: vortex_mask::Mask, values_nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_array::arrays::primitive::vtable::PrimitiveArray
 
-pub fn vortex_runend::compress::runend_decode_typed_bool(run_ends: impl core::iter::traits::iterator::Iterator<Item = usize>, values: &vortex_buffer::bit::buf::BitBuffer, values_validity: vortex_mask::Mask, values_nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_array::arrays::bool::array::BoolArray
+pub fn vortex_runend::compress::runend_decode_varbinview(ends: vortex_array::arrays::primitive::vtable::PrimitiveArray, values: vortex_array::arrays::varbinview::vtable::VarBinViewArray, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_array::arrays::varbinview::vtable::VarBinViewArray>
 
-pub fn vortex_runend::compress::runend_decode_typed_primitive<T: vortex_array::dtype::ptype::NativePType>(run_ends: impl core::iter::traits::iterator::Iterator<Item = usize>, values: &[T], values_validity: vortex_mask::Mask, values_nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_array::arrays::primitive::array::PrimitiveArray
+pub fn vortex_runend::compress::runend_encode(array: vortex_array::array::view::ArrayView<'_, vortex_array::arrays::primitive::vtable::Primitive>) -> (vortex_array::arrays::primitive::vtable::PrimitiveArray, vortex_array::array::erased::ArrayRef)
 
-pub fn vortex_runend::compress::runend_encode(array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> (vortex_array::arrays::primitive::array::PrimitiveArray, vortex_array::array::ArrayRef)
+pub mod vortex_runend::decompress_bool
 
-pub struct vortex_runend::RunEndArray
+pub fn vortex_runend::decompress_bool::runend_decode_bools(ends: vortex_array::arrays::primitive::vtable::PrimitiveArray, values: vortex_array::arrays::bool::vtable::BoolArray, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-impl vortex_runend::RunEndArray
+pub fn vortex_runend::decompress_bool::runend_decode_typed_bool(run_ends: impl core::iter::traits::iterator::Iterator<Item = usize>, values: &vortex_buffer::bit::buf::BitBuffer, values_validity: vortex_mask::Mask, values_nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_runend::RunEndArray::encode(array: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub struct vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndArray::ends(&self) -> &vortex_array::array::ArrayRef
+impl vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndArray::find_physical_index(&self, index: usize) -> vortex_error::VortexResult<usize>
+pub const vortex_runend::RunEnd::ID: vortex_array::array::ArrayId
 
-pub fn vortex_runend::RunEndArray::into_parts(self) -> vortex_runend::RunEndArrayParts
+pub fn vortex_runend::RunEnd::encode(array: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_runend::RunEndArray>
 
-pub fn vortex_runend::RunEndArray::new(ends: vortex_array::array::ArrayRef, values: vortex_array::array::ArrayRef) -> Self
+pub fn vortex_runend::RunEnd::new(ends: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef) -> vortex_runend::RunEndArray
 
-pub unsafe fn vortex_runend::RunEndArray::new_unchecked(ends: vortex_array::array::ArrayRef, values: vortex_array::array::ArrayRef, offset: usize, length: usize) -> Self
+pub unsafe fn vortex_runend::RunEnd::new_unchecked(ends: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef, offset: usize, length: usize) -> vortex_runend::RunEndArray
 
-pub fn vortex_runend::RunEndArray::offset(&self) -> usize
+pub fn vortex_runend::RunEnd::try_new(ends: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_runend::RunEndArray>
 
-pub fn vortex_runend::RunEndArray::try_new(ends: vortex_array::array::ArrayRef, values: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_runend::RunEnd::try_new_offset_length(ends: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef, offset: usize, length: usize) -> vortex_error::VortexResult<vortex_runend::RunEndArray>
 
-pub fn vortex_runend::RunEndArray::try_new_offset_length(ends: vortex_array::array::ArrayRef, values: vortex_array::array::ArrayRef, offset: usize, length: usize) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndArray::values(&self) -> &vortex_array::array::ArrayRef
+pub fn vortex_runend::RunEnd::clone(&self) -> vortex_runend::RunEnd
 
-impl core::clone::Clone for vortex_runend::RunEndArray
+impl core::fmt::Debug for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndArray::clone(&self) -> vortex_runend::RunEndArray
+pub fn vortex_runend::RunEnd::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_runend::RunEndArray
+impl vortex_array::array::vtable::VTable for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_runend::RunEnd::ArrayData = vortex_runend::RunEndData
 
-impl core::convert::From<vortex_runend::RunEndArray> for vortex_array::array::ArrayRef
+pub type vortex_runend::RunEnd::OperationsVTable = vortex_runend::RunEnd
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_runend::RunEndArray) -> vortex_array::array::ArrayRef
+pub type vortex_runend::RunEnd::ValidityVTable = vortex_runend::RunEnd
 
-impl core::fmt::Debug for vortex_runend::RunEndArray
+pub fn vortex_runend::RunEnd::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_runend::RunEndArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_runend::RunEnd::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::ops::deref::Deref for vortex_runend::RunEndArray
+pub fn vortex_runend::RunEnd::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_runend::RunEndArray::Target = dyn vortex_array::array::Array
+pub fn vortex_runend::RunEnd::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_runend::RunEndArray::deref(&self) -> &Self::Target
+pub fn vortex_runend::RunEnd::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_runend::RunEndArray
+pub fn vortex_runend::RunEnd::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_runend::RunEndArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_runend::RunEnd::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl<R: arrow_array::types::RunEndIndexType> vortex_array::arrow::FromArrowArray<&arrow_array::array::run_array::RunArray<R>> for vortex_runend::RunEndArray where <R as arrow_array::types::ArrowPrimitiveType>::Native: vortex_array::dtype::ptype::NativePType
+pub fn vortex_runend::RunEnd::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_runend::RunEndArray::from_arrow(array: &arrow_array::array::run_array::RunArray<R>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_runend::RunEnd::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_runend::RunEndArrayParts
+pub fn vortex_runend::RunEnd::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_runend::RunEndArrayParts::ends: vortex_array::array::ArrayRef
+pub fn vortex_runend::RunEnd::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_runend::RunEndArrayParts::values: vortex_array::array::ArrayRef
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_runend::RunEnd> for vortex_runend::RunEnd
 
-pub struct vortex_runend::RunEndMetadata
-
-pub vortex_runend::RunEndMetadata::ends_ptype: i32
-
-pub vortex_runend::RunEndMetadata::num_runs: u64
+pub fn vortex_runend::RunEnd::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_runend::RunEnd>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_runend::RunEndMetadata::offset: u64
-
-impl vortex_runend::RunEndMetadata
-
-pub fn vortex_runend::RunEndMetadata::ends_ptype(&self) -> vortex_array::dtype::ptype::PType
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_runend::RunEnd> for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndMetadata::set_ends_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
+pub fn vortex_runend::RunEnd::validity(array: vortex_array::array::view::ArrayView<'_, vortex_runend::RunEnd>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::clone::Clone for vortex_runend::RunEndMetadata
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndMetadata::clone(&self) -> vortex_runend::RunEndMetadata
+pub fn vortex_runend::RunEnd::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::default::Default for vortex_runend::RunEndMetadata
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndMetadata::default() -> Self
+pub fn vortex_runend::RunEnd::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl core::fmt::Debug for vortex_runend::RunEndMetadata
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_runend::RunEnd::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl prost::message::Message for vortex_runend::RunEndMetadata
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_runend::RunEnd
 
-pub fn vortex_runend::RunEndMetadata::clear(&mut self)
+pub fn vortex_runend::RunEnd::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_runend::RunEndMetadata::encoded_len(&self) -> usize
+impl vortex_array::scalar_fn::fns::fill_null::kernel::FillNullReduce for vortex_runend::RunEnd
 
-pub struct vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEnd::fill_null(array: vortex_array::array::view::ArrayView<'_, Self>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_runend::RunEndVTable
+pub struct vortex_runend::RunEndData
 
-pub const vortex_runend::RunEndVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_runend::RunEndData
 
-impl core::fmt::Debug for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndData::encode(array: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_runend::RunEndVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_runend::RunEndData::into_parts(self, ends: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef) -> vortex_runend::RunEndDataParts
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndData::new(offset: usize) -> Self
 
-pub fn vortex_runend::RunEndVTable::take(array: &vortex_runend::RunEndArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub unsafe fn vortex_runend::RunEndData::new_unchecked(offset: usize) -> Self
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_runend::RunEndVTable
+impl core::clone::Clone for vortex_runend::RunEndData
 
-pub fn vortex_runend::RunEndVTable::filter(array: &vortex_runend::RunEndArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_runend::RunEndData::clone(&self) -> vortex_runend::RunEndData
 
-impl vortex_array::compute::is_constant::IsConstantKernel for vortex_runend::RunEndVTable
+impl core::fmt::Debug for vortex_runend::RunEndData
 
-pub fn vortex_runend::RunEndVTable::is_constant(&self, array: &Self::Array, opts: &vortex_array::compute::is_constant::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_runend::RunEndData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::is_sorted::IsSortedKernel for vortex_runend::RunEndVTable
+impl core::fmt::Display for vortex_runend::RunEndData
 
-pub fn vortex_runend::RunEndVTable::is_sorted(&self, array: &vortex_runend::RunEndArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_runend::RunEndData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_runend::RunEndVTable::is_strict_sorted(&self, array: &vortex_runend::RunEndArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::hash::ArrayEq for vortex_runend::RunEndData
 
-impl vortex_array::compute::min_max::MinMaxKernel for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_runend::RunEndVTable::min_max(&self, array: &vortex_runend::RunEndArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::min_max::MinMaxResult>>
+impl vortex_array::hash::ArrayHash for vortex_runend::RunEndData
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_runend::RunEndVTable::compare(lhs: &vortex_runend::RunEndArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl<R: arrow_array::types::RunEndIndexType> vortex_array::arrow::FromArrowArray<&arrow_array::array::run_array::RunArray<R>> for vortex_runend::RunEndData where <R as arrow_array::types::ArrowPrimitiveType>::Native: vortex_array::dtype::ptype::NativePType
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndData::from_arrow(array: &arrow_array::array::run_array::RunArray<R>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_runend::RunEndVTable::cast(array: &vortex_runend::RunEndArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_runend::RunEndDataParts
 
-impl vortex_array::scalar_fn::fns::fill_null::kernel::FillNullReduce for vortex_runend::RunEndVTable
+pub vortex_runend::RunEndDataParts::ends: vortex_array::array::erased::ArrayRef
 
-pub fn vortex_runend::RunEndVTable::fill_null(array: &vortex_runend::RunEndArray, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_runend::RunEndDataParts::offset: usize
 
-impl vortex_array::vtable::VTable for vortex_runend::RunEndVTable
+pub vortex_runend::RunEndDataParts::values: vortex_array::array::erased::ArrayRef
 
-pub type vortex_runend::RunEndVTable::Array = vortex_runend::RunEndArray
-
-pub type vortex_runend::RunEndVTable::ArrayVTable = vortex_runend::RunEndVTable
-
-pub type vortex_runend::RunEndVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_runend::RunEndMetadata>
+pub struct vortex_runend::RunEndMetadata
 
-pub type vortex_runend::RunEndVTable::OperationsVTable = vortex_runend::RunEndVTable
+pub vortex_runend::RunEndMetadata::ends_ptype: i32
 
-pub type vortex_runend::RunEndVTable::ValidityVTable = vortex_runend::RunEndVTable
+pub vortex_runend::RunEndMetadata::num_runs: u64
 
-pub type vortex_runend::RunEndVTable::VisitorVTable = vortex_runend::RunEndVTable
+pub vortex_runend::RunEndMetadata::offset: u64
 
-pub fn vortex_runend::RunEndVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_runend::RunEndArray>
+impl vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_runend::RunEndMetadata::ends_ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_runend::RunEndVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_runend::RunEndMetadata::set_ends_ptype(&mut self, value: vortex_array::dtype::ptype::PType)
 
-pub fn vortex_runend::RunEndVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_runend::RunEndMetadata::clone(&self) -> vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::metadata(array: &vortex_runend::RunEndArray) -> vortex_error::VortexResult<Self::Metadata>
+impl core::default::Default for vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_runend::RunEndMetadata::default() -> Self
 
-pub fn vortex_runend::RunEndVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::fmt::Debug for vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_runend::RunEndMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_runend::RunEndVTable> for vortex_runend::RunEndVTable
+impl prost::message::Message for vortex_runend::RunEndMetadata
 
-pub fn vortex_runend::RunEndVTable::array_eq(array: &vortex_runend::RunEndArray, other: &vortex_runend::RunEndArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_runend::RunEndMetadata::clear(&mut self)
 
-pub fn vortex_runend::RunEndVTable::array_hash<H: core::hash::Hasher>(array: &vortex_runend::RunEndArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_runend::RunEndMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_runend::RunEndVTable::dtype(array: &vortex_runend::RunEndArray) -> &vortex_array::dtype::DType
+pub trait vortex_runend::RunEndArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_runend::RunEnd>
 
-pub fn vortex_runend::RunEndVTable::len(array: &vortex_runend::RunEndArray) -> usize
+pub fn vortex_runend::RunEndArrayExt::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_runend::RunEndVTable::stats(array: &vortex_runend::RunEndArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_runend::RunEndArrayExt::ends(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_runend::RunEndVTable> for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndArrayExt::find_physical_index(&self, index: usize) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_runend::RunEndVTable::scalar_at(array: &vortex_runend::RunEndArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_runend::RunEndArrayExt::offset(&self) -> usize
 
-impl vortex_array::vtable::validity::ValidityVTable<vortex_runend::RunEndVTable> for vortex_runend::RunEndVTable
+pub fn vortex_runend::RunEndArrayExt::values(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_runend::RunEndVTable::validity(array: &vortex_runend::RunEndArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_runend::RunEnd>> vortex_runend::RunEndArrayExt for T
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_runend::RunEndVTable> for vortex_runend::RunEndVTable
+pub fn T::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_runend::RunEndVTable::nbuffers(_array: &vortex_runend::RunEndArray) -> usize
+pub fn T::ends(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_runend::RunEndVTable::nchildren(_array: &vortex_runend::RunEndArray) -> usize
+pub fn T::find_physical_index(&self, index: usize) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_runend::RunEndVTable::visit_buffers(_array: &vortex_runend::RunEndArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn T::offset(&self) -> usize
 
-pub fn vortex_runend::RunEndVTable::visit_children(array: &vortex_runend::RunEndArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub fn T::values(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_runend::initialize(session: &mut vortex_session::VortexSession)
+pub fn vortex_runend::initialize(session: &vortex_session::VortexSession)
 
 pub fn vortex_runend::trimmed_ends_iter<E: vortex_array::dtype::ptype::IntegerPType>(run_ends: &[E], offset: usize, length: usize) -> impl core::iter::traits::iterator::Iterator<Item = usize> + use<'_, E>
+
+pub type vortex_runend::RunEndArray = vortex_array::array::typed::Array<vortex_runend::RunEnd>
diff --git a/encodings/runend/src/arbitrary.rs b/encodings/runend/src/arbitrary.rs
index cb561e7a20e..5347935c578 100644
--- a/encodings/runend/src/arbitrary.rs
+++ b/encodings/runend/src/arbitrary.rs
@@ -14,6 +14,7 @@ use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 
+use crate::RunEnd;
 use crate::RunEndArray;
 
 /// A wrapper type to implement `Arbitrary` for `RunEndArray`.
@@ -22,8 +23,7 @@ pub struct ArbitraryRunEndArray(pub RunEndArray);
 
 impl<'a> Arbitrary<'a> for ArbitraryRunEndArray {
     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
-        // RunEnd supports Bool or Primitive types for values
-        // Pick a random primitive type for values
+        // Pick a random primitive type for values.
         let ptype: PType = u.arbitrary()?;
         let nullability: Nullability = u.arbitrary()?;
         let dtype = DType::Primitive(ptype, nullability);
@@ -43,7 +43,7 @@ impl ArbitraryRunEndArray {
             // Empty RunEndArray
             let ends = PrimitiveArray::from_iter(Vec::<u64>::new()).into_array();
             let values = ArbitraryArray::arbitrary_with(u, Some(0), dtype)?.0;
-            let runend_array = RunEndArray::try_new(ends, values)
+            let runend_array = RunEnd::try_new(ends, values)
                 .vortex_expect("Empty RunEndArray creation should succeed");
             return Ok(ArbitraryRunEndArray(runend_array));
         }
@@ -55,7 +55,7 @@ impl ArbitraryRunEndArray {
         // Each end must be > previous end, and first end must be >= 1
         let ends = random_strictly_sorted_ends(u, num_runs, len)?;
 
-        let runend_array = RunEndArray::try_new(ends, values)
+        let runend_array = RunEnd::try_new(ends, values)
             .vortex_expect("RunEndArray creation should succeed in arbitrary impl");
 
         Ok(ArbitraryRunEndArray(runend_array))
diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs
index ac75776ea78..f714d09fc70 100644
--- a/encodings/runend/src/array.rs
+++ b/encodings/runend/src/array.rs
@@ -2,19 +2,26 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
+use prost::Message;
 use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
-use vortex_array::arrays::PrimitiveVTable;
+use vortex_array::TypedArrayRef;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::VarBinViewArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
@@ -23,12 +30,7 @@ use vortex_array::scalar::PValue;
 use vortex_array::search_sorted::SearchSorted;
 use vortex_array::search_sorted::SearchSortedSide;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
 use vortex_error::VortexExpect as _;
@@ -38,13 +40,15 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::compress::runend_decode_bools;
 use crate::compress::runend_decode_primitive;
+use crate::compress::runend_decode_varbinview;
 use crate::compress::runend_encode;
+use crate::decompress_bool::runend_decode_bools;
 use crate::kernel::PARENT_KERNELS;
 use crate::rules::RULES;
 
-vtable!(RunEnd);
+/// A [`RunEnd`]-encoded Vortex array.
+pub type RunEndArray = Array<RunEnd>;
 
 #[derive(Clone, prost::Message)]
 pub struct RunEndMetadata {
@@ -56,81 +60,105 @@ pub struct RunEndMetadata {
     pub offset: u64,
 }
 
-impl VTable for RunEndVTable {
-    type Array = RunEndArray;
+impl ArrayHash for RunEndData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.offset.hash(state);
+    }
+}
+
+impl ArrayEq for RunEndData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.offset == other.offset
+    }
+}
 
-    type Metadata = ProstMetadata<RunEndMetadata>;
+impl VTable for RunEnd {
+    type ArrayData = RunEndData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &RunEndArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(RunEndMetadata {
-            ends_ptype: PType::try_from(array.ends().dtype()).vortex_expect("Must be a valid PType")
-                as i32,
-            num_runs: array.ends().len() as u64,
-            offset: array.offset() as u64,
-        }))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let ends = slots[ENDS_SLOT]
+            .as_ref()
+            .vortex_expect("RunEndArray ends slot");
+        let values = slots[VALUES_SLOT]
+            .as_ref()
+            .vortex_expect("RunEndArray values slot");
+        RunEndData::validate_parts(ends, values, data.offset, len)?;
+        vortex_ensure!(
+            values.dtype() == dtype,
+            "expected dtype {}, got {}",
+            dtype,
+            values.dtype()
+        );
+        Ok(())
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("RunEndArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("RunEndArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let inner = <ProstMetadata<RunEndMetadata> as DeserializeMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(inner))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            RunEndMetadata {
+                ends_ptype: PType::try_from(array.ends().dtype())
+                    .vortex_expect("Must be a valid PType") as i32,
+                num_runs: array.ends().len() as u64,
+                offset: array.offset() as u64,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<RunEndArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = RunEndMetadata::decode(metadata)?;
         let ends_dtype = DType::Primitive(metadata.ends_ptype(), Nullability::NonNullable);
         let runs = usize::try_from(metadata.num_runs).vortex_expect("Must be a valid usize");
         let ends = children.get(0, &ends_dtype, runs)?;
 
         let values = children.get(1, dtype, runs)?;
-
-        RunEndArray::try_new_offset_length(
-            ends,
-            values,
-            usize::try_from(metadata.offset).vortex_expect("Offset must be a valid usize"),
-            len,
-        )
+        let offset = usize::try_from(metadata.offset).vortex_expect("Offset must be a valid usize");
+        let slots = vec![Some(ends), Some(values)];
+        let data = RunEndData::new(offset);
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 2,
-            "RunEndArray expects 2 children, got {}",
-            children.len()
-        );
-
-        let mut children_iter = children.into_iter();
-        array.ends = children_iter.next().vortex_expect("ends child");
-        array.values = children_iter.next().vortex_expect("values child");
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -138,7 +166,7 @@ impl VTable for RunEndVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -146,36 +174,152 @@ impl VTable for RunEndVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        run_end_canonicalize(array, ctx)
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        run_end_canonicalize(&array, ctx).map(ExecutionResult::done)
     }
 }
 
+/// The run-end positions marking where each run terminates.
+pub(super) const ENDS_SLOT: usize = 0;
+/// The values for each run.
+pub(super) const VALUES_SLOT: usize = 1;
+pub(super) const NUM_SLOTS: usize = 2;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["ends", "values"];
+
 #[derive(Clone, Debug)]
-pub struct RunEndArray {
-    ends: ArrayRef,
-    values: ArrayRef,
+pub struct RunEndData {
     offset: usize,
-    length: usize,
-    stats_set: ArrayStats,
 }
 
-pub struct RunEndArrayParts {
+impl Display for RunEndData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "offset: {}", self.offset)
+    }
+}
+
+pub struct RunEndDataParts {
     pub ends: ArrayRef,
     pub values: ArrayRef,
+    pub offset: usize,
+}
+
+pub trait RunEndArrayExt: TypedArrayRef<RunEnd> {
+    fn offset(&self) -> usize {
+        self.offset
+    }
+
+    fn ends(&self) -> &ArrayRef {
+        self.as_ref().slots()[ENDS_SLOT]
+            .as_ref()
+            .vortex_expect("RunEndArray ends slot")
+    }
+
+    fn values(&self) -> &ArrayRef {
+        self.as_ref().slots()[VALUES_SLOT]
+            .as_ref()
+            .vortex_expect("RunEndArray values slot")
+    }
+
+    fn dtype(&self) -> &DType {
+        self.values().dtype()
+    }
+
+    fn find_physical_index(&self, index: usize) -> VortexResult<usize> {
+        Ok(self
+            .ends()
+            .as_primitive_typed()
+            .search_sorted(
+                &PValue::from(index + self.offset()),
+                SearchSortedSide::Right,
+            )?
+            .to_ends_index(self.ends().len()))
+    }
 }
+impl<T: TypedArrayRef<RunEnd>> RunEndArrayExt for T {}
 
-#[derive(Debug)]
-pub struct RunEndVTable;
+#[derive(Clone, Debug)]
+pub struct RunEnd;
 
-impl RunEndVTable {
+impl RunEnd {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.runend");
+
+    /// Build a new [`RunEndArray`] without validation.
+    ///
+    /// # Safety
+    /// See [`RunEndData::new_unchecked`] for preconditions.
+    pub unsafe fn new_unchecked(
+        ends: ArrayRef,
+        values: ArrayRef,
+        offset: usize,
+        length: usize,
+    ) -> RunEndArray {
+        let dtype = values.dtype().clone();
+        let slots = vec![Some(ends.clone()), Some(values.clone())];
+        RunEndData::validate_parts(&ends, &values, offset, length)
+            .vortex_expect("RunEndArray validation failed");
+        let data = unsafe { RunEndData::new_unchecked(offset) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(RunEnd, dtype, length, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Build a new [`RunEndArray`] from ends and values.
+    pub fn try_new(ends: ArrayRef, values: ArrayRef) -> VortexResult<RunEndArray> {
+        let len = RunEndData::logical_len_from_ends(&ends)?;
+        let dtype = values.dtype().clone();
+        let slots = vec![Some(ends), Some(values)];
+        let data = RunEndData::new(0);
+        Array::try_from_parts(ArrayParts::new(RunEnd, dtype, len, data).with_slots(slots))
+    }
+
+    /// Build a new [`RunEndArray`] from ends, values, offset, and length.
+    pub fn try_new_offset_length(
+        ends: ArrayRef,
+        values: ArrayRef,
+        offset: usize,
+        length: usize,
+    ) -> VortexResult<RunEndArray> {
+        let dtype = values.dtype().clone();
+        let slots = vec![Some(ends), Some(values)];
+        let data = RunEndData::new(offset);
+        Array::try_from_parts(ArrayParts::new(RunEnd, dtype, length, data).with_slots(slots))
+    }
+
+    /// Build a new [`RunEndArray`] from ends and values (panics on invalid input).
+    pub fn new(ends: ArrayRef, values: ArrayRef) -> RunEndArray {
+        Self::try_new(ends, values).vortex_expect("RunEndData is always valid")
+    }
+
+    /// Run the array through run-end encoding.
+    pub fn encode(array: ArrayRef) -> VortexResult<RunEndArray> {
+        if let Some(parray) = array.as_opt::<Primitive>() {
+            let (ends, values) = runend_encode(parray);
+            let ends = ends.into_array();
+            let len = array.len();
+            let dtype = values.dtype().clone();
+            let slots = vec![Some(ends), Some(values)];
+            let data = unsafe { RunEndData::new_unchecked(0) };
+            Array::try_from_parts(ArrayParts::new(RunEnd, dtype, len, data).with_slots(slots))
+        } else {
+            vortex_bail!("REE can only encode primitive arrays")
+        }
+    }
 }
 
-impl RunEndArray {
-    fn validate(
-        ends: &dyn Array,
-        values: &dyn Array,
+impl RunEndData {
+    fn logical_len_from_ends(ends: &ArrayRef) -> VortexResult<usize> {
+        if ends.is_empty() {
+            Ok(0)
+        } else {
+            usize::try_from(&ends.scalar_at(ends.len() - 1)?)
+        }
+    }
+
+    pub(crate) fn validate_parts(
+        ends: &ArrayRef,
+        values: &ArrayRef,
         offset: usize,
         length: usize,
     ) -> VortexResult<()> {
@@ -185,12 +329,6 @@ impl RunEndArray {
             "run ends must be unsigned integers, was {}",
             ends.dtype(),
         );
-        vortex_ensure!(
-            values.dtype().is_primitive() || values.dtype().is_boolean(),
-            "RunEnd array can only have Bool or Primitive values, {} given",
-            values.dtype()
-        );
-
         vortex_ensure!(
             ends.len() == values.len(),
             "run ends len != run values len, {} != {}",
@@ -207,12 +345,8 @@ impl RunEndArray {
             return Ok(());
         }
 
-        // Avoid building a non-empty array with zero logical length.
+        // Zero-length logical slices may retain run metadata from the source array.
         if length == 0 {
-            vortex_ensure!(
-                ends.is_empty(),
-                "run ends must be empty when length is zero"
-            );
             return Ok(());
         }
 
@@ -239,8 +373,8 @@ impl RunEndArray {
         // Validate the offset and length are valid for the given ends and values
         if offset != 0 && length != 0 {
             let first_run_end = usize::try_from(&ends.scalar_at(0)?)?;
-            if first_run_end <= offset {
-                vortex_bail!("First run end {first_run_end} must be bigger than offset {offset}");
+            if first_run_end < offset {
+                vortex_bail!("First run end {first_run_end} must be >= offset {offset}");
             }
         }
 
@@ -254,10 +388,10 @@ impl RunEndArray {
     }
 }
 
-impl RunEndArray {
+impl RunEndData {
     /// Build a new `RunEndArray` from an array of run `ends` and an array of `values`.
     ///
-    /// Panics if any of the validation conditions described in [`RunEndArray::try_new`] is
+    /// Panics if any of the validation conditions described in [`RunEnd::try_new`] is
     /// not satisfied.
     ///
     /// # Examples
@@ -267,11 +401,11 @@ impl RunEndArray {
     /// # use vortex_array::IntoArray;
     /// # use vortex_buffer::buffer;
     /// # use vortex_error::VortexResult;
-    /// # use vortex_runend::RunEndArray;
+    /// # use vortex_runend::RunEnd;
     /// # fn main() -> VortexResult<()> {
     /// let ends = buffer![2u8, 3u8].into_array();
     /// let values = BoolArray::from_iter([false, true]).into_array();
-    /// let run_end = RunEndArray::new(ends, values);
+    /// let run_end = RunEnd::new(ends, values);
     ///
     /// // Array encodes
     /// assert_eq!(run_end.scalar_at(0)?, false.into());
@@ -280,194 +414,50 @@ impl RunEndArray {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn new(ends: ArrayRef, values: ArrayRef) -> Self {
-        Self::try_new(ends, values).vortex_expect("RunEndArray new")
-    }
-
-    /// Build a new `RunEndArray` from components.
-    ///
-    /// # Validation
-    ///
-    /// The `ends` must be non-nullable unsigned integers. The values may be `Bool` or `Primitive`
-    /// types.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use vortex_array::arrays::{BoolArray, VarBinViewArray};
-    /// # use vortex_array::IntoArray;
-    /// # use vortex_buffer::buffer;
-    /// # use vortex_runend::RunEndArray;
-    ///
-    /// // Error to provide incorrectly-typed values!
-    /// let result = RunEndArray::try_new(
-    ///     buffer![1u8, 2u8].into_array(),
-    ///     VarBinViewArray::from_iter_str(["bad", "dtype"]).into_array(),
-    /// );
-    /// assert!(result.is_err());
-    ///
-    /// // This array is happy
-    /// let result = RunEndArray::try_new(
-    ///     buffer![1u8, 2u8].into_array(),
-    ///     BoolArray::from_iter([false, true]).into_array(),
-    /// );
-    ///
-    /// assert!(result.is_ok());
-    /// ```
-    pub fn try_new(ends: ArrayRef, values: ArrayRef) -> VortexResult<Self> {
-        let length: usize = if ends.is_empty() {
-            0
-        } else {
-            usize::try_from(&ends.scalar_at(ends.len() - 1)?)?
-        };
-
-        Self::try_new_offset_length(ends, values, 0, length)
-    }
-
-    /// Construct a new sliced `RunEndArray` with the provided offset and length.
-    ///
-    /// This performs all the same validation as [`RunEndArray::try_new`].
-    pub fn try_new_offset_length(
-        ends: ArrayRef,
-        values: ArrayRef,
-        offset: usize,
-        length: usize,
-    ) -> VortexResult<Self> {
-        Self::validate(&ends, &values, offset, length)?;
-
-        Ok(Self {
-            ends,
-            values,
-            offset,
-            length,
-            stats_set: Default::default(),
-        })
+    pub fn new(offset: usize) -> Self {
+        Self { offset }
     }
 
     /// Build a new `RunEndArray` without validation.
     ///
     /// # Safety
     ///
-    /// The caller must ensure that all the validation performed in [`RunEndArray::try_new`] is
+    /// The caller must ensure that all the validation performed in
+    /// [`RunEnd::try_new_offset_length`] is
     /// satisfied before calling this function.
     ///
-    /// See [`RunEndArray::try_new`] for the preconditions needed to build a new array.
-    pub unsafe fn new_unchecked(
-        ends: ArrayRef,
-        values: ArrayRef,
-        offset: usize,
-        length: usize,
-    ) -> Self {
-        Self {
-            ends,
-            values,
-            offset,
-            length,
-            stats_set: Default::default(),
-        }
-    }
-
-    /// Convert the given logical index to an index into the `values` array
-    pub fn find_physical_index(&self, index: usize) -> VortexResult<usize> {
-        Ok(self
-            .ends()
-            .as_primitive_typed()
-            .search_sorted(
-                &PValue::from(index + self.offset()),
-                SearchSortedSide::Right,
-            )?
-            .to_ends_index(self.ends().len()))
+    /// See [`RunEnd::try_new_offset_length`] for the preconditions needed to build a new array.
+    pub unsafe fn new_unchecked(offset: usize) -> Self {
+        Self { offset }
     }
 
     /// Run the array through run-end encoding.
     pub fn encode(array: ArrayRef) -> VortexResult<Self> {
-        if let Some(parray) = array.as_opt::<PrimitiveVTable>() {
-            let (ends, values) = runend_encode(parray);
+        if let Some(parray) = array.as_opt::<Primitive>() {
+            let (_ends, _values) = runend_encode(parray);
             // SAFETY: runend_encode handles this
-            unsafe {
-                Ok(Self::new_unchecked(
-                    ends.into_array(),
-                    values,
-                    0,
-                    array.len(),
-                ))
-            }
+            unsafe { Ok(Self::new_unchecked(0)) }
         } else {
             vortex_bail!("REE can only encode primitive arrays")
         }
     }
 
-    /// The offset that the `ends` is relative to.
-    ///
-    /// This is generally zero for a "new" array, and non-zero after a slicing operation.
-    #[inline]
-    pub fn offset(&self) -> usize {
-        self.offset
-    }
-
-    /// The encoded "ends" of value runs.
-    ///
-    /// The `i`-th element indicates that there is a run of the same value, beginning
-    /// at `ends[i]` (inclusive) and terminating at `ends[i+1]` (exclusive).
-    #[inline]
-    pub fn ends(&self) -> &ArrayRef {
-        &self.ends
-    }
-
-    /// The scalar values.
-    ///
-    /// The `i`-th element is the scalar value for the `i`-th repeated run. The run begins
-    /// at `ends[i]` (inclusive) and terminates at `ends[i+1]` (exclusive).
-    #[inline]
-    pub fn values(&self) -> &ArrayRef {
-        &self.values
-    }
-
-    /// Split an `RunEndArray` into parts.
-    #[inline]
-    pub fn into_parts(self) -> RunEndArrayParts {
-        RunEndArrayParts {
-            ends: self.ends,
-            values: self.values,
+    pub fn into_parts(self, ends: ArrayRef, values: ArrayRef) -> RunEndDataParts {
+        RunEndDataParts {
+            ends,
+            values,
+            offset: self.offset,
         }
     }
 }
 
-impl BaseArrayVTable<RunEndVTable> for RunEndVTable {
-    fn len(array: &RunEndArray) -> usize {
-        array.length
-    }
-
-    fn dtype(array: &RunEndArray) -> &DType {
-        array.values.dtype()
-    }
-
-    fn stats(array: &RunEndArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &RunEndArray, state: &mut H, precision: Precision) {
-        array.ends.array_hash(state, precision);
-        array.values.array_hash(state, precision);
-        array.offset.hash(state);
-        array.length.hash(state);
-    }
-
-    fn array_eq(array: &RunEndArray, other: &RunEndArray, precision: Precision) -> bool {
-        array.ends.array_eq(&other.ends, precision)
-            && array.values.array_eq(&other.values, precision)
-            && array.offset == other.offset
-            && array.length == other.length
-    }
-}
-
-impl ValidityVTable<RunEndVTable> for RunEndVTable {
-    fn validity(array: &RunEndArray) -> VortexResult<Validity> {
+impl ValidityVTable<RunEnd> for RunEnd {
+    fn validity(array: ArrayView<'_, RunEnd>) -> VortexResult<Validity> {
         Ok(match array.values().validity()? {
             Validity::NonNullable | Validity::AllValid => Validity::AllValid,
             Validity::AllInvalid => Validity::AllInvalid,
             Validity::Array(values_validity) => Validity::Array(unsafe {
-                RunEndArray::new_unchecked(
+                RunEnd::new_unchecked(
                     array.ends().clone(),
                     values_validity,
                     array.offset(),
@@ -484,33 +474,43 @@ pub(super) fn run_end_canonicalize(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let pends = array.ends().clone().execute_as("ends", ctx)?;
+
     Ok(match array.dtype() {
         DType::Bool(_) => {
             let bools = array.values().clone().execute_as("values", ctx)?;
-            runend_decode_bools(pends, bools, array.offset(), array.len())?.into_array()
+            runend_decode_bools(pends, bools, array.offset(), array.len())?
         }
         DType::Primitive(..) => {
             let pvalues = array.values().clone().execute_as("values", ctx)?;
             runend_decode_primitive(pends, pvalues, array.offset(), array.len())?.into_array()
         }
-        _ => vortex_panic!("Only Primitive and Bool values are supported"),
+        DType::Utf8(_) | DType::Binary(_) => {
+            let values = array
+                .values()
+                .clone()
+                .execute_as::<VarBinViewArray>("values", ctx)?;
+            runend_decode_varbinview(pends, values, array.offset(), array.len())?.into_array()
+        }
+        _ => vortex_bail!("Unsupported RunEnd value type: {}", array.dtype()),
     })
 }
 
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
+    use vortex_array::arrays::DictArray;
+    use vortex_array::arrays::VarBinViewArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_buffer::buffer;
 
-    use crate::RunEndArray;
+    use crate::RunEnd;
 
     #[test]
     fn test_runend_constructor() {
-        let arr = RunEndArray::new(
+        let arr = RunEnd::new(
             buffer![2u32, 5, 10].into_array(),
             buffer![1i32, 2, 3].into_array(),
         );
@@ -524,6 +524,34 @@ mod tests {
         // 2, 3, 4 => 2
         // 5, 6, 7, 8, 9 => 3
         let expected = buffer![1, 1, 2, 2, 2, 3, 3, 3, 3, 3].into_array();
-        assert_arrays_eq!(arr.to_array(), expected);
+        assert_arrays_eq!(arr.into_array(), expected);
+    }
+
+    #[test]
+    fn test_runend_utf8() {
+        let values = VarBinViewArray::from_iter_str(["a", "b", "c"]).into_array();
+        let arr = RunEnd::new(buffer![2u32, 5, 10].into_array(), values);
+        assert_eq!(arr.len(), 10);
+        assert_eq!(arr.dtype(), &DType::Utf8(Nullability::NonNullable));
+
+        let expected =
+            VarBinViewArray::from_iter_str(["a", "a", "b", "b", "b", "c", "c", "c", "c", "c"])
+                .into_array();
+        assert_arrays_eq!(arr.into_array(), expected);
+    }
+
+    #[test]
+    fn test_runend_dict() {
+        let dict_values = VarBinViewArray::from_iter_str(["x", "y", "z"]).into_array();
+        let dict_codes = buffer![0u32, 1, 2].into_array();
+        let dict = DictArray::try_new(dict_codes, dict_values).unwrap();
+
+        let arr = RunEnd::try_new(buffer![2u32, 5, 10].into_array(), dict.into_array()).unwrap();
+        assert_eq!(arr.len(), 10);
+
+        let expected =
+            VarBinViewArray::from_iter_str(["x", "x", "y", "y", "y", "z", "z", "z", "z", "z"])
+                .into_array();
+        assert_arrays_eq!(arr.into_array(), expected);
     }
 }
diff --git a/encodings/runend/src/arrow.rs b/encodings/runend/src/arrow.rs
index a9369ff309e..564c1d06cb2 100644
--- a/encodings/runend/src/arrow.rs
+++ b/encodings/runend/src/arrow.rs
@@ -6,6 +6,7 @@ use arrow_array::types::RunEndIndexType;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
 use vortex_array::arrow::FromArrowArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::scalar::PValue;
@@ -15,10 +16,9 @@ use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
+use crate::RunEndData;
 use crate::ops::find_slice_end_index;
-
-impl<R: RunEndIndexType> FromArrowArray<&RunArray<R>> for RunEndArray
+impl<R: RunEndIndexType> FromArrowArray<&RunArray<R>> for RunEndData
 where
     R::Native: NativePType,
 {
@@ -31,23 +31,30 @@ where
             .reinterpret_cast(R::Native::PTYPE.to_unsigned());
         let values = ArrayRef::from_arrow(array.values().as_ref(), nullable)?;
 
+        let ends_array = PrimitiveArray::from_buffer_handle(
+            ends.buffer_handle().clone(),
+            ends.ptype(),
+            ends.validity()?,
+        )
+        .into_array();
         let (ends_slice, values_slice) = if offset == 0 && len == array.run_ends().max_value() {
-            (ends.into_array(), values)
+            (ends_array, values)
         } else {
-            let slice_begin = ends
+            let slice_begin = ends_array
                 .as_primitive_typed()
                 .search_sorted(&PValue::from(offset), SearchSortedSide::Right)?
-                .to_ends_index(ends.len());
-            let slice_end = find_slice_end_index(ends.as_ref(), offset + len)?;
+                .to_ends_index(ends_array.len());
+            let slice_end = find_slice_end_index(&ends_array, offset + len)?;
 
             (
-                ends.slice(slice_begin..slice_end)?,
+                ends_array.slice(slice_begin..slice_end)?,
                 values.slice(slice_begin..slice_end)?,
             )
         };
 
-        // SAFETY: arrow-rs enforces the RunEndArray invariants, we inherit their guarantees
-        Ok(unsafe { RunEndArray::new_unchecked(ends_slice, values_slice, offset, len) })
+        // SAFETY: arrow-rs enforces the RunEndArray invariants, we inherit their guarantees.
+        RunEndData::validate_parts(&ends_slice, &values_slice, offset, len)?;
+        Ok(unsafe { RunEndData::new_unchecked(offset) })
     }
 }
 
@@ -56,33 +63,84 @@ mod tests {
     use std::sync::Arc;
     use std::sync::LazyLock;
 
+    use arrow_array::Array as _;
     use arrow_array::Float64Array;
     use arrow_array::Int32Array;
     use arrow_array::Int64Array;
     use arrow_array::RunArray;
     use arrow_array::types::Int32Type;
     use arrow_array::types::Int64Type;
+    use arrow_array::types::RunEndIndexType;
     use arrow_schema::DataType;
     use arrow_schema::Field;
+    use rstest::rstest;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray as _;
     use vortex_array::VortexSessionExecute as _;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::primitive::PrimitiveArrayExt;
     use vortex_array::arrow::ArrowArrayExecutor;
     use vortex_array::arrow::FromArrowArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
+    use vortex_array::dtype::NativePType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
+    use vortex_array::scalar::PValue;
+    use vortex_array::search_sorted::SearchSorted;
+    use vortex_array::search_sorted::SearchSortedSide;
     use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
-    use crate::RunEndArray;
+    use crate::RunEnd;
+    use crate::ops::find_slice_end_index;
 
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
+    fn decode_run_array<R: RunEndIndexType>(
+        array: &RunArray<R>,
+        nullable: bool,
+    ) -> VortexResult<crate::RunEndArray>
+    where
+        R::Native: NativePType,
+    {
+        let offset = array.run_ends().offset();
+        let len = array.run_ends().len();
+        let ends_buf =
+            Buffer::<R::Native>::from_arrow_scalar_buffer(array.run_ends().inner().clone());
+        let ends = PrimitiveArray::new(ends_buf, Validity::NonNullable)
+            .reinterpret_cast(R::Native::PTYPE.to_unsigned());
+        let values = ArrayRef::from_arrow(array.values().as_ref(), nullable)?;
+
+        let ends_array = PrimitiveArray::from_buffer_handle(
+            ends.buffer_handle().clone(),
+            ends.ptype(),
+            ends.validity()?,
+        )
+        .into_array();
+        let (ends_slice, values_slice) = if offset == 0 && len == array.run_ends().max_value() {
+            (ends_array, values)
+        } else {
+            let slice_begin = ends_array
+                .as_primitive_typed()
+                .search_sorted(&PValue::from(offset), SearchSortedSide::Right)?
+                .to_ends_index(ends_array.len());
+            let slice_end = find_slice_end_index(&ends_array, offset + len)?;
+
+            (
+                ends_array.slice(slice_begin..slice_end)?,
+                values.slice(slice_begin..slice_end)?,
+            )
+        };
+
+        RunEnd::try_new_offset_length(ends_slice, values_slice, offset, array.len())
+    }
+
     #[test]
     fn test_arrow_run_array_to_vortex() -> VortexResult<()> {
         // Create an Arrow RunArray with UInt32 run ends and Int32 values
@@ -93,10 +151,10 @@ mod tests {
         let arrow_run_array = RunArray::<Int32Type>::try_new(&run_ends, &values).unwrap();
 
         // Convert to Vortex
-        let vortex_array = RunEndArray::from_arrow(&arrow_run_array, false)?;
+        let vortex_array = decode_run_array(&arrow_run_array, false)?;
 
         assert_arrays_eq!(
-            vortex_array.as_ref(),
+            vortex_array.into_array(),
             buffer![10i32, 10, 10, 20, 20, 30, 30, 30].into_array()
         );
         Ok(())
@@ -110,10 +168,10 @@ mod tests {
         let arrow_run_array = RunArray::<Int32Type>::try_new(&run_ends, &values).unwrap();
 
         // Convert to Vortex with nullable=true
-        let vortex_array = RunEndArray::from_arrow(&arrow_run_array, true)?;
+        let vortex_array = decode_run_array(&arrow_run_array, true)?;
 
         assert_arrays_eq!(
-            vortex_array.as_ref(),
+            vortex_array.into_array(),
             PrimitiveArray::from_option_iter([
                 Some(100i32),
                 Some(100i32),
@@ -134,7 +192,7 @@ mod tests {
         let arrow_run_array = RunArray::<Int64Type>::try_new(&run_ends, &values).unwrap();
 
         // Convert to Vortex
-        let vortex_array = RunEndArray::from_arrow(&arrow_run_array, false)?;
+        let vortex_array = decode_run_array(&arrow_run_array, false)?;
 
         assert_arrays_eq!(vortex_array, buffer![1.5f64, 2.5, 2.5, 3.5].into_array());
         Ok(())
@@ -154,7 +212,7 @@ mod tests {
         let sliced_array = arrow_run_array.slice(1, 6);
 
         // Convert the sliced array to Vortex
-        let vortex_array = RunEndArray::from_arrow(&sliced_array, false)?;
+        let vortex_array = decode_run_array(&sliced_array, false)?;
         assert_arrays_eq!(
             vortex_array,
             buffer![100, 200, 200, 200, 300, 300].into_array()
@@ -177,7 +235,7 @@ mod tests {
         let sliced_array = arrow_run_array.slice(4, 6);
 
         // Convert to Vortex with nullable=true
-        let vortex_array = RunEndArray::from_arrow(&sliced_array, true)?;
+        let vortex_array = decode_run_array(&sliced_array, true)?;
 
         assert_arrays_eq!(
             vortex_array,
@@ -208,7 +266,7 @@ mod tests {
         let sliced_array = arrow_run_array.slice(4, 0);
 
         // Convert to Vortex with nullable=true
-        let vortex_array = RunEndArray::from_arrow(&sliced_array, true)?;
+        let vortex_array = decode_run_array(&sliced_array, true)?;
 
         // Verify properties
         assert_eq!(vortex_array.len(), 0);
@@ -226,10 +284,7 @@ mod tests {
         )
     }
 
-    fn execute(
-        array: vortex_array::ArrayRef,
-        dt: &DataType,
-    ) -> VortexResult<arrow_array::ArrayRef> {
+    fn execute(array: ArrayRef, dt: &DataType) -> VortexResult<arrow_array::ArrayRef> {
         array.execute_arrow(Some(dt), &mut SESSION.create_execution_ctx())
     }
 
@@ -239,7 +294,7 @@ mod tests {
             &Int32Array::from(vec![3i32, 5, 8]),
             &Int32Array::from(vec![10, 20, 30]),
         )?;
-        let vortex_array = RunEndArray::from_arrow(&original, false)?;
+        let vortex_array = decode_run_array(&original, false)?;
         let target = ree_type(DataType::Int32, DataType::Int32);
         let result = execute(vortex_array.into_array(), &target)?;
 
@@ -251,19 +306,36 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_sliced_runend_to_arrow_ree() -> VortexResult<()> {
-        let array = RunEndArray::encode(
-            PrimitiveArray::from_iter(vec![10i32, 10, 20, 20, 20, 30, 30]).into_array(),
-        )?;
-        // Slicing from index 1 produces a non-zero offset in the RunEndArray.
-        let sliced = array.into_array().slice(1..5)?;
+    /// Slicing a RunEndArray and converting to Arrow REE must produce
+    /// correctly trimmed and adjusted run ends for both zero and non-zero offsets.
+    #[rstest]
+    #[case::nonzero_offset(
+        &[10i32, 10, 20, 20, 20, 30, 30],
+        1..5usize,
+        &[1i32, 4],
+        &[10i32, 20],
+    )]
+    #[case::zero_offset_excess_runs(
+        &[10i32, 10, 10, 20, 20, 30, 30, 30, 30, 30],
+        0..4usize,
+        &[3i32, 4],
+        &[10i32, 20],
+    )]
+    fn sliced_runend_to_arrow_ree(
+        #[case] input: &[i32],
+        #[case] slice_range: std::ops::Range<usize>,
+        #[case] expected_ends: &[i32],
+        #[case] expected_values: &[i32],
+    ) -> VortexResult<()> {
+        let array = RunEnd::encode(PrimitiveArray::from_iter(input.iter().copied()).into_array())?;
+        let sliced = array.into_array().slice(slice_range.clone())?;
         let target = ree_type(DataType::Int32, DataType::Int32);
         let result = execute(sliced, &target)?;
 
+        assert_eq!(result.len(), slice_range.len());
         let expected = RunArray::<Int32Type>::try_new(
-            &Int32Array::from(vec![1, 4]),
-            &Int32Array::from(vec![10, 20]),
+            &Int32Array::from(expected_ends.to_vec()),
+            &Int32Array::from(expected_values.to_vec()),
         )?;
         assert_eq!(result.as_ref(), &expected);
         Ok(())
diff --git a/encodings/runend/src/compress.rs b/encodings/runend/src/compress.rs
index 94f42281f48..df86d6cc5fb 100644
--- a/encodings/runend/src/compress.rs
+++ b/encodings/runend/src/compress.rs
@@ -3,11 +3,17 @@
 
 use itertools::Itertools;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
 use vortex_array::expr::stats::Precision;
@@ -16,7 +22,6 @@ use vortex_array::match_each_native_ptype;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BitBufferMut;
 use vortex_buffer::Buffer;
@@ -29,8 +34,11 @@ use vortex_mask::Mask;
 use crate::iter::trimmed_ends_iter;
 
 /// Run-end encode a `PrimitiveArray`, returning a tuple of `(ends, values)`.
-pub fn runend_encode(array: &PrimitiveArray) -> (PrimitiveArray, ArrayRef) {
-    let validity = match array.validity() {
+pub fn runend_encode(array: ArrayView<Primitive>) -> (PrimitiveArray, ArrayRef) {
+    let validity = match array
+        .validity()
+        .vortex_expect("run-end validity should be derivable")
+    {
         Validity::NonNullable => None,
         Validity::AllValid => None,
         Validity::AllInvalid => {
@@ -68,10 +76,7 @@ pub fn runend_encode(array: &PrimitiveArray) -> (PrimitiveArray, ArrayRef) {
         }
     };
 
-    let ends = ends
-        .narrow()
-        .vortex_expect("Ends must succeed downcasting")
-        .to_primitive();
+    let ends = ends.narrow().vortex_expect("Ends must succeed downcasting");
 
     ends.statistics()
         .set(Stat::IsStrictSorted, Precision::Exact(true.into()));
@@ -186,31 +191,16 @@ pub fn runend_decode_primitive(
     }))
 }
 
-pub fn runend_decode_bools(
-    ends: PrimitiveArray,
-    values: BoolArray,
-    offset: usize,
-    length: usize,
-) -> VortexResult<BoolArray> {
-    let validity_mask = values.validity_mask()?;
-    Ok(match_each_unsigned_integer_ptype!(ends.ptype(), |E| {
-        runend_decode_typed_bool(
-            trimmed_ends_iter(ends.as_slice::<E>(), offset, length),
-            &values.to_bit_buffer(),
-            validity_mask,
-            values.dtype().nullability(),
-            length,
-        )
-    }))
-}
-
-pub fn runend_decode_typed_primitive<T: NativePType>(
+/// Decode a run-end encoded slice of values into a flat `Buffer<T>` and `Validity`.
+///
+/// This is the core decode loop shared by primitive and varbinview run-end decoding.
+fn runend_decode_slice<T: Copy + Default>(
     run_ends: impl Iterator<Item = usize>,
     values: &[T],
     values_validity: Mask,
     values_nullability: Nullability,
     length: usize,
-) -> PrimitiveArray {
+) -> (Buffer<T>, Validity) {
     match values_validity {
         Mask::AllTrue(_) => {
             let mut decoded: BufferMut<T> = BufferMut::with_capacity(length);
@@ -225,9 +215,9 @@ pub fn runend_decode_typed_primitive<T: NativePType>(
                 // We preallocate enough capacity because we know the total length
                 unsafe { decoded.push_n_unchecked(*value, end - decoded.len()) };
             }
-            PrimitiveArray::new(decoded, values_nullability.into())
+            (decoded.into(), values_nullability.into())
         }
-        Mask::AllFalse(_) => PrimitiveArray::new(Buffer::<T>::zeroed(length), Validity::AllInvalid),
+        Mask::AllFalse(_) => (Buffer::<T>::zeroed(length), Validity::AllInvalid),
         Mask::Values(mask) => {
             let mut decoded = BufferMut::with_capacity(length);
             let mut decoded_validity = BitBufferMut::with_capacity(length);
@@ -258,50 +248,56 @@ pub fn runend_decode_typed_primitive<T: NativePType>(
                     }
                 }
             }
-            PrimitiveArray::new(decoded, Validity::from(decoded_validity.freeze()))
+            (decoded.into(), Validity::from(decoded_validity.freeze()))
         }
     }
 }
 
-pub fn runend_decode_typed_bool(
+pub fn runend_decode_typed_primitive<T: NativePType>(
     run_ends: impl Iterator<Item = usize>,
-    values: &BitBuffer,
+    values: &[T],
     values_validity: Mask,
     values_nullability: Nullability,
     length: usize,
-) -> BoolArray {
-    match values_validity {
-        Mask::AllTrue(_) => {
-            let mut decoded = BitBufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(values.iter()) {
-                decoded.append_n(value, end - decoded.len());
-            }
-            BoolArray::new(decoded.freeze(), values_nullability.into())
-        }
-        Mask::AllFalse(_) => BoolArray::new(BitBuffer::new_unset(length), Validity::AllInvalid),
-        Mask::Values(mask) => {
-            let mut decoded = BitBufferMut::with_capacity(length);
-            let mut decoded_validity = BitBufferMut::with_capacity(length);
-            for (end, value) in run_ends.zip_eq(
-                values
-                    .iter()
-                    .zip(mask.bit_buffer().iter())
-                    .map(|(v, is_valid)| is_valid.then_some(v)),
-            ) {
-                match value {
-                    None => {
-                        decoded_validity.append_n(false, end - decoded.len());
-                        decoded.append_n(false, end - decoded.len());
-                    }
-                    Some(value) => {
-                        decoded_validity.append_n(true, end - decoded.len());
-                        decoded.append_n(value, end - decoded.len());
-                    }
-                }
-            }
-            BoolArray::new(decoded.freeze(), Validity::from(decoded_validity.freeze()))
-        }
-    }
+) -> PrimitiveArray {
+    let (decoded, validity) = runend_decode_slice(
+        run_ends,
+        values,
+        values_validity,
+        values_nullability,
+        length,
+    );
+    PrimitiveArray::new(decoded, validity)
+}
+
+/// Decode a run-end encoded VarBinView array by expanding views directly.
+pub fn runend_decode_varbinview(
+    ends: PrimitiveArray,
+    values: VarBinViewArray,
+    offset: usize,
+    length: usize,
+) -> VortexResult<VarBinViewArray> {
+    let validity_mask = values.validity_mask()?;
+    let views = values.views();
+
+    let (decoded_views, validity) = match_each_unsigned_integer_ptype!(ends.ptype(), |E| {
+        runend_decode_slice(
+            trimmed_ends_iter(ends.as_slice::<E>(), offset, length),
+            views,
+            validity_mask,
+            values.dtype().nullability(),
+            length,
+        )
+    });
+
+    let parts = values.into_data_parts();
+    let view_handle = BufferHandle::new_host(decoded_views.into_byte_buffer());
+
+    // SAFETY: we are expanding views from a valid VarBinViewArray with the same
+    // buffers, so all buffer indices and offsets remain valid.
+    Ok(unsafe {
+        VarBinViewArray::new_handle_unchecked(view_handle, parts.buffers, parts.dtype, validity)
+    })
 }
 
 #[cfg(test)]
@@ -320,7 +316,7 @@ mod test {
     #[test]
     fn encode() {
         let arr = PrimitiveArray::from_iter([1i32, 1, 2, 2, 2, 3, 3, 3, 3, 3]);
-        let (ends, values) = runend_encode(&arr);
+        let (ends, values) = runend_encode(arr.as_view());
         let values = values.to_primitive();
 
         let expected_ends = PrimitiveArray::from_iter(vec![2u8, 5, 10]);
@@ -337,7 +333,7 @@ mod test {
                 true, true, false, false, true, true, true, true, false, false,
             ])),
         );
-        let (ends, values) = runend_encode(&arr);
+        let (ends, values) = runend_encode(arr.as_view());
         let values = values.to_primitive();
 
         let expected_ends = PrimitiveArray::from_iter(vec![2u8, 4, 5, 8, 10]);
@@ -353,7 +349,7 @@ mod test {
             buffer![0, 0, 0, 0, 0],
             Validity::from(BitBuffer::new_unset(5)),
         );
-        let (ends, values) = runend_encode(&arr);
+        let (ends, values) = runend_encode(arr.as_view());
         let values = values.to_primitive();
 
         let expected_ends = PrimitiveArray::from_iter(vec![5u64]);
diff --git a/encodings/runend/src/compute/cast.rs b/encodings/runend/src/compute/cast.rs
index eda74842058..1333a8d076a 100644
--- a/encodings/runend/src/compute/cast.rs
+++ b/encodings/runend/src/compute/cast.rs
@@ -2,24 +2,24 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
-
-impl CastReduce for RunEndVTable {
-    fn cast(array: &RunEndArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
+impl CastReduce for RunEnd {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Cast the values array to the target type
         let casted_values = array.values().cast(dtype.clone())?;
 
         // SAFETY: casting does not affect the ends being valid
         unsafe {
             Ok(Some(
-                RunEndArray::new_unchecked(
+                RunEnd::new_unchecked(
                     array.ends().clone(),
                     casted_values,
                     array.offset(),
@@ -34,7 +34,6 @@ impl CastReduce for RunEndVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::BoolArray;
@@ -47,11 +46,12 @@ mod tests {
     use vortex_array::dtype::PType;
     use vortex_buffer::buffer;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
 
     #[test]
     fn test_cast_runend_i32_to_i64() {
-        let runend = RunEndArray::try_new(
+        let runend = RunEnd::try_new(
             buffer![3u64, 5, 8, 10].into_array(),
             buffer![100i32, 200, 100, 300].into_array(),
         )
@@ -90,7 +90,7 @@ mod tests {
 
     #[test]
     fn test_cast_runend_nullable() {
-        let runend = RunEndArray::try_new(
+        let runend = RunEnd::try_new(
             buffer![2u64, 4, 7].into_array(),
             PrimitiveArray::from_option_iter([Some(10i32), None, Some(20)]).into_array(),
         )
@@ -109,7 +109,7 @@ mod tests {
     #[test]
     fn test_cast_runend_with_offset() {
         // Create a RunEndArray: [100, 100, 100, 200, 200, 300, 300, 300, 300, 300]
-        let runend = RunEndArray::try_new(
+        let runend = RunEnd::try_new(
             buffer![3u64, 5, 10].into_array(),
             buffer![100i32, 200, 300].into_array(),
         )
@@ -134,27 +134,27 @@ mod tests {
     }
 
     #[rstest]
-    #[case(RunEndArray::try_new(
+    #[case(RunEnd::try_new(
         buffer![3u64, 5, 8].into_array(),
         buffer![100i32, 200, 300].into_array()
     ).unwrap())]
-    #[case(RunEndArray::try_new(
+    #[case(RunEnd::try_new(
         buffer![1u64, 4, 10].into_array(),
         buffer![1.5f32, 2.5, 3.5].into_array()
     ).unwrap())]
-    #[case(RunEndArray::try_new(
+    #[case(RunEnd::try_new(
         buffer![2u64, 3, 5].into_array(),
         PrimitiveArray::from_option_iter([Some(42i32), None, Some(84)]).into_array()
     ).unwrap())]
-    #[case(RunEndArray::try_new(
+    #[case(RunEnd::try_new(
         buffer![10u64].into_array(),
         buffer![255u8].into_array()
     ).unwrap())]
-    #[case(RunEndArray::try_new(
+    #[case(RunEnd::try_new(
         buffer![2u64, 4, 6, 8, 10].into_array(),
         BoolArray::from_iter(vec![true, false, true, false, true]).into_array()
     ).unwrap())]
     fn test_cast_runend_conformance(#[case] array: RunEndArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/runend/src/compute/compare.rs b/encodings/runend/src/compute/compare.rs
index d00cdd72540..8dd253e453b 100644
--- a/encodings/runend/src/compute/compare.rs
+++ b/encodings/runend/src/compute/compare.rs
@@ -1,28 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
+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::binary::CompareKernel;
 use vortex_array::scalar_fn::fns::operators::CompareOperator;
 use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
-use crate::compress::runend_decode_bools;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
+use crate::decompress_bool::runend_decode_bools;
 
-impl CompareKernel for RunEndVTable {
+impl CompareKernel for RunEnd {
     fn compare(
-        lhs: &RunEndArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         // If the RHS is constant, then we just need to compare against our encoded values.
         if let Some(const_scalar) = rhs.as_constant() {
@@ -30,13 +31,13 @@ impl CompareKernel for RunEndVTable {
                 ConstantArray::new(const_scalar, lhs.values().len()).into_array(),
                 Operator::from(operator),
             )?;
-            let decoded = runend_decode_bools(
-                lhs.ends().to_primitive(),
-                values.to_bool(),
+            return runend_decode_bools(
+                lhs.ends().clone().execute::<PrimitiveArray>(ctx)?,
+                values.execute::<BoolArray>(ctx)?,
                 lhs.offset(),
                 lhs.len(),
-            )?;
-            return Ok(Some(decoded.into_array()));
+            )
+            .map(Some);
         }
 
         // Otherwise, fall back
@@ -54,20 +55,19 @@ mod test {
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::scalar_fn::fns::operators::Operator;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
 
     fn ree_array() -> RunEndArray {
-        RunEndArray::encode(
-            PrimitiveArray::from_iter([1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5]).into_array(),
-        )
-        .unwrap()
+        RunEnd::encode(PrimitiveArray::from_iter([1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5]).into_array())
+            .unwrap()
     }
 
     #[test]
     fn compare_run_end() {
         let arr = ree_array();
         let res = arr
-            .to_array()
+            .into_array()
             .binary(ConstantArray::new(5, 12).into_array(), Operator::Eq)
             .unwrap();
         let expected = BoolArray::from_iter([
diff --git a/encodings/runend/src/compute/fill_null.rs b/encodings/runend/src/compute/fill_null.rs
index 3cda14b945f..ddce31184eb 100644
--- a/encodings/runend/src/compute/fill_null.rs
+++ b/encodings/runend/src/compute/fill_null.rs
@@ -2,24 +2,33 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar_fn::fns::fill_null::FillNullReduce;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndArrayParts;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl FillNullReduce for RunEndVTable {
-    fn fill_null(array: &RunEndArray, fill_value: &Scalar) -> VortexResult<Option<ArrayRef>> {
-        let RunEndArrayParts { values, ends } = array.clone().into_parts();
-        let new_values = values.fill_null(fill_value.clone())?;
+impl FillNullReduce for RunEnd {
+    fn fill_null(
+        array: ArrayView<'_, Self>,
+        fill_value: &Scalar,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let new_values = array.values().fill_null(fill_value.clone())?;
         // SAFETY: modifying values only, does not affect ends
         Ok(Some(
-            unsafe { RunEndArray::new_unchecked(ends, new_values, array.offset(), array.len()) }
-                .into_array(),
+            unsafe {
+                RunEnd::new_unchecked(
+                    array.ends().clone(),
+                    new_values,
+                    array.offset(),
+                    array.len(),
+                )
+            }
+            .into_array(),
         ))
     }
 }
diff --git a/encodings/runend/src/compute/filter.rs b/encodings/runend/src/compute/filter.rs
index a85c694f5ad..11093d482ac 100644
--- a/encodings/runend/src/compute/filter.rs
+++ b/encodings/runend/src/compute/filter.rs
@@ -6,11 +6,11 @@ use std::ops::AddAssign;
 
 use num_traits::AsPrimitive;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::FilterKernel;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::validity::Validity;
@@ -20,17 +20,16 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 use crate::compute::take::take_indices_unchecked;
-
 const FILTER_TAKE_THRESHOLD: f64 = 0.1;
 
-impl FilterKernel for RunEndVTable {
+impl FilterKernel for RunEnd {
     fn filter(
-        array: &RunEndArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let mask_values = mask
             .values()
@@ -45,7 +44,7 @@ impl FilterKernel for RunEndVTable {
                 &Validity::NonNullable,
             )?))
         } else {
-            let primitive_run_ends = array.ends().to_primitive();
+            let primitive_run_ends = array.ends().clone().execute::<PrimitiveArray>(ctx)?;
             let (run_ends, values_mask) =
                 match_each_unsigned_integer_ptype!(primitive_run_ends.ptype(), |P| {
                     filter_run_end_primitive(
@@ -60,7 +59,7 @@ impl FilterKernel for RunEndVTable {
             // SAFETY: guaranteed by implementation of filter_run_end_primitive
             unsafe {
                 Ok(Some(
-                    RunEndArray::new_unchecked(
+                    RunEnd::new_unchecked(
                         run_ends.into_array(),
                         values,
                         0,
@@ -115,20 +114,18 @@ fn filter_run_end_primitive<R: NativePType + AddAssign + From<bool> + AsPrimitiv
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_error::VortexResult;
     use vortex_mask::Mask;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
 
     fn ree_array() -> RunEndArray {
-        RunEndArray::encode(
-            PrimitiveArray::from_iter([1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5]).into_array(),
-        )
-        .unwrap()
+        RunEnd::encode(PrimitiveArray::from_iter([1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5]).into_array())
+            .unwrap()
     }
 
     #[test]
@@ -138,7 +135,7 @@ mod tests {
 
         assert_arrays_eq!(
             filtered,
-            RunEndArray::new(
+            RunEnd::new(
                 PrimitiveArray::from_iter([1u8, 2, 3]).into_array(),
                 PrimitiveArray::from_iter([1i32, 4, 2]).into_array()
             )
diff --git a/encodings/runend/src/compute/is_constant.rs b/encodings/runend/src/compute/is_constant.rs
index 9e1f4ccbe45..53418f3ef50 100644
--- a/encodings/runend/src/compute/is_constant.rs
+++ b/encodings/runend/src/compute/is_constant.rs
@@ -1,33 +1,40 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
-use vortex_array::compute::IsConstantKernel;
-use vortex_array::compute::IsConstantKernelAdapter;
-use vortex_array::compute::IsConstantOpts;
-use vortex_array::compute::is_constant_opts;
-use vortex_array::expr::stats::Stat;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl IsConstantKernel for RunEndVTable {
-    fn is_constant(
+/// RunEnd-specific is_constant kernel.
+///
+/// If the values array of a run-end array is constant, the entire array is constant.
+#[derive(Debug)]
+pub(crate) struct RunEndIsConstantKernel;
+
+impl DynAggregateKernel for RunEndIsConstantKernel {
+    fn aggregate(
         &self,
-        array: &Self::Array,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        // If there are known to be me 0 len runs then we can check if constant on the values.
-        debug_assert_eq!(
-            array
-                .ends()
-                .statistics()
-                .compute_as::<bool>(Stat::IsStrictSorted),
-            Some(true)
-        );
-        is_constant_opts(array.values(), opts)
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
+            return Ok(None);
+        }
+
+        let Some(array) = batch.as_opt::<RunEnd>() else {
+            return Ok(None);
+        };
+
+        let result = is_constant(array.values(), ctx)?;
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
-
-register_kernel!(IsConstantKernelAdapter(RunEndVTable).lift());
diff --git a/encodings/runend/src/compute/is_sorted.rs b/encodings/runend/src/compute/is_sorted.rs
index 89033620dbd..e26a3d8cb57 100644
--- a/encodings/runend/src/compute/is_sorted.rs
+++ b/encodings/runend/src/compute/is_sorted.rs
@@ -1,24 +1,50 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::IsSortedKernel;
-use vortex_array::compute::IsSortedKernelAdapter;
-use vortex_array::compute::is_sorted;
-use vortex_array::compute::is_strict_sorted;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray as _;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::fns::is_sorted::is_sorted;
+use vortex_array::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl IsSortedKernel for RunEndVTable {
-    fn is_sorted(&self, array: &RunEndArray) -> VortexResult<Option<bool>> {
-        is_sorted(array.values())
-    }
+/// RunEnd-specific is_sorted kernel.
+///
+/// Non-strict: values array sorted implies the run-end array is sorted.
+/// Strict: must canonicalize since runs repeat values.
+#[derive(Debug)]
+pub(crate) struct RunEndIsSortedKernel;
+
+impl DynAggregateKernel for RunEndIsSortedKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let Some(options) = aggregate_fn.as_opt::<IsSorted>() else {
+            return Ok(None);
+        };
+
+        let Some(array) = batch.as_opt::<RunEnd>() else {
+            return Ok(None);
+        };
 
-    fn is_strict_sorted(&self, array: &RunEndArray) -> VortexResult<Option<bool>> {
-        is_strict_sorted(array.to_canonical()?.as_ref())
+        let result = if options.strict {
+            // Strict sort with run-end encoding means we need to canonicalize
+            // since run-end encoding repeats values.
+            is_strict_sorted(&array.array().to_canonical()?.into_array(), ctx)?
+        } else {
+            is_sorted(array.values(), ctx)?
+        };
+
+        Ok(Some(IsSorted::make_partial(batch, result, options.strict)?))
     }
 }
-
-register_kernel!(IsSortedKernelAdapter(RunEndVTable).lift());
diff --git a/encodings/runend/src/compute/min_max.rs b/encodings/runend/src/compute/min_max.rs
index c58616ae714..2a65d9de2bf 100644
--- a/encodings/runend/src/compute/min_max.rs
+++ b/encodings/runend/src/compute/min_max.rs
@@ -1,20 +1,48 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::MinMaxKernel;
-use vortex_array::compute::MinMaxKernelAdapter;
-use vortex_array::compute::MinMaxResult;
-use vortex_array::compute::min_max;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::min_max::MinMax;
+use vortex_array::aggregate_fn::fns::min_max::make_minmax_dtype;
+use vortex_array::aggregate_fn::fns::min_max::min_max;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl MinMaxKernel for RunEndVTable {
-    fn min_max(&self, array: &RunEndArray) -> VortexResult<Option<MinMaxResult>> {
-        min_max(array.values())
+/// RunEnd-specific min/max kernel.
+///
+/// Run-end encoded arrays store each unique run value once, so min/max can be computed directly
+/// on the values array without decoding.
+#[derive(Debug)]
+pub(crate) struct RunEndMinMaxKernel;
+
+impl DynAggregateKernel for RunEndMinMaxKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<MinMax>() {
+            return Ok(None);
+        }
+
+        let Some(run_end) = batch.as_opt::<RunEnd>() else {
+            return Ok(None);
+        };
+
+        let struct_dtype = make_minmax_dtype(batch.dtype());
+        match min_max(run_end.values(), ctx)? {
+            Some(result) => Ok(Some(Scalar::struct_(
+                struct_dtype,
+                vec![result.min, result.max],
+            ))),
+            None => Ok(Some(Scalar::null(struct_dtype))),
+        }
     }
 }
-
-register_kernel!(MinMaxKernelAdapter(RunEndVTable).lift());
diff --git a/encodings/runend/src/compute/mod.rs b/encodings/runend/src/compute/mod.rs
index 8b390bef750..f1f6dd97593 100644
--- a/encodings/runend/src/compute/mod.rs
+++ b/encodings/runend/src/compute/mod.rs
@@ -5,9 +5,9 @@ mod cast;
 mod compare;
 mod fill_null;
 pub(crate) mod filter;
-mod is_constant;
-mod is_sorted;
-mod min_max;
+pub(crate) mod is_constant;
+pub(crate) mod is_sorted;
+pub(crate) mod min_max;
 pub(crate) mod take;
 pub(crate) mod take_from;
 
@@ -19,32 +19,33 @@ mod tests {
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_buffer::buffer;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
 
     #[rstest]
     // Simple run-end arrays
-    #[case::runend_i32(RunEndArray::encode(
+    #[case::runend_i32(RunEnd::encode(
         buffer![1i32, 1, 1, 2, 2, 3, 3, 3, 3].into_array()
     ).unwrap())]
-    #[case::runend_single_run(RunEndArray::encode(
+    #[case::runend_single_run(RunEnd::encode(
         buffer![5i32, 5, 5, 5, 5].into_array()
     ).unwrap())]
-    #[case::runend_alternating(RunEndArray::encode(
+    #[case::runend_alternating(RunEnd::encode(
         buffer![1i32, 2, 1, 2, 1, 2].into_array()
     ).unwrap())]
     // Different types
-    #[case::runend_u64(RunEndArray::encode(
+    #[case::runend_u64(RunEnd::encode(
         buffer![100u64, 100, 200, 200, 200].into_array()
     ).unwrap())]
     // Edge cases
-    #[case::runend_single(RunEndArray::encode(
+    #[case::runend_single(RunEnd::encode(
         buffer![42i32].into_array()
     ).unwrap())]
-    #[case::runend_large(RunEndArray::encode(
+    #[case::runend_large(RunEnd::encode(
         PrimitiveArray::from_iter((0..1000).map(|i| i / 10)).into_array()
     ).unwrap())]
 
     fn test_runend_consistency(#[case] array: RunEndArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/runend/src/compute/take.rs b/encodings/runend/src/compute/take.rs
index 2a1a1403f0b..9bbdbf6784e 100644
--- a/encodings/runend/src/compute/take.rs
+++ b/encodings/runend/src/compute/take.rs
@@ -3,36 +3,36 @@
 
 use num_traits::AsPrimitive;
 use num_traits::NumCast;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::search_sorted::SearchResult;
 use vortex_array::search_sorted::SearchSorted;
 use vortex_array::search_sorted::SearchSortedSide;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl TakeExecute for RunEndVTable {
+impl TakeExecute for RunEnd {
     #[expect(
         clippy::cast_possible_truncation,
         reason = "index cast to usize inside macro"
     )]
     fn take(
-        array: &RunEndArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let primitive_indices = indices.to_primitive();
+        let primitive_indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
 
         let checked_indices = match_each_integer_ptype!(primitive_indices.ptype(), |P| {
             primitive_indices
@@ -49,13 +49,14 @@ impl TakeExecute for RunEndVTable {
                 .collect::<VortexResult<Vec<_>>>()?
         });
 
-        take_indices_unchecked(array, &checked_indices, primitive_indices.validity()).map(Some)
+        let indices_validity = primitive_indices.validity()?;
+        take_indices_unchecked(array, &checked_indices, &indices_validity).map(Some)
     }
 }
 
 /// Perform a take operation on a RunEndArray by binary searching for each of the indices.
 pub fn take_indices_unchecked<T: AsPrimitive<usize>>(
-    array: &RunEndArray,
+    array: ArrayView<'_, RunEnd>,
     indices: &[T],
     validity: &Validity,
 ) -> VortexResult<ArrayRef> {
@@ -84,13 +85,12 @@ pub fn take_indices_unchecked<T: AsPrimitive<usize>>(
         PrimitiveArray::new(buffer, validity.clone())
     });
 
-    array.values().take(physical_indices.to_array())
+    array.values().take(physical_indices.into_array())
 }
 
 #[cfg(test)]
 mod test {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
@@ -101,10 +101,11 @@ mod test {
     use vortex_array::compute::conformance::take::test_take_conformance;
     use vortex_buffer::buffer;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
 
     fn ree_array() -> RunEndArray {
-        RunEndArray::encode(buffer![1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5].into_array()).unwrap()
+        RunEnd::encode(buffer![1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5].into_array()).unwrap()
     }
 
     #[test]
@@ -143,19 +144,19 @@ mod test {
     #[test]
     fn ree_take_nullable() {
         let taken = ree_array()
-            .take(PrimitiveArray::from_option_iter([Some(1), None]).to_array())
+            .take(PrimitiveArray::from_option_iter([Some(1), None]).into_array())
             .unwrap();
 
         let expected = PrimitiveArray::from_option_iter([Some(1i32), None]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[rstest]
     #[case(ree_array())]
-    #[case(RunEndArray::encode(
+    #[case(RunEnd::encode(
         buffer![1u8, 1, 2, 2, 2, 3, 3, 3, 3, 4].into_array(),
     ).unwrap())]
-    #[case(RunEndArray::encode(
+    #[case(RunEnd::encode(
         PrimitiveArray::from_option_iter([
             Some(10),
             Some(10),
@@ -167,9 +168,9 @@ mod test {
         ])
         .into_array(),
     ).unwrap())]
-    #[case(RunEndArray::encode(buffer![42i32, 42, 42, 42, 42].into_array())
+    #[case(RunEnd::encode(buffer![42i32, 42, 42, 42, 42].into_array())
         .unwrap())]
-    #[case(RunEndArray::encode(
+    #[case(RunEnd::encode(
         buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_array(),
     ).unwrap())]
     #[case({
@@ -179,22 +180,22 @@ mod test {
                 values.push(i);
             }
         }
-        RunEndArray::encode(PrimitiveArray::from_iter(values).into_array()).unwrap()
+        RunEnd::encode(PrimitiveArray::from_iter(values).into_array()).unwrap()
     })]
     fn test_take_runend_conformance(#[case] array: RunEndArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 
     #[rstest]
     #[case(ree_array().slice(3..6).unwrap())]
     #[case({
-        let array = RunEndArray::encode(
+        let array = RunEnd::encode(
             buffer![1i32, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3].into_array(),
         )
         .unwrap();
         array.slice(2..8).unwrap()
     })]
     fn test_take_sliced_runend_conformance(#[case] sliced: ArrayRef) {
-        test_take_conformance(sliced.as_ref());
+        test_take_conformance(&sliced);
     }
 }
diff --git a/encodings/runend/src/compute/take_from.rs b/encodings/runend/src/compute/take_from.rs
index 1611dc3ba37..4e913f5feae 100644
--- a/encodings/runend/src/compute/take_from.rs
+++ b/encodings/runend/src/compute/take_from.rs
@@ -2,27 +2,28 @@
 // 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::arrays::DictArray;
-use vortex_array::arrays::DictVTable;
+use vortex_array::arrays::Dict;
+use vortex_array::arrays::dict::DictArraySlotsExt;
 use vortex_array::dtype::DType;
 use vortex_array::kernel::ExecuteParentKernel;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
 #[derive(Debug)]
-pub(crate) struct RunEndVTableTakeFrom;
+pub(crate) struct RunEndTakeFrom;
 
-impl ExecuteParentKernel<RunEndVTable> for RunEndVTableTakeFrom {
-    type Parent = DictVTable;
+impl ExecuteParentKernel<RunEnd> for RunEndTakeFrom {
+    type Parent = Dict;
 
     fn execute_parent(
         &self,
-        array: &RunEndArray,
-        dict: &DictArray,
+        array: ArrayView<'_, RunEnd>,
+        dict: ArrayView<'_, Dict>,
         child_idx: usize,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -38,7 +39,7 @@ impl ExecuteParentKernel<RunEndVTable> for RunEndVTableTakeFrom {
         // Create a new run-end array containing values as values, instead of indices as values.
         // SAFETY: we are copying ends from an existing valid RunEndArray
         let ree_array = unsafe {
-            RunEndArray::new_unchecked(
+            RunEnd::new_unchecked(
                 array.ends().clone(),
                 dict.values().take(array.values().clone())?,
                 array.offset(),
@@ -52,7 +53,6 @@ impl ExecuteParentKernel<RunEndVTable> for RunEndVTableTakeFrom {
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::ExecutionCtx;
     use vortex_array::IntoArray;
     use vortex_array::arrays::DictArray;
@@ -63,8 +63,10 @@ mod tests {
     use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
+    use crate::RunEnd;
     use crate::RunEndArray;
-    use crate::compute::take_from::RunEndVTableTakeFrom;
+    use crate::array::RunEndArrayExt;
+    use crate::compute::take_from::RunEndTakeFrom;
 
     /// Build a DictArray whose codes are run-end encoded.
     ///
@@ -73,7 +75,7 @@ mod tests {
     /// Codes:       `[0, 0, 0, 1, 1, 0, 0]`
     /// RunEnd encoded codes: ends=`[3, 5, 7]`, values=`[0, 1, 0]`
     fn make_dict_with_runend_codes() -> (RunEndArray, DictArray) {
-        let codes = RunEndArray::encode(buffer![0u32, 0, 0, 1, 1, 0, 0].into_array()).unwrap();
+        let codes = RunEnd::encode(buffer![0u32, 0, 0, 1, 1, 0, 0].into_array()).unwrap();
         let values = buffer![2i32, 3].into_array();
         let dict = DictArray::try_new(codes.clone().into_array(), values).unwrap();
         (codes, dict)
@@ -84,8 +86,8 @@ mod tests {
         let (codes, dict) = make_dict_with_runend_codes();
         let mut ctx = ExecutionCtx::new(VortexSession::empty());
 
-        let result = RunEndVTableTakeFrom
-            .execute_parent(&codes, &dict, 0, &mut ctx)?
+        let result = RunEndTakeFrom
+            .execute_parent(codes.as_view(), dict.as_view(), 0, &mut ctx)?
             .expect("kernel should return Some");
 
         let expected = PrimitiveArray::from_iter([2i32, 2, 2, 3, 3, 2, 2]);
@@ -98,7 +100,7 @@ mod tests {
         let (codes, dict) = make_dict_with_runend_codes();
         // Slice codes to positions 2..5 → logical codes [0, 1, 1] → values [2, 3, 3]
         let sliced_codes = unsafe {
-            RunEndArray::new_unchecked(
+            RunEnd::new_unchecked(
                 codes.ends().clone(),
                 codes.values().clone(),
                 2, // offset
@@ -107,8 +109,8 @@ mod tests {
         };
         let mut ctx = ExecutionCtx::new(VortexSession::empty());
 
-        let result = RunEndVTableTakeFrom
-            .execute_parent(&sliced_codes, &dict, 0, &mut ctx)?
+        let result = RunEndTakeFrom
+            .execute_parent(sliced_codes.as_view(), dict.as_view(), 0, &mut ctx)?
             .expect("kernel should return Some");
 
         let expected = PrimitiveArray::from_iter([2i32, 3, 3]);
@@ -121,7 +123,7 @@ mod tests {
         let (codes, dict) = make_dict_with_runend_codes();
         // Slice codes to positions 3..7 → logical codes [1, 1, 0, 0] → values [3, 3, 2, 2]
         let sliced_codes = unsafe {
-            RunEndArray::new_unchecked(
+            RunEnd::new_unchecked(
                 codes.ends().clone(),
                 codes.values().clone(),
                 3, // offset at exact run boundary
@@ -130,8 +132,8 @@ mod tests {
         };
         let mut ctx = ExecutionCtx::new(VortexSession::empty());
 
-        let result = RunEndVTableTakeFrom
-            .execute_parent(&sliced_codes, &dict, 0, &mut ctx)?
+        let result = RunEndTakeFrom
+            .execute_parent(sliced_codes.as_view(), dict.as_view(), 0, &mut ctx)?
             .expect("kernel should return Some");
 
         let expected = PrimitiveArray::from_iter([3i32, 3, 2, 2]);
@@ -144,7 +146,7 @@ mod tests {
         let (codes, dict) = make_dict_with_runend_codes();
         // Slice to single element at position 4 → code=1 → value=3
         let sliced_codes = unsafe {
-            RunEndArray::new_unchecked(
+            RunEnd::new_unchecked(
                 codes.ends().slice(1..3)?,
                 codes.values().slice(1..3)?,
                 4, // offset
@@ -153,8 +155,8 @@ mod tests {
         };
         let mut ctx = ExecutionCtx::new(VortexSession::empty());
 
-        let result = RunEndVTableTakeFrom
-            .execute_parent(&sliced_codes, &dict, 0, &mut ctx)?
+        let result = RunEndTakeFrom
+            .execute_parent(sliced_codes.as_view(), dict.as_view(), 0, &mut ctx)?
             .expect("kernel should return Some");
 
         let expected = PrimitiveArray::from_iter([3i32]);
@@ -167,7 +169,7 @@ mod tests {
         let (codes, dict) = make_dict_with_runend_codes();
         let mut ctx = ExecutionCtx::new(VortexSession::empty());
 
-        let result = RunEndVTableTakeFrom.execute_parent(&codes, &dict, 1, &mut ctx)?;
+        let result = RunEndTakeFrom.execute_parent(codes.as_view(), dict.as_view(), 1, &mut ctx)?;
         assert!(result.is_none());
         Ok(())
     }
diff --git a/encodings/runend/src/decompress_bool.rs b/encodings/runend/src/decompress_bool.rs
new file mode 100644
index 00000000000..6733f143a8c
--- /dev/null
+++ b/encodings/runend/src/decompress_bool.rs
@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Optimized run-end decoding for boolean arrays.
+//!
+//! Uses an adaptive strategy that pre-fills the buffer with the majority value
+//! (0s or 1s) and only fills the minority runs, minimizing work for skewed distributions.
+
+use itertools::Itertools;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::match_each_unsigned_integer_ptype;
+use vortex_array::scalar::Scalar;
+use vortex_array::validity::Validity;
+use vortex_buffer::BitBuffer;
+use vortex_buffer::BitBufferMut;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use crate::iter::trimmed_ends_iter;
+
+/// Threshold for number of runs below which we use sequential append instead of prefill.
+/// With few runs, the overhead of prefilling the entire buffer dominates.
+const PREFILL_RUN_THRESHOLD: usize = 32;
+
+/// Decodes run-end encoded boolean values into a flat `BoolArray`.
+pub fn runend_decode_bools(
+    ends: PrimitiveArray,
+    values: BoolArray,
+    offset: usize,
+    length: usize,
+) -> VortexResult<ArrayRef> {
+    let validity = values.validity_mask()?;
+    let values_buf = values.to_bit_buffer();
+    let nullability = values.dtype().nullability();
+
+    // Fast path for few runs with no offset - avoids iterator overhead
+    let num_runs = values_buf.len();
+    if offset == 0 && num_runs < PREFILL_RUN_THRESHOLD {
+        return Ok(match_each_unsigned_integer_ptype!(ends.ptype(), |E| {
+            decode_few_runs_no_offset(
+                ends.as_slice::<E>(),
+                &values_buf,
+                validity,
+                nullability,
+                length,
+            )
+        }));
+    }
+
+    Ok(match_each_unsigned_integer_ptype!(ends.ptype(), |E| {
+        runend_decode_typed_bool(
+            trimmed_ends_iter(ends.as_slice::<E>(), offset, length),
+            &values_buf,
+            validity,
+            nullability,
+            length,
+        )
+    }))
+}
+
+/// Decodes run-end encoded boolean values using an adaptive strategy.
+///
+/// The strategy counts true vs false runs and chooses the optimal approach:
+/// - If more true runs: pre-fill with 1s, clear false runs
+/// - If more false runs: pre-fill with 0s, fill true runs
+///
+/// This minimizes work for skewed distributions (e.g., sparse validity masks).
+pub fn runend_decode_typed_bool(
+    run_ends: impl Iterator<Item = usize>,
+    values: &BitBuffer,
+    values_validity: Mask,
+    values_nullability: Nullability,
+    length: usize,
+) -> ArrayRef {
+    match values_validity {
+        Mask::AllTrue(_) => {
+            decode_bool_non_nullable(run_ends, values, values_nullability, length).into_array()
+        }
+        Mask::AllFalse(_) => {
+            ConstantArray::new(Scalar::null(DType::Bool(Nullability::Nullable)), length)
+                .into_array()
+        }
+        Mask::Values(mask) => {
+            decode_bool_nullable(run_ends, values, mask.bit_buffer(), length).into_array()
+        }
+    }
+}
+
+/// Fast path for few runs with no offset. Uses direct slice access to minimize overhead.
+/// This avoids the `trimmed_ends_iter` iterator chain which adds significant overhead
+/// for small numbers of runs.
+#[inline(always)]
+fn decode_few_runs_no_offset<E: vortex_array::dtype::IntegerPType>(
+    ends: &[E],
+    values: &BitBuffer,
+    validity: Mask,
+    nullability: Nullability,
+    length: usize,
+) -> ArrayRef {
+    match validity {
+        Mask::AllTrue(_) => {
+            let mut decoded = BitBufferMut::with_capacity(length);
+            let mut prev_end = 0usize;
+            for (i, &end) in ends.iter().enumerate() {
+                let end = end.as_().min(length);
+                decoded.append_n(values.value(i), end - prev_end);
+                prev_end = end;
+            }
+            BoolArray::new(decoded.freeze(), nullability.into()).into_array()
+        }
+        Mask::AllFalse(_) => {
+            ConstantArray::new(Scalar::null(DType::Bool(Nullability::Nullable)), length)
+                .into_array()
+        }
+        Mask::Values(mask) => {
+            let validity_buf = mask.bit_buffer();
+            let mut decoded = BitBufferMut::with_capacity(length);
+            let mut decoded_validity = BitBufferMut::with_capacity(length);
+            let mut prev_end = 0usize;
+            for (i, &end) in ends.iter().enumerate() {
+                let end = end.as_().min(length);
+                let run_len = end - prev_end;
+                let is_valid = validity_buf.value(i);
+                if is_valid {
+                    decoded_validity.append_n(true, run_len);
+                    decoded.append_n(values.value(i), run_len);
+                } else {
+                    decoded_validity.append_n(false, run_len);
+                    decoded.append_n(false, run_len);
+                }
+                prev_end = end;
+            }
+            BoolArray::new(decoded.freeze(), Validity::from(decoded_validity.freeze())).into_array()
+        }
+    }
+}
+
+/// Decodes run-end encoded booleans when all values are valid (non-nullable).
+fn decode_bool_non_nullable(
+    run_ends: impl Iterator<Item = usize>,
+    values: &BitBuffer,
+    nullability: Nullability,
+    length: usize,
+) -> BoolArray {
+    let num_runs = values.len();
+
+    // For few runs, sequential append is faster than prefill + modify
+    if num_runs < PREFILL_RUN_THRESHOLD {
+        let mut decoded = BitBufferMut::with_capacity(length);
+        for (end, value) in run_ends.zip(values.iter()) {
+            decoded.append_n(value, end - decoded.len());
+        }
+        return BoolArray::new(decoded.freeze(), nullability.into());
+    }
+
+    // Adaptive strategy: prefill with majority value, only flip minority runs
+    let prefill = values.true_count() > num_runs - values.true_count();
+    let mut decoded = BitBufferMut::full(prefill, length);
+    let mut current_pos = 0usize;
+
+    for (end, value) in run_ends.zip_eq(values.iter()) {
+        if end > current_pos && value != prefill {
+            // SAFETY: current_pos < end <= length == decoded.len()
+            unsafe { decoded.fill_range_unchecked(current_pos, end, value) };
+        }
+        current_pos = end;
+    }
+    BoolArray::new(decoded.freeze(), nullability.into())
+}
+
+/// Decodes run-end encoded booleans when values may be null (nullable).
+fn decode_bool_nullable(
+    run_ends: impl Iterator<Item = usize>,
+    values: &BitBuffer,
+    validity_mask: &BitBuffer,
+    length: usize,
+) -> BoolArray {
+    let num_runs = values.len();
+
+    // For few runs, sequential append is faster than prefill + modify
+    if num_runs < PREFILL_RUN_THRESHOLD {
+        return decode_nullable_sequential(run_ends, values, validity_mask, length);
+    }
+
+    // Adaptive strategy: prefill each buffer with its majority value
+    let prefill_decoded = values.true_count() > num_runs - values.true_count();
+    let prefill_valid = validity_mask.true_count() > num_runs - validity_mask.true_count();
+
+    let mut decoded = BitBufferMut::full(prefill_decoded, length);
+    let mut decoded_validity = BitBufferMut::full(prefill_valid, length);
+    let mut current_pos = 0usize;
+
+    for (end, (value, is_valid)) in run_ends.zip_eq(values.iter().zip(validity_mask.iter())) {
+        if end > current_pos {
+            // SAFETY: current_pos < end <= length == decoded.len() == decoded_validity.len()
+            if is_valid != prefill_valid {
+                unsafe { decoded_validity.fill_range_unchecked(current_pos, end, is_valid) };
+            }
+            // Decoded bit should be the actual value when valid, false when null.
+            let want_decoded = is_valid && value;
+            if want_decoded != prefill_decoded {
+                unsafe { decoded.fill_range_unchecked(current_pos, end, want_decoded) };
+            }
+            current_pos = end;
+        }
+    }
+    BoolArray::new(decoded.freeze(), Validity::from(decoded_validity.freeze()))
+}
+
+/// Sequential decode for few runs - avoids prefill overhead.
+#[inline(always)]
+fn decode_nullable_sequential(
+    run_ends: impl Iterator<Item = usize>,
+    values: &BitBuffer,
+    validity_mask: &BitBuffer,
+    length: usize,
+) -> BoolArray {
+    let mut decoded = BitBufferMut::with_capacity(length);
+    let mut decoded_validity = BitBufferMut::with_capacity(length);
+
+    for (end, (value, is_valid)) in run_ends.zip(values.iter().zip(validity_mask.iter())) {
+        let run_len = end - decoded.len();
+        if is_valid {
+            decoded_validity.append_n(true, run_len);
+            decoded.append_n(value, run_len);
+        } else {
+            decoded_validity.append_n(false, run_len);
+            decoded.append_n(false, run_len);
+        }
+    }
+
+    BoolArray::new(decoded.freeze(), Validity::from(decoded_validity.freeze()))
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::ToCanonical;
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::bool::BoolArrayExt;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::BitBuffer;
+    use vortex_error::VortexResult;
+
+    use super::runend_decode_bools;
+
+    #[test]
+    fn decode_bools_alternating() -> VortexResult<()> {
+        // Alternating true/false: [T, T, F, F, F, T, T, T, T, T]
+        let ends = PrimitiveArray::from_iter([2u32, 5, 10]);
+        let values = BoolArray::from(BitBuffer::from(vec![true, false, true]));
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        let expected = BoolArray::from(BitBuffer::from(vec![
+            true, true, false, false, false, true, true, true, true, true,
+        ]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_mostly_true() -> VortexResult<()> {
+        // Mostly true: [T, T, T, T, T, F, T, T, T, T]
+        let ends = PrimitiveArray::from_iter([5u32, 6, 10]);
+        let values = BoolArray::from(BitBuffer::from(vec![true, false, true]));
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        let expected = BoolArray::from(BitBuffer::from(vec![
+            true, true, true, true, true, false, true, true, true, true,
+        ]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_mostly_false() -> VortexResult<()> {
+        // Mostly false: [F, F, F, F, F, T, F, F, F, F]
+        let ends = PrimitiveArray::from_iter([5u32, 6, 10]);
+        let values = BoolArray::from(BitBuffer::from(vec![false, true, false]));
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        let expected = BoolArray::from(BitBuffer::from(vec![
+            false, false, false, false, false, true, false, false, false, false,
+        ]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_all_true_single_run() -> VortexResult<()> {
+        let ends = PrimitiveArray::from_iter([10u32]);
+        let values = BoolArray::from(BitBuffer::from(vec![true]));
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        let expected = BoolArray::from(BitBuffer::from(vec![
+            true, true, true, true, true, true, true, true, true, true,
+        ]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_all_false_single_run() -> VortexResult<()> {
+        let ends = PrimitiveArray::from_iter([10u32]);
+        let values = BoolArray::from(BitBuffer::from(vec![false]));
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        let expected = BoolArray::from(BitBuffer::from(vec![
+            false, false, false, false, false, false, false, false, false, false,
+        ]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_with_offset() -> VortexResult<()> {
+        // Test with offset: [T, T, F, F, F, T, T, T, T, T] -> slice [2..8] = [F, F, F, T, T, T]
+        let ends = PrimitiveArray::from_iter([2u32, 5, 10]);
+        let values = BoolArray::from(BitBuffer::from(vec![true, false, true]));
+        let decoded = runend_decode_bools(ends, values, 2, 6)?;
+
+        let expected =
+            BoolArray::from(BitBuffer::from(vec![false, false, false, true, true, true]));
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_nullable() -> VortexResult<()> {
+        use vortex_array::validity::Validity;
+
+        // 3 runs: T (valid), F (null), T (valid) -> [T, T, null, null, null, T, T, T, T, T]
+        let ends = PrimitiveArray::from_iter([2u32, 5, 10]);
+        let values = BoolArray::new(
+            BitBuffer::from(vec![true, false, true]),
+            Validity::from(BitBuffer::from(vec![true, false, true])),
+        );
+        let decoded = runend_decode_bools(ends, values, 0, 10)?;
+
+        // Expected: values=[T, T, F, F, F, T, T, T, T, T], validity=[1, 1, 0, 0, 0, 1, 1, 1, 1, 1]
+        let expected = BoolArray::new(
+            BitBuffer::from(vec![
+                true, true, false, false, false, true, true, true, true, true,
+            ]),
+            Validity::from(BitBuffer::from(vec![
+                true, true, false, false, false, true, true, true, true, true,
+            ])),
+        );
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn decode_bools_nullable_few_runs() -> VortexResult<()> {
+        // Test few runs (uses fast path): 5 runs of length 2000 each
+        let ends = PrimitiveArray::from_iter([2000u32, 4000, 6000, 8000, 10000]);
+        let values = BoolArray::new(
+            BitBuffer::from(vec![true, false, true, false, true]),
+            Validity::from(BitBuffer::from(vec![true, false, true, false, true])),
+        );
+        let decoded = runend_decode_bools(ends, values, 0, 10000)?.to_bool();
+
+        // Check length and a few values
+        assert_eq!(decoded.len(), 10000);
+        // First run: valid true
+        assert!(decoded.validity_mask()?.value(0));
+        assert!(decoded.to_bit_buffer().value(0));
+        // Second run: null (validity false)
+        assert!(!decoded.validity_mask()?.value(2000));
+        // Third run: valid true
+        assert!(decoded.validity_mask()?.value(4000));
+        assert!(decoded.to_bit_buffer().value(4000));
+        Ok(())
+    }
+}
diff --git a/encodings/runend/src/iter.rs b/encodings/runend/src/iter.rs
index 691dcb3c527..0e2f9bc30f7 100644
--- a/encodings/runend/src/iter.rs
+++ b/encodings/runend/src/iter.rs
@@ -6,7 +6,6 @@ use std::cmp::min;
 use vortex_array::dtype::IntegerPType;
 use vortex_error::vortex_panic;
 
-#[inline]
 pub fn trimmed_ends_iter<E: IntegerPType>(
     run_ends: &[E],
     offset: usize,
diff --git a/encodings/runend/src/kernel.rs b/encodings/runend/src/kernel.rs
index ab51a8b4ae6..432453ee609 100644
--- a/encodings/runend/src/kernel.rs
+++ b/encodings/runend/src/kernel.rs
@@ -4,28 +4,28 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::SliceArray;
-use vortex_array::arrays::SliceVTable;
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::Slice;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::kernel::ExecuteParentKernel;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
-use crate::compute::take_from::RunEndVTableTakeFrom;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
+use crate::compute::take_from::RunEndTakeFrom;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<RunEndVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(RunEndVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<RunEnd> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(RunEnd)),
     ParentKernelSet::lift(&RunEndSliceKernel),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(RunEndVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(RunEndVTable)),
-    ParentKernelSet::lift(&RunEndVTableTakeFrom),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(RunEnd)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(RunEnd)),
+    ParentKernelSet::lift(&RunEndTakeFrom),
 ]);
 
 /// Kernel to execute slicing on a RunEnd array.
@@ -35,13 +35,13 @@ pub(super) const PARENT_KERNELS: ParentKernelSet<RunEndVTable> = ParentKernelSet
 #[derive(Debug)]
 struct RunEndSliceKernel;
 
-impl ExecuteParentKernel<RunEndVTable> for RunEndSliceKernel {
-    type Parent = SliceVTable;
+impl ExecuteParentKernel<RunEnd> for RunEndSliceKernel {
+    type Parent = Slice;
 
     fn execute_parent(
         &self,
-        array: &RunEndArray,
-        parent: &SliceArray,
+        array: ArrayView<'_, RunEnd>,
+        parent: ArrayView<'_, Slice>,
         _child_idx: usize,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -49,7 +49,7 @@ impl ExecuteParentKernel<RunEndVTable> for RunEndSliceKernel {
     }
 }
 
-fn slice(array: &RunEndArray, range: Range<usize>) -> VortexResult<ArrayRef> {
+fn slice(array: ArrayView<'_, RunEnd>, range: Range<usize>) -> VortexResult<ArrayRef> {
     let new_length = range.len();
 
     let slice_begin = array.find_physical_index(range.start)?;
@@ -63,7 +63,7 @@ fn slice(array: &RunEndArray, range: Range<usize>) -> VortexResult<ArrayRef> {
 
     // SAFETY: we maintain the ends invariant in our slice implementation
     Ok(unsafe {
-        RunEndArray::new_unchecked(
+        RunEnd::new_unchecked(
             array.ends().slice(slice_begin..slice_end)?,
             array.values().slice(slice_begin..slice_end)?,
             range.start + array.offset(),
diff --git a/encodings/runend/src/lib.rs b/encodings/runend/src/lib.rs
index c97da72ee3b..cff09767d38 100644
--- a/encodings/runend/src/lib.rs
+++ b/encodings/runend/src/lib.rs
@@ -13,6 +13,7 @@ mod array;
 mod arrow;
 pub mod compress;
 mod compute;
+pub mod decompress_bool;
 mod iter;
 mod kernel;
 mod ops;
@@ -25,37 +26,39 @@ pub mod _benchmarking {
     use super::*;
 }
 
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::is_constant::IsConstant;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::fns::min_max::MinMax;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
 use vortex_array::session::ArraySessionExt;
-use vortex_array::vtable::VisitorVTable;
 use vortex_session::VortexSession;
 
-impl VisitorVTable<RunEndVTable> for RunEndVTable {
-    fn visit_buffers(_array: &RunEndArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &RunEndArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &RunEndArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("ends", array.ends());
-        visitor.visit_child("values", array.values());
-    }
-
-    fn nchildren(_array: &RunEndArray) -> usize {
-        2
-    }
-}
-
 /// Initialize run-end encoding in the given session.
-pub fn initialize(session: &mut VortexSession) {
-    session.arrays().register(RunEndVTable::ID, RunEndVTable);
+pub fn initialize(session: &VortexSession) {
+    session.arrays().register(RunEnd);
+
+    // Register the RunEnd-specific aggregate kernels.
+    session.aggregate_fns().register_aggregate_kernel(
+        RunEnd::ID,
+        Some(MinMax.id()),
+        &compute::min_max::RunEndMinMaxKernel,
+    );
+    session.aggregate_fns().register_aggregate_kernel(
+        RunEnd::ID,
+        Some(IsConstant.id()),
+        &compute::is_constant::RunEndIsConstantKernel,
+    );
+    session.aggregate_fns().register_aggregate_kernel(
+        RunEnd::ID,
+        Some(IsSorted.id()),
+        &compute::is_sorted::RunEndIsSortedKernel,
+    );
 }
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::ProstMetadata;
+    use prost::Message;
     use vortex_array::dtype::PType;
     use vortex_array::test_harness::check_metadata;
 
@@ -66,11 +69,12 @@ mod tests {
     fn test_runend_metadata() {
         check_metadata(
             "runend.metadata",
-            ProstMetadata(RunEndMetadata {
+            &RunEndMetadata {
                 ends_ptype: PType::U64 as i32,
                 num_runs: u64::MAX,
                 offset: u64::MAX,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/encodings/runend/src/ops.rs b/encodings/runend/src/ops.rs
index 37ea347629d..c27885cc39a 100644
--- a/encodings/runend/src/ops.rs
+++ b/encodings/runend/src/ops.rs
@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::scalar::PValue;
 use vortex_array::scalar::Scalar;
 use vortex_array::search_sorted::SearchResult;
@@ -10,11 +12,15 @@ use vortex_array::search_sorted::SearchSortedSide;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-impl OperationsVTable<RunEndVTable> for RunEndVTable {
-    fn scalar_at(array: &RunEndArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<RunEnd> for RunEnd {
+    fn scalar_at(
+        array: ArrayView<'_, RunEnd>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         array.values().scalar_at(array.find_physical_index(index)?)
     }
 }
@@ -23,7 +29,7 @@ impl OperationsVTable<RunEndVTable> for RunEndVTable {
 ///
 /// If the index exists in the array we want to take that position (as we are searching from the right)
 /// otherwise we want to take the next one
-pub(crate) fn find_slice_end_index(array: &dyn Array, index: usize) -> VortexResult<usize> {
+pub(crate) fn find_slice_end_index(array: &ArrayRef, index: usize) -> VortexResult<usize> {
     let result = array
         .as_primitive_typed()
         .search_sorted(&PValue::from(index), SearchSortedSide::Right)?;
@@ -42,23 +48,22 @@ pub(crate) fn find_slice_end_index(array: &dyn Array, index: usize) -> VortexRes
 #[cfg(test)]
 mod tests {
 
-    use vortex_array::Array;
     use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::aggregate_fn::fns::is_constant::is_constant;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
-    use vortex_array::compute::Cost;
-    use vortex_array::compute::IsConstantOpts;
-    use vortex_array::compute::is_constant_opts;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_buffer::buffer;
 
-    use crate::RunEndArray;
+    use crate::RunEnd;
 
     #[test]
     fn slice_array() {
-        let arr = RunEndArray::try_new(
+        let arr = RunEnd::try_new(
             buffer![2u32, 5, 10].into_array(),
             buffer![1i32, 2, 3].into_array(),
         )
@@ -77,7 +82,7 @@ mod tests {
 
     #[test]
     fn double_slice() {
-        let arr = RunEndArray::try_new(
+        let arr = RunEnd::try_new(
             buffer![2u32, 5, 10].into_array(),
             buffer![1i32, 2, 3].into_array(),
         )
@@ -94,7 +99,7 @@ mod tests {
 
     #[test]
     fn slice_end_inclusive() {
-        let arr = RunEndArray::try_new(
+        let arr = RunEnd::try_new(
             buffer![2u32, 5, 10].into_array(),
             buffer![1i32, 2, 3].into_array(),
         )
@@ -113,7 +118,7 @@ mod tests {
 
     #[test]
     fn slice_at_end() {
-        let re_array = RunEndArray::try_new(
+        let re_array = RunEnd::try_new(
             buffer![7_u64, 10].into_array(),
             buffer![2_u64, 3].into_array(),
         )
@@ -127,7 +132,7 @@ mod tests {
 
     #[test]
     fn slice_single_end() {
-        let re_array = RunEndArray::try_new(
+        let re_array = RunEnd::try_new(
             buffer![7_u64, 10].into_array(),
             buffer![2_u64, 3].into_array(),
         )
@@ -137,21 +142,13 @@ mod tests {
 
         let sliced_array = re_array.slice(2..5).unwrap();
 
-        assert!(
-            is_constant_opts(
-                &sliced_array,
-                &IsConstantOpts {
-                    cost: Cost::Canonicalize
-                }
-            )
-            .unwrap()
-            .unwrap_or_default()
-        )
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(is_constant(&sliced_array, &mut ctx).unwrap())
     }
 
     #[test]
     fn ree_scalar_at_end() {
-        let scalar = RunEndArray::encode(buffer![1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5].into_array())
+        let scalar = RunEnd::encode(buffer![1, 1, 1, 4, 4, 4, 2, 2, 5, 5, 5, 5].into_array())
             .unwrap()
             .scalar_at(11)
             .unwrap();
@@ -163,7 +160,7 @@ mod tests {
     fn slice_along_run_boundaries() {
         // Create a runend array with runs: [1, 1, 1] [4, 4, 4] [2, 2] [5, 5, 5, 5]
         // Run ends at indices: 3, 6, 8, 12
-        let arr = RunEndArray::try_new(
+        let arr = RunEnd::try_new(
             buffer![3u32, 6, 8, 12].into_array(),
             buffer![1i32, 4, 2, 5].into_array(),
         )
diff --git a/encodings/runend/src/rules.rs b/encodings/runend/src/rules.rs
index 50489384056..73f9ef3cb7a 100644
--- a/encodings/runend/src/rules.rs
+++ b/encodings/runend/src/rules.rs
@@ -2,11 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::AnyScalarFn;
+use vortex_array::arrays::Constant;
 use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::ConstantVTable;
 use vortex_array::arrays::ScalarFnArray;
+use vortex_array::arrays::scalar_fn::AnyScalarFn;
+use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
+use vortex_array::arrays::scalar_fn::ScalarFnVTable;
 use vortex_array::dtype::DType;
 use vortex_array::optimizer::rules::ArrayParentReduceRule;
 use vortex_array::optimizer::rules::ParentRuleSet;
@@ -14,16 +17,16 @@ use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor;
 use vortex_error::VortexResult;
 
-use crate::RunEndArray;
-use crate::RunEndVTable;
+use crate::RunEnd;
+use crate::array::RunEndArrayExt;
 
-pub(super) const RULES: ParentRuleSet<RunEndVTable> = ParentRuleSet::new(&[
+pub(super) const RULES: ParentRuleSet<RunEnd> = ParentRuleSet::new(&[
     // CastReduceAdaptor must come before RunEndScalarFnRule so that cast operations are executed
     // eagerly (surfacing out-of-range errors immediately) rather than being pushed lazily into
     // the values array by the generic scalar function push-down rule.
-    ParentRuleSet::lift(&CastReduceAdaptor(RunEndVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(RunEnd)),
     ParentRuleSet::lift(&RunEndScalarFnRule),
-    ParentRuleSet::lift(&FillNullReduceAdaptor(RunEndVTable)),
+    ParentRuleSet::lift(&FillNullReduceAdaptor(RunEnd)),
 ]);
 
 /// A rule to push down scalar functions through run-end encoding into the values array.
@@ -32,22 +35,22 @@ pub(super) const RULES: ParentRuleSet<RunEndVTable> = ParentRuleSet::new(&[
 #[derive(Debug)]
 pub(crate) struct RunEndScalarFnRule;
 
-impl ArrayParentReduceRule<RunEndVTable> for RunEndScalarFnRule {
+impl ArrayParentReduceRule<RunEnd> for RunEndScalarFnRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        run_end: &RunEndArray,
-        parent: &ScalarFnArray,
+        run_end: ArrayView<'_, RunEnd>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
-        for (idx, child) in parent.children().iter().enumerate() {
+        for (idx, child) in parent.iter_children().enumerate() {
             if idx == child_idx {
                 // Skip ourselves
                 continue;
             }
 
-            if !child.is::<ConstantVTable>() {
+            if !child.is::<Constant>() {
                 // We can only push down if all other children are constants
                 return Ok(None);
             }
@@ -69,7 +72,7 @@ impl ArrayParentReduceRule<RunEndVTable> for RunEndScalarFnRule {
 
             // Replace other children with their constant scalar value with length adjusted
             // to the length of the run end values.
-            let constant = child.as_::<ConstantVTable>();
+            let constant = child.as_::<Constant>();
             *child = ConstantArray::new(constant.scalar().clone(), values_len).into_array();
         }
 
@@ -79,7 +82,7 @@ impl ArrayParentReduceRule<RunEndVTable> for RunEndScalarFnRule {
 
         Ok(Some(
             unsafe {
-                RunEndArray::new_unchecked(
+                RunEnd::new_unchecked(
                     run_end.ends().clone(),
                     new_values,
                     run_end.offset(),
diff --git a/encodings/sequence/public-api.lock b/encodings/sequence/public-api.lock
index a8d25f71fd0..aaacb5d3963 100644
--- a/encodings/sequence/public-api.lock
+++ b/encodings/sequence/public-api.lock
@@ -1,165 +1,129 @@
 pub mod vortex_sequence
 
-pub struct vortex_sequence::SequenceArray
+pub struct vortex_sequence::Sequence
 
-impl vortex_sequence::SequenceArray
+impl vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::base(&self) -> vortex_array::scalar::typed_view::primitive::pvalue::PValue
+pub const vortex_sequence::Sequence::ID: vortex_array::array::ArrayId
 
-pub fn vortex_sequence::SequenceArray::into_parts(self) -> vortex_sequence::SequenceArrayParts
+pub fn vortex_sequence::Sequence::try_new(base: vortex_array::scalar::typed_view::primitive::pvalue::PValue, multiplier: vortex_array::scalar::typed_view::primitive::pvalue::PValue, ptype: vortex_array::dtype::ptype::PType, nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_error::VortexResult<vortex_sequence::SequenceArray>
 
-pub fn vortex_sequence::SequenceArray::last(&self) -> vortex_array::scalar::typed_view::primitive::pvalue::PValue
+pub fn vortex_sequence::Sequence::try_new_typed<T: vortex_array::dtype::ptype::NativePType + core::convert::Into<vortex_array::scalar::typed_view::primitive::pvalue::PValue>>(base: T, multiplier: T, nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_error::VortexResult<vortex_sequence::SequenceArray>
 
-pub fn vortex_sequence::SequenceArray::multiplier(&self) -> vortex_array::scalar::typed_view::primitive::pvalue::PValue
+impl core::clone::Clone for vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::new(base: vortex_array::scalar::typed_view::primitive::pvalue::PValue, multiplier: vortex_array::scalar::typed_view::primitive::pvalue::PValue, ptype: vortex_array::dtype::ptype::PType, nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_sequence::Sequence::clone(&self) -> vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::ptype(&self) -> vortex_array::dtype::ptype::PType
+impl core::fmt::Debug for vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::typed_new<T: vortex_array::dtype::ptype::NativePType + core::convert::Into<vortex_array::scalar::typed_view::primitive::pvalue::PValue>>(base: T, multiplier: T, nullability: vortex_array::dtype::nullability::Nullability, length: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::clone::Clone for vortex_sequence::SequenceArray
+impl vortex_array::array::vtable::VTable for vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::clone(&self) -> vortex_sequence::SequenceArray
+pub type vortex_sequence::Sequence::ArrayData = vortex_sequence::SequenceData
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_sequence::SequenceArray
+pub type vortex_sequence::Sequence::OperationsVTable = vortex_sequence::Sequence
 
-pub fn vortex_sequence::SequenceArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_sequence::Sequence::ValidityVTable = vortex_sequence::Sequence
 
-impl core::convert::From<vortex_sequence::SequenceArray> for vortex_array::array::ArrayRef
+pub fn vortex_sequence::Sequence::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_sequence::SequenceArray) -> vortex_array::array::ArrayRef
+pub fn vortex_sequence::Sequence::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::fmt::Debug for vortex_sequence::SequenceArray
+pub fn vortex_sequence::Sequence::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub fn vortex_sequence::SequenceArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_sequence::Sequence::execute(array: vortex_array::array::typed::Array<Self>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-impl core::ops::deref::Deref for vortex_sequence::SequenceArray
+pub fn vortex_sequence::Sequence::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_sequence::SequenceArray::Target = dyn vortex_array::array::Array
+pub fn vortex_sequence::Sequence::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_sequence::SequenceArray::deref(&self) -> &Self::Target
+pub fn vortex_sequence::Sequence::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::array::IntoArray for vortex_sequence::SequenceArray
+pub fn vortex_sequence::Sequence::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_sequence::Sequence::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_sequence::SequenceArrayParts
+pub fn vortex_sequence::Sequence::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_sequence::SequenceArrayParts::base: vortex_array::scalar::typed_view::primitive::pvalue::PValue
+pub fn vortex_sequence::Sequence::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, _slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_sequence::SequenceArrayParts::len: usize
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_sequence::Sequence> for vortex_sequence::Sequence
 
-pub vortex_sequence::SequenceArrayParts::multiplier: vortex_array::scalar::typed_view::primitive::pvalue::PValue
+pub fn vortex_sequence::Sequence::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_sequence::Sequence>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_sequence::SequenceArrayParts::nullability: vortex_array::dtype::nullability::Nullability
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_sequence::Sequence> for vortex_sequence::Sequence
 
-pub vortex_sequence::SequenceArrayParts::ptype: vortex_array::dtype::ptype::PType
+pub fn vortex_sequence::Sequence::validity(_array: vortex_array::array::view::ArrayView<'_, vortex_sequence::Sequence>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub struct vortex_sequence::SequenceVTable
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_sequence::Sequence
 
-impl vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub const vortex_sequence::SequenceVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_sequence::Sequence
 
-impl core::fmt::Debug for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::slice::SliceReduce for vortex_sequence::Sequence
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::take(array: &vortex_sequence::SequenceArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_sequence::Sequence
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::compare(lhs: vortex_array::array::view::ArrayView<'_, Self>, rhs: &vortex_array::array::erased::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::filter(array: &vortex_sequence::SequenceArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_sequence::Sequence
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::list_contains::kernel::ListContainsElementReduce for vortex_sequence::Sequence
 
-impl vortex_array::compute::is_sorted::IsSortedKernel for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::Sequence::list_contains(list: &vortex_array::array::erased::ArrayRef, element: vortex_array::array::view::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::is_sorted(&self, array: &vortex_sequence::SequenceArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub struct vortex_sequence::SequenceData
 
-pub fn vortex_sequence::SequenceVTable::is_strict_sorted(&self, array: &vortex_sequence::SequenceArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_sequence::SequenceData
 
-impl vortex_array::compute::min_max::MinMaxKernel for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::base(&self) -> vortex_array::scalar::typed_view::primitive::pvalue::PValue
 
-pub fn vortex_sequence::SequenceVTable::min_max(&self, array: &vortex_sequence::SequenceArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::min_max::MinMaxResult>>
+pub fn vortex_sequence::SequenceData::into_parts(self) -> vortex_sequence::SequenceDataParts
 
-impl vortex_array::scalar_fn::fns::binary::compare::CompareKernel for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::multiplier(&self) -> vortex_array::scalar::typed_view::primitive::pvalue::PValue
 
-pub fn vortex_sequence::SequenceVTable::compare(lhs: &vortex_sequence::SequenceArray, rhs: &dyn vortex_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_sequence::SequenceData::ptype(&self) -> vortex_array::dtype::ptype::PType
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::validate(base: vortex_array::scalar::typed_view::primitive::pvalue::PValue, multiplier: vortex_array::scalar::typed_view::primitive::pvalue::PValue, dtype: &vortex_array::dtype::DType, length: usize) -> vortex_error::VortexResult<()>
 
-pub fn vortex_sequence::SequenceVTable::cast(array: &vortex_sequence::SequenceArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_sequence::SequenceData
 
-impl vortex_array::scalar_fn::fns::list_contains::kernel::ListContainsElementReduce for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::clone(&self) -> vortex_sequence::SequenceData
 
-pub fn vortex_sequence::SequenceVTable::list_contains(list: &dyn vortex_array::array::Array, element: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Debug for vortex_sequence::SequenceData
 
-impl vortex_array::vtable::VTable for vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_sequence::SequenceVTable::Array = vortex_sequence::SequenceArray
+impl core::fmt::Display for vortex_sequence::SequenceData
 
-pub type vortex_sequence::SequenceVTable::ArrayVTable = vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_sequence::SequenceVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_sequence::array::SequenceMetadata>
+impl vortex_array::hash::ArrayEq for vortex_sequence::SequenceData
 
-pub type vortex_sequence::SequenceVTable::OperationsVTable = vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub type vortex_sequence::SequenceVTable::ValidityVTable = vortex_sequence::SequenceVTable
+impl vortex_array::hash::ArrayHash for vortex_sequence::SequenceData
 
-pub type vortex_sequence::SequenceVTable::VisitorVTable = vortex_sequence::SequenceVTable
+pub fn vortex_sequence::SequenceData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_sequence::SequenceVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_sequence::SequenceArray>
+pub struct vortex_sequence::SequenceDataParts
 
-pub fn vortex_sequence::SequenceVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub vortex_sequence::SequenceDataParts::base: vortex_array::scalar::typed_view::primitive::pvalue::PValue
 
-pub fn vortex_sequence::SequenceVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub vortex_sequence::SequenceDataParts::multiplier: vortex_array::scalar::typed_view::primitive::pvalue::PValue
 
-pub fn vortex_sequence::SequenceVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_sequence::SequenceDataParts::ptype: vortex_array::dtype::ptype::PType
 
-pub fn vortex_sequence::SequenceVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_sequence::initialize(session: &vortex_session::VortexSession)
 
-pub fn vortex_sequence::SequenceVTable::metadata(array: &vortex_sequence::SequenceArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_sequence::sequence_encode(primitive_array: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sequence::SequenceVTable::reduce_parent(array: &vortex_sequence::SequenceArray, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
-
-pub fn vortex_sequence::SequenceVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
-pub fn vortex_sequence::SequenceVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
-
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_sequence::SequenceVTable> for vortex_sequence::SequenceVTable
-
-pub fn vortex_sequence::SequenceVTable::array_eq(array: &vortex_sequence::SequenceArray, other: &vortex_sequence::SequenceArray, _precision: vortex_array::hash::Precision) -> bool
-
-pub fn vortex_sequence::SequenceVTable::array_hash<H: core::hash::Hasher>(array: &vortex_sequence::SequenceArray, state: &mut H, _precision: vortex_array::hash::Precision)
-
-pub fn vortex_sequence::SequenceVTable::dtype(array: &vortex_sequence::SequenceArray) -> &vortex_array::dtype::DType
-
-pub fn vortex_sequence::SequenceVTable::len(array: &vortex_sequence::SequenceArray) -> usize
-
-pub fn vortex_sequence::SequenceVTable::stats(array: &vortex_sequence::SequenceArray) -> vortex_array::stats::array::StatsSetRef<'_>
-
-impl vortex_array::vtable::operations::OperationsVTable<vortex_sequence::SequenceVTable> for vortex_sequence::SequenceVTable
-
-pub fn vortex_sequence::SequenceVTable::scalar_at(array: &vortex_sequence::SequenceArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
-
-impl vortex_array::vtable::validity::ValidityVTable<vortex_sequence::SequenceVTable> for vortex_sequence::SequenceVTable
-
-pub fn vortex_sequence::SequenceVTable::validity(_array: &vortex_sequence::SequenceArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
-
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_sequence::SequenceVTable> for vortex_sequence::SequenceVTable
-
-pub fn vortex_sequence::SequenceVTable::nbuffers(_array: &vortex_sequence::SequenceArray) -> usize
-
-pub fn vortex_sequence::SequenceVTable::nchildren(_array: &vortex_sequence::SequenceArray) -> usize
-
-pub fn vortex_sequence::SequenceVTable::visit_buffers(_array: &vortex_sequence::SequenceArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
-
-pub fn vortex_sequence::SequenceVTable::visit_children(_array: &vortex_sequence::SequenceArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
-
-pub fn vortex_sequence::sequence_encode(primitive_array: &vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub type vortex_sequence::SequenceArray = vortex_array::array::typed::Array<vortex_sequence::Sequence>
diff --git a/encodings/sequence/src/array.rs b/encodings/sequence/src/array.rs
index 6009b6ab5a0..f941d4cf1a6 100644
--- a/encodings/sequence/src/array.rs
+++ b/encodings/sequence/src/array.rs
@@ -1,19 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
 use num_traits::cast::FromPrimitive;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::DeserializeMetadata;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
+use vortex_array::ExecutionResult;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
-use vortex_array::SerializeMetadata;
-use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
@@ -29,29 +33,25 @@ use vortex_array::scalar::PValue;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
 use vortex_array::stats::StatsSet;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
-use vortex_array::vtable::VisitorVTable;
-use vortex_buffer::BufferMut;
 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_error::vortex_panic;
 use vortex_session::VortexSession;
 
+use crate::compress::sequence_decompress;
 use crate::kernel::PARENT_KERNELS;
 use crate::rules::RULES;
 
-vtable!(Sequence);
+/// A [`Sequence`]-encoded Vortex array.
+pub type SequenceArray = Array<Sequence>;
 
 #[derive(Clone, prost::Message)]
 pub struct SequenceMetadata {
@@ -61,33 +61,35 @@ pub struct SequenceMetadata {
     multiplier: Option<vortex_proto::scalar::ScalarValue>,
 }
 
-/// Components of [`SequenceArray`].
-pub struct SequenceArrayParts {
-    pub base: PValue,
-    pub multiplier: PValue,
-    pub len: usize,
-    pub ptype: PType,
-    pub nullability: Nullability,
-}
+pub(super) const SLOT_NAMES: [&str; 0] = [];
 
 #[derive(Clone, Debug)]
 /// An array representing the equation `A[i] = base + i * multiplier`.
-pub struct SequenceArray {
+pub struct SequenceData {
     base: PValue,
     multiplier: PValue,
-    dtype: DType,
-    pub(crate) len: usize,
-    stats_set: ArrayStats,
 }
 
-impl SequenceArray {
-    pub fn typed_new<T: NativePType + Into<PValue>>(
+impl Display for SequenceData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "base: {}, multiplier: {}", self.base, self.multiplier)
+    }
+}
+
+pub struct SequenceDataParts {
+    pub base: PValue,
+    pub multiplier: PValue,
+    pub ptype: PType,
+}
+
+impl SequenceData {
+    pub(crate) fn try_new_typed<T: NativePType + Into<PValue>>(
         base: T,
         multiplier: T,
         nullability: Nullability,
         length: usize,
     ) -> VortexResult<Self> {
-        Self::new(
+        Self::try_new(
             base.into(),
             multiplier.into(),
             T::PTYPE,
@@ -97,73 +99,66 @@ impl SequenceArray {
     }
 
     /// Constructs a sequence array using two integer values (with the same ptype).
-    pub fn new(
+    pub(crate) fn try_new(
         base: PValue,
         multiplier: PValue,
         ptype: PType,
         nullability: Nullability,
         length: usize,
     ) -> VortexResult<Self> {
+        let dtype = DType::Primitive(ptype, nullability);
+        Self::validate(base, multiplier, &dtype, length)?;
+        let (base, multiplier) = Self::normalize(base, multiplier, ptype)?;
+
+        Ok(unsafe { Self::new_unchecked(base, multiplier) })
+    }
+
+    pub fn validate(
+        base: PValue,
+        multiplier: PValue,
+        dtype: &DType,
+        length: usize,
+    ) -> VortexResult<()> {
+        let DType::Primitive(ptype, _) = dtype else {
+            vortex_bail!("only primitive dtypes are supported in SequenceArray currently");
+        };
+
         if !ptype.is_int() {
             vortex_bail!("only integer ptype are supported in SequenceArray currently")
         }
 
-        Self::try_last(base, multiplier, ptype, length).map_err(|e| {
+        vortex_ensure!(length > 0, "SequenceArray length must be greater than zero");
+        Self::try_last(base, multiplier, *ptype, length).map_err(|e| {
             e.with_context(format!(
                 "final value not expressible, base = {base:?}, multiplier = {multiplier:?}, len = {length} ",
             ))
         })?;
 
-        Ok(Self::unchecked_new(
-            base,
-            multiplier,
-            ptype,
-            nullability,
-            length,
-        ))
+        Ok(())
     }
 
-    pub(crate) fn unchecked_new(
-        base: PValue,
-        multiplier: PValue,
-        ptype: PType,
-        nullability: Nullability,
-        length: usize,
-    ) -> Self {
-        let dtype = DType::Primitive(ptype, nullability);
-
-        // A sequence A[i] = base + i * multiplier is sorted iff multiplier >= 0,
-        // and strictly sorted iff multiplier > 0.
-
-        let (is_sorted, is_strict_sorted) = match_each_pvalue!(
-            multiplier,
-            uint: |v| { (true, v> 0) },
-            int: |v| { (v >= 0, v > 0) },
-            float: |_v| { unreachable!("float multiplier not supported") }
-        );
-
-        // SAFETY: we don't have duplicate stats
-        let stats_set = unsafe {
-            StatsSet::new_unchecked(vec![
-                (Stat::IsSorted, StatPrecision::Exact(is_sorted.into())),
-                (
-                    Stat::IsStrictSorted,
-                    StatPrecision::Exact(is_strict_sorted.into()),
-                ),
-            ])
-        };
+    fn normalize(base: PValue, multiplier: PValue, ptype: PType) -> VortexResult<(PValue, PValue)> {
+        match_each_integer_ptype!(ptype, |P| {
+            Ok((
+                PValue::from(base.cast::<P>()?),
+                PValue::from(multiplier.cast::<P>()?),
+            ))
+        })
+    }
 
-        Self {
-            base,
-            multiplier,
-            dtype,
-            len: length,
-            stats_set: ArrayStats::from(stats_set),
-        }
+    /// Constructs a [`SequenceArray`] payload without validation.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that:
+    /// - `base` and `multiplier` are both normalized to the same integer `ptype`.
+    /// - they are logically compatible with the outer dtype and len.
+    pub(crate) unsafe fn new_unchecked(base: PValue, multiplier: PValue) -> Self {
+        Self { base, multiplier }
     }
 
     pub fn ptype(&self) -> PType {
-        self.dtype.as_ptype()
+        self.base.ptype()
     }
 
     pub fn base(&self) -> PValue {
@@ -174,6 +169,14 @@ impl SequenceArray {
         self.multiplier
     }
 
+    pub fn into_parts(self) -> SequenceDataParts {
+        SequenceDataParts {
+            base: self.base,
+            multiplier: self.multiplier,
+            ptype: self.base.ptype(),
+        }
+    }
+
     pub(crate) fn try_last(
         base: PValue,
         multiplier: PValue,
@@ -195,8 +198,6 @@ impl SequenceArray {
     }
 
     pub(crate) fn index_value(&self, idx: usize) -> PValue {
-        assert!(idx < self.len, "index_value({idx}): index out of bounds");
-
         match_each_native_ptype!(self.ptype(), |P| {
             let base = self.base.cast::<P>().vortex_expect("must be able to cast");
             let multiplier = self
@@ -208,129 +209,127 @@ impl SequenceArray {
             PValue::from(value)
         })
     }
+}
 
-    /// Returns the validated final value of a sequence array
-    pub fn last(&self) -> PValue {
-        Self::try_last(self.base, self.multiplier, self.ptype(), self.len)
-            .vortex_expect("validated array")
+impl ArrayHash for SequenceData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.base.hash(state);
+        self.multiplier.hash(state);
     }
+}
 
-    pub fn into_parts(self) -> SequenceArrayParts {
-        SequenceArrayParts {
-            base: self.base,
-            multiplier: self.multiplier,
-            len: self.len,
-            ptype: self.dtype.as_ptype(),
-            nullability: self.dtype.nullability(),
-        }
+impl ArrayEq for SequenceData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.base == other.base && self.multiplier == other.multiplier
     }
 }
 
-impl VTable for SequenceVTable {
-    type Array = SequenceArray;
-
-    type Metadata = ProstMetadata<SequenceMetadata>;
+impl VTable for Sequence {
+    type ArrayData = SequenceData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &SequenceArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(SequenceMetadata {
-            base: Some((&array.base()).into()),
-            multiplier: Some((&array.multiplier()).into()),
-        }))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        SequenceData::validate(data.base, data.multiplier, dtype, len)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("SequenceArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("SequenceArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<SequenceMetadata> as DeserializeMetadata>::deserialize(bytes)?,
-        ))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let metadata = SequenceMetadata {
+            base: Some((&array.base()).into()),
+            multiplier: Some((&array.multiplier()).into()),
+        };
+
+        Ok(Some(metadata.encode_to_vec()))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
-        _children: &dyn ArrayChildren,
-    ) -> VortexResult<SequenceArray> {
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_ensure!(
+            buffers.is_empty(),
+            "SequenceArray expects 0 buffers, got {}",
+            buffers.len()
+        );
+        vortex_ensure!(
+            children.is_empty(),
+            "SequenceArray expects 0 children, got {}",
+            children.len()
+        );
+        let metadata = SequenceMetadata::decode(metadata)?;
+
         let ptype = dtype.as_ptype();
 
-        // We go via scalar to cast the scalar values into the correct PType
+        // We go via Scalar to validate that the value is valid for the ptype.
         let base = Scalar::from_proto_value(
             metadata
-                .0
                 .base
                 .as_ref()
                 .ok_or_else(|| vortex_err!("base required"))?,
             &DType::Primitive(ptype, NonNullable),
+            session,
         )?
         .as_primitive()
         .pvalue()
-        .vortex_expect("non-nullable primitive");
+        .vortex_expect("sequence array base should be a non-nullable primitive");
 
         let multiplier = Scalar::from_proto_value(
             metadata
-                .0
                 .multiplier
                 .as_ref()
                 .ok_or_else(|| vortex_err!("multiplier required"))?,
             &DType::Primitive(ptype, NonNullable),
+            session,
         )?
         .as_primitive()
         .pvalue()
-        .vortex_expect("non-nullable primitive");
+        .vortex_expect("sequence array multiplier should be a non-nullable primitive");
 
-        Ok(SequenceArray::unchecked_new(
-            base,
-            multiplier,
-            ptype,
-            dtype.nullability(),
-            len,
-        ))
+        let data = SequenceData::try_new(base, multiplier, ptype, dtype.nullability(), len)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data))
     }
 
-    fn with_children(_array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.is_empty(),
-            "SequenceArray expects 0 children, got {}",
-            children.len()
-        );
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        let prim = match_each_native_ptype!(array.ptype(), |P| {
-            let base = array.base().cast::<P>()?;
-            let multiplier = array.multiplier().cast::<P>()?;
-            let values = BufferMut::from_iter(
-                (0..array.len())
-                    .map(|i| base + <P>::from_usize(i).vortex_expect("must fit") * multiplier),
-            );
-            PrimitiveArray::new(values, array.dtype.nullability().into())
-        });
-
-        Ok(prim.into_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        sequence_decompress(&array).map(ExecutionResult::done)
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -339,7 +338,7 @@ impl VTable for SequenceVTable {
     }
 
     fn reduce_parent(
-        array: &SequenceArray,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -347,40 +346,12 @@ impl VTable for SequenceVTable {
     }
 }
 
-impl BaseArrayVTable<SequenceVTable> for SequenceVTable {
-    fn len(array: &SequenceArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &SequenceArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &SequenceArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &SequenceArray,
-        state: &mut H,
-        _precision: Precision,
-    ) {
-        array.base.hash(state);
-        array.multiplier.hash(state);
-        array.dtype.hash(state);
-        array.len.hash(state);
-    }
-
-    fn array_eq(array: &SequenceArray, other: &SequenceArray, _precision: Precision) -> bool {
-        array.base == other.base
-            && array.multiplier == other.multiplier
-            && array.dtype == other.dtype
-            && array.len == other.len
-    }
-}
-
-impl OperationsVTable<SequenceVTable> for SequenceVTable {
-    fn scalar_at(array: &SequenceArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Sequence> for Sequence {
+    fn scalar_at(
+        array: ArrayView<'_, Sequence>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Scalar::try_new(
             array.dtype().clone(),
             Some(ScalarValue::Primitive(array.index_value(index))),
@@ -388,33 +359,94 @@ impl OperationsVTable<SequenceVTable> for SequenceVTable {
     }
 }
 
-impl ValidityVTable<SequenceVTable> for SequenceVTable {
-    fn validity(_array: &SequenceArray) -> VortexResult<Validity> {
+impl ValidityVTable<Sequence> for Sequence {
+    fn validity(_array: ArrayView<'_, Sequence>) -> VortexResult<Validity> {
         Ok(Validity::AllValid)
     }
 }
 
-impl VisitorVTable<SequenceVTable> for SequenceVTable {
-    fn visit_buffers(_array: &SequenceArray, _visitor: &mut dyn ArrayBufferVisitor) {
-        // TODO(joe): expose scalar values
-    }
+#[derive(Clone, Debug)]
+pub struct Sequence;
 
-    fn nbuffers(_array: &SequenceArray) -> usize {
-        0
-    }
+impl Sequence {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.sequence");
 
-    fn visit_children(_array: &SequenceArray, _visitor: &mut dyn ArrayChildVisitor) {}
+    fn stats(multiplier: PValue) -> StatsSet {
+        // A sequence A[i] = base + i * multiplier is sorted iff multiplier >= 0,
+        // and strictly sorted iff multiplier > 0.
+        let (is_sorted, is_strict_sorted) = match_each_pvalue!(
+            multiplier,
+            uint: |v| { (true, v > 0) },
+            int: |v| { (v >= 0, v > 0) },
+            float: |_v| { unreachable!("float multiplier not supported") }
+        );
 
-    fn nchildren(_array: &SequenceArray) -> usize {
-        0
+        // SAFETY: we don't have duplicate stats.
+        unsafe {
+            StatsSet::new_unchecked(vec![
+                (Stat::IsSorted, StatPrecision::Exact(is_sorted.into())),
+                (
+                    Stat::IsStrictSorted,
+                    StatPrecision::Exact(is_strict_sorted.into()),
+                ),
+            ])
+        }
     }
-}
 
-#[derive(Debug)]
-pub struct SequenceVTable;
+    /// Construct a new [`SequenceArray`] from pre-validated parts.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure the sequence is logically compatible with the provided dtype and len.
+    pub(crate) unsafe fn new_unchecked(
+        base: PValue,
+        multiplier: PValue,
+        ptype: PType,
+        nullability: Nullability,
+        length: usize,
+    ) -> SequenceArray {
+        let dtype = DType::Primitive(ptype, nullability);
+        let (base, multiplier) = SequenceData::normalize(base, multiplier, ptype)
+            .vortex_expect("SequenceArray parts must be normalized to the target ptype");
+        let stats = Self::stats(multiplier);
+        let data = unsafe { SequenceData::new_unchecked(base, multiplier) };
+        unsafe { Array::from_parts_unchecked(ArrayParts::new(Sequence, dtype, length, data)) }
+            .with_stats_set(stats)
+    }
 
-impl SequenceVTable {
-    pub const ID: ArrayId = ArrayId::new_ref("vortex.sequence");
+    /// Construct a new [`SequenceArray`] from its components.
+    pub fn try_new(
+        base: PValue,
+        multiplier: PValue,
+        ptype: PType,
+        nullability: Nullability,
+        length: usize,
+    ) -> VortexResult<SequenceArray> {
+        let dtype = DType::Primitive(ptype, nullability);
+        let data = SequenceData::try_new(base, multiplier, ptype, nullability, length)?;
+        let stats = Self::stats(data.multiplier());
+        Ok(
+            unsafe { Array::from_parts_unchecked(ArrayParts::new(Sequence, dtype, length, data)) }
+                .with_stats_set(stats),
+        )
+    }
+
+    /// Construct a new typed [`SequenceArray`] from base/multiplier values.
+    pub fn try_new_typed<T: NativePType + Into<PValue>>(
+        base: T,
+        multiplier: T,
+        nullability: Nullability,
+        length: usize,
+    ) -> VortexResult<SequenceArray> {
+        let ptype = T::PTYPE;
+        let dtype = DType::Primitive(ptype, nullability);
+        let data = SequenceData::try_new_typed(base, multiplier, nullability, length)?;
+        let stats = Self::stats(data.multiplier());
+        Ok(
+            unsafe { Array::from_parts_unchecked(ArrayParts::new(Sequence, dtype, length, data)) }
+                .with_stats_set(stats),
+        )
+    }
 }
 
 #[cfg(test)]
@@ -429,11 +461,11 @@ mod tests {
     use vortex_array::scalar::ScalarValue;
     use vortex_error::VortexResult;
 
-    use crate::array::SequenceArray;
+    use crate::Sequence;
 
     #[test]
     fn test_sequence_canonical() {
-        let arr = SequenceArray::typed_new(2i64, 3, Nullability::NonNullable, 4).unwrap();
+        let arr = Sequence::try_new_typed(2i64, 3, Nullability::NonNullable, 4).unwrap();
 
         let canon = PrimitiveArray::from_iter((0..4).map(|i| 2i64 + i * 3));
 
@@ -442,7 +474,7 @@ mod tests {
 
     #[test]
     fn test_sequence_slice_canonical() {
-        let arr = SequenceArray::typed_new(2i64, 3, Nullability::NonNullable, 4)
+        let arr = Sequence::try_new_typed(2i64, 3, Nullability::NonNullable, 4)
             .unwrap()
             .slice(2..3)
             .unwrap();
@@ -454,7 +486,7 @@ mod tests {
 
     #[test]
     fn test_sequence_scalar_at() {
-        let scalar = SequenceArray::typed_new(2i64, 3, Nullability::NonNullable, 4)
+        let scalar = Sequence::try_new_typed(2i64, 3, Nullability::NonNullable, 4)
             .unwrap()
             .scalar_at(2)
             .unwrap();
@@ -467,19 +499,19 @@ mod tests {
 
     #[test]
     fn test_sequence_min_max() {
-        assert!(SequenceArray::typed_new(-127i8, -1i8, Nullability::NonNullable, 2).is_ok());
-        assert!(SequenceArray::typed_new(126i8, -1i8, Nullability::NonNullable, 2).is_ok());
+        assert!(Sequence::try_new_typed(-127i8, -1i8, Nullability::NonNullable, 2).is_ok());
+        assert!(Sequence::try_new_typed(126i8, -1i8, Nullability::NonNullable, 2).is_ok());
     }
 
     #[test]
     fn test_sequence_too_big() {
-        assert!(SequenceArray::typed_new(127i8, 1i8, Nullability::NonNullable, 2).is_err());
-        assert!(SequenceArray::typed_new(-128i8, -1i8, Nullability::NonNullable, 2).is_err());
+        assert!(Sequence::try_new_typed(127i8, 1i8, Nullability::NonNullable, 2).is_err());
+        assert!(Sequence::try_new_typed(-128i8, -1i8, Nullability::NonNullable, 2).is_err());
     }
 
     #[test]
     fn positive_multiplier_is_strict_sorted() -> VortexResult<()> {
-        let arr = SequenceArray::typed_new(0i64, 3, Nullability::NonNullable, 4)?;
+        let arr = Sequence::try_new_typed(0i64, 3, Nullability::NonNullable, 4)?;
 
         let is_sorted = arr
             .statistics()
@@ -495,7 +527,7 @@ mod tests {
 
     #[test]
     fn zero_multiplier_is_sorted_not_strict() -> VortexResult<()> {
-        let arr = SequenceArray::typed_new(5i64, 0, Nullability::NonNullable, 4)?;
+        let arr = Sequence::try_new_typed(5i64, 0, Nullability::NonNullable, 4)?;
 
         let is_sorted = arr
             .statistics()
@@ -511,7 +543,7 @@ mod tests {
 
     #[test]
     fn negative_multiplier_not_sorted() -> VortexResult<()> {
-        let arr = SequenceArray::typed_new(10i64, -1, Nullability::NonNullable, 4)?;
+        let arr = Sequence::try_new_typed(10i64, -1, Nullability::NonNullable, 4)?;
 
         let is_sorted = arr
             .statistics()
@@ -530,7 +562,7 @@ mod tests {
     #[test]
     fn test_large_multiplier_sorted() -> VortexResult<()> {
         let large_multiplier = (i64::MAX as u64) + 1;
-        let arr = SequenceArray::typed_new(0, large_multiplier, Nullability::NonNullable, 2)?;
+        let arr = Sequence::try_new_typed(0, large_multiplier, Nullability::NonNullable, 2)?;
 
         let is_sorted = arr
             .statistics()
diff --git a/encodings/sequence/src/compress.rs b/encodings/sequence/src/compress.rs
index 1a561f8b23f..6321aa3df78 100644
--- a/encodings/sequence/src/compress.rs
+++ b/encodings/sequence/src/compress.rs
@@ -1,17 +1,82 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::ops::Add;
+
 use num_traits::CheckedAdd;
 use num_traits::CheckedSub;
 use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
 use vortex_array::match_each_integer_ptype;
+use vortex_array::match_each_native_ptype;
 use vortex_array::scalar::PValue;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_buffer::trusted_len::TrustedLen;
 use vortex_error::VortexResult;
 
+use crate::Sequence;
 use crate::SequenceArray;
+use crate::SequenceData;
+/// An iterator that yields `base, base + step, base + 2*step, ...` via repeated addition.
+struct SequenceIter<T> {
+    acc: T,
+    step: T,
+    remaining: usize,
+}
+
+impl<T: Copy + Add<Output = T>> Iterator for SequenceIter<T> {
+    type Item = T;
+
+    #[inline]
+    fn next(&mut self) -> Option<T> {
+        if self.remaining == 0 {
+            return None;
+        }
+        let val = self.acc;
+        self.remaining -= 1;
+        if self.remaining > 0 {
+            self.acc = self.acc + self.step;
+        }
+        Some(val)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
+    }
+}
+
+// SAFETY: `size_hint` returns an exact count and `next` yields exactly that many items.
+unsafe impl<T: Copy + Add<Output = T>> TrustedLen for SequenceIter<T> {}
+
+/// Decompresses a [`SequenceArray`] into a [`PrimitiveArray`].
+#[inline]
+pub fn sequence_decompress(array: &SequenceArray) -> VortexResult<ArrayRef> {
+    fn decompress_inner<P: NativePType>(
+        base: P,
+        multiplier: P,
+        len: usize,
+        nullability: Nullability,
+    ) -> PrimitiveArray {
+        let values = BufferMut::from_trusted_len_iter(SequenceIter {
+            acc: base,
+            step: multiplier,
+            remaining: len,
+        });
+        PrimitiveArray::new(values, Validity::from(nullability))
+    }
+
+    let prim = match_each_native_ptype!(array.ptype(), |P| {
+        let base = array.base().cast::<P>()?;
+        let multiplier = array.multiplier().cast::<P>()?;
+        decompress_inner(base, multiplier, array.len(), array.dtype().nullability())
+    });
+    Ok(prim.into_array())
+}
 
 /// Encodes a primitive array into a sequence array, this is possible if:
 /// 1. The array is not empty, and contains no nulls
@@ -48,8 +113,8 @@ fn encode_primitive_array<P: NativePType + Into<PValue> + CheckedAdd + CheckedSu
 ) -> VortexResult<Option<ArrayRef>> {
     if slice.len() == 1 {
         // The multiplier here can be any value, zero is chosen
-        return SequenceArray::typed_new(slice[0], P::zero(), nullability, 1)
-            .map(|a| Some(a.to_array()));
+        return Sequence::try_new_typed(slice[0], P::zero(), nullability, 1)
+            .map(|a| Some(a.into_array()));
     }
     let base = slice[0];
     let Some(multiplier) = slice[1].checked_sub(&base) else {
@@ -60,7 +125,7 @@ fn encode_primitive_array<P: NativePType + Into<PValue> + CheckedAdd + CheckedSu
         return Ok(None);
     }
 
-    if SequenceArray::try_last(base.into(), multiplier.into(), P::PTYPE, slice.len()).is_err() {
+    if SequenceData::try_last(base.into(), multiplier.into(), P::PTYPE, slice.len()).is_err() {
         // If the last value is out of range, we cannot encode
         return Ok(None);
     }
@@ -69,8 +134,8 @@ fn encode_primitive_array<P: NativePType + Into<PValue> + CheckedAdd + CheckedSu
         .windows(2)
         .all(|w| Some(w[1]) == w[0].checked_add(&multiplier))
         .then_some(
-            SequenceArray::typed_new(base, multiplier, nullability, slice.len())
-                .map(|a| a.to_array()),
+            Sequence::try_new_typed(base, multiplier, nullability, slice.len())
+                .map(|a| a.into_array()),
         )
         .transpose()
 }
@@ -118,4 +183,13 @@ mod tests {
         let encoded = sequence_encode(&primitive_array).unwrap();
         assert!(encoded.is_none());
     }
+
+    #[test]
+    fn test_encode_all_u8_values() {
+        let primitive_array = PrimitiveArray::from_iter(0u8..=255);
+        let encoded = sequence_encode(&primitive_array).unwrap();
+        assert!(encoded.is_some());
+        let decoded = encoded.unwrap().to_primitive();
+        assert_arrays_eq!(decoded, primitive_array);
+    }
 }
diff --git a/encodings/sequence/src/compute/cast.rs b/encodings/sequence/src/compute/cast.rs
index dd0e94ede7d..1eb9ddf47d8 100644
--- a/encodings/sequence/src/compute/cast.rs
+++ b/encodings/sequence/src/compute/cast.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
@@ -11,11 +12,9 @@ use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
-use crate::SequenceArray;
-use crate::SequenceVTable;
-
-impl CastReduce for SequenceVTable {
-    fn cast(array: &SequenceArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::Sequence;
+impl CastReduce for Sequence {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // SequenceArray represents arithmetic sequences (base + i * multiplier) which
         // only makes sense for integer types. Floating-point sequences would accumulate
         // rounding errors, and other types don't support arithmetic operations.
@@ -32,7 +31,7 @@ impl CastReduce for SequenceVTable {
             // For SequenceArray, we can just create a new one with the same parameters
             // but different nullability
             return Ok(Some(
-                SequenceArray::new(
+                Sequence::try_new(
                     array.base(),
                     array.multiplier(),
                     *target_ptype,
@@ -71,7 +70,7 @@ impl CastReduce for SequenceVTable {
                 .ok_or_else(|| vortex_err!("Cast resulted in null multiplier value"))?;
 
             return Ok(Some(
-                SequenceArray::new(
+                Sequence::try_new(
                     new_base,
                     new_multiplier,
                     *target_ptype,
@@ -89,6 +88,7 @@ impl CastReduce for SequenceVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
@@ -98,15 +98,16 @@ mod tests {
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
 
+    use crate::Sequence;
     use crate::SequenceArray;
 
     #[test]
     fn test_cast_sequence_nullability() {
-        let sequence = SequenceArray::typed_new(0u32, 1u32, Nullability::NonNullable, 4).unwrap();
+        let sequence = Sequence::try_new_typed(0u32, 1u32, Nullability::NonNullable, 4).unwrap();
 
         // Cast to nullable
         let casted = sequence
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -117,11 +118,10 @@ mod tests {
 
     #[test]
     fn test_cast_sequence_u32_to_i64() {
-        let sequence =
-            SequenceArray::typed_new(100u32, 10u32, Nullability::NonNullable, 4).unwrap();
+        let sequence = Sequence::try_new_typed(100u32, 10u32, Nullability::NonNullable, 4).unwrap();
 
         let casted = sequence
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -137,10 +137,10 @@ mod tests {
     #[test]
     fn test_cast_sequence_i16_to_i32_nullable() {
         // Test ptype change AND nullability change in one cast
-        let sequence = SequenceArray::typed_new(5i16, 3i16, Nullability::NonNullable, 3).unwrap();
+        let sequence = Sequence::try_new_typed(5i16, 3i16, Nullability::NonNullable, 3).unwrap();
 
         let casted = sequence
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I32, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -158,11 +158,11 @@ mod tests {
 
     #[test]
     fn test_cast_sequence_to_float_delegates_to_canonical() {
-        let sequence = SequenceArray::typed_new(0i32, 1i32, Nullability::NonNullable, 5).unwrap();
+        let sequence = Sequence::try_new_typed(0i32, 1i32, Nullability::NonNullable, 5).unwrap();
 
         // Cast to float should delegate to canonical (SequenceArray doesn't support float)
         let casted = sequence
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F32, Nullability::NonNullable))
             .unwrap();
         // Should still succeed by decoding to canonical first
@@ -180,21 +180,21 @@ mod tests {
     }
 
     #[rstest]
-    #[case::i32(SequenceArray::typed_new(0i32, 1i32, Nullability::NonNullable, 5).unwrap())]
-    #[case::u64(SequenceArray::typed_new(1000u64, 100u64, Nullability::NonNullable, 4).unwrap())]
+    #[case::i32(Sequence::try_new_typed(0i32, 1i32, Nullability::NonNullable, 5).unwrap())]
+    #[case::u64(Sequence::try_new_typed(1000u64, 100u64, Nullability::NonNullable, 4).unwrap())]
     // TODO(DK): SequenceArray does not actually conform. You cannot cast this array to u8 even
     // though all its values are representable therein.
     //
-    // #[case::negative_step(SequenceArray::typed_new(100i32, -10i32, Nullability::NonNullable,
+    // #[case::negative_step(Sequence::try_new_typed(100i32, -10i32, Nullability::NonNullable,
     // 5).unwrap())]
-    #[case::single(SequenceArray::typed_new(42i64, 0i64, Nullability::NonNullable, 1).unwrap())]
-    #[case::constant(SequenceArray::typed_new(
+    #[case::single(Sequence::try_new_typed(42i64, 0i64, Nullability::NonNullable, 1).unwrap())]
+    #[case::constant(Sequence::try_new_typed(
         100i32,
         0i32, // multiplier of 0 means constant array
         Nullability::NonNullable,
         5,
     ).unwrap())]
     fn test_cast_sequence_conformance(#[case] sequence: SequenceArray) {
-        test_cast_conformance(sequence.as_ref());
+        test_cast_conformance(&sequence.into_array());
     }
 }
diff --git a/encodings/sequence/src/compute/compare.rs b/encodings/sequence/src/compute/compare.rs
index b2ec5770491..c0c9d1367d6 100644
--- a/encodings/sequence/src/compute/compare.rs
+++ b/encodings/sequence/src/compute/compare.rs
@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 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::ConstantArray;
 use vortex_array::dtype::NativePType;
@@ -19,13 +20,12 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
-use crate::SequenceArray;
-use crate::array::SequenceVTable;
+use crate::array::Sequence;
 
-impl CompareKernel for SequenceVTable {
+impl CompareKernel for Sequence {
     fn compare(
-        lhs: &SequenceArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -57,10 +57,10 @@ impl CompareKernel for SequenceVTable {
 
         if let Ok(set_idx) = set_idx {
             let buffer = BitBuffer::from_iter((0..lhs.len()).map(|idx| idx == set_idx));
-            Ok(Some(BoolArray::new(buffer, validity).to_array()))
+            Ok(Some(BoolArray::new(buffer, validity).into_array()))
         } else {
             Ok(Some(
-                ConstantArray::new(Scalar::bool(false, nullability), lhs.len()).to_array(),
+                ConstantArray::new(Scalar::bool(false, nullability), lhs.len()).into_array(),
             ))
         }
     }
@@ -135,6 +135,7 @@ fn find_intersection<P: NativePType>(
 
 #[cfg(test)]
 mod tests {
+    use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::ConstantArray;
     use vortex_array::assert_arrays_eq;
@@ -143,31 +144,40 @@ mod tests {
     use vortex_array::dtype::Nullability::Nullable;
     use vortex_array::scalar_fn::fns::operators::Operator;
 
-    use crate::SequenceArray;
+    use crate::Sequence;
 
     #[test]
     fn test_compare_match() {
-        let lhs = SequenceArray::typed_new(2i64, 1, NonNullable, 4).unwrap();
+        let lhs = Sequence::try_new_typed(2i64, 1, NonNullable, 4).unwrap();
         let rhs = ConstantArray::new(4i64, lhs.len());
-        let result = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let result = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
         let expected = BoolArray::from_iter([false, false, true, false]);
         assert_arrays_eq!(result, expected);
     }
 
     #[test]
     fn test_compare_match_scale() {
-        let lhs = SequenceArray::typed_new(2i64, 3, Nullable, 4).unwrap();
+        let lhs = Sequence::try_new_typed(2i64, 3, Nullable, 4).unwrap();
         let rhs = ConstantArray::new(8i64, lhs.len());
-        let result = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let result = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
         let expected = BoolArray::from_iter([Some(false), Some(false), Some(true), Some(false)]);
         assert_arrays_eq!(result, expected);
     }
 
     #[test]
     fn test_compare_no_match() {
-        let lhs = SequenceArray::typed_new(2i64, 1, NonNullable, 4).unwrap();
+        let lhs = Sequence::try_new_typed(2i64, 1, NonNullable, 4).unwrap();
         let rhs = ConstantArray::new(1i64, lhs.len());
-        let result = lhs.to_array().binary(rhs.to_array(), Operator::Eq).unwrap();
+        let result = lhs
+            .into_array()
+            .binary(rhs.into_array(), Operator::Eq)
+            .unwrap();
         let expected = BoolArray::from_iter([false, false, false, false]);
         assert_arrays_eq!(result, expected);
     }
diff --git a/encodings/sequence/src/compute/filter.rs b/encodings/sequence/src/compute/filter.rs
index 50253cb53a9..3ef24188fbf 100644
--- a/encodings/sequence/src/compute/filter.rs
+++ b/encodings/sequence/src/compute/filter.rs
@@ -2,10 +2,11 @@
 // 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::arrays::FilterKernel;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_native_ptype;
 use vortex_array::validity::Validity;
@@ -14,12 +15,11 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::SequenceArray;
-use crate::SequenceVTable;
+use crate::Sequence;
 
-impl FilterKernel for SequenceVTable {
+impl FilterKernel for Sequence {
     fn filter(
-        array: &SequenceArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -47,27 +47,29 @@ fn filter_impl<T: NativePType>(mul: T, base: T, mask: &Mask, validity: Validity)
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::compute::conformance::filter::LARGE_SIZE;
     use vortex_array::compute::conformance::filter::MEDIUM_SIZE;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
     use vortex_array::dtype::Nullability;
 
+    use crate::Sequence;
     use crate::SequenceArray;
 
     #[rstest]
-    #[case(SequenceArray::typed_new(0i32, 1, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(10i32, 2, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(100i32, -3, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(0i32, 1, Nullability::NonNullable, 1).unwrap())]
-    #[case(SequenceArray::typed_new(0i32, 1, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
-    #[case(SequenceArray::typed_new(0i32, 1, Nullability::NonNullable, LARGE_SIZE).unwrap())]
-    #[case(SequenceArray::typed_new(0i64, 1, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(1000i64, 50, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(-100i64, 10, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
-    #[case(SequenceArray::typed_new(0u32, 1, Nullability::NonNullable, 5).unwrap())]
-    #[case(SequenceArray::typed_new(0u32, 5, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
-    #[case(SequenceArray::typed_new(0u64, 1, Nullability::NonNullable, LARGE_SIZE).unwrap())]
+    #[case(Sequence::try_new_typed(0i32, 1, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(10i32, 2, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(100i32, -3, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(0i32, 1, Nullability::NonNullable, 1).unwrap())]
+    #[case(Sequence::try_new_typed(0i32, 1, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
+    #[case(Sequence::try_new_typed(0i32, 1, Nullability::NonNullable, LARGE_SIZE).unwrap())]
+    #[case(Sequence::try_new_typed(0i64, 1, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(1000i64, 50, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(-100i64, 10, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
+    #[case(Sequence::try_new_typed(0u32, 1, Nullability::NonNullable, 5).unwrap())]
+    #[case(Sequence::try_new_typed(0u32, 5, Nullability::NonNullable, MEDIUM_SIZE).unwrap())]
+    #[case(Sequence::try_new_typed(0u64, 1, Nullability::NonNullable, LARGE_SIZE).unwrap())]
     fn test_filter_sequence_conformance(#[case] array: SequenceArray) {
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/encodings/sequence/src/compute/is_sorted.rs b/encodings/sequence/src/compute/is_sorted.rs
index cec77aa837a..c930246508f 100644
--- a/encodings/sequence/src/compute/is_sorted.rs
+++ b/encodings/sequence/src/compute/is_sorted.rs
@@ -2,29 +2,51 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use num_traits::zero;
-use vortex_array::compute::IsSortedKernel;
-use vortex_array::compute::IsSortedKernelAdapter;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
 use vortex_array::match_each_native_ptype;
-use vortex_array::register_kernel;
+use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
-use crate::SequenceArray;
-use crate::SequenceVTable;
+use crate::Sequence;
 
-impl IsSortedKernel for SequenceVTable {
-    fn is_sorted(&self, array: &SequenceArray) -> VortexResult<Option<bool>> {
-        let m = array.multiplier();
-        match_each_native_ptype!(m.ptype(), |P| {
-            m.cast::<P>().map(|x| Some(x >= zero::<P>()))
-        })
-    }
+/// Sequence-specific is_sorted kernel.
+///
+/// A sequence `A[i] = base + i * multiplier` is sorted iff multiplier >= 0,
+/// and strict sorted iff multiplier > 0.
+#[derive(Debug)]
+pub(crate) struct SequenceIsSortedKernel;
+
+impl DynAggregateKernel for SequenceIsSortedKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let _ = ctx;
+        let Some(options) = aggregate_fn.as_opt::<IsSorted>() else {
+            return Ok(None);
+        };
+
+        let Some(array) = batch.as_opt::<Sequence>() else {
+            return Ok(None);
+        };
 
-    fn is_strict_sorted(&self, array: &SequenceArray) -> VortexResult<Option<bool>> {
         let m = array.multiplier();
-        match_each_native_ptype!(m.ptype(), |P| {
-            m.cast::<P>().map(|x| Some(x > zero::<P>()))
-        })
+        let result = match_each_native_ptype!(m.ptype(), |P| {
+            m.cast::<P>().map(|x| {
+                if options.strict {
+                    x > zero::<P>()
+                } else {
+                    x >= zero::<P>()
+                }
+            })
+        })?;
+
+        Ok(Some(IsSorted::make_partial(batch, result, options.strict)?))
     }
 }
-
-register_kernel!(IsSortedKernelAdapter(SequenceVTable).lift());
diff --git a/encodings/sequence/src/compute/list_contains.rs b/encodings/sequence/src/compute/list_contains.rs
index 2155c4aac2f..fa2cacb5e19 100644
--- a/encodings/sequence/src/compute/list_contains.rs
+++ b/encodings/sequence/src/compute/list_contains.rs
@@ -1,18 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
 use vortex_array::arrays::BoolArray;
 use vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::array::SequenceVTable;
+use crate::array::Sequence;
 use crate::compute::compare::find_intersection_scalar;
 
-impl ListContainsElementReduce for SequenceVTable {
-    fn list_contains(list: &dyn Array, element: &Self::Array) -> VortexResult<Option<ArrayRef>> {
+impl ListContainsElementReduce for Sequence {
+    fn list_contains(
+        list: &ArrayRef,
+        element: ArrayView<'_, Self>,
+    ) -> VortexResult<Option<ArrayRef>> {
         let Some(list_scalar) = list.as_constant() else {
             return Ok(None);
         };
@@ -40,7 +44,7 @@ impl ListContainsElementReduce for SequenceVTable {
         let nullability = list.dtype().nullability() | element.dtype().nullability();
 
         Ok(Some(
-            BoolArray::from_indices(element.len(), set_indices, nullability.into()).to_array(),
+            BoolArray::from_indices(element.len(), set_indices, nullability.into()).into_array(),
         ))
     }
 }
@@ -49,7 +53,7 @@ impl ListContainsElementReduce for SequenceVTable {
 mod tests {
     use std::sync::Arc;
 
-    use vortex_array::Array;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::Nullability;
@@ -59,7 +63,7 @@ mod tests {
     use vortex_array::expr::root;
     use vortex_array::scalar::Scalar;
 
-    use crate::SequenceArray;
+    use crate::Sequence;
 
     #[test]
     fn test_list_contains_seq() {
@@ -73,10 +77,12 @@ mod tests {
             // [1, 3] in  1
             //            2
             //            3
-            let array = SequenceArray::typed_new(1, 1, Nullability::NonNullable, 3).unwrap();
+            let array = Sequence::try_new_typed(1, 1, Nullability::NonNullable, 3)
+                .unwrap()
+                .into_array();
 
             let expr = list_contains(lit(list_scalar.clone()), root());
-            let result = array.apply(&expr).unwrap();
+            let result = array.into_array().apply(&expr).unwrap();
             let expected = BoolArray::from_iter([Some(true), Some(false), Some(true)]);
             assert_arrays_eq!(result, expected);
         }
@@ -85,10 +91,12 @@ mod tests {
             // [1, 3] in  1
             //            3
             //            5
-            let array = SequenceArray::typed_new(1, 2, Nullability::NonNullable, 3).unwrap();
+            let array = Sequence::try_new_typed(1, 2, Nullability::NonNullable, 3)
+                .unwrap()
+                .into_array();
 
             let expr = list_contains(lit(list_scalar), root());
-            let result = array.apply(&expr).unwrap();
+            let result = array.into_array().apply(&expr).unwrap();
             let expected = BoolArray::from_iter([Some(true), Some(true), Some(false)]);
             assert_arrays_eq!(result, expected);
         }
diff --git a/encodings/sequence/src/compute/min_max.rs b/encodings/sequence/src/compute/min_max.rs
index 8753d83a239..2ff8b2abd58 100644
--- a/encodings/sequence/src/compute/min_max.rs
+++ b/encodings/sequence/src/compute/min_max.rs
@@ -1,31 +1,81 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::compute::MinMaxKernel;
-use vortex_array::compute::MinMaxKernelAdapter;
-use vortex_array::compute::MinMaxResult;
-use vortex_array::dtype::Nullability::NonNullable;
-use vortex_array::register_kernel;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::AggregateFnRef;
+use vortex_array::aggregate_fn::fns::min_max::MinMax;
+use vortex_array::aggregate_fn::fns::min_max::make_minmax_dtype;
+use vortex_array::aggregate_fn::kernels::DynAggregateKernel;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::match_each_pvalue;
+use vortex_array::scalar::PValue;
 use vortex_array::scalar::Scalar;
+use vortex_array::scalar::ScalarValue;
 use vortex_error::VortexResult;
 
-use crate::SequenceArray;
-use crate::array::SequenceVTable;
-
-impl MinMaxKernel for SequenceVTable {
-    fn min_max(&self, array: &SequenceArray) -> VortexResult<Option<MinMaxResult>> {
-        let base = array.base();
-        let last = array.last();
-        let (min, max) = if base < last {
-            (base, last)
-        } else {
-            (last, base)
+use crate::Sequence;
+use crate::SequenceData;
+
+/// Sequence-specific min/max kernel.
+///
+/// A sequence array represents `A[i] = base + i * multiplier`, so min/max can be computed
+/// algebraically from `base` and `last` based on the sign of the multiplier.
+#[derive(Debug)]
+pub(crate) struct SequenceMinMaxKernel;
+
+impl DynAggregateKernel for SequenceMinMaxKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<MinMax>() {
+            return Ok(None);
+        }
+
+        let Some(seq) = batch.as_opt::<Sequence>() else {
+            return Ok(None);
         };
-        Ok(Some(MinMaxResult {
-            min: Scalar::primitive_value(min, array.ptype(), NonNullable),
-            max: Scalar::primitive_value(max, array.ptype(), NonNullable),
-        }))
+
+        let struct_dtype = make_minmax_dtype(batch.dtype());
+
+        // Empty sequences shouldn't exist (try_new validates length), but handle gracefully.
+        if seq.is_empty() {
+            return Ok(Some(Scalar::null(struct_dtype)));
+        }
+
+        let base = seq.base();
+        let last = SequenceData::try_last(base, seq.multiplier(), seq.ptype(), seq.len())?;
+
+        // Determine min and max based on multiplier direction.
+        // For unsigned types, multiplier is always >= 0.
+        let (min_pvalue, max_pvalue) = match_each_pvalue!(
+            seq.multiplier(),
+            uint: |_v| { (base, last) },
+            int: |v| {
+                if v >= 0 {
+                    (base, last)
+                } else {
+                    (last, base)
+                }
+            },
+            float: |_v| { unreachable!("float multiplier not supported for SequenceArray") }
+        );
+
+        let non_nullable_dtype = DType::Primitive(seq.ptype(), Nullability::NonNullable);
+        let min_scalar = Scalar::try_new(
+            non_nullable_dtype.clone(),
+            Some(ScalarValue::Primitive(min_pvalue)),
+        )?;
+        let max_scalar =
+            Scalar::try_new(non_nullable_dtype, Some(ScalarValue::Primitive(max_pvalue)))?;
+
+        Ok(Some(Scalar::struct_(
+            struct_dtype,
+            vec![min_scalar, max_scalar],
+        )))
     }
 }
-
-register_kernel!(MinMaxKernelAdapter(SequenceVTable).lift());
diff --git a/encodings/sequence/src/compute/mod.rs b/encodings/sequence/src/compute/mod.rs
index 7a7f8e1c198..9a99ff235c4 100644
--- a/encodings/sequence/src/compute/mod.rs
+++ b/encodings/sequence/src/compute/mod.rs
@@ -4,29 +4,31 @@
 mod cast;
 pub(crate) mod compare;
 mod filter;
-mod is_sorted;
+pub(crate) mod is_sorted;
 mod list_contains;
-mod min_max;
+pub(crate) mod min_max;
 mod slice;
 mod take;
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_array::dtype::Nullability;
 
+    use crate::Sequence;
     use crate::SequenceArray;
 
     #[rstest]
     // Basic sequence arrays - A[i] = base + i * multiplier
-    #[case::sequence_i32(SequenceArray::typed_new(
+    #[case::sequence_i32(Sequence::try_new_typed(
         0i32,      // base
         1i32,      // multiplier
         Nullability::NonNullable,
         5          // length
     ).unwrap())] // Results in [0, 1, 2, 3, 4]
-    #[case::sequence_i64_step2(SequenceArray::typed_new(
+    #[case::sequence_i64_step2(Sequence::try_new_typed(
         10i64,     // base
         2i64,      // multiplier
         Nullability::NonNullable,
@@ -34,13 +36,13 @@ mod tests {
     ).unwrap())] // Results in [10, 12, 14, 16, 18]
 
     // Different types
-    #[case::sequence_u32(SequenceArray::typed_new(
+    #[case::sequence_u32(Sequence::try_new_typed(
         100u32,    // base
         10u32,     // multiplier
         Nullability::NonNullable,
         5          // length
     ).unwrap())] // Results in [100, 110, 120, 130, 140]
-    #[case::sequence_i16(SequenceArray::typed_new(
+    #[case::sequence_i16(Sequence::try_new_typed(
         -10i16,    // base
         3i16,      // multiplier
         Nullability::NonNullable,
@@ -48,19 +50,19 @@ mod tests {
     ).unwrap())] // Results in [-10, -7, -4, -1, 2]
 
     // Edge cases
-    #[case::sequence_single(SequenceArray::typed_new(
+    #[case::sequence_single(Sequence::try_new_typed(
         42i32,
         0i32,      // multiplier of 0 means constant array
         Nullability::NonNullable,
         1
     ).unwrap())]
-    #[case::sequence_zero_multiplier(SequenceArray::typed_new(
+    #[case::sequence_zero_multiplier(Sequence::try_new_typed(
         100i32,
         0i32,      // All values will be 100
         Nullability::NonNullable,
         5
     ).unwrap())]
-    #[case::sequence_negative_step(SequenceArray::typed_new(
+    #[case::sequence_negative_step(Sequence::try_new_typed(
         100i32,
         -10i32,    // Decreasing sequence
         Nullability::NonNullable,
@@ -68,13 +70,13 @@ mod tests {
     ).unwrap())] // Results in [100, 90, 80, 70, 60]
 
     // Large arrays
-    #[case::sequence_large(SequenceArray::typed_new(
+    #[case::sequence_large(Sequence::try_new_typed(
         0i64,
         1i64,
         Nullability::NonNullable,
         2000
     ).unwrap())] // Results in [0, 1, 2, ..., 1999]
-    #[case::sequence_large_step(SequenceArray::typed_new(
+    #[case::sequence_large_step(Sequence::try_new_typed(
         1000i32,
         100i32,
         Nullability::NonNullable,
@@ -82,6 +84,6 @@ mod tests {
     ).unwrap())] // Results in [1000, 1100, 1200, ..., 150900]
 
     fn test_sequence_consistency(#[case] array: SequenceArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/sequence/src/compute/slice.rs b/encodings/sequence/src/compute/slice.rs
index d18fec1218b..c2b64b68ef4 100644
--- a/encodings/sequence/src/compute/slice.rs
+++ b/encodings/sequence/src/compute/slice.rs
@@ -4,23 +4,27 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::SequenceArray;
-use crate::SequenceVTable;
+use crate::Sequence;
 
-impl SliceReduce for SequenceVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Sequence {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        // SAFETY: this is a slice of an already-validated `SequenceArray`, so this is still valid.
         Ok(Some(
-            SequenceArray::unchecked_new(
-                array.index_value(range.start),
-                array.multiplier(),
-                array.ptype(),
-                array.dtype().nullability(),
-                range.len(),
-            )
-            .to_array(),
+            unsafe {
+                Sequence::new_unchecked(
+                    array.index_value(range.start),
+                    array.multiplier(),
+                    array.ptype(),
+                    array.dtype().nullability(),
+                    range.len(),
+                )
+            }
+            .into_array(),
         ))
     }
 }
diff --git a/encodings/sequence/src/compute/take.rs b/encodings/sequence/src/compute/take.rs
index 523dd3907c8..ab3a4ce5f97 100644
--- a/encodings/sequence/src/compute/take.rs
+++ b/encodings/sequence/src/compute/take.rs
@@ -2,14 +2,13 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use num_traits::cast::NumCast;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::dtype::NativePType;
@@ -25,8 +24,7 @@ use vortex_error::vortex_panic;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 
-use crate::SequenceArray;
-use crate::SequenceVTable;
+use crate::Sequence;
 
 fn take_inner<T: IntegerPType, S: NativePType>(
     mul: S,
@@ -73,14 +71,14 @@ fn take_inner<T: IntegerPType, S: NativePType>(
     }
 }
 
-impl TakeExecute for SequenceVTable {
+impl TakeExecute for Sequence {
     fn take(
-        array: &SequenceArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let mask = indices.validity_mask()?;
-        let indices = indices.to_primitive();
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
         let result_nullability = array.dtype().nullability() | indices.dtype().nullability();
 
         match_each_integer_ptype!(indices.ptype(), |T| {
@@ -105,56 +103,59 @@ impl TakeExecute for SequenceVTable {
 mod test {
     use rstest::rstest;
     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::Nullability;
 
+    use crate::Sequence;
     use crate::SequenceArray;
 
     #[rstest]
-    #[case::basic_sequence(SequenceArray::typed_new(
+    #[case::basic_sequence(Sequence::try_new_typed(
         0i32,
         1i32,
         Nullability::NonNullable,
         10
     ).unwrap())]
-    #[case::sequence_with_multiplier(SequenceArray::typed_new(
+    #[case::sequence_with_multiplier(Sequence::try_new_typed(
         10i32,
         5i32,
         Nullability::Nullable,
         20
     ).unwrap())]
-    #[case::sequence_i64(SequenceArray::typed_new(
+    #[case::sequence_i64(Sequence::try_new_typed(
         100i64,
         10i64,
         Nullability::NonNullable,
         50
     ).unwrap())]
-    #[case::sequence_u32(SequenceArray::typed_new(
+    #[case::sequence_u32(Sequence::try_new_typed(
         0u32,
         2u32,
         Nullability::NonNullable,
         100
     ).unwrap())]
-    #[case::sequence_negative_step(SequenceArray::typed_new(
+    #[case::sequence_negative_step(Sequence::try_new_typed(
         1000i32,
         -10i32,
         Nullability::Nullable,
         30
     ).unwrap())]
-    #[case::sequence_constant(SequenceArray::typed_new(
+    #[case::sequence_constant(Sequence::try_new_typed(
         42i32,
         0i32,  // multiplier of 0 means all values are the same
         Nullability::Nullable,
         15
     ).unwrap())]
-    #[case::sequence_i16(SequenceArray::typed_new(
+    #[case::sequence_i16(Sequence::try_new_typed(
         -100i16,
         3i16,
         Nullability::NonNullable,
         25
     ).unwrap())]
-    #[case::sequence_large(SequenceArray::typed_new(
+    #[case::sequence_large(Sequence::try_new_typed(
         0i64,
         1i64,
         Nullability::Nullable,
@@ -162,16 +163,16 @@ mod test {
     ).unwrap())]
     fn test_take_conformance(#[case] sequence: SequenceArray) {
         use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(sequence.as_ref());
+        test_take_conformance(&sequence.into_array());
     }
 
     #[test]
     #[should_panic(expected = "out of bounds")]
     fn test_bounds_check() {
-        let array = SequenceArray::typed_new(0i32, 1i32, Nullability::NonNullable, 10).unwrap();
-        let indices = vortex_array::arrays::PrimitiveArray::from_iter([0i32, 20]);
+        let array = Sequence::try_new_typed(0i32, 1i32, Nullability::NonNullable, 10).unwrap();
+        let indices = PrimitiveArray::from_iter([0i32, 20]);
         let _array = array
-            .take(indices.to_array())
+            .take(indices.into_array())
             .unwrap()
             .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
diff --git a/encodings/sequence/src/kernel.rs b/encodings/sequence/src/kernel.rs
index 05ed04ba0de..394a52ec69e 100644
--- a/encodings/sequence/src/kernel.rs
+++ b/encodings/sequence/src/kernel.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+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 crate::SequenceVTable;
+use crate::Sequence;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<SequenceVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(SequenceVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(SequenceVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(SequenceVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<Sequence> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(Sequence)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(Sequence)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Sequence)),
 ]);
diff --git a/encodings/sequence/src/lib.rs b/encodings/sequence/src/lib.rs
index 974a88eb0aa..aec425e0bae 100644
--- a/encodings/sequence/src/lib.rs
+++ b/encodings/sequence/src/lib.rs
@@ -9,12 +9,36 @@ mod rules;
 
 /// Represents the equation A\[i\] = a * i + b.
 /// This can be used for compression, fast comparisons and also for row ids.
-pub use array::SequenceArray;
-pub use array::SequenceArrayParts;
+pub use array::Sequence;
 /// Represents the equation A\[i\] = a * i + b.
 /// This can be used for compression, fast comparisons and also for row ids.
-pub use array::SequenceVTable;
+pub use array::SequenceArray;
+pub use array::SequenceData;
+pub use array::SequenceDataParts;
 pub use compress::sequence_encode;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::fns::is_sorted::IsSorted;
+use vortex_array::aggregate_fn::fns::min_max::MinMax;
+use vortex_array::aggregate_fn::session::AggregateFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
+
+/// Initialize sequence encoding in the given session.
+pub fn initialize(session: &VortexSession) {
+    session.arrays().register(Sequence);
+
+    // Register the Sequence-specific aggregate kernels.
+    session.aggregate_fns().register_aggregate_kernel(
+        Sequence::ID,
+        Some(MinMax.id()),
+        &compute::min_max::SequenceMinMaxKernel,
+    );
+    session.aggregate_fns().register_aggregate_kernel(
+        Sequence::ID,
+        Some(IsSorted.id()),
+        &compute::is_sorted::SequenceIsSortedKernel,
+    );
+}
 
 // TODO(joe): hook up to the compressor
 // TODO(joe): support comparisons with other operators
diff --git a/encodings/sequence/src/rules.rs b/encodings/sequence/src/rules.rs
index baae00d7c92..f87c08e8109 100644
--- a/encodings/sequence/src/rules.rs
+++ b/encodings/sequence/src/rules.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor;
 
-use crate::SequenceVTable;
+use crate::Sequence;
 
-pub(crate) static RULES: ParentRuleSet<SequenceVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(SequenceVTable)),
-    ParentRuleSet::lift(&ListContainsElementReduceAdaptor(SequenceVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(SequenceVTable)),
+pub(crate) static RULES: ParentRuleSet<Sequence> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(Sequence)),
+    ParentRuleSet::lift(&ListContainsElementReduceAdaptor(Sequence)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Sequence)),
 ]);
diff --git a/encodings/sparse/public-api.lock b/encodings/sparse/public-api.lock
index d90142cf162..30a2e9a726c 100644
--- a/encodings/sparse/public-api.lock
+++ b/encodings/sparse/public-api.lock
@@ -1,155 +1,143 @@
 pub mod vortex_sparse
 
-pub struct vortex_sparse::SparseArray
+pub struct vortex_sparse::Sparse
 
-impl vortex_sparse::SparseArray
+impl vortex_sparse::Sparse
 
-pub fn vortex_sparse::SparseArray::encode(array: &dyn vortex_array::array::Array, fill_value: core::option::Option<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub const vortex_sparse::Sparse::ID: vortex_array::array::ArrayId
 
-pub fn vortex_sparse::SparseArray::fill_scalar(&self) -> &vortex_array::scalar::Scalar
+pub fn vortex_sparse::Sparse::encode(array: &vortex_array::array::erased::ArrayRef, fill_value: core::option::Option<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_sparse::SparseArray::patches(&self) -> &vortex_array::patches::Patches
+pub fn vortex_sparse::Sparse::try_new(indices: vortex_array::array::erased::ArrayRef, values: vortex_array::array::erased::ArrayRef, len: usize, fill_value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_sparse::SparseArray>
 
-pub fn vortex_sparse::SparseArray::resolved_patches(&self) -> vortex_error::VortexResult<vortex_array::patches::Patches>
+pub fn vortex_sparse::Sparse::try_new_from_patches(patches: vortex_array::patches::Patches, fill_value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_sparse::SparseArray>
 
-pub fn vortex_sparse::SparseArray::try_new(indices: vortex_array::array::ArrayRef, values: vortex_array::array::ArrayRef, len: usize, fill_value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_sparse::Sparse
 
-pub fn vortex_sparse::SparseArray::try_new_from_patches(patches: vortex_array::patches::Patches, fill_value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_sparse::Sparse::clone(&self) -> vortex_sparse::Sparse
 
-impl core::clone::Clone for vortex_sparse::SparseArray
+impl core::fmt::Debug for vortex_sparse::Sparse
 
-pub fn vortex_sparse::SparseArray::clone(&self) -> vortex_sparse::SparseArray
+pub fn vortex_sparse::Sparse::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_sparse::SparseArray
+impl vortex_array::array::vtable::VTable for vortex_sparse::Sparse
 
-pub fn vortex_sparse::SparseArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_sparse::Sparse::ArrayData = vortex_sparse::SparseData
 
-impl core::convert::From<vortex_sparse::SparseArray> for vortex_array::array::ArrayRef
+pub type vortex_sparse::Sparse::OperationsVTable = vortex_sparse::Sparse
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_sparse::SparseArray) -> vortex_array::array::ArrayRef
+pub type vortex_sparse::Sparse::ValidityVTable = vortex_sparse::Sparse
 
-impl core::fmt::Debug for vortex_sparse::SparseArray
+pub fn vortex_sparse::Sparse::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_sparse::SparseArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_sparse::Sparse::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::ops::deref::Deref for vortex_sparse::SparseArray
+pub fn vortex_sparse::Sparse::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_sparse::SparseArray::Target = dyn vortex_array::array::Array
+pub fn vortex_sparse::Sparse::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_sparse::SparseArray::deref(&self) -> &Self::Target
+pub fn vortex_sparse::Sparse::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_sparse::SparseArray
+pub fn vortex_sparse::Sparse::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_sparse::SparseArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_sparse::Sparse::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-#[repr(C)] pub struct vortex_sparse::SparseMetadata
-
-impl core::clone::Clone for vortex_sparse::SparseMetadata
-
-pub fn vortex_sparse::SparseMetadata::clone(&self) -> vortex_sparse::SparseMetadata
-
-impl core::default::Default for vortex_sparse::SparseMetadata
-
-pub fn vortex_sparse::SparseMetadata::default() -> Self
-
-impl core::fmt::Debug for vortex_sparse::SparseMetadata
-
-pub fn vortex_sparse::SparseMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_sparse::Sparse::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl prost::message::Message for vortex_sparse::SparseMetadata
+pub fn vortex_sparse::Sparse::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_sparse::SparseMetadata::clear(&mut self)
+pub fn vortex_sparse::Sparse::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_sparse::SparseMetadata::encoded_len(&self) -> usize
+pub fn vortex_sparse::Sparse::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, _slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_sparse::SparseVTable
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_sparse::Sparse> for vortex_sparse::Sparse
 
-impl vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_sparse::Sparse>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub const vortex_sparse::SparseVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_sparse::Sparse> for vortex_sparse::Sparse
 
-impl core::fmt::Debug for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::validity(array: vortex_array::array::view::ArrayView<'_, vortex_sparse::Sparse>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_sparse::SparseVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_sparse::Sparse
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sparse::SparseVTable::take(array: &vortex_sparse::SparseArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_sparse::Sparse
 
-impl vortex_array::arrays::filter::kernel::FilterKernel for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sparse::SparseVTable::filter(array: &vortex_sparse::SparseArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::slice::SliceKernel for vortex_sparse::Sparse
 
-impl vortex_array::arrays::slice::SliceKernel for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sparse::SparseVTable::slice(array: &vortex_sparse::SparseArray, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_sparse::Sparse
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sparse::SparseVTable::cast(array: &vortex_sparse::SparseArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::not::kernel::NotReduce for vortex_sparse::Sparse
 
-impl vortex_array::scalar_fn::fns::not::kernel::NotReduce for vortex_sparse::SparseVTable
+pub fn vortex_sparse::Sparse::invert(array: vortex_array::array::view::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_sparse::SparseVTable::invert(array: &vortex_sparse::SparseArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub struct vortex_sparse::SparseData
 
-impl vortex_array::vtable::VTable for vortex_sparse::SparseVTable
+impl vortex_sparse::SparseData
 
-pub type vortex_sparse::SparseVTable::Array = vortex_sparse::SparseArray
+pub fn vortex_sparse::SparseData::dtype(&self) -> &vortex_array::dtype::DType
 
-pub type vortex_sparse::SparseVTable::ArrayVTable = vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseData::encode(array: &vortex_array::array::erased::ArrayRef, fill_value: core::option::Option<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub type vortex_sparse::SparseVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_sparse::SparseMetadata>
+pub fn vortex_sparse::SparseData::fill_scalar(&self) -> &vortex_array::scalar::Scalar
 
-pub type vortex_sparse::SparseVTable::OperationsVTable = vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseData::is_empty(&self) -> bool
 
-pub type vortex_sparse::SparseVTable::ValidityVTable = vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseData::len(&self) -> usize
 
-pub type vortex_sparse::SparseVTable::VisitorVTable = vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseData::patches(&self) -> &vortex_array::patches::Patches
 
-pub fn vortex_sparse::SparseVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_sparse::SparseArray>
+pub fn vortex_sparse::SparseData::resolved_patches(&self) -> vortex_error::VortexResult<vortex_array::patches::Patches>
 
-pub fn vortex_sparse::SparseVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_sparse::SparseData::try_new_from_patches(patches: vortex_array::patches::Patches, fill_value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_sparse::SparseVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_sparse::SparseData::validate(patches: &vortex_array::patches::Patches, fill_value: &vortex_array::scalar::Scalar, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<()>
 
-pub fn vortex_sparse::SparseVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::clone::Clone for vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_sparse::SparseData::clone(&self) -> vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::metadata(array: &vortex_sparse::SparseArray) -> vortex_error::VortexResult<Self::Metadata>
+impl core::fmt::Debug for vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_sparse::SparseData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_sparse::SparseVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::fmt::Display for vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_sparse::SparseData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_sparse::SparseVTable> for vortex_sparse::SparseVTable
+impl vortex_array::hash::ArrayEq for vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::array_eq(array: &vortex_sparse::SparseArray, other: &vortex_sparse::SparseArray, precision: vortex_array::hash::Precision) -> bool
+pub fn vortex_sparse::SparseData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_sparse::SparseVTable::array_hash<H: core::hash::Hasher>(array: &vortex_sparse::SparseArray, state: &mut H, precision: vortex_array::hash::Precision)
+impl vortex_array::hash::ArrayHash for vortex_sparse::SparseData
 
-pub fn vortex_sparse::SparseVTable::dtype(array: &vortex_sparse::SparseArray) -> &vortex_array::dtype::DType
+pub fn vortex_sparse::SparseData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-pub fn vortex_sparse::SparseVTable::len(array: &vortex_sparse::SparseArray) -> usize
+#[repr(C)] pub struct vortex_sparse::SparseMetadata
 
-pub fn vortex_sparse::SparseVTable::stats(array: &vortex_sparse::SparseArray) -> vortex_array::stats::array::StatsSetRef<'_>
+impl core::clone::Clone for vortex_sparse::SparseMetadata
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_sparse::SparseVTable> for vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseMetadata::clone(&self) -> vortex_sparse::SparseMetadata
 
-pub fn vortex_sparse::SparseVTable::scalar_at(array: &vortex_sparse::SparseArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl core::default::Default for vortex_sparse::SparseMetadata
 
-impl vortex_array::vtable::validity::ValidityVTable<vortex_sparse::SparseVTable> for vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseMetadata::default() -> Self
 
-pub fn vortex_sparse::SparseVTable::validity(array: &vortex_sparse::SparseArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl core::fmt::Debug for vortex_sparse::SparseMetadata
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_sparse::SparseVTable> for vortex_sparse::SparseVTable
+pub fn vortex_sparse::SparseMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_sparse::SparseVTable::nbuffers(_array: &vortex_sparse::SparseArray) -> usize
+impl prost::message::Message for vortex_sparse::SparseMetadata
 
-pub fn vortex_sparse::SparseVTable::nchildren(array: &vortex_sparse::SparseArray) -> usize
+pub fn vortex_sparse::SparseMetadata::clear(&mut self)
 
-pub fn vortex_sparse::SparseVTable::visit_buffers(array: &vortex_sparse::SparseArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_sparse::SparseMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_sparse::SparseVTable::visit_children(array: &vortex_sparse::SparseArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub type vortex_sparse::SparseArray = vortex_array::array::typed::Array<vortex_sparse::Sparse>
diff --git a/encodings/sparse/src/canonical.rs b/encodings/sparse/src/canonical.rs
index 9abd131d596..c53fd8989e8 100644
--- a/encodings/sparse/src/canonical.rs
+++ b/encodings/sparse/src/canonical.rs
@@ -5,19 +5,20 @@ use std::sync::Arc;
 
 use itertools::Itertools;
 use num_traits::NumCast;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
 use vortex_array::arrays::BoolArray;
-use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::FixedSizeListArray;
 use vortex_array::arrays::ListViewArray;
 use vortex_array::arrays::NullArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::build_views::BinaryView;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
+use vortex_array::arrays::varbinview::build_views::BinaryView;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::DecimalBuilder;
@@ -41,7 +42,6 @@ use vortex_array::scalar::ListScalar;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::StructScalar;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferString;
@@ -51,11 +51,16 @@ use vortex_buffer::buffer_mut;
 use vortex_error::VortexError;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
 
+use crate::ConstantArray;
+use crate::Sparse;
 use crate::SparseArray;
-
-pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {
+pub(super) fn execute_sparse(
+    array: &SparseArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
     if array.patches().num_patches() == 0 {
         return Ok(ConstantArray::new(array.fill_scalar().clone(), array.len()).into_array());
     }
@@ -67,12 +72,12 @@ pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {
         }
         DType::Bool(..) => {
             let resolved_patches = array.resolved_patches()?;
-            execute_sparse_bools(&resolved_patches, array.fill_scalar())?
+            execute_sparse_bools(&resolved_patches, array.fill_scalar(), ctx)?
         }
         DType::Primitive(ptype, ..) => {
             let resolved_patches = array.resolved_patches()?;
             match_each_native_ptype!(ptype, |P| {
-                execute_sparse_primitives::<P>(&resolved_patches, array.fill_scalar())?
+                execute_sparse_primitives::<P>(&resolved_patches, array.fill_scalar(), ctx)?
             })
         }
         DType::Struct(struct_fields, ..) => execute_sparse_struct(
@@ -81,6 +86,7 @@ pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {
             array.dtype(),
             array.patches(),
             array.len(),
+            ctx,
         )?,
         DType::Decimal(decimal_dtype, nullability) => {
             let canonical_decimal_value_type =
@@ -93,25 +99,27 @@ pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {
                     fill_value,
                     array.patches(),
                     array.len(),
+                    ctx,
                 )?
             })
         }
         dtype @ DType::Utf8(..) => {
             let fill_value = array.fill_scalar().as_utf8().value().cloned();
             let fill_value = fill_value.map(BufferString::into_inner);
-            execute_varbin(array, dtype.clone(), fill_value)?
+            execute_varbin(array, dtype.clone(), fill_value, ctx)?
         }
         dtype @ DType::Binary(..) => {
             let fill_value = array.fill_scalar().as_binary().value().cloned();
-            execute_varbin(array, dtype.clone(), fill_value)?
+            execute_varbin(array, dtype.clone(), fill_value, ctx)?
         }
         DType::List(values_dtype, nullability) => {
-            execute_sparse_lists(array, values_dtype.clone(), *nullability)?
+            execute_sparse_lists(array, Arc::clone(values_dtype), *nullability, ctx)?
         }
         DType::FixedSizeList(.., nullability) => {
-            execute_sparse_fixed_size_list(array, *nullability)?
+            execute_sparse_fixed_size_list(array, *nullability, ctx)?
         }
         DType::Extension(_ext_dtype) => todo!(),
+        DType::Variant(_) => vortex_bail!("Sparse canonicalization does not support Variant"),
     })
 }
 
@@ -123,17 +131,24 @@ fn execute_sparse_lists(
     array: &SparseArray,
     values_dtype: Arc<DType>,
     nullability: Nullability,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let resolved_patches = array.resolved_patches()?;
 
-    let indices = resolved_patches.indices().to_primitive();
-    let values = resolved_patches.values().to_listview();
+    let indices = resolved_patches
+        .indices()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let values = resolved_patches
+        .values()
+        .clone()
+        .execute::<ListViewArray>(ctx)?;
     let fill_value = array.fill_scalar().as_list();
 
     let n_filled = array.len() - resolved_patches.num_patches();
     let total_canonical_values = values.elements().len() + fill_value.len() * n_filled;
 
-    let validity = Validity::from_mask(array.validity_mask()?, nullability);
+    let validity = Validity::from_mask(array.as_array().validity_mask()?, nullability);
 
     Ok(match_each_integer_ptype!(indices.ptype(), |I| {
         match_smallest_offset_type!(total_canonical_values, |O| {
@@ -205,13 +220,20 @@ fn execute_sparse_lists_inner<I: IntegerPType, O: IntegerPType>(
 fn execute_sparse_fixed_size_list(
     array: &SparseArray,
     nullability: Nullability,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let resolved_patches = array.resolved_patches()?;
-    let indices = resolved_patches.indices().to_primitive();
-    let values = resolved_patches.values().to_fixed_size_list();
+    let indices = resolved_patches
+        .indices()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let values = resolved_patches
+        .values()
+        .clone()
+        .execute::<FixedSizeListArray>(ctx)?;
     let fill_value = array.fill_scalar().as_list();
 
-    let validity = Validity::from_mask(array.validity_mask()?, nullability);
+    let validity = Validity::from_mask(array.as_array().validity_mask()?, nullability);
 
     Ok(match_each_integer_ptype!(indices.ptype(), |I| {
         execute_sparse_fixed_size_list_inner::<I>(
@@ -261,6 +283,7 @@ fn execute_sparse_fixed_size_list_inner<I: IntegerPType>(
         // Append the patch value, handling null patches by appending defaults.
         if values
             .validity()
+            .vortex_expect("sparse fixed-size-list validity should be derivable")
             .is_valid(patch_idx)
             .vortex_expect("is_valid")
         {
@@ -316,7 +339,11 @@ fn append_n_lists(
     }
 }
 
-fn execute_sparse_bools(patches: &Patches, fill_value: &Scalar) -> VortexResult<ArrayRef> {
+fn execute_sparse_bools(
+    patches: &Patches,
+    fill_value: &Scalar,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
     let (fill_bool, validity) = if fill_value.is_null() {
         (false, Validity::AllInvalid)
     } else {
@@ -334,12 +361,13 @@ fn execute_sparse_bools(patches: &Patches, fill_value: &Scalar) -> VortexResult<
 
     let bools = BoolArray::new(BitBuffer::full(fill_bool, patches.array_len()), validity);
 
-    Ok(bools.patch(patches)?.into_array())
+    Ok(bools.patch(patches, ctx)?.into_array())
 }
 
 fn execute_sparse_primitives<T: NativePType + for<'a> TryFrom<&'a Scalar, Error = VortexError>>(
     patches: &Patches,
     fill_value: &Scalar,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let (primitive_fill, validity) = if fill_value.is_null() {
         (T::default(), Validity::AllInvalid)
@@ -358,7 +386,7 @@ fn execute_sparse_primitives<T: NativePType + for<'a> TryFrom<&'a Scalar, Error
 
     let parray = PrimitiveArray::new(buffer![primitive_fill; patches.array_len()], validity);
 
-    Ok(parray.patch(patches)?.into_array())
+    Ok(parray.patch(patches, ctx)?.into_array())
 }
 
 fn execute_sparse_struct(
@@ -368,6 +396,7 @@ fn execute_sparse_struct(
     // Resolution is unnecessary b/c we're just pushing the patches into the fields.
     unresolved_patches: &Patches,
     len: usize,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let (fill_values, top_level_fill_validity) = match fill_struct.fields_iter() {
         Some(fill_values) => (fill_values.collect::<Vec<_>>(), Validity::AllValid),
@@ -379,7 +408,10 @@ fn execute_sparse_struct(
             Validity::AllInvalid,
         ),
     };
-    let patch_values_as_struct = unresolved_patches.values().to_struct();
+    let patch_values_as_struct = unresolved_patches
+        .values()
+        .clone()
+        .execute::<StructArray>(ctx)?;
     let columns_patch_values = patch_values_as_struct.unmasked_fields();
     let names = patch_values_as_struct.names();
     let validity = if dtype.is_nullable() {
@@ -394,6 +426,7 @@ fn execute_sparse_struct(
                     .vortex_expect("validity_mask"),
                 Nullability::Nullable,
             ),
+            ctx,
         )?
     } else {
         top_level_fill_validity
@@ -408,7 +441,7 @@ fn execute_sparse_struct(
                 .cloned()
                 .zip_eq(fill_values)
                 .map(|(patch_values, fill_value)| unsafe {
-                    SparseArray::new_unchecked(
+                    Sparse::new_unchecked(
                         unresolved_patches
                             .clone()
                             .map_values(|_| Ok(patch_values))
@@ -428,6 +461,7 @@ fn execute_sparse_decimal<D: NativeDecimalType>(
     fill_value: DecimalScalar,
     patches: &Patches,
     len: usize,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let mut builder = DecimalBuilder::with_capacity::<D>(len, decimal_dtype, nullability);
     match fill_value.decimal_value() {
@@ -444,19 +478,19 @@ fn execute_sparse_decimal<D: NativeDecimalType>(
         }
     }
     let filled_array = builder.finish_into_decimal();
-    let array = filled_array.patch(patches)?;
-    Ok(array.into_array())
+    Ok(filled_array.patch(patches, ctx)?.into_array())
 }
 
 fn execute_varbin(
     array: &SparseArray,
     dtype: DType,
     fill_value: Option<ByteBuffer>,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let patches = array.resolved_patches()?;
-    let indices = patches.indices().to_primitive();
-    let values = patches.values().to_varbinview();
-    let validity = Validity::from_mask(array.validity_mask()?, dtype.nullability());
+    let indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
+    let values = patches.values().clone().execute::<VarBinViewArray>(ctx)?;
+    let validity = Validity::from_mask(array.as_array().validity_mask()?, dtype.nullability());
     let len = array.len();
 
     Ok(match_each_integer_ptype!(indices.ptype(), |I| {
@@ -475,8 +509,8 @@ fn execute_varbin_inner<I: IntegerPType>(
 ) -> VarBinViewArray {
     assert_eq!(dtype.nullability(), validity.nullability());
 
-    let n_patch_buffers = values.buffers().len();
-    let mut buffers = values.buffers().to_vec();
+    let n_patch_buffers = values.data_buffers().len();
+    let mut buffers = values.data_buffers().to_vec();
 
     let fill = if let Some(buffer) = &fill_value {
         buffers.push(BufferHandle::new_host(buffer.clone()));
@@ -519,6 +553,7 @@ mod test {
     use vortex_array::arrays::StructArray;
     use vortex_array::arrays::VarBinArray;
     use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::arrays::listview::ListViewArrayExt;
     use vortex_array::arrow::IntoArrowArray as _;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
@@ -538,7 +573,7 @@ mod test {
     use vortex_error::VortexResult;
     use vortex_mask::Mask;
 
-    use crate::SparseArray;
+    use crate::Sparse;
 
     #[rstest]
     #[case(Some(true))]
@@ -547,9 +582,8 @@ mod test {
     fn test_sparse_bool(#[case] fill_value: Option<bool>) {
         let indices = buffer![0u64, 1, 7].into_array();
         let values = BoolArray::from_iter([Some(true), None, Some(false)]).into_array();
-        let sparse_bools =
-            SparseArray::try_new(indices, values, 10, Scalar::from(fill_value)).unwrap();
-        let actual = sparse_bools.to_bool();
+        let sparse_bools = Sparse::try_new(indices, values, 10, Scalar::from(fill_value)).unwrap();
+        let actual = sparse_bools.as_array().to_bool();
 
         let expected = BoolArray::from_iter([
             Some(true),
@@ -574,11 +608,10 @@ mod test {
     fn test_sparse_primitive(#[case] fill_value: Option<i32>) {
         let indices = buffer![0u64, 1, 7].into_array();
         let values = PrimitiveArray::from_option_iter([Some(0i32), None, Some(1)]).into_array();
-        let sparse_ints =
-            SparseArray::try_new(indices, values, 10, Scalar::from(fill_value)).unwrap();
+        let sparse_ints = Sparse::try_new(indices, values, 10, Scalar::from(fill_value)).unwrap();
         assert_eq!(*sparse_ints.dtype(), DType::Primitive(PType::I32, Nullable));
 
-        let flat_ints = sparse_ints.to_primitive();
+        let flat_ints = sparse_ints.as_array().to_primitive();
         let expected = PrimitiveArray::from_option_iter([
             Some(0i32),
             None,
@@ -615,7 +648,7 @@ mod test {
             struct_fields.clone(),
             4,
             Validity::Array(
-                BoolArray::from_indices(4, vec![0, 1, 2], Validity::NonNullable).to_array(),
+                BoolArray::from_indices(4, vec![0, 1, 2], Validity::NonNullable).into_array(),
             ),
         )
         .unwrap()
@@ -626,7 +659,7 @@ mod test {
             vec![Scalar::from(Some(-10i32)), Scalar::from(Some(-1i32))],
         );
         let len = 10;
-        let sparse_struct = SparseArray::try_new(indices, patch_values, len, fill_scalar).unwrap();
+        let sparse_struct = Sparse::try_new(indices, patch_values, len, fill_scalar).unwrap();
 
         let expected_a = PrimitiveArray::from_option_iter((0..len).map(|i| {
             if i == 0 {
@@ -659,9 +692,9 @@ mod test {
             Validity::from_mask(Mask::from_excluded_indices(10, vec![8]), Nullable),
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
-        let actual = sparse_struct.to_struct();
+        let actual = sparse_struct.as_array().to_struct();
         assert_arrays_eq!(actual, expected);
     }
 
@@ -685,7 +718,7 @@ mod test {
             struct_fields.clone(),
             4,
             Validity::Array(
-                BoolArray::from_indices(4, vec![0, 1, 2], Validity::NonNullable).to_array(),
+                BoolArray::from_indices(4, vec![0, 1, 2], Validity::NonNullable).into_array(),
             ),
         )
         .unwrap()
@@ -693,7 +726,7 @@ mod test {
 
         let fill_scalar = Scalar::null(struct_dtype);
         let len = 10;
-        let sparse_struct = SparseArray::try_new(indices, patch_values, len, fill_scalar).unwrap();
+        let sparse_struct = Sparse::try_new(indices, patch_values, len, fill_scalar).unwrap();
 
         let expected_a = PrimitiveArray::from_option_iter((0..len).map(|i| {
             if i == 0 {
@@ -726,9 +759,9 @@ mod test {
             Validity::from_mask(Mask::from_indices(10, vec![0, 1, 7]), Nullable),
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
-        let actual = sparse_struct.to_struct();
+        let actual = sparse_struct.as_array().to_struct();
         assert_arrays_eq!(actual, expected);
     }
 
@@ -741,10 +774,10 @@ mod test {
             decimal_dtype,
             Validity::from_iter([true, true, true, false]),
         )
-        .to_array();
+        .into_array();
         let len = 10;
         let fill_scalar = Scalar::decimal(DecimalValue::I32(123), decimal_dtype, Nullable);
-        let sparse_struct = SparseArray::try_new(indices, patch_values, len, fill_scalar).unwrap();
+        let sparse_struct = Sparse::try_new(indices, patch_values, len, fill_scalar).unwrap();
 
         let expected = DecimalArray::new(
             buffer![100i128, 200, 123, 123, 123, 123, 123, 300, 4000, 123],
@@ -752,13 +785,14 @@ mod test {
             // NB: patch indices: [0, 1, 7, 8]; patch validity: [Valid, Valid, Valid, Invalid]; ergo 0, 1, 7 are valid.
             Validity::from_mask(Mask::from_excluded_indices(10, vec![8]), Nullable),
         )
-        .to_array()
+        .into_array()
         .into_arrow_preferred()
         .unwrap();
 
         let actual = sparse_struct
+            .as_array()
             .to_decimal()
-            .to_array()
+            .into_array()
             .into_arrow_preferred()
             .unwrap();
 
@@ -779,7 +813,7 @@ mod test {
         ])
         .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 7, 9, 10].into_array(),
             strings,
             12,
@@ -787,7 +821,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = <VarBinViewArray as FromIterator<_>>::from_iter([
             Some("hello"),
             Some("123"),
@@ -820,7 +854,7 @@ mod test {
         ])
         .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 7, 9, 10].into_array(),
             strings,
             12,
@@ -828,7 +862,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = <VarBinViewArray as FromIterator<_>>::from_iter([
             Some("hello"),
             None,
@@ -854,7 +888,7 @@ mod test {
             VarBinViewArray::from_iter_str(["hello", "goodbye", "hello", "bonjour", "你好"])
                 .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 8].into_array(),
             strings,
             9,
@@ -862,7 +896,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = VarBinViewArray::from_iter_str([
             "hello", "123", "123", "goodbye", "hello", "bonjour", "123", "123", "你好",
         ])
@@ -884,7 +918,7 @@ mod test {
         ])
         .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 7, 9, 10].into_array(),
             strings,
             12,
@@ -892,7 +926,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = <VarBinViewArray as FromIterator<_>>::from_iter([
             Some("hello"),
             None,
@@ -925,7 +959,7 @@ mod test {
         ])
         .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 7, 9, 10].into_array(),
             binaries,
             12,
@@ -933,7 +967,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = VarBinViewArray::from_iter_nullable_bin([
             Some(b"hello" as &[u8]),
             Some(b"123"),
@@ -972,7 +1006,7 @@ mod test {
 
         let indices = buffer![0u8, 3u8, 4u8, 5u8].into_array();
         let fill_value = Scalar::null(lists.dtype().clone());
-        let sparse = SparseArray::try_new(indices, lists, 6, fill_value)
+        let sparse = Sparse::try_new(indices, lists, 6, fill_value)
             .unwrap()
             .into_array();
 
@@ -1026,7 +1060,7 @@ mod test {
 
         let indices = buffer![0u8, 3u8, 4u8, 5u8].into_array();
         let fill_value = Scalar::null(lists.dtype().clone());
-        let sparse = SparseArray::try_new(indices, lists, 6, fill_value)
+        let sparse = Sparse::try_new(indices, lists, 6, fill_value)
             .unwrap()
             .into_array();
 
@@ -1069,7 +1103,7 @@ mod test {
 
         let indices = buffer![0u8, 3u8, 4u8, 5u8].into_array();
         let fill_value = Scalar::from(Some(vec![5i32, 6, 7, 8]));
-        let sparse = SparseArray::try_new(indices, lists, 6, fill_value)
+        let sparse = Sparse::try_new(indices, lists, 6, fill_value)
             .unwrap()
             .into_array();
 
@@ -1138,7 +1172,7 @@ mod test {
         ])
         .into_array();
 
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0u16, 3, 4, 5, 7, 9, 10].into_array(),
             strings,
             12,
@@ -1146,7 +1180,7 @@ mod test {
         )
         .unwrap();
 
-        let actual = array.to_varbinview().into_array();
+        let actual = array.as_array().to_varbinview().into_array();
         let expected = VarBinViewArray::from_iter_nullable_bin([
             Some(b"hello" as &[u8]),
             None,
@@ -1180,7 +1214,7 @@ mod test {
             3,
             Nullable,
         ));
-        let sparse = SparseArray::try_new(indices, fsl, 5, fill_value)
+        let sparse = Sparse::try_new(indices, fsl, 5, fill_value)
             .unwrap()
             .into_array();
 
@@ -1218,7 +1252,7 @@ mod test {
             ],
             NonNullable,
         );
-        let sparse = SparseArray::try_new(indices, fsl, 6, fill_value)
+        let sparse = Sparse::try_new(indices, fsl, 6, fill_value)
             .unwrap()
             .into_array();
 
@@ -1256,7 +1290,7 @@ mod test {
             ],
             Nullable,
         );
-        let sparse = SparseArray::try_new(indices, fsl, 6, fill_value)
+        let sparse = Sparse::try_new(indices, fsl, 6, fill_value)
             .unwrap()
             .into_array();
 
@@ -1304,7 +1338,7 @@ mod test {
             NonNullable,
         );
 
-        let sparse = SparseArray::try_new(indices, fsl, 100, fill_value)
+        let sparse = Sparse::try_new(indices, fsl, 100, fill_value)
             .unwrap()
             .into_array();
 
@@ -1361,7 +1395,7 @@ mod test {
             ],
             NonNullable,
         );
-        let sparse = SparseArray::try_new(indices, fsl, 1, fill_value)
+        let sparse = Sparse::try_new(indices, fsl, 1, fill_value)
             .unwrap()
             .into_array();
 
@@ -1387,7 +1421,7 @@ mod test {
 
         let indices = buffer![0u8, 1u8, 2u8, 3u8].into_array();
         let fill_value = Scalar::from(Some(vec![42i32; 252])); // 252 + 4 elements = 256 > u8::MAX
-        let sparse = SparseArray::try_new(indices, lists, 5, fill_value)
+        let sparse = Sparse::try_new(indices, lists, 5, fill_value)
             .unwrap()
             .into_array();
 
@@ -1433,7 +1467,7 @@ mod test {
         let sizes = buffer![3u32, 2, 4].into_array();
 
         let list_view = unsafe {
-            ListViewArray::new_unchecked(elements.clone(), offsets, sizes, Validity::AllValid)
+            ListViewArray::new_unchecked(elements, offsets, sizes, Validity::AllValid)
                 .with_zero_copy_to_list(true)
         };
 
@@ -1449,7 +1483,7 @@ mod test {
         // - Index 7: List 2 [30, 31, 32, 33]
         // - Index 8-9: null
         let indices = buffer![1u8, 4, 7].into_array();
-        let sparse = SparseArray::try_new(
+        let sparse = Sparse::try_new(
             indices,
             list_view.into_array(),
             10,
@@ -1535,7 +1569,7 @@ mod test {
         // Extract only the values we need from the sliced array
         let values = sliced.slice(0..2).unwrap();
         let sparse =
-            SparseArray::try_new(indices, values, 5, Scalar::null(sliced.dtype().clone())).unwrap();
+            Sparse::try_new(indices, values, 5, Scalar::null(sliced.dtype().clone())).unwrap();
 
         let canonical = sparse.to_canonical()?.into_array();
         let result_listview = canonical.to_listview();
diff --git a/encodings/sparse/src/compute/cast.rs b/encodings/sparse/src/compute/cast.rs
index 2a92439eefe..a9fe0046646 100644
--- a/encodings/sparse/src/compute/cast.rs
+++ b/encodings/sparse/src/compute/cast.rs
@@ -2,26 +2,32 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
+use vortex_array::scalar::Scalar;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::SparseArray;
-use crate::SparseVTable;
-
-impl CastReduce for SparseVTable {
-    fn cast(array: &SparseArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
-        // Cast both the patches values and the fill value
-        let casted_fill = array.fill_scalar().cast(dtype)?;
+use crate::Sparse;
+impl CastReduce for Sparse {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         let casted_patches = array
             .patches()
             .clone()
             .map_values(|values| values.cast(dtype.clone()))?;
 
+        let casted_fill = if array.patches().num_patches() == array.len() {
+            // When every position is patched the fill scalar is unused and can be undefined.
+            // We skip casting it entirely and substitute a default value for the target dtype.
+            Scalar::default_value(dtype)
+        } else {
+            array.fill_scalar().cast(dtype)?
+        };
+
         Ok(Some(
-            SparseArray::try_new_from_patches(casted_patches, casted_fill)?.into_array(),
+            Sparse::try_new_from_patches(casted_patches, casted_fill)?.into_array(),
         ))
     }
 }
@@ -41,11 +47,12 @@ mod tests {
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
 
+    use crate::Sparse;
     use crate::SparseArray;
 
     #[test]
     fn test_cast_sparse_i32_to_i64() {
-        let sparse = SparseArray::try_new(
+        let sparse = Sparse::try_new(
             buffer![2u64, 5, 8].into_array(),
             buffer![100i32, 200, 300].into_array(),
             10,
@@ -54,7 +61,7 @@ mod tests {
         .unwrap();
 
         let casted = sparse
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -68,7 +75,7 @@ mod tests {
 
     #[test]
     fn test_cast_sparse_with_null_fill() {
-        let sparse = SparseArray::try_new(
+        let sparse = Sparse::try_new(
             buffer![1u64, 3, 5].into_array(),
             PrimitiveArray::from_option_iter([Some(42i32), Some(84), Some(126)]).into_array(),
             8,
@@ -77,7 +84,7 @@ mod tests {
         .unwrap();
 
         let casted = sparse
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -87,31 +94,80 @@ mod tests {
     }
 
     #[rstest]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![2u64, 5, 8].into_array(),
         buffer![100i32, 200, 300].into_array(),
         10,
         Scalar::from(0i32)
     ).unwrap())]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![0u64, 4, 9].into_array(),
         buffer![1.5f32, 2.5, 3.5].into_array(),
         10,
         Scalar::from(0.0f32)
     ).unwrap())]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![1u64, 3, 7].into_array(),
         PrimitiveArray::from_option_iter([Some(100i32), None, Some(300)]).into_array(),
         10,
         Scalar::null_native::<i32>()
     ).unwrap())]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![5u64].into_array(),
         buffer![42u8].into_array(),
         10,
         Scalar::from(0u8)
     ).unwrap())]
     fn test_cast_sparse_conformance(#[case] array: SparseArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
+    }
+
+    #[test]
+    fn test_cast_sparse_null_fill_all_patched_to_non_nullable() -> vortex_error::VortexResult<()> {
+        // Regression test for https://github.com/vortex-data/vortex/issues/6932
+        //
+        // When all positions are patched the null fill is unused, so a cast to
+        // non-nullable is valid.  Sparse::cast detects this case, substitutes a
+        // zero fill, and keeps the result in the Sparse encoding.
+        let sparse = Sparse::try_new(
+            buffer![0u64, 1, 2, 3, 4].into_array(),
+            buffer![10u64, 20, 30, 40, 50].into_array(),
+            5,
+            Scalar::null_native::<u64>(),
+        )?;
+
+        let casted = sparse
+            .into_array()
+            .cast(DType::Primitive(PType::U64, Nullability::NonNullable))?;
+
+        assert_eq!(
+            casted.dtype(),
+            &DType::Primitive(PType::U64, Nullability::NonNullable)
+        );
+
+        let expected = PrimitiveArray::from_iter([10u64, 20, 30, 40, 50]);
+        assert_arrays_eq!(casted.to_primitive(), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_fill_null_sparse_with_null_fill() -> vortex_error::VortexResult<()> {
+        // Regression test for https://github.com/vortex-data/vortex/issues/6932
+        // fill_null on a sparse array with null fill triggers an internal cast to
+        // non-nullable, which must not panic.
+        let sparse = Sparse::try_new(
+            buffer![1u64, 3].into_array(),
+            buffer![10u64, 20].into_array(),
+            5,
+            Scalar::null_native::<u64>(),
+        )?;
+
+        let filled = sparse.into_array().fill_null(Scalar::from(0u64))?;
+
+        assert_eq!(
+            filled.dtype(),
+            &DType::Primitive(PType::U64, Nullability::NonNullable)
+        );
+        Ok(())
     }
 }
diff --git a/encodings/sparse/src/compute/filter.rs b/encodings/sparse/src/compute/filter.rs
index 72e0a2f71d6..2cc8064a6cd 100644
--- a/encodings/sparse/src/compute/filter.rs
+++ b/encodings/sparse/src/compute/filter.rs
@@ -2,33 +2,31 @@
 // 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::arrays::ConstantArray;
-use vortex_array::arrays::FilterKernel;
+use vortex_array::arrays::filter::FilterKernel;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::SparseArray;
-use crate::SparseVTable;
-
-impl FilterKernel for SparseVTable {
+use crate::ConstantArray;
+use crate::Sparse;
+impl FilterKernel for Sparse {
     fn filter(
-        array: &SparseArray,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let new_length = mask.true_count();
 
-        let Some(new_patches) = array.patches().filter(mask)? else {
+        let Some(new_patches) = array.patches().filter(mask, ctx)? else {
             return Ok(Some(
                 ConstantArray::new(array.fill_scalar().clone(), new_length).into_array(),
             ));
         };
 
         Ok(Some(
-            SparseArray::try_new_from_patches(new_patches, array.fill_scalar().clone())?
-                .into_array(),
+            Sparse::try_new_from_patches(new_patches, array.fill_scalar().clone())?.into_array(),
         ))
     }
 }
@@ -37,7 +35,6 @@ impl FilterKernel for SparseVTable {
 mod tests {
     use rstest::fixture;
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
@@ -52,11 +49,11 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
-    use crate::SparseArray;
+    use crate::Sparse;
 
     #[fixture]
     fn array() -> ArrayRef {
-        SparseArray::try_new(
+        Sparse::try_new(
             buffer![2u64, 9, 15].into_array(),
             PrimitiveArray::new(buffer![33_i32, 44, 55], Validity::AllValid).into_array(),
             20,
@@ -76,7 +73,7 @@ mod tests {
 
         // Construct expected SparseArray: index 2 was kept, which had value 33.
         // The new index is 0 (since it's the only element).
-        let expected = SparseArray::try_new(
+        let expected = Sparse::try_new(
             buffer![0u64].into_array(),
             PrimitiveArray::new(buffer![33_i32], Validity::AllValid).into_array(),
             1,
@@ -90,7 +87,7 @@ mod tests {
     #[test]
     fn true_fill_value() {
         let mask = Mask::from_iter([false, true, false, true, false, true, true]);
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0_u64, 3, 6].into_array(),
             PrimitiveArray::new(buffer![33_i32, 44, 55], Validity::AllValid).into_array(),
             7,
@@ -105,7 +102,7 @@ mod tests {
         // Mask keeps indices 1, 3, 5, 6 -> new indices 0, 1, 2, 3.
         // Index 3 (value 44) maps to new index 1.
         // Index 6 (value 55) maps to new index 3.
-        let expected = SparseArray::try_new(
+        let expected = Sparse::try_new(
             buffer![1u64, 3].into_array(),
             PrimitiveArray::new(buffer![44_i32, 55], Validity::AllValid).into_array(),
             4,
@@ -120,7 +117,7 @@ mod tests {
     fn test_filter_sparse_array() {
         let null_fill_value = Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable));
         test_filter_conformance(
-            SparseArray::try_new(
+            &Sparse::try_new(
                 buffer![1u64, 2, 4].into_array(),
                 buffer![100i32, 200, 300]
                     .into_array()
@@ -130,19 +127,19 @@ mod tests {
                 null_fill_value,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
 
         let ten_fill_value = Scalar::from(10i32);
         test_filter_conformance(
-            SparseArray::try_new(
+            &Sparse::try_new(
                 buffer![1u64, 2, 4].into_array(),
                 buffer![100i32, 200, 300].into_array(),
                 5,
                 ten_fill_value,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         )
     }
 }
diff --git a/encodings/sparse/src/compute/mod.rs b/encodings/sparse/src/compute/mod.rs
index 7ac6eefae9a..a303a06b58a 100644
--- a/encodings/sparse/src/compute/mod.rs
+++ b/encodings/sparse/src/compute/mod.rs
@@ -24,11 +24,11 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
-    use crate::SparseArray;
+    use crate::Sparse;
 
     #[fixture]
     fn array() -> ArrayRef {
-        SparseArray::try_new(
+        Sparse::try_new(
             buffer![2u64, 9, 15].into_array(),
             PrimitiveArray::new(buffer![33_i32, 44, 55], Validity::AllValid).into_array(),
             20,
@@ -48,7 +48,7 @@ mod test {
 
         // Construct expected SparseArray: index 2 was kept, which had value 33.
         // The new index is 0 (since it's the only element).
-        let expected = SparseArray::try_new(
+        let expected = Sparse::try_new(
             buffer![0u64].into_array(),
             PrimitiveArray::new(buffer![33_i32], Validity::AllValid).into_array(),
             1,
@@ -62,7 +62,7 @@ mod test {
     #[test]
     fn true_fill_value() {
         let mask = Mask::from_iter([false, true, false, true, false, true, true]);
-        let array = SparseArray::try_new(
+        let array = Sparse::try_new(
             buffer![0_u64, 3, 6].into_array(),
             PrimitiveArray::new(buffer![33_i32, 44, 55], Validity::AllValid).into_array(),
             7,
@@ -77,7 +77,7 @@ mod test {
         // Mask keeps indices 1, 3, 5, 6 -> new indices 0, 1, 2, 3.
         // Index 3 (value 44) maps to new index 1.
         // Index 6 (value 55) maps to new index 3.
-        let expected = SparseArray::try_new(
+        let expected = Sparse::try_new(
             buffer![1u64, 3].into_array(),
             PrimitiveArray::new(buffer![44_i32, 55], Validity::AllValid).into_array(),
             4,
@@ -97,7 +97,7 @@ mod test {
     fn test_mask_sparse_array() {
         let null_fill_value = Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable));
         test_mask_conformance(
-            SparseArray::try_new(
+            &Sparse::try_new(
                 buffer![1u64, 2, 4].into_array(),
                 buffer![100i32, 200, 300]
                     .into_array()
@@ -107,19 +107,19 @@ mod test {
                 null_fill_value,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
 
         let ten_fill_value = Scalar::from(10i32);
         test_mask_conformance(
-            SparseArray::try_new(
+            &Sparse::try_new(
                 buffer![1u64, 2, 4].into_array(),
                 buffer![100i32, 200, 300].into_array(),
                 5,
                 ten_fill_value,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         )
     }
 }
@@ -138,50 +138,51 @@ mod tests {
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
 
+    use crate::Sparse;
     use crate::SparseArray;
 
     #[rstest]
     // Basic sparse arrays
-    #[case::sparse_i32_null_fill(SparseArray::try_new(
+    #[case::sparse_i32_null_fill(Sparse::try_new(
         buffer![2u64, 5, 8].into_array(),
         PrimitiveArray::from_option_iter([Some(100i32), Some(200), Some(300)]).into_array(),
         10,
         Scalar::null_native::<i32>()
     ).unwrap())]
-    #[case::sparse_i32_value_fill(SparseArray::try_new(
+    #[case::sparse_i32_value_fill(Sparse::try_new(
         buffer![1u64, 3, 7].into_array(),
         buffer![42i32, 84, 126].into_array(),
         10,
         Scalar::from(0i32)
     ).unwrap())]
     // Different types
-    #[case::sparse_u64(SparseArray::try_new(
+    #[case::sparse_u64(Sparse::try_new(
         buffer![0u64, 4, 9].into_array(),
         buffer![1000u64, 2000, 3000].into_array(),
         10,
         Scalar::from(999u64)
     ).unwrap())]
-    #[case::sparse_f32(SparseArray::try_new(
+    #[case::sparse_f32(Sparse::try_new(
         buffer![2u64, 6].into_array(),
         buffer![std::f32::consts::PI, std::f32::consts::E].into_array(),
         8,
         Scalar::from(0.0f32)
     ).unwrap())]
     // Edge cases
-    #[case::sparse_single_patch(SparseArray::try_new(
+    #[case::sparse_single_patch(Sparse::try_new(
         buffer![5u64].into_array(),
         buffer![42i32].into_array(),
         10,
         Scalar::from(-1i32)
     ).unwrap())]
-    #[case::sparse_dense_patches(SparseArray::try_new(
+    #[case::sparse_dense_patches(Sparse::try_new(
         buffer![0u64, 1, 2, 3, 4].into_array(),
         PrimitiveArray::from_option_iter([Some(10i32), Some(20), Some(30), Some(40), Some(50)]).into_array(),
         5,
         Scalar::null_native::<i32>()
     ).unwrap())]
     // Large sparse arrays
-    #[case::sparse_large(SparseArray::try_new(
+    #[case::sparse_large(Sparse::try_new(
         buffer![100u64, 500, 900, 1500, 1999].into_array(),
         buffer![111i32, 222, 333, 444, 555].into_array(),
         2000,
@@ -190,7 +191,7 @@ mod tests {
     // Nullable patches
     #[case::sparse_nullable_patches({
         let null_fill_value = Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable));
-        SparseArray::try_new(
+        Sparse::try_new(
             buffer![1u64, 4, 7].into_array(),
             PrimitiveArray::from_option_iter([Some(100i32), None, Some(300)])
                 .into_array()
@@ -202,41 +203,41 @@ mod tests {
     })]
 
     fn test_sparse_consistency(#[case] array: SparseArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
-    #[case::sparse_i32_basic(SparseArray::try_new(
+    #[case::sparse_i32_basic(Sparse::try_new(
         buffer![2u64, 5, 8].into_array(),
         buffer![100i32, 200, 300].into_array(),
         10,
         Scalar::from(0i32)
     ).unwrap())]
-    #[case::sparse_u32_basic(SparseArray::try_new(
+    #[case::sparse_u32_basic(Sparse::try_new(
         buffer![1u64, 3, 7].into_array(),
         buffer![1000u32, 2000, 3000].into_array(),
         10,
         Scalar::from(100u32)
     ).unwrap())]
-    #[case::sparse_i64_basic(SparseArray::try_new(
+    #[case::sparse_i64_basic(Sparse::try_new(
         buffer![0u64, 4, 9].into_array(),
         buffer![5000i64, 6000, 7000].into_array(),
         10,
         Scalar::from(1000i64)
     ).unwrap())]
-    #[case::sparse_f32_basic(SparseArray::try_new(
+    #[case::sparse_f32_basic(Sparse::try_new(
         buffer![2u64, 6].into_array(),
         buffer![1.5f32, 2.5].into_array(),
         8,
         Scalar::from(0.5f32)
     ).unwrap())]
-    #[case::sparse_f64_basic(SparseArray::try_new(
+    #[case::sparse_f64_basic(Sparse::try_new(
         buffer![1u64, 5, 9].into_array(),
         buffer![10.1f64, 20.2, 30.3].into_array(),
         10,
         Scalar::from(5.0f64)
     ).unwrap())]
-    #[case::sparse_i32_large(SparseArray::try_new(
+    #[case::sparse_i32_large(Sparse::try_new(
         buffer![10u64, 50, 90, 150, 199].into_array(),
         buffer![111i32, 222, 333, 444, 555].into_array(),
         200,
diff --git a/encodings/sparse/src/compute/take.rs b/encodings/sparse/src/compute/take.rs
index 9118f3b3f8c..b0b5f83cad0 100644
--- a/encodings/sparse/src/compute/take.rs
+++ b/encodings/sparse/src/compute/take.rs
@@ -1,27 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
 use vortex_error::VortexResult;
 
-use crate::SparseArray;
-use crate::SparseVTable;
-
-impl TakeExecute for SparseVTable {
+use crate::ConstantArray;
+use crate::Sparse;
+impl TakeExecute for Sparse {
     fn take(
-        array: &SparseArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let patches_take = if array.fill_scalar().is_null() {
-            array.patches().take(indices)?
+            array.patches().take(indices, ctx)?
         } else {
-            array.patches().take_with_nulls(indices)?
+            array.patches().take_with_nulls(indices, ctx)?
         };
 
         let Some(new_patches) = patches_take else {
@@ -41,7 +39,7 @@ impl TakeExecute for SparseVTable {
         }
 
         Ok(Some(
-            SparseArray::try_new_from_patches(
+            Sparse::try_new_from_patches(
                 new_patches,
                 array.fill_scalar().cast(
                     &array
@@ -57,7 +55,6 @@ impl TakeExecute for SparseVTable {
 #[cfg(test)]
 mod test {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::ConstantArray;
@@ -68,6 +65,7 @@ mod test {
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
+    use crate::Sparse;
     use crate::SparseArray;
 
     fn test_array_fill_value() -> Scalar {
@@ -76,7 +74,7 @@ mod test {
     }
 
     fn sparse_array() -> ArrayRef {
-        SparseArray::try_new(
+        Sparse::try_new(
             buffer![0u64, 37, 47, 99].into_array(),
             PrimitiveArray::new(buffer![1.23f64, 0.47, 9.99, 3.5], Validity::AllValid).into_array(),
             100,
@@ -92,7 +90,7 @@ mod test {
         let sparse = sparse.slice(30..40).unwrap();
         let taken = sparse.take(buffer![6, 7, 8].into_array()).unwrap();
         let expected = PrimitiveArray::from_option_iter([Option::<f64>::None, Some(0.47), None]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[test]
@@ -106,7 +104,7 @@ mod test {
             Some(1.23),
             Some(3.5),
         ]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[test]
@@ -124,12 +122,12 @@ mod test {
         let taken = sparse.take(buffer![69, 37].into_array()).unwrap();
         // Index 69 is not in sparse array (fill value is null), index 37 has value 0.47
         let expected = PrimitiveArray::from_option_iter([Option::<f64>::None, Some(0.47f64)]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[test]
     fn nullable_take() {
-        let arr = SparseArray::try_new(
+        let arr = Sparse::try_new(
             buffer![1u32].into_array(),
             buffer![10].into_array(),
             10,
@@ -140,17 +138,17 @@ mod test {
         let taken = arr
             .take(
                 PrimitiveArray::from_option_iter([Some(2u32), Some(1u32), Option::<u32>::None])
-                    .to_array(),
+                    .into_array(),
             )
             .unwrap();
 
         let expected = PrimitiveArray::from_option_iter([Some(1), Some(10), Option::<i32>::None]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[test]
     fn nullable_take_with_many_patches() {
-        let arr = SparseArray::try_new(
+        let arr = Sparse::try_new(
             buffer![1u32, 3, 7, 8, 9].into_array(),
             buffer![10, 8, 3, 2, 1].into_array(),
             10,
@@ -161,22 +159,22 @@ mod test {
         let taken = arr
             .take(
                 PrimitiveArray::from_option_iter([Some(2u32), Some(1u32), Option::<u32>::None])
-                    .to_array(),
+                    .into_array(),
             )
             .unwrap();
 
         let expected = PrimitiveArray::from_option_iter([Some(1), Some(10), Option::<i32>::None]);
-        assert_arrays_eq!(taken, expected.to_array());
+        assert_arrays_eq!(taken, expected.into_array());
     }
 
     #[rstest]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![0u64, 37, 47, 99].into_array(),
         PrimitiveArray::new(buffer![1.23f64, 0.47, 9.99, 3.5], Validity::AllValid).into_array(),
         100,
         Scalar::null_native::<f64>(),
     ).unwrap())]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![1u32, 3, 7, 8, 9].into_array(),
         buffer![10, 8, 3, 2, 1].into_array(),
         10,
@@ -184,14 +182,14 @@ mod test {
     ).unwrap())]
     #[case({
         let nullable_values = PrimitiveArray::from_option_iter([Some(100i64), None, Some(300)]);
-        SparseArray::try_new(
+        Sparse::try_new(
             buffer![2u64, 4, 6].into_array(),
             nullable_values.into_array(),
             10,
             Scalar::null_native::<i64>(),
         ).unwrap()
     })]
-    #[case(SparseArray::try_new(
+    #[case(Sparse::try_new(
         buffer![5u64].into_array(),
         buffer![999i32].into_array(),
         20,
@@ -199,6 +197,6 @@ mod test {
     ).unwrap())]
     fn test_take_sparse_conformance(#[case] sparse: SparseArray) {
         use vortex_array::compute::conformance::take::test_take_conformance;
-        test_take_conformance(sparse.as_ref());
+        test_take_conformance(&sparse.into_array());
     }
 }
diff --git a/encodings/sparse/src/kernel.rs b/encodings/sparse/src/kernel.rs
index 5b6795b407b..18928ea0142 100644
--- a/encodings/sparse/src/kernel.rs
+++ b/encodings/sparse/src/kernel.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterExecuteAdaptor;
-use vortex_array::arrays::SliceExecuteAdaptor;
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::filter::FilterExecuteAdaptor;
+use vortex_array::arrays::slice::SliceExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::SparseVTable;
+use crate::Sparse;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<SparseVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(SparseVTable)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(SparseVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(SparseVTable)),
+pub(crate) static PARENT_KERNELS: ParentKernelSet<Sparse> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FilterExecuteAdaptor(Sparse)),
+    ParentKernelSet::lift(&SliceExecuteAdaptor(Sparse)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Sparse)),
 ]);
diff --git a/encodings/sparse/src/lib.rs b/encodings/sparse/src/lib.rs
index 57feb8731c9..87fd640fd1c 100644
--- a/encodings/sparse/src/lib.rs
+++ b/encodings/sparse/src/lib.rs
@@ -2,25 +2,29 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 
 use kernel::PARENT_KERNELS;
 use prost::Message as _;
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::bool::BoolArrayExt;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builtins::ArrayBuiltins;
-use vortex_array::compute::filter;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::patches::Patches;
@@ -29,21 +33,17 @@ use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
-use vortex_array::vtable::VisitorVTable;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBufferMut;
 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_panic;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 use vortex_session::VortexSession;
@@ -58,7 +58,8 @@ mod ops;
 mod rules;
 mod slice;
 
-vtable!(Sparse);
+/// A [`Sparse`]-encoded Vortex array.
+pub type SparseArray = Array<Sparse>;
 
 #[derive(Clone, prost::Message)]
 #[repr(C)]
@@ -67,101 +68,125 @@ pub struct SparseMetadata {
     patches: PatchesMetadata,
 }
 
-impl VTable for SparseVTable {
-    type Array = SparseArray;
+impl ArrayHash for SparseData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.patches.array_hash(state, precision);
+        self.fill_value.hash(state);
+    }
+}
+
+impl ArrayEq for SparseData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.patches.array_eq(&other.patches, precision) && self.fill_value == other.fill_value
+    }
+}
 
-    type Metadata = ProstMetadata<SparseMetadata>;
+impl VTable for Sparse {
+    type ArrayData = SparseData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &SparseArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(SparseMetadata {
-            patches: array.patches().to_metadata(array.len(), array.dtype())?,
-        }))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        SparseData::validate(data.patches(), data.fill_scalar(), dtype, len)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => {
+                let fill_value_buffer =
+                    ScalarValue::to_proto_bytes::<ByteBufferMut>(array.fill_value.value()).freeze();
+                BufferHandle::new_host(fill_value_buffer)
+            }
+            _ => vortex_panic!("SparseArray buffer index {idx} out of bounds"),
+        }
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("fill_value".to_string()),
+            _ => vortex_panic!("SparseArray buffer_name index {idx} out of bounds"),
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(SparseMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        let patches = array.patches().to_metadata(array.len(), array.dtype())?;
+        let metadata = SparseMetadata { patches };
+
+        // Note that we DO NOT serialize the fill value since that is stored in the buffers.
+        Ok(Some(metadata.encode_to_vec()))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<SparseArray> {
-        if children.len() != 2 {
-            vortex_bail!(
-                "Expected 2 children for sparse encoding, found {}",
-                children.len()
-            )
-        }
-        vortex_ensure!(
-            metadata.0.patches.offset()? == 0,
-            "Patches must start at offset 0"
-        );
+        session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = SparseMetadata::decode(metadata)?;
 
-        let patch_indices = children.get(
-            0,
-            &metadata.0.patches.indices_dtype()?,
-            metadata.0.patches.len()?,
-        )?;
-        let patch_values = children.get(1, dtype, metadata.0.patches.len()?)?;
+        // Once we have the patches metadata, we need to get the fill value from the buffers.
 
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
+        let scalar_bytes: &[u8] = &buffers[0].clone().try_to_host_sync()?;
 
-        let bytes: &[u8] = &buffers[0].clone().try_to_host_sync()?;
-        let scalar_value = ScalarValue::from_proto_bytes(bytes, dtype)?;
-
+        let scalar_value = ScalarValue::from_proto_bytes(scalar_bytes, dtype, session)?;
         let fill_value = Scalar::try_new(dtype.clone(), scalar_value)?;
 
-        SparseArray::try_new(patch_indices, patch_values, len, fill_value)
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 2,
-            "SparseArray expects 2 children, got {}",
+        vortex_ensure_eq!(
+            children.len(),
+            2,
+            "SparseArray expects 2 children for sparse encoding, found {}",
             children.len()
         );
 
-        let mut children_iter = children.into_iter();
-        let patch_indices = children_iter.next().vortex_expect("patch_indices child");
-        let patch_values = children_iter.next().vortex_expect("patch_values child");
+        let patch_indices = children.get(
+            0,
+            &metadata.patches.indices_dtype()?,
+            metadata.patches.len()?,
+        )?;
+        let patch_values = children.get(1, dtype, metadata.patches.len()?)?;
 
-        array.patches = Patches::new(
-            array.patches.array_len(),
-            array.patches.offset(),
+        let patches = Patches::new(
+            len,
+            metadata.patches.offset()?,
             patch_indices,
             patch_values,
-            array.patches.chunk_offsets().clone(),
+            None,
         )?;
+        let slots = SparseData::make_slots(&patches);
+        let data = SparseData::try_new_from_patches(patches, fill_value)?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+    }
 
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -169,7 +194,7 @@ impl VTable for SparseVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -177,79 +202,136 @@ impl VTable for SparseVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        execute_sparse(array)
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        execute_sparse(&array, ctx).map(ExecutionResult::done)
     }
 }
 
+pub(crate) const NUM_SLOTS: usize = 3;
+pub(crate) const SLOT_NAMES: [&str; NUM_SLOTS] =
+    ["patch_indices", "patch_values", "patch_chunk_offsets"];
+
 #[derive(Clone, Debug)]
-pub struct SparseArray {
+pub struct SparseData {
     patches: Patches,
     fill_value: Scalar,
-    stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
-pub struct SparseVTable;
+impl Display for SparseData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "fill_value: {}", self.fill_value)
+    }
+}
 
-impl SparseVTable {
+#[derive(Clone, Debug)]
+pub struct Sparse;
+
+impl Sparse {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.sparse");
-}
 
-impl SparseArray {
+    /// Construct a new [`SparseArray`] from indices, values, length, and fill value.
     pub fn try_new(
         indices: ArrayRef,
         values: ArrayRef,
         len: usize,
         fill_value: Scalar,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(
-            indices.len() == values.len(),
-            "Mismatched indices {} and values {} length",
-            indices.len(),
-            values.len()
-        );
-
-        if indices.is_host() {
-            debug_assert_eq!(
-                indices.statistics().compute_is_strict_sorted(),
-                Some(true),
-                "SparseArray: indices must be strict-sorted"
-            );
+    ) -> VortexResult<SparseArray> {
+        let dtype = fill_value.dtype().clone();
+        let patches = Patches::new(len, 0, indices, values, None)?;
+        let slots = SparseData::make_slots(&patches);
+        let data = SparseData::try_new_from_patches(patches, fill_value)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Sparse, dtype, len, data).with_slots(slots))
+        })
+    }
 
-            // Verify the indices are all in the valid range
-            if !indices.is_empty() {
-                let last_index = usize::try_from(&indices.scalar_at(indices.len() - 1)?)?;
+    pub fn try_new_from_patches(patches: Patches, fill_value: Scalar) -> VortexResult<SparseArray> {
+        let dtype = fill_value.dtype().clone();
+        let len = patches.array_len();
+        let slots = SparseData::make_slots(&patches);
+        let data = SparseData::try_new_from_patches(patches, fill_value)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Sparse, dtype, len, data).with_slots(slots))
+        })
+    }
 
-                vortex_ensure!(
-                    last_index < len,
-                    "Array length was {len} but the last index is {last_index}"
-                );
-            }
+    pub(crate) unsafe fn new_unchecked(patches: Patches, fill_value: Scalar) -> SparseArray {
+        let dtype = fill_value.dtype().clone();
+        let len = patches.array_len();
+        let slots = SparseData::make_slots(&patches);
+        let data = unsafe { SparseData::new_unchecked(patches, fill_value) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Sparse, dtype, len, data).with_slots(slots))
         }
+    }
 
-        Ok(Self {
-            // TODO(0ax1): handle chunk offsets
-            patches: Patches::new(len, 0, indices, values, None)?,
-            fill_value,
-            stats_set: Default::default(),
-        })
+    /// Encode the given array as a [`SparseArray`].
+    pub fn encode(array: &ArrayRef, fill_value: Option<Scalar>) -> VortexResult<ArrayRef> {
+        SparseData::encode(array, fill_value)
     }
+}
+
+impl SparseData {
+    fn normalize_patches_dtype(patches: Patches, fill_value: &Scalar) -> VortexResult<Patches> {
+        let fill_dtype = fill_value.dtype();
+        let values_dtype = patches.values().dtype();
 
-    /// Build a new SparseArray from an existing set of patches.
-    pub fn try_new_from_patches(patches: Patches, fill_value: Scalar) -> VortexResult<Self> {
         vortex_ensure!(
-            fill_value.dtype() == patches.values().dtype(),
+            values_dtype.eq_ignore_nullability(fill_dtype),
             "fill value, {:?}, should be instance of values dtype, {} but was {}.",
             fill_value,
-            patches.values().dtype(),
+            values_dtype,
+            fill_dtype,
+        );
+
+        if values_dtype == fill_dtype {
+            Ok(patches)
+        } else {
+            patches.cast_values(fill_dtype)
+        }
+    }
+
+    pub fn validate(
+        patches: &Patches,
+        fill_value: &Scalar,
+        dtype: &DType,
+        len: usize,
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            fill_value.dtype() == dtype,
+            "fill value dtype {} does not match array dtype {}",
             fill_value.dtype(),
+            dtype,
         );
+        vortex_ensure!(
+            patches.array_len() == len,
+            "patches length {} does not match array length {}",
+            patches.array_len(),
+            len
+        );
+        vortex_ensure!(
+            patches.values().dtype() == dtype,
+            "patch values dtype {} does not match array dtype {}",
+            patches.values().dtype(),
+            dtype,
+        );
+        Ok(())
+    }
 
+    fn make_slots(patches: &Patches) -> Vec<Option<ArrayRef>> {
+        vec![
+            Some(patches.indices().clone()),
+            Some(patches.values().clone()),
+            patches.chunk_offsets().clone(),
+        ]
+    }
+
+    /// Build a new SparseArray from an existing set of patches.
+    pub fn try_new_from_patches(patches: Patches, fill_value: Scalar) -> VortexResult<Self> {
+        let patches = Self::normalize_patches_dtype(patches, &fill_value)?;
         Ok(Self {
             patches,
             fill_value,
-            stats_set: Default::default(),
         })
     }
 
@@ -257,10 +339,27 @@ impl SparseArray {
         Self {
             patches,
             fill_value,
-            stats_set: Default::default(),
         }
     }
 
+    /// Returns the length of the array.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.patches.array_len()
+    }
+
+    /// Returns whether the array is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.patches.array_len() == 0
+    }
+
+    /// Returns the logical data type of the array.
+    #[inline]
+    pub fn dtype(&self) -> &DType {
+        self.fill_scalar().dtype()
+    }
+
     #[inline]
     pub fn patches(&self) -> &Patches {
         &self.patches
@@ -270,7 +369,7 @@ impl SparseArray {
     pub fn resolved_patches(&self) -> VortexResult<Patches> {
         let patches = self.patches();
         let indices_offset = Scalar::from(patches.offset()).cast(patches.indices().dtype())?;
-        let indices = patches.indices().to_array().binary(
+        let indices = patches.indices().binary(
             ConstantArray::new(indices_offset, patches.indices().len()).into_array(),
             Operator::Sub,
         )?;
@@ -293,12 +392,12 @@ impl SparseArray {
     /// Encode given array as a SparseArray.
     ///
     /// Optionally provided fill value will be respected if the array is less than 90% null.
-    pub fn encode(array: &dyn Array, fill_value: Option<Scalar>) -> VortexResult<ArrayRef> {
+    pub fn encode(array: &ArrayRef, fill_value: Option<Scalar>) -> VortexResult<ArrayRef> {
         if let Some(fill_value) = fill_value.as_ref()
-            && array.dtype() != fill_value.dtype()
+            && !array.dtype().eq_ignore_nullability(fill_value.dtype())
         {
             vortex_bail!(
-                "Array and fill value types must match. got {} and {}",
+                "Array and fill value types must have the same base type. got {} and {}",
                 array.dtype(),
                 fill_value.dtype()
             )
@@ -312,7 +411,8 @@ impl SparseArray {
             );
         } else if mask.false_count() as f64 > (0.9 * mask.len() as f64) {
             // Array is dominated by NULL but has non-NULL values
-            let non_null_values = filter(array, &mask)?;
+            // TODO(joe): use exe ctx?
+            let non_null_values = array.filter(mask.clone())?.to_canonical()?.into_array();
             let non_null_indices = match mask.indices() {
                 AllOr::All => {
                     // We already know that the mask is 90%+ false
@@ -332,17 +432,17 @@ impl SparseArray {
                 }
             };
 
-            return Ok(SparseArray::try_new(
+            return Sparse::try_new(
                 non_null_indices,
                 non_null_values,
                 array.len(),
                 Scalar::null(array.dtype().clone()),
-            )?
-            .into_array());
+            )
+            .map(IntoArray::into_array);
         }
 
         let fill = if let Some(fill) = fill_value {
-            fill
+            fill.cast(array.dtype())?
         } else {
             // TODO(robert): Support other dtypes, only thing missing is getting most common value out of the array
             let (top_pvalue, _) = array
@@ -356,14 +456,16 @@ impl SparseArray {
         let fill_array = ConstantArray::new(fill.clone(), array.len()).into_array();
         let non_top_mask = Mask::from_buffer(
             array
-                .to_array()
                 .binary(fill_array.clone(), Operator::NotEq)?
                 .fill_null(Scalar::bool(true, Nullability::NonNullable))?
                 .to_bool()
                 .to_bit_buffer(),
         );
 
-        let non_top_values = filter(array, &non_top_mask)?;
+        let non_top_values = array
+            .filter(non_top_mask.clone())?
+            .to_canonical()?
+            .into_array();
 
         let indices: Buffer<u64> = match non_top_mask {
             Mask::AllTrue(count) => {
@@ -377,36 +479,13 @@ impl SparseArray {
             Mask::Values(values) => values.indices().iter().map(|v| *v as u64).collect(),
         };
 
-        SparseArray::try_new(indices.into_array(), non_top_values, array.len(), fill)
-            .map(|a| a.into_array())
+        Sparse::try_new(indices.into_array(), non_top_values, array.len(), fill)
+            .map(IntoArray::into_array)
     }
 }
 
-impl BaseArrayVTable<SparseVTable> for SparseVTable {
-    fn len(array: &SparseArray) -> usize {
-        array.patches.array_len()
-    }
-
-    fn dtype(array: &SparseArray) -> &DType {
-        array.fill_scalar().dtype()
-    }
-
-    fn stats(array: &SparseArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &SparseArray, state: &mut H, precision: Precision) {
-        array.patches.array_hash(state, precision);
-        array.fill_value.hash(state);
-    }
-
-    fn array_eq(array: &SparseArray, other: &SparseArray, precision: Precision) -> bool {
-        array.patches.array_eq(&other.patches, precision) && array.fill_value == other.fill_value
-    }
-}
-
-impl ValidityVTable<SparseVTable> for SparseVTable {
-    fn validity(array: &SparseArray) -> VortexResult<Validity> {
+impl ValidityVTable<Sparse> for Sparse {
+    fn validity(array: ArrayView<'_, Sparse>) -> VortexResult<Validity> {
         let patches = unsafe {
             Patches::new_unchecked(
                 array.patches.array_len(),
@@ -423,33 +502,12 @@ impl ValidityVTable<SparseVTable> for SparseVTable {
         };
 
         Ok(Validity::Array(
-            unsafe { SparseArray::new_unchecked(patches, array.fill_value.is_valid().into()) }
+            unsafe { Sparse::new_unchecked(patches, array.fill_value.is_valid().into()) }
                 .into_array(),
         ))
     }
 }
 
-impl VisitorVTable<SparseVTable> for SparseVTable {
-    fn visit_buffers(array: &SparseArray, visitor: &mut dyn ArrayBufferVisitor) {
-        let fill_value_buffer =
-            ScalarValue::to_proto_bytes::<ByteBufferMut>(array.fill_value.value()).freeze();
-        visitor.visit_buffer_handle("fill_value", &BufferHandle::new_host(fill_value_buffer));
-    }
-
-    fn nbuffers(_array: &SparseArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &SparseArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_patches(array.patches())
-    }
-
-    fn nchildren(array: &SparseArray) -> usize {
-        // patches have indices + values + optional chunk_offsets
-        2 + array.patches().chunk_offsets().is_some() as usize
-    }
-}
-
 #[cfg(test)]
 mod test {
     use itertools::Itertools;
@@ -467,6 +525,7 @@ mod test {
     use vortex_error::VortexExpect;
 
     use super::*;
+    use crate::Sparse;
 
     fn nullable_fill() -> Scalar {
         Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable))
@@ -481,7 +540,7 @@ mod test {
         let mut values = buffer![100i32, 200, 300].into_array();
         values = values.cast(fill_value.dtype().clone()).unwrap();
 
-        SparseArray::try_new(buffer![2u64, 5, 8].into_array(), values, 10, fill_value)
+        Sparse::try_new(buffer![2u64, 5, 8].into_array(), values, 10, fill_value)
             .unwrap()
             .into_array()
     }
@@ -504,7 +563,7 @@ mod test {
 
     #[test]
     pub fn test_scalar_at_again() {
-        let arr = SparseArray::try_new(
+        let arr = Sparse::try_new(
             ConstantArray::new(10u32, 1).into_array(),
             ConstantArray::new(Scalar::primitive(1234u32, Nullability::Nullable), 1).into_array(),
             100,
@@ -540,7 +599,7 @@ mod test {
 
     #[test]
     pub fn validity_mask_sliced_nonnull_fill() {
-        let sliced = SparseArray::try_new(
+        let sliced = Sparse::try_new(
             buffer![2u64, 5, 8].into_array(),
             ConstantArray::new(
                 Scalar::null(DType::Primitive(PType::F32, Nullability::Nullable)),
@@ -603,7 +662,7 @@ mod test {
         let values = buffer![15_u32, 135, 13531, 42].into_array();
         let indices = buffer![10_u64, 11, 50, 100].into_array();
 
-        SparseArray::try_new(indices, values, 100, 0_u32.into()).unwrap();
+        Sparse::try_new(indices, values, 100, 0_u32.into()).unwrap();
     }
 
     #[test]
@@ -611,7 +670,7 @@ mod test {
         let values = buffer![15_u32, 135, 13531, 42].into_array();
         let indices = buffer![10_u64, 11, 50, 100].into_array();
 
-        SparseArray::try_new(indices, values, 101, 0_u32.into()).unwrap();
+        Sparse::try_new(indices, values, 101, 0_u32.into()).unwrap();
     }
 
     #[test]
@@ -622,8 +681,8 @@ mod test {
                 true, true, false, true, false, true, false, true, true, false, true, false,
             ]),
         );
-        let sparse = SparseArray::encode(&original.clone().into_array(), None)
-            .vortex_expect("SparseArray::encode should succeed for test data");
+        let sparse = Sparse::encode(&original.clone().into_array(), None)
+            .vortex_expect("Sparse::encode should succeed for test data");
         assert_eq!(
             sparse.validity_mask().unwrap(),
             Mask::from_iter(vec![
@@ -638,8 +697,7 @@ mod test {
         let indices = buffer![0u8, 2, 4, 6, 8].into_array();
         let values = PrimitiveArray::from_option_iter([Some(0i16), Some(1), None, None, Some(4)])
             .into_array();
-        let array =
-            SparseArray::try_new(indices, values, 10, Scalar::null_native::<i16>()).unwrap();
+        let array = Sparse::try_new(indices, values, 10, Scalar::null_native::<i16>()).unwrap();
         let actual = array.validity_mask().unwrap();
         let expected = Mask::from_iter([
             true, false, true, false, false, false, false, false, true, false,
diff --git a/encodings/sparse/src/ops.rs b/encodings/sparse/src/ops.rs
index 7fbe2b4af4c..552dcf5fa6e 100644
--- a/encodings/sparse/src/ops.rs
+++ b/encodings/sparse/src/ops.rs
@@ -1,15 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
 use vortex_array::scalar::Scalar;
 use vortex_array::vtable::OperationsVTable;
 use vortex_error::VortexResult;
 
-use crate::SparseArray;
-use crate::SparseVTable;
+use crate::Sparse;
 
-impl OperationsVTable<SparseVTable> for SparseVTable {
-    fn scalar_at(array: &SparseArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Sparse> for Sparse {
+    fn scalar_at(
+        array: ArrayView<'_, Sparse>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(array
             .patches()
             .get_patched(index)?
@@ -25,14 +30,14 @@ mod tests {
     use vortex_array::assert_arrays_eq;
     use vortex_buffer::buffer;
 
-    use super::*;
+    use crate::Sparse;
 
     #[test]
     fn slice_partially_invalid() {
         let values = buffer![0u64].into_array();
         let indices = buffer![0u8].into_array();
 
-        let sparse = SparseArray::try_new(indices, values, 1000, 999u64.into()).unwrap();
+        let sparse = Sparse::try_new(indices, values, 1000, 999u64.into()).unwrap();
         let sliced = sparse.slice(0..1000).unwrap();
         let mut expected = vec![999u64; 1000];
         expected[0] = 0;
diff --git a/encodings/sparse/src/rules.rs b/encodings/sparse/src/rules.rs
index 221af9060ae..c53e7e4c6a5 100644
--- a/encodings/sparse/src/rules.rs
+++ b/encodings/sparse/src/rules.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::optimizer::rules::ParentRuleSet;
@@ -10,20 +11,19 @@ use vortex_array::scalar_fn::fns::not::NotReduce;
 use vortex_array::scalar_fn::fns::not::NotReduceAdaptor;
 use vortex_error::VortexResult;
 
-use crate::SparseArray;
-use crate::SparseVTable;
+use crate::Sparse;
 
-pub(crate) static RULES: ParentRuleSet<SparseVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(SparseVTable)),
-    ParentRuleSet::lift(&NotReduceAdaptor(SparseVTable)),
+pub(crate) static RULES: ParentRuleSet<Sparse> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(Sparse)),
+    ParentRuleSet::lift(&NotReduceAdaptor(Sparse)),
 ]);
 
-impl NotReduce for SparseVTable {
-    fn invert(array: &SparseArray) -> VortexResult<Option<ArrayRef>> {
+impl NotReduce for Sparse {
+    fn invert(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>> {
         let inverted_fill = array.fill_scalar().as_bool().invert().into_scalar();
         let inverted_patches = array.patches().clone().map_values(|values| values.not())?;
         Ok(Some(
-            SparseArray::try_new_from_patches(inverted_patches, inverted_fill)?.into_array(),
+            Sparse::try_new_from_patches(inverted_patches, inverted_fill)?.into_array(),
         ))
     }
 }
diff --git a/encodings/sparse/src/slice.rs b/encodings/sparse/src/slice.rs
index ba125c3d8cb..7a36d58e209 100644
--- a/encodings/sparse/src/slice.rs
+++ b/encodings/sparse/src/slice.rs
@@ -4,18 +4,18 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::SliceKernel;
+use vortex_array::arrays::slice::SliceKernel;
 use vortex_error::VortexResult;
 
-use crate::SparseArray;
-use crate::SparseVTable;
+use crate::ConstantArray;
+use crate::Sparse;
 
-impl SliceKernel for SparseVTable {
+impl SliceKernel for Sparse {
     fn slice(
-        array: &SparseArray,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -35,8 +35,7 @@ impl SliceKernel for SparseVTable {
         // patches slice will ensure that dtype of patches is unchanged and the indices and
         // values match
         Ok(Some(
-            unsafe { SparseArray::new_unchecked(new_patches, array.fill_scalar().clone()) }
-                .into_array(),
+            unsafe { Sparse::new_unchecked(new_patches, array.fill_scalar().clone()) }.into_array(),
         ))
     }
 }
diff --git a/encodings/zigzag/public-api.lock b/encodings/zigzag/public-api.lock
index 8ad219a508b..a366ce1d631 100644
--- a/encodings/zigzag/public-api.lock
+++ b/encodings/zigzag/public-api.lock
@@ -1,135 +1,125 @@
 pub mod vortex_zigzag
 
-pub struct vortex_zigzag::ZigZagArray
+pub struct vortex_zigzag::ZigZag
 
-impl vortex_zigzag::ZigZagArray
+impl vortex_zigzag::ZigZag
 
-pub fn vortex_zigzag::ZigZagArray::encoded(&self) -> &vortex_array::array::ArrayRef
+pub const vortex_zigzag::ZigZag::ID: vortex_array::array::ArrayId
 
-pub fn vortex_zigzag::ZigZagArray::new(encoded: vortex_array::array::ArrayRef) -> Self
+pub fn vortex_zigzag::ZigZag::try_new(encoded: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_zigzag::ZigZagArray>
 
-pub fn vortex_zigzag::ZigZagArray::ptype(&self) -> vortex_array::dtype::ptype::PType
+impl core::clone::Clone for vortex_zigzag::ZigZag
 
-pub fn vortex_zigzag::ZigZagArray::try_new(encoded: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_zigzag::ZigZag::clone(&self) -> vortex_zigzag::ZigZag
 
-impl core::clone::Clone for vortex_zigzag::ZigZagArray
+impl core::fmt::Debug for vortex_zigzag::ZigZag
 
-pub fn vortex_zigzag::ZigZagArray::clone(&self) -> vortex_zigzag::ZigZagArray
+pub fn vortex_zigzag::ZigZag::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_zigzag::ZigZagArray
+impl vortex_array::array::vtable::VTable for vortex_zigzag::ZigZag
 
-pub fn vortex_zigzag::ZigZagArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_zigzag::ZigZag::ArrayData = vortex_zigzag::ZigZagData
 
-impl core::convert::From<vortex_zigzag::ZigZagArray> for vortex_array::array::ArrayRef
+pub type vortex_zigzag::ZigZag::OperationsVTable = vortex_zigzag::ZigZag
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_zigzag::ZigZagArray) -> vortex_array::array::ArrayRef
+pub type vortex_zigzag::ZigZag::ValidityVTable = vortex_array::array::vtable::validity::ValidityVTableFromChild
 
-impl core::fmt::Debug for vortex_zigzag::ZigZagArray
+pub fn vortex_zigzag::ZigZag::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_zigzag::ZigZagArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_zigzag::ZigZag::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::ops::deref::Deref for vortex_zigzag::ZigZagArray
+pub fn vortex_zigzag::ZigZag::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-pub type vortex_zigzag::ZigZagArray::Target = dyn vortex_array::array::Array
+pub fn vortex_zigzag::ZigZag::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub fn vortex_zigzag::ZigZagArray::deref(&self) -> &Self::Target
+pub fn vortex_zigzag::ZigZag::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_array::array::IntoArray for vortex_zigzag::ZigZagArray
+pub fn vortex_zigzag::ZigZag::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_zigzag::ZigZagArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_zigzag::ZigZag::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-impl vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::serialize(_array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub const vortex_zigzag::ZigZagVTable::ID: vortex_array::vtable::dyn_::ArrayId
+pub fn vortex_zigzag::ZigZag::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::fmt::Debug for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_zigzag::ZigZagVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_zigzag::ZigZag> for vortex_zigzag::ZigZag
 
-impl vortex_array::arrays::dict::take::TakeExecute for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_zigzag::ZigZag>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_zigzag::ZigZagVTable::take(array: &vortex_zigzag::ZigZagArray, indices: &dyn vortex_array::array::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::array::vtable::validity::ValidityChild<vortex_zigzag::ZigZag> for vortex_zigzag::ZigZag
 
-impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::validity_child(array: vortex_array::array::view::ArrayView<'_, vortex_zigzag::ZigZag>) -> vortex_array::array::erased::ArrayRef
 
-pub fn vortex_zigzag::ZigZagVTable::filter(array: &vortex_zigzag::ZigZagArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_zigzag::ZigZag
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::take(array: vortex_array::array::view::ArrayView<'_, Self>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_zigzag::ZigZagVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::filter::kernel::FilterReduce for vortex_zigzag::ZigZag
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::filter(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_zigzag::ZigZagVTable::cast(array: &vortex_zigzag::ZigZagArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::arrays::slice::SliceReduce for vortex_zigzag::ZigZag
 
-impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_zigzag::ZigZagVTable::mask(array: &vortex_zigzag::ZigZagArray, mask: &vortex_array::array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_zigzag::ZigZag
 
-impl vortex_array::vtable::VTable for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_zigzag::ZigZagVTable::Array = vortex_zigzag::ZigZagArray
+impl vortex_array::scalar_fn::fns::mask::kernel::MaskReduce for vortex_zigzag::ZigZag
 
-pub type vortex_zigzag::ZigZagVTable::ArrayVTable = vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZag::mask(array: vortex_array::array::view::ArrayView<'_, Self>, mask: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub type vortex_zigzag::ZigZagVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub struct vortex_zigzag::ZigZagData
 
-pub type vortex_zigzag::ZigZagVTable::OperationsVTable = vortex_zigzag::ZigZagVTable
+impl vortex_zigzag::ZigZagData
 
-pub type vortex_zigzag::ZigZagVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromChild
+pub fn vortex_zigzag::ZigZagData::new() -> Self
 
-pub type vortex_zigzag::ZigZagVTable::VisitorVTable = vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZagData::try_new(encoded_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_zigzag::ZigZagVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_zigzag::ZigZagArray>
+impl core::clone::Clone for vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_zigzag::ZigZagData::clone(&self) -> vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl core::default::Default for vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_zigzag::ZigZagData::default() -> Self
 
-pub fn vortex_zigzag::ZigZagVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+impl core::fmt::Debug for vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::metadata(_array: &vortex_zigzag::ZigZagArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_zigzag::ZigZagData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zigzag::ZigZagVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl core::fmt::Display for vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_zigzag::ZigZagData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zigzag::ZigZagVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl vortex_array::hash::ArrayEq for vortex_zigzag::ZigZagData
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_zigzag::ZigZagVTable> for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::ZigZagData::array_eq(&self, _other: &Self, _precision: vortex_array::hash::Precision) -> bool
 
-pub fn vortex_zigzag::ZigZagVTable::array_eq(array: &vortex_zigzag::ZigZagArray, other: &vortex_zigzag::ZigZagArray, precision: vortex_array::hash::Precision) -> bool
+impl vortex_array::hash::ArrayHash for vortex_zigzag::ZigZagData
 
-pub fn vortex_zigzag::ZigZagVTable::array_hash<H: core::hash::Hasher>(array: &vortex_zigzag::ZigZagArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub fn vortex_zigzag::ZigZagData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::hash::Precision)
 
-pub fn vortex_zigzag::ZigZagVTable::dtype(array: &vortex_zigzag::ZigZagArray) -> &vortex_array::dtype::DType
+pub trait vortex_zigzag::ZigZagArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_zigzag::ZigZag>
 
-pub fn vortex_zigzag::ZigZagVTable::len(array: &vortex_zigzag::ZigZagArray) -> usize
+pub fn vortex_zigzag::ZigZagArrayExt::encoded(&self) -> &vortex_array::array::erased::ArrayRef
 
-pub fn vortex_zigzag::ZigZagVTable::stats(array: &vortex_zigzag::ZigZagArray) -> vortex_array::stats::array::StatsSetRef<'_>
+pub fn vortex_zigzag::ZigZagArrayExt::ptype(&self) -> vortex_array::dtype::ptype::PType
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_zigzag::ZigZagVTable> for vortex_zigzag::ZigZagVTable
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_zigzag::ZigZag>> vortex_zigzag::ZigZagArrayExt for T
 
-pub fn vortex_zigzag::ZigZagVTable::scalar_at(array: &vortex_zigzag::ZigZagArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn T::encoded(&self) -> &vortex_array::array::erased::ArrayRef
 
-impl vortex_array::vtable::validity::ValidityChild<vortex_zigzag::ZigZagVTable> for vortex_zigzag::ZigZagVTable
+pub fn T::ptype(&self) -> vortex_array::dtype::ptype::PType
 
-pub fn vortex_zigzag::ZigZagVTable::validity_child(array: &vortex_zigzag::ZigZagArray) -> &vortex_array::array::ArrayRef
+pub fn vortex_zigzag::zigzag_decode(parray: vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_array::arrays::primitive::vtable::PrimitiveArray
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_zigzag::ZigZagVTable> for vortex_zigzag::ZigZagVTable
+pub fn vortex_zigzag::zigzag_encode(parray: vortex_array::arrays::primitive::vtable::PrimitiveArray) -> vortex_error::VortexResult<vortex_zigzag::ZigZagArray>
 
-pub fn vortex_zigzag::ZigZagVTable::nbuffers(_array: &vortex_zigzag::ZigZagArray) -> usize
-
-pub fn vortex_zigzag::ZigZagVTable::nchildren(_array: &vortex_zigzag::ZigZagArray) -> usize
-
-pub fn vortex_zigzag::ZigZagVTable::visit_buffers(_array: &vortex_zigzag::ZigZagArray, _visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
-
-pub fn vortex_zigzag::ZigZagVTable::visit_children(array: &vortex_zigzag::ZigZagArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
-
-pub fn vortex_zigzag::zigzag_decode(parray: vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_array::arrays::primitive::array::PrimitiveArray
-
-pub fn vortex_zigzag::zigzag_encode(parray: vortex_array::arrays::primitive::array::PrimitiveArray) -> vortex_error::VortexResult<vortex_zigzag::ZigZagArray>
+pub type vortex_zigzag::ZigZagArray = vortex_array::array::typed::Array<vortex_zigzag::ZigZag>
diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs
index 03241396010..34b1d2d19f6 100644
--- a/encodings/zigzag/src/array.rs
+++ b/encodings/zigzag/src/array.rs
@@ -1,38 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::hash::Hash;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
 
 use vortex_array::Array;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
-use vortex_array::EmptyMetadata;
+use vortex_array::ArrayView;
 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;
 use vortex_array::dtype::PType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
-use vortex_array::vtable::VisitorVTable;
 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 zigzag::ZigZag as ExternalZigZag;
 
@@ -41,47 +40,76 @@ use crate::kernel::PARENT_KERNELS;
 use crate::rules::RULES;
 use crate::zigzag_decode;
 
-vtable!(ZigZag);
+/// A [`ZigZag`]-encoded Vortex array.
+pub type ZigZagArray = Array<ZigZag>;
 
-impl VTable for ZigZagVTable {
-    type Array = ZigZagArray;
+impl VTable for ZigZag {
+    type ArrayData = ZigZagData;
 
-    type Metadata = EmptyMetadata;
-
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &ZigZagArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        _data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let encoded = slots[ENCODED_SLOT]
+            .as_ref()
+            .vortex_expect("ZigZagArray encoded slot");
+        let expected_dtype = ZigZagData::dtype_from_encoded_dtype(encoded.dtype())?;
+        vortex_ensure!(
+            dtype == &expected_dtype,
+            "expected dtype {expected_dtype}, got {dtype}"
+        );
+        vortex_ensure!(
+            encoded.len() == len,
+            "expected len {len}, got {}",
+            encoded.len()
+        );
+        Ok(())
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ZigZagArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("ZigZagArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ZigZagArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "ZigZagArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         if children.len() != 1 {
             vortex_bail!("Expected 1 child, got {}", children.len());
         }
@@ -90,25 +118,23 @@ impl VTable for ZigZagVTable {
         let encoded_type = DType::Primitive(ptype.to_unsigned(), dtype.nullability());
 
         let encoded = children.get(0, &encoded_type, len)?;
-        ZigZagArray::try_new(encoded)
+        let slots = vec![Some(encoded.clone())];
+        let data = ZigZagData::try_new(encoded.dtype())?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1,
-            "ZigZagArray expects exactly 1 child (encoded), got {}",
-            children.len()
-        );
-        array.encoded = children.into_iter().next().vortex_expect("checked");
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(zigzag_decode(array.encoded().clone().execute(ctx)?).into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            zigzag_decode(array.encoded().clone().execute(ctx)?).into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -116,7 +142,7 @@ impl VTable for ZigZagVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -125,78 +151,100 @@ impl VTable for ZigZagVTable {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct ZigZagArray {
-    dtype: DType,
-    encoded: ArrayRef,
-    stats_set: ArrayStats,
+impl ArrayHash for ZigZagData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
 }
 
-#[derive(Debug)]
-pub struct ZigZagVTable;
-
-impl ZigZagVTable {
-    pub const ID: ArrayId = ArrayId::new_ref("vortex.zigzag");
-}
-
-impl ZigZagArray {
-    pub fn new(encoded: ArrayRef) -> Self {
-        Self::try_new(encoded).vortex_expect("ZigZagArray new")
+impl ArrayEq for ZigZagData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
     }
+}
 
-    pub fn try_new(encoded: ArrayRef) -> VortexResult<Self> {
-        let encoded_dtype = encoded.dtype().clone();
-        if !encoded_dtype.is_unsigned_int() {
-            vortex_bail!(MismatchedTypes: "unsigned int", encoded_dtype);
-        }
+/// The zigzag-encoded values (signed integers mapped to unsigned).
+pub(super) const ENCODED_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["encoded"];
 
-        let dtype = DType::from(PType::try_from(&encoded_dtype)?.to_signed())
-            .with_nullability(encoded_dtype.nullability());
+#[derive(Clone, Debug)]
+pub struct ZigZagData {}
 
-        Ok(Self {
-            dtype,
-            encoded,
-            stats_set: Default::default(),
-        })
+impl Display for ZigZagData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
     }
+}
 
-    pub fn ptype(&self) -> PType {
-        self.dtype().as_ptype()
+pub trait ZigZagArrayExt: TypedArrayRef<ZigZag> {
+    fn encoded(&self) -> &ArrayRef {
+        self.as_ref().slots()[ENCODED_SLOT]
+            .as_ref()
+            .vortex_expect("ZigZagArray encoded slot")
     }
 
-    pub fn encoded(&self) -> &ArrayRef {
-        &self.encoded
+    fn ptype(&self) -> PType {
+        PType::try_from(self.encoded().dtype())
+            .vortex_expect("ZigZagArray encoded dtype")
+            .to_signed()
     }
 }
 
-impl BaseArrayVTable<ZigZagVTable> for ZigZagVTable {
-    fn len(array: &ZigZagArray) -> usize {
-        array.encoded.len()
+impl<T: TypedArrayRef<ZigZag>> ZigZagArrayExt for T {}
+
+#[derive(Clone, Debug)]
+pub struct ZigZag;
+
+impl ZigZag {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.zigzag");
+
+    /// Construct a new [`ZigZagArray`] from an encoded unsigned integer array.
+    pub fn try_new(encoded: ArrayRef) -> VortexResult<ZigZagArray> {
+        let dtype = ZigZagData::dtype_from_encoded_dtype(encoded.dtype())?;
+        let len = encoded.len();
+        let slots = vec![Some(encoded.clone())];
+        let data = ZigZagData::try_new(encoded.dtype())?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(ZigZag, dtype, len, data).with_slots(slots))
+        })
     }
+}
 
-    fn dtype(array: &ZigZagArray) -> &DType {
-        &array.dtype
+impl ZigZagData {
+    fn dtype_from_encoded_dtype(encoded_dtype: &DType) -> VortexResult<DType> {
+        Ok(DType::from(PType::try_from(encoded_dtype)?.to_signed())
+            .with_nullability(encoded_dtype.nullability()))
     }
 
-    fn stats(array: &ZigZagArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
+    pub fn new() -> Self {
+        Self {}
     }
 
-    fn array_hash<H: std::hash::Hasher>(array: &ZigZagArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.encoded.array_hash(state, precision);
+    pub fn try_new(encoded_dtype: &DType) -> VortexResult<Self> {
+        if !encoded_dtype.is_unsigned_int() {
+            vortex_bail!(MismatchedTypes: "unsigned int", encoded_dtype);
+        }
+
+        Self::dtype_from_encoded_dtype(encoded_dtype)?;
+
+        Ok(Self {})
     }
+}
 
-    fn array_eq(array: &ZigZagArray, other: &ZigZagArray, precision: Precision) -> bool {
-        array.dtype == other.dtype && array.encoded.array_eq(&other.encoded, precision)
+impl Default for ZigZagData {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
-impl OperationsVTable<ZigZagVTable> for ZigZagVTable {
-    fn scalar_at(array: &ZigZagArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ZigZag> for ZigZag {
+    fn scalar_at(
+        array: ArrayView<'_, ZigZag>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let scalar = array.encoded().scalar_at(index)?;
         if scalar.is_null() {
-            return scalar.primitive_reinterpret_cast(array.ptype());
+            return scalar.primitive_reinterpret_cast(ZigZagArrayExt::ptype(&array));
         }
 
         let pscalar = scalar.as_primitive();
@@ -213,25 +261,9 @@ impl OperationsVTable<ZigZagVTable> for ZigZagVTable {
     }
 }
 
-impl ValidityChild<ZigZagVTable> for ZigZagVTable {
-    fn validity_child(array: &ZigZagArray) -> &ArrayRef {
-        array.encoded()
-    }
-}
-
-impl VisitorVTable<ZigZagVTable> for ZigZagVTable {
-    fn visit_buffers(_array: &ZigZagArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &ZigZagArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ZigZagArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("encoded", array.encoded())
-    }
-
-    fn nchildren(_array: &ZigZagArray) -> usize {
-        1
+impl ValidityChild<ZigZag> for ZigZag {
+    fn validity_child(array: ArrayView<'_, ZigZag>) -> ArrayRef {
+        array.encoded().clone()
     }
 }
 
@@ -266,9 +298,9 @@ mod test {
         );
 
         let sliced = zigzag.slice(0..2).unwrap();
-        let sliced = sliced.as_::<ZigZagVTable>();
+        let sliced = sliced.as_::<ZigZag>();
         assert_eq!(
-            sliced.scalar_at(sliced.len() - 1).unwrap(),
+            sliced.array().scalar_at(sliced.len() - 1).unwrap(),
             Scalar::from(-5i32)
         );
 
diff --git a/encodings/zigzag/src/compress.rs b/encodings/zigzag/src/compress.rs
index a7f40255efb..998a39f2b49 100644
--- a/encodings/zigzag/src/compress.rs
+++ b/encodings/zigzag/src/compress.rs
@@ -1,21 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::IntoArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
 use zigzag::ZigZag as ExternalZigZag;
 
+use crate::ZigZag;
 use crate::ZigZagArray;
-
 pub fn zigzag_encode(parray: PrimitiveArray) -> VortexResult<ZigZagArray> {
-    let validity = parray.validity().clone();
+    let validity = parray.validity()?;
     let encoded = match parray.ptype() {
         PType::I8 => zigzag_encode_primitive::<i8>(parray.into_buffer_mut(), validity),
         PType::I16 => zigzag_encode_primitive::<i16>(parray.into_buffer_mut(), validity),
@@ -26,7 +27,7 @@ pub fn zigzag_encode(parray: PrimitiveArray) -> VortexResult<ZigZagArray> {
             parray.ptype()
         ),
     };
-    ZigZagArray::try_new(encoded.to_array())
+    ZigZag::try_new(encoded.into_array())
 }
 
 fn zigzag_encode_primitive<T: ExternalZigZag + NativePType>(
@@ -43,7 +44,9 @@ where
 }
 
 pub fn zigzag_decode(parray: PrimitiveArray) -> PrimitiveArray {
-    let validity = parray.validity().clone();
+    let validity = parray
+        .validity()
+        .vortex_expect("zigzag validity should be derivable");
     match parray.ptype() {
         PType::U8 => zigzag_decode_primitive::<i8>(parray.into_buffer_mut(), validity),
         PType::U16 => zigzag_decode_primitive::<i16>(parray.into_buffer_mut(), validity),
@@ -71,16 +74,19 @@ where
 
 #[cfg(test)]
 mod test {
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::assert_arrays_eq;
 
     use super::*;
-    use crate::ZigZagVTable;
+    use crate::ZigZag;
 
     #[test]
     fn test_compress_i8() {
-        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i8..100)).unwrap();
-        assert!(compressed.is::<ZigZagVTable>());
+        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i8..100))
+            .unwrap()
+            .into_array();
+        assert!(compressed.is::<ZigZag>());
         assert_arrays_eq!(
             compressed.to_primitive(),
             PrimitiveArray::from_iter(-100_i8..100)
@@ -88,8 +94,10 @@ mod test {
     }
     #[test]
     fn test_compress_i16() {
-        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i16..100)).unwrap();
-        assert!(compressed.is::<ZigZagVTable>());
+        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i16..100))
+            .unwrap()
+            .into_array();
+        assert!(compressed.is::<ZigZag>());
         assert_arrays_eq!(
             compressed.to_primitive(),
             PrimitiveArray::from_iter(-100_i16..100)
@@ -97,8 +105,10 @@ mod test {
     }
     #[test]
     fn test_compress_i32() {
-        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i32..100)).unwrap();
-        assert!(compressed.is::<ZigZagVTable>());
+        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i32..100))
+            .unwrap()
+            .into_array();
+        assert!(compressed.is::<ZigZag>());
         assert_arrays_eq!(
             compressed.to_primitive(),
             PrimitiveArray::from_iter(-100_i32..100)
@@ -106,8 +116,10 @@ mod test {
     }
     #[test]
     fn test_compress_i64() {
-        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i64..100)).unwrap();
-        assert!(compressed.is::<ZigZagVTable>());
+        let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i64..100))
+            .unwrap()
+            .into_array();
+        assert!(compressed.is::<ZigZag>());
         assert_arrays_eq!(
             compressed.to_primitive(),
             PrimitiveArray::from_iter(-100_i64..100)
diff --git a/encodings/zigzag/src/compute/cast.rs b/encodings/zigzag/src/compute/cast.rs
index 293f19b1559..7f6741d9aa1 100644
--- a/encodings/zigzag/src/compute/cast.rs
+++ b/encodings/zigzag/src/compute/cast.rs
@@ -2,17 +2,17 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
 use vortex_error::VortexResult;
 
-use crate::ZigZagArray;
-use crate::ZigZagVTable;
-
-impl CastReduce for ZigZagVTable {
-    fn cast(array: &ZigZagArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::ZigZag;
+use crate::array::ZigZagArrayExt;
+impl CastReduce for ZigZag {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !dtype.is_signed_int() {
             return Ok(None);
         }
@@ -20,14 +20,14 @@ impl CastReduce for ZigZagVTable {
         let new_encoded_dtype =
             DType::Primitive(dtype.as_ptype().to_unsigned(), dtype.nullability());
         let new_encoded = array.encoded().cast(new_encoded_dtype)?;
-        Ok(Some(ZigZagArray::try_new(new_encoded)?.into_array()))
+        Ok(Some(ZigZag::try_new(new_encoded)?.into_array()))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
@@ -45,7 +45,7 @@ mod tests {
         let zigzag = zigzag_encode(values).unwrap();
 
         let casted = zigzag
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -71,7 +71,7 @@ mod tests {
         let zigzag = zigzag_encode(values).unwrap();
 
         let casted = zigzag
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I16, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -90,7 +90,7 @@ mod tests {
         let zigzag16 = zigzag_encode(values16).unwrap();
 
         let casted64 = zigzag16
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -112,7 +112,7 @@ mod tests {
         let zigzag = zigzag_encode(values).unwrap();
 
         let casted = zigzag
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -127,6 +127,6 @@ mod tests {
     #[case(zigzag_encode(PrimitiveArray::from_option_iter([Some(-5i16), None, Some(0), Some(5), None])).unwrap())]
     #[case(zigzag_encode(PrimitiveArray::from_iter([i32::MIN, -1, 0, 1, i32::MAX])).unwrap())]
     fn test_cast_zigzag_conformance(#[case] array: ZigZagArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/encodings/zigzag/src/compute/mod.rs b/encodings/zigzag/src/compute/mod.rs
index df586320368..71938dbcc18 100644
--- a/encodings/zigzag/src/compute/mod.rs
+++ b/encodings/zigzag/src/compute/mod.rs
@@ -3,48 +3,48 @@
 
 mod cast;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::FilterReduce;
-use vortex_array::arrays::ScalarFnArrayExt;
-use vortex_array::arrays::TakeExecute;
+use vortex_array::arrays::dict::TakeExecute;
+use vortex_array::arrays::filter::FilterReduce;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
 use vortex_array::scalar_fn::EmptyOptions;
 use vortex_array::scalar_fn::fns::mask::Mask as MaskExpr;
 use vortex_array::scalar_fn::fns::mask::MaskReduce;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::ZigZagArray;
-use crate::ZigZagVTable;
+use crate::ZigZag;
+use crate::array::ZigZagArrayExt;
 
-impl FilterReduce for ZigZagVTable {
-    fn filter(array: &ZigZagArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for ZigZag {
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         let encoded = array.encoded().filter(mask.clone())?;
-        Ok(Some(ZigZagArray::try_new(encoded)?.into_array()))
+        Ok(Some(ZigZag::try_new(encoded)?.into_array()))
     }
 }
 
-impl TakeExecute for ZigZagVTable {
+impl TakeExecute for ZigZag {
     fn take(
-        array: &ZigZagArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let encoded = array.encoded().take(indices.to_array())?;
-        Ok(Some(ZigZagArray::try_new(encoded)?.into_array()))
+        let encoded = array.encoded().take(indices.clone())?;
+        Ok(Some(ZigZag::try_new(encoded)?.into_array()))
     }
 }
 
-impl MaskReduce for ZigZagVTable {
-    fn mask(array: &ZigZagArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for ZigZag {
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_encoded = MaskExpr.try_new_array(
             array.encoded().len(),
             EmptyOptions,
             [array.encoded().clone(), mask.clone()],
         )?;
-        Ok(Some(ZigZagArray::try_new(masked_encoded)?.into_array()))
+        Ok(Some(ZigZag::try_new(masked_encoded)?.into_array()))
     }
 }
 
@@ -71,7 +71,6 @@ impl ZigZagEncoded for u64 {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
@@ -110,8 +109,9 @@ mod tests {
         ))?;
 
         let indices = buffer![0, 2].into_array();
-        let actual = zigzag.take(indices.to_array()).unwrap();
-        let expected = zigzag_encode(PrimitiveArray::new(buffer![-189, 1], Validity::AllValid))?;
+        let actual = zigzag.take(indices).unwrap();
+        let expected =
+            zigzag_encode(PrimitiveArray::new(buffer![-189, 1], Validity::AllValid))?.into_array();
         assert_arrays_eq!(actual, expected);
         Ok(())
     }
@@ -140,20 +140,20 @@ mod tests {
             buffer![-189i32, -160, 1, 42, -73],
             Validity::AllValid,
         ))?;
-        test_filter_conformance(zigzag.as_ref());
+        test_filter_conformance(&zigzag.into_array());
 
         // Test with i64 values
         let zigzag = zigzag_encode(PrimitiveArray::new(
             buffer![1000i64, -2000, 3000, -4000, 5000],
             Validity::AllValid,
         ))?;
-        test_filter_conformance(zigzag.as_ref());
+        test_filter_conformance(&zigzag.into_array());
 
         // Test with nullable values
         let array =
             PrimitiveArray::from_option_iter([Some(-10i16), None, Some(20), Some(-30), None]);
         let zigzag = zigzag_encode(array)?;
-        test_filter_conformance(zigzag.as_ref());
+        test_filter_conformance(&zigzag.into_array());
         Ok(())
     }
 
@@ -166,14 +166,14 @@ mod tests {
             buffer![-100i32, 200, -300, 400, -500],
             Validity::AllValid,
         ))?;
-        test_mask_conformance(zigzag.as_ref());
+        test_mask_conformance(&zigzag.into_array());
 
         // Test with i8 values
         let zigzag = zigzag_encode(PrimitiveArray::new(
             buffer![-127i8, 0, 127, -1, 1],
             Validity::AllValid,
         ))?;
-        test_mask_conformance(zigzag.as_ref());
+        test_mask_conformance(&zigzag.into_array());
         Ok(())
     }
 
@@ -187,47 +187,35 @@ mod tests {
         use vortex_array::compute::conformance::take::test_take_conformance;
 
         let zigzag = zigzag_encode(array.to_primitive())?;
-        test_take_conformance(zigzag.as_ref());
+        test_take_conformance(&zigzag.into_array());
         Ok(())
     }
 
     #[rstest]
     // Basic ZigZag arrays
     #[case::zigzag_i8(zigzag_encode(PrimitiveArray::from_iter([-128i8, -1, 0, 1, 127])).unwrap())]
-    #[case::zigzag_i16(zigzag_encode(PrimitiveArray::from_iter([-1000i16, -100, 0, 100, 1000])).unwrap()
-    )]
-    #[case::zigzag_i32(zigzag_encode(PrimitiveArray::from_iter([-100000i32, -1000, 0, 1000, 100000])).unwrap()
-    )]
-    #[case::zigzag_i64(zigzag_encode(PrimitiveArray::from_iter([-1000000i64, -10000, 0, 10000, 1000000])).unwrap()
-    )]
+    #[case::zigzag_i16(zigzag_encode(PrimitiveArray::from_iter([-1000i16, -100, 0, 100, 1000])).unwrap())]
+    #[case::zigzag_i32(zigzag_encode(PrimitiveArray::from_iter([-100000i32, -1000, 0, 1000, 100000])).unwrap())]
+    #[case::zigzag_i64(zigzag_encode(PrimitiveArray::from_iter([-1000000i64, -10000, 0, 10000, 1000000])).unwrap())]
     // Nullable arrays
-    #[case::zigzag_nullable_i32(zigzag_encode(PrimitiveArray::from_option_iter([Some(-100i32), None, Some(0), Some(100), None])).unwrap()
-    )]
-    #[case::zigzag_nullable_i64(zigzag_encode(PrimitiveArray::from_option_iter([Some(-1000i64), None, Some(0), Some(1000), None])).unwrap()
-    )]
+    #[case::zigzag_nullable_i32(zigzag_encode(PrimitiveArray::from_option_iter([Some(-100i32), None, Some(0), Some(100), None])).unwrap())]
+    #[case::zigzag_nullable_i64(zigzag_encode(PrimitiveArray::from_option_iter([Some(-1000i64), None, Some(0), Some(1000), None])).unwrap())]
     // Edge cases
     #[case::zigzag_single(zigzag_encode(PrimitiveArray::from_iter([-42i32])).unwrap())]
-    #[case::zigzag_alternating(zigzag_encode(PrimitiveArray::from_iter([-1i32, 1, -2, 2, -3, 3])).unwrap()
-    )]
+    #[case::zigzag_alternating(zigzag_encode(PrimitiveArray::from_iter([-1i32, 1, -2, 2, -3, 3])).unwrap())]
     // Large arrays
     #[case::zigzag_large_i32(zigzag_encode(PrimitiveArray::from_iter(-500..500)).unwrap())]
-    #[case::zigzag_large_i64(zigzag_encode(PrimitiveArray::from_iter((-1000..1000).map(|i| i as i64 * 100))).unwrap()
-    )]
+    #[case::zigzag_large_i64(zigzag_encode(PrimitiveArray::from_iter((-1000..1000).map(|i| i as i64 * 100))).unwrap())]
     fn test_zigzag_consistency(#[case] array: ZigZagArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
-    #[case::zigzag_i8_basic(zigzag_encode(PrimitiveArray::from_iter([-10i8, -5, 0, 5, 10])).unwrap()
-    )]
-    #[case::zigzag_i16_basic(zigzag_encode(PrimitiveArray::from_iter([-100i16, -50, 0, 50, 100])).unwrap()
-    )]
-    #[case::zigzag_i32_basic(zigzag_encode(PrimitiveArray::from_iter([-1000i32, -500, 0, 500, 1000])).unwrap()
-    )]
-    #[case::zigzag_i64_basic(zigzag_encode(PrimitiveArray::from_iter([-10000i64, -5000, 0, 5000, 10000])).unwrap()
-    )]
-    #[case::zigzag_i32_large(zigzag_encode(PrimitiveArray::from_iter((-50..50).map(|i| i * 10))).unwrap()
-    )]
+    #[case::zigzag_i8_basic(zigzag_encode(PrimitiveArray::from_iter([-10i8, -5, 0, 5, 10])).unwrap())]
+    #[case::zigzag_i16_basic(zigzag_encode(PrimitiveArray::from_iter([-100i16, -50, 0, 50, 100])).unwrap())]
+    #[case::zigzag_i32_basic(zigzag_encode(PrimitiveArray::from_iter([-1000i32, -500, 0, 500, 1000])).unwrap())]
+    #[case::zigzag_i64_basic(zigzag_encode(PrimitiveArray::from_iter([-10000i64, -5000, 0, 5000, 10000])).unwrap())]
+    #[case::zigzag_i32_large(zigzag_encode(PrimitiveArray::from_iter((-50..50).map(|i| i * 10))).unwrap())]
     fn test_zigzag_binary_numeric(#[case] array: ZigZagArray) {
         test_binary_numeric_array(array.into_array());
     }
diff --git a/encodings/zigzag/src/kernel.rs b/encodings/zigzag/src/kernel.rs
index 6b93005d0f2..d0096abaae1 100644
--- a/encodings/zigzag/src/kernel.rs
+++ b/encodings/zigzag/src/kernel.rs
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::TakeExecuteAdaptor;
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 
-use crate::ZigZagVTable;
+use crate::ZigZag;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<ZigZagVTable> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ZigZagVTable))]);
+pub(crate) const PARENT_KERNELS: ParentKernelSet<ZigZag> =
+    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ZigZag))]);
diff --git a/encodings/zigzag/src/rules.rs b/encodings/zigzag/src/rules.rs
index 3809c7b578e..c3b612d101d 100644
--- a/encodings/zigzag/src/rules.rs
+++ b/encodings/zigzag/src/rules.rs
@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::FilterReduceAdaptor;
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::filter::FilterReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 use vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-use crate::ZigZagVTable;
+use crate::ZigZag;
 
-pub(crate) static RULES: ParentRuleSet<ZigZagVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ZigZagVTable)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(ZigZagVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ZigZagVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ZigZagVTable)),
+pub(crate) static RULES: ParentRuleSet<ZigZag> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(ZigZag)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(ZigZag)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ZigZag)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(ZigZag)),
 ]);
diff --git a/encodings/zigzag/src/slice.rs b/encodings/zigzag/src/slice.rs
index 5ffbd408c2c..6a7128d5111 100644
--- a/encodings/zigzag/src/slice.rs
+++ b/encodings/zigzag/src/slice.rs
@@ -4,17 +4,18 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
 use vortex_error::VortexResult;
 
-use crate::ZigZagArray;
-use crate::ZigZagVTable;
+use crate::ZigZag;
+use crate::array::ZigZagArrayExt;
 
-impl SliceReduce for ZigZagVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for ZigZag {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            ZigZagArray::new(array.encoded().slice(range)?).into_array(),
+            ZigZag::try_new(array.encoded().slice(range)?)?.into_array(),
         ))
     }
 }
diff --git a/encodings/zstd/benches/listview_rebuild.rs b/encodings/zstd/benches/listview_rebuild.rs
index a15012e02ef..82b16c392fa 100644
--- a/encodings/zstd/benches/listview_rebuild.rs
+++ b/encodings/zstd/benches/listview_rebuild.rs
@@ -6,17 +6,26 @@
 use divan::Bencher;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ListViewArray;
-use vortex_array::arrays::ListViewRebuildMode;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::listview::ListViewRebuildMode;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
-use vortex_zstd::ZstdArray;
+use vortex_zstd::Zstd;
+use vortex_zstd::ZstdData;
 
 #[divan::bench(sample_size = 1000)]
 fn rebuild_naive(bencher: Bencher) {
     let dudes = VarBinViewArray::from_iter_str(["Washington", "Adams", "Jefferson", "Madison"])
         .into_array();
-    let dudes = ZstdArray::from_array(dudes, 9, 1024).unwrap().into_array();
+    let dtype = dudes.dtype().clone();
+    let validity = dudes.validity().unwrap();
+    let dudes = Zstd::try_new(
+        dtype,
+        ZstdData::from_array(dudes, 9, 1024).unwrap(),
+        validity,
+    )
+    .unwrap()
+    .into_array();
 
     let offsets = std::iter::repeat_n(0u32, 1024)
         .collect::<Buffer<u32>>()
diff --git a/encodings/zstd/public-api.lock b/encodings/zstd/public-api.lock
index 6720df1c9fd..44365606591 100644
--- a/encodings/zstd/public-api.lock
+++ b/encodings/zstd/public-api.lock
@@ -1,78 +1,72 @@
 pub mod vortex_zstd
 
-pub struct vortex_zstd::ZstdArray
+pub struct vortex_zstd::Zstd
 
-impl vortex_zstd::ZstdArray
+impl vortex_zstd::Zstd
 
-pub fn vortex_zstd::ZstdArray::decompress(&self) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub const vortex_zstd::Zstd::ID: vortex_array::array::ArrayId
 
-pub fn vortex_zstd::ZstdArray::from_array(array: vortex_array::array::ArrayRef, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_zstd::Zstd::decompress(array: &vortex_zstd::ZstdArray, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_zstd::ZstdArray::from_canonical(canonical: &vortex_array::canonical::Canonical, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_zstd::Zstd::from_primitive(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<vortex_zstd::ZstdArray>
 
-pub fn vortex_zstd::ZstdArray::from_primitive(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_zstd::Zstd::from_var_bin_view(vbv: &vortex_array::arrays::varbinview::vtable::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<vortex_zstd::ZstdArray>
 
-pub fn vortex_zstd::ZstdArray::from_primitive_without_dict(parray: &vortex_array::arrays::primitive::array::PrimitiveArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_zstd::Zstd::from_var_bin_view_without_dict(vbv: &vortex_array::arrays::varbinview::vtable::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<vortex_zstd::ZstdArray>
 
-pub fn vortex_zstd::ZstdArray::from_var_bin_view(vbv: &vortex_array::arrays::varbinview::array::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_zstd::Zstd::try_new(dtype: vortex_array::dtype::DType, data: vortex_zstd::ZstdData, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<vortex_zstd::ZstdArray>
 
-pub fn vortex_zstd::ZstdArray::from_var_bin_view_without_dict(vbv: &vortex_array::arrays::varbinview::array::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_zstd::Zstd
 
-pub fn vortex_zstd::ZstdArray::into_parts(self) -> vortex_zstd::ZstdArrayParts
+pub fn vortex_zstd::Zstd::clone(&self) -> vortex_zstd::Zstd
 
-pub fn vortex_zstd::ZstdArray::new(dictionary: core::option::Option<vortex_buffer::ByteBuffer>, frames: alloc::vec::Vec<vortex_buffer::ByteBuffer>, dtype: vortex_array::dtype::DType, metadata: vortex_zstd::ZstdMetadata, n_rows: usize, validity: vortex_array::validity::Validity) -> Self
+impl core::fmt::Debug for vortex_zstd::Zstd
 
-impl core::clone::Clone for vortex_zstd::ZstdArray
+pub fn vortex_zstd::Zstd::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zstd::ZstdArray::clone(&self) -> vortex_zstd::ZstdArray
+impl vortex_array::array::vtable::VTable for vortex_zstd::Zstd
 
-impl core::convert::AsRef<dyn vortex_array::array::Array> for vortex_zstd::ZstdArray
+pub type vortex_zstd::Zstd::ArrayData = vortex_zstd::ZstdData
 
-pub fn vortex_zstd::ZstdArray::as_ref(&self) -> &dyn vortex_array::array::Array
+pub type vortex_zstd::Zstd::OperationsVTable = vortex_zstd::Zstd
 
-impl core::convert::From<vortex_zstd::ZstdArray> for vortex_array::array::ArrayRef
+pub type vortex_zstd::Zstd::ValidityVTable = vortex_zstd::Zstd
 
-pub fn vortex_array::array::ArrayRef::from(value: vortex_zstd::ZstdArray) -> vortex_array::array::ArrayRef
+pub fn vortex_zstd::Zstd::buffer(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::fmt::Debug for vortex_zstd::ZstdArray
+pub fn vortex_zstd::Zstd::buffer_name(array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_zstd::ZstdArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_zstd::Zstd::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
 
-impl core::ops::deref::Deref for vortex_zstd::ZstdArray
+pub fn vortex_zstd::Zstd::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
-pub type vortex_zstd::ZstdArray::Target = dyn vortex_array::array::Array
+pub fn vortex_zstd::Zstd::id(&self) -> vortex_array::array::ArrayId
 
-pub fn vortex_zstd::ZstdArray::deref(&self) -> &Self::Target
+pub fn vortex_zstd::Zstd::nbuffers(array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::array::IntoArray for vortex_zstd::ZstdArray
+pub fn vortex_zstd::Zstd::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub fn vortex_zstd::ZstdArray::into_array(self) -> vortex_array::array::ArrayRef
+pub fn vortex_zstd::Zstd::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::validity::ValiditySliceHelper for vortex_zstd::ZstdArray
+pub fn vortex_zstd::Zstd::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_zstd::ZstdArray::unsliced_validity_and_slice(&self) -> (&vortex_array::validity::Validity, usize, usize)
+pub fn vortex_zstd::Zstd::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_zstd::ZstdArrayParts
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_zstd::Zstd> for vortex_zstd::Zstd
 
-pub vortex_zstd::ZstdArrayParts::dictionary: core::option::Option<vortex_buffer::ByteBuffer>
+pub fn vortex_zstd::Zstd::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_zstd::Zstd>, index: usize, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_zstd::ZstdArrayParts::dtype: vortex_array::dtype::DType
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_zstd::Zstd> for vortex_zstd::Zstd
 
-pub vortex_zstd::ZstdArrayParts::frames: alloc::vec::Vec<vortex_buffer::ByteBuffer>
+pub fn vortex_zstd::Zstd::validity(array: vortex_array::array::view::ArrayView<'_, vortex_zstd::Zstd>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_zstd::ZstdArrayParts::metadata: vortex_zstd::ZstdMetadata
+impl vortex_array::arrays::slice::SliceReduce for vortex_zstd::Zstd
 
-pub vortex_zstd::ZstdArrayParts::n_rows: usize
+pub fn vortex_zstd::Zstd::slice(array: vortex_array::array::view::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub vortex_zstd::ZstdArrayParts::slice_start: usize
+impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_zstd::Zstd
 
-pub vortex_zstd::ZstdArrayParts::slice_stop: usize
-
-pub vortex_zstd::ZstdArrayParts::validity: vortex_array::validity::Validity
-
-impl core::fmt::Debug for vortex_zstd::ZstdArrayParts
-
-pub fn vortex_zstd::ZstdArrayParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_zstd::Zstd::cast(array: vortex_array::array::view::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
 pub struct vortex_zstd::ZstdBuffersMetadata
 
@@ -102,126 +96,116 @@ pub fn vortex_zstd::ZstdBuffersMetadata::clear(&mut self)
 
 pub fn vortex_zstd::ZstdBuffersMetadata::encoded_len(&self) -> usize
 
-pub struct vortex_zstd::ZstdFrameMetadata
-
-pub vortex_zstd::ZstdFrameMetadata::n_values: u64
-
-pub vortex_zstd::ZstdFrameMetadata::uncompressed_size: u64
-
-impl core::clone::Clone for vortex_zstd::ZstdFrameMetadata
-
-pub fn vortex_zstd::ZstdFrameMetadata::clone(&self) -> vortex_zstd::ZstdFrameMetadata
-
-impl core::default::Default for vortex_zstd::ZstdFrameMetadata
+pub struct vortex_zstd::ZstdData
 
-pub fn vortex_zstd::ZstdFrameMetadata::default() -> Self
+impl vortex_zstd::ZstdData
 
-impl core::fmt::Debug for vortex_zstd::ZstdFrameMetadata
+pub fn vortex_zstd::ZstdData::from_array(array: vortex_array::array::erased::ArrayRef, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_zstd::ZstdFrameMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_zstd::ZstdData::from_canonical(canonical: &vortex_array::canonical::Canonical, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<core::option::Option<Self>>
 
-impl prost::message::Message for vortex_zstd::ZstdFrameMetadata
+pub fn vortex_zstd::ZstdData::from_primitive(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_zstd::ZstdFrameMetadata::clear(&mut self)
+pub fn vortex_zstd::ZstdData::from_primitive_without_dict(parray: &vortex_array::arrays::primitive::vtable::PrimitiveArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_zstd::ZstdFrameMetadata::encoded_len(&self) -> usize
+pub fn vortex_zstd::ZstdData::from_var_bin_view(vbv: &vortex_array::arrays::varbinview::vtable::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
 
-pub struct vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::from_var_bin_view_without_dict(vbv: &vortex_array::arrays::varbinview::vtable::VarBinViewArray, level: i32, values_per_frame: usize) -> vortex_error::VortexResult<Self>
 
-pub vortex_zstd::ZstdMetadata::dictionary_size: u32
+pub fn vortex_zstd::ZstdData::into_parts(self, validity: vortex_array::validity::Validity) -> vortex_zstd::ZstdDataParts
 
-pub vortex_zstd::ZstdMetadata::frames: alloc::vec::Vec<vortex_zstd::ZstdFrameMetadata>
+pub fn vortex_zstd::ZstdData::is_empty(&self) -> bool
 
-impl core::clone::Clone for vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::len(&self) -> usize
 
-pub fn vortex_zstd::ZstdMetadata::clone(&self) -> vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::new(dictionary: core::option::Option<vortex_buffer::ByteBuffer>, frames: alloc::vec::Vec<vortex_buffer::ByteBuffer>, metadata: vortex_zstd::ZstdMetadata, n_rows: usize) -> Self
 
-impl core::default::Default for vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::validate(&self, dtype: &vortex_array::dtype::DType, len: usize, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub fn vortex_zstd::ZstdMetadata::default() -> Self
+impl core::clone::Clone for vortex_zstd::ZstdData
 
-impl core::fmt::Debug for vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::clone(&self) -> vortex_zstd::ZstdData
 
-pub fn vortex_zstd::ZstdMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Debug for vortex_zstd::ZstdData
 
-impl prost::message::Message for vortex_zstd::ZstdMetadata
+pub fn vortex_zstd::ZstdData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zstd::ZstdMetadata::clear(&mut self)
+impl core::fmt::Display for vortex_zstd::ZstdData
 
-pub fn vortex_zstd::ZstdMetadata::encoded_len(&self) -> usize
+pub fn vortex_zstd::ZstdData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_zstd::ZstdVTable
+impl vortex_array::hash::ArrayEq for vortex_zstd::ZstdData
 
-impl vortex_zstd::ZstdVTable
+pub fn vortex_zstd::ZstdData::array_eq(&self, other: &Self, precision: vortex_array::hash::Precision) -> bool
 
-pub const vortex_zstd::ZstdVTable::ID: vortex_array::vtable::dyn_::ArrayId
+impl vortex_array::hash::ArrayHash for vortex_zstd::ZstdData
 
-impl core::fmt::Debug for vortex_zstd::ZstdVTable
+pub fn vortex_zstd::ZstdData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::hash::Precision)
 
-pub fn vortex_zstd::ZstdVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_zstd::ZstdDataParts
 
-impl vortex_array::arrays::slice::SliceReduce for vortex_zstd::ZstdVTable
+pub vortex_zstd::ZstdDataParts::dictionary: core::option::Option<vortex_buffer::ByteBuffer>
 
-pub fn vortex_zstd::ZstdVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_zstd::ZstdDataParts::frames: alloc::vec::Vec<vortex_buffer::ByteBuffer>
 
-impl vortex_array::scalar_fn::fns::cast::kernel::CastReduce for vortex_zstd::ZstdVTable
+pub vortex_zstd::ZstdDataParts::metadata: vortex_zstd::ZstdMetadata
 
-pub fn vortex_zstd::ZstdVTable::cast(array: &vortex_zstd::ZstdArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub vortex_zstd::ZstdDataParts::n_rows: usize
 
-impl vortex_array::vtable::VTable for vortex_zstd::ZstdVTable
+pub vortex_zstd::ZstdDataParts::slice_start: usize
 
-pub type vortex_zstd::ZstdVTable::Array = vortex_zstd::ZstdArray
+pub vortex_zstd::ZstdDataParts::slice_stop: usize
 
-pub type vortex_zstd::ZstdVTable::ArrayVTable = vortex_zstd::ZstdVTable
+pub vortex_zstd::ZstdDataParts::validity: vortex_array::validity::Validity
 
-pub type vortex_zstd::ZstdVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_zstd::ZstdMetadata>
+pub struct vortex_zstd::ZstdFrameMetadata
 
-pub type vortex_zstd::ZstdVTable::OperationsVTable = vortex_zstd::ZstdVTable
+pub vortex_zstd::ZstdFrameMetadata::n_values: u64
 
-pub type vortex_zstd::ZstdVTable::ValidityVTable = vortex_array::vtable::validity::ValidityVTableFromValiditySliceHelper
+pub vortex_zstd::ZstdFrameMetadata::uncompressed_size: u64
 
-pub type vortex_zstd::ZstdVTable::VisitorVTable = vortex_zstd::ZstdVTable
+impl core::clone::Clone for vortex_zstd::ZstdFrameMetadata
 
-pub fn vortex_zstd::ZstdVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_zstd::ZstdArray>
+pub fn vortex_zstd::ZstdFrameMetadata::clone(&self) -> vortex_zstd::ZstdFrameMetadata
 
-pub fn vortex_zstd::ZstdVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl core::default::Default for vortex_zstd::ZstdFrameMetadata
 
-pub fn vortex_zstd::ZstdVTable::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_zstd::ZstdFrameMetadata::default() -> Self
 
-pub fn vortex_zstd::ZstdVTable::id(_array: &Self::Array) -> vortex_array::vtable::dyn_::ArrayId
+impl core::fmt::Debug for vortex_zstd::ZstdFrameMetadata
 
-pub fn vortex_zstd::ZstdVTable::metadata(array: &vortex_zstd::ZstdArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_zstd::ZstdFrameMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zstd::ZstdVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+impl prost::message::Message for vortex_zstd::ZstdFrameMetadata
 
-pub fn vortex_zstd::ZstdVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_zstd::ZstdFrameMetadata::clear(&mut self)
 
-pub fn vortex_zstd::ZstdVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_zstd::ZstdFrameMetadata::encoded_len(&self) -> usize
 
-impl vortex_array::vtable::array::BaseArrayVTable<vortex_zstd::ZstdVTable> for vortex_zstd::ZstdVTable
+pub struct vortex_zstd::ZstdMetadata
 
-pub fn vortex_zstd::ZstdVTable::array_eq(array: &vortex_zstd::ZstdArray, other: &vortex_zstd::ZstdArray, precision: vortex_array::hash::Precision) -> bool
+pub vortex_zstd::ZstdMetadata::dictionary_size: u32
 
-pub fn vortex_zstd::ZstdVTable::array_hash<H: core::hash::Hasher>(array: &vortex_zstd::ZstdArray, state: &mut H, precision: vortex_array::hash::Precision)
+pub vortex_zstd::ZstdMetadata::frames: alloc::vec::Vec<vortex_zstd::ZstdFrameMetadata>
 
-pub fn vortex_zstd::ZstdVTable::dtype(array: &vortex_zstd::ZstdArray) -> &vortex_array::dtype::DType
+impl core::clone::Clone for vortex_zstd::ZstdMetadata
 
-pub fn vortex_zstd::ZstdVTable::len(array: &vortex_zstd::ZstdArray) -> usize
+pub fn vortex_zstd::ZstdMetadata::clone(&self) -> vortex_zstd::ZstdMetadata
 
-pub fn vortex_zstd::ZstdVTable::stats(array: &vortex_zstd::ZstdArray) -> vortex_array::stats::array::StatsSetRef<'_>
+impl core::default::Default for vortex_zstd::ZstdMetadata
 
-impl vortex_array::vtable::operations::OperationsVTable<vortex_zstd::ZstdVTable> for vortex_zstd::ZstdVTable
+pub fn vortex_zstd::ZstdMetadata::default() -> Self
 
-pub fn vortex_zstd::ZstdVTable::scalar_at(array: &vortex_zstd::ZstdArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl core::fmt::Debug for vortex_zstd::ZstdMetadata
 
-impl vortex_array::vtable::visitor::VisitorVTable<vortex_zstd::ZstdVTable> for vortex_zstd::ZstdVTable
+pub fn vortex_zstd::ZstdMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_zstd::ZstdVTable::nbuffers(array: &vortex_zstd::ZstdArray) -> usize
+impl prost::message::Message for vortex_zstd::ZstdMetadata
 
-pub fn vortex_zstd::ZstdVTable::nchildren(array: &vortex_zstd::ZstdArray) -> usize
+pub fn vortex_zstd::ZstdMetadata::clear(&mut self)
 
-pub fn vortex_zstd::ZstdVTable::visit_buffers(array: &vortex_zstd::ZstdArray, visitor: &mut dyn vortex_array::array::visitor::ArrayBufferVisitor)
+pub fn vortex_zstd::ZstdMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_zstd::ZstdVTable::visit_children(array: &vortex_zstd::ZstdArray, visitor: &mut dyn vortex_array::array::visitor::ArrayChildVisitor)
+pub fn vortex_zstd::reconstruct_views(buffer: &vortex_buffer::ByteBuffer, max_buffer_len: usize) -> (alloc::vec::Vec<vortex_buffer::ByteBuffer>, vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::view::BinaryView>)
 
-pub fn vortex_zstd::reconstruct_views(buffer: &vortex_buffer::ByteBuffer) -> vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::view::BinaryView>
+pub type vortex_zstd::ZstdArray = vortex_array::array::typed::Array<vortex_zstd::Zstd>
diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs
index ee49f403271..e8a3612b06d 100644
--- a/encodings/zstd/src/array.rs
+++ b/encodings/zstd/src/array.rs
@@ -2,45 +2,45 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 use std::sync::Arc;
 
 use itertools::Itertools as _;
 use prost::Message as _;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
 use vortex_array::ToCanonical;
+use vortex_array::VortexSessionExecute;
 use vortex_array::accessor::ArrayAccessor;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::build_views::BinaryView;
+use vortex_array::arrays::varbinview::build_views::BinaryView;
+use vortex_array::arrays::varbinview::build_views::MAX_BUFFER_LEN;
 use vortex_array::buffer::BufferHandle;
-use vortex_array::compute::filter;
 use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
 use vortex_array::validity::Validity;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_array::vtable::ValiditySliceHelper;
-use vortex_array::vtable::ValidityVTableFromValiditySliceHelper;
-use vortex_array::vtable::VisitorVTable;
-use vortex_array::vtable::validity_nchildren;
+use vortex_array::vtable::ValidityVTable;
+use vortex_array::vtable::child_to_validity;
+use vortex_array::vtable::validity_to_child;
 use vortex_buffer::Alignment;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
@@ -81,47 +81,117 @@ type ViewLen = u32;
 // We then insert these values to the correct position using a primitive array
 // constructor.
 
-vtable!(Zstd);
+/// A [`Zstd`]-encoded Vortex array.
+pub type ZstdArray = Array<Zstd>;
 
-impl VTable for ZstdVTable {
-    type Array = ZstdArray;
+impl ArrayHash for ZstdData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        match &self.dictionary {
+            Some(dict) => {
+                true.hash(state);
+                dict.array_hash(state, precision);
+            }
+            None => {
+                false.hash(state);
+            }
+        }
+        for frame in &self.frames {
+            frame.array_hash(state, precision);
+        }
+        self.unsliced_n_rows.hash(state);
+        self.slice_start.hash(state);
+        self.slice_stop.hash(state);
+    }
+}
+
+impl ArrayEq for ZstdData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        if !match (&self.dictionary, &other.dictionary) {
+            (Some(d1), Some(d2)) => d1.array_eq(d2, precision),
+            (None, None) => true,
+            _ => false,
+        } {
+            return false;
+        }
+        if self.frames.len() != other.frames.len() {
+            return false;
+        }
+        for (a, b) in self.frames.iter().zip(&other.frames) {
+            if !a.array_eq(b, precision) {
+                return false;
+            }
+        }
+        self.unsliced_n_rows == other.unsliced_n_rows
+            && self.slice_start == other.slice_start
+            && self.slice_stop == other.slice_stop
+    }
+}
 
-    type Metadata = ProstMetadata<ZstdMetadata>;
+impl VTable for Zstd {
+    type ArrayData = ZstdData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValiditySliceHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &ZstdArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(array.metadata.clone()))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let validity = child_to_validity(&slots[0], dtype.nullability());
+        data.validate(dtype, len, &validity)
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize {
+        array.dictionary.is_some() as usize + array.frames.len()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        if let Some(dict) = &array.dictionary {
+            if idx == 0 {
+                return BufferHandle::new_host(dict.clone());
+            }
+            BufferHandle::new_host(array.frames[idx - 1].clone())
+        } else {
+            BufferHandle::new_host(array.frames[idx].clone())
+        }
+    }
+
+    fn buffer_name(array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        if array.dictionary.is_some() {
+            if idx == 0 {
+                Some("dictionary".to_string())
+            } else {
+                Some(format!("frame_{}", idx - 1))
+            }
+        } else {
+            Some(format!("frame_{idx}"))
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ZstdMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(array.metadata.clone().encode_to_vec()))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ZstdArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = ZstdMetadata::decode(metadata)?;
         let validity = if children.is_empty() {
             Validity::from(dtype.nullability())
         } else if children.len() == 1 {
@@ -131,7 +201,7 @@ impl VTable for ZstdVTable {
             vortex_bail!("ZstdArray expected 0 or 1 child, got {}", children.len());
         };
 
-        let (dictionary_buffer, compressed_buffers) = if metadata.0.dictionary_size == 0 {
+        let (dictionary_buffer, compressed_buffers) = if metadata.dictionary_size == 0 {
             // no dictionary
             (
                 None,
@@ -151,38 +221,27 @@ impl VTable for ZstdVTable {
             )
         };
 
-        Ok(ZstdArray::new(
-            dictionary_buffer,
-            compressed_buffers,
-            dtype.clone(),
-            metadata.0.clone(),
-            len,
-            validity,
-        ))
+        let slots = vec![validity_to_child(&validity, len)];
+        let data = ZstdData::new(dictionary_buffer, compressed_buffers, metadata, len);
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "ZstdArray expects at most 1 child (validity), got {}",
-            children.len()
-        );
-
-        array.unsliced_validity = if children.is_empty() {
-            Validity::from(array.dtype.nullability())
-        } else {
-            Validity::Array(children.into_iter().next().vortex_expect("checked"))
-        };
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        array.decompress()?.execute(ctx)
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let unsliced_validity =
+            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        array
+            .data()
+            .decompress(array.dtype(), &unsliced_validity, ctx)?
+            .execute::<ArrayRef>(ctx)
+            .map(ExecutionResult::done)
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -190,47 +249,108 @@ impl VTable for ZstdVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct ZstdVTable;
+#[derive(Clone, Debug)]
+pub struct Zstd;
 
-impl ZstdVTable {
+impl Zstd {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.zstd");
+
+    pub fn try_new(dtype: DType, data: ZstdData, validity: Validity) -> VortexResult<ZstdArray> {
+        let len = data.len();
+        data.validate(&dtype, len, &validity)?;
+        let slots = vec![validity_to_child(&validity, data.unsliced_n_rows())];
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Zstd, dtype, len, data).with_slots(slots))
+        })
+    }
+
+    /// Compress a [`VarBinViewArray`] using Zstd without a dictionary.
+    pub fn from_var_bin_view_without_dict(
+        vbv: &VarBinViewArray,
+        level: i32,
+        values_per_frame: usize,
+    ) -> VortexResult<ZstdArray> {
+        let validity = vbv.validity()?;
+        Self::try_new(
+            vbv.dtype().clone(),
+            ZstdData::from_var_bin_view_without_dict(vbv, level, values_per_frame)?,
+            validity,
+        )
+    }
+
+    /// Compress a [`PrimitiveArray`] using Zstd.
+    pub fn from_primitive(
+        parray: &PrimitiveArray,
+        level: i32,
+        values_per_frame: usize,
+    ) -> VortexResult<ZstdArray> {
+        let validity = parray.validity()?;
+        Self::try_new(
+            parray.dtype().clone(),
+            ZstdData::from_primitive(parray, level, values_per_frame)?,
+            validity,
+        )
+    }
+
+    /// Compress a [`VarBinViewArray`] using Zstd.
+    pub fn from_var_bin_view(
+        vbv: &VarBinViewArray,
+        level: i32,
+        values_per_frame: usize,
+    ) -> VortexResult<ZstdArray> {
+        let validity = vbv.validity()?;
+        Self::try_new(
+            vbv.dtype().clone(),
+            ZstdData::from_var_bin_view(vbv, level, values_per_frame)?,
+            validity,
+        )
+    }
+
+    pub fn decompress(array: &ZstdArray, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+        let unsliced_validity =
+            child_to_validity(&array.as_ref().slots()[0], array.dtype().nullability());
+        array
+            .data()
+            .decompress(array.dtype(), &unsliced_validity, ctx)
+    }
 }
 
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
+
 #[derive(Clone, Debug)]
-pub struct ZstdArray {
+pub struct ZstdData {
     pub(crate) dictionary: Option<ByteBuffer>,
     pub(crate) frames: Vec<ByteBuffer>,
     pub(crate) metadata: ZstdMetadata,
-    dtype: DType,
-    pub(crate) unsliced_validity: Validity,
     unsliced_n_rows: usize,
-    stats_set: ArrayStats,
     slice_start: usize,
     slice_stop: usize,
 }
 
-/// The parts of a [`ZstdArray`] returned by [`ZstdArray::into_parts`].
-#[derive(Debug)]
-pub struct ZstdArrayParts {
-    /// The optional dictionary used for compression.
+impl Display for ZstdData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "nrows: {}, slice: {}..{}",
+            self.unsliced_n_rows, self.slice_start, self.slice_stop
+        )
+    }
+}
+
+pub struct ZstdDataParts {
     pub dictionary: Option<ByteBuffer>,
-    /// The compressed frames.
     pub frames: Vec<ByteBuffer>,
-    /// The compression metadata.
     pub metadata: ZstdMetadata,
-    /// The data type of the uncompressed array.
-    pub dtype: DType,
-    /// The validity of the uncompressed array.
     pub validity: Validity,
-    /// The number of rows in the uncompressed array.
     pub n_rows: usize,
-    /// Slice start offset.
     pub slice_start: usize,
-    /// Slice stop offset.
     pub slice_stop: usize,
 }
 
+/// The parts of a [`ZstdArray`] returned by [`ZstdArray::into_parts`].
+#[derive(Debug)]
 struct Frames {
     dictionary: Option<ByteBuffer>,
     frames: Vec<ByteBuffer>,
@@ -247,7 +367,7 @@ fn choose_max_dict_size(uncompressed_size: usize) -> usize {
 
 fn collect_valid_primitive(parray: &PrimitiveArray) -> VortexResult<PrimitiveArray> {
     let mask = parray.validity_mask()?;
-    Ok(filter(&parray.to_array(), &mask)?.to_primitive())
+    Ok(parray.filter(mask)?.to_primitive())
 }
 
 fn collect_valid_vbv(vbv: &VarBinViewArray) -> VortexResult<(ByteBuffer, Vec<usize>)> {
@@ -280,9 +400,20 @@ fn collect_valid_vbv(vbv: &VarBinViewArray) -> VortexResult<(ByteBuffer, Vec<usi
 /// Reconstruct BinaryView structs from length-prefixed byte data.
 ///
 /// The buffer contains interleaved u32 lengths (little-endian) and string data.
-pub fn reconstruct_views(buffer: &ByteBuffer) -> Buffer<BinaryView> {
-    let mut res = BufferMut::<BinaryView>::empty();
+/// When the cumulative data exceeds `max_buffer_len`, the buffer is split (zero-copy) into
+/// multiple segments so that BinaryView's u32 offsets can address all data.
+///
+/// Pass [`MAX_BUFFER_LEN`] for `max_buffer_len` in production; a smaller value can be used in
+/// tests to exercise the splitting path without allocating >2 GiB.
+pub fn reconstruct_views(
+    buffer: &ByteBuffer,
+    max_buffer_len: usize,
+) -> (Vec<ByteBuffer>, Buffer<BinaryView>) {
+    let mut views = BufferMut::<BinaryView>::empty();
+    let mut buffers = Vec::new();
+    let mut segment_start: usize = 0;
     let mut offset = 0;
+
     while offset < buffer.len() {
         let str_len = ViewLen::from_le_bytes(
             buffer
@@ -292,40 +423,127 @@ pub fn reconstruct_views(buffer: &ByteBuffer) -> Buffer<BinaryView> {
                 .ok()
                 .vortex_expect("must fit ViewLen size"),
         ) as usize;
-        offset += size_of::<ViewLen>();
-        let value = &buffer[offset..offset + str_len];
-        res.push(BinaryView::make_view(
-            value,
-            0,
-            u32::try_from(offset).vortex_expect("offset must fit in u32"),
-        ));
-        offset += str_len;
-    }
-    res.freeze()
+
+        let value_data_offset = offset + size_of::<ViewLen>();
+        let local_offset = value_data_offset - segment_start;
+
+        if local_offset + str_len > max_buffer_len && offset > segment_start {
+            buffers.push(buffer.slice(segment_start..offset));
+            segment_start = offset;
+        }
+
+        let local_offset = u32::try_from(value_data_offset - segment_start)
+            .vortex_expect("local offset within segment must fit in u32");
+        let buf_index = u32::try_from(buffers.len()).vortex_expect("buffer index must fit in u32");
+        let value = &buffer[value_data_offset..value_data_offset + str_len];
+        views.push(BinaryView::make_view(value, buf_index, local_offset));
+        offset = value_data_offset + str_len;
+    }
+
+    if segment_start < buffer.len() {
+        buffers.push(buffer.slice(segment_start..buffer.len()));
+    }
+
+    (buffers, views.freeze())
 }
 
-impl ZstdArray {
+impl ZstdData {
     pub fn new(
         dictionary: Option<ByteBuffer>,
         frames: Vec<ByteBuffer>,
-        dtype: DType,
         metadata: ZstdMetadata,
         n_rows: usize,
-        validity: Validity,
     ) -> Self {
         Self {
             dictionary,
             frames,
             metadata,
-            dtype,
-            unsliced_validity: validity,
             unsliced_n_rows: n_rows,
-            stats_set: Default::default(),
             slice_start: 0,
             slice_stop: n_rows,
         }
     }
 
+    pub fn validate(&self, dtype: &DType, len: usize, validity: &Validity) -> VortexResult<()> {
+        vortex_ensure!(
+            matches!(
+                dtype,
+                DType::Primitive(..) | DType::Binary(_) | DType::Utf8(_)
+            ),
+            "Unsupported dtype for Zstd array: {dtype}"
+        );
+        vortex_ensure!(
+            self.slice_start <= self.slice_stop,
+            "Invalid slice range {}..{}",
+            self.slice_start,
+            self.slice_stop
+        );
+        vortex_ensure!(
+            self.slice_stop <= self.unsliced_n_rows,
+            "Slice stop {} exceeds unsliced row count {}",
+            self.slice_stop,
+            self.unsliced_n_rows
+        );
+        vortex_ensure!(
+            self.slice_stop - self.slice_start == len,
+            "Slice length {} does not match array length {}",
+            self.slice_stop - self.slice_start,
+            len
+        );
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure!(
+                validity_len == self.unsliced_n_rows,
+                "Validity length {} does not match unsliced row count {}",
+                validity_len,
+                self.unsliced_n_rows
+            );
+        }
+
+        match &self.dictionary {
+            Some(dictionary) => vortex_ensure!(
+                usize::try_from(self.metadata.dictionary_size)? == dictionary.len(),
+                "Dictionary size metadata {} does not match buffer size {}",
+                self.metadata.dictionary_size,
+                dictionary.len()
+            ),
+            None => vortex_ensure!(
+                self.metadata.dictionary_size == 0,
+                "Dictionary metadata present without dictionary buffer"
+            ),
+        }
+        vortex_ensure!(
+            self.frames.len() == self.metadata.frames.len(),
+            "Frame count {} does not match metadata frame count {}",
+            self.frames.len(),
+            self.metadata.frames.len()
+        );
+
+        Ok(())
+    }
+
+    pub(crate) fn with_slice(&self, start: usize, stop: usize) -> Self {
+        let new_start = self.slice_start + start;
+        let new_stop = self.slice_start + stop;
+
+        assert!(
+            new_start <= self.slice_stop,
+            "new slice start {new_start} exceeds end {}",
+            self.slice_stop
+        );
+
+        assert!(
+            new_stop <= self.slice_stop,
+            "new slice stop {new_stop} exceeds end {}",
+            self.slice_stop
+        );
+
+        Self {
+            slice_start: new_start,
+            slice_stop: new_stop,
+            ..self.clone()
+        }
+    }
+
     fn compress_values(
         value_bytes: &ByteBuffer,
         frame_byte_starts: &[usize],
@@ -429,7 +647,6 @@ impl ZstdArray {
         values_per_frame: usize,
         use_dictionary: bool,
     ) -> VortexResult<Self> {
-        let dtype = parray.dtype().clone();
         let byte_width = parray.ptype().byte_width();
 
         // We compress only the valid elements.
@@ -470,14 +687,7 @@ impl ZstdArray {
             frames: frame_metas,
         };
 
-        Ok(ZstdArray::new(
-            dictionary,
-            frames,
-            dtype,
-            metadata,
-            parray.len(),
-            parray.validity().clone(),
-        ))
+        Ok(ZstdData::new(dictionary, frames, metadata, parray.len()))
     }
 
     /// Creates a ZstdArray from a VarBinView array.
@@ -526,8 +736,6 @@ impl ZstdArray {
         // to separate the binary data and lengths as two separate streams, but
         // this approach is simpler and can be best in cases when there is
         // mutual information between strings and their lengths.
-        let dtype = vbv.dtype().clone();
-
         // We compress only the valid elements.
         let (value_bytes, value_byte_indices) = collect_valid_vbv(vbv)?;
         let n_values = value_byte_indices.len();
@@ -561,14 +769,7 @@ impl ZstdArray {
                 .try_into()?,
             frames: frame_metas,
         };
-        Ok(ZstdArray::new(
-            dictionary,
-            frames,
-            dtype,
-            metadata,
-            vbv.len(),
-            vbv.validity().clone(),
-        ))
+        Ok(ZstdData::new(dictionary, frames, metadata, vbv.len()))
     }
 
     pub fn from_canonical(
@@ -577,12 +778,12 @@ impl ZstdArray {
         values_per_frame: usize,
     ) -> VortexResult<Option<Self>> {
         match canonical {
-            Canonical::Primitive(parray) => Ok(Some(ZstdArray::from_primitive(
+            Canonical::Primitive(parray) => Ok(Some(ZstdData::from_primitive(
                 parray,
                 level,
                 values_per_frame,
             )?)),
-            Canonical::VarBinView(vbv) => Ok(Some(ZstdArray::from_var_bin_view(
+            Canonical::VarBinView(vbv) => Ok(Some(ZstdData::from_var_bin_view(
                 vbv,
                 level,
                 values_per_frame,
@@ -596,22 +797,26 @@ impl ZstdArray {
             .ok_or_else(|| vortex_err!("Zstd can only encode Primitive and VarBinView arrays"))
     }
 
-    fn byte_width(&self) -> usize {
-        if self.dtype.is_primitive() {
-            self.dtype.as_ptype().byte_width()
+    fn byte_width(dtype: &DType) -> usize {
+        if dtype.is_primitive() {
+            dtype.as_ptype().byte_width()
         } else {
             1
         }
     }
 
-    pub fn decompress(&self) -> VortexResult<ArrayRef> {
+    fn decompress(
+        &self,
+        dtype: &DType,
+        unsliced_validity: &Validity,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
         // To start, we figure out which frames we need to decompress, and with
         // what row offset into the first such frame.
-        let byte_width = self.byte_width();
+        let byte_width = Self::byte_width(dtype);
         let slice_n_rows = self.slice_stop - self.slice_start;
-        let slice_value_indices = self
-            .unsliced_validity
-            .to_mask(self.unsliced_n_rows)
+        let slice_value_indices = unsliced_validity
+            .execute_mask(self.unsliced_n_rows, ctx)?
             .valid_counts_for_indices(&[self.slice_start, self.slice_stop]);
 
         let slice_value_idx_start = slice_value_indices[0];
@@ -677,9 +882,7 @@ impl ZstdArray {
 
         let decompressed = decompressed.freeze();
         // Last, we slice the exact values requested out of the decompressed data.
-        let mut slice_validity = self
-            .unsliced_validity
-            .slice(self.slice_start..self.slice_stop)?;
+        let mut slice_validity = unsliced_validity.slice(self.slice_start..self.slice_stop)?;
 
         // NOTE: this block handles setting the output type when the validity and DType disagree.
         //
@@ -689,21 +892,21 @@ impl ZstdArray {
         //
         // We ensure that the validity of the decompressed array ALWAYS matches the validity
         // implied by the DType.
-        if !self.dtype().is_nullable() && slice_validity != Validity::NonNullable {
+        if !dtype.is_nullable() && !matches!(slice_validity, Validity::NonNullable) {
             assert!(
-                slice_validity.all_valid(slice_n_rows)?,
+                matches!(slice_validity, Validity::AllValid),
                 "ZSTD array expects to be non-nullable but there are nulls after decompression"
             );
 
             slice_validity = Validity::NonNullable;
-        } else if self.dtype.is_nullable() && slice_validity == Validity::NonNullable {
+        } else if dtype.is_nullable() && matches!(slice_validity, Validity::NonNullable) {
             slice_validity = Validity::AllValid;
         }
         //
         // END OF IMPORTANT BLOCK
         //
 
-        match &self.dtype {
+        match dtype {
             DType::Primitive(..) => {
                 let slice_values_buffer = decompressed.slice(
                     (slice_value_idx_start - n_skipped_values) * byte_width
@@ -711,7 +914,7 @@ impl ZstdArray {
                 );
                 let primitive = PrimitiveArray::from_values_byte_buffer(
                     slice_values_buffer,
-                    self.dtype.as_ptype(),
+                    dtype.as_ptype(),
                     slice_validity,
                     slice_n_rows,
                 );
@@ -719,12 +922,10 @@ impl ZstdArray {
                 Ok(primitive.into_array())
             }
             DType::Binary(_) | DType::Utf8(_) => {
-                match slice_validity.to_mask(slice_n_rows).indices() {
+                match slice_validity.execute_mask(slice_n_rows, ctx)?.indices() {
                     AllOr::All => {
-                        // the decompressed buffer is a bunch of interleaved u32 lengths
-                        // and strings of those lengths, we need to reconstruct the
-                        // views into those strings by passing through the buffer.
-                        let valid_views = reconstruct_views(&decompressed).slice(
+                        let (buffers, all_views) = reconstruct_views(&decompressed, MAX_BUFFER_LEN);
+                        let valid_views = all_views.slice(
                             slice_value_idx_start - n_skipped_values
                                 ..slice_value_idx_stop - n_skipped_values,
                         );
@@ -733,23 +934,21 @@ impl ZstdArray {
                         Ok(unsafe {
                             VarBinViewArray::new_unchecked(
                                 valid_views,
-                                Arc::from([decompressed]),
-                                self.dtype.clone(),
+                                Arc::from(buffers),
+                                dtype.clone(),
                                 slice_validity,
                             )
                         }
                         .into_array())
                     }
                     AllOr::None => Ok(ConstantArray::new(
-                        Scalar::null(self.dtype.clone()),
+                        Scalar::null(dtype.clone()),
                         slice_n_rows,
                     )
                     .into_array()),
                     AllOr::Some(valid_indices) => {
-                        // the decompressed buffer is a bunch of interleaved u32 lengths
-                        // and strings of those lengths, we need to reconstruct the
-                        // views into those strings by passing through the buffer.
-                        let valid_views = reconstruct_views(&decompressed).slice(
+                        let (buffers, all_views) = reconstruct_views(&decompressed, MAX_BUFFER_LEN);
+                        let valid_views = all_views.slice(
                             slice_value_idx_start - n_skipped_values
                                 ..slice_value_idx_stop - n_skipped_values,
                         );
@@ -763,8 +962,8 @@ impl ZstdArray {
                         Ok(unsafe {
                             VarBinViewArray::new_unchecked(
                                 views.freeze(),
-                                Arc::from([decompressed]),
-                                self.dtype.clone(),
+                                Arc::from(buffers),
+                                dtype.clone(),
                                 slice_validity,
                             )
                         }
@@ -772,52 +971,34 @@ impl ZstdArray {
                     }
                 }
             }
-            _ => vortex_panic!("Unsupported dtype for Zstd array: {}", self.dtype),
+            _ => vortex_panic!("Unsupported dtype for Zstd array: {}", dtype),
         }
     }
 
-    pub(crate) fn _slice(&self, start: usize, stop: usize) -> ZstdArray {
-        let new_start = self.slice_start + start;
-        let new_stop = self.slice_start + stop;
-
-        assert!(
-            new_start <= self.slice_stop,
-            "new slice start {new_start} exceeds end {}",
-            self.slice_stop
-        );
-
-        assert!(
-            new_stop <= self.slice_stop,
-            "new slice stop {new_stop} exceeds end {}",
-            self.slice_stop
-        );
+    /// Returns the length of the array.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.slice_stop - self.slice_start
+    }
 
-        ZstdArray {
-            slice_start: self.slice_start + start,
-            slice_stop: self.slice_start + stop,
-            stats_set: Default::default(),
-            ..self.clone()
-        }
+    /// Returns whether the array is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.slice_stop == self.slice_start
     }
 
-    /// Consumes the array and returns its parts.
-    pub fn into_parts(self) -> ZstdArrayParts {
-        ZstdArrayParts {
+    pub fn into_parts(self, validity: Validity) -> ZstdDataParts {
+        ZstdDataParts {
             dictionary: self.dictionary,
             frames: self.frames,
             metadata: self.metadata,
-            dtype: self.dtype,
-            validity: self.unsliced_validity,
+            validity,
             n_rows: self.unsliced_n_rows,
             slice_start: self.slice_start,
             slice_stop: self.slice_stop,
         }
     }
 
-    pub(crate) fn dtype(&self) -> &DType {
-        &self.dtype
-    }
-
     pub(crate) fn slice_start(&self) -> usize {
         self.slice_start
     }
@@ -831,99 +1012,74 @@ impl ZstdArray {
     }
 }
 
-impl ValiditySliceHelper for ZstdArray {
-    fn unsliced_validity_and_slice(&self) -> (&Validity, usize, usize) {
-        (&self.unsliced_validity, self.slice_start, self.slice_stop)
+impl ValidityVTable<Zstd> for Zstd {
+    fn validity(array: ArrayView<'_, Zstd>) -> VortexResult<Validity> {
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        unsliced_validity.slice(array.slice_start()..array.slice_stop())
     }
 }
 
-impl BaseArrayVTable<ZstdVTable> for ZstdVTable {
-    fn len(array: &ZstdArray) -> usize {
-        array.slice_stop - array.slice_start
-    }
-
-    fn dtype(array: &ZstdArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ZstdArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &ZstdArray, state: &mut H, precision: Precision) {
-        match &array.dictionary {
-            Some(dict) => {
-                true.hash(state);
-                dict.array_hash(state, precision);
-            }
-            None => {
-                false.hash(state);
-            }
-        }
-        for frame in &array.frames {
-            frame.array_hash(state, precision);
-        }
-        array.dtype.hash(state);
-        array.unsliced_validity.array_hash(state, precision);
-        array.unsliced_n_rows.hash(state);
-        array.slice_start.hash(state);
-        array.slice_stop.hash(state);
-    }
-
-    fn array_eq(array: &ZstdArray, other: &ZstdArray, precision: Precision) -> bool {
-        if !match (&array.dictionary, &other.dictionary) {
-            (Some(d1), Some(d2)) => d1.array_eq(d2, precision),
-            (None, None) => true,
-            _ => false,
-        } {
-            return false;
-        }
-        if array.frames.len() != other.frames.len() {
-            return false;
-        }
-        for (a, b) in array.frames.iter().zip(&other.frames) {
-            if !a.array_eq(b, precision) {
-                return false;
-            }
-        }
-        array.dtype == other.dtype
-            && array
-                .unsliced_validity
-                .array_eq(&other.unsliced_validity, precision)
-            && array.unsliced_n_rows == other.unsliced_n_rows
-            && array.slice_start == other.slice_start
-            && array.slice_stop == other.slice_stop
-    }
-}
-
-impl OperationsVTable<ZstdVTable> for ZstdVTable {
-    fn scalar_at(array: &ZstdArray, index: usize) -> VortexResult<Scalar> {
-        array._slice(index, index + 1).decompress()?.scalar_at(0)
+impl OperationsVTable<Zstd> for Zstd {
+    fn scalar_at(
+        array: ArrayView<'_, Zstd>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        let sliced = array.data().with_slice(index, index + 1);
+        sliced
+            .decompress(array.dtype(), &unsliced_validity, &mut ctx)?
+            .scalar_at(0)
     }
 }
 
-impl VisitorVTable<ZstdVTable> for ZstdVTable {
-    fn visit_buffers(array: &ZstdArray, visitor: &mut dyn ArrayBufferVisitor) {
-        if let Some(buffer) = &array.dictionary {
-            visitor.visit_buffer_handle("dictionary", &BufferHandle::new_host(buffer.clone()));
-        }
-        for (i, buffer) in array.frames.iter().enumerate() {
-            visitor.visit_buffer_handle(
-                &format!("frame_{i}"),
-                &BufferHandle::new_host(buffer.clone()),
-            );
+#[cfg(test)]
+#[allow(clippy::cast_possible_truncation)]
+mod tests {
+    use vortex_buffer::ByteBuffer;
+
+    use super::reconstruct_views;
+    use crate::array::BinaryView;
+
+    /// Build a Zstd-style interleaved buffer: [u32-LE length][string bytes] repeated.
+    fn make_interleaved(strings: &[&[u8]]) -> ByteBuffer {
+        let mut buf = Vec::new();
+        for s in strings {
+            let len = s.len() as u32;
+            buf.extend_from_slice(&len.to_le_bytes());
+            buf.extend_from_slice(s);
         }
+        ByteBuffer::copy_from(buf.as_slice())
     }
 
-    fn nbuffers(array: &ZstdArray) -> usize {
-        array.dictionary.is_some() as usize + array.frames.len()
-    }
-
-    fn visit_children(array: &ZstdArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(&array.unsliced_validity, array.unsliced_n_rows());
+    #[test]
+    fn test_reconstruct_views_no_split() {
+        let strings: &[&[u8]] = &[b"hello", b"world"];
+        let buf = make_interleaved(strings);
+        let (buffers, views) = reconstruct_views(&buf, 1024);
+
+        assert_eq!(buffers.len(), 1);
+        assert_eq!(views.len(), 2);
+        // Each entry: [u32 len (4 bytes)][data], so offsets are 4 and 4+5+4=13
+        assert_eq!(views[0], BinaryView::make_view(b"hello", 0, 4));
+        assert_eq!(views[1], BinaryView::make_view(b"world", 0, 13));
     }
 
-    fn nchildren(array: &ZstdArray) -> usize {
-        validity_nchildren(&array.unsliced_validity)
+    #[test]
+    fn test_reconstruct_views_split_across_segments() {
+        // "aaaaaaaaaaaaa" (13 bytes) and "bbbbbbbbbbbbb" (13 bytes).
+        // Each entry occupies 4 (length prefix) + 13 (data) = 17 bytes.
+        // With max_buffer_len=20, the second entry's data (offset 4+13+4=21) exceeds the limit,
+        // so it rolls into a second segment.
+        let strings: &[&[u8]] = &[b"aaaaaaaaaaaaa", b"bbbbbbbbbbbbb"];
+        let buf = make_interleaved(strings);
+        let (buffers, views) = reconstruct_views(&buf, 20);
+
+        assert_eq!(buffers.len(), 2);
+        assert_eq!(views.len(), 2);
+        assert_eq!(views[0], BinaryView::make_view(b"aaaaaaaaaaaaa", 0, 4));
+        // Second entry starts a new segment at byte 17 (the length prefix), so local offset = 4.
+        assert_eq!(views[1], BinaryView::make_view(b"bbbbbbbbbbbbb", 1, 4));
     }
 }
diff --git a/encodings/zstd/src/compute/cast.rs b/encodings/zstd/src/compute/cast.rs
index bf67900f41f..2beb94a1a4e 100644
--- a/encodings/zstd/src/compute/cast.rs
+++ b/encodings/zstd/src/compute/cast.rs
@@ -2,16 +2,19 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::scalar_fn::fns::cast::CastReduce;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::child_to_validity;
 use vortex_error::VortexResult;
 
-use crate::ZstdArray;
-use crate::ZstdVTable;
-
-impl CastReduce for ZstdVTable {
-    fn cast(array: &ZstdArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+use crate::Zstd;
+use crate::ZstdData;
+impl CastReduce for Zstd {
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !dtype.eq_ignore_nullability(array.dtype()) {
             // Type changes can't be handled in ZSTD, need to decode and tweak.
             // TODO(aduffy): handle trivial conversions like Binary -> UTF8, integer widening, etc.
@@ -25,28 +28,36 @@ impl CastReduce for ZstdVTable {
             // Same type case. This should be handled in the layer above but for
             // completeness of the match arms we also handle it here.
             (Nullability::Nullable, Nullability::Nullable)
-            | (Nullability::NonNullable, Nullability::NonNullable) => Ok(Some(array.to_array())),
+            | (Nullability::NonNullable, Nullability::NonNullable) => {
+                Ok(Some(array.array().clone()))
+            }
             (Nullability::NonNullable, Nullability::Nullable) => {
                 // nonnull => null, trivial cast by altering the validity
+                let unsliced_validity =
+                    child_to_validity(&array.slots()[0], array.dtype().nullability());
                 Ok(Some(
-                    ZstdArray::new(
-                        array.dictionary.clone(),
-                        array.frames.clone(),
+                    Zstd::try_new(
                         dtype.clone(),
-                        array.metadata.clone(),
-                        array.unsliced_n_rows(),
-                        array.unsliced_validity.clone(),
-                    )
+                        ZstdData::new(
+                            array.dictionary.clone(),
+                            array.frames.clone(),
+                            array.metadata.clone(),
+                            array.unsliced_n_rows(),
+                        ),
+                        unsliced_validity,
+                    )?
+                    .into_array()
                     .slice(array.slice_start()..array.slice_stop())?,
                 ))
             }
             (Nullability::Nullable, Nullability::NonNullable) => {
                 // null => non-null works if there are no nulls in the sliced range
-                let sliced_len = array.slice_stop() - array.slice_start();
-                let has_nulls = !array
-                    .unsliced_validity
-                    .slice(array.slice_start()..array.slice_stop())?
-                    .all_valid(sliced_len)?;
+                let unsliced_validity =
+                    child_to_validity(&array.slots()[0], array.dtype().nullability());
+                let has_nulls = !matches!(
+                    unsliced_validity.slice(array.slice_start()..array.slice_stop())?,
+                    Validity::AllValid | Validity::NonNullable
+                );
 
                 // We don't attempt to handle casting when there are nulls.
                 if has_nulls {
@@ -55,14 +66,17 @@ impl CastReduce for ZstdVTable {
 
                 // If there are no nulls, the cast is trivial
                 Ok(Some(
-                    ZstdArray::new(
-                        array.dictionary.clone(),
-                        array.frames.clone(),
+                    Zstd::try_new(
                         dtype.clone(),
-                        array.metadata.clone(),
-                        array.unsliced_n_rows(),
-                        array.unsliced_validity.clone(),
-                    )
+                        ZstdData::new(
+                            array.dictionary.clone(),
+                            array.frames.clone(),
+                            array.metadata.clone(),
+                            array.unsliced_n_rows(),
+                        ),
+                        unsliced_validity,
+                    )?
+                    .into_array()
                     .slice(array.slice_start()..array.slice_stop())?,
                 ))
             }
@@ -73,6 +87,7 @@ impl CastReduce for ZstdVTable {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
@@ -82,20 +97,17 @@ mod tests {
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
 
-    use crate::ZstdArray;
+    use crate::Zstd;
 
     #[test]
     fn test_cast_zstd_i32_to_i64() {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1i32, 2, 3, 4, 5]),
-            Validity::NonNullable,
-        );
-        let zstd = ZstdArray::from_primitive(&values, 0, 0).unwrap();
+        let values = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
+        let zstd = Zstd::from_primitive(&values, 0, 0).unwrap();
 
         let casted = zstd
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -109,14 +121,11 @@ mod tests {
 
     #[test]
     fn test_cast_zstd_nullability_change() {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40]),
-            Validity::NonNullable,
-        );
-        let zstd = ZstdArray::from_primitive(&values, 0, 0).unwrap();
+        let values = PrimitiveArray::from_iter([10u32, 20, 30, 40]);
+        let zstd = Zstd::from_primitive(&values, 0, 0).unwrap();
 
         let casted = zstd
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -128,10 +137,10 @@ mod tests {
     #[test]
     fn test_cast_sliced_zstd_nullable_to_nonnullable() {
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40, 50, 60]),
+            buffer![10u32, 20, 30, 40, 50, 60],
             Validity::from_iter([true, true, true, true, true, true]),
         );
-        let zstd = ZstdArray::from_primitive(&values, 0, 128).unwrap();
+        let zstd = Zstd::from_primitive(&values, 0, 128).unwrap();
         let sliced = zstd.slice(1..5).unwrap();
         let casted = sliced
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
@@ -155,7 +164,7 @@ mod tests {
             Some(50),
             Some(60),
         ]);
-        let zstd = ZstdArray::from_primitive(&values, 0, 128).unwrap();
+        let zstd = Zstd::from_primitive(&values, 0, 128).unwrap();
         let sliced = zstd.slice(1..5).unwrap();
         let casted = sliced
             .cast(DType::Primitive(PType::U32, Nullability::NonNullable))
@@ -171,23 +180,23 @@ mod tests {
 
     #[rstest]
     #[case::i32(PrimitiveArray::new(
-        Buffer::copy_from(vec![100i32, 200, 300, 400, 500]),
+        buffer![100i32, 200, 300, 400, 500],
         Validity::NonNullable,
     ))]
     #[case::f64(PrimitiveArray::new(
-        Buffer::copy_from(vec![1.1f64, 2.2, 3.3, 4.4, 5.5]),
+        buffer![1.1f64, 2.2, 3.3, 4.4, 5.5],
         Validity::NonNullable,
     ))]
     #[case::single(PrimitiveArray::new(
-        Buffer::copy_from(vec![42i64]),
+        buffer![42i64],
         Validity::NonNullable,
     ))]
     #[case::large(PrimitiveArray::new(
-        Buffer::copy_from((0..1000).map(|i| i as u32).collect::<Vec<_>>()),
+        buffer![0u32..1000],
         Validity::NonNullable,
     ))]
     fn test_cast_zstd_conformance(#[case] values: PrimitiveArray) {
-        let zstd = ZstdArray::from_primitive(&values, 0, 0).unwrap();
-        test_cast_conformance(zstd.as_ref());
+        let zstd = Zstd::from_primitive(&values, 0, 0).unwrap();
+        test_cast_conformance(&zstd.into_array());
     }
 }
diff --git a/encodings/zstd/src/compute/mod.rs b/encodings/zstd/src/compute/mod.rs
index 52e4983fb8d..adf6937c246 100644
--- a/encodings/zstd/src/compute/mod.rs
+++ b/encodings/zstd/src/compute/mod.rs
@@ -6,72 +6,62 @@ mod cast;
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
-    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
 
+    use crate::Zstd;
     use crate::ZstdArray;
 
     fn zstd_i32() -> ZstdArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![100i32, 200, 300, 400, 500]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        let values = PrimitiveArray::from_iter([100i32, 200, 300, 400, 500]);
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_f64() -> ZstdArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![1.1f64, 2.2, 3.3, 4.4, 5.5]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        let values = PrimitiveArray::from_iter([1.1f64, 2.2, 3.3, 4.4, 5.5]);
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_u32() -> ZstdArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![10u32, 20, 30, 40, 50]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        let values = PrimitiveArray::from_iter([10u32, 20, 30, 40, 50]);
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_nullable_i64() -> ZstdArray {
         let values =
             PrimitiveArray::from_option_iter([Some(1000i64), None, Some(3000), Some(4000), None]);
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_single() -> ZstdArray {
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![42i64]),
+            buffer![42i64],
             vortex_array::validity::Validity::NonNullable,
         );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_large() -> ZstdArray {
         let values = PrimitiveArray::new(
-            Buffer::copy_from((0..1000).map(|i| i as u32).collect::<Vec<_>>()),
+            buffer![0u32..1000],
             vortex_array::validity::Validity::NonNullable,
         );
-        ZstdArray::from_primitive(&values, 3, 0).unwrap()
+        Zstd::from_primitive(&values, 3, 0).unwrap()
     }
 
     fn zstd_all_same() -> ZstdArray {
         let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![42i32; 100]),
+            buffer![42i32; 100],
             vortex_array::validity::Validity::NonNullable,
         );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     fn zstd_negative() -> ZstdArray {
-        let values = PrimitiveArray::new(
-            Buffer::copy_from(vec![-100i32, -50, 0, 50, 100]),
-            vortex_array::validity::Validity::NonNullable,
-        );
-        ZstdArray::from_primitive(&values, 0, 0).unwrap()
+        let values = PrimitiveArray::from_iter([-100i32, -50, 0, 50, 100]);
+        Zstd::from_primitive(&values, 0, 0).unwrap()
     }
 
     #[rstest]
@@ -84,6 +74,6 @@ mod tests {
     #[case::all_same(zstd_all_same())]
     #[case::negative(zstd_negative())]
     fn test_zstd_consistency(#[case] array: ZstdArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/encodings/zstd/src/rules.rs b/encodings/zstd/src/rules.rs
index b34ae4b8409..cfbf93b09e8 100644
--- a/encodings/zstd/src/rules.rs
+++ b/encodings/zstd/src/rules.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::arrays::SliceReduceAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
 use vortex_array::optimizer::rules::ParentRuleSet;
 use vortex_array::scalar_fn::fns::cast::CastReduceAdaptor;
 
-use crate::ZstdVTable;
+use crate::Zstd;
 
-pub(crate) static RULES: ParentRuleSet<ZstdVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&SliceReduceAdaptor(ZstdVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(ZstdVTable)),
+pub(crate) static RULES: ParentRuleSet<Zstd> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&SliceReduceAdaptor(Zstd)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Zstd)),
 ]);
diff --git a/encodings/zstd/src/slice.rs b/encodings/zstd/src/slice.rs
index f4adb7cc306..6b6906a1628 100644
--- a/encodings/zstd/src/slice.rs
+++ b/encodings/zstd/src/slice.rs
@@ -4,19 +4,24 @@
 use std::ops::Range;
 
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::IntoArray;
-use vortex_array::arrays::SliceReduce;
+use vortex_array::arrays::slice::SliceReduce;
+use vortex_array::vtable::child_to_validity;
 use vortex_error::VortexResult;
 
-use crate::ZstdArray;
-use crate::ZstdVTable;
+use crate::Zstd;
 
-impl SliceReduce for ZstdVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        Ok(Some(slice_zstd(array, range)))
+impl SliceReduce for Zstd {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        let unsliced_validity = child_to_validity(&array.slots()[0], array.dtype().nullability());
+        Ok(Some(
+            Zstd::try_new(
+                array.dtype().clone(),
+                array.data().with_slice(range.start, range.end),
+                unsliced_validity,
+            )?
+            .into_array(),
+        ))
     }
 }
-
-fn slice_zstd(array: &ZstdArray, range: Range<usize>) -> ArrayRef {
-    array._slice(range.start, range.end).into_array()
-}
diff --git a/encodings/zstd/src/test.rs b/encodings/zstd/src/test.rs
index 04fd267e752..01800577d7b 100644
--- a/encodings/zstd/src/test.rs
+++ b/encodings/zstd/src/test.rs
@@ -2,7 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 #![allow(clippy::cast_possible_truncation)]
 
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::ToCanonical;
+use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
@@ -11,25 +14,25 @@ use vortex_array::assert_nth_scalar;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Alignment;
 use vortex_buffer::Buffer;
 use vortex_mask::Mask;
 
-use crate::ZstdArray;
+use crate::Zstd;
 
 #[test]
 fn test_zstd_compress_decompress() {
     let data: Vec<i32> = (0..200).collect();
     let array = PrimitiveArray::from_iter(data.clone());
 
-    let compressed = ZstdArray::from_primitive(&array, 3, 0).unwrap();
+    let compressed = Zstd::from_primitive(&array, 3, 0).unwrap();
     // this data should be compressible
-    assert!(compressed.frames.len() < array.nbytes() as usize);
+    assert!(compressed.frames.len() < array.into_array().nbytes() as usize);
     assert!(compressed.dictionary.is_none());
 
     // check full decompression works
-    let decompressed = compressed.decompress().unwrap();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let decompressed = Zstd::decompress(&compressed, &mut ctx).unwrap();
     assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(data));
 
     // check slicing works
@@ -51,7 +54,7 @@ fn test_zstd_empty() {
         Validity::NonNullable,
     );
 
-    let compressed = ZstdArray::from_primitive(&array, 3, 100).unwrap();
+    let compressed = Zstd::from_primitive(&array, 3, 100).unwrap();
 
     assert_arrays_eq!(compressed, PrimitiveArray::from_iter(data));
 }
@@ -64,21 +67,30 @@ fn test_zstd_with_validity_and_multi_frame() {
     validity[177] = true;
     let array = PrimitiveArray::new(
         Buffer::from(data),
-        Validity::Array(BoolArray::from_iter(validity).to_array()),
+        Validity::Array(BoolArray::from_iter(validity).into_array()),
     );
 
-    let compressed = ZstdArray::from_primitive(&array, 0, 30).unwrap();
+    let compressed = Zstd::from_primitive(&array, 0, 30).unwrap();
     assert!(compressed.dictionary.is_none());
     assert_nth_scalar!(compressed, 0, None::<i32>);
     assert_nth_scalar!(compressed, 3, 3);
     assert_nth_scalar!(compressed, 10, None::<i32>);
     assert_nth_scalar!(compressed, 177, 177);
 
-    let decompressed = compressed.decompress().unwrap().to_primitive();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let decompressed = Zstd::decompress(&compressed, &mut ctx)
+        .unwrap()
+        .to_primitive();
     let decompressed_values = decompressed.as_slice::<i32>();
     assert_eq!(decompressed_values[3], 3);
     assert_eq!(decompressed_values[177], 177);
-    assert_eq!(decompressed.validity(), array.validity());
+    assert!(
+        decompressed
+            .validity()
+            .unwrap()
+            .mask_eq(&array.validity().unwrap(), &mut ctx)
+            .unwrap()
+    );
 
     // check slicing works
     let slice = compressed.slice(176..179).unwrap();
@@ -87,9 +99,15 @@ fn test_zstd_with_validity_and_multi_frame() {
         i32::try_from(&primitive.scalar_at(1).unwrap()).unwrap(),
         177
     );
-    assert_eq!(
-        primitive.validity(),
-        &Validity::Array(BoolArray::from_iter(vec![false, true, false]).to_array())
+    assert!(
+        primitive
+            .validity()
+            .unwrap()
+            .mask_eq(
+                &Validity::Array(BoolArray::from_iter(vec![false, true, false]).into_array()),
+                &mut ctx
+            )
+            .unwrap()
     );
 }
 
@@ -101,12 +119,15 @@ fn test_zstd_with_dict() {
         Validity::NonNullable,
     );
 
-    let compressed = ZstdArray::from_primitive(&array, 0, 16).unwrap();
+    let compressed = Zstd::from_primitive(&array, 0, 16).unwrap();
     assert!(compressed.dictionary.is_some());
     assert_nth_scalar!(compressed, 0, 0);
     assert_nth_scalar!(compressed, 199, 199);
 
-    let decompressed = compressed.decompress().unwrap().to_primitive();
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let decompressed = Zstd::decompress(&compressed, &mut ctx)
+        .unwrap()
+        .to_primitive();
     assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(data));
 
     // check slicing works
@@ -120,11 +141,11 @@ fn test_validity_vtable() {
     let mask_bools = vec![false, true, true, false, true];
     let array = PrimitiveArray::new(
         (0..5).collect::<Buffer<_>>(),
-        Validity::Array(BoolArray::from_iter(mask_bools.clone()).to_array()),
+        Validity::Array(BoolArray::from_iter(mask_bools.clone()).into_array()),
     );
-    let compressed = ZstdArray::from_primitive(&array, 3, 0).unwrap();
+    let compressed = Zstd::from_primitive(&array, 3, 0).unwrap();
     assert_eq!(
-        compressed.validity_mask().unwrap(),
+        compressed.as_array().validity_mask().unwrap(),
         Mask::from_iter(mask_bools)
     );
     assert_eq!(
@@ -144,7 +165,7 @@ fn test_zstd_var_bin_view() {
     ];
     let array = VarBinViewArray::from_iter(data, DType::Utf8(Nullability::Nullable));
 
-    let compressed = ZstdArray::from_var_bin_view(&array, 0, 3).unwrap();
+    let compressed = Zstd::from_var_bin_view(&array, 0, 3).unwrap();
     assert!(compressed.dictionary.is_none());
     assert_nth_scalar!(compressed, 0, "foo");
     assert_nth_scalar!(compressed, 1, "bar");
@@ -169,14 +190,18 @@ fn test_zstd_decompress_var_bin_view() {
     ];
     let array = VarBinViewArray::from_iter(data, DType::Utf8(Nullability::Nullable));
 
-    let compressed = ZstdArray::from_var_bin_view(&array, 0, 3).unwrap();
+    let compressed = Zstd::from_var_bin_view(&array, 0, 3).unwrap();
     assert!(compressed.dictionary.is_none());
     assert_nth_scalar!(compressed, 0, "foo");
     assert_nth_scalar!(compressed, 1, "bar");
     assert_nth_scalar!(compressed, 2, None::<String>);
     assert_nth_scalar!(compressed, 3, "Lorem ipsum dolor sit amet");
     assert_nth_scalar!(compressed, 4, "baz");
-    let decompressed = compressed.decompress().unwrap().to_varbinview();
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let decompressed = Zstd::decompress(&compressed, &mut ctx)
+        .unwrap()
+        .to_varbinview();
     assert_nth_scalar!(decompressed, 0, "foo");
     assert_nth_scalar!(decompressed, 1, "bar");
     assert_nth_scalar!(decompressed, 2, None::<String>);
@@ -187,8 +212,7 @@ fn test_zstd_decompress_var_bin_view() {
 #[test]
 fn test_sliced_array_children() {
     let data: Vec<Option<i32>> = (0..10).map(|v| (v != 5).then_some(v)).collect();
-    let compressed =
-        ZstdArray::from_primitive(&PrimitiveArray::from_option_iter(data), 0, 100).unwrap();
+    let compressed = Zstd::from_primitive(&PrimitiveArray::from_option_iter(data), 0, 100).unwrap();
     let sliced = compressed.slice(0..4).unwrap();
     sliced.children();
 }
@@ -201,7 +225,7 @@ fn test_zstd_frame_start_buffer_alignment() {
     let aligned_buffer = Buffer::copy_from_aligned(&data, Alignment::new(8));
     // u8 array now has a 8-byte alignment.
     let array = PrimitiveArray::new(aligned_buffer, Validity::NonNullable);
-    let compressed = ZstdArray::from_primitive(&array, 0, 1);
+    let compressed = Zstd::from_primitive(&array, 0, 1);
 
     assert!(compressed.is_ok());
 }
diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs
index f6cc7373abd..e1712b01c2e 100644
--- a/encodings/zstd/src/zstd_buffers.rs
+++ b/encodings/zstd/src/zstd_buffers.rs
@@ -2,32 +2,31 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::hash::Hash;
+use std::hash::Hasher;
 use std::sync::Arc;
 
 use prost::Message as _;
-use vortex_array::ArrayBufferVisitor;
-use vortex_array::ArrayChildVisitor;
+use vortex_array::Array;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
+use vortex_array::ExecutionResult;
 use vortex_array::Precision;
-use vortex_array::ProstMetadata;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
 use vortex_array::session::ArraySessionExt;
-use vortex_array::stats::ArrayStats;
-use vortex_array::stats::StatsSetRef;
-use vortex_array::vtable;
-use vortex_array::vtable::ArrayId;
-use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
-use vortex_array::vtable::VisitorVTable;
 use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
@@ -38,13 +37,95 @@ use vortex_session::VortexSession;
 
 use crate::ZstdBuffersMetadata;
 
-vtable!(ZstdBuffers);
+/// A [`ZstdBuffers`]-encoded Vortex array.
+pub type ZstdBuffersArray = Array<ZstdBuffers>;
 
-#[derive(Debug)]
-pub struct ZstdBuffersVTable;
+#[derive(Clone, Debug)]
+pub struct ZstdBuffers;
 
-impl ZstdBuffersVTable {
+impl ZstdBuffers {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.zstd_buffers");
+
+    pub fn try_new(
+        dtype: DType,
+        len: usize,
+        data: ZstdBuffersData,
+    ) -> VortexResult<ZstdBuffersArray> {
+        Array::try_from_parts(ArrayParts::new(ZstdBuffers, dtype, len, data))
+    }
+
+    pub fn compress(
+        array: &ArrayRef,
+        level: i32,
+        session: &VortexSession,
+    ) -> VortexResult<ZstdBuffersArray> {
+        let encoding_id = array.encoding_id();
+        let metadata = array
+            .metadata(session)?
+            .ok_or_else(|| vortex_err!("Array does not support serialization"))?;
+        let buffer_handles = array.buffer_handles();
+        let children = array.children();
+
+        let mut compressed_buffers = Vec::with_capacity(buffer_handles.len());
+        let mut uncompressed_sizes = Vec::with_capacity(buffer_handles.len());
+        let mut buffer_alignments = Vec::with_capacity(buffer_handles.len());
+
+        let mut compressor = zstd::bulk::Compressor::new(level)?;
+        // Compression is currently CPU-only, so we gather all buffers on the host.
+        for handle in &buffer_handles {
+            buffer_alignments.push(u32::from(handle.alignment()));
+            let host_buf = handle.clone().try_to_host_sync()?;
+            uncompressed_sizes.push(host_buf.len() as u64);
+            let compressed = compressor.compress(&host_buf)?;
+            compressed_buffers.push(BufferHandle::new_host(ByteBuffer::from(compressed)));
+        }
+
+        let data = ZstdBuffersData {
+            inner_encoding_id: encoding_id,
+            inner_metadata: metadata,
+            compressed_buffers,
+            uncompressed_sizes,
+            buffer_alignments,
+        };
+        let slots = children.into_iter().map(Some).collect();
+        let compressed = Array::try_from_parts(
+            ArrayParts::new(ZstdBuffers, array.dtype().clone(), array.len(), data)
+                .with_slots(slots),
+        )?;
+        compressed.statistics().inherit_from(array.statistics());
+        Ok(compressed)
+    }
+
+    pub fn build_inner(
+        array: &ZstdBuffersArray,
+        buffer_handles: &[BufferHandle],
+        session: &VortexSession,
+    ) -> VortexResult<ArrayRef> {
+        let registry = session.arrays().registry().clone();
+        let inner_vtable = registry
+            .find(&array.data().inner_encoding_id)
+            .ok_or_else(|| {
+                vortex_err!("Unknown inner encoding: {}", array.data().inner_encoding_id)
+            })?;
+
+        let children: Vec<ArrayRef> = array.slots().iter().flatten().cloned().collect();
+        inner_vtable.deserialize(
+            array.dtype(),
+            array.len(),
+            &array.data().inner_metadata,
+            buffer_handles,
+            &children.as_slice(),
+            session,
+        )
+    }
+
+    fn decompress_and_build_inner(
+        array: &ZstdBuffersArray,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayRef> {
+        let decompressed_buffers = array.data().decompress_buffers()?;
+        Self::build_inner(array, &decompressed_buffers, session)
+    }
 }
 
 /// An encoding that ZSTD-compresses the buffers of any wrapped array.
@@ -53,16 +134,18 @@ impl ZstdBuffersVTable {
 /// `ZstdBuffersArray` compresses each buffer independently. This enables zero-conversion
 /// GPU decompression since the original buffer layout is preserved after decompression.
 #[derive(Clone, Debug)]
-pub struct ZstdBuffersArray {
+pub struct ZstdBuffersData {
     inner_encoding_id: ArrayId,
     inner_metadata: Vec<u8>,
     compressed_buffers: Vec<BufferHandle>,
     uncompressed_sizes: Vec<u64>,
     buffer_alignments: Vec<u32>,
-    children: Vec<ArrayRef>,
-    dtype: DType,
-    len: usize,
-    stats_set: ArrayStats,
+}
+
+impl Display for ZstdBuffersData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "inner_encoding: {}", self.inner_encoding_id)
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -124,7 +207,7 @@ impl ZstdBuffersDecodePlan {
     }
 }
 
-impl ZstdBuffersArray {
+impl ZstdBuffersData {
     fn validate(&self) -> VortexResult<()> {
         vortex_ensure_eq!(
             self.compressed_buffers.len(),
@@ -143,50 +226,6 @@ impl ZstdBuffersArray {
         Ok(())
     }
 
-    /// Compresses the buffers of the given array using ZSTD.
-    ///
-    /// Each buffer of the input array is independently ZSTD-compressed. The children
-    /// and metadata of the input array are preserved as-is.
-    pub fn compress(array: &ArrayRef, level: i32) -> VortexResult<Self> {
-        let encoding_id = array.encoding_id();
-        let metadata = array
-            .metadata()?
-            .ok_or_else(|| vortex_err!("Array does not support serialization"))?;
-        let buffer_handles = array.buffer_handles();
-        let children = array.children();
-
-        let mut compressed_buffers = Vec::with_capacity(buffer_handles.len());
-        let mut uncompressed_sizes = Vec::with_capacity(buffer_handles.len());
-        let mut buffer_alignments = Vec::with_capacity(buffer_handles.len());
-
-        let mut compressor = zstd::bulk::Compressor::new(level)?;
-        // Compression is currently CPU-only, so we gather all buffers on the host.
-        for handle in &buffer_handles {
-            buffer_alignments.push(u32::from(handle.alignment()));
-            let host_buf = handle.clone().try_to_host_sync()?;
-            uncompressed_sizes.push(host_buf.len() as u64);
-            let compressed = compressor.compress(&host_buf)?;
-            compressed_buffers.push(BufferHandle::new_host(ByteBuffer::from(compressed)));
-        }
-
-        let compressed = Self {
-            inner_encoding_id: encoding_id,
-            inner_metadata: metadata,
-            compressed_buffers,
-            uncompressed_sizes,
-            buffer_alignments,
-            children,
-            dtype: array.dtype().clone(),
-            len: array.len(),
-            stats_set: Default::default(),
-        };
-        compressed
-            .stats_set
-            .to_ref(compressed.as_ref())
-            .inherit_from(array.statistics());
-        Ok(compressed)
-    }
-
     fn decompress_buffers(&self) -> VortexResult<Vec<BufferHandle>> {
         // CPU decode path: zstd::bulk works on host bytes, so compressed buffers are
         // materialized on the host via `try_to_host_sync`.
@@ -234,35 +273,6 @@ impl ZstdBuffersArray {
         Ok(result)
     }
 
-    fn decompress_and_build_inner(&self, session: &VortexSession) -> VortexResult<ArrayRef> {
-        let decompressed_buffers = self.decompress_buffers()?;
-        self.build_inner(&decompressed_buffers, session)
-    }
-
-    // This is exposed to help non-CPU executors pass uncompressed buffer handles
-    // to build the inner array.
-    pub fn build_inner(
-        &self,
-        buffer_handles: &[BufferHandle],
-        session: &VortexSession,
-    ) -> VortexResult<ArrayRef> {
-        let registry = session.arrays().registry().clone();
-        let inner_vtable = registry
-            .find(&self.inner_encoding_id)
-            .ok_or_else(|| vortex_err!("Unknown inner encoding: {}", self.inner_encoding_id))?;
-
-        let children = self.children.as_slice();
-        inner_vtable.build(
-            self.inner_encoding_id.clone(),
-            &self.dtype,
-            self.len,
-            &self.inner_metadata,
-            buffer_handles,
-            &children,
-            session,
-        )
-    }
-
     pub fn decode_plan(&self) -> VortexResult<ZstdBuffersDecodePlan> {
         // If invariants are somehow broken, device decompression could have UB, so ensure
         // they still hold.
@@ -326,173 +336,155 @@ fn array_id_from_string(s: &str) -> ArrayId {
     ArrayId::new_arc(Arc::from(s))
 }
 
-impl VTable for ZstdBuffersVTable {
-    type Array = ZstdBuffersArray;
+impl ArrayHash for ZstdBuffersData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.inner_encoding_id.hash(state);
+        self.inner_metadata.hash(state);
+        for buf in &self.compressed_buffers {
+            buf.array_hash(state, precision);
+        }
+        self.uncompressed_sizes.hash(state);
+        self.buffer_alignments.hash(state);
+    }
+}
 
-    type Metadata = ProstMetadata<ZstdBuffersMetadata>;
+impl ArrayEq for ZstdBuffersData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.inner_encoding_id == other.inner_encoding_id
+            && self.inner_metadata == other.inner_metadata
+            && self.compressed_buffers.len() == other.compressed_buffers.len()
+            && self
+                .compressed_buffers
+                .iter()
+                .zip(&other.compressed_buffers)
+                .all(|(a, b)| a.array_eq(b, precision))
+            && self.uncompressed_sizes == other.uncompressed_sizes
+            && self.buffer_alignments == other.buffer_alignments
+    }
+}
 
-    type ArrayVTable = Self;
+impl VTable for ZstdBuffers {
+    type ArrayData = ZstdBuffersData;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &ZstdBuffersArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ZstdBuffersMetadata {
-            inner_encoding_id: array.inner_encoding_id.to_string(),
-            inner_metadata: array.inner_metadata.clone(),
-            uncompressed_sizes: array.uncompressed_sizes.clone(),
-            buffer_alignments: array.buffer_alignments.clone(),
-        }))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        _dtype: &DType,
+        _len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        data.validate()
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.0.encode_to_vec()))
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize {
+        array.compressed_buffers.len()
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        array.compressed_buffers[idx].clone()
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        Some(format!("compressed_{idx}"))
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        format!("child_{idx}")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ZstdBuffersMetadata::decode(bytes)?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            ZstdBuffersMetadata {
+                inner_encoding_id: array.inner_encoding_id.to_string(),
+                inner_metadata: array.inner_metadata.clone(),
+                uncompressed_sizes: array.uncompressed_sizes.clone(),
+                buffer_alignments: array.buffer_alignments.clone(),
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ZstdBuffersArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = ZstdBuffersMetadata::decode(metadata)?;
         let compressed_buffers: Vec<BufferHandle> = buffers.to_vec();
 
-        let child_arrays: Vec<ArrayRef> = (0..children.len())
-            .map(|i| children.get(i, dtype, len))
+        let slots: Vec<Option<ArrayRef>> = (0..children.len())
+            .map(|i| children.get(i, dtype, len).map(Some))
             .collect::<VortexResult<Vec<_>>>()?;
 
-        let array = ZstdBuffersArray {
-            inner_encoding_id: array_id_from_string(&metadata.0.inner_encoding_id),
-            inner_metadata: metadata.0.inner_metadata.clone(),
+        let data = ZstdBuffersData {
+            inner_encoding_id: array_id_from_string(&metadata.inner_encoding_id),
+            inner_metadata: metadata.inner_metadata.clone(),
             compressed_buffers,
-            uncompressed_sizes: metadata.0.uncompressed_sizes.clone(),
-            buffer_alignments: metadata.0.buffer_alignments.clone(),
-            children: child_arrays,
-            dtype: dtype.clone(),
-            len,
-            stats_set: Default::default(),
+            uncompressed_sizes: metadata.uncompressed_sizes.clone(),
+            buffer_alignments: metadata.buffer_alignments.clone(),
         };
 
-        array.validate()?;
-        Ok(array)
+        data.validate()?;
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        array.children = children;
-        Ok(())
-    }
+    // with_slots handles child replacement via the slots mechanism
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let session = ctx.session();
-        let inner_array = array.decompress_and_build_inner(session)?;
-        inner_array.execute::<ArrayRef>(ctx)
+        let inner_array = ZstdBuffers::decompress_and_build_inner(&array, session)?;
+        inner_array
+            .execute::<ArrayRef>(ctx)
+            .map(ExecutionResult::done)
     }
 }
 
-impl BaseArrayVTable<ZstdBuffersVTable> for ZstdBuffersVTable {
-    fn len(array: &ZstdBuffersArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &ZstdBuffersArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ZstdBuffersArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &ZstdBuffersArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.inner_encoding_id.hash(state);
-        array.inner_metadata.hash(state);
-        for buf in &array.compressed_buffers {
-            buf.array_hash(state, precision);
-        }
-        array.uncompressed_sizes.hash(state);
-        array.buffer_alignments.hash(state);
-        array.dtype.hash(state);
-        array.len.hash(state);
-        for child in &array.children {
-            child.array_hash(state, precision);
-        }
-    }
-
-    fn array_eq(array: &ZstdBuffersArray, other: &ZstdBuffersArray, precision: Precision) -> bool {
-        array.inner_encoding_id == other.inner_encoding_id
-            && array.inner_metadata == other.inner_metadata
-            && array.compressed_buffers.len() == other.compressed_buffers.len()
-            && array
-                .compressed_buffers
-                .iter()
-                .zip(&other.compressed_buffers)
-                .all(|(a, b)| a.array_eq(b, precision))
-            && array.uncompressed_sizes == other.uncompressed_sizes
-            && array.buffer_alignments == other.buffer_alignments
-            && array.dtype == other.dtype
-            && array.len == other.len
-            && array.children.len() == other.children.len()
-            && array
-                .children
-                .iter()
-                .zip(&other.children)
-                .all(|(a, b)| a.array_eq(b, precision))
-    }
-}
-
-impl OperationsVTable<ZstdBuffersVTable> for ZstdBuffersVTable {
-    fn scalar_at(array: &ZstdBuffersArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ZstdBuffers> for ZstdBuffers {
+    fn scalar_at(
+        array: ArrayView<'_, ZstdBuffers>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // TODO(os): maybe we should not support scalar_at, it is really slow, and adding a cache
         // layer here is weird. Valid use of zstd buffers array would be by executing it first into
         // canonical
-        let inner_array = array.decompress_and_build_inner(&vortex_array::LEGACY_SESSION)?;
+        let inner_array = ZstdBuffers::decompress_and_build_inner(
+            &array.into_owned(),
+            &vortex_array::LEGACY_SESSION,
+        )?;
         inner_array.scalar_at(index)
     }
 }
 
-impl ValidityVTable<ZstdBuffersVTable> for ZstdBuffersVTable {
-    fn validity(array: &ZstdBuffersArray) -> VortexResult<vortex_array::validity::Validity> {
-        if !array.dtype.is_nullable() {
+impl ValidityVTable<ZstdBuffers> for ZstdBuffers {
+    fn validity(
+        array: ArrayView<'_, ZstdBuffers>,
+    ) -> VortexResult<vortex_array::validity::Validity> {
+        if !array.dtype().is_nullable() {
             return Ok(vortex_array::validity::Validity::NonNullable);
         }
 
-        let inner_array = array.decompress_and_build_inner(&vortex_array::LEGACY_SESSION)?;
+        let inner_array = ZstdBuffers::decompress_and_build_inner(
+            &array.into_owned(),
+            &vortex_array::LEGACY_SESSION,
+        )?;
         inner_array.validity()
     }
 }
 
-impl VisitorVTable<ZstdBuffersVTable> for ZstdBuffersVTable {
-    fn visit_buffers(array: &ZstdBuffersArray, visitor: &mut dyn ArrayBufferVisitor) {
-        for (i, buffer) in array.compressed_buffers.iter().enumerate() {
-            visitor.visit_buffer_handle(&format!("compressed_{i}"), buffer);
-        }
-    }
-
-    fn visit_children(array: &ZstdBuffersArray, visitor: &mut dyn ArrayChildVisitor) {
-        for (i, child) in array.children.iter().enumerate() {
-            visitor.visit_child(&format!("child_{i}"), child);
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
@@ -550,10 +542,10 @@ mod tests {
     #[case::empty_primitive(make_empty_primitive_array())]
     #[case::inlined_varbinview(make_inlined_varbinview_array())]
     fn test_roundtrip(#[case] input: ArrayRef) -> VortexResult<()> {
-        let compressed = ZstdBuffersArray::compress(&input, 3)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?;
 
-        assert_eq!(compressed.len, input.len());
-        assert_eq!(&compressed.dtype, input.dtype());
+        assert_eq!(compressed.len(), input.len());
+        assert_eq!(compressed.dtype(), input.dtype());
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let decompressed = compressed.into_array().execute::<ArrayRef>(&mut ctx)?;
@@ -567,7 +559,7 @@ mod tests {
         let input = make_primitive_array();
         input.statistics().set(Stat::Min, Precision::exact(0i32));
 
-        let compressed = ZstdBuffersArray::compress(&input, 3)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?;
 
         assert!(compressed.statistics().get(Stat::Min).is_some());
         Ok(())
@@ -576,7 +568,7 @@ mod tests {
     #[test]
     fn test_validity_delegates_for_nullable_input() -> VortexResult<()> {
         let input = make_nullable_primitive_array();
-        let compressed = ZstdBuffersArray::compress(&input, 3)?.into_array();
+        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?.into_array();
 
         assert_eq!(compressed.all_valid()?, input.all_valid()?);
         assert_eq!(compressed.all_invalid()?, input.all_invalid()?);
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index b81635bdf5d..e2d05b706f9 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -36,6 +36,7 @@ vortex-array = { workspace = true, features = ["arbitrary", "_test-harness"] }
 vortex-btrblocks = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-error = { workspace = true }
+vortex-fsst = { workspace = true }
 vortex-io = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-runend = { workspace = true, features = ["arbitrary"] }
@@ -50,6 +51,9 @@ vortex-file = { workspace = true, optional = true }
 tokio = { workspace = true, features = ["rt", "macros"], optional = true }
 vortex-cuda = { workspace = true, optional = true }
 
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+
 [lints]
 workspace = true
 
@@ -85,6 +89,14 @@ path = "fuzz_targets/compress_roundtrip.rs"
 test = false
 required-features = ["native"]
 
+[[bin]]
+bench = false
+doc = false
+name = "fsst_like"
+path = "fuzz_targets/fsst_like.rs"
+test = false
+required-features = ["native"]
+
 [[bin]]
 bench = false
 doc = false
diff --git a/fuzz/fuzz_targets/array_ops.rs b/fuzz/fuzz_targets/array_ops.rs
index e474df342b2..dded332b64c 100644
--- a/fuzz/fuzz_targets/array_ops.rs
+++ b/fuzz/fuzz_targets/array_ops.rs
@@ -4,18 +4,32 @@
 #![no_main]
 #![allow(clippy::unwrap_used, clippy::result_large_err)]
 
+use std::str::FromStr;
+
 use libfuzzer_sys::Corpus;
 use libfuzzer_sys::fuzz_target;
+use tracing::level_filters::LevelFilter;
 use vortex_error::vortex_panic;
 use vortex_fuzz::FuzzArrayAction;
 use vortex_fuzz::run_fuzz_action;
 
-fuzz_target!(|fuzz_action: FuzzArrayAction| -> Corpus {
+fuzz_target!(
+    init: {
+        let fmt = tracing_subscriber::fmt::format()
+            .with_ansi(false) // Colour output is messed up in raw logs
+            .without_time() // We run fuzzer in CI which prepends timestamps
+            .compact();
+        let level = std::env::var("RUST_LOG").map(
+            |v| LevelFilter::from_str(v.as_str()).unwrap()).unwrap_or(LevelFilter::INFO);
+        tracing_subscriber::fmt()
+            .event_format(fmt)
+            .with_max_level(level)
+            .init();
+    },
+    |fuzz_action: FuzzArrayAction| -> Corpus {
     match run_fuzz_action(fuzz_action) {
         Ok(true) => Corpus::Keep,
         Ok(false) => Corpus::Reject,
-        Err(e) => {
-            vortex_panic!("{e}");
-        }
+        Err(e) => vortex_panic!("{e}"),
     }
 });
diff --git a/fuzz/fuzz_targets/file_io.rs b/fuzz/fuzz_targets/file_io.rs
index 518ac323086..7d728905148 100644
--- a/fuzz/fuzz_targets/file_io.rs
+++ b/fuzz/fuzz_targets/file_io.rs
@@ -7,17 +7,18 @@
 use itertools::Itertools;
 use libfuzzer_sys::Corpus;
 use libfuzzer_sys::fuzz_target;
-use vortex_array::Array;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::ChunkedArray;
+use vortex_array::arrays::bool::BoolArrayExt;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::StructFields;
 use vortex_array::expr::lit;
 use vortex_array::expr::root;
 use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_btrblocks::BtrBlocksCompressorBuilder;
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
@@ -46,6 +47,7 @@ fuzz_target!(|fuzz: FuzzFileAction| -> Corpus {
 
     let expected_array = {
         let bool_mask = array_data
+            .clone()
             .apply(&filter_expr.clone().unwrap_or_else(|| lit(true)))
             .vortex_expect("filter expression evaluation should succeed in fuzz test");
         let mask = bool_mask.to_bool().to_mask_fill_null_false();
@@ -59,12 +61,11 @@ fuzz_target!(|fuzz: FuzzFileAction| -> Corpus {
 
     let write_options = match compressor_strategy {
         CompressorStrategy::Default => SESSION.write_options(),
-        CompressorStrategy::Compact => {
-            let strategy = WriteStrategyBuilder::default()
-                .with_compact_encodings()
-                .build();
-            SESSION.write_options().with_strategy(strategy)
-        }
+        CompressorStrategy::Compact => SESSION.write_options().with_strategy(
+            WriteStrategyBuilder::default()
+                .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
+                .build(),
+        ),
     };
 
     let mut full_buff = ByteBufferMut::empty();
@@ -113,7 +114,10 @@ fuzz_target!(|fuzz: FuzzFileAction| -> Corpus {
         .to_bool();
     let true_count = bool_result.to_bit_buffer().true_count();
     if true_count != expected_array.len()
-        && (bool_result.all_valid().vortex_expect("all_valid")
+        && (bool_result
+            .into_array()
+            .all_valid()
+            .vortex_expect("all_valid")
             || expected_array.all_valid().vortex_expect("all_valid"))
     {
         vortex_panic!(
diff --git a/fuzz/fuzz_targets/fsst_like.rs b/fuzz/fuzz_targets/fsst_like.rs
new file mode 100644
index 00000000000..8e03badff00
--- /dev/null
+++ b/fuzz/fuzz_targets/fsst_like.rs
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![no_main]
+#![allow(clippy::unwrap_used, clippy::result_large_err)]
+
+use std::str::FromStr;
+
+use libfuzzer_sys::Corpus;
+use libfuzzer_sys::fuzz_target;
+use tracing::level_filters::LevelFilter;
+use vortex_error::vortex_panic;
+use vortex_fuzz::FuzzFsstLike;
+use vortex_fuzz::run_fsst_like_fuzz;
+
+fuzz_target!(
+    init: {
+        let fmt = tracing_subscriber::fmt::format()
+            .with_ansi(false)
+            .without_time()
+            .compact();
+        let level = std::env::var("RUST_LOG").map(
+            |v| LevelFilter::from_str(v.as_str()).unwrap()).unwrap_or(LevelFilter::INFO);
+        tracing_subscriber::fmt()
+            .event_format(fmt)
+            .with_max_level(level)
+            .init();
+    },
+    |fuzz_action: FuzzFsstLike| -> Corpus {
+    match run_fsst_like_fuzz(fuzz_action) {
+        Ok(true) => Corpus::Keep,
+        Ok(false) => Corpus::Reject,
+        Err(e) => vortex_panic!("{e}"),
+    }
+});
diff --git a/fuzz/src/array/cast.rs b/fuzz/src/array/cast.rs
index afa54b6f076..a6112bec0ff 100644
--- a/fuzz/src/array/cast.rs
+++ b/fuzz/src/array/cast.rs
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::DType;
@@ -42,7 +42,7 @@ pub fn cast_canonical_array(array: &ArrayRef, target: &DType) -> VortexResult<Op
                             .collect::<Buffer<Out>>(),
                         Validity::from_mask(array.validity_mask()?, target.nullability()),
                     )
-                    .to_array()
+                    .into_array()
                 })
             }
         )))
@@ -68,7 +68,7 @@ pub fn cast_canonical_array(array: &ArrayRef, target: &DType) -> VortexResult<Op
                         .collect::<Buffer<f64>>(),
                     Validity::from_mask(array.validity_mask()?, target.nullability()),
                 )
-                .to_array(),
+                .into_array(),
             )),
             (PType::F64, PType::F32) =>
             {
@@ -83,7 +83,7 @@ pub fn cast_canonical_array(array: &ArrayRef, target: &DType) -> VortexResult<Op
                             .collect::<Buffer<f32>>(),
                         Validity::from_mask(array.validity_mask()?, target.nullability()),
                     )
-                    .to_array(),
+                    .into_array(),
                 ))
             }
             _ => Ok(None),
diff --git a/fuzz/src/array/compare.rs b/fuzz/src/array/compare.rs
index dcc53d11d9b..e6d069d47b1 100644
--- a/fuzz/src/array/compare.rs
+++ b/fuzz/src/array/compare.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::accessor::ArrayAccessor;
 use vortex_array::arrays::BoolArray;
-use vortex_array::arrays::NativeValue;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::primitive::NativeValue;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::match_each_decimal_value_type;
@@ -21,7 +21,7 @@ use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
 
 pub fn compare_canonical_array(
-    array: &dyn Array,
+    array: &ArrayRef,
     value: &Scalar,
     operator: CompareOperator,
 ) -> ArrayRef {
@@ -134,14 +134,15 @@ pub fn compare_canonical_array(
             let scalar_vals: Vec<Scalar> = (0..array.len())
                 .map(|i| array.scalar_at(i).vortex_expect("scalar_at"))
                 .collect();
-            BoolArray::from_iter(
-                scalar_vals
-                    .iter()
-                    .map(|v| scalar_cmp(v, value, operator).as_bool().value()),
-            )
+            BoolArray::from_iter(scalar_vals.iter().map(|v| {
+                scalar_cmp(v, value, operator)
+                    .vortex_expect("tried to compare different typed scalars")
+                    .as_bool()
+                    .value()
+            }))
             .into_array()
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/array/fill_null.rs b/fuzz/src/array/fill_null.rs
index 1e9319963d6..21430ce2b4d 100644
--- a/fuzz/src/array/fill_null.rs
+++ b/fuzz/src/array/fill_null.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
@@ -10,6 +12,7 @@ use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
@@ -17,7 +20,6 @@ use vortex_array::match_each_decimal_value_type;
 use vortex_array::match_each_native_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
@@ -34,21 +36,22 @@ pub fn fill_null_canonical_array(
 
     Ok(match canonical {
         Canonical::Null(array) => ConstantArray::new(fill_value.clone(), array.len()).into_array(),
-        Canonical::Bool(array) => fill_bool_array(&array, fill_value, result_nullability),
-        Canonical::Primitive(array) => fill_primitive_array(&array, fill_value, result_nullability),
-        Canonical::Decimal(array) => fill_decimal_array(&array, fill_value, result_nullability),
+        Canonical::Bool(array) => fill_bool_array(array, fill_value, result_nullability),
+        Canonical::Primitive(array) => fill_primitive_array(array, fill_value, result_nullability),
+        Canonical::Decimal(array) => fill_decimal_array(array, fill_value, result_nullability),
         Canonical::VarBinView(array) => {
-            fill_varbinview_array(&array, fill_value, result_nullability)
+            fill_varbinview_array(array, fill_value, result_nullability)
         }
         Canonical::Struct(_)
         | Canonical::List(_)
         | Canonical::FixedSizeList(_)
         | Canonical::Extension(_) => canonical.into_array().fill_null(fill_value.clone())?,
+        Canonical::Variant(_) => unreachable!("Variant arrays are not fuzzed"),
     })
 }
 
 fn fill_bool_array(
-    array: &BoolArray,
+    array: BoolArray,
     fill_value: &Scalar,
     result_nullability: Nullability,
 ) -> ArrayRef {
@@ -57,30 +60,42 @@ fn fill_bool_array(
         .value()
         .vortex_expect("cannot have null fill value");
 
-    match array.validity() {
+    match array
+        .validity()
+        .vortex_expect("bool validity should be derivable in fuzz baseline")
+    {
         Validity::NonNullable | Validity::AllValid => {
-            BoolArray::new(array.to_bit_buffer(), result_nullability.into()).into_array()
+            BoolArray::new(array.into_bit_buffer(), result_nullability.into()).into_array()
         }
         Validity::AllInvalid => ConstantArray::new(fill_value.clone(), array.len()).into_array(),
         Validity::Array(validity_array) => {
-            let validity_bool_array = validity_array.to_bool();
-            let validity_bits = validity_bool_array.to_bit_buffer();
-            let data_bits = array.to_bit_buffer();
-
-            let mut new_bits = data_bits.into_mut();
-
-            (!validity_bits)
-                .set_indices()
-                .for_each(|i| new_bits.set_to(i, fill_bool));
+            let validity_bits = validity_array.to_bool().into_bit_buffer();
+            let data_bits = array.into_bit_buffer();
+
+            let new_bits = match data_bits.try_into_mut() {
+                Ok(mut buf) => {
+                    (!validity_bits)
+                        .set_indices()
+                        .for_each(|i| buf.set_to(i, fill_bool));
+                    buf.freeze()
+                }
+                Err(data_bits) => {
+                    if fill_bool {
+                        data_bits | !validity_bits
+                    } else {
+                        data_bits & validity_bits
+                    }
+                }
+            };
 
-            BoolArray::new(new_bits.freeze(), result_nullability.into()).into_array()
+            BoolArray::new(new_bits, result_nullability.into()).into_array()
         }
     }
 }
 
 #[expect(clippy::cognitive_complexity)]
 fn fill_primitive_array(
-    array: &PrimitiveArray,
+    array: PrimitiveArray,
     fill_value: &Scalar,
     result_nullability: Nullability,
 ) -> ArrayRef {
@@ -88,7 +103,10 @@ fn fill_primitive_array(
         let fill_val = T::try_from(fill_value)
             .vortex_expect("fill value conversion should succeed in fuzz test");
 
-        match array.validity() {
+        match array
+            .validity()
+            .vortex_expect("primitive validity should be derivable in fuzz baseline")
+        {
             Validity::NonNullable | Validity::AllValid => {
                 PrimitiveArray::new(array.to_buffer::<T>(), result_nullability.into()).into_array()
             }
@@ -117,7 +135,7 @@ fn fill_primitive_array(
 }
 
 fn fill_decimal_array(
-    array: &DecimalArray,
+    array: DecimalArray,
     fill_value: &Scalar,
     result_nullability: Nullability,
 ) -> ArrayRef {
@@ -128,7 +146,10 @@ fn fill_decimal_array(
         let fill_val = D::try_from(decimal_scalar)
             .vortex_expect("decimal fill value conversion should succeed in fuzz test");
 
-        match array.validity() {
+        match array
+            .validity()
+            .vortex_expect("decimal validity should be derivable in fuzz baseline")
+        {
             Validity::NonNullable | Validity::AllValid => DecimalArray::new(
                 array.buffer::<D>(),
                 decimal_dtype,
@@ -161,12 +182,16 @@ fn fill_decimal_array(
 }
 
 fn fill_varbinview_array(
-    array: &VarBinViewArray,
+    array: VarBinViewArray,
     fill_value: &Scalar,
     result_nullability: Nullability,
 ) -> ArrayRef {
-    match array.validity() {
-        Validity::NonNullable | Validity::AllValid => array.clone().into_array(),
+    let array_ref = array.clone().into_array();
+    match array
+        .validity()
+        .vortex_expect("varbinview validity should be derivable in fuzz baseline")
+    {
+        Validity::NonNullable | Validity::AllValid => array.into_array(),
         Validity::AllInvalid => ConstantArray::new(fill_value.clone(), array.len()).into_array(),
         Validity::Array(validity_array) => {
             let validity_bool_array = validity_array.to_bool();
@@ -181,7 +206,7 @@ fn fill_varbinview_array(
                     let strings: Vec<String> = (0..array.len())
                         .map(|i| {
                             if validity_bits.value(i) {
-                                array
+                                array_ref
                                     .scalar_at(i)
                                     .vortex_expect("scalar_at")
                                     .as_utf8()
@@ -198,7 +223,7 @@ fn fill_varbinview_array(
                     if result_nullability == Nullability::Nullable {
                         VarBinViewArray::new_handle(
                             result.to_varbinview().views_handle().clone(),
-                            result.to_varbinview().buffers().clone(),
+                            Arc::clone(result.to_varbinview().data_buffers()),
                             result.dtype().as_nullable(),
                             result_nullability.into(),
                         )
@@ -215,7 +240,7 @@ fn fill_varbinview_array(
                     let binaries: Vec<Vec<u8>> = (0..array.len())
                         .map(|i| {
                             if validity_bits.value(i) {
-                                array
+                                array_ref
                                     .scalar_at(i)
                                     .vortex_expect("scalar_at")
                                     .as_binary()
@@ -232,7 +257,7 @@ fn fill_varbinview_array(
                     if result_nullability == Nullability::Nullable {
                         VarBinViewArray::new_handle(
                             result.to_varbinview().views_handle().clone(),
-                            result.to_varbinview().buffers().clone(),
+                            Arc::clone(result.to_varbinview().data_buffers()),
                             result.dtype().as_nullable(),
                             result_nullability.into(),
                         )
@@ -249,7 +274,6 @@ fn fill_varbinview_array(
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::DecimalArray;
diff --git a/fuzz/src/array/filter.rs b/fuzz/src/array/filter.rs
index 563ba67f0db..fbcc2856e61 100644
--- a/fuzz/src/array/filter.rs
+++ b/fuzz/src/array/filter.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -11,6 +10,8 @@ use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_decimal_value_type;
 use vortex_array::match_each_native_ptype;
@@ -21,7 +22,7 @@ use vortex_error::VortexResult;
 
 use crate::array::take_canonical_array_non_nullable_indices;
 
-pub fn filter_canonical_array(array: &dyn Array, filter: &[bool]) -> VortexResult<ArrayRef> {
+pub fn filter_canonical_array(array: &ArrayRef, filter: &[bool]) -> VortexResult<ArrayRef> {
     let validity = if array.dtype().is_nullable() {
         let validity_buff = array.validity_mask()?.to_bit_buffer();
         Validity::from_iter(
@@ -93,8 +94,7 @@ pub fn filter_canonical_array(array: &dyn Array, filter: &[bool]) -> VortexResul
         DType::Struct(..) => {
             let struct_array = array.to_struct();
             let filtered_children = struct_array
-                .unmasked_fields()
-                .iter()
+                .iter_unmasked_fields()
                 .map(|c| filter_canonical_array(c, filter))
                 .collect::<VortexResult<Vec<_>>>()?;
 
@@ -115,7 +115,7 @@ pub fn filter_canonical_array(array: &dyn Array, filter: &[bool]) -> VortexResul
             }
             take_canonical_array_non_nullable_indices(array, indices.as_slice())
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/array/mask.rs b/fuzz/src/array/mask.rs
index 5d0fd87e605..4c97200fa2d 100644
--- a/fuzz/src/array/mask.rs
+++ b/fuzz/src/array/mask.rs
@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use std::sync::Arc;
+
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
@@ -14,37 +15,44 @@ use vortex_array::arrays::ListViewArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::Nullability;
 use vortex_array::match_each_decimal_value_type;
 use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 
-/// Set to false any entries for which the mask is true.
-///
+/// Apply a logical AND of a validity and a mask.
+/// This needs to be coherent with applications of Mask.
 /// The result is always nullable. The result has the same length as self.
 #[inline]
 pub fn mask_validity(validity: &Validity, mask: &Mask) -> Validity {
-    match mask.bit_buffer() {
-        AllOr::All => Validity::AllInvalid,
-        AllOr::None => validity.clone().into_nullable(),
-        AllOr::Some(make_invalid) => match validity {
+    let out = match mask.bit_buffer() {
+        AllOr::All => validity.clone().into_nullable(),
+        AllOr::None => Validity::AllInvalid,
+        AllOr::Some(make_valid) => match validity {
+            Validity::AllInvalid => Validity::AllInvalid,
             Validity::NonNullable | Validity::AllValid => {
-                Validity::from_bit_buffer(!make_invalid, Nullability::Nullable)
+                Validity::from_bit_buffer(make_valid.clone(), Nullability::Nullable)
             }
-            Validity::AllInvalid => Validity::AllInvalid,
             Validity::Array(is_valid) => {
                 let is_valid = is_valid.to_bool();
                 Validity::from_bit_buffer(
-                    is_valid.to_bit_buffer() & !make_invalid,
+                    is_valid.to_bit_buffer() & make_valid,
                     Nullability::Nullable,
                 )
             }
         },
-    }
+    };
+
+    tracing::debug!(validity = ?validity, mask = ?mask, out = ?out, "generated fuzzer mask");
+    out
 }
 
 /// Apply mask on the canonical form of the array to get a consistent baseline.
@@ -57,11 +65,11 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
             array.into_array()
         }
         Canonical::Bool(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             BoolArray::new(array.to_bit_buffer(), new_validity).into_array()
         }
         Canonical::Primitive(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             PrimitiveArray::from_buffer_handle(
                 array.buffer_handle().clone(),
                 array.ptype(),
@@ -70,24 +78,24 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
             .into_array()
         }
         Canonical::Decimal(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             match_each_decimal_value_type!(array.values_type(), |D| {
                 DecimalArray::new(array.buffer::<D>(), array.decimal_dtype(), new_validity)
                     .into_array()
             })
         }
         Canonical::VarBinView(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             VarBinViewArray::new_handle(
                 array.views_handle().clone(),
-                array.buffers().clone(),
+                Arc::clone(array.data_buffers()),
                 array.dtype().with_nullability(new_validity.nullability()),
                 new_validity,
             )
             .into_array()
         }
         Canonical::List(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
 
             // SAFETY: Since we are only masking the validity and everything else comes from an
             // already valid `ListViewArray`, all of the invariants are still upheld.
@@ -103,7 +111,7 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
             .into_array()
         }
         Canonical::FixedSizeList(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             FixedSizeListArray::new(
                 array.elements().clone(),
                 array.list_size(),
@@ -113,9 +121,9 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
             .into_array()
         }
         Canonical::Struct(array) => {
-            let new_validity = mask_validity(array.validity(), mask);
+            let new_validity = mask_validity(&array.validity()?, mask);
             StructArray::try_new_with_dtype(
-                array.unmasked_fields().clone(),
+                array.unmasked_fields(),
                 array.struct_fields().clone(),
                 array.len(),
                 new_validity,
@@ -125,7 +133,7 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
         }
         Canonical::Extension(array) => {
             // Recursively mask the storage array
-            let masked_storage = mask_canonical_array(array.storage().to_canonical()?, mask)
+            let masked_storage = mask_canonical_array(array.storage_array().to_canonical()?, mask)
                 .vortex_expect("mask_canonical_array should succeed in fuzz test");
 
             let ext_dtype = array
@@ -133,12 +141,12 @@ pub fn mask_canonical_array(canonical: Canonical, mask: &Mask) -> VortexResult<A
                 .with_nullability(masked_storage.dtype().nullability());
             ExtensionArray::new(ext_dtype, masked_storage).into_array()
         }
+        Canonical::Variant(_) => unreachable!("Variant arrays are not fuzzed"),
     })
 }
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::Array;
     use vortex_array::IntoArray;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::DecimalArray;
@@ -173,7 +181,7 @@ mod tests {
     #[test]
     fn test_mask_bool_array() {
         let array = BoolArray::from_iter([true, false, true, false, true]);
-        let mask = Mask::from_iter([true, false, false, true, false]);
+        let mask = Mask::from_iter([false, true, true, false, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -184,7 +192,7 @@ mod tests {
     #[test]
     fn test_mask_primitive_array() {
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
-        let mask = Mask::from_iter([false, true, false, true, false]);
+        let mask = Mask::from_iter([true, false, true, false, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -195,7 +203,7 @@ mod tests {
     #[test]
     fn test_mask_primitive_array_with_nulls() {
         let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]);
-        let mask = Mask::from_iter([true, false, false, true, false]);
+        let mask = Mask::from_iter([false, true, true, false, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -210,7 +218,7 @@ mod tests {
             [Some(1i128), Some(2), Some(3), Some(4), Some(5)],
             dtype,
         );
-        let mask = Mask::from_iter([false, false, true, false, false]);
+        let mask = Mask::from_iter([true, true, false, true, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -222,7 +230,7 @@ mod tests {
     #[test]
     fn test_mask_varbinview_array() {
         let array = VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]);
-        let mask = Mask::from_iter([true, false, true, false, true]);
+        let mask = Mask::from_iter([false, true, false, true, false]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -241,7 +249,7 @@ mod tests {
                 .with_zero_copy_to_list(true)
         };
 
-        let mask = Mask::from_iter([false, true, false]);
+        let mask = Mask::from_iter([true, false, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -257,7 +265,7 @@ mod tests {
         let array =
             FixedSizeListArray::try_new(elements, 2, Nullability::NonNullable.into(), 3).unwrap();
 
-        let mask = Mask::from_iter([true, false, true]);
+        let mask = Mask::from_iter([false, true, false]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -281,7 +289,7 @@ mod tests {
         )
         .unwrap();
 
-        let mask = Mask::from_iter([false, true, false]);
+        let mask = Mask::from_iter([true, false, true]);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -292,9 +300,9 @@ mod tests {
     }
 
     #[test]
-    fn test_mask_all_true() {
+    fn test_mask_all_false() {
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
-        let mask = Mask::AllTrue(5);
+        let mask = Mask::AllFalse(5);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -303,9 +311,9 @@ mod tests {
     }
 
     #[test]
-    fn test_mask_all_false() {
+    fn test_mask_all_true() {
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
-        let mask = Mask::AllFalse(5);
+        let mask = Mask::AllTrue(5);
 
         let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
 
@@ -317,10 +325,9 @@ mod tests {
     #[test]
     fn test_mask_empty_array() {
         let array = PrimitiveArray::from_iter(Vec::<i32>::new());
-        let mask = Mask::AllFalse(0);
-
-        let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
-
-        assert_eq!(result.len(), 0);
+        for mask in [Mask::AllFalse(0), Mask::AllTrue(0)] {
+            let result = mask_canonical_array(array.to_canonical().unwrap(), &mask).unwrap();
+            assert_eq!(result.len(), 0);
+        }
     }
 }
diff --git a/fuzz/src/array/min_max.rs b/fuzz/src/array/min_max.rs
index 0280a1d6c9c..5600fe27568 100644
--- a/fuzz/src/array/min_max.rs
+++ b/fuzz/src/array/min_max.rs
@@ -2,12 +2,16 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::Canonical;
-use vortex_array::compute::MinMaxResult;
-use vortex_array::compute::min_max;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray as _;
+use vortex_array::aggregate_fn::fns::min_max::MinMaxResult;
+use vortex_array::aggregate_fn::fns::min_max::min_max;
 use vortex_error::VortexResult;
 
 /// Compute min_max on the canonical form of the array to get a consistent baseline.
-pub fn min_max_canonical_array(canonical: Canonical) -> VortexResult<Option<MinMaxResult>> {
-    // TODO(joe): replace with baseline not using canonical
-    min_max(canonical.as_ref())
+pub fn min_max_canonical_array(
+    canonical: Canonical,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Option<MinMaxResult>> {
+    min_max(&canonical.into_array(), ctx)
 }
diff --git a/fuzz/src/array/mod.rs b/fuzz/src/array/mod.rs
index 3c051aff1bc..b0dd2c2b242 100644
--- a/fuzz/src/array/mod.rs
+++ b/fuzz/src/array/mod.rs
@@ -1,6 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+pub(crate) use cast::*;
+pub(crate) use compare::*;
+pub(crate) use fill_null::*;
+pub(crate) use filter::*;
+pub(crate) use mask::*;
+pub(crate) use min_max::*;
+pub(crate) use scalar_at::*;
+pub(crate) use search_sorted::*;
+pub(crate) use slice::*;
+pub use sort::sort_canonical_array;
+pub(crate) use sum::*;
+pub(crate) use take::*;
+
 mod cast;
 mod compare;
 mod fill_null;
@@ -20,42 +33,44 @@ use std::ops::Range;
 use arbitrary::Arbitrary;
 use arbitrary::Error::EmptyChoose;
 use arbitrary::Unstructured;
-pub(crate) use cast::*;
-pub(crate) use compare::*;
-pub(crate) use fill_null::*;
-pub(crate) use filter::*;
 use itertools::Itertools;
-pub(crate) use mask::*;
-pub(crate) use min_max::*;
-pub(crate) use scalar_at::*;
-pub(crate) use search_sorted::*;
-pub(crate) use slice::*;
-pub use sort::sort_canonical_array;
 use strum::EnumCount;
 use strum::EnumDiscriminants;
 use strum::EnumIter;
 use strum::IntoEnumIterator;
-pub(crate) use sum::*;
-pub(crate) use take::*;
-use vortex_array::Array;
+use tracing::debug;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::aggregate_fn::fns::min_max::MinMaxResult;
+use vortex_array::aggregate_fn::fns::min_max::min_max;
+use vortex_array::aggregate_fn::fns::sum::sum;
+use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::arbitrary::ArbitraryArray;
-use vortex_array::compute::MinMaxResult;
+use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::arbitrary::random_scalar;
 use vortex_array::scalar_fn::fns::operators::CompareOperator;
+use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_array::search_sorted::SearchResult;
+use vortex_array::search_sorted::SearchSorted;
 use vortex_array::search_sorted::SearchSortedSide;
 use vortex_btrblocks::BtrBlocksCompressor;
+#[cfg(feature = "zstd")]
+use vortex_btrblocks::BtrBlocksCompressorBuilder;
 use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 use vortex_utils::aliases::hash_set::HashSet;
 
+use crate::SESSION;
+use crate::error::Backtrace;
+use crate::error::VortexFuzzError;
+use crate::error::VortexFuzzResult;
+
 #[derive(Debug)]
 pub struct FuzzArrayAction {
     pub array: ArrayRef,
@@ -155,7 +170,9 @@ impl ExpectedValue {
 impl<'a> Arbitrary<'a> for FuzzArrayAction {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let array = ArbitraryArray::arbitrary(u)?.0;
-        let mut current_array = array.to_array();
+        let mut current_array = array.clone();
+
+        let mut ctx = SESSION.create_execution_ctx();
 
         let mut valid_actions = actions_for_dtype(current_array.dtype())
             .into_iter()
@@ -179,7 +196,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                     let strategy = CompressorStrategy::arbitrary(u)?;
                     (
                         Action::Compress(strategy),
-                        ExpectedValue::Array(current_array.to_array()),
+                        ExpectedValue::Array(current_array.clone()),
                     )
                 }
                 ActionType::Slice => {
@@ -190,7 +207,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
 
                     (
                         Action::Slice(start..stop),
-                        ExpectedValue::Array(current_array.to_array()),
+                        ExpectedValue::Array(current_array.clone()),
                     )
                 }
                 ActionType::Take => {
@@ -223,7 +240,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                         .vortex_expect("BtrBlocksCompressor compress should succeed in fuzz test");
                     (
                         Action::Take(compressed),
-                        ExpectedValue::Array(current_array.to_array()),
+                        ExpectedValue::Array(current_array.clone()),
                     )
                 }
                 ActionType::SearchSorted => {
@@ -268,7 +285,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                         .vortex_expect("filter_canonical_array should succeed in fuzz test");
                     (
                         Action::Filter(Mask::from_iter(mask)),
-                        ExpectedValue::Array(current_array.to_array()),
+                        ExpectedValue::Array(current_array.clone()),
                     )
                 }
                 ActionType::Compare => {
@@ -286,7 +303,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                     current_array = compare_canonical_array(&current_array, &scalar, op);
                     (
                         Action::Compare(scalar, op),
-                        ExpectedValue::Array(current_array.to_array()),
+                        ExpectedValue::Array(current_array.clone()),
                     )
                 }
                 ActionType::Cast => {
@@ -314,6 +331,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                         current_array
                             .to_canonical()
                             .vortex_expect("to_canonical should succeed in fuzz test"),
+                        &mut ctx,
                     )
                     .vortex_expect("sum_canonical_array should succeed in fuzz test");
                     (Action::Sum, ExpectedValue::Scalar(sum_result))
@@ -324,6 +342,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                         current_array
                             .to_canonical()
                             .vortex_expect("to_canonical should succeed in fuzz test"),
+                        &mut ctx,
                     )
                     .vortex_expect("min_max_canonical_array should succeed in fuzz test");
                     (Action::MinMax, ExpectedValue::MinMax(min_max_result))
@@ -487,6 +506,8 @@ fn actions_for_dtype(dtype: &DType) -> HashSet<ActionType> {
             // Extension types delegate to storage dtype, support most operations
             ActionType::iter().collect()
         }
+        // Currently, no support at all
+        DType::Variant(_) => unreachable!("Variant dtype shouldn't be fuzzed"),
     }
 }
 
@@ -516,20 +537,13 @@ fn random_action_from_list(
 
 /// Compress an array using the given strategy.
 #[cfg(feature = "zstd")]
-pub fn compress_array(array: &dyn Array, strategy: CompressorStrategy) -> ArrayRef {
-    use vortex_btrblocks::BtrBlocksCompressorBuilder;
-    use vortex_btrblocks::FloatCode;
-    use vortex_btrblocks::IntCode;
-    use vortex_btrblocks::StringCode;
-
+pub fn compress_array(array: &ArrayRef, strategy: CompressorStrategy) -> ArrayRef {
     match strategy {
         CompressorStrategy::Default => BtrBlocksCompressor::default()
             .compress(array)
             .vortex_expect("BtrBlocksCompressor compress should succeed in fuzz test"),
         CompressorStrategy::Compact => BtrBlocksCompressorBuilder::default()
-            .include_string([StringCode::Zstd])
-            .include_int([IntCode::Pco])
-            .include_float([FloatCode::Pco])
+            .with_compact()
             .build()
             .compress(array)
             .vortex_expect("Compact compress should succeed in fuzz test"),
@@ -538,7 +552,7 @@ pub fn compress_array(array: &dyn Array, strategy: CompressorStrategy) -> ArrayR
 
 /// Compress an array using the given strategy (only Default).
 #[cfg(not(feature = "zstd"))]
-pub fn compress_array(array: &dyn Array, _strategy: CompressorStrategy) -> ArrayRef {
+pub fn compress_array(array: &ArrayRef, _strategy: CompressorStrategy) -> ArrayRef {
     BtrBlocksCompressor::default()
         .compress(array)
         .vortex_expect("BtrBlocksCompressor compress should succeed in fuzz test")
@@ -551,22 +565,26 @@ pub fn compress_array(array: &dyn Array, _strategy: CompressorStrategy) -> Array
 /// - `Ok(false)` - reject from corpus
 /// - `Err(_)` - a bug was found
 #[allow(clippy::result_large_err)]
-pub fn run_fuzz_action(fuzz_action: FuzzArrayAction) -> crate::error::VortexFuzzResult<bool> {
-    use vortex_array::arrays::ConstantArray;
-    use vortex_array::builtins::ArrayBuiltins;
-    use vortex_array::compute::min_max;
-    use vortex_array::compute::sum;
-    use vortex_array::scalar_fn::fns::operators::Operator;
+pub fn run_fuzz_action(fuzz_action: FuzzArrayAction) -> VortexFuzzResult<bool> {
     let FuzzArrayAction { array, actions } = fuzz_action;
-    let mut current_array = array.to_array();
+    let mut current_array = array;
+
+    let mut ctx = SESSION.create_execution_ctx();
+
+    debug!(
+        "Initial array:\nTree:\n{}Values:\n{:#}",
+        current_array.display_tree(),
+        current_array.display_values()
+    );
 
     for (i, (action, expected)) in actions.into_iter().enumerate() {
+        debug!(id = i, action = ?action);
         match action {
             Action::Compress(strategy) => {
                 let canonical = current_array
                     .to_canonical()
                     .vortex_expect("to_canonical should succeed in fuzz test");
-                current_array = compress_array(canonical.as_ref(), strategy);
+                current_array = compress_array(&canonical.into_array(), strategy);
                 assert_array_eq(&expected.array(), &current_array, i)?;
             }
             Action::Slice(range) => {
@@ -627,12 +645,12 @@ pub fn run_fuzz_action(fuzz_action: FuzzArrayAction) -> crate::error::VortexFuzz
                 current_array = cast_result;
             }
             Action::Sum => {
-                let sum_result =
-                    sum(&current_array).vortex_expect("sum operation should succeed in fuzz test");
+                let sum_result = sum(&current_array, &mut ctx)
+                    .vortex_expect("sum operation should succeed in fuzz test");
                 assert_scalar_eq(&expected.scalar(), &sum_result, i)?;
             }
             Action::MinMax => {
-                let min_max_result = min_max(&current_array)
+                let min_max_result = min_max(&current_array, &mut ctx)
                     .vortex_expect("min_max operation should succeed in fuzz test");
                 assert_min_max_eq(&expected.min_max(), &min_max_result, i)?;
             }
@@ -667,12 +685,7 @@ fn assert_search_sorted(
     side: SearchSortedSide,
     expected: SearchResult,
     step: usize,
-) -> crate::error::VortexFuzzResult<()> {
-    use vortex_array::search_sorted::SearchSorted;
-
-    use crate::error::Backtrace;
-    use crate::error::VortexFuzzError;
-
+) -> VortexFuzzResult<()> {
     let search_result = array
         .search_sorted(&s, side)
         .map_err(|e| VortexFuzzError::VortexError(e, Backtrace::capture()))?;
@@ -680,7 +693,7 @@ fn assert_search_sorted(
         Err(VortexFuzzError::SearchSortedError(
             s,
             expected,
-            array.to_array(),
+            array,
             side,
             search_result,
             step,
@@ -693,14 +706,7 @@ fn assert_search_sorted(
 
 /// Assert two arrays are equal.
 #[allow(clippy::result_large_err)]
-pub fn assert_array_eq(
-    lhs: &ArrayRef,
-    rhs: &ArrayRef,
-    step: usize,
-) -> crate::error::VortexFuzzResult<()> {
-    use crate::error::Backtrace;
-    use crate::error::VortexFuzzError;
-
+pub fn assert_array_eq(lhs: &ArrayRef, rhs: &ArrayRef, step: usize) -> VortexFuzzResult<()> {
     if lhs.dtype() != rhs.dtype() {
         return Err(VortexFuzzError::DTypeMismatch(
             lhs.clone(),
@@ -714,8 +720,8 @@ pub fn assert_array_eq(
         return Err(VortexFuzzError::LengthMismatch(
             lhs.len(),
             rhs.len(),
-            lhs.to_array(),
-            rhs.to_array(),
+            lhs.clone(),
+            rhs.clone(),
             step,
             Backtrace::capture(),
         ));
@@ -741,14 +747,7 @@ pub fn assert_array_eq(
 
 /// Assert two scalars are equal.
 #[allow(clippy::result_large_err)]
-pub fn assert_scalar_eq(
-    lhs: &Scalar,
-    rhs: &Scalar,
-    step: usize,
-) -> crate::error::VortexFuzzResult<()> {
-    use crate::error::Backtrace;
-    use crate::error::VortexFuzzError;
-
+pub fn assert_scalar_eq(lhs: &Scalar, rhs: &Scalar, step: usize) -> VortexFuzzResult<()> {
     if lhs != rhs {
         return Err(VortexFuzzError::ScalarMismatch(
             lhs.clone(),
@@ -766,10 +765,7 @@ pub fn assert_min_max_eq(
     lhs: &Option<MinMaxResult>,
     rhs: &Option<MinMaxResult>,
     step: usize,
-) -> crate::error::VortexFuzzResult<()> {
-    use crate::error::Backtrace;
-    use crate::error::VortexFuzzError;
-
+) -> VortexFuzzResult<()> {
     if lhs != rhs {
         return Err(VortexFuzzError::MinMaxMismatch(
             lhs.clone(),
diff --git a/fuzz/src/array/scalar_at.rs b/fuzz/src/array/scalar_at.rs
index 31b7be93aa3..91898390df6 100644
--- a/fuzz/src/array/scalar_at.rs
+++ b/fuzz/src/array/scalar_at.rs
@@ -3,9 +3,14 @@
 
 use std::sync::Arc;
 
-use vortex_array::Array;
 use vortex_array::Canonical;
-use vortex_array::arrays::varbin_scalar;
+use vortex_array::IntoArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
+use vortex_array::arrays::varbin::varbin_scalar;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_decimal_value_type;
 use vortex_array::match_each_native_ptype;
@@ -18,8 +23,9 @@ use vortex_error::VortexResult;
 /// This implementation manually extracts the scalar value from each canonical type
 /// without using the scalar_at method, to serve as an independent baseline for testing.
 pub fn scalar_at_canonical_array(canonical: Canonical, index: usize) -> VortexResult<Scalar> {
-    if canonical.as_ref().is_invalid(index)? {
-        return Ok(Scalar::null(canonical.as_ref().dtype().clone()));
+    let canonical_ref = canonical.clone().into_array();
+    if canonical_ref.is_invalid(index)? {
+        return Ok(Scalar::null(canonical_ref.dtype().clone()));
     }
     Ok(match canonical {
         Canonical::Null(_array) => Scalar::null(DType::Null),
@@ -76,8 +82,7 @@ pub fn scalar_at_canonical_array(canonical: Canonical, index: usize) -> VortexRe
         }
         Canonical::Struct(array) => {
             let field_scalars: Vec<Scalar> = array
-                .unmasked_fields()
-                .iter()
+                .iter_unmasked_fields()
                 .map(|field| {
                     scalar_at_canonical_array(
                         field
@@ -91,8 +96,10 @@ pub fn scalar_at_canonical_array(canonical: Canonical, index: usize) -> VortexRe
             Scalar::struct_(array.dtype().clone(), field_scalars)
         }
         Canonical::Extension(array) => {
-            let storage_scalar = scalar_at_canonical_array(array.storage().to_canonical()?, index)?;
+            let storage_scalar =
+                scalar_at_canonical_array(array.storage_array().to_canonical()?, index)?;
             Scalar::extension_ref(array.ext_dtype().clone(), storage_scalar)
         }
+        Canonical::Variant(_) => unreachable!("Variant arrays are not fuzzed"),
     })
 }
diff --git a/fuzz/src/array/search_sorted.rs b/fuzz/src/array/search_sorted.rs
index 4a5ac465bb5..d22b583a39b 100644
--- a/fuzz/src/array/search_sorted.rs
+++ b/fuzz/src/array/search_sorted.rs
@@ -4,9 +4,10 @@
 use std::cmp::Ordering;
 use std::fmt::Debug;
 
-use vortex_array::Array;
+use vortex_array::ArrayRef;
 use vortex_array::ToCanonical;
 use vortex_array::accessor::ArrayAccessor;
+use vortex_array::arrays::bool::BoolArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_decimal_value_type;
@@ -56,7 +57,7 @@ impl<T: NativePType> IndexOrd<Option<T>> for SearchPrimitiveSlice<T> {
 }
 
 pub fn search_sorted_canonical_array(
-    array: &dyn Array,
+    array: &ArrayRef,
     scalar: &Scalar,
     side: SearchSortedSide,
 ) -> VortexResult<SearchResult> {
@@ -130,7 +131,7 @@ pub fn search_sorted_canonical_array(
                 .collect::<VortexResult<Vec<_>>>()?;
             scalar_vals.search_sorted(&scalar.cast(array.dtype())?, side)
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/array/slice.rs b/fuzz/src/array/slice.rs
index 672a6810759..65952ee49da 100644
--- a/fuzz/src/array/slice.rs
+++ b/fuzz/src/array/slice.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -13,6 +12,10 @@ use vortex_array::arrays::ListViewArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::match_each_decimal_value_type;
 use vortex_array::match_each_native_ptype;
@@ -21,7 +24,7 @@ use vortex_error::VortexResult;
 
 #[allow(clippy::unnecessary_fallible_conversions)]
 pub fn slice_canonical_array(
-    array: &dyn Array,
+    array: &ArrayRef,
     start: usize,
     stop: usize,
 ) -> VortexResult<ArrayRef> {
@@ -61,8 +64,7 @@ pub fn slice_canonical_array(
         DType::Struct(..) => {
             let struct_array = array.to_struct();
             let sliced_children = struct_array
-                .unmasked_fields()
-                .iter()
+                .iter_unmasked_fields()
                 .map(|c| slice_canonical_array(c, start, stop))
                 .collect::<VortexResult<Vec<_>>>()?;
             StructArray::try_new_with_dtype(
@@ -111,10 +113,10 @@ pub fn slice_canonical_array(
                         validity,
                     )
                 })
-                .to_array(),
+                .into_array(),
             )
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/array/sort.rs b/fuzz/src/array/sort.rs
index ac600ce8cd4..6c07c76c20d 100644
--- a/fuzz/src/array/sort.rs
+++ b/fuzz/src/array/sort.rs
@@ -3,7 +3,6 @@
 
 use std::cmp::Ordering;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -12,6 +11,7 @@ use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::match_each_decimal_value_type;
@@ -21,7 +21,7 @@ use vortex_error::VortexResult;
 
 use crate::array::take_canonical_array_non_nullable_indices;
 
-pub fn sort_canonical_array(array: &dyn Array) -> VortexResult<ArrayRef> {
+pub fn sort_canonical_array(array: &ArrayRef) -> VortexResult<ArrayRef> {
     match array.dtype() {
         DType::Bool(_) => {
             let bool_array = array.to_bool();
@@ -81,7 +81,7 @@ pub fn sort_canonical_array(array: &dyn Array) -> VortexResult<ArrayRef> {
             });
             take_canonical_array_non_nullable_indices(array, &sort_indices)
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/array/sum.rs b/fuzz/src/array/sum.rs
index 756c27e5e1c..9cb2eb9bb90 100644
--- a/fuzz/src/array/sum.rs
+++ b/fuzz/src/array/sum.rs
@@ -2,12 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_array::Canonical;
-use vortex_array::compute::sum;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray as _;
+use vortex_array::aggregate_fn::fns::sum::sum;
 use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 
 /// Compute sum on the canonical form of the array to get a consistent baseline.
-pub fn sum_canonical_array(canonical: Canonical) -> VortexResult<Scalar> {
+pub fn sum_canonical_array(canonical: Canonical, ctx: &mut ExecutionCtx) -> VortexResult<Scalar> {
     // TODO(joe): replace with baseline not using canonical
-    sum(canonical.as_ref())
+    sum(&canonical.into_array(), ctx)
 }
diff --git a/fuzz/src/array/take.rs b/fuzz/src/array/take.rs
index 584f611efe1..a113829077b 100644
--- a/fuzz/src/array/take.rs
+++ b/fuzz/src/array/take.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -11,6 +10,8 @@ use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::builders::builder_with_capacity;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::DecimalDType;
@@ -25,7 +26,7 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 pub fn take_canonical_array_non_nullable_indices(
-    array: &dyn Array,
+    array: &ArrayRef,
     indices: &[usize],
 ) -> VortexResult<ArrayRef> {
     take_canonical_array(
@@ -38,10 +39,7 @@ pub fn take_canonical_array_non_nullable_indices(
     )
 }
 
-pub fn take_canonical_array(
-    array: &dyn Array,
-    indices: &[Option<usize>],
-) -> VortexResult<ArrayRef> {
+pub fn take_canonical_array(array: &ArrayRef, indices: &[Option<usize>]) -> VortexResult<ArrayRef> {
     let nullable: Nullability = indices.contains(&None).into();
 
     let validity = if array.dtype().is_nullable() || nullable == Nullability::Nullable {
@@ -109,8 +107,7 @@ pub fn take_canonical_array(
         DType::Struct(..) => {
             let struct_array = array.to_struct();
             let taken_children = struct_array
-                .unmasked_fields()
-                .iter()
+                .iter_unmasked_fields()
                 .map(|c| take_canonical_array_non_nullable_indices(c, indices_slice_non_opt))
                 .collect::<VortexResult<Vec<_>>>()?;
 
@@ -141,7 +138,7 @@ pub fn take_canonical_array(
             }
             Ok(builder.finish())
         }
-        d @ (DType::Null | DType::Extension(_)) => {
+        d @ (DType::Null | DType::Extension(_) | DType::Variant(_)) => {
             unreachable!("DType {d} not supported for fuzzing")
         }
     }
diff --git a/fuzz/src/compress.rs b/fuzz/src/compress.rs
index da132e7cd95..9ca6fadb348 100644
--- a/fuzz/src/compress.rs
+++ b/fuzz/src/compress.rs
@@ -8,11 +8,10 @@
 
 use arbitrary::Arbitrary;
 use arbitrary::Unstructured;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ArbitraryConstantArray;
-use vortex_array::arrays::ArbitraryDictArray;
+use vortex_array::arrays::constant::ArbitraryConstantArray;
+use vortex_array::arrays::dict::ArbitraryDictArray;
 use vortex_runend::ArbitraryRunEndArray;
 
 /// Which compressed encoding to generate.
diff --git a/fuzz/src/error.rs b/fuzz/src/error.rs
index 27192161222..b82afd9ad9b 100644
--- a/fuzz/src/error.rs
+++ b/fuzz/src/error.rs
@@ -10,9 +10,8 @@ use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
-use vortex_array::compute::MinMaxResult;
+use vortex_array::aggregate_fn::fns::min_max::MinMaxResult;
 use vortex_array::scalar::Scalar;
 use vortex_array::search_sorted::SearchResult;
 use vortex_array::search_sorted::SearchSortedSide;
@@ -97,12 +96,29 @@ impl Display for VortexFuzzError {
                     "MinMax mismatch: expected {lhs:?} got {rhs:?} in step {step}\nBacktrace:\n{backtrace}"
                 )
             }
-            VortexFuzzError::ArrayNotEqual(expected, actual, idx, lhs, rhs, step, backtrace) => {
+            VortexFuzzError::ArrayNotEqual(
+                expected_scalar,
+                actual_scalar,
+                idx,
+                expected_array,
+                current_array,
+                step,
+                backtrace,
+            ) => {
+                let expected_tree = expected_array.display_tree();
+                let current_tree = current_array.display_tree();
+                let expected_values = expected_array.display_values();
+                let current_values = current_array.display_values();
                 write!(
                     f,
-                    "{expected} != {actual} at index {idx}, lhs is {} rhs is {} in step {step}\nBacktrace:\n{backtrace}",
-                    lhs.display_tree(),
-                    rhs.display_tree(),
+                    "Mismatch at step {step} at index {idx}\n\
+                    Expected scalar:\n{expected_scalar}\n\
+                    Actual scalar:\n{actual_scalar}\n\n\
+                    Expected tree:\n{expected_tree}\n\
+                    Current tree:\n{current_tree}\n\
+                    Expected values:\n{expected_values:#}\n\n\
+                    Current values:\n{current_values:#}\
+                    \n{backtrace}"
                 )
             }
             VortexFuzzError::DTypeMismatch(lhs, rhs, step, backtrace) => {
diff --git a/fuzz/src/fsst_like.rs b/fuzz/src/fsst_like.rs
new file mode 100644
index 00000000000..b962c4244c8
--- /dev/null
+++ b/fuzz/src/fsst_like.rs
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Fuzzer for FSST LIKE pushdown: compresses arbitrary strings with FSST, then
+//! runs a LIKE pattern on both the compressed and uncompressed arrays, asserting
+//! that the boolean results are identical.
+
+use std::sync::LazyLock;
+
+use arbitrary::Arbitrary;
+use arbitrary::Unstructured;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::scalar_fn::fns::like::Like;
+use vortex_array::scalar_fn::fns::like::LikeOptions;
+use vortex_array::session::ArraySession;
+use vortex_error::VortexResult;
+use vortex_fsst::FSSTArray;
+use vortex_fsst::fsst_compress;
+use vortex_fsst::fsst_train_compressor;
+use vortex_session::VortexSession;
+
+use crate::error::Backtrace;
+use crate::error::VortexFuzzError;
+use crate::error::VortexFuzzResult;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+/// A random string from a small alphabet (`a..=h`) with bounded length.
+#[derive(Debug)]
+struct SmallAlphabetString {
+    max_len: usize,
+}
+
+impl SmallAlphabetString {
+    fn generate(&self, u: &mut Unstructured<'_>) -> arbitrary::Result<String> {
+        let len: usize = u.int_in_range(0..=self.max_len)?;
+        (0..len)
+            .map(|_| Ok(u.int_in_range(b'a'..=b'h')? as char))
+            .collect()
+    }
+}
+
+/// Fuzz input: a set of strings and a LIKE pattern.
+#[derive(Debug)]
+pub struct FuzzFsstLike {
+    pub strings: Vec<String>,
+    pub pattern: String,
+    pub negated: bool,
+}
+
+impl<'a> Arbitrary<'a> for FuzzFsstLike {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let n_strings: usize = u.int_in_range(1..=200)?;
+        let str_gen = SmallAlphabetString { max_len: 512 };
+        let strings: Vec<String> = (0..n_strings)
+            .map(|_| str_gen.generate(u))
+            .collect::<arbitrary::Result<_>>()?;
+
+        let needle = SmallAlphabetString { max_len: 254 }.generate(u)?;
+
+        let pattern = match u.int_in_range(0..=2)? {
+            0 => format!("{needle}%"),  // prefix
+            1 => format!("%{needle}%"), // contains
+            2 => format!("%{needle}"),  // suffix (should fall back, still correct)
+            _ => unreachable!(""),
+        };
+
+        let negated: bool = u.arbitrary()?;
+
+        Ok(FuzzFsstLike {
+            strings,
+            pattern,
+            negated,
+        })
+    }
+}
+
+/// Run the FSST LIKE fuzzer: compare LIKE on compressed vs uncompressed.
+///
+/// Returns:
+/// - `Ok(true)` — keep in corpus
+/// - `Ok(false)` — reject (e.g. too few strings)
+/// - `Err(_)` — mismatch found (bug)
+#[allow(clippy::result_large_err)]
+pub fn run_fsst_like_fuzz(fuzz: FuzzFsstLike) -> VortexFuzzResult<bool> {
+    let FuzzFsstLike {
+        strings,
+        pattern,
+        negated,
+    } = fuzz;
+
+    if strings.is_empty() {
+        return Ok(false);
+    }
+
+    let len = strings.len();
+
+    // Build uncompressed VarBinArray.
+    let varbin = VarBinArray::from_iter(
+        strings.iter().map(|s| Some(s.as_str())),
+        DType::Utf8(Nullability::NonNullable),
+    );
+
+    // Train FSST compressor and compress.
+    let compressor = fsst_train_compressor(&varbin);
+    let fsst_array: FSSTArray =
+        fsst_compress(varbin.clone(), varbin.len(), varbin.dtype(), &compressor);
+
+    let opts = LikeOptions {
+        negated,
+        case_insensitive: false,
+    };
+
+    // Run LIKE on the uncompressed array.
+    let expected = run_like_on_array(&varbin.into_array(), &pattern, len, opts)
+        .map_err(|err| VortexFuzzError::VortexError(err, Backtrace::capture()))?;
+
+    // Run LIKE on the FSST-compressed array.
+    let actual = run_like_on_array(&fsst_array.into_array(), &pattern, len, opts)
+        .map_err(|err| VortexFuzzError::VortexError(err, Backtrace::capture()))?;
+
+    // Compare bit-for-bit.
+    let expected_bits = expected.to_bit_buffer();
+    let actual_bits = actual.to_bit_buffer();
+    for idx in 0..len {
+        let expected_val = expected_bits.value(idx);
+        let actual_val = actual_bits.value(idx);
+        if expected_val != actual_val {
+            return Err(VortexFuzzError::VortexError(
+                vortex_error::vortex_err!(
+                    "FSST LIKE mismatch at index {idx}:\n  \
+                     pattern:  {pattern:?}\n  \
+                     string:   {:?}\n  \
+                     expected: {expected_val}\n  \
+                     actual:   {actual_val}",
+                    &strings[idx],
+                ),
+                Backtrace::capture(),
+            ));
+        }
+    }
+
+    Ok(true)
+}
+
+fn run_like_on_array(
+    array: &ArrayRef,
+    pattern: &str,
+    len: usize,
+    opts: LikeOptions,
+) -> VortexResult<BoolArray> {
+    use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+
+    let pattern_arr = ConstantArray::new(pattern, len).into_array();
+    let result = Like
+        .try_new_array(len, opts, [array.clone(), pattern_arr])?
+        .into_array()
+        .execute::<Canonical>(&mut SESSION.create_execution_ctx())?;
+    Ok(result.into_bool())
+}
diff --git a/fuzz/src/gpu/mod.rs b/fuzz/src/gpu/mod.rs
index 6f55d0e816e..6d762813000 100644
--- a/fuzz/src/gpu/mod.rs
+++ b/fuzz/src/gpu/mod.rs
@@ -11,7 +11,7 @@ use arbitrary::Result;
 use arbitrary::Unstructured;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::arrays::ArbitraryDictArray;
+use vortex_array::arrays::dict::ArbitraryDictArray;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_error::vortex_err;
diff --git a/fuzz/src/lib.rs b/fuzz/src/lib.rs
index 1d117e6d113..f6712e3540c 100644
--- a/fuzz/src/lib.rs
+++ b/fuzz/src/lib.rs
@@ -6,6 +6,7 @@
 mod array;
 pub mod compress;
 pub mod error;
+pub mod fsst_like;
 
 // File module only available for native builds (requires vortex-file which uses tokio)
 #[cfg(not(target_arch = "wasm32"))]
@@ -24,6 +25,8 @@ pub use compress::FuzzCompressRoundtrip;
 pub use compress::run_compress_roundtrip;
 #[cfg(not(target_arch = "wasm32"))]
 pub use file::FuzzFileAction;
+pub use fsst_like::FuzzFsstLike;
+pub use fsst_like::run_fsst_like_fuzz;
 #[cfg(feature = "cuda")]
 pub use gpu::FuzzCompressGpu;
 #[cfg(feature = "cuda")]
@@ -61,7 +64,9 @@ pub use native_runtime::RUNTIME;
 #[cfg(not(target_arch = "wasm32"))]
 pub use native_runtime::SESSION;
 
-#[cfg(target_arch = "wasm32")]
+// target_os = "unknown" matches wasm32-unknown-unknown (browser), excluding WASI targets
+// where wasm-bindgen's JS interop is not available.
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 mod wasm_runtime {
     use std::sync::LazyLock;
 
@@ -74,5 +79,20 @@ mod wasm_runtime {
         LazyLock::new(|| VortexSession::default().with_handle(WasmRuntime::handle()));
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 pub use wasm_runtime::SESSION;
+
+/// WASI targets get a session without an async runtime handle since wasm-bindgen
+/// is not available. The fuzz workloads are synchronous, so this is sufficient.
+#[cfg(all(target_arch = "wasm32", not(target_os = "unknown")))]
+mod wasi_runtime {
+    use std::sync::LazyLock;
+
+    use vortex::VortexSessionDefault;
+    use vortex_session::VortexSession;
+
+    pub static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::default);
+}
+
+#[cfg(all(target_arch = "wasm32", not(target_os = "unknown")))]
+pub use wasi_runtime::SESSION;
diff --git a/java/build.gradle.kts b/java/build.gradle.kts
index fc25f99acd2..48c1ed3349f 100644
--- a/java/build.gradle.kts
+++ b/java/build.gradle.kts
@@ -4,12 +4,11 @@
 import net.ltgt.gradle.errorprone.errorprone
 
 plugins {
-    id("com.diffplug.spotless") version "8.1.0"
-    id("com.palantir.consistent-versions") version "3.7.0"
-    id("com.palantir.git-version") version "4.2.0"
-    id("net.ltgt.errorprone") version "4.3.0" apply false
+    id("com.diffplug.spotless") version "8.4.0"
+    id("com.palantir.git-version") version "5.0.0"
+    id("net.ltgt.errorprone") version "5.1.0" apply false
     id("com.google.protobuf") version "0.9.6" apply false
-    id("com.vanniktech.maven.publish") version "0.35.0" apply false
+    id("com.vanniktech.maven.publish") version "0.36.0" apply false
 }
 
 subprojects {
@@ -33,9 +32,9 @@ allprojects {
         apply(plugin = "net.ltgt.errorprone")
 
         dependencies {
-            "errorprone"("com.google.errorprone:error_prone_core")
-            "errorprone"("com.jakewharton.nopen:nopen-checker")
-            "compileOnly"("com.jakewharton.nopen:nopen-annotations")
+            "errorprone"("com.google.errorprone:error_prone_core:2.36.0")
+            "errorprone"("com.jakewharton.nopen:nopen-checker:1.0.1")
+            "compileOnly"("com.jakewharton.nopen:nopen-annotations:1.0.1")
         }
 
         spotless {
diff --git a/java/gradle/libs.versions.toml b/java/gradle/libs.versions.toml
new file mode 100644
index 00000000000..c881e141de9
--- /dev/null
+++ b/java/gradle/libs.versions.toml
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+[versions]
+arrow = "18.3.0"
+errorprone = "2.36.0"
+guava = "33.5.0-jre"
+immutables = "2.12.1"
+junit-jupiter = "6.0.3"
+logback = "1.5.32"
+netty = "4.2.7.Final"
+nopen = "1.0.1"
+protobuf = "4.33.5"
+slf4j = "2.0.17"
+spark3 = "3.5.8"
+spark4 = "4.1.1"
+s3mock = "4.11.0"
+testcontainers-jupiter = "1.20.4"
+
+[libraries]
+arrow-c-data = { module = "org.apache.arrow:arrow-c-data", version.ref = "arrow" }
+arrow-memory-core = { module = "org.apache.arrow:arrow-memory-core", version.ref = "arrow" }
+arrow-memory-netty = { module = "org.apache.arrow:arrow-memory-netty", version.ref = "arrow" }
+errorprone-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "errorprone" }
+errorprone-core = { module = "com.google.errorprone:error_prone_core", version.ref = "errorprone" }
+guava = { module = "com.google.guava:guava", version.ref = "guava" }
+immutables-value = { module = "org.immutables:value", version.ref = "immutables" }
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
+junit-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit-jupiter" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
+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" }
+protobuf-java = { module = "com.google.protobuf:protobuf-java", version.ref = "protobuf" }
+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
diff --git a/java/gradle/wrapper/gradle-wrapper.jar b/java/gradle/wrapper/gradle-wrapper.jar
index f8e1ee3125f..d997cfc60f4 100644
Binary files a/java/gradle/wrapper/gradle-wrapper.jar and b/java/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/java/gradle/wrapper/gradle-wrapper.properties b/java/gradle/wrapper/gradle-wrapper.properties
index 23449a2b543..c61a118f7dd 100644
--- a/java/gradle/wrapper/gradle-wrapper.properties
+++ b/java/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/java/gradlew b/java/gradlew
index adff685a034..739907dfd15 100755
--- a/java/gradlew
+++ b/java/gradlew
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/2d6327017519d23b96af35865dc997fcb544fb40/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
diff --git a/java/settings-gradle.lockfile b/java/settings-gradle.lockfile
deleted file mode 100644
index 709a43f74f8..00000000000
--- a/java/settings-gradle.lockfile
+++ /dev/null
@@ -1,4 +0,0 @@
-# This is a Gradle generated file for dependency locking.
-# Manual edits can break the build and are not advised.
-# This file is expected to be part of source control.
-empty=incomingCatalogForLibs0
diff --git a/java/settings.gradle.kts b/java/settings.gradle.kts
index 838875f40b0..a601cfa9488 100644
--- a/java/settings.gradle.kts
+++ b/java/settings.gradle.kts
@@ -19,4 +19,8 @@ rootProject.name = "vortex-root"
 
 // API bindings
 include("vortex-jni")
-include("vortex-spark")
+include("vortex-spark_2.12")
+project(":vortex-spark_2.12").projectDir = file("vortex-spark")
+
+include("vortex-spark_2.13")
+project(":vortex-spark_2.13").projectDir = file("vortex-spark")
diff --git a/java/testfiles/Cargo.lock b/java/testfiles/Cargo.lock
index 393fab6eaab..190904c651f 100644
--- a/java/testfiles/Cargo.lock
+++ b/java/testfiles/Cargo.lock
@@ -42,9 +42,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.101"
+version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "arcref"
@@ -60,9 +60,9 @@ checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrow-arith"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b"
+checksum = "ced5406f8b720cc0bc3aa9cf5758f93e8593cda5490677aa194e4b4b383f9a59"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -74,9 +74,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-array"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef"
+checksum = "772bd34cacdda8baec9418d80d23d0fb4d50ef0735685bd45158b83dfeb6e62d"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -92,9 +92,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-buffer"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c697ddca96183182f35b3a18e50b9110b11e916d7b7799cbfd4d34662f2c56c2"
+checksum = "898f4cf1e9598fdb77f356fdf2134feedfd0ee8d5a4e0a5f573e7d0aec16baa4"
 dependencies = [
  "bytes",
  "half",
@@ -104,9 +104,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-cast"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5"
+checksum = "b0127816c96533d20fc938729f48c52d3e48f99717e7a0b5ade77d742510736d"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-data"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304"
+checksum = "42d10beeab2b1c3bb0b53a00f7c944a178b622173a5c7bcabc3cb45d90238df4"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -138,9 +138,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ord"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b"
+checksum = "763a7ba279b20b52dad300e68cfc37c17efa65e68623169076855b3a9e941ca5"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -151,18 +151,18 @@ dependencies = [
 
 [[package]]
 name = "arrow-schema"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68"
+checksum = "c30a1365d7a7dc50cc847e54154e6af49e4c4b0fddc9f607b687f29212082743"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "arrow-select"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b"
+checksum = "78694888660a9e8ac949853db393af2a8b8fc82c19ce333132dfa2e72cc1a7fe"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -174,9 +174,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-string"
-version = "57.3.0"
+version = "58.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8"
+checksum = "61e04a01f8bb73ce54437514c5fd3ee2aa3e8abe4c777ee5cc55853b1652f79e"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -321,7 +321,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -338,7 +338,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -389,14 +389,17 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "bit-vec"
-version = "0.8.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "bitflags"
@@ -431,9 +434,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.20.1"
+version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6f81257d10a0f602a294ae4182251151ff97dbb504ef9afcdda4a64b24d9b4"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
 [[package]]
 name = "bytemuck"
@@ -455,9 +458,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"
-version = "1.2.56"
+version = "1.2.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -480,11 +483,22 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "rand_core 0.10.0",
+]
+
 [[package]]
 name = "chrono"
-version = "0.4.43"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
  "iana-time-zone",
  "num-traits",
@@ -543,6 +557,15 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
@@ -599,17 +622,6 @@ dependencies = [
  "parking_lot_core",
 ]
 
-[[package]]
-name = "displaydoc"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.116",
-]
-
 [[package]]
 name = "dtype_dispatch"
 version = "0.2.1"
@@ -639,7 +651,7 @@ checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -756,20 +768,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
-name = "form_urlencoded"
-version = "1.2.2"
+name = "fsst-rs"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+checksum = "cbfc42bd5e2b76f850ba4ff6dd6cb170389bc3c1e64dc45238a742d79bbfb2ca"
 dependencies = [
- "percent-encoding",
+ "rustc-hash",
 ]
 
-[[package]]
-name = "fsst-rs"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "561f2458a3407836ab8f1acc9113b8cda91b9d6378ba8dad13b2fe1a1d3af5ce"
-
 [[package]]
 name = "funty"
 version = "2.0.0"
@@ -845,7 +851,7 @@ checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -895,24 +901,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
- "wasm-bindgen",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
- "r-efi",
+ "r-efi 6.0.0",
+ "rand_core 0.10.0",
  "wasip2",
  "wasip3",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1010,114 +1017,12 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "icu_collections"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
-dependencies = [
- "displaydoc",
- "potential_utf",
- "yoke",
- "zerofrom",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locale_core"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
-dependencies = [
- "displaydoc",
- "litemap",
- "tinystr",
- "writeable",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
-dependencies = [
- "icu_collections",
- "icu_normalizer_data",
- "icu_properties",
- "icu_provider",
- "smallvec",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer_data"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
-
-[[package]]
-name = "icu_properties"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
-dependencies = [
- "icu_collections",
- "icu_locale_core",
- "icu_properties_data",
- "icu_provider",
- "zerotrie",
- "zerovec",
-]
-
-[[package]]
-name = "icu_properties_data"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
-
-[[package]]
-name = "icu_provider"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
-dependencies = [
- "displaydoc",
- "icu_locale_core",
- "writeable",
- "yoke",
- "zerofrom",
- "zerotrie",
- "zerovec",
-]
-
 [[package]]
 name = "id-arena"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 
-[[package]]
-name = "idna"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
-dependencies = [
- "idna_adapter",
- "smallvec",
- "utf8_iter",
-]
-
-[[package]]
-name = "idna_adapter"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
-dependencies = [
- "icu_normalizer",
- "icu_properties",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.13.0"
@@ -1132,9 +1037,9 @@ dependencies = [
 
 [[package]]
 name = "inventory"
-version = "0.3.21"
+version = "0.3.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
+checksum = "009ae045c87e7082cb72dab0ccd01ae075dd00141ddc108f43a0ea150a9e7227"
 dependencies = [
  "rustversion",
 ]
@@ -1159,15 +1064,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "jiff"
-version = "0.2.20"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c867c356cc096b33f4981825ab281ecba3db0acefe60329f044c1789d94c6543"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
 dependencies = [
  "jiff-static",
  "jiff-tzdb-platform",
@@ -1180,20 +1085,20 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.20"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7946b4325269738f270bb55b3c19ab5c5040525f83fd625259422a9d25d9be5"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "jiff-tzdb"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68971ebff725b9e2ca27a601c5eb38a4c5d64422c4cbab0c535f248087eda5c2"
+checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
 
 [[package]]
 name = "jiff-tzdb-platform"
@@ -1216,9 +1121,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.85"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -1324,9 +1229,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.182"
+version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
 [[package]]
 name = "libloading"
@@ -1346,15 +1251,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
-
-[[package]]
-name = "litemap"
-version = "0.8.1"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "lock_api"
@@ -1401,9 +1300,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "moka"
-version = "0.12.13"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac832c50ced444ef6be0767a008b02c106a909ba79d1d830501e94b96f6b7e"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
 dependencies = [
  "async-lock",
  "crossbeam-channel",
@@ -1437,7 +1336,7 @@ checksum = "b093064383341eb3271f42e381cb8f10a01459478446953953c75d24bd339fc0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
  "target-features",
 ]
 
@@ -1518,9 +1417,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -1528,29 +1427,29 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 dependencies = [
  "parking_lot_core",
 ]
 
 [[package]]
 name = "oneshot"
-version = "0.1.13"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "269bca4c2591a28585d6bf10d9ed0332b7d76900a1b02bec41bdc3a2cdcda107"
+checksum = "cfe21416a02c693fb9f980befcb230ecc70b0b3d1cc4abf88b9675c4c1457f0c"
 
 [[package]]
 name = "parking"
@@ -1599,23 +1498,17 @@ dependencies = [
  "rand_xoshiro",
 ]
 
-[[package]]
-name = "percent-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
-
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "piper"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
 dependencies = [
  "atomic-waker",
  "fastrand",
@@ -1656,31 +1549,13 @@ checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a9db96d7fa8782dd8c15ce32ffe8680bbd1e978a43bf51a34d39483540495f5"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
 dependencies = [
  "portable-atomic",
 ]
 
-[[package]]
-name = "potential_utf"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
-dependencies = [
- "zerovec",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -1688,7 +1563,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1720,7 +1595,7 @@ dependencies = [
  "itertools 0.14.0",
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1734,9 +1609,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -1747,6 +1622,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -1755,22 +1636,13 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
 dependencies = [
- "rand_chacha",
- "rand_core 0.9.5",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.9.5",
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.0",
 ]
 
 [[package]]
@@ -1781,12 +1653,9 @@ checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 
 [[package]]
 name = "rand_core"
-version = "0.9.5"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
-dependencies = [
- "getrandom 0.3.4",
-]
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
 
 [[package]]
 name = "rand_xoshiro"
@@ -1831,9 +1700,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.9"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "roaring"
@@ -1862,9 +1731,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
  "bitflags",
  "errno",
@@ -1910,6 +1779,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
  "serde_core",
+ "serde_derive",
 ]
 
 [[package]]
@@ -1929,7 +1799,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1969,9 +1839,9 @@ checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "sketches-ddsketch"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a"
+checksum = "05e40b6cf54d988dc1a2223531b969c9a9e30906ad90ef64890c27b4bfbb46ea"
 
 [[package]]
 name = "slab"
@@ -2002,12 +1872,6 @@ dependencies = [
  "futures-lite",
 ]
 
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -2027,26 +1891,15 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.116"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df424c70518695237746f84cede799c9c58fcb37450d7b23716568cc8bc69cb"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
-[[package]]
-name = "synstructure"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.116",
-]
-
 [[package]]
 name = "tagptr"
 version = "0.2.0"
@@ -2067,9 +1920,9 @@ checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
 
 [[package]]
 name = "termtree"
-version = "0.5.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
+checksum = "d4d1330fe7f7f872cd05165130b10602d667b205fd85be09be2814b115d4ced9"
 
 [[package]]
 name = "testfiles"
@@ -2087,21 +1940,11 @@ dependencies = [
  "crunchy",
 ]
 
-[[package]]
-name = "tinystr"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
-dependencies = [
- "displaydoc",
- "zerovec",
-]
-
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
  "bytes",
  "pin-project-lite",
@@ -2135,31 +1978,13 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "url"
-version = "2.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
- "serde",
-]
-
-[[package]]
-name = "utf8_iter"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
-
 [[package]]
 name = "uuid"
-version = "1.21.0"
+version = "1.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
 dependencies = [
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "js-sys",
  "wasm-bindgen",
 ]
@@ -2240,7 +2065,7 @@ dependencies = [
  "enum-iterator",
  "flatbuffers",
  "futures",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "half",
  "humansize",
  "inventory",
@@ -2259,6 +2084,7 @@ dependencies = [
  "static_assertions",
  "termtree",
  "tracing",
+ "uuid",
  "vortex-buffer",
  "vortex-error",
  "vortex-flatbuffers",
@@ -2272,8 +2098,7 @@ dependencies = [
 name = "vortex-btrblocks"
 version = "0.1.0"
 dependencies = [
- "enum-iterator",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "itertools 0.14.0",
  "num-traits",
  "pco",
@@ -2283,6 +2108,7 @@ dependencies = [
  "vortex-alp",
  "vortex-array",
  "vortex-buffer",
+ "vortex-compressor",
  "vortex-datetime-parts",
  "vortex-decimal-byte-parts",
  "vortex-error",
@@ -2322,6 +2148,23 @@ dependencies = [
  "vortex-session",
 ]
 
+[[package]]
+name = "vortex-compressor"
+version = "0.1.0"
+dependencies = [
+ "itertools 0.14.0",
+ "num-traits",
+ "parking_lot",
+ "rand",
+ "rustc-hash",
+ "tracing",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-utils",
+]
+
 [[package]]
 name = "vortex-datetime-parts"
 version = "0.1.0"
@@ -2362,7 +2205,6 @@ dependencies = [
 name = "vortex-fastlanes"
 version = "0.1.0"
 dependencies = [
- "arrayref",
  "fastlanes",
  "itertools 0.14.0",
  "lending-iterator",
@@ -2383,8 +2225,7 @@ dependencies = [
  "bytes",
  "flatbuffers",
  "futures",
- "getrandom 0.3.4",
- "glob",
+ "getrandom 0.4.2",
  "itertools 0.14.0",
  "kanal",
  "moka",
@@ -2392,7 +2233,6 @@ dependencies = [
  "parking_lot",
  "pin-project-lite",
  "tracing",
- "url",
  "uuid",
  "vortex-alp",
  "vortex-array",
@@ -2434,7 +2274,6 @@ name = "vortex-fsst"
 version = "0.1.0"
 dependencies = [
  "fsst-rs",
- "num-traits",
  "prost",
  "vortex-array",
  "vortex-buffer",
@@ -2453,7 +2292,7 @@ dependencies = [
  "bytes",
  "custom-labels",
  "futures",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "glob",
  "handle",
  "kanal",
@@ -2492,8 +2331,11 @@ name = "vortex-layout"
 version = "0.1.0"
 dependencies = [
  "arcref",
+ "arrow-array",
+ "arrow-schema",
  "async-stream",
  "async-trait",
+ "bit-vec",
  "flatbuffers",
  "futures",
  "itertools 0.14.0",
@@ -2506,18 +2348,18 @@ dependencies = [
  "pin-project-lite",
  "prost",
  "rustc-hash",
+ "sketches-ddsketch",
  "termtree",
  "tracing",
- "uuid",
  "vortex-array",
  "vortex-btrblocks",
  "vortex-buffer",
- "vortex-decimal-byte-parts",
  "vortex-error",
  "vortex-flatbuffers",
  "vortex-io",
  "vortex-mask",
  "vortex-metrics",
+ "vortex-scan",
  "vortex-sequence",
  "vortex-session",
  "vortex-utils",
@@ -2536,10 +2378,9 @@ dependencies = [
 name = "vortex-metrics"
 version = "0.1.0"
 dependencies = [
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "parking_lot",
  "sketches-ddsketch",
- "vortex-session",
 ]
 
 [[package]]
@@ -2582,24 +2423,14 @@ dependencies = [
 name = "vortex-scan"
 version = "0.1.0"
 dependencies = [
- "arrow-array",
- "arrow-schema",
  "async-trait",
- "bit-vec",
  "futures",
- "itertools 0.14.0",
- "kanal",
- "parking_lot",
  "roaring",
- "sketches-ddsketch",
  "tracing",
  "vortex-array",
  "vortex-buffer",
  "vortex-error",
- "vortex-io",
- "vortex-layout",
  "vortex-mask",
- "vortex-metrics",
  "vortex-session",
 ]
 
@@ -2614,7 +2445,6 @@ dependencies = [
  "vortex-error",
  "vortex-mask",
  "vortex-proto",
- "vortex-runend",
  "vortex-session",
 ]
 
@@ -2704,9 +2534,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -2717,9 +2547,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.58"
+version = "0.4.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -2731,9 +2561,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2741,22 +2571,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
 dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
 dependencies = [
  "unicode-ident",
 ]
@@ -2797,9 +2627,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.85"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -2826,7 +2656,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2837,7 +2667,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2903,7 +2733,7 @@ dependencies = [
  "heck",
  "indexmap",
  "prettyplease",
- "syn 2.0.116",
+ "syn 2.0.117",
  "wasm-metadata",
  "wit-bindgen-core",
  "wit-component",
@@ -2919,7 +2749,7 @@ dependencies = [
  "prettyplease",
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
  "wit-bindgen-core",
  "wit-bindgen-rust",
 ]
@@ -2961,12 +2791,6 @@ dependencies = [
  "wasmparser",
 ]
 
-[[package]]
-name = "writeable"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
-
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -2976,101 +2800,24 @@ dependencies = [
  "tap",
 ]
 
-[[package]]
-name = "yoke"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
-dependencies = [
- "stable_deref_trait",
- "yoke-derive",
- "zerofrom",
-]
-
-[[package]]
-name = "yoke-derive"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.116",
- "synstructure",
-]
-
 [[package]]
 name = "zerocopy"
-version = "0.8.39"
+version = "0.8.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.116",
-]
-
-[[package]]
-name = "zerofrom"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
-dependencies = [
- "zerofrom-derive",
-]
-
-[[package]]
-name = "zerofrom-derive"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.116",
- "synstructure",
-]
-
-[[package]]
-name = "zerotrie"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
-dependencies = [
- "displaydoc",
- "yoke",
- "zerofrom",
-]
-
-[[package]]
-name = "zerovec"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
-dependencies = [
- "yoke",
- "zerofrom",
- "zerovec-derive",
-]
-
-[[package]]
-name = "zerovec-derive"
-version = "0.11.2"
+version = "0.8.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.116",
+ "syn 2.0.117",
 ]
 
 [[package]]
diff --git a/java/testfiles/src/main.rs b/java/testfiles/src/main.rs
index 206db638726..1db61c7f08b 100644
--- a/java/testfiles/src/main.rs
+++ b/java/testfiles/src/main.rs
@@ -5,16 +5,21 @@
 
 use std::path::Path;
 
+use vortex::VortexSessionDefault;
+use vortex::array::IntoArray;
 use vortex::array::arrays::StructArray;
-use vortex::array::builders::{ArrayBuilder, DecimalBuilder, VarBinViewBuilder};
+use vortex::array::builders::ArrayBuilder;
+use vortex::array::builders::DecimalBuilder;
+use vortex::array::builders::VarBinViewBuilder;
 use vortex::array::validity::Validity;
-use vortex::dtype::{DType, DecimalDType, Nullability};
+use vortex::dtype::DType;
+use vortex::dtype::DecimalDType;
+use vortex::dtype::Nullability;
 use vortex::file::WriteOptionsSessionExt;
-use vortex::io::runtime::current::CurrentThreadRuntime;
 use vortex::io::runtime::BlockingRuntime;
+use vortex::io::runtime::current::CurrentThreadRuntime;
 use vortex::io::session::RuntimeSessionExt;
 use vortex::session::VortexSession;
-use vortex::VortexSessionDefault;
 
 /// Generate a test dataset with the following small set of rows:
 ///
@@ -74,7 +79,8 @@ fn main() {
         10,
         Validity::NonNullable,
     )
-    .expect("Could not create struct array");
+    .expect("Could not create struct array")
+    .into_array();
 
     // Save to file
     let minimal_path = Path::new(env!("CARGO_MANIFEST_DIR"))
diff --git a/java/versions.lock b/java/versions.lock
deleted file mode 100644
index 88a7d21f0f5..00000000000
--- a/java/versions.lock
+++ /dev/null
@@ -1,411 +0,0 @@
-# Run ./gradlew writeVersionsLocks to regenerate this file. Blank lines are to minimize merge conflicts.
-
-com.clearspring.analytics:stream:2.9.8 (2 constraints: f219c36c)
-
-com.esotericsoftware:kryo-shaded:4.0.3 (3 constraints: cc27721b)
-
-com.esotericsoftware:minlog:1.3.0 (2 constraints: 241b55b7)
-
-com.fasterxml.jackson:jackson-bom:2.20.0 (3 constraints: e4396971)
-
-com.fasterxml.jackson.core:jackson-annotations:2.20 (8 constraints: 3385e8c6)
-
-com.fasterxml.jackson.core:jackson-core:2.20.0 (12 constraints: d6b49f0f)
-
-com.fasterxml.jackson.core:jackson-databind:2.20.0 (15 constraints: 2ee57295)
-
-com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.20.0 (3 constraints: cc28a571)
-
-com.fasterxml.jackson.module:jackson-module-scala_2.13:2.20.0 (4 constraints: 6b3931d4)
-
-com.github.luben:zstd-jni:1.5.7-6 (4 constraints: 42350924)
-
-com.google.code.findbugs:jsr305:3.0.2 (6 constraints: c455aae6)
-
-com.google.code.gson:gson:2.11.0 (2 constraints: 46198b34)
-
-com.google.crypto.tink:tink:1.16.0 (2 constraints: 531e1afd)
-
-com.google.errorprone:error_prone_annotations:2.41.0 (1 constraints: 490a3ebf)
-
-com.google.flatbuffers:flatbuffers-java:25.2.10 (3 constraints: c8279713)
-
-com.google.guava:failureaccess:1.0.3 (2 constraints: 1b0f8086)
-
-com.google.guava:guava:33.5.0-jre (2 constraints: d116aa2e)
-
-com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava (2 constraints: 692a93df)
-
-com.google.j2objc:j2objc-annotations:3.1 (1 constraints: b809f1a0)
-
-com.google.protobuf:protobuf-java:4.33.5 (4 constraints: df2b5f02)
-
-com.ibm.icu:icu4j:77.1 (2 constraints: 671acb77)
-
-com.jakewharton.nopen:nopen-annotations:1.0.1 (1 constraints: 0405f135)
-
-com.ning:compress-lzf:1.1.2 (2 constraints: d419256a)
-
-com.thoughtworks.paranamer:paranamer:2.8.3 (3 constraints: 512d6500)
-
-com.twitter:chill-java:0.10.0 (3 constraints: df234a78)
-
-com.twitter:chill_2.13:0.10.0 (3 constraints: 4a28a47f)
-
-com.univocity:univocity-parsers:2.9.1 (2 constraints: a01bb4f6)
-
-commons-codec:commons-codec:1.19.0 (5 constraints: 15468a82)
-
-commons-io:commons-io:2.21.0 (4 constraints: 8b37b3ef)
-
-commons-logging:commons-logging:1.3.0 (1 constraints: af1031b8)
-
-io.airlift:aircompressor:2.0.2 (3 constraints: 7e258cc5)
-
-io.dropwizard.metrics:metrics-core:4.2.37 (8 constraints: c47be587)
-
-io.dropwizard.metrics:metrics-graphite:4.2.37 (2 constraints: 4c1a4a9b)
-
-io.dropwizard.metrics:metrics-jmx:4.2.37 (2 constraints: 4c1a4a9b)
-
-io.dropwizard.metrics:metrics-json:4.2.37 (2 constraints: 4c1a4a9b)
-
-io.dropwizard.metrics:metrics-jvm:4.2.37 (2 constraints: 4c1a4a9b)
-
-io.jsonwebtoken:jjwt-api:0.12.6 (4 constraints: 0333016c)
-
-io.jsonwebtoken:jjwt-impl:0.12.6 (2 constraints: 3e1af599)
-
-io.jsonwebtoken:jjwt-jackson:0.12.6 (2 constraints: 3e1af599)
-
-io.netty:netty-all:4.2.7.Final (3 constraints: 643135fb)
-
-io.netty:netty-buffer:4.2.7.Final (25 constraints: 218d1e04)
-
-io.netty:netty-codec:4.2.7.Final (2 constraints: a9198d30)
-
-io.netty:netty-codec-base:4.2.7.Final (15 constraints: 25d3b40d)
-
-io.netty:netty-codec-classes-quic:4.2.7.Final (4 constraints: 7a37a99a)
-
-io.netty:netty-codec-compression:4.2.7.Final (5 constraints: 6340b61a)
-
-io.netty:netty-codec-dns:4.2.7.Final (3 constraints: 1e2899dd)
-
-io.netty:netty-codec-haproxy:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-http:4.2.7.Final (5 constraints: e443f0a0)
-
-io.netty:netty-codec-http2:4.2.7.Final (2 constraints: a9198d30)
-
-io.netty:netty-codec-http3:4.2.7.Final (2 constraints: a9198d30)
-
-io.netty:netty-codec-marshalling:4.2.7.Final (3 constraints: 3825eb9d)
-
-io.netty:netty-codec-memcache:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-mqtt:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-native-quic:4.2.7.Final (3 constraints: 5827a396)
-
-io.netty:netty-codec-protobuf:4.2.7.Final (3 constraints: 3825eb9d)
-
-io.netty:netty-codec-redis:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-smtp:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-socks:4.2.7.Final (3 constraints: 87281c0b)
-
-io.netty:netty-codec-stomp:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-codec-xml:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-common:4.2.7.Final (29 constraints: dbcba09e)
-
-io.netty:netty-handler:4.2.7.Final (9 constraints: 6580689e)
-
-io.netty:netty-handler-proxy:4.2.7.Final (2 constraints: a9198d30)
-
-io.netty:netty-handler-ssl-ocsp:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-resolver:4.2.7.Final (6 constraints: ba4fcab2)
-
-io.netty:netty-resolver-dns:4.2.7.Final (3 constraints: 792d6878)
-
-io.netty:netty-resolver-dns-classes-macos:4.2.7.Final (2 constraints: 341e795c)
-
-io.netty:netty-resolver-dns-native-macos:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-tcnative-boringssl-static:2.0.74.Final (3 constraints: 5d327650)
-
-io.netty:netty-tcnative-classes:2.0.74.Final (2 constraints: e3224c8b)
-
-io.netty:netty-transport:4.2.7.Final (23 constraints: e36836ed)
-
-io.netty:netty-transport-classes-epoll:4.2.7.Final (3 constraints: 242c1cc1)
-
-io.netty:netty-transport-classes-io_uring:4.2.7.Final (3 constraints: 642d855c)
-
-io.netty:netty-transport-classes-kqueue:4.2.7.Final (3 constraints: 982cedf6)
-
-io.netty:netty-transport-native-epoll:4.2.7.Final (5 constraints: 354cf2bd)
-
-io.netty:netty-transport-native-io_uring:4.2.7.Final (2 constraints: a9198d30)
-
-io.netty:netty-transport-native-kqueue:4.2.7.Final (4 constraints: 2e3c0713)
-
-io.netty:netty-transport-native-unix-common:4.2.7.Final (11 constraints: 16bb45a8)
-
-io.netty:netty-transport-rxtx:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-transport-sctp:4.2.7.Final (1 constraints: cb0afec4)
-
-io.netty:netty-transport-udt:4.2.7.Final (1 constraints: cb0afec4)
-
-jakarta.annotation:jakarta.annotation-api:2.1.1 (5 constraints: b5468312)
-
-jakarta.inject:jakarta.inject-api:2.0.1 (8 constraints: fc7b14ed)
-
-jakarta.servlet:jakarta.servlet-api:5.0.0 (2 constraints: d6196b6a)
-
-jakarta.validation:jakarta.validation-api:3.0.2 (2 constraints: bc1d564f)
-
-jakarta.ws.rs:jakarta.ws.rs-api:3.0.0 (6 constraints: 2a71295f)
-
-javax.annotation:javax.annotation-api:1.3.2 (3 constraints: 9e2a22fe)
-
-javax.servlet:javax.servlet-api:4.0.1 (2 constraints: d619636a)
-
-net.razorvine:pickle:1.5 (2 constraints: 1c19130f)
-
-net.sf.py4j:py4j:0.10.9.9 (2 constraints: 0e1ba9fb)
-
-org.antlr:antlr4-runtime:4.13.1 (2 constraints: 4c1b26f6)
-
-org.apache.arrow:arrow-c-data:18.3.0 (1 constraints: 3e05583b)
-
-org.apache.arrow:arrow-compression:18.3.0 (1 constraints: f60ce234)
-
-org.apache.arrow:arrow-format:18.3.0 (2 constraints: 1f1aad72)
-
-org.apache.arrow:arrow-memory-core:18.3.0 (7 constraints: 685f2dc7)
-
-org.apache.arrow:arrow-memory-netty:18.3.0 (3 constraints: 8f20bbf4)
-
-org.apache.arrow:arrow-memory-netty-buffer-patch:18.3.0 (2 constraints: 861ce438)
-
-org.apache.arrow:arrow-vector:18.3.0 (4 constraints: 5a37a125)
-
-org.apache.avro:avro:1.12.1 (3 constraints: 1b2506f8)
-
-org.apache.avro:avro-ipc:1.12.1 (2 constraints: 1119c626)
-
-org.apache.avro:avro-mapred:1.12.1 (2 constraints: 361a5399)
-
-org.apache.commons:commons-collections4:4.5.0 (2 constraints: de191f6b)
-
-org.apache.commons:commons-compress:1.28.0 (4 constraints: 0b33e88a)
-
-org.apache.commons:commons-crypto:1.1.0 (3 constraints: fb2a0ea2)
-
-org.apache.commons:commons-lang3:3.19.0 (6 constraints: 0e580fc4)
-
-org.apache.commons:commons-math3:3.6.1 (2 constraints: e019456b)
-
-org.apache.commons:commons-text:1.14.0 (2 constraints: 381a8699)
-
-org.apache.curator:curator-client:5.9.0 (2 constraints: a81c812d)
-
-org.apache.curator:curator-framework:5.9.0 (2 constraints: c51bf3e5)
-
-org.apache.curator:curator-recipes:5.9.0 (2 constraints: e819096c)
-
-org.apache.datasketches:datasketches-java:6.2.0 (2 constraints: 981b10f6)
-
-org.apache.datasketches:datasketches-memory:3.0.2 (2 constraints: 521e77cb)
-
-org.apache.hadoop:hadoop-client-api:3.4.2 (4 constraints: dc360ebb)
-
-org.apache.hadoop:hadoop-client-runtime:3.4.2 (4 constraints: 6730a1c5)
-
-org.apache.hive:hive-storage-api:2.8.1 (1 constraints: c50ce027)
-
-org.apache.ivy:ivy:2.5.3 (2 constraints: 1e1d617b)
-
-org.apache.logging.log4j:log4j-1.2-api:2.24.3 (3 constraints: da2f6971)
-
-org.apache.logging.log4j:log4j-api:2.24.3 (6 constraints: ab5e8bdb)
-
-org.apache.logging.log4j:log4j-core:2.24.3 (5 constraints: 0456b92c)
-
-org.apache.logging.log4j:log4j-layout-template-json:2.24.3 (3 constraints: da2f6971)
-
-org.apache.logging.log4j:log4j-slf4j2-impl:2.24.3 (3 constraints: da2f6971)
-
-org.apache.orc:orc-core:2.2.1 (1 constraints: bf0cce27)
-
-org.apache.orc:orc-format:1.1.1 (1 constraints: bd0cc627)
-
-org.apache.orc:orc-mapreduce:2.2.1 (1 constraints: bf0cce27)
-
-org.apache.orc:orc-shims:2.2.1 (2 constraints: f916de7d)
-
-org.apache.parquet:parquet-column:1.16.0 (2 constraints: ad1bcef4)
-
-org.apache.parquet:parquet-common:1.16.0 (4 constraints: 023acd6f)
-
-org.apache.parquet:parquet-encoding:1.16.0 (2 constraints: c01bebf8)
-
-org.apache.parquet:parquet-format-structures:1.16.0 (3 constraints: 762ae433)
-
-org.apache.parquet:parquet-hadoop:1.16.0 (1 constraints: f20cc534)
-
-org.apache.parquet:parquet-jackson:1.16.0 (2 constraints: ad1bcef4)
-
-org.apache.spark:spark-catalyst_2.13:4.1.1 (2 constraints: c711ff26)
-
-org.apache.spark:spark-common-utils-java_2.13:4.1.1 (3 constraints: 452edb59)
-
-org.apache.spark:spark-common-utils_2.13:4.1.1 (6 constraints: d052a763)
-
-org.apache.spark:spark-core_2.13:4.1.1 (3 constraints: 9b201cd7)
-
-org.apache.spark:spark-kvstore_2.13:4.1.1 (2 constraints: d819916a)
-
-org.apache.spark:spark-launcher_2.13:4.1.1 (2 constraints: d819916a)
-
-org.apache.spark:spark-network-common_2.13:4.1.1 (3 constraints: 6b2b82d5)
-
-org.apache.spark:spark-network-shuffle_2.13:4.1.1 (2 constraints: d819916a)
-
-org.apache.spark:spark-sketch_2.13:4.1.1 (3 constraints: ba29f91e)
-
-org.apache.spark:spark-sql-api_2.13:4.1.1 (2 constraints: 941ba8f5)
-
-org.apache.spark:spark-sql_2.13:4.1.1 (1 constraints: 08050336)
-
-org.apache.spark:spark-tags_2.13:4.1.1 (11 constraints: 3ea41436)
-
-org.apache.spark:spark-unsafe_2.13:4.1.1 (4 constraints: d2361402)
-
-org.apache.spark:spark-variant_2.13:4.1.1 (3 constraints: 8529a2f0)
-
-org.apache.ws.xmlschema:xmlschema-core:2.3.1 (2 constraints: 941ba0f5)
-
-org.apache.xbean:xbean-asm9-shaded:4.28 (2 constraints: ca1c9a47)
-
-org.apache.yetus:audience-annotations:0.12.0 (3 constraints: 362a1aa7)
-
-org.apache.zookeeper:zookeeper:3.9.4 (3 constraints: 7e28da5d)
-
-org.apache.zookeeper:zookeeper-jute:3.9.4 (2 constraints: 591aec42)
-
-org.bouncycastle:bcprov-jdk18on:1.80 (1 constraints: 81088d81)
-
-org.codehaus.janino:commons-compiler:3.1.9 (3 constraints: 6e2735a9)
-
-org.codehaus.janino:janino:3.1.9 (2 constraints: a21bc6f6)
-
-org.fusesource.leveldbjni:leveldbjni-all:1.8 (3 constraints: 5b2beb77)
-
-org.glassfish.hk2:hk2-api:3.0.6 (2 constraints: 30191619)
-
-org.glassfish.hk2:hk2-locator:3.0.6 (2 constraints: 061d752d)
-
-org.glassfish.hk2:hk2-utils:3.0.6 (3 constraints: e323c035)
-
-org.glassfish.hk2:osgi-resource-locator:1.0.3 (2 constraints: ac1d494e)
-
-org.glassfish.hk2.external:aopalliance-repackaged:3.0.6 (3 constraints: e323c035)
-
-org.glassfish.jersey.containers:jersey-container-servlet:3.0.18 (2 constraints: 441a849a)
-
-org.glassfish.jersey.containers:jersey-container-servlet-core:3.0.18 (3 constraints: 6332f4bf)
-
-org.glassfish.jersey.core:jersey-client:3.0.18 (3 constraints: 782ba076)
-
-org.glassfish.jersey.core:jersey-common:3.0.18 (7 constraints: 1e7f9e49)
-
-org.glassfish.jersey.core:jersey-server:3.0.18 (4 constraints: 584ca4a0)
-
-org.glassfish.jersey.inject:jersey-hk2:3.0.18 (2 constraints: 441a849a)
-
-org.immutables:value:2.12.1 (1 constraints: 3805363b)
-
-org.javassist:javassist:3.30.2-GA (3 constraints: 1f2c152b)
-
-org.jctools:jctools-core:4.0.5 (1 constraints: af08368a)
-
-org.json4s:json4s-ast_2.13:4.0.7 (3 constraints: f5252a5a)
-
-org.json4s:json4s-core_2.13:4.0.7 (2 constraints: 12193330)
-
-org.json4s:json4s-jackson-core_2.13:4.0.7 (2 constraints: 12193330)
-
-org.json4s:json4s-jackson_2.13:4.0.7 (3 constraints: 0d28f849)
-
-org.json4s:json4s-scalap_2.13:4.0.7 (2 constraints: d2172edd)
-
-org.jspecify:jspecify:1.0.0 (1 constraints: 130ae0b4)
-
-org.locationtech.jts:jts-core:1.20.0 (3 constraints: 1e26b429)
-
-org.lz4:lz4-java:1.8.0 (2 constraints: de19136b)
-
-org.objenesis:objenesis:3.4 (3 constraints: b2266f52)
-
-org.roaringbitmap:RoaringBitmap:1.3.0 (4 constraints: 923cb58a)
-
-org.rocksdb:rocksdbjni:9.8.4 (3 constraints: 992c4a61)
-
-org.scala-lang:scala-library:2.13.17 (14 constraints: 8bcc9cd3)
-
-org.scala-lang:scala-reflect:2.13.17 (3 constraints: 3629d01e)
-
-org.scala-lang.modules:scala-parallel-collections_2.13:1.2.0 (3 constraints: a328f396)
-
-org.scala-lang.modules:scala-parser-combinators_2.13:2.4.0 (2 constraints: e61a76c4)
-
-org.scala-lang.modules:scala-xml_2.13:2.4.0 (2 constraints: d8198d6a)
-
-org.slf4j:jcl-over-slf4j:2.0.17 (3 constraints: d72fb570)
-
-org.slf4j:jul-to-slf4j:2.0.17 (3 constraints: d72fb570)
-
-org.slf4j:slf4j-api:2.0.17 (32 constraints: c8b7441c)
-
-org.threeten:threeten-extra:1.8.0 (2 constraints: 0117967e)
-
-org.tukaani:xz:1.10 (2 constraints: 1217e075)
-
-org.xerial.snappy:snappy-java:1.1.10.8 (6 constraints: 1656e028)
-
-oro:oro:2.0.8 (2 constraints: 1e1d4d7b)
-
-
-
-[Test dependencies]
-
-ch.qos.logback:logback-classic:1.5.27 (1 constraints: 4105423b)
-
-ch.qos.logback:logback-core:1.5.27 (1 constraints: 400d472a)
-
-org.junit:junit-bom:6.0.2 (7 constraints: 6f74267c)
-
-org.junit.jupiter:junit-jupiter:6.0.2 (2 constraints: 821026dd)
-
-org.junit.jupiter:junit-jupiter-api:6.0.2 (4 constraints: 6f388b2c)
-
-org.junit.jupiter:junit-jupiter-engine:6.0.2 (2 constraints: 1317943b)
-
-org.junit.jupiter:junit-jupiter-params:6.0.2 (3 constraints: 1c1c12c8)
-
-org.junit.platform:junit-platform-commons:6.0.2 (3 constraints: e529462a)
-
-org.junit.platform:junit-platform-engine:6.0.2 (3 constraints: fd2b2315)
-
-org.junit.platform:junit-platform-launcher:6.0.2 (1 constraints: 0f097a95)
-
-org.opentest4j:opentest4j:1.3.0 (2 constraints: cf209249)
-
-org.slf4j:slf4j-simple:2.0.17 (1 constraints: 3c05323b)
diff --git a/java/versions.props b/java/versions.props
deleted file mode 100644
index a7195e64b84..00000000000
--- a/java/versions.props
+++ /dev/null
@@ -1,15 +0,0 @@
-#  SPDX-License-Identifier: Apache-2.0
-#  SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-com.google.errorprone:error_prone_core = 2.36.0
-com.google.guava:failureaccess = 1.0.3
-com.google.guava:guava = 33.5.0-jre
-com.google.guava:listenablefuture = 9999.0-empty-to-avoid-conflict-with-guava
-com.jakewharton.nopen:* = 1.0.1
-org.apache.spark:* = 4.1.1
-org.immutables:value = 2.12.1
-com.google.protobuf:protobuf-java = 4.33.5
-org.apache.arrow:* = 18.3.0
-
-# Test dependencies
-org.junit.jupiter:* = 6.0.2
diff --git a/java/vortex-jni/build.gradle.kts b/java/vortex-jni/build.gradle.kts
index ad7e2518f45..7bf389683c9 100644
--- a/java/vortex-jni/build.gradle.kts
+++ b/java/vortex-jni/build.gradle.kts
@@ -8,28 +8,31 @@ plugins {
     `java-library`
     `jvm-test-suite`
     id("com.google.protobuf")
-    id("com.gradleup.shadow") version "9.2.2"
+    id("com.gradleup.shadow") version "9.4.0"
 }
 
 dependencies {
-    implementation("org.apache.arrow:arrow-c-data")
-    implementation("org.apache.arrow:arrow-memory-core")
-    implementation("org.apache.arrow:arrow-memory-netty")
+    // Align Netty versions across Arrow and Spark
+    implementation(platform(libs.netty.bom))
 
-    compileOnly("org.immutables:value")
-    annotationProcessor("org.immutables:value")
+    implementation(libs.arrow.c.data)
+    implementation(libs.arrow.memory.core)
+    implementation(libs.arrow.memory.netty)
 
-    errorprone("com.google.errorprone:error_prone_core")
-    errorprone("com.jakewharton.nopen:nopen-checker")
+    compileOnly(libs.immutables.value)
+    annotationProcessor(libs.immutables.value)
 
-    implementation("com.google.guava:guava")
-    implementation("com.google.protobuf:protobuf-java")
-    compileOnly("com.google.errorprone:error_prone_annotations")
-    compileOnly("com.jakewharton.nopen:nopen-annotations")
+    errorprone(libs.errorprone.core)
+    errorprone(libs.nopen.checker)
+
+    implementation(libs.guava)
+    implementation(libs.protobuf.java)
+    compileOnly(libs.errorprone.annotations)
+    compileOnly(libs.nopen.annotations)
 
     // Logging
-    implementation("org.slf4j:slf4j-api:2.0.17")
-    testRuntimeOnly("ch.qos.logback:logback-classic:1.5.27")
+    implementation(libs.slf4j.api)
+    testRuntimeOnly(libs.logback.classic)
 }
 
 testing {
@@ -37,7 +40,7 @@ testing {
         val test by getting(JvmTestSuite::class) {
             useJUnitJupiter()
             dependencies {
-                implementation("org.junit.jupiter:junit-jupiter-params")
+                implementation(libs.junit.jupiter.params)
             }
         }
     }
@@ -90,7 +93,7 @@ tasks.withType<Test>().all {
 
 protobuf {
     protoc {
-        artifact = "com.google.protobuf:protoc:4.33.5"
+        artifact = "com.google.protobuf:protoc:${libs.versions.protobuf.get()}"
     }
 }
 
@@ -107,6 +110,7 @@ tasks.withType<ShadowJar> {
         // Note this class is not used by us, but required when loading the native lib
         exclude("org.apache.arrow.c.ArrayStreamExporter\$ExportedArrayStreamPrivateData")
     }
+    relocate("com.fasterxml.jackson", "dev.vortex.relocated.com.fasterxml.jackson")
 }
 
 tasks.build {
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/DType.java b/java/vortex-jni/src/main/java/dev/vortex/api/DType.java
index 4b483c1a140..2c190b07be8 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/DType.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/DType.java
@@ -46,10 +46,15 @@ public interface DType extends AutoCloseable {
     List<DType> getFieldTypes();
 
     /**
-     * Get the element type for a LIST type.
+     * Get the element type for a LIST or FIXED_SIZE_LIST type.
      */
     DType getElementType();
 
+    /**
+     * Get the fixed size for a FIXED_SIZE_LIST type.
+     */
+    int getFixedSizeListSize();
+
     /**
      * Checks if this data type represents a date.
      *
@@ -234,6 +239,19 @@ static DType newList(DType element, boolean isNullable) {
         return new JNIDType(NativeDTypeMethods.newList(jniType.getPointer(), isNullable), true);
     }
 
+    /**
+     * Create a new FixedSizeList data type.
+     *
+     * @param element    DType of the list elements
+     * @param size       The fixed size of each list
+     * @param isNullable True if the values can be null
+     * @return The new DType instance, allocated in native heap memory
+     */
+    static DType newFixedSizeList(DType element, int size, boolean isNullable) {
+        JNIDType jniType = (JNIDType) element;
+        return new JNIDType(NativeDTypeMethods.newFixedSizeList(jniType.getPointer(), size, isNullable), true);
+    }
+
     /**
      * Create a new Struct data type.
      *
@@ -467,12 +485,17 @@ enum Variant {
          * Decimal type for precise numeric values
          */
         DECIMAL,
+
+        /**
+         * Fixed-size list type containing a fixed number of elements of a single type
+         */
+        FIXED_SIZE_LIST,
         ;
 
         /**
          * Converts a byte value to the corresponding Variant enum.
          *
-         * @param variant the byte value representing the variant (0-18)
+         * @param variant the byte value representing the variant (0-19)
          * @return the corresponding {@link Variant} enum value
          * @throws RuntimeException if the variant value is not recognized
          */
@@ -516,6 +539,8 @@ public static Variant from(byte variant) {
                     return EXTENSION;
                 case 18:
                     return DECIMAL;
+                case 19:
+                    return FIXED_SIZE_LIST;
                 default:
                     throw new IllegalArgumentException("Unknown DType variant: " + variant);
             }
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 9790415436c..8dc4ec881b4 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
@@ -87,6 +87,14 @@ interface Visitor<T> {
          */
         T visitGetItem(GetItem getItem);
 
+        /**
+         * Visits an is null expression (null check).
+         *
+         * @param isNull the is null expression to visit
+         * @return the result of visiting the is null expression
+         */
+        T visitIsNull(IsNull isNull);
+
         /**
          * For expressions that do not have a specific visitor method.
          */
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/Files.java b/java/vortex-jni/src/main/java/dev/vortex/api/Files.java
index d4752e27401..8483c26be56 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/Files.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/Files.java
@@ -31,6 +31,15 @@ private Files() {}
     /**
      * Opens a Vortex file from the specified path string.
      *
+     * @see #open(String, Map)
+     */
+    public static File open(String path) {
+        return open(path, Map.of());
+    }
+
+    /**
+     * Opens a Vortex file from the specified path string and format parameters.
+     *
      * <p>This method provides a convenient way to open Vortex files using either
      * absolute file system paths or URI strings. If the path starts with "/",
      * it is treated as an absolute file system path and converted to a file URI.
@@ -42,16 +51,15 @@ private Files() {}
      * @param path the path to the Vortex file, either as an absolute file system path
      *             (starting with "/") or as a URI string
      * @return a {@link File} instance representing the opened Vortex file
-     * @throws RuntimeException if the file cannot be opened or the path is invalid
+     * @throws RuntimeException     if the file cannot be opened or the path is invalid
      * @throws NullPointerException if path is null
-     *
      * @see #open(URI, Map)
      */
-    public static File open(String path) {
+    public static File open(String path, Map<String, String> properties) {
         if (path.startsWith("/")) {
-            return open(Paths.get(path).toUri(), Map.of());
+            return open(Paths.get(path).toUri(), properties);
         }
-        return open(URI.create(path), Map.of());
+        return open(URI.create(path), properties);
     }
 
     /**
@@ -66,14 +74,13 @@ public static File open(String path) {
      * underlying file system or storage layer. The specific properties supported
      * depend on the URI scheme and storage backend being used.
      *
-     * @param uri the URI pointing to the Vortex file to open
+     * @param uri        the URI pointing to the Vortex file to open
      * @param properties a map of configuration properties for opening the file;
      *                   may be empty but must not be null
      * @return a {@link File} instance representing the opened Vortex file
-     * @throws RuntimeException if the file cannot be opened, the URI is invalid,
-     *                                  or the returned native pointer is invalid
+     * @throws RuntimeException     if the file cannot be opened, the URI is invalid,
+     *                              or the returned native pointer is invalid
      * @throws NullPointerException if uri or properties is null
-     *
      * @see #open(String)
      */
     public static File open(URI uri, Map<String, String> properties) {
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/VortexWriter.java b/java/vortex-jni/src/main/java/dev/vortex/api/VortexWriter.java
index 9714399b739..9bc5dfd0cf3 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/VortexWriter.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/VortexWriter.java
@@ -42,6 +42,18 @@ static VortexWriter create(String uri, DType dtype, Map<String, String> options)
      */
     void writeBatch(byte[] arrowData) throws IOException;
 
+    /**
+     * Writes a batch of Arrow data directly from Arrow C Data Interface pointers.
+     * <p>
+     * This avoids the IPC serialization overhead by accepting raw memory addresses
+     * of ArrowArray and ArrowSchema structs.
+     *
+     * @param arrowArrayAddr  memory address of the ArrowArray struct
+     * @param arrowSchemaAddr memory address of the ArrowSchema struct
+     * @throws IOException if writing fails
+     */
+    void writeBatchFfi(long arrowArrayAddr, long arrowSchemaAddr) throws IOException;
+
     /**
      * Closes the writer and finalizes the Vortex file.
      * <p>
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/expressions/IsNull.java b/java/vortex-jni/src/main/java/dev/vortex/api/expressions/IsNull.java
new file mode 100644
index 00000000000..834cc6d5494
--- /dev/null
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/expressions/IsNull.java
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.api.expressions;
+
+import dev.vortex.api.Expression;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Represents an IS NULL expression that checks whether values are null.
+ * This expression returns true for null values and false for non-null values.
+ */
+public final class IsNull implements Expression {
+    private final Expression child;
+
+    private IsNull(Expression child) {
+        this.child = child;
+    }
+
+    /**
+     * Parses an IsNull expression from serialized metadata and child expressions.
+     * This method is used during deserialization of Vortex expressions.
+     *
+     * @param metadata the serialized metadata, must be empty for IsNull expressions
+     * @param children the child expressions, must contain exactly one element
+     * @return a new IsNull expression parsed from the provided data
+     * @throws IllegalArgumentException if the number of children is not exactly one,
+     *                                  or if metadata is not empty
+     */
+    public static IsNull parse(byte[] metadata, List<Expression> children) {
+        if (children.size() != 1) {
+            throw new IllegalArgumentException(
+                    "IsNull expression must have exactly one child, found: " + children.size());
+        }
+        if (metadata.length > 0) {
+            throw new IllegalArgumentException(
+                    "IsNull expression must not have metadata, found: " + metadata.length);
+        }
+        return new IsNull(children.get(0));
+    }
+
+    /**
+     * Creates a new IsNull expression that checks nullity of the given child expression.
+     *
+     * @param child the expression to check for null values
+     * @return a new IsNull expression
+     */
+    public static IsNull of(Expression child) {
+        return new IsNull(child);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        IsNull other = (IsNull) o;
+        return Objects.equals(child, other.child);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(child);
+    }
+
+    @Override
+    public String id() {
+        return "vortex.is_null";
+    }
+
+    @Override
+    public List<Expression> children() {
+        return List.of(child);
+    }
+
+    @Override
+    public Optional<byte[]> metadata() {
+        return Optional.of(new byte[] {});
+    }
+
+    @Override
+    public String toString() {
+        return "vortex.is_null(" + child + ")";
+    }
+
+    /**
+     * Returns the child expression that will be checked for null values.
+     *
+     * @return the child expression
+     */
+    public Expression getChild() {
+        return child;
+    }
+
+    @Override
+    public <T> T accept(Visitor<T> visitor) {
+        return visitor.visitIsNull(this);
+    }
+}
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/proto/Expressions.java b/java/vortex-jni/src/main/java/dev/vortex/api/proto/Expressions.java
index b0bd6c0abbc..dc2464851f2 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/proto/Expressions.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/proto/Expressions.java
@@ -56,6 +56,8 @@ public static Expression deserialize(ExprProtos.Expr expr) {
                 return Literal.parse(metadata, children);
             case "vortex.not":
                 return Not.parse(metadata, children);
+            case "vortex.is_null":
+                return IsNull.parse(metadata, children);
             default:
                 return new Unknown(expr.getId(), children, expr.getMetadata().toByteArray());
         }
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/JNIDType.java b/java/vortex-jni/src/main/java/dev/vortex/jni/JNIDType.java
index 016026bdc42..d19dc0624e7 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/JNIDType.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/JNIDType.java
@@ -64,6 +64,11 @@ public DType getElementType() {
         return new JNIDType(NativeDTypeMethods.getElementType(pointer.getAsLong()));
     }
 
+    @Override
+    public int getFixedSizeListSize() {
+        return NativeDTypeMethods.getFixedSizeListSize(pointer.getAsLong());
+    }
+
     @Override
     public boolean isDate() {
         return NativeDTypeMethods.isDate(pointer.getAsLong());
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/JNIWriter.java b/java/vortex-jni/src/main/java/dev/vortex/jni/JNIWriter.java
index 7fb69248808..6b0c62ca091 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/JNIWriter.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/JNIWriter.java
@@ -48,6 +48,24 @@ public void writeBatch(byte[] arrowData) throws IOException {
         }
     }
 
+    /**
+     * Writes a batch of Arrow data directly from Arrow C Data Interface pointers.
+     *
+     * @param arrowArrayAddr  memory address of the ArrowArray struct
+     * @param arrowSchemaAddr memory address of the ArrowSchema struct
+     * @throws IOException if writing fails
+     */
+    @Override
+    public void writeBatchFfi(long arrowArrayAddr, long arrowSchemaAddr) throws IOException {
+        logger.trace("Writing batch via FFI (arrayAddr={}, schemaAddr={})", arrowArrayAddr, arrowSchemaAddr);
+
+        boolean success = NativeWriterMethods.writeBatchFfi(ptr.getAsLong(), arrowArrayAddr, arrowSchemaAddr);
+        if (!success) {
+            logger.error("Failed to write FFI batch to Vortex file");
+            throw new IOException("Failed to write FFI batch to Vortex file");
+        }
+    }
+
     /**
      * Closes the writer and finalizes the Vortex file.
      *
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeDTypeMethods.java b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeDTypeMethods.java
index 1d6c73af743..a59fc9f95d8 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeDTypeMethods.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeDTypeMethods.java
@@ -103,6 +103,16 @@ private NativeDTypeMethods() {}
      */
     public static native long newList(long elementTypePtr, boolean isNullable);
 
+    /**
+     * Create a new native DType for a FixedSizeList type. The created object lives in native memory.
+     *
+     * @param elementTypePtr A native pointer to a DType containing the type of the elements
+     * @param size           The fixed size of each list
+     * @param isNullable     true if the values can be null
+     * @return Pointer to a new heap-allocated {@code DType}.
+     */
+    public static native long newFixedSizeList(long elementTypePtr, int size, boolean isNullable);
+
     /**
      * Create a new native DType for a Struct type. The created object lives in native memory.
      *
@@ -154,6 +164,8 @@ private NativeDTypeMethods() {}
 
     public static native long getElementType(long pointer);
 
+    public static native int getFixedSizeListSize(long pointer);
+
     public static native boolean isDate(long pointer);
 
     public static native boolean isTime(long pointer);
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeWriterMethods.java b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeWriterMethods.java
index 1cb5c543427..8ddc7ce0bb1 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeWriterMethods.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeWriterMethods.java
@@ -35,6 +35,16 @@ private NativeWriterMethods() {}
      */
     public static native boolean writeBatch(long writerPtr, byte[] arrowData);
 
+    /**
+     * Writes a batch of Arrow data to the Vortex file directly from Arrow C Data Interface pointers.
+     *
+     * @param writerPtr       the native writer pointer
+     * @param arrowArrayAddr  memory address of the ArrowArray struct
+     * @param arrowSchemaAddr memory address of the ArrowSchema struct
+     * @return true if successful, false otherwise
+     */
+    public static native boolean writeBatchFfi(long writerPtr, long arrowArrayAddr, long arrowSchemaAddr);
+
     /**
      * Close and flush the writer, finalizing it to the storage system.
      *
diff --git a/java/vortex-jni/src/test/java/dev/vortex/api/DTypeTest.java b/java/vortex-jni/src/test/java/dev/vortex/api/DTypeTest.java
new file mode 100644
index 00000000000..6946812e1b0
--- /dev/null
+++ b/java/vortex-jni/src/test/java/dev/vortex/api/DTypeTest.java
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.api;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+public final class DTypeTest {
+
+    @Test
+    public void testNewFixedSizeListNonNullable() {
+        var elementType = DType.newInt(false);
+        var fslType = DType.newFixedSizeList(elementType, 3, false);
+        assertEquals(DType.Variant.FIXED_SIZE_LIST, fslType.getVariant());
+        assertFalse(fslType.isNullable());
+        assertEquals(3, fslType.getFixedSizeListSize());
+
+        var innerType = fslType.getElementType();
+        assertEquals(DType.Variant.PRIMITIVE_I32, innerType.getVariant());
+    }
+
+    @Test
+    public void testNewFixedSizeListNullable() {
+        var elementType = DType.newUtf8(true);
+        var fslType = DType.newFixedSizeList(elementType, 5, true);
+        assertEquals(DType.Variant.FIXED_SIZE_LIST, fslType.getVariant());
+        assertTrue(fslType.isNullable());
+        assertEquals(5, fslType.getFixedSizeListSize());
+
+        var innerType = fslType.getElementType();
+        assertEquals(DType.Variant.UTF8, innerType.getVariant());
+    }
+
+    @Test
+    public void testNewListGetElementType() {
+        var elementType = DType.newDouble(false);
+        var listType = DType.newList(elementType, false);
+        assertEquals(DType.Variant.LIST, listType.getVariant());
+
+        var innerType = listType.getElementType();
+        assertEquals(DType.Variant.PRIMITIVE_F64, innerType.getVariant());
+    }
+
+    @Test
+    public void testNestedFixedSizeList() {
+        var innerElement = DType.newLong(false);
+        var innerFsl = DType.newFixedSizeList(innerElement, 2, false);
+        var outerFsl = DType.newFixedSizeList(innerFsl, 4, true);
+        assertEquals(DType.Variant.FIXED_SIZE_LIST, outerFsl.getVariant());
+        assertTrue(outerFsl.isNullable());
+        assertEquals(4, outerFsl.getFixedSizeListSize());
+
+        var inner = outerFsl.getElementType();
+        assertEquals(DType.Variant.FIXED_SIZE_LIST, inner.getVariant());
+    }
+
+    @Test
+    public void testFixedSizeListInStruct() {
+        var elementType = DType.newFloat(false);
+        var fslType = DType.newFixedSizeList(elementType, 3, false);
+        var structType =
+                DType.newStruct(new String[] {"id", "embedding"}, new DType[] {DType.newInt(false), fslType}, false);
+        assertEquals(DType.Variant.STRUCT, structType.getVariant());
+
+        var fieldTypes = structType.getFieldTypes();
+        assertEquals(2, fieldTypes.size());
+
+        var embeddingType = fieldTypes.get(1);
+        assertEquals(DType.Variant.FIXED_SIZE_LIST, embeddingType.getVariant());
+    }
+}
diff --git a/java/vortex-jni/src/test/java/dev/vortex/api/expressions/proto/TestExpressionProtos.java b/java/vortex-jni/src/test/java/dev/vortex/api/expressions/proto/TestExpressionProtos.java
index d35544904ac..f3e9fffd081 100644
--- a/java/vortex-jni/src/test/java/dev/vortex/api/expressions/proto/TestExpressionProtos.java
+++ b/java/vortex-jni/src/test/java/dev/vortex/api/expressions/proto/TestExpressionProtos.java
@@ -22,4 +22,12 @@ public void testRoundTrip() {
         Expression deserialized = Expressions.deserialize(proto);
         assertEquals(expression, deserialized);
     }
+
+    @Test
+    public void testIsNullRoundTrip() {
+        Expression expression = IsNull.of(GetItem.of(Root.INSTANCE, "a.b.c"));
+        ExprProtos.Expr proto = Expressions.serialize(expression);
+        Expression deserialized = Expressions.deserialize(proto);
+        assertEquals(expression, deserialized);
+    }
 }
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 44a0a247047..3a9e356d2fa 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
@@ -3,16 +3,31 @@
 
 package dev.vortex.jni;
 
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import dev.vortex.api.DType;
+import dev.vortex.api.ScanOptions;
 import dev.vortex.api.VortexWriter;
+import dev.vortex.arrow.ArrowAllocation;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.Map;
+import org.apache.arrow.c.ArrowArray;
+import org.apache.arrow.c.ArrowSchema;
+import org.apache.arrow.c.Data;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+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;
@@ -58,4 +73,66 @@ public void testCreateWriter() throws IOException {
         assertTrue(Files.exists(outputPath), "Output file should exist");
         System.err.println("File created at: " + outputPath);
     }
+
+    @Test
+    public void testWriteBatchFfi() throws IOException {
+        Path outputPath = tempDir.resolve("test_ffi.vortex");
+        String writePath = outputPath.toAbsolutePath().toUri().toString();
+
+        var writeSchema = DType.newStruct(
+                new String[] {"name", "age"}, new DType[] {DType.newUtf8(false), DType.newInt(false)}, false);
+
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+
+        Schema arrowSchema = new Schema(java.util.List.of(
+                new Field("name", FieldType.notNullable(new ArrowType.Utf8()), null),
+                new Field("age", FieldType.notNullable(new ArrowType.Int(32, true)), null)));
+
+        try (VortexWriter writer = VortexWriter.create(writePath, writeSchema, new HashMap<>())) {
+            // Build a batch with Arrow Java
+            try (VectorSchemaRoot root = VectorSchemaRoot.create(arrowSchema, allocator)) {
+                VarCharVector nameVec = (VarCharVector) root.getVector("name");
+                IntVector ageVec = (IntVector) root.getVector("age");
+
+                nameVec.allocateNew(3);
+                ageVec.allocateNew(3);
+
+                nameVec.setSafe(0, "Alice".getBytes(UTF_8));
+                nameVec.setSafe(1, "Bob".getBytes(UTF_8));
+                nameVec.setSafe(2, "Carol".getBytes(UTF_8));
+                ageVec.setSafe(0, 30);
+                ageVec.setSafe(1, 25);
+                ageVec.setSafe(2, 40);
+
+                root.setRowCount(3);
+
+                // Export to C Data Interface
+                try (ArrowArray arrowArray = ArrowArray.allocateNew(allocator);
+                        ArrowSchema arrowSchemaFfi = ArrowSchema.allocateNew(allocator)) {
+                    Data.exportVectorSchemaRoot(allocator, root, null, arrowArray, arrowSchemaFfi);
+
+                    writer.writeBatchFfi(arrowArray.memoryAddress(), arrowSchemaFfi.memoryAddress());
+                }
+            }
+        }
+
+        assertTrue(Files.exists(outputPath), "Output file should exist");
+
+        // Read back and verify
+        try (var file = dev.vortex.api.Files.open(outputPath.toAbsolutePath().toString());
+                var scan = file.newScan(ScanOptions.of())) {
+            assertEquals(3, file.rowCount());
+
+            var batch = scan.next();
+            var nameField = batch.getField(0);
+            var ageField = batch.getField(1);
+
+            assertEquals("Alice", nameField.getUTF8(0));
+            assertEquals("Bob", nameField.getUTF8(1));
+            assertEquals("Carol", nameField.getUTF8(2));
+            assertEquals(30, ageField.getInt(0));
+            assertEquals(25, ageField.getInt(1));
+            assertEquals(40, ageField.getInt(2));
+        }
+    }
 }
diff --git a/java/vortex-spark/build.gradle.kts b/java/vortex-spark/build.gradle.kts
index e091160a6fc..f5fb83fe7ba 100644
--- a/java/vortex-spark/build.gradle.kts
+++ b/java/vortex-spark/build.gradle.kts
@@ -3,24 +3,45 @@
 
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 
-apply(plugin = "com.vanniktech.maven.publish")
-
 plugins {
     `java-library`
     `jvm-test-suite`
-    id("com.gradleup.shadow") version "9.2.2"
+    id("com.gradleup.shadow") version "9.4.0"
 }
 
+// Derive Scala and Spark versions from the Gradle project name (vortex-spark_2.12 or vortex-spark_2.13)
+val scalaVersion: String = project.name.substringAfterLast("_")
+val sparkVersion: String =
+    when (scalaVersion) {
+        "2.12" -> {
+            libs.versions.spark3.get()
+        }
+
+        "2.13" -> {
+            libs.versions.spark4.get()
+        }
+
+        else -> {
+            throw GradleException(
+                "Unsupported Scala version: $scalaVersion (project name must end with _2.12 or _2.13)",
+            )
+        }
+    }
+
+// Both vortex-spark_2.12 and vortex-spark_2.13 share this projectDir.
+// Give each its own build directory to avoid output conflicts.
+layout.buildDirectory = layout.projectDirectory.dir("build/${project.name}")
+
 dependencies {
-    compileOnly("org.apache.spark:spark-catalyst_2.13")
-    compileOnly("org.apache.spark:spark-sql_2.13")
+    compileOnly("org.apache.spark:spark-catalyst_$scalaVersion:$sparkVersion")
+    compileOnly("org.apache.spark:spark-sql_$scalaVersion:$sparkVersion")
     api(project(":vortex-jni", configuration = "shadow"))
 
-    compileOnly("org.immutables:value")
-    annotationProcessor("org.immutables:value")
+    compileOnly(libs.immutables.value)
+    annotationProcessor(libs.immutables.value)
 
-    implementation("com.google.guava:guava")
-    implementation("org.slf4j:slf4j-api:2.0.17")
+    implementation(libs.guava)
+    implementation(libs.slf4j.api)
 }
 
 testing {
@@ -29,24 +50,30 @@ testing {
             useJUnitJupiter()
 
             dependencies {
-                implementation("org.junit.jupiter:junit-jupiter:6.0.2")
-                implementation("org.apache.spark:spark-core_2.13")
-                implementation("org.apache.spark:spark-sql_2.13")
-                runtimeOnly("org.slf4j:slf4j-simple:2.0.17")
+                implementation(libs.junit.jupiter)
+                implementation("org.apache.spark:spark-core_$scalaVersion:$sparkVersion")
+                implementation("org.apache.spark:spark-sql_$scalaVersion:$sparkVersion")
+                implementation(libs.s3mock.testcontainers)
+                implementation(libs.testcontainers.juputer)
+                runtimeOnly(libs.slf4j.simple)
+                if (scalaVersion == "2.12") {
+                    // Spark 3.5 marks javax.servlet-api as provided; needed at test runtime for MetricsServlet
+                    runtimeOnly("javax.servlet:javax.servlet-api:4.0.1")
+                }
             }
         }
     }
 }
 
 mavenPublishing {
-    coordinates(groupId = "dev.vortex", artifactId = "vortex-spark", version = "${rootProject.version}")
+    coordinates(groupId = "dev.vortex", artifactId = "vortex-spark_$scalaVersion", version = "${rootProject.version}")
 
     publishToMavenCentral()
 
     signAllPublications()
 
     pom {
-        name = "vortex-spark"
+        name = "vortex-spark_$scalaVersion"
         description = project.description
         url = "https://vortex.dev"
         inceptionYear = "2025"
@@ -89,6 +116,7 @@ tasks.withType<ShadowJar> {
         // Note this class is not used by us, but required when loading the native lib
         exclude("org.apache.arrow.c.ArrayStreamExporter\$ExportedArrayStreamPrivateData")
     }
+    relocate("com.fasterxml.jackson", "dev.vortex.relocated.com.fasterxml.jackson")
 }
 
 tasks.withType<Test>().all {
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/SparkTypes.java b/java/vortex-spark/src/main/java/dev/vortex/spark/SparkTypes.java
index ed5392a5af3..bcd4aed6219 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/SparkTypes.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/SparkTypes.java
@@ -121,6 +121,7 @@ public static DataType toDataType(DType dType) {
 
                 return DataTypes.createStructType(fields);
             case LIST:
+            case FIXED_SIZE_LIST:
                 return DataTypes.createArrayType(toDataType(dType.getElementType()), dType.isNullable());
             case EXTENSION:
                 /*
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexDataSourceV2.java b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexDataSourceV2.java
index 4ea28289e43..66f3e5f001c 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexDataSourceV2.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexDataSourceV2.java
@@ -5,20 +5,29 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import dev.vortex.api.File;
 import dev.vortex.api.Files;
 import dev.vortex.jni.NativeFileMethods;
+import dev.vortex.spark.config.HadoopUtils;
+import dev.vortex.spark.read.PartitionPathUtils;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.spark.sql.SparkSession;
 import org.apache.spark.sql.connector.catalog.CatalogV2Util;
 import org.apache.spark.sql.connector.catalog.Table;
 import org.apache.spark.sql.connector.catalog.TableProvider;
 import org.apache.spark.sql.connector.expressions.Transform;
 import org.apache.spark.sql.sources.DataSourceRegister;
+import org.apache.spark.sql.types.DataType;
 import org.apache.spark.sql.types.StructType;
 import org.apache.spark.sql.util.CaseInsensitiveStringMap;
+import scala.Option;
 
 /**
  * Spark V2 data source for reading and writing Vortex files.
@@ -33,13 +42,17 @@ public final class VortexDataSourceV2 implements TableProvider, DataSourceRegist
     private static final String PATH_KEY = "path";
     private static final String PATHS_KEY = "paths";
 
+    private final Option<SparkSession> sparkSession;
+
     /**
      * Creates a new instance of the Vortex data source.
      * <p>
      * This no-argument constructor is required for Spark to instantiate the data source
      * through reflection.
      */
-    public VortexDataSourceV2() {}
+    public VortexDataSourceV2() {
+        this.sparkSession = SparkSession.getActiveSession();
+    }
 
     /**
      * Infers the schema of the Vortex files specified in the options.
@@ -64,26 +77,40 @@ public StructType inferSchema(CaseInsensitiveStringMap options) {
             return new StructType();
         }
 
+        var formatOptions = buildDataSourceOptions(options.asCaseSensitiveMap());
+
         var pathToInfer = Objects.requireNonNull(Iterables.getLast(paths));
         // If the path is a directory, scan the directory for a file and use that file
         if (!pathToInfer.endsWith(".vortex")) {
-            Optional<String> firstFile =
-                    NativeFileMethods.listVortexFiles(pathToInfer, options.asCaseSensitiveMap()).stream()
-                            .findFirst();
+            Optional<String> firstFile = NativeFileMethods.listVortexFiles(pathToInfer, formatOptions).stream()
+                    .findFirst();
 
             if (firstFile.isEmpty()) {
-                // Return empty struct if no files found
-                // TODO(aduffy): how does Parquet handle this?
                 return new StructType();
             } else {
                 pathToInfer = firstFile.get();
             }
         }
 
-        try (File file = Files.open(pathToInfer)) {
+        StructType dataSchema;
+        try (File file = Files.open(pathToInfer, formatOptions)) {
             var columns = SparkTypes.toColumns(file.getDType());
-            return CatalogV2Util.v2ColumnsToStructType(columns);
+            dataSchema = CatalogV2Util.v2ColumnsToStructType(columns);
         }
+
+        // Discover partition columns from Hive-style directory paths and append them.
+        Map<String, String> partitionValues = PartitionPathUtils.parsePartitionValues(pathToInfer);
+        if (!partitionValues.isEmpty()) {
+            Set<String> dataColumnNames = Stream.of(dataSchema.fieldNames()).collect(Collectors.toSet());
+            for (Map.Entry<String, String> entry : partitionValues.entrySet()) {
+                if (!dataColumnNames.contains(entry.getKey())) {
+                    DataType type = PartitionPathUtils.inferPartitionColumnType(entry.getValue());
+                    dataSchema = dataSchema.add(entry.getKey(), type, true);
+                }
+            }
+        }
+
+        return dataSchema;
     }
 
     /**
@@ -93,17 +120,16 @@ public StructType inferSchema(CaseInsensitiveStringMap options) {
      * Vortex files. The partitioning parameter is currently ignored.
      *
      * @param schema        the table schema
-     * @param _partitioning table partitioning transforms (currently ignored)
+     * @param partitioning table partitioning transforms
      * @param properties    the table properties containing file paths and other options
      * @return a VortexTable instance for reading and writing data
      * @throws RuntimeException if required path properties are missing
      */
     @Override
-    public Table getTable(StructType schema, Transform[] _partitioning, Map<String, String> properties) {
+    public Table getTable(StructType schema, Transform[] partitioning, Map<String, String> properties) {
         var uncased = new CaseInsensitiveStringMap(properties);
-
         ImmutableList<String> paths = getPaths(uncased);
-        return new VortexTable(paths, schema, properties);
+        return new VortexTable(paths, schema, buildDataSourceOptions(properties), partitioning);
     }
 
     /**
@@ -132,6 +158,20 @@ public String shortName() {
         return "vortex";
     }
 
+    private Map<String, String> buildDataSourceOptions(Map<String, String> properties) {
+        var hadoopConf = sparkSession.get().sessionState().newHadoopConf();
+
+        var options = ImmutableMap.<String, String>builder();
+        options.putAll(properties);
+
+        // Forward any S3-relevant properties from hadoopConf to the reader config.
+        options.putAll(HadoopUtils.s3PropertiesFromHadoopConf(hadoopConf));
+        // Forward any Azure-relevant properties from hadoopConf to the reader config.
+        options.putAll(HadoopUtils.azurePropertiesFromHadoopConf(hadoopConf));
+
+        return options.build();
+    }
+
     private static ImmutableList<String> getPaths(CaseInsensitiveStringMap uncased) {
         if (uncased.containsKey(PATH_KEY)) {
             return ImmutableList.of(uncased.get(PATH_KEY));
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexFilePartition.java b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexFilePartition.java
index eb3712c57b9..7d88f8469c4 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexFilePartition.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexFilePartition.java
@@ -4,7 +4,9 @@
 package dev.vortex.spark;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import java.io.Serializable;
+import java.util.Map;
 import org.apache.spark.sql.connector.catalog.Column;
 import org.apache.spark.sql.connector.read.InputPartition;
 
@@ -18,16 +20,26 @@
 public final class VortexFilePartition implements InputPartition, Serializable {
     private final String path;
     private final ImmutableList<Column> columns;
+    private final ImmutableMap<String, String> formatOptions;
+    private final ImmutableMap<String, String> partitionValues;
 
     /**
      * Creates a new Vortex file partition.
      *
      * @param path the file system path to the Vortex file
      * @param columns the list of columns to read from the file
+     * @param formatOptions options for accessing the file (S3/Azure credentials, etc.)
+     * @param partitionValues Hive-style partition column values extracted from the file path
      */
-    public VortexFilePartition(String path, ImmutableList<Column> columns) {
+    public VortexFilePartition(
+            String path,
+            ImmutableList<Column> columns,
+            ImmutableMap<String, String> formatOptions,
+            ImmutableMap<String, String> partitionValues) {
         this.path = path;
         this.columns = columns;
+        this.formatOptions = formatOptions;
+        this.partitionValues = partitionValues;
     }
 
     /**
@@ -47,4 +59,18 @@ public String getPath() {
     public ImmutableList<Column> getColumns() {
         return columns;
     }
+
+    public Map<String, String> getFormatOptions() {
+        return formatOptions;
+    }
+
+    /**
+     * Returns the partition column values parsed from this file's Hive-style directory path.
+     * Keys are column names, values are the string-encoded partition values.
+     *
+     * @return the partition values, empty if the file is not in a partitioned directory
+     */
+    public ImmutableMap<String, String> getPartitionValues() {
+        return partitionValues;
+    }
 }
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexTable.java b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexTable.java
index 66185e2c641..d650923ee7f 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/VortexTable.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/VortexTable.java
@@ -11,6 +11,7 @@
 import java.util.Map;
 import java.util.Set;
 import org.apache.spark.sql.connector.catalog.*;
+import org.apache.spark.sql.connector.expressions.Transform;
 import org.apache.spark.sql.connector.read.ScanBuilder;
 import org.apache.spark.sql.connector.write.LogicalWriteInfo;
 import org.apache.spark.sql.connector.write.WriteBuilder;
@@ -26,14 +27,20 @@ public final class VortexTable implements Table, SupportsRead, SupportsWrite {
     private final ImmutableList<String> paths;
     private final StructType schema;
     private final Map<String, String> formatOptions;
+    private final Transform[] partitionTransforms;
 
     /**
      * Creates a new VortexTable with read/write support.
      */
-    public VortexTable(ImmutableList<String> paths, StructType schema, Map<String, String> formatOptions) {
+    public VortexTable(
+            ImmutableList<String> paths,
+            StructType schema,
+            Map<String, String> formatOptions,
+            Transform[] partitionTransforms) {
         this.paths = paths;
         this.schema = schema;
         this.formatOptions = formatOptions;
+        this.partitionTransforms = partitionTransforms;
     }
 
     /**
@@ -93,7 +100,17 @@ public StructType schema() {
     public WriteBuilder newWriteBuilder(LogicalWriteInfo info) {
         // Make sure only one write path was provided.
         String writePath = Iterables.getOnlyElement(paths);
-        return new VortexWriteBuilder(writePath, info, formatOptions);
+        return new VortexWriteBuilder(writePath, info, formatOptions, partitionTransforms);
+    }
+
+    /**
+     * Returns the partitioning transforms for this table.
+     *
+     * @return an array of partition transforms
+     */
+    @Override
+    public Transform[] partitioning() {
+        return partitionTransforms;
     }
 
     /**
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/config/HadoopUtils.java b/java/vortex-spark/src/main/java/dev/vortex/spark/config/HadoopUtils.java
new file mode 100644
index 00000000000..d091269df0a
--- /dev/null
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/config/HadoopUtils.java
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark.config;
+
+import java.util.Map;
+import org.apache.hadoop.conf.Configuration;
+
+public final class HadoopUtils {
+    private HadoopUtils() {}
+
+    static final String FS_S3A_ACCESS_KEY = "fs.s3a.access.key";
+    static final String FS_S3A_SECRET_KEY = "fs.s3a.secret.key";
+    static final String FS_S3A_SESSION_TOKEN = "fs.s3a.session.token";
+    static final String FS_S3A_ENDPOINT = "fs.s3a.endpoint";
+    static final String FS_S3A_ENDPOINT_REGION = "fs.s3a.endpoint.region";
+
+    public static Map<String, String> s3PropertiesFromHadoopConf(Configuration hadoopConf) {
+        VortexS3Properties properties = new VortexS3Properties();
+
+        for (Map.Entry<String, String> entry : hadoopConf) {
+            switch (entry.getKey()) {
+                case FS_S3A_ACCESS_KEY:
+                    properties.setAccessKeyId(entry.getValue());
+                    break;
+                case FS_S3A_SECRET_KEY:
+                    properties.setSecretAccessKey(entry.getValue());
+                    break;
+                case FS_S3A_SESSION_TOKEN:
+                    properties.setSessionToken(entry.getValue());
+                    break;
+                case FS_S3A_ENDPOINT:
+                    String qualified = entry.getValue();
+                    if (!qualified.startsWith("http")) {
+                        qualified = "https://" + qualified;
+                    }
+                    properties.setEndpoint(qualified);
+                    break;
+                case FS_S3A_ENDPOINT_REGION:
+                    properties.setRegion(entry.getValue());
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        return properties.asProperties();
+    }
+
+    static final String ACCESS_KEY_PREFIX = "fs.azure.account.key";
+    static final String FIXED_TOKEN_PREFIX = "fs.azure.sas.fixed.token.";
+
+    public static Map<String, String> azurePropertiesFromHadoopConf(Configuration hadoopConf) {
+        VortexAzureProperties properties = new VortexAzureProperties();
+
+        // TODO(aduffy): match on storage account name.
+        for (Map.Entry<String, String> entry : hadoopConf) {
+            String configKey = entry.getKey();
+            if (configKey.startsWith(ACCESS_KEY_PREFIX)) {
+                properties.setAccessKey(entry.getValue());
+            } else if (configKey.startsWith(FIXED_TOKEN_PREFIX)) {
+                properties.setSasKey(entry.getValue());
+            }
+        }
+
+        if (properties.accessKey().isEmpty()) {
+            properties.setSkipSignature(true);
+        }
+
+        return properties.asProperties();
+    }
+}
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexAzureProperties.java b/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexAzureProperties.java
new file mode 100644
index 00000000000..b064575c311
--- /dev/null
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexAzureProperties.java
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark.config;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.Optional;
+
+public final class VortexAzureProperties {
+    private static final String ACCOUNT_KEY = "azure_storage_account_key";
+    private static final String SAS_KEY = "azure_storage_sas_key";
+    private static final String SKIP_SIGNATURE = "azure_skip_signature";
+
+    private final Map<String, String> properties = Maps.newHashMap();
+
+    public Optional<String> accessKey() {
+        return Optional.ofNullable(properties.get(ACCOUNT_KEY));
+    }
+
+    public Optional<String> sasKey() {
+        return Optional.ofNullable(properties.get(SAS_KEY));
+    }
+
+    public boolean skipSignature() {
+        return Boolean.parseBoolean(properties.getOrDefault(SKIP_SIGNATURE, "false"));
+    }
+
+    public VortexAzureProperties setAccessKey(String accountKey) {
+        properties.put(ACCOUNT_KEY, accountKey);
+        return this;
+    }
+
+    public VortexAzureProperties setSasKey(String sasKey) {
+        properties.put(SAS_KEY, sasKey);
+        return this;
+    }
+
+    public VortexAzureProperties setSkipSignature(boolean skipSignature) {
+        properties.put(SKIP_SIGNATURE, String.valueOf(skipSignature));
+        return this;
+    }
+
+    public Map<String, String> asProperties() {
+        return ImmutableMap.copyOf(properties);
+    }
+}
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexS3Properties.java b/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexS3Properties.java
new file mode 100644
index 00000000000..f8298891f18
--- /dev/null
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/config/VortexS3Properties.java
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark.config;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.Optional;
+
+public final class VortexS3Properties {
+    private static final String ACCESS_KEY = "aws_access_key_id";
+    private static final String SECRET_KEY = "aws_secret_access_key";
+    private static final String SESSION_TOKEN = "aws_session_token";
+    private static final String REGION = "aws_region";
+    private static final String ENDPOINT = "aws_endpoint";
+    private static final String SKIP_SIGNATURE = "aws_skip_signature";
+
+    private final Map<String, String> properties = Maps.newHashMap();
+
+    public Optional<String> accessKeyId() {
+        return Optional.ofNullable(properties.get(ACCESS_KEY));
+    }
+
+    public Optional<String> secretAccessKey() {
+        return Optional.ofNullable(properties.get(SECRET_KEY));
+    }
+
+    public Optional<String> sessionToken() {
+        return Optional.ofNullable(properties.get(SESSION_TOKEN));
+    }
+
+    public Optional<String> region() {
+        return Optional.ofNullable(properties.get(REGION));
+    }
+
+    public Optional<String> endpoint() {
+        return Optional.ofNullable(properties.get(ENDPOINT));
+    }
+
+    public boolean skipSignature() {
+        return Boolean.parseBoolean(properties.getOrDefault(SKIP_SIGNATURE, "false"));
+    }
+
+    public void setAccessKeyId(String accessKeyId) {
+        properties.put(ACCESS_KEY, accessKeyId);
+    }
+
+    public void setSecretAccessKey(String secretAccessKey) {
+        properties.put(SECRET_KEY, secretAccessKey);
+    }
+
+    public void setSessionToken(String sessionToken) {
+        properties.put(SESSION_TOKEN, sessionToken);
+    }
+
+    public void setRegion(String region) {
+        properties.put(REGION, region);
+    }
+
+    public void setEndpoint(String endpoint) {
+        properties.put(ENDPOINT, endpoint);
+    }
+
+    public void setSkipSignature(boolean skipSignature) {
+        properties.put(SKIP_SIGNATURE, Boolean.toString(skipSignature));
+    }
+
+    public Map<String, String> asProperties() {
+        return ImmutableMap.copyOf(properties);
+    }
+}
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/PartitionPathUtils.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/PartitionPathUtils.java
new file mode 100644
index 00000000000..bbd73f6115c
--- /dev/null
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/PartitionPathUtils.java
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark.read;
+
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.apache.spark.sql.execution.vectorized.ConstantColumnVector;
+import org.apache.spark.sql.types.*;
+import org.apache.spark.unsafe.types.UTF8String;
+
+/**
+ * Utilities for discovering and materializing Hive-style partition columns from file paths.
+ */
+public final class PartitionPathUtils {
+    private static final String HIVE_DEFAULT_PARTITION = "__HIVE_DEFAULT_PARTITION__";
+
+    private PartitionPathUtils() {}
+
+    /**
+     * Parses Hive-style {@code key=value} segments from a file path.
+     *
+     * @return an ordered map of partition column names to their string values
+     */
+    public static Map<String, String> parsePartitionValues(String filePath) {
+        LinkedHashMap<String, String> values = new LinkedHashMap<>();
+        String[] segments = filePath.split("/");
+        for (String segment : segments) {
+            int eqIdx = segment.indexOf('=');
+            if (eqIdx > 0 && eqIdx < segment.length() - 1) {
+                String key = URLDecoder.decode(segment.substring(0, eqIdx), StandardCharsets.UTF_8);
+                String val = URLDecoder.decode(segment.substring(eqIdx + 1), StandardCharsets.UTF_8);
+                values.put(key, val);
+            }
+        }
+        return values;
+    }
+
+    /**
+     * Infers a Spark {@link DataType} from a partition value string.
+     * Tries integer, long, double, boolean, and falls back to string.
+     */
+    public static DataType inferPartitionColumnType(String value) {
+        if (value == null || HIVE_DEFAULT_PARTITION.equals(value)) {
+            return DataTypes.StringType;
+        }
+        try {
+            Integer.parseInt(value);
+            return DataTypes.IntegerType;
+        } catch (NumberFormatException ignored) {
+        }
+        try {
+            Long.parseLong(value);
+            return DataTypes.LongType;
+        } catch (NumberFormatException ignored) {
+        }
+        try {
+            Double.parseDouble(value);
+            return DataTypes.DoubleType;
+        } catch (NumberFormatException ignored) {
+        }
+        if ("true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value)) {
+            return DataTypes.BooleanType;
+        }
+        return DataTypes.StringType;
+    }
+
+    /**
+     * Creates a Spark {@link ConstantColumnVector} populated with the given partition value,
+     * parsed according to the target {@link DataType}.
+     */
+    public static ConstantColumnVector createConstantVector(int numRows, DataType type, String value) {
+        ConstantColumnVector vec = new ConstantColumnVector(numRows, type);
+        if (value == null || HIVE_DEFAULT_PARTITION.equals(value)) {
+            vec.setNull();
+            return vec;
+        }
+        vec.setNotNull();
+        if (type instanceof StringType) {
+            vec.setUtf8String(UTF8String.fromString(value));
+        } else if (type instanceof IntegerType || type instanceof DateType) {
+            vec.setInt(Integer.parseInt(value));
+        } else if (type instanceof LongType || type instanceof TimestampType || type instanceof TimestampNTZType) {
+            vec.setLong(Long.parseLong(value));
+        } else if (type instanceof ShortType) {
+            vec.setShort(Short.parseShort(value));
+        } else if (type instanceof ByteType) {
+            vec.setByte(Byte.parseByte(value));
+        } else if (type instanceof BooleanType) {
+            vec.setBoolean(Boolean.parseBoolean(value));
+        } else if (type instanceof FloatType) {
+            vec.setFloat(Float.parseFloat(value));
+        } else if (type instanceof DoubleType) {
+            vec.setDouble(Double.parseDouble(value));
+        } else {
+            vec.setUtf8String(UTF8String.fromString(value));
+        }
+        return vec;
+    }
+}
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexBatchExec.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexBatchExec.java
index 7c9ccd5ea5e..199513f1d8a 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexBatchExec.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexBatchExec.java
@@ -4,6 +4,7 @@
 package dev.vortex.spark.read;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import dev.vortex.jni.NativeFileMethods;
 import dev.vortex.spark.VortexFilePartition;
 import java.util.Map;
@@ -19,7 +20,7 @@
 public final class VortexBatchExec implements Batch {
     private final ImmutableList<String> paths;
     private final ImmutableList<Column> columns;
-    private final Map<String, String> formatOptions;
+    private final ImmutableMap<String, String> formatOptions;
 
     /**
      * Creates a new VortexBatchExec for scanning the specified Vortex files.
@@ -28,7 +29,7 @@ public final class VortexBatchExec implements Batch {
      * @param columns the list of columns to read from the files
      */
     public VortexBatchExec(
-            ImmutableList<String> paths, ImmutableList<Column> columns, Map<String, String> formatOptions) {
+            ImmutableList<String> paths, ImmutableList<Column> columns, ImmutableMap<String, String> formatOptions) {
         this.paths = paths;
         this.columns = columns;
         this.formatOptions = formatOptions;
@@ -44,17 +45,20 @@ public VortexBatchExec(
      */
     @Override
     public InputPartition[] planInputPartitions() {
-        // Scan all paths and assign each file its own partition
+        // Scan all paths and assign each file its own partition.
+        // For each discovered file, parse Hive-style partition values from the path.
         return paths.stream()
                 .flatMap(path -> {
                     if (path.endsWith(".vortex")) {
                         return Stream.of(path);
                     } else {
-                        // Scan and return the paths
                         return NativeFileMethods.listVortexFiles(path, formatOptions).stream();
                     }
                 })
-                .map(path -> new VortexFilePartition(path, columns))
+                .map(path -> {
+                    Map<String, String> partVals = PartitionPathUtils.parsePartitionValues(path);
+                    return new VortexFilePartition(path, columns, formatOptions, ImmutableMap.copyOf(partVals));
+                })
                 .toArray(InputPartition[]::new);
     }
 
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexPartitionReader.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexPartitionReader.java
index a1680e0801e..3904e0272f6 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexPartitionReader.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexPartitionReader.java
@@ -9,15 +9,20 @@
 import dev.vortex.api.Files;
 import dev.vortex.api.ScanOptions;
 import dev.vortex.spark.VortexFilePartition;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.*;
 import org.apache.spark.sql.connector.catalog.Column;
 import org.apache.spark.sql.connector.read.PartitionReader;
+import org.apache.spark.sql.vectorized.ColumnVector;
 import org.apache.spark.sql.vectorized.ColumnarBatch;
 
 /**
  * A {@link PartitionReader} that reads columnar batches out of a Vortex file into
  * Vortex memory format.
+ * <p>
+ * When reading from partitioned directories, partition column values are extracted from the
+ * Hive-style file path and materialized as Spark
+ * {@link org.apache.spark.sql.execution.vectorized.ConstantColumnVector} instances that are
+ * spliced into each output batch.
  */
 final class VortexPartitionReader implements PartitionReader<ColumnarBatch> {
     private final VortexFilePartition partition;
@@ -25,6 +30,12 @@ final class VortexPartitionReader implements PartitionReader<ColumnarBatch> {
     private File file;
     private VortexColumnarBatchIterator batches;
 
+    /** Names of columns whose values come from the partition path rather than the data file. */
+    private Set<String> partitionColumnNames;
+
+    /** Tracks the last data batch so its native memory can be freed properly. */
+    private ColumnarBatch lastDataBatch;
+
     VortexPartitionReader(VortexFilePartition partition) {
         this.partition = partition;
         initNativeResources();
@@ -33,29 +44,86 @@ final class VortexPartitionReader implements PartitionReader<ColumnarBatch> {
     @Override
     public boolean next() {
         checkNotNull(batches, "batches");
-
         return batches.hasNext();
     }
 
     @Override
     public ColumnarBatch get() {
         checkNotNull(batches, "closed ArrayStream");
-        return batches.next();
+
+        // Free previous data batch native memory
+        if (lastDataBatch != null) {
+            lastDataBatch.close();
+            lastDataBatch = null;
+        }
+
+        ColumnarBatch dataBatch = batches.next();
+
+        if (partitionColumnNames.isEmpty()) {
+            return dataBatch;
+        }
+
+        // Track the data batch for lifecycle management
+        lastDataBatch = dataBatch;
+        return buildCombinedBatch(dataBatch);
+    }
+
+    /**
+     * Builds a combined batch with data columns from the file and constant partition columns
+     * in the order expected by the full table schema.
+     */
+    private ColumnarBatch buildCombinedBatch(ColumnarBatch dataBatch) {
+        int rowCount = dataBatch.numRows();
+        Map<String, String> partVals = partition.getPartitionValues();
+        List<Column> allColumns = partition.getColumns();
+        ColumnVector[] combined = new ColumnVector[allColumns.size()];
+
+        int dataIdx = 0;
+        for (int i = 0; i < allColumns.size(); i++) {
+            Column col = allColumns.get(i);
+            String partValue = partVals.get(col.name());
+            if (partValue != null) {
+                combined[i] = PartitionPathUtils.createConstantVector(rowCount, col.dataType(), partValue);
+            } else {
+                combined[i] = dataBatch.column(dataIdx++);
+            }
+        }
+
+        return new CombinedColumnarBatch(combined, rowCount);
     }
 
     /**
      * Initialize the Vortex File and ArrayStream resources.
+     * <p>
+     * Partition columns are identified by matching requested column names against the
+     * partition values from the file path. Only non-partition columns are pushed down
+     * to the Vortex scan.
      */
     void initNativeResources() {
-        file = Files.open(partition.getPath());
-        List<String> pushdownColumns =
-                partition.getColumns().stream().map(Column::name).collect(Collectors.toList());
+        Map<String, String> partVals = partition.getPartitionValues();
+        this.partitionColumnNames = new HashSet<>();
+
+        List<String> dataColumnNames = new ArrayList<>();
+        for (Column col : partition.getColumns()) {
+            if (partVals.containsKey(col.name())) {
+                partitionColumnNames.add(col.name());
+            } else {
+                dataColumnNames.add(col.name());
+            }
+        }
+
+        file = Files.open(partition.getPath(), partition.getFormatOptions());
         batches = new VortexColumnarBatchIterator(
-                file.newScan(ScanOptions.builder().columns(pushdownColumns).build()));
+                file.newScan(ScanOptions.builder().columns(dataColumnNames).build()));
     }
 
     @Override
     public void close() {
+        if (lastDataBatch != null) {
+            lastDataBatch.close();
+            lastDataBatch = null;
+        }
+
         checkNotNull(file, "File was closed");
         checkNotNull(batches, "ArrayStream was closed");
 
@@ -65,4 +133,27 @@ public void close() {
         file.close();
         file = null;
     }
+
+    /**
+     * A ColumnarBatch that does not close its column vectors on {@link #close()}.
+     * <p>
+     * The data column vectors are owned by the underlying {@link VortexColumnarBatch}
+     * (tracked via {@link #lastDataBatch}), and the constant partition vectors have trivial
+     * lifecycle. Neither should be closed by this wrapper.
+     */
+    private static final class CombinedColumnarBatch extends ColumnarBatch {
+        CombinedColumnarBatch(ColumnVector[] columns, int numRows) {
+            super(columns, numRows);
+        }
+
+        @Override
+        public void close() {
+            // Intentionally empty: lifecycle is managed by VortexPartitionReader
+        }
+
+        @Override
+        public void closeIfFreeable() {
+            // Intentionally empty
+        }
+    }
 }
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScan.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScan.java
index d7542962c8d..1ec1a0aeb7d 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScan.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScan.java
@@ -4,7 +4,7 @@
 package dev.vortex.spark.read;
 
 import com.google.common.collect.ImmutableList;
-import java.util.Map;
+import com.google.common.collect.ImmutableMap;
 import org.apache.spark.sql.connector.catalog.CatalogV2Util;
 import org.apache.spark.sql.connector.catalog.Column;
 import org.apache.spark.sql.connector.read.Batch;
@@ -18,7 +18,7 @@ public final class VortexScan implements Scan {
 
     private final ImmutableList<String> paths;
     private final ImmutableList<Column> readColumns;
-    private final Map<String, String> formatOptions;
+    private final ImmutableMap<String, String> formatOptions;
 
     /**
      * Creates a new VortexScan for the specified file paths and columns.
@@ -27,7 +27,9 @@ public final class VortexScan implements Scan {
      * @param readColumns the list of columns to read from the files
      */
     public VortexScan(
-            ImmutableList<String> paths, ImmutableList<Column> readColumns, Map<String, String> formatOptions) {
+            ImmutableList<String> paths,
+            ImmutableList<Column> readColumns,
+            ImmutableMap<String, String> formatOptions) {
         this.paths = paths;
         this.readColumns = readColumns;
         this.formatOptions = formatOptions;
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScanBuilder.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScanBuilder.java
index e4e17dc2500..0ea690b6406 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScanBuilder.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/VortexScanBuilder.java
@@ -6,6 +6,7 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -89,6 +90,7 @@ public VortexScanBuilder addAllColumns(Iterable<Column> columns) {
     public Scan build() {
         var paths = this.paths.build();
         var columns = ImmutableList.copyOf(this.columns);
+        var formatOptions = ImmutableMap.copyOf(this.formatOptions);
 
         checkState(!paths.isEmpty(), "paths cannot be empty");
         // Allow empty columns for operations like count() that don't need actual column data
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/PartitionedVortexDataWriter.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/PartitionedVortexDataWriter.java
new file mode 100644
index 00000000000..aa27381242d
--- /dev/null
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/PartitionedVortexDataWriter.java
@@ -0,0 +1,459 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark.write;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.primitives.ImmutableIntArray;
+import java.io.IOException;
+import java.io.Serializable;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.*;
+import java.util.stream.Collectors;
+import org.apache.hadoop.shaded.com.google.common.collect.Streams;
+import org.apache.spark.sql.catalyst.InternalRow;
+import org.apache.spark.sql.catalyst.expressions.BoundReference;
+import org.apache.spark.sql.catalyst.expressions.UnsafeProjection;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Transform;
+import org.apache.spark.sql.connector.write.DataWriter;
+import org.apache.spark.sql.connector.write.WriterCommitMessage;
+import org.apache.spark.sql.types.*;
+import org.apache.spark.sql.util.CaseInsensitiveStringMap;
+import org.apache.spark.unsafe.types.UTF8String;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Writes Spark InternalRow data to Vortex files organized in Hive-style partition directories.
+ * <p>
+ * Supports the standard Spark partition transforms: {@code identity}, {@code years},
+ * {@code months}, {@code days}, {@code hours}, and {@code bucket}. For each unique combination
+ * of evaluated transform values, a separate subdirectory is created and a dedicated
+ * {@link VortexDataWriter} writes data within it.
+ */
+public final class PartitionedVortexDataWriter implements DataWriter<InternalRow>, AutoCloseable {
+    private static final Logger logger = LoggerFactory.getLogger(PartitionedVortexDataWriter.class);
+    private static final String HIVE_DEFAULT_PARTITION = "__HIVE_DEFAULT_PARTITION__";
+
+    private final String baseOutputUri;
+    private final StructType dataSchema;
+    private final UnsafeProjection dataProjection;
+    private final CaseInsensitiveStringMap options;
+    private final ResolvedTransform[] resolvedTransforms;
+    private final int partitionId;
+    private final long taskId;
+
+    private final Map<String, VortexDataWriter> writers = new HashMap<>();
+    private boolean closed = false;
+
+    /**
+     * Creates a new PartitionedVortexDataWriter.
+     *
+     * @param baseOutputUri      the base output path
+     * @param schema             the full schema of the data
+     * @param options            write options
+     * @param resolvedTransforms pre-resolved partition transforms
+     * @param partitionId        the Spark partition ID
+     * @param taskId             the Spark task ID
+     */
+    PartitionedVortexDataWriter(
+            String baseOutputUri,
+            StructType schema,
+            CaseInsensitiveStringMap options,
+            ResolvedTransform[] resolvedTransforms,
+            int partitionId,
+            long taskId) {
+        this.baseOutputUri = baseOutputUri.endsWith("/") ? baseOutputUri : baseOutputUri + "/";
+        this.options = options;
+        this.partitionId = partitionId;
+        this.taskId = taskId;
+        this.resolvedTransforms = resolvedTransforms;
+
+        // Compute the data schema by removing identity partition columns.
+        // Only identity transforms correspond to columns that should be stripped from the data,
+        // since temporal/bucket transforms derive values from the source column.
+        Set<Integer> identityPartitionIndices = new HashSet<>();
+        for (ResolvedTransform rt : resolvedTransforms) {
+            if ("identity".equals(rt.transformName())) {
+                identityPartitionIndices.add(rt.columnIndices().get(0));
+            }
+        }
+
+        StructField[] fields = schema.fields();
+        List<StructField> dataFields = new ArrayList<>();
+        List<org.apache.spark.sql.catalyst.expressions.Expression> projExprs = new ArrayList<>();
+        for (int i = 0; i < fields.length; i++) {
+            if (!identityPartitionIndices.contains(i)) {
+                dataFields.add(fields[i]);
+                projExprs.add(new BoundReference(i, fields[i].dataType(), fields[i].nullable()));
+            }
+        }
+        this.dataSchema = new StructType(dataFields.toArray(new StructField[0]));
+        this.dataProjection = UnsafeProjection.create(asScalaSeq(projExprs));
+    }
+
+    @SuppressWarnings("deprecation") // JavaConverters is deprecated in Scala 2.13 but works in both 2.12 and 2.13
+    private static <T> scala.collection.immutable.Seq<T> asScalaSeq(List<T> list) {
+        return scala.collection.JavaConverters.asScalaBufferConverter(list)
+                .asScala()
+                .toList();
+    }
+
+    @Override
+    public void write(InternalRow row) throws IOException {
+        String partitionPath = getPartitionPath(row);
+        VortexDataWriter writer = writers.get(partitionPath);
+        if (writer == null) {
+            writer = createWriterForPartition(partitionPath);
+            writers.put(partitionPath, writer);
+        }
+        writer.write(dataProjection.apply(row));
+    }
+
+    @Override
+    public WriterCommitMessage commit() throws IOException {
+        if (closed) {
+            return new PartitionedWriterCommitMessage(List.of());
+        }
+
+        List<VortexWriterCommitMessage> messages = new ArrayList<>();
+        IOException firstException = null;
+
+        for (Map.Entry<String, VortexDataWriter> entry : writers.entrySet()) {
+            try {
+                WriterCommitMessage msg = entry.getValue().commit();
+                if (msg instanceof VortexWriterCommitMessage) {
+                    messages.add((VortexWriterCommitMessage) msg);
+                }
+            } catch (IOException e) {
+                if (firstException == null) {
+                    firstException = e;
+                } else {
+                    firstException.addSuppressed(e);
+                }
+            }
+        }
+
+        closed = true;
+
+        if (firstException != null) {
+            throw firstException;
+        }
+
+        logger.info("Committed {} partition writers", messages.size());
+        return new PartitionedWriterCommitMessage(messages);
+    }
+
+    @Override
+    public void abort() throws IOException {
+        if (closed) {
+            return;
+        }
+
+        for (VortexDataWriter writer : writers.values()) {
+            try {
+                writer.abort();
+            } catch (IOException e) {
+                logger.error("Error aborting partition writer", e);
+            }
+        }
+        closed = true;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (!closed) {
+            logger.warn("PartitionedVortexDataWriter.close() called without commit() or abort() - cleaning up");
+            try {
+                abort();
+            } catch (IOException e) {
+                logger.error("Error during cleanup in close()", e);
+            }
+        }
+    }
+
+    private VortexDataWriter createWriterForPartition(String partitionPath) {
+        String fileName = String.format("part-%05d-%d.vortex", partitionId, taskId);
+        String fileUri = baseOutputUri + partitionPath + "/" + fileName;
+        logger.debug("Creating writer for partition path: {}", fileUri);
+        return new VortexDataWriter(fileUri, dataSchema, options);
+    }
+
+    private String getPartitionPath(InternalRow row) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < resolvedTransforms.length; i++) {
+            if (i > 0) {
+                sb.append("/");
+            }
+            ResolvedTransform rt = resolvedTransforms[i];
+            sb.append(URLEncoder.encode(rt.directoryKey, StandardCharsets.UTF_8));
+            sb.append("=");
+
+            String value = evaluateTransform(rt, row);
+            sb.append(URLEncoder.encode(value, StandardCharsets.UTF_8));
+        }
+        return sb.toString();
+    }
+
+    // ------------------------------------------------------------------
+    // Transform resolution: converts Transform[] into ResolvedTransform[]
+    // ------------------------------------------------------------------
+
+    static ResolvedTransform[] resolveTransforms(Transform[] transforms, StructType schema) {
+        return Arrays.stream(transforms)
+                .map(transform -> resolveOne(transform, schema))
+                .toArray(ResolvedTransform[]::new);
+    }
+
+    private static ResolvedTransform resolveOne(Transform transform, StructType schema) {
+        String transformName = transform.name();
+        NamedReference[] refs = transform.references();
+
+        if (refs.length == 0) {
+            throw new IllegalArgumentException("Partition transform has no column references: " + transform);
+        }
+
+        // Primary column (all single-column transforms use this)
+        String primaryColName = String.join(".", refs[0].fieldNames());
+        int primaryColIdx = schema.fieldIndex(primaryColName);
+        DataType primaryType = schema.fields()[primaryColIdx].dataType();
+
+        switch (transformName) {
+            case "identity":
+                return new ResolvedTransform(primaryColName, transformName, primaryColIdx, primaryType);
+
+            case "years":
+                requireTemporalType(primaryType, transformName);
+                return new ResolvedTransform(primaryColName + "_year", transformName, primaryColIdx, primaryType);
+
+            case "months":
+                requireTemporalType(primaryType, transformName);
+                return new ResolvedTransform(primaryColName + "_month", transformName, primaryColIdx, primaryType);
+
+            case "days":
+                requireTemporalType(primaryType, transformName);
+                return new ResolvedTransform(primaryColName + "_day", transformName, primaryColIdx, primaryType);
+
+            case "hours":
+                requireTimestampType(primaryType, transformName);
+                return new ResolvedTransform(primaryColName + "_hour", transformName, primaryColIdx, primaryType);
+
+            case "bucket": {
+                int bucketCount = extractBucketCount(transform);
+                String colNames = Arrays.stream(refs)
+                        .map(r -> String.join(".", r.fieldNames()))
+                        .collect(Collectors.joining("_"));
+
+                // Resolve all referenced columns for multi-column bucket
+                ImmutableIntArray.Builder allIndices = ImmutableIntArray.builder(refs.length);
+                ImmutableList.Builder<DataType> allTypes = ImmutableList.builderWithExpectedSize(refs.length);
+                for (NamedReference ref : refs) {
+                    String colName = String.join(".", ref.fieldNames());
+                    int idx = schema.fieldIndex(colName);
+                    allIndices.add(idx);
+                    allTypes.add(schema.fields()[idx].dataType());
+                }
+                return new ResolvedTransform(
+                        colNames + "_bucket", transformName, allIndices.build(), allTypes.build(), bucketCount);
+            }
+
+            default:
+                throw new IllegalArgumentException("Unsupported partition transform: " + transformName);
+        }
+    }
+
+    private static int extractBucketCount(Transform transform) {
+        for (Expression arg : transform.arguments()) {
+            if (arg instanceof Literal<?>) {
+                Object value = ((Literal<?>) arg).value();
+                if (value instanceof Integer) {
+                    return (Integer) value;
+                }
+            }
+        }
+        throw new IllegalArgumentException("bucket transform missing integer numBuckets argument");
+    }
+
+    private static void requireTemporalType(DataType type, String transformName) {
+        if (!(type instanceof DateType || type instanceof TimestampType || type instanceof TimestampNTZType)) {
+            throw new IllegalArgumentException(
+                    transformName + " transform requires a date or timestamp column, got: " + type);
+        }
+    }
+
+    private static void requireTimestampType(DataType type, String transformName) {
+        if (!(type instanceof TimestampType || type instanceof TimestampNTZType)) {
+            throw new IllegalArgumentException(transformName + " transform requires a timestamp column, got: " + type);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Transform evaluation: produces partition values from rows
+    // ------------------------------------------------------------------
+
+    private static String evaluateTransform(ResolvedTransform rt, InternalRow row) {
+        int colIdx = rt.columnIndices.get(0);
+
+        if (row.isNullAt(colIdx)) {
+            return HIVE_DEFAULT_PARTITION;
+        }
+
+        return switch (rt.transformName) {
+            case "identity" -> extractIdentityValue(row, colIdx, rt.columnTypes.get(0));
+            case "years" -> extractYearValue(row, colIdx, rt.columnTypes.get(0));
+            case "months" -> extractMonthValue(row, colIdx, rt.columnTypes.get(0));
+            case "days" -> extractDayValue(row, colIdx, rt.columnTypes.get(0));
+            case "hours" -> extractHourValue(row, colIdx, rt.columnTypes.get(0));
+            case "bucket" -> extractBucketValue(row, rt);
+            default -> throw new IllegalArgumentException("Unsupported transform: " + rt.transformName);
+        };
+    }
+
+    private static String extractIdentityValue(InternalRow row, int ordinal, DataType dataType) {
+        if (dataType instanceof BooleanType) {
+            return String.valueOf(row.getBoolean(ordinal));
+        } else if (dataType instanceof ByteType) {
+            return String.valueOf(row.getByte(ordinal));
+        } else if (dataType instanceof ShortType) {
+            return String.valueOf(row.getShort(ordinal));
+        } else if (dataType instanceof IntegerType) {
+            return String.valueOf(row.getInt(ordinal));
+        } else if (dataType instanceof LongType) {
+            return String.valueOf(row.getLong(ordinal));
+        } else if (dataType instanceof FloatType) {
+            return String.valueOf(row.getFloat(ordinal));
+        } else if (dataType instanceof DoubleType) {
+            return String.valueOf(row.getDouble(ordinal));
+        } else if (dataType instanceof StringType) {
+            UTF8String str = row.getUTF8String(ordinal);
+            return str != null ? str.toString() : HIVE_DEFAULT_PARTITION;
+        } else if (dataType instanceof DateType) {
+            return String.valueOf(row.getInt(ordinal));
+        } else if (dataType instanceof TimestampType || dataType instanceof TimestampNTZType) {
+            return String.valueOf(row.getLong(ordinal));
+        } else {
+            throw new IllegalArgumentException("Unsupported partition column type: " + dataType);
+        }
+    }
+
+    private static String extractYearValue(InternalRow row, int colIdx, DataType type) {
+        if (type instanceof DateType) {
+            return String.valueOf(LocalDate.ofEpochDay(row.getInt(colIdx)).getYear());
+        } else {
+            return String.valueOf(microsToDateTime(row.getLong(colIdx)).getYear());
+        }
+    }
+
+    private static String extractMonthValue(InternalRow row, int colIdx, DataType type) {
+        LocalDate date;
+        if (type instanceof DateType) {
+            date = LocalDate.ofEpochDay(row.getInt(colIdx));
+        } else {
+            date = microsToDateTime(row.getLong(colIdx)).toLocalDate();
+        }
+        return String.format("%04d-%02d", date.getYear(), date.getMonthValue());
+    }
+
+    private static String extractDayValue(InternalRow row, int colIdx, DataType type) {
+        LocalDate date;
+        if (type instanceof DateType) {
+            date = LocalDate.ofEpochDay(row.getInt(colIdx));
+        } else {
+            date = microsToDateTime(row.getLong(colIdx)).toLocalDate();
+        }
+        return date.toString(); // YYYY-MM-DD
+    }
+
+    private static String extractHourValue(InternalRow row, int colIdx, DataType type) {
+        LocalDateTime dt = microsToDateTime(row.getLong(colIdx));
+        return String.format("%s-%02d", dt.toLocalDate(), dt.getHour());
+    }
+
+    /**
+     * Computes the bucket value matching Spark's {@code InMemoryBaseTable} reference implementation:
+     * per-column values are converted to longs (hashed for strings/binary), summed, then
+     * {@code Math.floorMod(sum, numBuckets)}.
+     */
+    private static String extractBucketValue(InternalRow row, ResolvedTransform rt) {
+        long hash = Streams.zip(
+                        rt.columnIndices.stream().boxed(),
+                        rt.columnTypes.stream(),
+                        (Integer idx, DataType dt) -> columnHashValue(row, idx, dt))
+                .reduce(0L, Long::sum);
+        int bucket = Math.floorMod(hash, rt.bucketCount);
+        return String.valueOf(bucket);
+    }
+
+    private static long columnHashValue(InternalRow row, int ordinal, DataType dataType) {
+        if (dataType instanceof ByteType) {
+            return row.getByte(ordinal);
+        } else if (dataType instanceof ShortType) {
+            return row.getShort(ordinal);
+        } else if (dataType instanceof IntegerType) {
+            return row.getInt(ordinal);
+        } else if (dataType instanceof LongType
+                || dataType instanceof TimestampType
+                || dataType instanceof TimestampNTZType) {
+            return row.getLong(ordinal);
+        } else if (dataType instanceof StringType) {
+            return row.getUTF8String(ordinal).hashCode();
+        } else if (dataType instanceof BinaryType) {
+            return java.util.Arrays.hashCode(row.getBinary(ordinal));
+        } else {
+            throw new IllegalArgumentException("Unsupported bucket column type: " + dataType);
+        }
+    }
+
+    private static LocalDateTime microsToDateTime(long micros) {
+        long epochSecond = Math.floorDiv(micros, 1_000_000);
+        int nanoOfSecond = (int) (Math.floorMod(micros, 1_000_000) * 1000);
+        return LocalDateTime.ofInstant(Instant.ofEpochSecond(epochSecond, nanoOfSecond), ZoneOffset.UTC);
+    }
+
+    // ------------------------------------------------------------------
+    // Internal types
+    // ------------------------------------------------------------------
+
+    /**
+     * Pre-resolved representation of a partition transform, ready for per-row evaluation.
+     *
+     * @param bucketCount -1 if not a bucket transform
+     */
+    record ResolvedTransform(
+            String directoryKey,
+            String transformName,
+            ImmutableIntArray columnIndices,
+            List<DataType> columnTypes,
+            int bucketCount)
+            implements Serializable {
+        ResolvedTransform(String directoryKey, String transformName, int columnIndex, DataType columnType) {
+            this(directoryKey, transformName, ImmutableIntArray.of(columnIndex), List.of(columnType), -1);
+        }
+    }
+
+    /**
+     * Commit message that aggregates results from multiple partition writers.
+     */
+    public static final class PartitionedWriterCommitMessage implements WriterCommitMessage, Serializable {
+        private final List<VortexWriterCommitMessage> partitionMessages;
+
+        PartitionedWriterCommitMessage(List<VortexWriterCommitMessage> partitionMessages) {
+            this.partitionMessages = partitionMessages;
+        }
+
+        /**
+         * Returns the commit messages from each individual partition writer.
+         */
+        public List<VortexWriterCommitMessage> getPartitionMessages() {
+            return partitionMessages;
+        }
+    }
+}
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexBatchWrite.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexBatchWrite.java
index 65bc16f3165..be0b516e81e 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexBatchWrite.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexBatchWrite.java
@@ -10,7 +10,11 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.spark.sql.connector.expressions.Transform;
 import org.apache.spark.sql.connector.write.*;
 import org.apache.spark.sql.types.StructType;
 import org.slf4j.Logger;
@@ -29,20 +33,30 @@ public final class VortexBatchWrite implements Write, BatchWrite, Serializable {
     private final StructType schema;
     private final Map<String, String> options;
     private final boolean overwrite;
+    // Resolved eagerly so that Spark Transform objects (Scala case classes that are not
+    // Java-serializable) never reach the DataWriterFactory serialization boundary.
+    private final PartitionedVortexDataWriter.ResolvedTransform[] resolvedTransforms;
 
     /**
      * Creates a new VortexBatchWrite.
      *
-     * @param outputPath the base path where Vortex files will be written
-     * @param schema     the schema of the data to write
-     * @param options    additional write options
-     * @param overwrite  whether to overwrite existing files
+     * @param outputPath          the base path where Vortex files will be written
+     * @param schema              the schema of the data to write
+     * @param options             additional write options
+     * @param overwrite           whether to overwrite existing files
+     * @param partitionTransforms partition transforms (may be empty)
      */
-    public VortexBatchWrite(String outputPath, StructType schema, Map<String, String> options, boolean overwrite) {
+    VortexBatchWrite(
+            String outputPath,
+            StructType schema,
+            Map<String, String> options,
+            boolean overwrite,
+            Transform[] partitionTransforms) {
         this.outputPath = outputPath;
         this.schema = schema;
         this.options = options;
         this.overwrite = overwrite;
+        this.resolvedTransforms = PartitionedVortexDataWriter.resolveTransforms(partitionTransforms, schema);
     }
 
     /**
@@ -75,7 +89,7 @@ public DataWriterFactory createBatchWriterFactory(PhysicalWriteInfo info) {
             log.warn("overwrite currently does not do anything for vortex format");
         }
 
-        return new VortexDataWriterFactory(outputPath, schema, options);
+        return new VortexDataWriterFactory(outputPath, schema, options, resolvedTransforms);
     }
 
     /**
@@ -103,17 +117,10 @@ public void onDataWriterCommit(WriterCommitMessage message) {
      */
     @Override
     public void commit(WriterCommitMessage[] messages) {
-        // Overwrite cleanup should happen BEFORE writing, not after
-        // The commit method is called AFTER files are written, so we don't delete them here
+        List<String> writtenFiles = extractFilePaths(messages);
 
-        // Extract file paths from commit messages for logging
-        String[] writtenFiles = Arrays.stream(messages)
-                .filter(msg -> msg instanceof VortexWriterCommitMessage)
-                .map(msg -> ((VortexWriterCommitMessage) msg).getFilePath())
-                .toArray(String[]::new);
-
-        if (writtenFiles.length > 0) {
-            log.info("Successfully wrote {} Vortex files to {}", writtenFiles.length, outputPath);
+        if (!writtenFiles.isEmpty()) {
+            log.info("Successfully wrote {} Vortex files to {}", writtenFiles.size(), outputPath);
         }
     }
 
@@ -126,20 +133,29 @@ public void commit(WriterCommitMessage[] messages) {
      */
     @Override
     public void abort(WriterCommitMessage[] messages) {
-        // Clean up any partially written files
-        Arrays.stream(messages)
-                .filter(msg -> msg instanceof VortexWriterCommitMessage)
-                .map(msg -> ((VortexWriterCommitMessage) msg).getFilePath())
-                .forEach(filePath -> {
-                    try {
-                        Path path = Paths.get(filePath);
-                        if (Files.exists(path)) {
-                            Files.delete(path);
-                        }
-                    } catch (IOException e) {
-                        // Log but don't throw - we're already in an error state
-                        log.error("Failed to clean up file: {}", filePath, e);
+        for (String filePath : extractFilePaths(messages)) {
+            try {
+                Path path = Paths.get(filePath);
+                if (Files.exists(path)) {
+                    Files.delete(path);
+                }
+            } catch (IOException e) {
+                log.error("Failed to clean up file: {}", filePath, e);
+            }
+        }
+    }
+
+    private static List<String> extractFilePaths(WriterCommitMessage[] messages) {
+        return Arrays.stream(messages)
+                .flatMap(msg -> {
+                    if (msg instanceof VortexWriterCommitMessage) {
+                        return Stream.of(((VortexWriterCommitMessage) msg).filePath());
+                    } else if (msg instanceof PartitionedVortexDataWriter.PartitionedWriterCommitMessage) {
+                        return ((PartitionedVortexDataWriter.PartitionedWriterCommitMessage) msg)
+                                .getPartitionMessages().stream().map(VortexWriterCommitMessage::filePath);
                     }
-                });
+                    return Stream.empty();
+                })
+                .collect(Collectors.toList());
     }
 }
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriter.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriter.java
index 08ff564f8fb..ed1c986b9c1 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriter.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriter.java
@@ -4,22 +4,20 @@
 package dev.vortex.spark.write;
 
 import dev.vortex.api.VortexWriter;
+import dev.vortex.relocated.org.apache.arrow.c.ArrowArray;
+import dev.vortex.relocated.org.apache.arrow.c.ArrowSchema;
+import dev.vortex.relocated.org.apache.arrow.c.Data;
 import dev.vortex.relocated.org.apache.arrow.memory.BufferAllocator;
 import dev.vortex.relocated.org.apache.arrow.memory.RootAllocator;
 import dev.vortex.relocated.org.apache.arrow.vector.*;
 import dev.vortex.relocated.org.apache.arrow.vector.VectorSchemaRoot;
 import dev.vortex.relocated.org.apache.arrow.vector.complex.ListVector;
-import dev.vortex.relocated.org.apache.arrow.vector.ipc.ArrowStreamWriter;
 import dev.vortex.spark.SparkTypes;
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.channels.Channels;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import org.apache.spark.sql.catalyst.InternalRow;
 import org.apache.spark.sql.catalyst.expressions.SpecializedGetters;
 import org.apache.spark.sql.catalyst.util.ArrayData;
@@ -64,7 +62,7 @@ public final class VortexDataWriter implements DataWriter<InternalRow>, AutoClos
      * @param schema   the schema of the data to write
      * @param options  additional write options
      */
-    public VortexDataWriter(String filePath, StructType schema, CaseInsensitiveStringMap options) {
+    VortexDataWriter(String filePath, StructType schema, CaseInsensitiveStringMap options) {
         this.filePath = filePath;
         this.schema = schema;
         this.options = options;
@@ -96,11 +94,8 @@ public VortexDataWriter(String filePath, StructType schema, CaseInsensitiveStrin
             var writeSchema = SparkTypes.toDType(schema);
             var arrowSchema = SparkToArrowSchema.convert(schema);
 
-            // Convert the writer to a new schema type instead.
-
             // Create Vortex writer
-            Map<String, String> writerOptions = new HashMap<>();
-            this.vortexWriter = VortexWriter.create(filePath, writeSchema, writerOptions);
+            this.vortexWriter = VortexWriter.create(filePath, writeSchema, options.asCaseSensitiveMap());
 
             // Create VectorSchemaRoot for batching rows
             this.vectorSchemaRoot = VectorSchemaRoot.create(arrowSchema, allocator);
@@ -163,26 +158,22 @@ private void writeBatch() throws IOException {
                     populateVector(vector, dataType, row, fieldIndex, rowIndex);
                 }
             }
-
-            vector.setValueCount(batchRows.size());
         }
 
         vectorSchemaRoot.setRowCount(batchRows.size());
 
-        // Serialize to Arrow IPC format and write to Vortex
-        try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
-            try (ArrowStreamWriter writer = new ArrowStreamWriter(vectorSchemaRoot, null, Channels.newChannel(baos))) {
-                writer.start();
-                writer.writeBatch();
-            }
-
-            byte[] arrowData = baos.toByteArray();
-            vortexWriter.writeBatch(arrowData);
-            bytesWritten += arrowData.length;
-
-            vectorSchemaRoot.clear();
-            batchRows.clear();
+        // Export via Arrow C Data Interface and write to Vortex
+        for (FieldVector vector : vectorSchemaRoot.getFieldVectors()) {
+            bytesWritten += vector.getBufferSize();
         }
+        try (ArrowArray arrowArray = ArrowArray.allocateNew(allocator);
+                ArrowSchema arrowSchema = ArrowSchema.allocateNew(allocator)) {
+            Data.exportVectorSchemaRoot(allocator, vectorSchemaRoot, null, arrowArray, arrowSchema);
+            vortexWriter.writeBatchFfi(arrowArray.memoryAddress(), arrowSchema.memoryAddress());
+        }
+
+        vectorSchemaRoot.clear();
+        batchRows.clear();
     }
 
     /**
@@ -283,17 +274,19 @@ public WriterCommitMessage commit() throws IOException {
                 }
             }
 
-            try {
-                if (allocator != null) {
+            // The Arrow C Data Interface export (Data.exportVectorSchemaRoot) creates structural
+            // allocations from this allocator. When writeBatchFfi passes the ArrowArray to Rust,
+            // FFI_ArrowArray::from_raw() takes ownership and nullifies the release callback on
+            // the Java side. The Rust side calls release asynchronously on its own thread, so
+            // small structural allocations may still be outstanding when the allocator is closed.
+            // These are reclaimed when the allocator is garbage collected.
+            if (allocator != null) {
+                try {
                     allocator.close();
-                    allocator = null;
-                }
-            } catch (Exception e) {
-                if (exception == null) {
-                    exception = new IOException("Failed to close allocator", e);
-                } else {
-                    exception.addSuppressed(e);
+                } catch (IllegalStateException e) {
+                    logger.debug("Allocator closed with outstanding FFI allocations: {}", e.getMessage());
                 }
+                allocator = null;
             }
 
             closed = true;
@@ -334,7 +327,11 @@ public void abort() throws IOException {
             }
 
             if (allocator != null) {
-                allocator.close();
+                try {
+                    allocator.close();
+                } catch (IllegalStateException e) {
+                    logger.debug("Allocator closed with outstanding FFI allocations: {}", e.getMessage());
+                }
                 allocator = null;
             }
 
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriterFactory.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriterFactory.java
index fd2eba263f7..4cc68736a51 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriterFactory.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexDataWriterFactory.java
@@ -17,7 +17,9 @@
  * Factory for creating VortexDataWriter instances on Spark executors.
  * <p>
  * This factory is serialized and sent to executors where it creates
- * data writers for each task.
+ * data writers for each task. When partition transforms are specified,
+ * it creates partitioned writers that organize output into Hive-style
+ * partition directories.
  */
 public final class VortexDataWriterFactory implements DataWriterFactory, Serializable {
 
@@ -27,32 +29,51 @@ public final class VortexDataWriterFactory implements DataWriterFactory, Seriali
     private final StructType schema;
     // Store options as a serializable Map instead of CaseInsensitiveStringMap
     private final Map<String, String> options;
+    private final PartitionedVortexDataWriter.ResolvedTransform[] resolvedTransforms;
 
     /**
      * Creates a new VortexDataWriterFactory.
      *
-     * @param outputUri the base path where Vortex files will be written
-     * @param schema    the schema of the data to write
-     * @param options   additional write options
+     * @param outputUri          the base path where Vortex files will be written
+     * @param schema             the schema of the data to write
+     * @param options            additional write options
+     * @param resolvedTransforms pre-resolved partition transforms (may be empty)
      */
-    public VortexDataWriterFactory(String outputUri, StructType schema, Map<String, String> options) {
+    VortexDataWriterFactory(
+            String outputUri,
+            StructType schema,
+            Map<String, String> options,
+            PartitionedVortexDataWriter.ResolvedTransform[] resolvedTransforms) {
         this.outputUri = outputUri;
         this.schema = schema;
         this.options = options;
+        this.resolvedTransforms = resolvedTransforms;
     }
 
     /**
      * Creates a new data writer for a specific partition and task.
      * <p>
      * Each task writes its data to a separate Vortex file to avoid conflicts.
+     * When partition transforms are configured, returns a {@link PartitionedVortexDataWriter}
+     * that creates Hive-style partition directories.
      *
      * @param partitionId the partition ID
      * @param taskId      the task ID
-     * @return a new VortexDataWriter instance
+     * @return a new DataWriter instance
      */
     @Override
     public DataWriter<InternalRow> createWriter(int partitionId, long taskId) {
-        // Create a unique file name for this task
+        log.debug("Creating writer for partition={} task={}", partitionId, taskId);
+
+        CaseInsensitiveStringMap optionsMap = new CaseInsensitiveStringMap(options);
+
+        if (resolvedTransforms.length > 0) {
+            log.debug("Creating partitioned writer with {} transforms", resolvedTransforms.length);
+            return new PartitionedVortexDataWriter(
+                    outputUri, schema, optionsMap, resolvedTransforms, partitionId, taskId);
+        }
+
+        // Non-partitioned write: single file per task
         String fileName = String.format("part-%05d-%d.vortex", partitionId, taskId);
         String fileUri;
         if (outputUri.endsWith("/")) {
@@ -61,13 +82,7 @@ public DataWriter<InternalRow> createWriter(int partitionId, long taskId) {
             fileUri = outputUri + "/" + fileName;
         }
 
-        log.debug("Creating writer for partition={} task={}", partitionId, taskId);
-        log.debug("Output path: {}", outputUri);
-        log.debug("File name: {}", fileName);
-        log.debug("Full file path: {}", fileUri);
-
-        // Create a new CaseInsensitiveStringMap from our serializable Map
-        CaseInsensitiveStringMap optionsMap = new CaseInsensitiveStringMap(options);
+        log.debug("Output file: {}", fileUri);
         return new VortexDataWriter(fileUri, schema, optionsMap);
     }
 }
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriteBuilder.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriteBuilder.java
index 21198f7b4d7..8fe910ad370 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriteBuilder.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriteBuilder.java
@@ -4,6 +4,7 @@
 package dev.vortex.spark.write;
 
 import java.util.Map;
+import org.apache.spark.sql.connector.expressions.Transform;
 import org.apache.spark.sql.connector.write.LogicalWriteInfo;
 import org.apache.spark.sql.connector.write.SupportsTruncate;
 import org.apache.spark.sql.connector.write.Write;
@@ -20,19 +21,23 @@ public final class VortexWriteBuilder implements WriteBuilder, SupportsTruncate
     private final String paths;
     private final LogicalWriteInfo writeInfo;
     private final Map<String, String> options;
+    private final Transform[] partitionTransforms;
     private boolean truncate = false;
 
     /**
      * Creates a new VortexWriteBuilder.
      *
-     * @param paths     root path for write
-     * @param writeInfo logical information about the write operation
-     * @param options   additional write options
+     * @param paths               root path for write
+     * @param writeInfo           logical information about the write operation
+     * @param options             additional write options
+     * @param partitionTransforms partition transforms (may be empty)
      */
-    public VortexWriteBuilder(String paths, LogicalWriteInfo writeInfo, Map<String, String> options) {
+    public VortexWriteBuilder(
+            String paths, LogicalWriteInfo writeInfo, Map<String, String> options, Transform[] partitionTransforms) {
         this.paths = paths;
         this.writeInfo = writeInfo;
         this.options = options;
+        this.partitionTransforms = partitionTransforms;
     }
 
     /**
@@ -42,7 +47,7 @@ public VortexWriteBuilder(String paths, LogicalWriteInfo writeInfo, Map<String,
      */
     @Override
     public Write build() {
-        return new VortexBatchWrite(paths, writeInfo.schema(), options, truncate);
+        return new VortexBatchWrite(paths, writeInfo.schema(), options, truncate, partitionTransforms);
     }
 
     /**
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriterCommitMessage.java b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriterCommitMessage.java
index cd452ae1f34..911819106e7 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriterCommitMessage.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/write/VortexWriterCommitMessage.java
@@ -8,35 +8,29 @@
 
 /**
  * Commit message containing information about a successfully written Vortex file.
- *
+ * <p>
  * This message is passed from executors back to the driver to coordinate
  * the commit phase of the write operation.
  */
-public final class VortexWriterCommitMessage implements WriterCommitMessage, Serializable {
-
-    private final String filePath;
-    private final long recordCount;
-    private final long bytesWritten;
+public record VortexWriterCommitMessage(String filePath, long recordCount, long bytesWritten)
+        implements WriterCommitMessage, Serializable {
 
     /**
      * Creates a new commit message for a written Vortex file.
      *
-     * @param filePath the path to the written file
-     * @param recordCount the number of records written
+     * @param filePath     the path to the written file
+     * @param recordCount  the number of records written
      * @param bytesWritten the number of bytes written
      */
-    public VortexWriterCommitMessage(String filePath, long recordCount, long bytesWritten) {
-        this.filePath = filePath;
-        this.recordCount = recordCount;
-        this.bytesWritten = bytesWritten;
-    }
+    public VortexWriterCommitMessage {}
 
     /**
      * Gets the path to the written Vortex file.
      *
      * @return the file path
      */
-    public String getFilePath() {
+    @Override
+    public String filePath() {
         return filePath;
     }
 
@@ -45,7 +39,8 @@ public String getFilePath() {
      *
      * @return the record count
      */
-    public long getRecordCount() {
+    @Override
+    public long recordCount() {
         return recordCount;
     }
 
@@ -54,7 +49,8 @@ public long getRecordCount() {
      *
      * @return the byte count
      */
-    public long getBytesWritten() {
+    @Override
+    public long bytesWritten() {
         return bytesWritten;
     }
 }
diff --git a/java/vortex-spark/src/test/java/dev/vortex/spark/SparkTypesTest.java b/java/vortex-spark/src/test/java/dev/vortex/spark/SparkTypesTest.java
new file mode 100644
index 00000000000..6c80ab6b694
--- /dev/null
+++ b/java/vortex-spark/src/test/java/dev/vortex/spark/SparkTypesTest.java
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import dev.vortex.api.DType;
+import dev.vortex.jni.NativeLoader;
+import org.apache.spark.sql.types.ArrayType;
+import org.apache.spark.sql.types.DataTypes;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public final class SparkTypesTest {
+
+    @BeforeAll
+    public static void loadLibrary() {
+        NativeLoader.loadJni();
+    }
+
+    @Test
+    @DisplayName("toDataType should convert FIXED_SIZE_LIST to Spark ArrayType")
+    public void testFixedSizeListToDataType() {
+        var elementType = DType.newInt(false);
+        var fslType = DType.newFixedSizeList(elementType, 3, true);
+        var sparkType = SparkTypes.toDataType(fslType);
+        assertInstanceOf(ArrayType.class, sparkType);
+        ArrayType arrayType = (ArrayType) sparkType;
+        assertEquals(DataTypes.IntegerType, arrayType.elementType());
+    }
+
+    @Test
+    @DisplayName("toDataType should convert LIST to Spark ArrayType")
+    public void testListToDataType() {
+        var elementType = DType.newDouble(false);
+        var listType = DType.newList(elementType, true);
+        var sparkType = SparkTypes.toDataType(listType);
+        assertInstanceOf(ArrayType.class, sparkType);
+        ArrayType arrayType = (ArrayType) sparkType;
+        assertEquals(DataTypes.DoubleType, arrayType.elementType());
+    }
+}
diff --git a/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceBasicTest.java b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceBasicTest.java
index d603c32cc8b..81b0ae3613a 100644
--- a/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceBasicTest.java
+++ b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceBasicTest.java
@@ -100,8 +100,8 @@ public void testWriterCommitMessage() {
 
         var message = new dev.vortex.spark.write.VortexWriterCommitMessage(testPath, recordCount, bytesWritten);
 
-        assertEquals(testPath, message.getFilePath());
-        assertEquals(recordCount, message.getRecordCount());
-        assertEquals(bytesWritten, message.getBytesWritten());
+        assertEquals(testPath, message.filePath());
+        assertEquals(recordCount, message.recordCount());
+        assertEquals(bytesWritten, message.bytesWritten());
     }
 }
diff --git a/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceS3MockTest.java b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceS3MockTest.java
new file mode 100644
index 00000000000..04c94546013
--- /dev/null
+++ b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceS3MockTest.java
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+package dev.vortex.spark;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.adobe.testing.s3mock.testcontainers.S3MockContainer;
+import java.util.List;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SaveMode;
+import org.apache.spark.sql.SparkSession;
+import org.apache.spark.sql.types.StructField;
+import org.apache.spark.sql.types.StructType;
+import org.junit.jupiter.api.*;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+/**
+ * Integration test for Vortex DataSource with mocked S3 using Adobe S3Mock.
+ *
+ * <p>This test verifies that Vortex can correctly read and write files from S3-compatible
+ * storage by using S3Mock running as a Testcontainer.
+ */
+@Testcontainers
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public final class VortexDataSourceS3MockTest {
+
+    private static final String TEST_BUCKET = "vortex-test-bucket";
+
+    @Container
+    private static final S3MockContainer S3_MOCK = new S3MockContainer("4.11.0").withInitialBuckets(TEST_BUCKET);
+
+    private SparkSession spark;
+
+    @BeforeAll
+    public void setUp() {
+        // Get the S3Mock endpoint
+        String s3Endpoint = S3_MOCK.getHttpEndpoint();
+
+        // Create a local Spark session configured to use S3Mock
+        spark = SparkSession.builder()
+                .appName("VortexS3MockTest")
+                .master("local[2]")
+                .config("spark.sql.shuffle.partitions", "2")
+                .config("spark.sql.adaptive.enabled", "false")
+                .config("spark.ui.enabled", "false")
+                // S3A configuration for S3Mock.
+                // This should be propagated into our reader
+                .config("spark.hadoop.fs.s3a.endpoint", s3Endpoint)
+                .config("spark.hadoop.fs.s3a.access.key", "foo")
+                .config("spark.hadoop.fs.s3a.secret.key", "bar")
+                .config("spark.hadoop.fs.s3a.path.style.access", "true")
+                // Disable features that S3Mock may not support
+                .config("spark.hadoop.fs.s3a.change.detection.version.required", "false")
+                .config("spark.hadoop.fs.s3a.change.detection.mode", "none")
+                .config("spark.hadoop.fs.s3a.multiobjectdelete.enable", "false")
+                .getOrCreate();
+    }
+
+    @AfterAll
+    public void tearDown() {
+        if (spark != null) {
+            spark.stop();
+        }
+    }
+
+    @Test
+    @DisplayName("Write and read Vortex files from mocked S3")
+    public void testWriteAndReadVortexFilesFromS3Mock() {
+        // Given: Create a DataFrame with test data
+        int numRows = 100;
+        Dataset<Row> originalDf = createTestDataFrame(numRows);
+
+        // When: Write to S3Mock
+        String s3Path = "s3a://" + TEST_BUCKET + "/vortex-test";
+        originalDf
+                .repartition(2)
+                .write()
+                .format("vortex")
+                .option("path", s3Path)
+                .mode(SaveMode.Overwrite)
+                .save();
+
+        // Then: Read back from S3Mock
+        Dataset<Row> readDf = spark.read().format("vortex").load(s3Path);
+
+        // Verify schema is preserved
+        assertSchemaEquals(originalDf.schema(), readDf.schema());
+
+        // Verify row count
+        assertEquals(numRows, readDf.count(), "Read DataFrame should have same number of rows as original");
+
+        // Verify data content
+        verifyDataContent(originalDf, readDf);
+    }
+
+    @Test
+    @DisplayName("Write and read Vortex files with format options from S3Mock")
+    public void testWriteAndReadWithFormatOptionsFromS3Mock() {
+        // Given: Create a DataFrame with test data
+        int numRows = 50;
+        Dataset<Row> originalDf = createTestDataFrame(numRows);
+
+        // When: Write to S3Mock with format options
+        String s3Path = "s3a://" + TEST_BUCKET + "/vortex-options-test";
+        originalDf
+                .write()
+                .format("vortex")
+                .option("path", s3Path)
+                .mode(SaveMode.Overwrite)
+                .save();
+
+        // Then: Read back from S3Mock with format options
+        Dataset<Row> readDf =
+                spark.read().format("vortex").option("path", s3Path).load();
+
+        // Verify row count
+        assertEquals(numRows, readDf.count(), "Read DataFrame should have same number of rows as original");
+
+        // Verify data content
+        verifyDataContent(originalDf, readDf);
+    }
+
+    /**
+     * Creates a test DataFrame with monotonically increasing integers
+     * and their string representations.
+     */
+    private Dataset<Row> createTestDataFrame(int numRows) {
+        return spark.range(0, numRows)
+                .selectExpr(
+                        "cast(id as int) as id",
+                        "concat('value_', cast(id as string)) as value",
+                        "array('Alpha', 'Bravo', 'Charlie') AS elements");
+    }
+
+    /**
+     * Verifies that two schemas are equal.
+     */
+    private void assertSchemaEquals(StructType expected, StructType actual) {
+        assertEquals(expected.fields().length, actual.fields().length, "Schemas should have same number of fields");
+
+        for (int i = 0; i < expected.fields().length; i++) {
+            StructField expectedField = expected.fields()[i];
+            StructField actualField = actual.fields()[i];
+
+            assertEquals(expectedField.name(), actualField.name(), "Field names should match at position " + i);
+            assertEquals(
+                    expectedField.dataType(),
+                    actualField.dataType(),
+                    "Field types should match for field: " + expectedField.name());
+            assertEquals(
+                    expectedField.nullable(),
+                    actualField.nullable(),
+                    "Field nullability should match for field: " + expectedField.name());
+        }
+    }
+
+    /**
+     * Verifies that the data content of two DataFrames is identical.
+     */
+    private void verifyDataContent(Dataset<Row> expected, Dataset<Row> actual) {
+        // Sort both DataFrames by id to ensure consistent ordering
+        Dataset<Row> expectedSorted = expected.orderBy("id");
+        Dataset<Row> actualSorted = actual.orderBy("id");
+
+        // Collect and compare
+        List<Row> expectedRows = expectedSorted.collectAsList();
+        List<Row> actualRows = actualSorted.collectAsList();
+
+        assertEquals(expectedRows.size(), actualRows.size(), "Should have same number of rows");
+
+        for (int i = 0; i < expectedRows.size(); i++) {
+            Row expectedRow = expectedRows.get(i);
+            Row actualRow = actualRows.get(i);
+
+            assertEquals(expectedRow.getInt(0), actualRow.getInt(0), "ID should match at row " + i);
+            assertEquals(expectedRow.getString(1), actualRow.getString(1), "Value should match at row " + i);
+        }
+    }
+}
diff --git a/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceWriteTest.java b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceWriteTest.java
index df22407162b..6c5686fa93c 100644
--- a/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceWriteTest.java
+++ b/java/vortex-spark/src/test/java/dev/vortex/spark/VortexDataSourceWriteTest.java
@@ -178,53 +178,100 @@ public void testOverwriteMode() throws IOException {
     }
 
     @Test
-    @DisplayName("Write and read Vortex files from S3")
-    public void testWriteAndReadFromS3() throws IOException {
-        // Skip test if AWS credentials or S3 base URI are not available
-        String awsAccessKey = System.getenv("AWS_ACCESS_KEY_ID");
-        String awsSecretKey = System.getenv("AWS_SECRET_ACCESS_KEY");
-        String s3BaseUri = System.getenv("VORTEX_TEST_S3_BASE_URI");
-
-        Assumptions.assumeTrue(
-                awsAccessKey != null && awsSecretKey != null, "Skipping S3 test - AWS credentials not configured");
+    @DisplayName("Write and read partitioned Vortex files")
+    public void testPartitionedWrite() throws IOException {
+        // Given: a DataFrame with a partition column
+        List<Row> rows = Arrays.asList(
+                RowFactory.create(1, "alpha", "A"),
+                RowFactory.create(2, "beta", "B"),
+                RowFactory.create(3, "gamma", "A"),
+                RowFactory.create(4, "delta", "B"),
+                RowFactory.create(5, "epsilon", "A"));
 
-        Assumptions.assumeTrue(
-                s3BaseUri != null,
-                "Skipping S3 test - VORTEX_TEST_S3_BASE_URI not configured (e.g., s3://bucket/path)");
+        Dataset<Row> df = spark.createDataFrame(
+                rows,
+                DataTypes.createStructType(Arrays.asList(
+                        DataTypes.createStructField("id", DataTypes.IntegerType, false),
+                        DataTypes.createStructField("name", DataTypes.StringType, true),
+                        DataTypes.createStructField("group", DataTypes.StringType, true))));
 
-        // Given: Create a test DataFrame
-        int numRows = 100;
-        Dataset<Row> originalDf = createTestDataFrame(numRows);
+        Path outputPath = tempDir.resolve("partitioned_output");
 
-        // When: Write to S3 (relying on environment credentials)
-        String s3Path = s3BaseUri + "/spark-test-" + System.currentTimeMillis();
-        originalDf
-                .repartition(2) // Force 2 partitions
-                .write()
+        // When: write with partitionBy
+        df.write()
                 .format("vortex")
-                .option("path", s3Path)
+                .partitionBy("group")
+                .option("path", outputPath.toUri().toString())
                 .mode(SaveMode.Overwrite)
                 .save();
 
-        // Then: Read back from S3
-        Dataset<Row> readDf =
-                spark.read().format("vortex").option("path", s3Path).load();
+        // Then: verify partition directories exist
+        assertTrue(Files.exists(outputPath.resolve("group=A")), "Partition directory group=A should exist");
+        assertTrue(Files.exists(outputPath.resolve("group=B")), "Partition directory group=B should exist");
 
-        // Verify schema is preserved
-        assertSchemaEquals(originalDf.schema(), readDf.schema());
+        // Verify vortex files inside partition directories
+        List<Path> filesA = findVortexFiles(outputPath.resolve("group=A"));
+        List<Path> filesB = findVortexFiles(outputPath.resolve("group=B"));
+        assertTrue(!filesA.isEmpty(), "Partition A should have vortex files");
+        assertTrue(!filesB.isEmpty(), "Partition B should have vortex files");
 
-        // Verify row count
-        assertEquals(numRows, readDf.count(), "Read DataFrame should have same number of rows as original");
+        // When: read back
+        Dataset<Row> readDf = spark.read()
+                .format("vortex")
+                .option("path", outputPath.toUri().toString())
+                .load();
 
-        // Verify data content
-        verifyDataContent(originalDf, readDf);
+        // Then: verify all rows are present
+        assertEquals(5, readDf.count(), "Should read all 5 rows back");
 
-        // Log the S3 path for debugging
-        System.out.println("Successfully wrote and read Vortex files from: " + s3Path);
+        // Verify partition values are correct
+        Dataset<Row> groupA = readDf.filter(readDf.col("group").equalTo("A")).orderBy("id");
+        assertEquals(3, groupA.count(), "Group A should have 3 rows");
+        assertEquals(1, (int) groupA.collectAsList().get(0).getAs("id"));
+        assertEquals(3, (int) groupA.collectAsList().get(1).getAs("id"));
+        assertEquals(5, (int) groupA.collectAsList().get(2).getAs("id"));
+    }
+
+    @Test
+    @DisplayName("Write and read with multiple partition columns")
+    public void testMultiColumnPartitionedWrite() throws IOException {
+        List<Row> rows = Arrays.asList(
+                RowFactory.create(1, "X", 10),
+                RowFactory.create(2, "Y", 20),
+                RowFactory.create(3, "X", 20),
+                RowFactory.create(4, "Y", 10));
+
+        Dataset<Row> df = spark.createDataFrame(
+                rows,
+                DataTypes.createStructType(Arrays.asList(
+                        DataTypes.createStructField("id", DataTypes.IntegerType, false),
+                        DataTypes.createStructField("category", DataTypes.StringType, true),
+                        DataTypes.createStructField("bucket", DataTypes.IntegerType, false))));
+
+        Path outputPath = tempDir.resolve("multi_partition_output");
+
+        df.write()
+                .format("vortex")
+                .partitionBy("category", "bucket")
+                .option("path", outputPath.toUri().toString())
+                .mode(SaveMode.Overwrite)
+                .save();
+
+        // Verify nested partition directories
+        assertTrue(
+                Files.exists(outputPath.resolve("category=X/bucket=10")),
+                "Partition directory category=X/bucket=10 should exist");
+        assertTrue(
+                Files.exists(outputPath.resolve("category=Y/bucket=20")),
+                "Partition directory category=Y/bucket=20 should exist");
+
+        // Read back and verify
+        Dataset<Row> readDf = spark.read()
+                .format("vortex")
+                .option("path", outputPath.toUri().toString())
+                .load();
 
-        // Cleanup: Delete the test files from S3
-        // Note: In production, you might want to use AWS SDK for cleanup
-        // For now, we'll rely on a periodic cleanup job for the test folder
+        assertEquals(4, readDf.count(), "Should read all 4 rows back");
     }
 
     @Test
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 00000000000..0cd0ca8e96d
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "vortex",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
diff --git a/package.json b/package.json
new file mode 100644
index 00000000000..0967ef424bc
--- /dev/null
+++ b/package.json
@@ -0,0 +1 @@
+{}
diff --git a/pyproject.toml b/pyproject.toml
index ff4654cf220..f0e82ec52c9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,28 +14,17 @@ build-backend = "hatchling.build"
 packages = ["dummy"] # Required for workspace project
 
 [dependency-groups]
-# Currently, all dev dependencies live in the root since uv doesn't have transitive dev dependencies.
-#  See: https://github.com/astral-sh/uv/issues/7541
+# Shared dev tooling. Member-specific dev deps live in each member's pyproject.toml.
+# `uv sync --all-packages` picks up dev groups from all workspace members.
 dev = [
     "basedpyright>=1.31",
-    "duckdb>=1.1.2",
     "ipython>=8.26.0",
-    "maturin>=1.7.2",
-    "pandas-stubs>=2.2.3.241126",
-    "pandas[output-formatting]>=2.2.3",
-    "pcodec>=0.3.3",
     "pip>=23.3.2",
-    "polars>=1.9.0",
-    "pyarrow-stubs>=17.16",
-    "pytest-benchmark>=4.0.0",
     "pytest>=7.4.0",
     "ruff>=0.7.1",
-    "ray>=2.48",
-    "pytest-benchmark>=5.1.0",
     # forced transitive bumps
     "urllib3>=2.6.3",
     "filelock>=3.20.3",
-    "protobuf>=6.33.5",
 ]
 
 [tool.uv]
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index e6c94d091a7..c8eba8175ae 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
 channel = "1.90"
 components = ["rust-src", "rustfmt", "clippy", "rust-analyzer"]
-profile = "minimal"
+profile = "minimal"
\ No newline at end of file
diff --git a/scripts/bench-taskset.sh b/scripts/bench-taskset.sh
new file mode 100644
index 00000000000..a86f6818ab3
--- /dev/null
+++ b/scripts/bench-taskset.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+set -Eeu -o pipefail
+
+if [[ $# -eq 0 ]]; then
+    echo "Usage: $0 <command> [args...]" >&2
+    exit 1
+fi
+
+if [[ -f /tmp/vortex-benchmark.env ]]; then
+    # shellcheck disable=SC1091
+    source /tmp/vortex-benchmark.env
+fi
+
+
+
+if [[ -z "${BENCH_CPUS:-}" ]]; then
+    cpu_count="$(nproc)"
+    BENCH_CPUS="2-$((cpu_count - 1))"
+fi
+
+if command -v numactl >/dev/null 2>&1; then
+    exec numactl --physcpubind="$BENCH_CPUS" --localalloc "$@"
+fi
+
+exec taskset -c "$BENCH_CPUS" "$@"
diff --git a/scripts/capture-file-sizes.py b/scripts/capture-file-sizes.py
new file mode 100644
index 00000000000..754df1ee702
--- /dev/null
+++ b/scripts/capture-file-sizes.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+"""Capture file sizes from benchmark data directories and output as JSONL."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Capture file sizes from benchmark data directories")
+    parser.add_argument("data_dir", help="Data directory (e.g., vortex-bench/data)")
+    parser.add_argument("--benchmark", required=True, help="Benchmark name (e.g., clickbench)")
+    parser.add_argument("--commit", required=True, help="Commit SHA")
+    parser.add_argument("-o", "--output", required=True, help="Output JSONL file path")
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    if not data_dir.exists():
+        print(f"Data directory not found: {data_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    # Find benchmark directories matching the name (handles flavors like clickbench_partitioned)
+    # Also handles exact match (e.g., tpch)
+    benchmark_dirs = [
+        d
+        for d in data_dir.iterdir()
+        if d.is_dir() and (d.name == args.benchmark or d.name.startswith(f"{args.benchmark}_"))
+    ]
+
+    if not benchmark_dirs:
+        print(f"No benchmark directories found matching: {args.benchmark}", file=sys.stderr)
+        sys.exit(1)
+
+    # Formats to capture (vortex formats only, not parquet/duckdb)
+    # Note: "vortex" CLI arg maps to "vortex-file-compressed" directory name
+    formats_to_capture = {"vortex-file-compressed", "vortex-compact"}
+
+    records = []
+
+    # Walk subdirectories looking for format directories
+    # Handle both direct format dirs (clickbench_partitioned/vortex-file-compressed/)
+    # and scale factor subdirs (tpch/1.0/vortex-file-compressed/)
+    for benchmark_dir in benchmark_dirs:
+        for format_dir in benchmark_dir.rglob("*"):
+            if not format_dir.is_dir():
+                continue
+
+            format_name = format_dir.name
+            if format_name not in formats_to_capture:
+                continue
+
+            # Extract scale factor from path (e.g., "1.0" for tpch/1.0/vortex-file-compressed)
+            # Default to "1.0" if no intermediate directory (e.g., clickbench)
+            path_between = format_dir.relative_to(benchmark_dir).parent
+            scale_factor = str(path_between) if str(path_between) != "." else "1.0"
+
+            # Capture all files in this format directory
+            for file_path in format_dir.rglob("*"):
+                if not file_path.is_file():
+                    continue
+
+                size_bytes = file_path.stat().st_size
+                relative_path = file_path.relative_to(format_dir)
+
+                records.append(
+                    {
+                        "commit_id": args.commit,
+                        "benchmark": args.benchmark,
+                        "scale_factor": scale_factor,
+                        "format": format_name,
+                        "file": str(relative_path),
+                        "size_bytes": size_bytes,
+                    }
+                )
+
+    # Sort for deterministic output
+    records.sort(key=lambda r: (r["benchmark"], r["scale_factor"], r["format"], r["file"]))
+
+    # Write JSONL output
+    with open(args.output, "w") as f:
+        for record in records:
+            f.write(json.dumps(record) + "\n")
+
+    print(f"Captured {len(records)} file sizes to {args.output}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/cat-s3.sh b/scripts/cat-s3.sh
index cb9edc2a53e..5864149759b 100644
--- a/scripts/cat-s3.sh
+++ b/scripts/cat-s3.sh
@@ -12,7 +12,25 @@ local_concatenated=$(mktemp)
 n_failures=0
 
 while (( n_failures < 100 )); do
-    current_etag=$(aws s3api head-object --bucket "$bucket" --key "$key" --query ETag --output text)
+    current_etag=$(aws s3api head-object --bucket "$bucket" --key "$key" --query ETag --output text 2>/dev/null) || {
+        # File doesn't exist yet, try to create it fresh
+        echo "File does not exist in S3, creating new file."
+        if [[ "$key" =~ \.gz$ ]]; then
+            gzip -c "$local_file_to_concatenate" > "$local_concatenated"
+        else
+            cp "$local_file_to_concatenate" "$local_concatenated"
+        fi
+        # Use --if-none-match to avoid race with concurrent writers
+        aws s3api put-object --bucket "$bucket" --key "$key" --body "$local_concatenated" --if-none-match "*" && {
+            echo "File created and uploaded successfully."
+            exit 0
+        }
+        # Another writer created the file first, retry to concatenate with it
+        echo "File was created by another writer, retrying to concatenate."
+        n_failures=$(( n_failures + 1 ))
+        sleep 0.1
+        continue
+    }
     if [[ "$current_etag" == "null" ]]; then
         echo "Failed to retrieve ETag. Exiting."
         exit 1
@@ -32,7 +50,7 @@ while (( n_failures < 100 )); do
         gzip -c "$local_decompressed_concat" > "$local_concatenated"
         rm "$local_decompressed" "$local_decompressed_concat"
     else
-        cat $local_copy $local_file_to_concatenate > $local_concatenated
+        cat "$local_copy" "$local_file_to_concatenate" > "$local_concatenated"
     fi
 
 
diff --git a/scripts/compare-benchmark-jsons.py b/scripts/compare-benchmark-jsons.py
index 6bda4e2eadd..44514053fad 100644
--- a/scripts/compare-benchmark-jsons.py
+++ b/scripts/compare-benchmark-jsons.py
@@ -1,6 +1,7 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
+#   "numpy",
 #   "pandas",
 #   "tabulate",
 # ]
@@ -10,192 +11,619 @@
 # SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 import math
+import re
 import sys
+from dataclasses import dataclass
+from typing import Any
 
+import numpy as np
 import pandas as pd
 
-# Check if benchmark name argument is provided (will be added from workflow)
-benchmark_name = sys.argv[3] if len(sys.argv) > 3 else ""
+# Analysis overview:
+# - Join base and PR benchmark rows on benchmark identity.
+# - Use log-ratios because benchmark slowdowns/speedups are multiplicative.
+# - Treat parquet rows as controls to estimate systemic drift beta(q).
+# - Attribute the remaining change to the PR as alpha(q, c).
+# - Call a row significant only when alpha clears a conservative noise floor.
+# - Collapse those row-level results into a short verdict for the PR comment.
+#
+# Concretely:
+# - raw ratio = median_runtime_pr / median_runtime_base
+# - log_ratio = log(raw ratio)
+# - beta(q) = mean(log_ratio) across parquet control rows for query q
+# - alpha(q, c) = log_ratio(q, c) - beta(q)
+# - attributed impact = geometric mean of alpha ratios across non-control rows
+
+# Benchmarks are noisier than textbook measurement data, so use a conservative
+# cutoff that is closer to a 99% two-sided interval before calling a change real.
+Z_SCORE_99 = 2.5758293035489004
+CONTROL_FORMAT = "parquet"
+
+
+@dataclass
+class MedianPolishResult:
+    """Robust additive decomposition for the query x config log-ratio matrix."""
+
+    overall: float
+    row_effects: pd.Series
+    column_effects: pd.Series
+    residuals: pd.DataFrame
+    converged: bool
+
+
+def extract_dataset_key(df: pd.DataFrame) -> pd.DataFrame:
+    """Normalize dataset metadata into a stable join key."""
 
-base = pd.read_json(sys.argv[1], lines=True)
-pr = pd.read_json(sys.argv[2], lines=True)
-
-base_commit_id = set(base["commit_id"].unique())
-pr_commit_id = set(pr["commit_id"].unique())
-
-assert len(base_commit_id) == 1, base_commit_id
-base_commit_id = next(iter(base_commit_id))
-assert len(pr_commit_id) == 1, pr_commit_id
-pr_commit_id = next(iter(pr_commit_id))
-
-# Handle missing storage field
-if "storage" not in base:
-    base["storage"] = pd.NA
-if "storage" not in pr:
-    pr["storage"] = pd.NA
-
-
-# Handle missing dataset field and create a dataset key for joining
-def extract_dataset_key(df):
     if "dataset" not in df.columns:
         df["dataset_key"] = pd.NA
     else:
-        # Convert dataset dict to a string representation for joining
         df["dataset_key"] = df["dataset"].apply(
             lambda x: str(sorted(x.items())) if pd.notna(x) and isinstance(x, dict) else pd.NA
         )
     return df
 
 
-base = extract_dataset_key(base)
-pr = extract_dataset_key(pr)
+def extract_target_fields(name: str) -> pd.Series:
+    """Parse query, engine, and format from the benchmark name."""
+
+    if not isinstance(name, str):
+        return pd.Series({"engine": "unknown", "file_format": "unknown", "query": pd.NA})
+
+    match = re.search(r"_q(\d+)/([^:]+):(.+)$", name)
+    if match is None:
+        return pd.Series({"engine": "unknown", "file_format": "unknown", "query": pd.NA})
+
+    return pd.Series(
+        {
+            "engine": match.group(2),
+            "file_format": match.group(3),
+            "query": int(match.group(1)),
+        }
+    )
+
+
+def positive_samples(values: Any) -> np.ndarray:
+    """Keep only finite, strictly positive runtime samples."""
+
+    if not isinstance(values, (list, tuple, np.ndarray, pd.Series)):
+        return np.array([], dtype=float)
+    samples = np.asarray(values, dtype=float)
+    return samples[np.isfinite(samples) & (samples > 0)]
+
+
+def log_runtime_stats(values: Any) -> dict[str, float]:
+    """Summarize repeated runtimes on the log scale."""
+
+    samples = positive_samples(values)
+    if samples.size == 0:
+        return {
+            "sample_count": 0,
+            "log_mean": float("nan"),
+            "log_std": float("nan"),
+            "log_se": float("nan"),
+        }
+
+    logs = np.log(samples)
+    log_std = float(np.std(logs, ddof=1)) if logs.size > 1 else 0.0
+    return {
+        "sample_count": int(logs.size),
+        "log_mean": float(logs.mean()),
+        "log_std": log_std,
+        "log_se": float(log_std / np.sqrt(logs.size)),
+    }
+
+
+def ratio_stats(
+    base_values: Any,
+    pr_values: Any,
+    base_median: float,
+    pr_median: float,
+) -> dict[str, float]:
+    """Compute the PR/base effect and its sampling error for one matched row."""
+
+    base_stats = log_runtime_stats(base_values)
+    pr_stats = log_runtime_stats(pr_values)
+
+    if not np.isfinite(base_median) or not np.isfinite(pr_median) or base_median <= 0 or pr_median <= 0:
+        return {
+            "ratio": float("nan"),
+            "log_ratio": float("nan"),
+            "log_ratio_se": float("nan"),
+            **{f"base_{key}": value for key, value in base_stats.items()},
+            **{f"pr_{key}": value for key, value in pr_stats.items()},
+        }
+
+    ratio = pr_median / base_median
+    return {
+        "ratio": ratio,
+        "log_ratio": float(np.log(ratio)),
+        "log_ratio_se": float(np.hypot(base_stats["log_se"], pr_stats["log_se"])),
+        **{f"base_{key}": value for key, value in base_stats.items()},
+        **{f"pr_{key}": value for key, value in pr_stats.items()},
+    }
+
+
+def median_polish(table: pd.DataFrame, max_iterations: int = 10, tolerance: float = 1e-8) -> MedianPolishResult | None:
+    """Estimate row and column effects for the log-ratio matrix."""
+
+    working = table.copy().astype(float)
+    working = working.dropna(axis=0, how="any").dropna(axis=1, how="any")
+    if working.shape[0] < 2 or working.shape[1] < 2:
+        return None
+
+    row_effects = pd.Series(0.0, index=working.index, dtype=float)
+    column_effects = pd.Series(0.0, index=working.columns, dtype=float)
+    overall = 0.0
+    converged = False
+
+    for _ in range(max_iterations):
+        row_medians = working.median(axis=1)
+        working = working.sub(row_medians, axis=0)
+        row_effects = row_effects.add(row_medians, fill_value=0.0)
+        row_shift = float(row_effects.median())
+        row_effects -= row_shift
+        overall += row_shift
+
+        column_medians = working.median(axis=0)
+        working = working.sub(column_medians, axis=1)
+        column_effects = column_effects.add(column_medians, fill_value=0.0)
+        column_shift = float(column_effects.median())
+        column_effects -= column_shift
+        overall += column_shift
+
+        largest_adjustment = max(
+            float(row_medians.abs().max()) if not row_medians.empty else 0.0,
+            float(column_medians.abs().max()) if not column_medians.empty else 0.0,
+        )
+        if largest_adjustment <= tolerance:
+            converged = True
+            break
+
+    return MedianPolishResult(
+        overall=float(overall),
+        row_effects=row_effects,
+        column_effects=column_effects,
+        residuals=working,
+        converged=converged,
+    )
+
+
+def mean_with_standard_error(group: pd.DataFrame, value_column: str, se_column: str) -> float:
+    """Approximate the standard error of a group mean from row-level errors."""
+
+    valid = group[[value_column, se_column]].dropna()
+    if valid.empty:
+        return float("nan")
+    return float(np.sqrt(np.square(valid[se_column]).sum()) / len(valid))
+
 
-# Join on name, storage, and dataset_key
-# NB: `pd.merge` considers two null key values to be equal, so benchmarks without these keys will match.
-df3 = pd.merge(base, pr, on=["name", "storage", "dataset_key"], how="right", suffixes=("_base", "_pr"))
+def classify_signal(alpha_log_ratio: float, alpha_log_se: float, control_noise_log_std: float, threshold: float) -> str:
+    """Label an attributed change as real or noise using a conservative floor."""
 
-# assert df3["unit_base"].equals(df3["unit_pr"]), (df3["unit_base"], df3["unit_pr"])
+    if np.isnan(alpha_log_ratio):
+        return "N/A"
 
-# Determine threshold based on benchmark name
-# Use 30% threshold for S3 benchmarks, 10% for others
-is_s3_benchmark = "s3" in benchmark_name.lower()
-threshold_pct = 30 if is_s3_benchmark else 10
-improvement_threshold = 1.0 - (threshold_pct / 100.0)  # e.g., 0.7 for 30%, 0.9 for 10%
-regression_threshold = 1.0 + (threshold_pct / 100.0)  # e.g., 1.3 for 30%, 1.1 for 10%
+    effect_floor = np.log1p(threshold)
+    sample_noise = Z_SCORE_99 * alpha_log_se if np.isfinite(alpha_log_se) else 0.0
+    systemic_noise = Z_SCORE_99 * control_noise_log_std if np.isfinite(control_noise_log_std) else 0.0
+    noise_floor = max(effect_floor, sample_noise, systemic_noise)
 
-# Generate summary statistics
-df3["ratio"] = df3["value_pr"] / df3["value_base"]
-df3["remark"] = pd.Series([""] * len(df3))
-df3["remark"] = df3["remark"].case_when(
-    [
-        (df3["ratio"] >= regression_threshold, "🚨"),
-        (df3["ratio"] <= improvement_threshold, "🚀"),
-    ]
-)
+    if abs(alpha_log_ratio) < noise_floor:
+        return "noise"
+    return "regression" if alpha_log_ratio > 0 else "improvement"
 
-# Filter for different target combinations for summary statistics
-vortex_df = df3[df3["name"].str.contains("vortex", case=False, na=False)]
-duckdb_vortex_df = df3[df3["name"].str.contains("duckdb.*vortex", case=False, na=False, regex=True)]
-datafusion_vortex_df = df3[df3["name"].str.contains("datafusion.*vortex", case=False, na=False, regex=True)]
 
+def build_statistical_analysis(df: pd.DataFrame, threshold_pct: int) -> dict[str, Any] | None:
+    """Build the full alpha/beta attribution model for the markdown report."""
 
-# Overall performance (all results)
-valid_positive_ratios = [r for r in df3["ratio"] if r > 0 and not pd.isna(r)]
-if len(valid_positive_ratios) > 0:
-    geo_mean_ratio = math.exp(sum(math.log(r) for r in valid_positive_ratios) / len(valid_positive_ratios))
-else:
-    geo_mean_ratio = float("nan")
+    matched = df[
+        df["query"].notna()
+        & df["engine"].notna()
+        & df["file_format"].notna()
+        & df["value_base"].notna()
+        & df["value_pr"].notna()
+    ].copy()
 
+    if matched.empty:
+        return None
+
+    # One row here is one query/config benchmark matched between base and PR.
+    rows: list[dict[str, Any]] = []
+    for _, row in matched.iterrows():
+        stats = ratio_stats(
+            row.get("all_runtimes_base"),
+            row.get("all_runtimes_pr"),
+            float(row["value_base"]),
+            float(row["value_pr"]),
+        )
+        rows.append(
+            {
+                "name": row["name"],
+                "query": int(row["query"]),
+                "engine": row["engine"],
+                "file_format": row["file_format"],
+                "combo": f"{row['engine']}:{row['file_format']}",
+                "is_control": row["file_format"] == CONTROL_FORMAT,
+                **stats,
+            }
+        )
+
+    detail_df = pd.DataFrame(rows).sort_values(["query", "engine", "file_format"]).reset_index(drop=True)
+    controls = detail_df[detail_df["is_control"] & detail_df["log_ratio"].notna()]
+    if controls.empty:
+        return None
+
+    # beta(q): systemic drift inferred from parquet controls for query q.
+    query_rows: list[dict[str, Any]] = []
+    for query, group in controls.groupby("query", sort=True):
+        beta_log_ratio = float(group["log_ratio"].mean())
+        query_rows.append(
+            {
+                "query": int(query),
+                "beta_log_ratio": beta_log_ratio,
+                "beta_ratio": float(np.exp(beta_log_ratio)),
+                "beta_log_se": mean_with_standard_error(group, "log_ratio", "log_ratio_se"),
+                "beta_log_std": float(group["log_ratio"].std(ddof=1)) if len(group) > 1 else 0.0,
+                "control_count": int(len(group)),
+            }
+        )
+
+    query_stats = pd.DataFrame(query_rows)
+    detail_df = detail_df.merge(query_stats, on="query", how="left")
+
+    systemic_shift_log_ratio = float(query_stats["beta_log_ratio"].mean())
+    systemic_shift_std = float(query_stats["beta_log_ratio"].std(ddof=1)) if len(query_stats) > 1 else 0.0
+    # alpha(q, c): PR-attributable effect after subtracting the control drift.
+    detail_df["alpha_log_ratio"] = detail_df["log_ratio"] - detail_df["beta_log_ratio"]
+    detail_df["alpha_ratio"] = np.exp(detail_df["alpha_log_ratio"])
+    detail_df["alpha_log_se"] = np.hypot(detail_df["log_ratio_se"], detail_df["beta_log_se"])
+    # Noise floor = max(user threshold, sampling error, control drift variability).
+    detail_df["noise_floor_log"] = np.maximum.reduce(
+        [
+            np.full(len(detail_df), np.log1p(threshold_pct / 100.0)),
+            Z_SCORE_99 * np.nan_to_num(detail_df["alpha_log_se"], nan=0.0),
+            np.full(len(detail_df), Z_SCORE_99 * systemic_shift_std),
+        ]
+    )
+    detail_df["noise_floor_ratio"] = np.exp(detail_df["noise_floor_log"])
+    detail_df["signal"] = detail_df.apply(
+        lambda row: classify_signal(
+            row["alpha_log_ratio"],
+            row["alpha_log_se"],
+            systemic_shift_std,
+            threshold_pct / 100.0,
+        ),
+        axis=1,
+    )
+
+    # Median polish gives a robust overall shift estimate.
+    log_ratio_table = detail_df.pivot(index="query", columns="combo", values="log_ratio")
+    polish = median_polish(log_ratio_table)
+
+    return {
+        "detail_df": detail_df,
+        "query_stats": query_stats,
+        "systemic_shift_ratio": float(np.exp(systemic_shift_log_ratio)),
+        "systemic_shift_std": systemic_shift_std,
+        "median_polish": polish,
+    }
+
+
+def calculate_geo_mean(df: pd.DataFrame) -> float:
+    """Geometric mean of positive ratios from a DataFrame ratio column."""
 
-# Performance for different target combinations
-def calculate_geo_mean(df):
     valid_ratios = [r for r in df["ratio"] if r > 0 and not pd.isna(r)]
     if len(valid_ratios) > 0:
         return math.exp(sum(math.log(r) for r in valid_ratios) / len(valid_ratios))
-    else:
-        return float("nan")
+    return float("nan")
 
 
-vortex_geo_mean_ratio = calculate_geo_mean(vortex_df)
-duckdb_vortex_geo_mean_ratio = calculate_geo_mean(duckdb_vortex_df)
-datafusion_vortex_geo_mean_ratio = calculate_geo_mean(datafusion_vortex_df)
+def geometric_mean_from_values(values: pd.Series) -> float:
+    """Geometric mean of a ratio series."""
 
-# Find best and worst changes for vortex-only results
-vortex_valid_ratios = vortex_df["ratio"].dropna()
-if len(vortex_valid_ratios) > 0:
-    # Best improvement: smallest ratio (< 1.0, fastest performance)
-    improvements = vortex_valid_ratios[vortex_valid_ratios < 1.0]
-    if len(improvements) > 0:
-        best_idx = improvements.idxmin()
-        best_improvement = f"{vortex_df.loc[best_idx, 'name']} ({vortex_df.loc[best_idx, 'ratio']:.3f}x)"
-    else:
-        best_improvement = "No improvements"
+    valid_values = values[(values > 0) & values.notna()]
+    if len(valid_values) == 0:
+        return float("nan")
+    return float(np.exp(np.log(valid_values).mean()))
 
-    # Worst regression: largest ratio (> 1.0, slowest performance)
-    regressions = vortex_valid_ratios[vortex_valid_ratios > 1.0]
-    if len(regressions) > 0:
-        worst_idx = regressions.idxmax()
-        worst_regression = f"{vortex_df.loc[worst_idx, 'name']} ({vortex_df.loc[worst_idx, 'ratio']:.3f}x)"
-    else:
-        worst_regression = "No regressions"
-else:
-    best_improvement = "No valid vortex comparisons"
-    worst_regression = "No valid vortex comparisons"
 
-# Count significant changes for vortex-only results
-significant_improvements = (vortex_df["ratio"] < improvement_threshold).sum()
-significant_regressions = (vortex_df["ratio"] > regression_threshold).sum()
+def format_ratio_change(ratio: float) -> str:
+    """Render a ratio as a signed percent delta."""
 
+    if pd.isna(ratio) or ratio <= 0:
+        return "N/A"
+    return f"{(ratio - 1.0) * 100:+.1f}%"
+
+
+def format_performance(
+    ratio: float, improvement_threshold: float, regression_threshold: float, target_name: str
+) -> str:
+    """Render a geomean ratio with a coarse emoji summary."""
 
-# Build summary
-def format_performance(ratio, target_name):
     if pd.isna(ratio):
         return f"no {target_name.lower()} data"
+
+    if improvement_threshold <= ratio <= regression_threshold:
+        emoji = "➖"
+    elif ratio < 1:
+        emoji = "✅"
     else:
-        # Use neutral emoji if within threshold
-        if improvement_threshold <= ratio <= regression_threshold:
-            emoji = "➖"
-        elif ratio < 1:
-            emoji = "✅"
-        else:
-            emoji = "❌"
-        return f"{ratio:.3f}x {emoji}"
-
-
-overall_performance = "no data" if pd.isna(geo_mean_ratio) else format_performance(geo_mean_ratio, "overall")
-vortex_performance = format_performance(vortex_geo_mean_ratio, "vortex")
-duckdb_vortex_performance = format_performance(duckdb_vortex_geo_mean_ratio, "duckdb:vortex")
-datafusion_vortex_performance = format_performance(datafusion_vortex_geo_mean_ratio, "datafusion:vortex")
-
-summary_lines = [
-    "## Summary",
-    "",
-    f"- **Overall**: {overall_performance}",
-]
-
-# Only add vortex-specific sections if we have vortex data
-if len(vortex_df) > 0:
-    summary_lines.extend(
-        [
-            f"- **Vortex**: {vortex_performance}",
-        ]
-    )
+        emoji = "❌"
+    return f"{ratio:.3f}x {emoji}"
 
-# Only add duckdb:vortex section if we have that data
-if len(duckdb_vortex_df) > 0:
-    summary_lines.append(f"- **duckdb:vortex**: {duckdb_vortex_performance}")
 
-# Only add datafusion:vortex section if we have that data
-if len(datafusion_vortex_df) > 0:
-    summary_lines.append(f"- **datafusion:vortex**: {datafusion_vortex_performance}")
+def format_integer_value(value: float) -> str:
+    """Render numeric timing values for markdown tables."""
 
-# Only add best/worst if we have vortex data
-if len(vortex_df) > 0:
-    summary_lines.extend(
-        [
-            f"- **Best**: {best_improvement}",
-            f"- **Worst**: {worst_regression}",
-            f"- **Significant (>{threshold_pct}%)**: {significant_improvements}↑ {significant_regressions}↓",
-        ]
+    if pd.isna(value):
+        return ""
+    return str(int(value))
+
+
+def format_name_with_highlight(
+    name: str, ratio: float, improvement_threshold: float, regression_threshold: float
+) -> str:
+    """Highlight clearly large raw changes in the detailed per-config tables."""
+
+    if pd.isna(ratio):
+        return name
+    if ratio <= improvement_threshold:
+        return f"{name} 🚀"
+    if ratio >= regression_threshold:
+        return f"{name} 🚨"
+    return name
+
+
+def format_signal(signal: str) -> str:
+    """Render the attributed-change label for markdown output."""
+
+    if signal == "improvement":
+        return "✅ faster"
+    if signal == "regression":
+        return "🚨 regression"
+    if signal == "noise":
+        return "➖ noise"
+    return "N/A"
+
+
+def build_verdict(statistical_analysis: dict[str, Any]) -> dict[str, str] | None:
+    """Collapse row-level attribution into a short PR-comment headline."""
+
+    alpha_rows = statistical_analysis["detail_df"][~statistical_analysis["detail_df"]["is_control"]].copy()
+    if alpha_rows.empty:
+        return None
+
+    # Attributed impact is the geometric mean of non-control alpha ratios.
+    attributed_impact_ratio = geometric_mean_from_values(alpha_rows["alpha_ratio"])
+    if pd.isna(attributed_impact_ratio):
+        return None
+
+    # Confidence depends on directional consistency, share above the noise floor,
+    # and whether the controls themselves look unusually noisy.
+    signs = alpha_rows["alpha_log_ratio"].dropna()
+    consistent_sign_share = 0.0
+    if not signs.empty:
+        positive_share = float((signs > 0).mean())
+        negative_share = float((signs < 0).mean())
+        consistent_sign_share = max(positive_share, negative_share)
+
+    significant_share = float((alpha_rows["signal"] != "noise").mean())
+    evidence_share = min(consistent_sign_share, significant_share)
+
+    control_sigma = float(np.exp(statistical_analysis["systemic_shift_std"]))
+    aggregate_noise_floor = max(
+        1.0 + 1e-9,
+        control_sigma,
+        geometric_mean_from_values(alpha_rows["noise_floor_ratio"]),
     )
 
-# Build table
-table_df = pd.DataFrame(
-    {
-        "name": df3["name"],
-        f"PR {pr_commit_id[:8]}": df3["value_pr"],
-        f"base {base_commit_id[:8]}": df3["value_base"],
-        "ratio (PR/base)": df3["ratio"],
-        "unit": df3["unit_base"],
-        "remark": df3["remark"],
+    if (
+        not np.isfinite(aggregate_noise_floor)
+        or attributed_impact_ratio < aggregate_noise_floor
+        and (1.0 / attributed_impact_ratio if attributed_impact_ratio > 0 else float("inf")) < aggregate_noise_floor
+    ):
+        status = "No clear signal"
+    elif attributed_impact_ratio > 1.0:
+        status = "Likely regression"
+    else:
+        status = "Likely improvement"
+
+    if control_sigma > 1.05:
+        confidence = "environment too noisy"
+    elif evidence_share >= 0.7:
+        confidence = "high"
+    elif evidence_share >= 0.4:
+        confidence = "medium"
+    else:
+        confidence = "low"
+
+    return {
+        "status": status,
+        "impact": format_ratio_change(attributed_impact_ratio),
+        "confidence": confidence,
+        "environment_shift": format_ratio_change(statistical_analysis["systemic_shift_ratio"]),
     }
-)
-
-# Output complete formatted markdown
-print("\n".join(summary_lines))
-print("")
-print("<details>")
-print("<summary>Detailed Results Table</summary>")
-print("")
-print(table_df.to_markdown(index=False))
-print("</details>")
+
+
+ENGINE_ORDER = {
+    "vortex": 0,
+    "datafusion": 1,
+    "duckdb": 2,
+    "lance": 3,
+    "arrow": 4,
+}
+
+FILE_FORMAT_ORDER = {
+    "vortex-file-compressed": 0,
+    "vortex-compact": 1,
+    "parquet": 2,
+    "lance": 3,
+    "duckdb": 4,
+    "arrow": 5,
+}
+
+
+def group_sort_key(group_key: tuple[str, str]) -> tuple[int, int, str, str]:
+    """Keep output ordering stable and grouped by likely reader interest."""
+
+    engine, file_format = group_key
+    return (
+        ENGINE_ORDER.get(engine, len(ENGINE_ORDER)),
+        FILE_FORMAT_ORDER.get(file_format, len(FILE_FORMAT_ORDER)),
+        engine,
+        file_format,
+    )
+
+
+def main() -> None:
+    """Render the benchmark comparison markdown used in CI PR comments."""
+
+    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_commit_id = set(base["commit_id"].unique())
+    pr_commit_id = set(pr["commit_id"].unique())
+    assert len(base_commit_id) == 1, base_commit_id
+    assert len(pr_commit_id) == 1, pr_commit_id
+    base_commit_id = next(iter(base_commit_id))
+    pr_commit_id = next(iter(pr_commit_id))
+
+    if "storage" not in base:
+        base["storage"] = pd.NA
+    if "storage" not in pr:
+        pr["storage"] = pd.NA
+
+    base = extract_dataset_key(base)
+    pr = extract_dataset_key(pr)
+
+    df3 = pd.merge(base, pr, on=["name", "storage", "dataset_key"], how="right", suffixes=("_base", "_pr"))
+    df3["ratio"] = df3["value_pr"] / df3["value_base"]
+    df3[["engine", "file_format", "query"]] = df3["name"].apply(extract_target_fields)
+
+    is_s3_benchmark = "s3" in benchmark_name.lower()
+    threshold_pct = 30 if is_s3_benchmark else 10
+    improvement_threshold = 1.0 - (threshold_pct / 100.0)
+    regression_threshold = 1.0 + (threshold_pct / 100.0)
+
+    vortex_df = df3[df3["name"].str.contains("vortex", case=False, na=False)]
+    parquet_df = df3[df3["name"].str.contains("parquet", case=False, na=False)]
+
+    vortex_geo_mean_ratio = calculate_geo_mean(vortex_df)
+    parquet_geo_mean_ratio = calculate_geo_mean(parquet_df)
+
+    statistical_analysis = build_statistical_analysis(df3, threshold_pct)
+    verdict = build_verdict(statistical_analysis) if statistical_analysis is not None else None
+
+    summary_fields: list[str] = []
+
+    if verdict is not None:
+        summary_fields.append(f"**Verdict**: {verdict['status']} ({verdict['confidence']} confidence)")
+        summary_fields.append(f"**Attributed Vortex impact**: {verdict['impact']}")
+
+    if len(vortex_df) > 0:
+        vortex_performance = format_performance(
+            vortex_geo_mean_ratio,
+            improvement_threshold,
+            regression_threshold,
+            "vortex",
+        )
+        summary_fields.append(f"**Vortex (geomean)**: {vortex_performance}")
+    if len(parquet_df) > 0:
+        parquet_performance = format_performance(
+            parquet_geo_mean_ratio,
+            improvement_threshold,
+            regression_threshold,
+            "parquet",
+        )
+        summary_fields.append(f"**Parquet (geomean)**: {parquet_performance}")
+
+    if verdict is not None:
+        shifts = f"Parquet (control) {verdict['environment_shift']}"
+        if statistical_analysis is not None:
+            polish = statistical_analysis["median_polish"]
+            if polish is not None:
+                shifts += f" · Median polish {format_ratio_change(float(np.exp(polish.overall)))}"
+        summary_fields.append(f"**Shifts**: {shifts}")
+
+    print("<br>".join(summary_fields))
+    print("")
+    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")
+        group_performance = format_performance(
+            calculate_geo_mean(group_df),
+            improvement_threshold,
+            regression_threshold,
+            "group",
+        )
+        significant_improvements = (group_df["ratio"] < improvement_threshold).sum()
+        significant_regressions = (group_df["ratio"] > regression_threshold).sum()
+        unit = group_df["unit_base"].dropna().iloc[0] if group_df["unit_base"].notna().any() else "unit"
+        display_df = pd.DataFrame(
+            {
+                "name": [
+                    format_name_with_highlight(name, ratio, improvement_threshold, regression_threshold)
+                    for name, ratio in zip(group_df["name"], group_df["ratio"])
+                ],
+                f"PR {pr_commit_id[:8]} ({unit})": group_df["value_pr"].map(format_integer_value),
+                f"base {base_commit_id[:8]} ({unit})": group_df["value_base"].map(format_integer_value),
+                "ratio (PR/base)": group_df["ratio"],
+            }
+        )
+        print("<details>")
+        summary_text = (
+            f"{engine} / {file_format} ({group_performance}, {significant_improvements}↑ {significant_regressions}↓)"
+        )
+        print(f"<summary>{summary_text}</summary>")
+        print("")
+        print("<br>")
+        print("")
+        print(
+            display_df.to_markdown(
+                index=False,
+                tablefmt="github",
+                floatfmt=".2f",
+            )
+        )
+        print("")
+        print("</details>")
+
+    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/compare-file-sizes.py b/scripts/compare-file-sizes.py
new file mode 100644
index 00000000000..a4a40538e47
--- /dev/null
+++ b/scripts/compare-file-sizes.py
@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+"""Compare file sizes between base and HEAD and generate markdown report."""
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+
+
+def format_size(size_bytes: int) -> str:
+    """Format bytes as human-readable size."""
+    if size_bytes >= 1024**3:
+        return f"{size_bytes / (1024**3):.2f} GB"
+    elif size_bytes >= 1024**2:
+        return f"{size_bytes / (1024**2):.2f} MB"
+    elif size_bytes >= 1024:
+        return f"{size_bytes / 1024:.2f} KB"
+    else:
+        return f"{size_bytes} B"
+
+
+def format_change(change_bytes: int) -> str:
+    """Format byte change with sign."""
+    sign = "+" if change_bytes > 0 else ""
+    return f"{sign}{format_size(abs(change_bytes))}"
+
+
+def format_pct_change(pct: float) -> str:
+    """Format percentage change with sign."""
+    sign = "+" if pct > 0 else ""
+    return f"{sign}{pct:.1f}%"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compare file sizes between base and HEAD")
+    parser.add_argument("base_file", help="Base JSONL file")
+    parser.add_argument("head_file", help="HEAD JSONL file")
+    args = parser.parse_args()
+
+    # Load base and head data
+    base_data = {}
+    try:
+        with open(args.base_file) as f:
+            for line in f:
+                record = json.loads(line)
+                # Support old records without scale_factor (default to "1.0")
+                scale_factor = record.get("scale_factor", "1.0")
+                key = (record["benchmark"], scale_factor, record["format"], record["file"])
+                base_data[key] = record["size_bytes"]
+    except FileNotFoundError:
+        print("_Base file sizes not found._")
+        sys.exit(0)
+
+    head_data = {}
+    try:
+        with open(args.head_file) as f:
+            for line in f:
+                record = json.loads(line)
+                scale_factor = record.get("scale_factor", "1.0")
+                key = (record["benchmark"], scale_factor, record["format"], record["file"])
+                head_data[key] = record["size_bytes"]
+    except FileNotFoundError:
+        print("_HEAD file sizes not found._")
+        sys.exit(0)
+
+    # Compare sizes
+    comparisons = []
+    format_totals = defaultdict(lambda: {"base": 0, "head": 0})
+
+    all_keys = set(base_data.keys()) | set(head_data.keys())
+    for key in all_keys:
+        benchmark, scale_factor, fmt, file_name = key
+        base_size = base_data.get(key, 0)
+        head_size = head_data.get(key, 0)
+
+        format_totals[fmt]["base"] += base_size
+        format_totals[fmt]["head"] += head_size
+
+        change = head_size - base_size
+        if change == 0:
+            continue
+
+        if base_size > 0:
+            pct_change = (head_size / base_size - 1) * 100
+        elif head_size > 0:
+            pct_change = float("inf")
+        else:
+            pct_change = 0
+
+        comparisons.append(
+            {
+                "file": file_name,
+                "scale_factor": scale_factor,
+                "format": fmt,
+                "base_size": base_size,
+                "head_size": head_size,
+                "change": change,
+                "pct_change": pct_change,
+            }
+        )
+
+    if not comparisons:
+        print("_No file size changes detected._")
+        return
+
+    # Sort by pct_change descending (largest increases first)
+    comparisons.sort(key=lambda x: x["pct_change"], reverse=True)
+
+    # Build summary line for collapsible header
+    total_base = sum(format_totals[fmt]["base"] for fmt in format_totals)
+    total_head = sum(format_totals[fmt]["head"] for fmt in format_totals)
+    if total_base > 0:
+        overall_pct = (total_head / total_base - 1) * 100
+        overall_pct_str = format_pct_change(overall_pct)
+    else:
+        overall_pct_str = "new"
+
+    increases = sum(1 for c in comparisons if c["change"] > 0)
+    decreases = sum(1 for c in comparisons if c["change"] < 0)
+
+    # Output collapsible markdown
+    print("<details>")
+    summary = (
+        f"<summary>File Size Changes ({len(comparisons)} files changed, "
+        f"{overall_pct_str} overall, {increases}↑ {decreases}↓)</summary>"
+    )
+    print(summary)
+    print("")
+    print("<br>")
+    print("")
+
+    # Output markdown table
+    print("| File | Scale | Format | Base | HEAD | Change | % |")
+    print("|------|-------|--------|------|------|--------|---|")
+
+    for comp in comparisons:
+        pct_str = format_pct_change(comp["pct_change"]) if comp["pct_change"] != float("inf") else "new"
+        base_str = format_size(comp["base_size"]) if comp["base_size"] > 0 else "-"
+        print(
+            f"| {comp['file']} | {comp['scale_factor']} | {comp['format']} | {base_str} | "
+            f"{format_size(comp['head_size'])} | {format_change(comp['change'])} | {pct_str} |"
+        )
+
+    # Output totals
+    print("")
+    print("**Totals:**")
+    for fmt in sorted(format_totals.keys()):
+        totals = format_totals[fmt]
+        base_total = totals["base"]
+        head_total = totals["head"]
+        if base_total > 0:
+            total_pct = (head_total / base_total - 1) * 100
+            pct_str = f" ({format_pct_change(total_pct)})"
+        else:
+            pct_str = ""
+        print(f"- {fmt}: {format_size(base_total)} \u2192 {format_size(head_total)}{pct_str}")
+
+    print("")
+    print("</details>")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/pre-commit b/scripts/pre-commit
deleted file mode 100755
index 87dcb02951b..00000000000
--- a/scripts/pre-commit
+++ /dev/null
@@ -1,150 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Git Pre-Commit Hook for Vortex
-# Validates commits to ensure code formatting and REUSE compliance.
-#
-# If you want to use this hook, simply copy and paste the file into a new file
-# `.git/hooks/pre-commit` and everything should work correctly. If you are in the project root, you
-# can use these command:
-#
-# ```sh
-# cp scripts/pre-commit .git/hooks/
-# ```
-
-set -Euo pipefail
-
-# Configuration.
-MAIN_BRANCH="develop"  # The main branch name for vortex.
-
-# Color codes for terminal output.
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-BOLD='\033[1m'
-RESET='\033[0m'
-
-# Output helper functions.
-print_error() {
-    echo -e "${RED}$1${RESET}"
-}
-
-print_success() {
-    echo -e "${GREEN}$1${RESET}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}$1${RESET}"
-}
-
-print_info() {
-    echo -e "${BLUE}$1${RESET}"
-}
-
-print_header() {
-    echo -e "\n${BOLD}$1${RESET}"
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-}
-
-# Navigate to repository root to ensure consistent execution.
-ROOT_DIR="$(git rev-parse --show-toplevel)"
-cd "$ROOT_DIR"
-
-# ============================================================================
-# CHECK 1: REUSE Compliance (License Headers)
-# ============================================================================
-# Ensure all files have proper license headers as required by REUSE specification.
-# This helps maintain clear licensing information throughout the codebase.
-
-print_header "📜 Checking REUSE compliance"
-
-if ! command -v reuse &> /dev/null; then
-    print_warning "⚠️  REUSE tool not found - skipping license check."
-    echo "   Install from: https://reuse.software/"
-else
-    # Run REUSE lint check.
-    REUSE_OUTPUT=$(reuse lint 2>&1)
-    REUSE_EXIT_CODE=$?
-
-    if [ $REUSE_EXIT_CODE -eq 0 ]; then
-        print_success "✅ REUSE compliant - all files have proper license headers"
-    else
-        print_error "❌ REUSE compliance check failed"
-        echo
-        # Show first 30 lines of errors.
-        echo "$REUSE_OUTPUT" | head -30
-        if [ $(echo "$REUSE_OUTPUT" | wc -l) -gt 30 ]; then
-            echo
-            echo "... (output truncated, run 'reuse lint' for full report)"
-        fi
-        echo
-        print_warning "⚠️  To skip checks: git commit --no-verify"
-        exit 1
-    fi
-fi
-
-# ============================================================================
-# CHECK 2: Code Formatting
-# ============================================================================
-# Verify that all Rust code and TOML files follow the project's formatting standards.
-# Consistent formatting improves readability and reduces merge conflicts.
-
-print_header "🎨 Checking code formatting"
-
-if ! command -v cargo &> /dev/null; then
-    print_error "❌ Cargo not found in PATH"
-    exit 1
-fi
-
-# Check if Rust code needs formatting.
-FMT_OUTPUT=$(cargo +nightly fmt --all -- --check 2>&1)
-FMT_EXIT_CODE=$?
-
-if [ $FMT_EXIT_CODE -eq 0 ]; then
-    print_success "✅ Rust code formatting looks good"
-else
-    print_error "❌ Rust code needs formatting"
-    echo
-    echo "$FMT_OUTPUT"
-    echo
-    print_info "💡 Fix with: cargo +nightly fmt"
-    echo
-    print_warning "⚠️  To skip checks: git commit --no-verify"
-    exit 1
-fi
-
-# Check if TOML files need formatting.
-if ! command -v taplo &> /dev/null; then
-    print_warning "⚠️  taplo not found - skipping TOML formatting check."
-    echo "   Install from: https://github.com/tamasfe/taplo"
-else
-    TAPLO_OUTPUT=$(taplo fmt --check 2>&1)
-    TAPLO_EXIT_CODE=$?
-
-    if [ $TAPLO_EXIT_CODE -eq 0 ]; then
-        print_success "✅ TOML formatting looks good"
-    else
-        print_error "❌ TOML files need formatting"
-        echo
-        echo "$TAPLO_OUTPUT"
-        echo
-        print_info "💡 Fix with: taplo fmt"
-        echo
-        print_warning "⚠️  To skip checks: git commit --no-verify"
-        exit 1
-    fi
-fi
-
-# ============================================================================
-# Success
-# ============================================================================
-
-echo
-print_success "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-print_success "🎉 All pre-commit checks passed! Proceeding with push..."
-print_success "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo
-
-exit 0
diff --git a/scripts/pre-push b/scripts/pre-push
deleted file mode 100755
index 925b13cb27b..00000000000
--- a/scripts/pre-push
+++ /dev/null
@@ -1,219 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Git Pre-Push Hook for Vortex
-# Validates commits being pushed to ensure code quality and DCO (signed-off commits).
-#
-# If you want to use this hook, simply copy and paste the file into a new file `.git/hooks/pre-push`
-# and everything should work correctly. If you are in the project root, you can use these command:
-#
-# ```sh
-# cp scripts/pre-push .git/hooks/
-# ```
-
-set -Euo pipefail
-
-# Configuration.
-MAIN_BRANCH="develop"  # The main branch name for vortex.
-
-# Color codes for terminal output.
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-BOLD='\033[1m'
-RESET='\033[0m'
-
-# Output helper functions.
-print_error() {
-    echo -e "${RED}$1${RESET}"
-}
-
-print_success() {
-    echo -e "${GREEN}$1${RESET}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}$1${RESET}"
-}
-
-print_info() {
-    echo -e "${BLUE}$1${RESET}"
-}
-
-print_header() {
-    echo -e "\n${BOLD}$1${RESET}"
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-}
-
-# Navigate to repository root to ensure consistent execution.
-ROOT_DIR="$(git rev-parse --show-toplevel)"
-cd "$ROOT_DIR"
-
-# Parse stdin from git to determine what commits are being pushed.
-# Git provides information about each ref being pushed via stdin.
-SKIP=true
-COMMIT_RANGES=()
-
-print_header "🚀 Pre-push checks starting..."
-
-# Process each ref being pushed. Git provides one line per ref via stdin.
-# Each line contains the local ref, local SHA, remote ref, and remote SHA.
-while read LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA; do
-    # Check if this is an actual push (not a branch deletion).
-    if [[ "$LOCAL_REF" != "(delete)" && \
-          "$LOCAL_SHA" != "0000000000000000000000000000000000000000" ]]; then
-        SKIP=false
-
-        # Determine the range of commits to check.
-        # We only want to check new commits that aren't already on the remote.
-        if [ "$REMOTE_SHA" = "0000000000000000000000000000000000000000" ]; then
-            # This is a new branch being pushed for the first time.
-            # Check only commits since diverging from the main branch.
-            if git show-ref --verify --quiet "refs/remotes/origin/$MAIN_BRANCH"; then
-                MERGE_BASE=$(git merge-base "origin/$MAIN_BRANCH" "$LOCAL_SHA" 2>/dev/null || echo "")
-                if [ -n "$MERGE_BASE" ]; then
-                    RANGE="$MERGE_BASE..$LOCAL_SHA"
-                else
-                    # Can't find merge base, check all commits in the branch.
-                    RANGE="origin/$MAIN_BRANCH..$LOCAL_SHA"
-                fi
-            else
-                # Main branch doesn't exist remotely yet (rare case).
-                print_warning "⚠️  Remote branch 'origin/$MAIN_BRANCH' not found."
-                RANGE="$LOCAL_SHA"
-            fi
-        else
-            # This is an existing branch being updated.
-            # Only check the new commits being pushed.
-            RANGE="$REMOTE_SHA..$LOCAL_SHA"
-        fi
-
-        COMMIT_RANGES+=("$RANGE")
-
-        # Show what we're checking for transparency.
-        NUM_COMMITS=$(git rev-list --count "$RANGE" 2>/dev/null || echo "0")
-        if [ "$NUM_COMMITS" -gt 0 ]; then
-            print_info "ℹ️  Checking $NUM_COMMITS new commit(s)"
-        fi
-    fi
-done
-
-# Exit early if only deleting branches.
-if $SKIP; then
-    print_info "ℹ️  Only deleting remote branches - skipping checks."
-    exit 0
-fi
-
-# ============================================================================
-# CHECK 1: Commit Sign-offs (DCO Compliance)
-# ============================================================================
-# Verify that all commits have proper Signed-off-by trailers for DCO compliance.
-# This ensures contributors have agreed to the Developer Certificate of Origin.
-
-print_header "✍️  Checking commit sign-offs (DCO compliance)"
-
-UNSIGNED_COMMITS=()
-TOTAL_COMMITS=0
-SIGNED_COMMITS=0
-
-# Iterate through each commit range identified during the push.
-# Each range contains only the new commits that will be pushed to the remote.
-for RANGE in "${COMMIT_RANGES[@]}"; do
-    # Skip empty ranges.
-    if ! git rev-list -n1 "$RANGE" &>/dev/null; then
-        continue
-    fi
-
-    # Process each individual commit in this range to check for DCO compliance.
-    # Extract commit hash, subject, committer name, and email for validation.
-    while IFS='|' read -r COMMIT SUBJECT NAME EMAIL; do
-        TOTAL_COMMITS=$((TOTAL_COMMITS + 1))
-        COMMIT_SHORT="${COMMIT:0:7}"
-
-        # Extract commit message and trailers.
-        FULL_MESSAGE=$(git show -s --format=%B "$COMMIT")
-        TRAILERS=$(echo "$FULL_MESSAGE" | git interpret-trailers --parse)
-
-        if [ -z "$TRAILERS" ]; then
-            # No trailers found at all.
-            UNSIGNED_COMMITS+=("  ${RED}✗${RESET} ${COMMIT_SHORT} ${SUBJECT}")
-            UNSIGNED_COMMITS+=("    ${YELLOW}→ Missing Signed-off-by trailer${RESET}")
-        else
-            # Check for Signed-off-by trailer.
-            SIGNOFF=$(echo "$TRAILERS" | grep "^Signed-off-by: " || true)
-
-            if [ -z "$SIGNOFF" ]; then
-                # Has trailers but no Signed-off-by.
-                UNSIGNED_COMMITS+=("  ${RED}✗${RESET} ${COMMIT_SHORT} ${SUBJECT}")
-                UNSIGNED_COMMITS+=("    ${YELLOW}→ Has trailers but missing Signed-off-by${RESET}")
-            else
-                # Accept any valid Signed-off-by trailer.
-                SIGNED_COMMITS=$((SIGNED_COMMITS + 1))
-            fi
-        fi
-    done < <(git rev-list --format='%H|%s|%cn|%ce' --no-commit-header "$RANGE")
-done
-
-# Report DCO check results.
-if [ ${#UNSIGNED_COMMITS[@]} -gt 0 ]; then
-    print_error "\n❌ Missing sign-offs found:"
-    printf '%s\n' "${UNSIGNED_COMMITS[@]}"
-
-    echo
-    print_info "💡 Add sign-offs with: git commit --signoff or git rebase --signoff"
-    echo
-    print_warning "⚠️  To skip checks: git push --no-verify"
-    exit 1
-else
-    if [ "$TOTAL_COMMITS" -gt 0 ]; then
-        print_success "✅ All $TOTAL_COMMITS commit(s) properly signed off"
-    fi
-fi
-
-
-# ============================================================================
-# CHECK 2: Clippy Lints
-# ============================================================================
-# Run Clippy to catch common mistakes and enforce idiomatic Rust patterns.
-# This helps maintain code quality and prevents potential bugs.
-
-print_header "📝 Running Clippy linter"
-
-if ! cargo clippy --version &> /dev/null; then
-    print_warning "⚠️  Clippy not found - skipping lint check."
-    echo "   Install with: rustup component add clippy"
-else
-    # Run Clippy with warnings as errors.
-    CLIPPY_OUTPUT=$(cargo clippy --all-targets --all-features -- -D warnings 2>&1)
-    CLIPPY_EXIT_CODE=$?
-
-    if [ $CLIPPY_EXIT_CODE -eq 0 ]; then
-        print_success "✅ Clippy found no issues"
-    else
-        print_error "❌ Clippy found problems"
-        echo
-        # Show first 25 lines of errors.
-        echo "$CLIPPY_OUTPUT" | head -25
-        if [ $(echo "$CLIPPY_OUTPUT" | wc -l) -gt 25 ]; then
-            echo
-            echo "... (output truncated, run 'cargo clippy' for full output)"
-        fi
-        echo
-        print_warning "⚠️  To skip checks: git push --no-verify"
-        exit 1
-    fi
-fi
-
-# ============================================================================
-# Success
-# ============================================================================
-
-echo
-print_success "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-print_success "🎉 All pre-push checks passed! Proceeding with push..."
-print_success "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo
-
-exit 0
diff --git a/scripts/setup-benchmark.sh b/scripts/setup-benchmark.sh
new file mode 100755
index 00000000000..48536092e17
--- /dev/null
+++ b/scripts/setup-benchmark.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+set -Eeu -o pipefail -x
+
+if [ "$EUID" -ne 0 ]; then
+    echo "Environment setup script for benchmarks should run as root."
+    exit 0
+fi
+
+# Disable turbo boost so benchmark runs stay at a more stable clock rate.
+[[ -w /sys/devices/system/cpu/intel_pstate/no_turbo ]] && echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo || true
+[[ -w /sys/devices/system/cpu/cpufreq/boost ]] && echo 0 > /sys/devices/system/cpu/cpufreq/boost || true
+
+# Really discourage swapping to disk
+sysctl vm.swappiness=0
+swapoff -a || true
+
+# Might be worse if a single application uses the OS
+# https://www.intel.com/content/www/us/en/developer/articles/technical/measuring-impact-of-numa-migrations-on-performance.html
+sysctl -w kernel.numa_balancing=0
+
+# Disable ASLR - https://docs.kernel.org/admin-guide/sysctl/kernel.html#randomize-va-space
+sysctl kernel.randomize_va_space=0
+
+# This is a desktop optimization, making sure its disabled
+sysctl -w kernel.sched_autogroup_enabled=0
+
+# Reduce kernel logging to minimum
+dmesg -n 1
+
+# Disable some unused services and features
+systemctl stop apparmor ModemManager
+systemctl disable apparmor ModemManager
+
+# mask prevents them from being started by other services
+systemctl mask ModemManager
+
+# For apparmor specifically, also teardown loaded profiles
+aa-teardown
+
+# Reduce background activity (Ubuntu-specific)
+for unit in \
+  irqbalance \
+  apt-daily.service \
+  apt-daily-upgrade.service \
+  apt-daily.timer \
+  apt-daily-upgrade.timer \
+  motd-news.service \
+  motd-news.timer \
+  apport
+do
+  systemctl disable --now "$unit" 2>/dev/null
+done
+systemctl mask irqbalance 2>/dev/null
+
+CPU_COUNT="$(nproc)"
+HOUSEKEEPING_CPUS="0-1"
+BENCH_CPUS="2-$((CPU_COUNT - 1))"
+
+# Pin all IRQs to housekeeping CPUs
+for f in /proc/irq/[0-9]*/smp_affinity_list; do
+  if [[ -w "$f" ]]; then
+    # Some IRQs are kernel-managed and reject writes with EPERM even as root.
+    echo "$HOUSEKEEPING_CPUS" > "$f" 2>/dev/null || true
+  fi
+done
+
+# Persist CPU affinity ranges for non-root benchmark steps in CI.
+cat > /tmp/vortex-benchmark.env <<EOF
+HOUSEKEEPING_CPUS=$HOUSEKEEPING_CPUS
+BENCH_CPUS=$BENCH_CPUS
+EOF
+chmod 0644 /tmp/vortex-benchmark.env
diff --git a/uv.lock b/uv.lock
index afd6afb2b5c..c5ec5b0d865 100644
--- a/uv.lock
+++ b/uv.lock
@@ -131,7 +131,8 @@ name = "breathe"
 version = "4.36.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/01/56/99bf7d0799d95ad485d95596dc01c2a5b3dda58ebf50a94f6f73b33bacdf/breathe-4.36.0.tar.gz", hash = "sha256:14860b73118ac140b7a3f55446890c777d1b67149cb024279fe3710dad7f535c", size = 154842, upload-time = "2025-02-22T18:36:03.36Z" }
 wheels = [
@@ -241,7 +242,8 @@ dependencies = [
     { name = "myst-parser" },
     { name = "pydata-sphinx-theme" },
     { name = "setuptools" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
     { name = "sphinx-autobuild" },
     { name = "sphinx-copybutton" },
     { name = "sphinx-design" },
@@ -261,7 +263,7 @@ requires-dist = [
     { name = "myst-parser", specifier = ">=4.0.0" },
     { name = "pydata-sphinx-theme", specifier = ">=0.16.0" },
     { name = "setuptools", specifier = ">=75.8.0" },
-    { name = "sphinx", specifier = ">=8.0.2" },
+    { name = "sphinx", specifier = ">=9.0.0" },
     { name = "sphinx-autobuild", specifier = ">=2024.10.3" },
     { name = "sphinx-copybutton", specifier = ">=0.5.2" },
     { name = "sphinx-design", specifier = ">=0.6.0" },
@@ -349,7 +351,8 @@ name = "hawkmoth"
 version = "0.21.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/11/19/bc186706b15923d02c75d5113443190ffc2be44d60903b8d5ff2813a7958/hawkmoth-0.21.0.tar.gz", hash = "sha256:da338218411fdc67b52254f02dbdec162ed4a7db588de7d3a1e5314864fce5cd", size = 25958, upload-time = "2025-05-10T12:35:22.053Z" }
 wheels = [
@@ -496,14 +499,14 @@ wheels = [
 
 [[package]]
 name = "markdown-it-py"
-version = "3.0.0"
+version = "4.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mdurl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
 ]
 
 [[package]]
@@ -689,7 +692,7 @@ wheels = [
 
 [[package]]
 name = "myst-parser"
-version = "4.0.1"
+version = "5.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docutils" },
@@ -697,11 +700,12 @@ dependencies = [
     { name = "markdown-it-py" },
     { name = "mdit-py-plugins" },
     { name = "pyyaml" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/fa/7b45eef11b7971f0beb29d27b7bfe0d747d063aa29e170d9edd004733c8a/myst_parser-5.0.0.tar.gz", hash = "sha256:f6f231452c56e8baa662cc352c548158f6a16fcbd6e3800fc594978002b94f3a", size = 98535, upload-time = "2026-01-15T09:08:18.036Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ac/686789b9145413f1a61878c407210e41bfdb097976864e0913078b24098c/myst_parser-5.0.0-py3-none-any.whl", hash = "sha256:ab31e516024918296e169139072b81592336f2fef55b8986aa31c9f04b5f7211", size = 84533, upload-time = "2026-01-15T09:08:16.788Z" },
 ]
 
 [[package]]
@@ -1118,7 +1122,8 @@ dependencies = [
     { name = "beautifulsoup4" },
     { name = "docutils" },
     { name = "pygments" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
     { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/00/20/bb50f9de3a6de69e6abd6b087b52fa2418a0418b19597601605f855ad044/pydata_sphinx_theme-0.16.1.tar.gz", hash = "sha256:a08b7f0b7f70387219dc659bff0893a7554d5eb39b59d3b8ef37b8401b7642d7", size = 2412693, upload-time = "2024-12-17T10:53:39.537Z" }
@@ -1255,7 +1260,7 @@ wheels = [
 
 [[package]]
 name = "ray"
-version = "2.53.0"
+version = "2.54.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -1268,17 +1273,17 @@ dependencies = [
     { name = "requests" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/64/d5c29a4b014d8b9a624203a88b67630072c1d6960425dbf7a1f0fa5d6b74/ray-2.53.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:bd3ec4c342776ddac23ae2b108c64f5939f417ccc4875900d586c7c978463269", size = 69479296, upload-time = "2025-12-20T16:06:05.111Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/41/9e19d1e5d9458a5ba157c36642e2874bcb22fddbd7c1e77b668e5afc3f3d/ray-2.53.0-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:a0bbb98b0b0f25a3ee075ca10171e1260e70b6bc690cd509ecd7ce1228af854d", size = 71463449, upload-time = "2025-12-20T16:06:10.983Z" },
-    { url = "https://files.pythonhosted.org/packages/63/de/58c19906b0dd16ea06b4f2465b7327f5f180e6b6e1c8c9b610d7c589ea5f/ray-2.53.0-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:eb000c17f7301071fdd15c44c4cd3ac0f7953bb4c7c227e61719fe7048195bcd", size = 72305102, upload-time = "2025-12-20T16:06:17.989Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/43/72cc1cfe17d26abe62a793eab10445f9546dce24192b85a6cd0cdc47ed86/ray-2.53.0-cp311-cp311-win_amd64.whl", hash = "sha256:4a1bb3fe09ab4cd0d16ddc96b9f60c9ed83b3f93b87aa8506e0d3b746fd4e825", size = 27194174, upload-time = "2025-12-20T16:06:23.042Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/44/562718a634e63e8ef7985285288a167d4af62bc2a7decce3300cf937776a/ray-2.53.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:d8b95d047d947493803fb8417aea31225dcacdab15afdc75b8a238901949d457", size = 69463763, upload-time = "2025-12-20T16:06:28.685Z" },
-    { url = "https://files.pythonhosted.org/packages/38/68/8e59b8413f3751fe7ce8b98ee8787d13964b47a4043587950790a9dd2151/ray-2.53.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:65e2ce58d3dc6baa3cf45824d889c1968ebde565ee54dfd80a98af8f31af8e4a", size = 71504450, upload-time = "2025-12-20T16:06:34.922Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/db/978a50d264565ca42e2a4bf115ec9a1f04f19ca5e620e6aa2f280747b644/ray-2.53.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:14f46363e9b4cf0c1c8b4d8623ec337c5bd408377831b5e5b50067930137bbca", size = 72370424, upload-time = "2025-12-20T16:06:40.821Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/6c/bba6f22a9d83ee8f236000ba315f0c197bdc79888b4fa42fd762f729cbbd/ray-2.53.0-cp312-cp312-win_amd64.whl", hash = "sha256:b828c147f9ff2f277b1d254e4fe9a746fdfaee7e313a93a97c7edf4dae9b81a4", size = 27178106, upload-time = "2025-12-20T16:06:45.594Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/38/450cf9cf3c490fa4cc6d470597f819444da60f85579d2b34b95ee79fcb6f/ray-2.53.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:85b472ab6fb8f1189f8cef81913fd91b24dd69b3fa7dcca7e144827bd924f6c0", size = 69409819, upload-time = "2025-12-20T16:06:50.668Z" },
-    { url = "https://files.pythonhosted.org/packages/71/5e/d452970b07174d5e4f8688abae889d01321b51ced827db1f1d1cb7d56d44/ray-2.53.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:7196e5358dfcc8211be864f45e6dfe4827202df294af3c7a76ff8fbc080e0522", size = 71409529, upload-time = "2025-12-20T16:06:56.2Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/84/50b317a125617a638a64694c12f56183edd5df01828a35fa4c55c7b13c66/ray-2.53.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:73dbbaa7962a7f5e38aa8cf9483e0e9817205e989aa3dc859c738c2af1ae01df", size = 72283961, upload-time = "2025-12-20T16:07:05.831Z" },
+    { url = "https://files.pythonhosted.org/packages/08/58/6209b2231947f3c8df09ce1436f1c76c4a11fcafd57c8def852dcbb6d8ef/ray-2.54.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:8e39dd56b47a0a1820d5a5a54385bbe54d1d67e1093736d12d8ed4e99d0fa455", size = 70098998, upload-time = "2026-02-18T04:04:58.801Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/29/7871f4206e6b00a9bb784c16dad32ccd01e9df5a93545db92de220eb2871/ray-2.54.0-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:491ae56ab80d8822c4eaf4d5bb96dcf32a6231d8d7b76eb8034400eb9be1bb18", size = 72066630, upload-time = "2026-02-18T04:05:04.957Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/e8/d2c8ebd9cd945abc817b01ad02a29df78cdb86cd07d764587e16977389d0/ray-2.54.0-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:928bb09245a3c6f7c3c113ba8eafc69f948da9602d7f33e8251ecdf97c157615", size = 72895723, upload-time = "2026-02-18T04:05:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/96/a5ea3a149a943475cda1d68fdcdb14c86251826c652c232ae853600ad7e7/ray-2.54.0-cp311-cp311-win_amd64.whl", hash = "sha256:1e786330de55b3ba2228e36ec305381a9b86f0b01a8b6072c5811c3bc4dd9a3d", size = 27448371, upload-time = "2026-02-18T04:05:16.34Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/16/45eefb51eb1767342a6dbf41af0b432279e422e56160705fcd1098a7ec53/ray-2.54.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:cf5c33b4b13850ec24a5bd5f9d9e0a8161f8e586bfd297e52913d170dec447fe", size = 70084880, upload-time = "2026-02-18T04:05:22.007Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ad/e07aca3637e9c3ec4857ec4366208099cf8488ece8061a9925ba29b66382/ray-2.54.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:795ae21d6b764245d3f521bc5833446d58569e7dfde9c5777417eb285d87450f", size = 72107346, upload-time = "2026-02-18T04:05:27.999Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b9/cc5ea8460c3dc602e6b7198277a7c59ba2b8929374ab22efa8df9f3deac8/ray-2.54.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:a972afd5aa3dda99d0b2f369b5f62e5dd95865ab7d37bf2e0a0e0d2cfbd9b325", size = 72967230, upload-time = "2026-02-18T04:05:33.771Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d7/744de3b1bb881701330ddcbb2f6efaccd65915d564ece899a3838f9fb105/ray-2.54.0-cp312-cp312-win_amd64.whl", hash = "sha256:2ee074ede491d0aacfa339c003f5d7a15826e1e2a72ce873234ccbc0446e19b3", size = 27427353, upload-time = "2026-02-18T04:05:38.853Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f2/5c0161d10445e703b7d01413ab54ec1cc5e27032555279d296df89b9c4ee/ray-2.54.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5ad77961fea16c697a0fb0e51216dd39c0bec28868cde54ac668edd58d12b8ae", size = 70030991, upload-time = "2026-02-18T04:05:43.966Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/8c/4a4a38eaec6e9614076a96967f58540f4f8d4aa0c793f43150c5df23cb9a/ray-2.54.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:8952c23a8aa94f10728c2d16e0dc3732d09aa0e6254801757ff494984a214f45", size = 72013826, upload-time = "2026-02-18T04:05:49.866Z" },
+    { url = "https://files.pythonhosted.org/packages/42/ac/e7ec2a406bd755f61c7090460fa5ab3f09b00c3c2d8db6d0b559f78a30eb/ray-2.54.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:ab89e6089abb6e46fb98fdd96d399b31a852d79127cd8ac00746c61d93defa2c", size = 72880209, upload-time = "2026-02-18T04:05:55.498Z" },
 ]
 
 [[package]]
@@ -1324,12 +1329,12 @@ wheels = [
 ]
 
 [[package]]
-name = "roman-numerals-py"
-version = "3.1.0"
+name = "roman-numerals"
+version = "4.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/30/76/48fd56d17c5bdbdf65609abbc67288728a98ed4c02919428d4f52d23b24b/roman_numerals_py-3.1.0.tar.gz", hash = "sha256:be4bf804f083a4ce001b5eb7e3c0862479d10f94c936f6c4e5f250aa5ff5bd2d", size = 9017, upload-time = "2025-02-22T07:34:54.333Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/97/d2cbbaa10c9b826af0e10fdf836e1bf344d9f0abb873ebc34d1f49642d3f/roman_numerals_py-3.1.0-py3-none-any.whl", hash = "sha256:9da2ad2fb670bcf24e81070ceb3be72f6c11c440d73bd579fbeca1e9f330954c", size = 7742, upload-time = "2025-02-22T07:34:52.422Z" },
+    { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" },
 ]
 
 [[package]]
@@ -1522,30 +1527,64 @@ wheels = [
 
 [[package]]
 name = "sphinx"
-version = "8.2.3"
+version = "9.0.4"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.12'",
+]
 dependencies = [
-    { name = "alabaster" },
-    { name = "babel" },
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "docutils" },
-    { name = "imagesize" },
-    { name = "jinja2" },
-    { name = "packaging" },
-    { name = "pygments" },
-    { name = "requests" },
-    { name = "roman-numerals-py" },
-    { name = "snowballstemmer" },
-    { name = "sphinxcontrib-applehelp" },
-    { name = "sphinxcontrib-devhelp" },
-    { name = "sphinxcontrib-htmlhelp" },
-    { name = "sphinxcontrib-jsmath" },
-    { name = "sphinxcontrib-qthelp" },
-    { name = "sphinxcontrib-serializinghtml" },
+    { name = "alabaster", marker = "python_full_version < '3.12'" },
+    { name = "babel", marker = "python_full_version < '3.12'" },
+    { name = "colorama", marker = "python_full_version < '3.12' and sys_platform == 'win32'" },
+    { name = "docutils", marker = "python_full_version < '3.12'" },
+    { name = "imagesize", marker = "python_full_version < '3.12'" },
+    { name = "jinja2", marker = "python_full_version < '3.12'" },
+    { name = "packaging", marker = "python_full_version < '3.12'" },
+    { name = "pygments", marker = "python_full_version < '3.12'" },
+    { name = "requests", marker = "python_full_version < '3.12'" },
+    { name = "roman-numerals", marker = "python_full_version < '3.12'" },
+    { name = "snowballstemmer", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-applehelp", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-devhelp", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-htmlhelp", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-qthelp", marker = "python_full_version < '3.12'" },
+    { name = "sphinxcontrib-serializinghtml", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/50/a8c6ccc36d5eacdfd7913ddccd15a9cee03ecafc5ee2bc40e1f168d85022/sphinx-9.0.4.tar.gz", hash = "sha256:594ef59d042972abbc581d8baa577404abe4e6c3b04ef61bd7fc2acbd51f3fa3", size = 8710502, upload-time = "2025-12-04T07:45:27.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/3f/4bbd76424c393caead2e1eb89777f575dee5c8653e2d4b6afd7a564f5974/sphinx-9.0.4-py3-none-any.whl", hash = "sha256:5bebc595a5e943ea248b99c13814c1c5e10b3ece718976824ffa7959ff95fffb", size = 3917713, upload-time = "2025-12-04T07:45:24.944Z" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" },
+
+[[package]]
+name = "sphinx"
+version = "9.1.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12'",
+]
+dependencies = [
+    { name = "alabaster", marker = "python_full_version >= '3.12'" },
+    { name = "babel", marker = "python_full_version >= '3.12'" },
+    { name = "colorama", marker = "python_full_version >= '3.12' and sys_platform == 'win32'" },
+    { name = "docutils", marker = "python_full_version >= '3.12'" },
+    { name = "imagesize", marker = "python_full_version >= '3.12'" },
+    { name = "jinja2", marker = "python_full_version >= '3.12'" },
+    { name = "packaging", marker = "python_full_version >= '3.12'" },
+    { name = "pygments", marker = "python_full_version >= '3.12'" },
+    { name = "requests", marker = "python_full_version >= '3.12'" },
+    { name = "roman-numerals", marker = "python_full_version >= '3.12'" },
+    { name = "snowballstemmer", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-applehelp", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-devhelp", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-htmlhelp", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-qthelp", marker = "python_full_version >= '3.12'" },
+    { name = "sphinxcontrib-serializinghtml", marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/f7/b1884cb3188ab181fc81fa00c266699dab600f927a964df02ec3d5d1916a/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978", size = 3921742, upload-time = "2025-12-31T15:09:25.561Z" },
 ]
 
 [[package]]
@@ -1554,7 +1593,8 @@ version = "2025.8.25"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
     { name = "starlette" },
     { name = "uvicorn" },
     { name = "watchfiles" },
@@ -1570,7 +1610,8 @@ name = "sphinx-copybutton"
 version = "0.5.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fc/2b/a964715e7f5295f77509e59309959f4125122d648f86b4fe7d70ca1d882c/sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd", size = 23039, upload-time = "2023-04-14T08:10:22.998Z" }
 wheels = [
@@ -1582,7 +1623,8 @@ name = "sphinx-design"
 version = "0.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/13/7b/804f311da4663a4aecc6cf7abd83443f3d4ded970826d0c958edc77d4527/sphinx_design-0.7.0.tar.gz", hash = "sha256:d2a3f5b19c24b916adb52f97c5f00efab4009ca337812001109084a740ec9b7a", size = 2203582, upload-time = "2026-01-19T13:12:53.297Z" }
 wheels = [
@@ -1594,7 +1636,8 @@ name = "sphinx-inline-tabs"
 version = "2023.4.21"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/48/f5/f8a2be63ed7be9f91a4c2bea0e25bcb56aa4c5cc37ec4d8ead8065f926b1/sphinx_inline_tabs-2023.4.21.tar.gz", hash = "sha256:5df2f13f602c158f3f5f6c509e008aeada199a8c76d97ba3aa2822206683bebc", size = 42664, upload-time = "2023-04-21T20:25:30.578Z" }
 wheels = [
@@ -1618,7 +1661,8 @@ dependencies = [
     { name = "docutils" },
     { name = "pybtex" },
     { name = "pybtex-docutils" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/de/83/1488c9879f2fa3c2cbd6f666c7a3a42a1fa9e08462bec73281fa6c092cba/sphinxcontrib_bibtex-2.6.5.tar.gz", hash = "sha256:9b3224dd6fece9268ebd8c905dc0a83ff2f6c54148a9235fe70e9d1e9ff149c0", size = 118462, upload-time = "2025-06-27T10:40:14.061Z" }
 wheels = [
@@ -1659,7 +1703,8 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jinja2" },
     { name = "pyyaml" },
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/96/a5/65a5c439cc14ba80483b9891e9350f11efb80cd3bdccb222f0c738068c78/sphinxcontrib_mermaid-2.0.0.tar.gz", hash = "sha256:cf4f7d453d001132eaba5d1fdf53d42049f02e913213cf8337427483bfca26f4", size = 18194, upload-time = "2026-01-13T17:13:42.563Z" }
 wheels = [
@@ -1689,7 +1734,8 @@ name = "sphinxext-opengraph"
 version = "0.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "sphinx" },
+    { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f6/c0/eb6838e3bae624ce6c8b90b245d17e84252863150e95efdb88f92c8aa3fb/sphinxext_opengraph-0.13.0.tar.gz", hash = "sha256:103335d08567ad8468faf1425f575e3b698e9621f9323949a6c8b96d9793e80b", size = 1026875, upload-time = "2025-08-29T12:20:31.066Z" }
 wheels = [
@@ -1858,13 +1904,18 @@ ray = [
 
 [package.dev-dependencies]
 dev = [
-    { name = "basedpyright" },
+    { name = "duckdb" },
+    { name = "maturin" },
     { name = "numpy" },
+    { name = "pandas", extra = ["output-formatting"] },
     { name = "pandas-stubs" },
     { name = "pcodec" },
+    { name = "polars" },
+    { name = "protobuf" },
     { name = "pyarrow-stubs" },
     { name = "pytest-benchmark" },
     { name = "pytest-xdist" },
+    { name = "ray" },
 ]
 
 [package.metadata]
@@ -1875,20 +1926,25 @@ requires-dist = [
     { name = "polars", marker = "extra == 'polars'", specifier = ">=1.31.0" },
     { name = "pyarrow", specifier = ">=17.0.0" },
     { name = "ray", marker = "extra == 'ray'", specifier = ">=2.48" },
-    { name = "substrait", specifier = ">=0.23.0" },
+    { name = "substrait", specifier = ">=0.23.0,<0.29.0" },
     { name = "typing-extensions", specifier = ">=4.5.0" },
 ]
 provides-extras = ["duckdb", "numpy", "pandas", "polars", "ray"]
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "basedpyright", specifier = ">=1.31" },
+    { name = "duckdb", specifier = ">=1.1.2" },
+    { name = "maturin", specifier = ">=1.7.2" },
     { name = "numpy", specifier = ">=2.2.2" },
+    { name = "pandas", extras = ["output-formatting"], specifier = ">=2.2.3" },
     { name = "pandas-stubs", specifier = ">=2.2.3.241126" },
     { name = "pcodec", specifier = ">=0.3.3" },
+    { name = "polars", specifier = ">=1.9.0" },
+    { name = "protobuf", specifier = ">=6.33.5" },
     { name = "pyarrow-stubs", specifier = ">=17.16" },
     { name = "pytest-benchmark", specifier = ">=5.1.0" },
     { name = "pytest-xdist", specifier = ">=3.5.0" },
+    { name = "ray", specifier = ">=2.48" },
 ]
 
 [[package]]
@@ -2039,20 +2095,10 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "basedpyright" },
-    { name = "duckdb" },
     { name = "filelock" },
     { name = "ipython" },
-    { name = "maturin" },
-    { name = "pandas", extra = ["output-formatting"] },
-    { name = "pandas-stubs" },
-    { name = "pcodec" },
     { name = "pip" },
-    { name = "polars" },
-    { name = "protobuf" },
-    { name = "pyarrow-stubs" },
     { name = "pytest" },
-    { name = "pytest-benchmark" },
-    { name = "ray" },
     { name = "ruff" },
     { name = "urllib3" },
 ]
@@ -2067,21 +2113,10 @@ requires-dist = [
 [package.metadata.requires-dev]
 dev = [
     { name = "basedpyright", specifier = ">=1.31" },
-    { name = "duckdb", specifier = ">=1.1.2" },
     { name = "filelock", specifier = ">=3.20.3" },
     { name = "ipython", specifier = ">=8.26.0" },
-    { name = "maturin", specifier = ">=1.7.2" },
-    { name = "pandas", extras = ["output-formatting"], specifier = ">=2.2.3" },
-    { name = "pandas-stubs", specifier = ">=2.2.3.241126" },
-    { name = "pcodec", specifier = ">=0.3.3" },
     { name = "pip", specifier = ">=23.3.2" },
-    { name = "polars", specifier = ">=1.9.0" },
-    { name = "protobuf", specifier = ">=6.33.5" },
-    { name = "pyarrow-stubs", specifier = ">=17.16" },
     { name = "pytest", specifier = ">=7.4.0" },
-    { name = "pytest-benchmark", specifier = ">=4.0.0" },
-    { name = "pytest-benchmark", specifier = ">=5.1.0" },
-    { name = "ray", specifier = ">=2.48" },
     { name = "ruff", specifier = ">=0.7.1" },
     { name = "urllib3", specifier = ">=2.6.3" },
 ]
diff --git a/vortex-test/e2e/Cargo.toml b/vortex-array-macros/Cargo.toml
similarity index 53%
rename from vortex-test/e2e/Cargo.toml
rename to vortex-array-macros/Cargo.toml
index e0a914a19a2..3d5ac1d60d8 100644
--- a/vortex-test/e2e/Cargo.toml
+++ b/vortex-array-macros/Cargo.toml
@@ -1,13 +1,14 @@
 [package]
-name = "vortex-test-e2e"
+name = "vortex-array-macros"
 authors = { workspace = true }
-description = "End-to-end tests for Vortex"
+categories = { workspace = true }
+description = "Proc macros for slot-oriented Vortex array helpers"
 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 }
 version = { workspace = true }
@@ -15,10 +16,10 @@ version = { workspace = true }
 [lints]
 workspace = true
 
-[features]
-unstable_encodings = ["vortex/unstable_encodings"]
+[lib]
+proc-macro = true
 
 [dependencies]
-futures = { workspace = true }
-tokio = { workspace = true, features = ["rt", "macros"] }
-vortex = { workspace = true, features = ["files", "tokio"] }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { workspace = true }
diff --git a/vortex-array-macros/src/lib.rs b/vortex-array-macros/src/lib.rs
new file mode 100644
index 00000000000..7828a4ec5a6
--- /dev/null
+++ b/vortex-array-macros/src/lib.rs
@@ -0,0 +1,446 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Proc macros for `vortex-array`.
+
+use proc_macro::TokenStream;
+use quote::format_ident;
+use quote::quote;
+use syn::Field;
+use syn::Fields;
+use syn::Ident;
+use syn::ItemStruct;
+use syn::Path;
+use syn::Type;
+use syn::Visibility;
+use syn::parse_macro_input;
+use syn::spanned::Spanned;
+
+/// Generate slot index constants, a borrowed view struct, and a typed ext trait
+/// from a slot struct definition.
+///
+/// Fields must be `ArrayRef` (required slot) or `Option<ArrayRef>` (optional slot).
+/// Field declaration order determines slot indices.
+///
+/// # Example
+///
+/// ```ignore
+/// #[array_slots(Patched)]
+/// pub struct PatchedSlots {
+///     pub inner: ArrayRef,
+///     pub lane_offsets: ArrayRef,
+///     pub patch_indices: ArrayRef,
+///     pub patch_values: ArrayRef,
+/// }
+/// ```
+///
+/// # Generated output
+///
+/// Given the above, the macro generates:
+///
+/// ```ignore
+/// // --- The original struct is preserved as-is ---
+/// pub struct PatchedSlots { ... }
+///
+/// // --- Slot index constants and conversion methods on the struct ---
+/// impl PatchedSlots {
+///     pub const INNER: usize = 0;
+///     pub const LANE_OFFSETS: usize = 1;
+///     pub const PATCH_INDICES: usize = 2;
+///     pub const PATCH_VALUES: usize = 3;
+///     pub const COUNT: usize = 4;
+///     pub const NAMES: [&'static str; 4] = ["inner", "lane_offsets", "patch_indices", "patch_values"];
+///
+///     /// Take ownership of slots from a `Vec<Option<ArrayRef>>`.
+///     pub fn from_slots(slots: Vec<Option<ArrayRef>>) -> Self { ... }
+///
+///     /// Convert back into storage order.
+///     pub fn into_slots(self) -> Vec<Option<ArrayRef>> { ... }
+/// }
+///
+/// // --- Borrowed view with &ArrayRef / Option<&ArrayRef> fields ---
+/// pub struct PatchedSlotsView<'a> {
+///     pub inner: &'a ArrayRef,
+///     pub lane_offsets: &'a ArrayRef,
+///     pub patch_indices: &'a ArrayRef,
+///     pub patch_values: &'a ArrayRef,
+/// }
+///
+/// impl<'a> PatchedSlotsView<'a> {
+///     pub fn from_slots(slots: &'a [Option<ArrayRef>]) -> Self { ... }
+///     pub fn to_owned(&self) -> PatchedSlots { ... }
+/// }
+///
+/// // --- Ext trait with per-field accessors + slots_view() ---
+/// pub trait PatchedArraySlotsExt: TypedArrayRef<Patched> {
+///     fn inner(&self) -> &ArrayRef { ... }         // indexes slots directly
+///     fn lane_offsets(&self) -> &ArrayRef { ... }
+///     fn patch_indices(&self) -> &ArrayRef { ... }
+///     fn patch_values(&self) -> &ArrayRef { ... }
+///     fn slots_view(&self) -> PatchedSlotsView<'_> { ... }
+/// }
+///
+/// impl<T: TypedArrayRef<Patched>> PatchedArraySlotsExt for T {}
+/// ```
+///
+/// # Required vs optional slots
+///
+/// - `ArrayRef` — the slot must be present. `from_slots()` panics if `None`.
+///   The ext trait accessor returns `&ArrayRef`. The view field is `&'a ArrayRef`.
+///
+/// - `Option<ArrayRef>` — the slot may be absent. `from_slots()` preserves `None`.
+///   The ext trait accessor returns `Option<&ArrayRef>`. The view field is
+///   `Option<&'a ArrayRef>`.
+///
+/// The underlying storage is always `Vec<Option<ArrayRef>>` — the field type only
+/// controls whether the macro inserts a `.vortex_expect()` unwrap or not.
+#[proc_macro_attribute]
+pub fn array_slots(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let encoding = parse_macro_input!(attr as Path);
+    let item_struct = parse_macro_input!(item as ItemStruct);
+
+    match expand_array_slots(encoding, item_struct) {
+        Ok(tokens) => tokens.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+fn expand_array_slots(
+    encoding: Path,
+    item_struct: ItemStruct,
+) -> syn::Result<proc_macro2::TokenStream> {
+    if !item_struct.generics.params.is_empty() || item_struct.generics.where_clause.is_some() {
+        return Err(syn::Error::new(
+            item_struct.generics.span(),
+            "#[array_slots] does not support generic slot structs",
+        ));
+    }
+
+    let fields = match &item_struct.fields {
+        Fields::Named(fields) => &fields.named,
+        _ => {
+            return Err(syn::Error::new(
+                item_struct.span(),
+                "#[array_slots] requires a struct with named fields",
+            ));
+        }
+    };
+
+    let encoding_ident = encoding
+        .segments
+        .last()
+        .map(|segment| &segment.ident)
+        .ok_or_else(|| syn::Error::new(encoding.span(), "missing encoding type"))?;
+
+    let struct_ident = &item_struct.ident;
+    let struct_vis = &item_struct.vis;
+    let view_ident = format_ident!("{}View", ident_name(struct_ident));
+    let ext_ident = format_ident!("{}ArraySlotsExt", ident_name(encoding_ident));
+
+    let field_specs = fields
+        .iter()
+        .enumerate()
+        .map(|(index, field)| SlotField::new(field, index, struct_ident))
+        .collect::<syn::Result<Vec<_>>>()?;
+
+    let idx_consts = field_specs.iter().map(SlotField::idx_const);
+    let view_fields = field_specs.iter().map(SlotField::view_field);
+    let view_from_slots = field_specs.iter().map(SlotField::view_from_slots);
+    let view_to_owned = field_specs.iter().map(SlotField::view_to_owned);
+    let owned_from_slots = field_specs.iter().map(SlotField::owned_from_slots);
+    let into_slots = field_specs.iter().map(SlotField::storage_slot);
+    let ext_methods = field_specs.iter().map(SlotField::ext_method);
+    let slot_names = field_specs.iter().map(|field| field.slot_name.as_str());
+    let slot_count = field_specs.len();
+
+    Ok(quote! {
+        #item_struct
+
+        impl #struct_ident {
+            #(#idx_consts)*
+
+            #[doc = "Total number of slots."]
+            pub const COUNT: usize = #slot_count;
+
+            #[doc = "Slot names in storage order."]
+            pub const NAMES: [&'static str; #slot_count] = [#(#slot_names),*];
+
+            #[doc = "Convert owned slot storage into an owned slot struct."]
+            pub fn from_slots(mut slots: Vec<Option<::vortex_array::ArrayRef>>) -> Self {
+                Self {
+                    #(#owned_from_slots,)*
+                }
+            }
+
+            #[doc = "Convert this slot struct into storage order."]
+            pub fn into_slots(self) -> Vec<Option<::vortex_array::ArrayRef>> {
+                vec![#(#into_slots),*]
+            }
+        }
+
+        #[derive(Clone, Copy, Debug)]
+        #[doc = concat!("Borrowed view of `", stringify!(#struct_ident), "`.")]
+        #struct_vis struct #view_ident<'a> {
+            #(#view_fields,)*
+        }
+
+        impl<'a> #view_ident<'a> {
+            #[doc = "Borrow a slot slice as a typed view."]
+            pub fn from_slots(slots: &'a [Option<::vortex_array::ArrayRef>]) -> Self {
+                Self {
+                    #(#view_from_slots,)*
+                }
+            }
+
+            #[doc = "Clone all referenced slots into an owned slot struct."]
+            pub fn to_owned(&self) -> #struct_ident {
+                #struct_ident {
+                    #(#view_to_owned,)*
+                }
+            }
+        }
+
+        #[doc = concat!("Typed array accessors for `", stringify!(#encoding_ident), "`.")]
+        #struct_vis trait #ext_ident: ::vortex_array::TypedArrayRef<#encoding> {
+            #(#ext_methods)*
+
+            #[doc = "Returns a borrowed view of all slots."]
+            fn slots_view(&self) -> #view_ident<'_> {
+                #view_ident::from_slots(self.as_ref().slots())
+            }
+        }
+
+        impl<T: ::vortex_array::TypedArrayRef<#encoding>> #ext_ident for T {}
+    })
+}
+
+struct SlotField {
+    field_ident: Ident,
+    field_vis: Visibility,
+    const_ident: Ident,
+    slot_name: String,
+    slot_type: SlotFieldType,
+    index: usize,
+    expect_message: syn::LitStr,
+    struct_ident: Ident,
+}
+
+impl SlotField {
+    fn new(field: &Field, index: usize, struct_ident: &Ident) -> syn::Result<Self> {
+        let field_ident = field
+            .ident
+            .clone()
+            .ok_or_else(|| syn::Error::new(field.span(), "slot fields must be named"))?;
+        let field_name = ident_name(&field_ident);
+        let const_ident = format_ident!("{}", to_screaming_snake_case(&field_name));
+        let slot_type = SlotFieldType::from_syn_type(&field.ty)?;
+        let expect_message = syn::LitStr::new(
+            &format!("{} {} slot", ident_name(struct_ident), field_name),
+            field.span(),
+        );
+
+        Ok(Self {
+            field_ident,
+            field_vis: field.vis.clone(),
+            const_ident,
+            slot_name: field_name,
+            slot_type,
+            index,
+            expect_message,
+            struct_ident: struct_ident.clone(),
+        })
+    }
+
+    fn idx_const(&self) -> proc_macro2::TokenStream {
+        let const_ident = &self.const_ident;
+        let index = self.index;
+        let slot_name = &self.slot_name;
+
+        quote! {
+            #[doc = concat!("Slot index for `", #slot_name, "`.")]
+            pub const #const_ident: usize = #index;
+        }
+    }
+
+    fn view_field(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+        let field_vis = &self.field_vis;
+        let ty = self.slot_type.view_field_ty();
+
+        quote! {
+            #field_vis #field_ident: #ty
+        }
+    }
+
+    fn view_from_slots(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+        let struct_ident = &self.struct_ident;
+        let const_ident = &self.const_ident;
+        let expect_message = &self.expect_message;
+
+        match self.slot_type {
+            SlotFieldType::Required => quote! {
+                #field_ident: ::vortex_error::VortexExpect::vortex_expect(
+                    slots[#struct_ident::#const_ident].as_ref(),
+                    #expect_message,
+                )
+            },
+            SlotFieldType::Optional => quote! {
+                #field_ident: slots[#struct_ident::#const_ident].as_ref()
+            },
+        }
+    }
+
+    fn view_to_owned(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+
+        match self.slot_type {
+            SlotFieldType::Required => quote! {
+                #field_ident: ::std::clone::Clone::clone(self.#field_ident)
+            },
+            SlotFieldType::Optional => quote! {
+                #field_ident: self.#field_ident.cloned()
+            },
+        }
+    }
+
+    fn owned_from_slots(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+        let struct_ident = &self.struct_ident;
+        let const_ident = &self.const_ident;
+        let expect_message = &self.expect_message;
+
+        match self.slot_type {
+            SlotFieldType::Required => quote! {
+                #field_ident: ::vortex_error::VortexExpect::vortex_expect(
+                    slots[#struct_ident::#const_ident].take(),
+                    #expect_message,
+                )
+            },
+            SlotFieldType::Optional => quote! {
+                #field_ident: slots[#struct_ident::#const_ident].take()
+            },
+        }
+    }
+
+    fn storage_slot(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+
+        match self.slot_type {
+            SlotFieldType::Required => quote! {
+                Some(self.#field_ident)
+            },
+            SlotFieldType::Optional => quote! {
+                self.#field_ident
+            },
+        }
+    }
+
+    fn ext_method(&self) -> proc_macro2::TokenStream {
+        let field_ident = &self.field_ident;
+        let struct_ident = &self.struct_ident;
+        let const_ident = &self.const_ident;
+        let expect_message = &self.expect_message;
+
+        match self.slot_type {
+            SlotFieldType::Required => quote! {
+                #[inline]
+                fn #field_ident(&self) -> &::vortex_array::ArrayRef {
+                    ::vortex_error::VortexExpect::vortex_expect(
+                        self.as_ref().slots()[#struct_ident::#const_ident].as_ref(),
+                        #expect_message,
+                    )
+                }
+            },
+            SlotFieldType::Optional => quote! {
+                #[inline]
+                fn #field_ident(&self) -> Option<&::vortex_array::ArrayRef> {
+                    self.as_ref().slots()[#struct_ident::#const_ident].as_ref()
+                }
+            },
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum SlotFieldType {
+    Required,
+    Optional,
+}
+
+impl SlotFieldType {
+    fn from_syn_type(ty: &Type) -> syn::Result<Self> {
+        if is_array_ref_type(ty) {
+            return Ok(Self::Required);
+        }
+
+        if let Some(inner_ty) = option_inner_type(ty)
+            && is_array_ref_type(inner_ty)
+        {
+            return Ok(Self::Optional);
+        }
+
+        Err(syn::Error::new(
+            ty.span(),
+            "#[array_slots] fields must be ArrayRef or Option<ArrayRef>",
+        ))
+    }
+
+    fn view_field_ty(self) -> proc_macro2::TokenStream {
+        match self {
+            Self::Required => quote! { &'a ::vortex_array::ArrayRef },
+            Self::Optional => quote! { Option<&'a ::vortex_array::ArrayRef> },
+        }
+    }
+}
+
+fn is_array_ref_type(ty: &Type) -> bool {
+    matches!(
+        ty,
+        Type::Path(type_path)
+            if type_path.qself.is_none()
+                && type_path
+                    .path
+                    .segments
+                    .last()
+                    .is_some_and(|segment| segment.ident == "ArrayRef")
+    )
+}
+
+fn option_inner_type(ty: &Type) -> Option<&Type> {
+    let Type::Path(type_path) = ty else {
+        return None;
+    };
+    let segment = type_path.path.segments.last()?;
+    if segment.ident != "Option" {
+        return None;
+    }
+
+    let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
+        return None;
+    };
+
+    match args.args.first()? {
+        syn::GenericArgument::Type(inner_ty) => Some(inner_ty),
+        _ => None,
+    }
+}
+
+fn ident_name(ident: &Ident) -> String {
+    ident.to_string().trim_start_matches("r#").to_owned()
+}
+
+fn to_screaming_snake_case(name: &str) -> String {
+    let mut result = String::with_capacity(name.len());
+    let mut prev_is_lower_or_digit = false;
+
+    for ch in name.chars() {
+        if ch.is_ascii_uppercase() && prev_is_lower_or_digit {
+            result.push('_');
+        }
+        result.push(ch.to_ascii_uppercase());
+        prev_is_lower_or_digit = ch.is_ascii_lowercase() || ch.is_ascii_digit();
+    }
+
+    result
+}
diff --git a/vortex-array/Cargo.toml b/vortex-array/Cargo.toml
index 22feac3d943..462e85a1364 100644
--- a/vortex-array/Cargo.toml
+++ b/vortex-array/Cargo.toml
@@ -67,6 +67,8 @@ tabled = { workspace = true, optional = true, default-features = false, features
 ] }
 termtree = { workspace = true }
 tracing = { workspace = true }
+uuid = { workspace = true }
+vortex-array-macros = { workspace = true }
 vortex-buffer = { workspace = true, features = ["arrow"] }
 vortex-error = { workspace = true, features = ["flatbuffers"] }
 vortex-flatbuffers = { workspace = true, features = ["array", "dtype"] }
@@ -127,6 +129,11 @@ name = "expr_large_struct_pack"
 path = "benches/expr/large_struct_pack.rs"
 harness = false
 
+[[bench]]
+name = "expr_case_when"
+path = "benches/expr/case_when_bench.rs"
+harness = false
+
 [[bench]]
 name = "chunked_dict_builder"
 harness = false
@@ -166,6 +173,10 @@ harness = false
 name = "take_fsl"
 harness = false
 
+[[bench]]
+name = "filter_bool"
+harness = false
+
 [[bench]]
 name = "listview_rebuild"
 harness = false
diff --git a/vortex-array/benches/chunk_array_builder.rs b/vortex-array/benches/chunk_array_builder.rs
index d61b29bea4b..b334b65e9e6 100644
--- a/vortex-array/benches/chunk_array_builder.rs
+++ b/vortex-array/benches/chunk_array_builder.rs
@@ -4,15 +4,15 @@
 use std::sync::LazyLock;
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::prelude::StdRng;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ChunkedArray;
+use vortex_array::arrays::ConstantArray;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::builders::VarBinViewBuilder;
 use vortex_array::builders::builder_with_capacity;
@@ -120,6 +120,61 @@ fn chunked_varbinview_opt_into_canonical(bencher: Bencher, (len, chunk_count): (
         .bench_refs(|chunk| chunk.to_canonical())
 }
 
+#[divan::bench(args = BENCH_ARGS)]
+fn chunked_constant_i32_append_to_builder(bencher: Bencher, (len, chunk_count): (usize, usize)) {
+    let chunk = make_constant_i32_chunks(len, chunk_count);
+
+    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
+        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+        chunk
+            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
+            .vortex_expect("append failed");
+        builder.finish()
+    })
+}
+
+const CONSTANT_UTF8_BENCH_ARGS: &[(&str, usize, usize)] = &[
+    // value, length, chunk_count
+    ("hi", 1000, 10),            // inline (≤12 bytes)
+    ("hello world!!", 1000, 10), // non-inline (>12 bytes)
+];
+
+#[divan::bench(args = CONSTANT_UTF8_BENCH_ARGS)]
+fn chunked_constant_utf8_append_to_builder(
+    bencher: Bencher,
+    (value, len, chunk_count): (&str, usize, usize),
+) {
+    let chunk = make_constant_utf8_chunks(value, len, chunk_count);
+
+    bencher.with_inputs(|| &chunk).bench_refs(|chunk| {
+        let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
+        chunk
+            .append_to_builder(builder.as_mut(), &mut SESSION.create_execution_ctx())
+            .vortex_expect("append failed");
+        builder.finish()
+    })
+}
+
+fn make_constant_utf8_chunks(value: &str, len: usize, chunk_count: usize) -> ArrayRef {
+    use vortex_array::dtype::Nullability;
+    use vortex_array::scalar::Scalar;
+
+    (0..chunk_count)
+        .map(|_| {
+            ConstantArray::new(Scalar::utf8(value, Nullability::NonNullable), len).into_array()
+        })
+        .collect::<ChunkedArray>()
+        .into_array()
+}
+
+fn make_constant_i32_chunks(len: usize, chunk_count: usize) -> ArrayRef {
+    // Each chunk is a ConstantArray of i32; dtype is I32/NonNullable via From<i32> for Scalar.
+    (0..chunk_count)
+        .map(|_| ConstantArray::new(42i32, len).into_array())
+        .collect::<ChunkedArray>()
+        .into_array()
+}
+
 fn make_opt_bool_chunks(len: usize, chunk_count: usize) -> ArrayRef {
     let mut rng = StdRng::seed_from_u64(0);
 
diff --git a/vortex-array/benches/chunked_dict_builder.rs b/vortex-array/benches/chunked_dict_builder.rs
index 2aedc237793..b42514fcf19 100644
--- a/vortex-array/benches/chunked_dict_builder.rs
+++ b/vortex-array/benches/chunked_dict_builder.rs
@@ -6,19 +6,16 @@ use std::sync::LazyLock;
 use divan::Bencher;
 use rand::distr::Distribution;
 use rand::distr::StandardUniform;
-use vortex_array::Array;
 use vortex_array::Canonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::dict_test::gen_dict_primitive_chunks;
 use vortex_array::builders::builder_with_capacity;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::dtype::NativePType;
 use vortex_array::session::ArraySession;
 use vortex_error::VortexExpect;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
diff --git a/vortex-array/benches/compare.rs b/vortex-array/benches/compare.rs
index d60d972c850..4aceffd6de1 100644
--- a/vortex-array/benches/compare.rs
+++ b/vortex-array/benches/compare.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::prelude::StdRng;
@@ -21,7 +21,7 @@ fn main() {
     divan::main();
 }
 
-const ARRAY_SIZE: usize = 10_000_000;
+const ARRAY_SIZE: usize = 65_536;
 
 #[divan::bench]
 fn compare_bool(bencher: Bencher) {
@@ -37,8 +37,8 @@ fn compare_bool(bencher: Bencher) {
         .bench_refs(|input| {
             input
                 .0
-                .to_array()
-                .binary(input.1.to_array(), Operator::Gte)
+                .clone()
+                .binary(input.1.clone(), Operator::Gte)
                 .unwrap()
                 .execute::<Canonical>(&mut input.2)
         });
@@ -65,8 +65,8 @@ fn compare_int(bencher: Bencher) {
         .bench_refs(|input| {
             input
                 .0
-                .to_array()
-                .binary(input.1.to_array(), Operator::Gte)
+                .clone()
+                .binary(input.1.clone(), Operator::Gte)
                 .unwrap()
                 .execute::<Canonical>(&mut input.2)
         });
diff --git a/vortex-array/benches/dict_compare.rs b/vortex-array/benches/dict_compare.rs
index a15b77b54de..b361ba1006e 100644
--- a/vortex-array/benches/dict_compare.rs
+++ b/vortex-array/benches/dict_compare.rs
@@ -6,6 +6,7 @@
 use std::str::from_utf8;
 
 use vortex_array::Canonical;
+use vortex_array::IntoArray;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::accessor::ArrayAccessor;
@@ -16,7 +17,6 @@ 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::builtins::ArrayBuiltins;
-use vortex_array::compute::warm_up_vtables;
 use vortex_array::expr::eq;
 use vortex_array::expr::lit;
 use vortex_array::expr::root;
@@ -24,7 +24,6 @@ use vortex_array::scalar_fn::fns::operators::Operator;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -49,15 +48,16 @@ const LENGTH_AND_UNIQUE_VALUES: &[(usize, usize)] = &[
 #[divan::bench(args = LENGTH_AND_UNIQUE_VALUES)]
 fn bench_compare_primitive(bencher: divan::Bencher, (len, uniqueness): (usize, usize)) {
     let primitive_arr = gen_primitive_for_dict::<i32>(len, uniqueness);
-    let dict = dict_encode(primitive_arr.as_ref()).unwrap();
+    let dict = dict_encode(&primitive_arr.clone().into_array()).unwrap();
     let value = primitive_arr.as_slice::<i32>()[0];
     let session = VortexSession::empty();
 
     bencher
         .with_inputs(|| (&dict, session.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| {
-            dict.to_array()
-                .binary(ConstantArray::new(value, len).to_array(), Operator::Eq)
+            dict.clone()
+                .into_array()
+                .binary(ConstantArray::new(value, len).into_array(), Operator::Eq)
                 .unwrap()
                 .execute::<Canonical>(ctx)
                 .unwrap()
@@ -67,7 +67,7 @@ fn bench_compare_primitive(bencher: divan::Bencher, (len, uniqueness): (usize, u
 #[divan::bench(args = LENGTH_AND_UNIQUE_VALUES)]
 fn bench_compare_varbin(bencher: divan::Bencher, (len, uniqueness): (usize, usize)) {
     let varbin_arr = VarBinArray::from(gen_varbin_words(len, uniqueness));
-    let dict = dict_encode(varbin_arr.as_ref()).unwrap();
+    let dict = dict_encode(&varbin_arr.clone().into_array()).unwrap();
     let bytes = varbin_arr.with_iterator(|i| i.next().unwrap().unwrap().to_vec());
     let value = from_utf8(bytes.as_slice()).unwrap();
     let session = VortexSession::empty();
@@ -75,8 +75,9 @@ fn bench_compare_varbin(bencher: divan::Bencher, (len, uniqueness): (usize, usiz
     bencher
         .with_inputs(|| (&dict, session.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| {
-            dict.to_array()
-                .binary(ConstantArray::new(value, len).to_array(), Operator::Eq)
+            dict.clone()
+                .into_array()
+                .binary(ConstantArray::new(value, len).into_array(), Operator::Eq)
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap()
@@ -86,7 +87,7 @@ fn bench_compare_varbin(bencher: divan::Bencher, (len, uniqueness): (usize, usiz
 #[divan::bench(args = LENGTH_AND_UNIQUE_VALUES)]
 fn bench_compare_varbinview(bencher: divan::Bencher, (len, uniqueness): (usize, usize)) {
     let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(len, uniqueness));
-    let dict = dict_encode(varbinview_arr.as_ref()).unwrap();
+    let dict = dict_encode(&varbinview_arr.clone().into_array()).unwrap();
     let bytes = varbinview_arr.with_iterator(|i| i.next().unwrap().unwrap().to_vec());
     let value = from_utf8(bytes.as_slice()).unwrap();
     let session = VortexSession::empty();
@@ -94,8 +95,9 @@ fn bench_compare_varbinview(bencher: divan::Bencher, (len, uniqueness): (usize,
     bencher
         .with_inputs(|| (&dict, session.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| {
-            dict.to_array()
-                .binary(ConstantArray::new(value, len).to_array(), Operator::Eq)
+            dict.clone()
+                .into_array()
+                .binary(ConstantArray::new(value, len).into_array(), Operator::Eq)
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap()
@@ -120,15 +122,16 @@ fn bench_compare_sliced_dict_primitive(
     (codes_len, values_len): (usize, usize),
 ) {
     let primitive_arr = gen_primitive_for_dict::<i32>(codes_len.max(values_len), values_len);
-    let dict = dict_encode(primitive_arr.as_ref()).unwrap();
-    let dict = dict.slice(0..codes_len).unwrap();
+    let dict = dict_encode(&primitive_arr.clone().into_array()).unwrap();
+    let dict = dict.into_array().slice(0..codes_len).unwrap();
     let value = primitive_arr.as_slice::<i32>()[0];
     let session = VortexSession::empty();
 
     bencher
         .with_inputs(|| (&dict, session.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| {
-            dict.apply(&eq(root(), lit(value)))
+            dict.clone()
+                .apply(&eq(root(), lit(value)))
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap()
@@ -141,8 +144,8 @@ fn bench_compare_sliced_dict_varbinview(
     (codes_len, values_len): (usize, usize),
 ) {
     let varbin_arr = VarBinArray::from(gen_varbin_words(codes_len.max(values_len), values_len));
-    let dict = dict_encode(varbin_arr.as_ref()).unwrap();
-    let dict = dict.slice(0..codes_len).unwrap();
+    let dict = dict_encode(&varbin_arr.clone().into_array()).unwrap();
+    let dict = dict.into_array().slice(0..codes_len).unwrap();
     let bytes = varbin_arr.with_iterator(|i| i.next().unwrap().unwrap().to_vec());
     let value = from_utf8(bytes.as_slice()).unwrap();
     let session = VortexSession::empty();
@@ -150,7 +153,8 @@ fn bench_compare_sliced_dict_varbinview(
     bencher
         .with_inputs(|| (&dict, session.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| {
-            dict.apply(&eq(root(), lit(value)))
+            dict.clone()
+                .apply(&eq(root(), lit(value)))
                 .unwrap()
                 .execute::<RecursiveCanonical>(ctx)
                 .unwrap()
diff --git a/vortex-array/benches/dict_compress.rs b/vortex-array/benches/dict_compress.rs
index ea51d602a4a..5ecf06378cb 100644
--- a/vortex-array/benches/dict_compress.rs
+++ b/vortex-array/benches/dict_compress.rs
@@ -6,16 +6,15 @@
 use divan::Bencher;
 use rand::distr::Distribution;
 use rand::distr::StandardUniform;
+use vortex_array::IntoArray;
 use vortex_array::arrays::VarBinArray;
 use vortex_array::arrays::VarBinViewArray;
 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::compute::warm_up_vtables;
 use vortex_array::dtype::NativePType;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
@@ -43,7 +42,7 @@ where
 
     bencher
         .with_inputs(|| &primitive_arr)
-        .bench_refs(|arr| dict_encode(arr.as_ref()));
+        .bench_refs(|arr| dict_encode(&arr.clone().into_array()));
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -52,7 +51,7 @@ fn encode_varbin(bencher: Bencher, (len, unique_values): (usize, usize)) {
 
     bencher
         .with_inputs(|| &varbin_arr)
-        .bench_refs(|arr| dict_encode(arr.as_ref()));
+        .bench_refs(|arr| dict_encode(&arr.clone().into_array()));
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -61,7 +60,7 @@ fn encode_varbinview(bencher: Bencher, (len, unique_values): (usize, usize)) {
 
     bencher
         .with_inputs(|| &varbinview_arr)
-        .bench_refs(|arr| dict_encode(arr.as_ref()));
+        .bench_refs(|arr| dict_encode(&arr.clone().into_array()));
 }
 
 #[divan::bench(types = [u8, f32, i64], args = BENCH_ARGS)]
@@ -71,7 +70,9 @@ where
     StandardUniform: Distribution<T>,
 {
     let primitive_arr = gen_primitive_for_dict::<T>(len, unique_values);
-    let dict = dict_encode(primitive_arr.as_ref()).unwrap();
+    let dict = dict_encode(&primitive_arr.into_array())
+        .unwrap()
+        .into_array();
 
     bencher
         .with_inputs(|| &dict)
@@ -81,7 +82,7 @@ where
 #[divan::bench(args = BENCH_ARGS)]
 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.as_ref()).unwrap();
+    let dict = dict_encode(&varbin_arr.into_array()).unwrap().into_array();
 
     bencher
         .with_inputs(|| &dict)
@@ -91,7 +92,9 @@ fn decode_varbin(bencher: Bencher, (len, unique_values): (usize, usize)) {
 #[divan::bench(args = BENCH_ARGS)]
 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.as_ref()).unwrap();
+    let dict = dict_encode(&varbinview_arr.into_array())
+        .unwrap()
+        .into_array();
 
     bencher
         .with_inputs(|| &dict)
diff --git a/vortex-array/benches/dict_mask.rs b/vortex-array/benches/dict_mask.rs
index eca43aab6da..9f0be5e585d 100644
--- a/vortex-array/benches/dict_mask.rs
+++ b/vortex-array/benches/dict_mask.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
@@ -13,12 +13,10 @@ use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::DictArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builtins::ArrayBuiltins;
-use vortex_array::compute::warm_up_vtables;
 use vortex_mask::Mask;
 use vortex_session::VortexSession;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
diff --git a/vortex-array/benches/dict_unreferenced_mask.rs b/vortex-array/benches/dict_unreferenced_mask.rs
index b15b9622f83..24cf366f692 100644
--- a/vortex-array/benches/dict_unreferenced_mask.rs
+++ b/vortex-array/benches/dict_unreferenced_mask.rs
@@ -4,16 +4,15 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
 use vortex_array::arrays::DictArray;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::compute::warm_up_vtables;
+use vortex_array::arrays::dict::DictArrayExt;
 
 fn main() {
-    warm_up_vtables();
     divan::main();
 }
 
diff --git a/vortex-array/benches/expr/case_when_bench.rs b/vortex-array/benches/expr/case_when_bench.rs
new file mode 100644
index 00000000000..b49ba4944a0
--- /dev/null
+++ b/vortex-array/benches/expr/case_when_bench.rs
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::cast_possible_truncation)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::expr::case_when;
+use vortex_array::expr::case_when_no_else;
+use vortex_array::expr::eq;
+use vortex_array::expr::get_item;
+use vortex_array::expr::gt;
+use vortex_array::expr::lit;
+use vortex_array::expr::lt;
+use vortex_array::expr::nested_case_when;
+use vortex_array::expr::root;
+use vortex_array::session::ArraySession;
+use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+fn main() {
+    divan::main();
+}
+
+fn make_struct_array(size: usize) -> ArrayRef {
+    let data: Buffer<i32> = (0..size as i32).collect();
+    let field = data.into_array();
+    StructArray::from_fields(&[("value", field)])
+        .unwrap()
+        .into_array()
+}
+
+/// Array with boolean columns cycling through thirds: `c0[i] = i%3==0`, `c1[i] = i%3==1`.
+fn make_fragmented_array(size: usize) -> ArrayRef {
+    StructArray::from_fields(&[
+        (
+            "c0",
+            BoolArray::from_iter((0..size).map(|i| i % 3 == 0)).into_array(),
+        ),
+        (
+            "c1",
+            BoolArray::from_iter((0..size).map(|i| i % 3 == 1)).into_array(),
+        ),
+    ])
+    .unwrap()
+    .into_array()
+}
+
+/// Benchmark a simple binary CASE WHEN with varying array sizes.
+#[divan::bench(args = [1000, 10000, 100000])]
+fn case_when_simple(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value > 500 THEN 100 ELSE 0 END
+    let expr = case_when(
+        gt(get_item("value", root()), lit(500i32)),
+        lit(100i32),
+        lit(0i32),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark n-ary CASE WHEN with 3 conditions.
+#[divan::bench(args = [1000, 10000])]
+fn case_when_nary_3_conditions(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value > 750 THEN 3 WHEN value > 500 THEN 2 WHEN value > 250 THEN 1 ELSE 0 END
+    let expr = nested_case_when(
+        vec![
+            (gt(get_item("value", root()), lit(750i32)), lit(3i32)),
+            (gt(get_item("value", root()), lit(500i32)), lit(2i32)),
+            (gt(get_item("value", root()), lit(250i32)), lit(1i32)),
+        ],
+        Some(lit(0i32)),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark n-ary CASE WHEN with 10 conditions.
+#[divan::bench(args = [1000, 10000])]
+fn case_when_nary_10_conditions(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    let pairs: Vec<_> = (0..10)
+        .map(|i| {
+            let threshold = (i + 1) * (size as i32 / 10);
+            (
+                gt(get_item("value", root()), lit(threshold)),
+                lit((i + 1) * 100),
+            )
+        })
+        .collect();
+    let expr = nested_case_when(pairs, Some(lit(0i32)));
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark n-ary CASE WHEN with equality conditions (lookup-table style).
+#[divan::bench(args = [1000, 10000])]
+fn case_when_nary_equality_lookup(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // Map specific values: CASE WHEN value = 0 THEN 'a' WHEN value = 1 THEN 'b' ... ELSE 'other' END
+    let pairs: Vec<_> = (0..5)
+        .map(|i| (eq(get_item("value", root()), lit(i)), lit(i * 10)))
+        .collect();
+    let expr = nested_case_when(pairs, Some(lit(-1i32)));
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark CASE WHEN without ELSE clause (result is nullable).
+#[divan::bench(args = [1000, 10000, 100000])]
+fn case_when_without_else(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value > 500 THEN 100 END
+    let expr = case_when_no_else(gt(get_item("value", root()), lit(500i32)), lit(100i32));
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark CASE WHEN where all conditions are true.
+#[divan::bench(args = [1000, 10000, 100000])]
+fn case_when_all_true(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value >= 0 THEN 100 ELSE 0 END (always true for our data)
+    let expr = case_when(
+        gt(get_item("value", root()), lit(-1i32)),
+        lit(100i32),
+        lit(0i32),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark n-ary CASE WHEN where the first branch dominates (~90% of rows).
+/// This highlights the early-exit and deferred-merge optimizations: subsequent conditions
+/// match no remaining rows and are skipped entirely.
+#[divan::bench(args = [1000, 10000])]
+fn case_when_nary_early_dominant(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value < 90% THEN 1 WHEN value < 95% THEN 2 WHEN value < 97.5% THEN 3 ELSE 4
+    let t1 = (size as i32 * 9) / 10;
+    let t2 = (size as i32 * 19) / 20;
+    let t3 = (size as i32 * 39) / 40;
+
+    let expr = nested_case_when(
+        vec![
+            (lt(get_item("value", root()), lit(t1)), lit(1i32)),
+            (lt(get_item("value", root()), lit(t2)), lit(2i32)),
+            (lt(get_item("value", root()), lit(t3)), lit(3i32)),
+        ],
+        Some(lit(4i32)),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark CASE WHEN where all conditions are false.
+#[divan::bench(args = [1000, 10000, 100000])]
+fn case_when_all_false(bencher: Bencher, size: usize) {
+    let array = make_struct_array(size);
+
+    // CASE WHEN value > 1000000 THEN 100 ELSE 0 END (always false for our data)
+    let expr = case_when(
+        gt(get_item("value", root()), lit(1_000_000i32)),
+        lit(100i32),
+        lit(0i32),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
+
+/// Benchmark CASE WHEN cycling through 3 branches per row (triggers merge_row_by_row).
+/// Run length = 1; exercises branch 0, branch 1, and the else fallback at every 3rd row.
+#[divan::bench(args = [100, 1000])]
+fn case_when_fragmented(bencher: Bencher, size: usize) {
+    let array = make_fragmented_array(size);
+
+    // CASE WHEN c0 THEN 0 WHEN c1 THEN 1 ELSE 2 END
+    let expr = nested_case_when(
+        vec![
+            (get_item("c0", root()), lit(0i32)),
+            (get_item("c1", root()), lit(1i32)),
+        ],
+        Some(lit(2i32)),
+    );
+
+    bencher
+        .with_inputs(|| (&expr, &array))
+        .bench_refs(|(expr, array)| {
+            let mut ctx = SESSION.create_execution_ctx();
+            array
+                .clone()
+                .apply(expr)
+                .unwrap()
+                .execute::<Canonical>(&mut ctx)
+                .unwrap()
+        });
+}
diff --git a/vortex-array/benches/filter_bool.rs b/vortex-array/benches/filter_bool.rs
new file mode 100644
index 00000000000..c346f653814
--- /dev/null
+++ b/vortex-array/benches/filter_bool.rs
@@ -0,0 +1,470 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Benchmarks for filtering BoolArray by a boolean mask.
+//!
+//! Tests multiple mask patterns (mostly-true, mostly-false, random, correlated runs)
+//! with both uniform-random and power-law distributions, across array sizes from 1K to 250K.
+
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::cast_possible_truncation)]
+#![allow(clippy::cast_sign_loss)]
+#![allow(clippy::cast_precision_loss)]
+
+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_buffer::BitBuffer;
+use vortex_mask::Mask;
+
+fn main() {
+    divan::main();
+}
+
+const SIZES: &[usize] = &[1_000, 10_000, 100_000, 250_000];
+const DENSITY_SWEEP_SIZE: usize = 100_000;
+const ARRAY_SEED: u64 = 42;
+const MASK_SEED: u64 = 43;
+
+// --- Mask generators ---
+
+/// Mostly-true mask: ~90% true bits.
+fn make_mostly_true(len: usize, rng: &mut StdRng) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter(
+        (0..len).map(|_| rng.random_ratio(9, 10)),
+    ))
+}
+
+/// Mostly-false mask: ~10% true bits.
+fn make_mostly_false(len: usize, rng: &mut StdRng) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter(
+        (0..len).map(|_| rng.random_ratio(1, 10)),
+    ))
+}
+
+/// Random 50/50 mask.
+fn make_random(len: usize, rng: &mut StdRng) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter((0..len).map(|_| rng.random_bool(0.5))))
+}
+
+/// Correlated runs: alternating runs of true/false with geometrically distributed lengths.
+fn make_correlated_runs(len: usize, rng: &mut StdRng) -> Mask {
+    let mut bits = Vec::with_capacity(len);
+    let mut current = true;
+    while bits.len() < len {
+        // Average run length ~64
+        let run_len = (rng.random::<f64>().ln() / (1.0_f64 - 1.0 / 64.0).ln()) as usize + 1;
+        let run_len = run_len.min(len - bits.len());
+        bits.extend(std::iter::repeat_n(current, run_len));
+        current = !current;
+    }
+    Mask::from_buffer(BitBuffer::from_iter(bits))
+}
+
+/// Power-law (Zipfian) mask: indices chosen from a Zipf distribution, so lower indices are
+/// much more likely to be selected.
+fn make_power_law(len: usize, rng: &mut StdRng) -> Mask {
+    let zipf = Zipf::new(len as f64, 1.0).unwrap();
+    let num_selected = len / 2;
+    let mut indices: Vec<usize> = rng
+        .sample_iter(&zipf)
+        .take(num_selected * 2)
+        .map(|v: f64| (v as usize).saturating_sub(1).min(len - 1))
+        .collect();
+    indices.sort_unstable();
+    indices.dedup();
+    indices.truncate(num_selected);
+    Mask::from_indices(len, indices)
+}
+
+/// Mask with exact density: fraction of bits set to true.
+fn make_density_mask(len: usize, density: f64, rng: &mut StdRng) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter(
+        (0..len).map(|_| rng.random_bool(density)),
+    ))
+}
+
+/// Dense runs mask: long runs of true with rare false gaps.
+fn make_dense_runs(len: usize, false_rate: f64, rng: &mut StdRng) -> Mask {
+    let mut bits = Vec::with_capacity(len);
+    let mut current = true;
+    while bits.len() < len {
+        let avg_run = if current {
+            (1.0 / false_rate).max(1.0)
+        } else {
+            2.0
+        };
+        let run_len = (rng.random::<f64>().ln() / (1.0 - 1.0 / avg_run).ln()).max(1.0) as usize;
+        let run_len = run_len.min(len - bits.len());
+        bits.extend(std::iter::repeat_n(current, run_len));
+        current = !current;
+    }
+    Mask::from_buffer(BitBuffer::from_iter(bits))
+}
+
+/// Single contiguous block of true values (best case for slice path).
+fn make_single_slice(len: usize, density: f64) -> Mask {
+    let true_count = (len as f64 * density) as usize;
+    let start = (len - true_count) / 2;
+    Mask::from_indices(len, (start..start + true_count).collect())
+}
+
+// --- Source array generators ---
+
+fn make_random_bool_array(len: usize, rng: &mut StdRng) -> BoolArray {
+    BoolArray::from_iter((0..len).map(|_| rng.random_bool(0.5)))
+}
+
+fn make_power_law_bool_array(len: usize, rng: &mut StdRng) -> BoolArray {
+    let zipf = Zipf::new(len as f64, 1.0).unwrap();
+    BoolArray::from_iter((0..len).map(|i| {
+        let threshold: f64 = rng.sample(zipf);
+        (i as f64) < threshold
+    }))
+}
+
+/// Create a fresh StdRng with the mask seed.
+fn mask_rng() -> StdRng {
+    StdRng::seed_from_u64(MASK_SEED)
+}
+
+// --- Benchmarks: Random source array ---
+
+#[divan::bench(args = SIZES)]
+fn filter_random_by_mostly_true(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_mostly_true(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_random_by_mostly_false(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_mostly_false(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_random_by_random(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_random(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_random_by_correlated_runs(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_correlated_runs(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_random_by_power_law(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_power_law(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+// --- Benchmarks: Power-law source array ---
+
+#[divan::bench(args = SIZES)]
+fn filter_powerlaw_by_mostly_true(bencher: Bencher, n: usize) {
+    let array = make_power_law_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_mostly_true(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_powerlaw_by_mostly_false(bencher: Bencher, n: usize) {
+    let array = make_power_law_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_mostly_false(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_powerlaw_by_random(bencher: Bencher, n: usize) {
+    let array = make_power_law_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_random(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_powerlaw_by_correlated_runs(bencher: Bencher, n: usize) {
+    let array = make_power_law_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_correlated_runs(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = SIZES)]
+fn filter_powerlaw_by_power_law(bencher: Bencher, n: usize) {
+    let array = make_power_law_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_power_law(n, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+// --- Density sweep ---
+
+const DENSITIES: &[f64] = &[
+    0.001, 0.005, 0.01, 0.02, 0.05, 0.1, 0.5, 0.9, 0.95, 0.99, 0.999, 0.9999,
+];
+
+#[divan::bench(args = DENSITIES)]
+fn density_sweep_random(bencher: Bencher, density: f64) {
+    let array = make_random_bool_array(DENSITY_SWEEP_SIZE, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_density_mask(DENSITY_SWEEP_SIZE, density, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = DENSITIES)]
+fn density_sweep_dense_runs(bencher: Bencher, density: f64) {
+    let array = make_random_bool_array(DENSITY_SWEEP_SIZE, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    let false_rate = (1.0 - density).max(0.0001);
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_dense_runs(DENSITY_SWEEP_SIZE, false_rate, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = DENSITIES)]
+fn density_sweep_single_slice(bencher: Bencher, density: f64) {
+    let array = make_random_bool_array(DENSITY_SWEEP_SIZE, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_single_slice(DENSITY_SWEEP_SIZE, density),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+// --- Extreme cases ---
+
+const LARGE_SIZES: &[usize] = &[10_000, 100_000, 250_000];
+
+#[divan::bench(args = LARGE_SIZES)]
+fn filter_all_true(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                Mask::new_true(n),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = LARGE_SIZES)]
+fn filter_one_false(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            let mut bits: Vec<bool> = vec![true; n];
+            bits[n / 2] = false;
+            (
+                array.clone(),
+                Mask::from_buffer(BitBuffer::from_iter(bits)),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
+
+#[divan::bench(args = LARGE_SIZES)]
+fn filter_ultra_sparse(bencher: Bencher, n: usize) {
+    let array = make_random_bool_array(n, &mut StdRng::seed_from_u64(ARRAY_SEED));
+    bencher
+        .with_inputs(|| {
+            (
+                array.clone(),
+                make_density_mask(n, 0.0001, &mut mask_rng()),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, m, ctx)| {
+            array
+                .clone()
+                .filter(m.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
+}
diff --git a/vortex-array/benches/listview_rebuild.rs b/vortex-array/benches/listview_rebuild.rs
index f9e25e6b0d3..6affedca45f 100644
--- a/vortex-array/benches/listview_rebuild.rs
+++ b/vortex-array/benches/listview_rebuild.rs
@@ -11,10 +11,11 @@ use vortex_array::IntoArray;
 use vortex_array::arrays::FixedSizeListArray;
 use vortex_array::arrays::ListArray;
 use vortex_array::arrays::ListViewArray;
-use vortex_array::arrays::ListViewRebuildMode;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 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::validity::Validity;
 use vortex_buffer::Buffer;
diff --git a/vortex-array/benches/scalar_at_struct.rs b/vortex-array/benches/scalar_at_struct.rs
index cc446836f99..a4ab5c32df8 100644
--- a/vortex-array/benches/scalar_at_struct.rs
+++ b/vortex-array/benches/scalar_at_struct.rs
@@ -4,10 +4,11 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::rngs::StdRng;
+use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::dtype::FieldNames;
@@ -39,6 +40,7 @@ fn scalar_at_struct_simple(bencher: Bencher) {
         Validity::NonNullable,
     )
     .unwrap();
+    let struct_array: ArrayRef = struct_array.into_array();
 
     let indices: Vec<usize> = (0..NUM_ACCESSES)
         .map(|_| rng.random_range(0..ARRAY_SIZE))
@@ -72,8 +74,10 @@ fn scalar_at_struct_wide(bencher: Bencher) {
         "field1", "field2", "field3", "field4", "field5", "field6", "field7", "field8",
     ]);
 
-    let struct_array =
-        StructArray::try_new(field_names, fields, ARRAY_SIZE, Validity::NonNullable).unwrap();
+    let struct_array: ArrayRef =
+        StructArray::try_new(field_names, fields, ARRAY_SIZE, Validity::NonNullable)
+            .unwrap()
+            .into_array();
 
     let indices: Vec<usize> = (0..NUM_ACCESSES)
         .map(|_| rng.random_range(0..ARRAY_SIZE))
diff --git a/vortex-array/benches/scalar_subtract.rs b/vortex-array/benches/scalar_subtract.rs
index fa04240a0b4..0d026db5d3e 100644
--- a/vortex-array/benches/scalar_subtract.rs
+++ b/vortex-array/benches/scalar_subtract.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::rngs::StdRng;
@@ -44,7 +44,7 @@ fn scalar_subtract(bencher: Bencher) {
         .with_inputs(|| (&chunked, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(chunked, ctx)| {
             chunked
-                .to_array()
+                .clone()
                 .binary(
                     ConstantArray::new(
                         vortex_array::scalar::Scalar::from(to_subtract),
diff --git a/vortex-array/benches/search_sorted.rs b/vortex-array/benches/search_sorted.rs
index 353dec65a3b..31ed741765a 100644
--- a/vortex-array/benches/search_sorted.rs
+++ b/vortex-array/benches/search_sorted.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::prelude::StdRng;
@@ -33,8 +33,8 @@ fn binary_search_vortex(bencher: Bencher) {
 
 fn fixture() -> (Vec<i32>, i32) {
     let mut rng = StdRng::seed_from_u64(0);
-    let range = Uniform::new(0, 1_000_000).unwrap();
-    let mut data: Vec<i32> = (0..1_000_000).map(|_| rng.sample(range)).collect();
+    let range = Uniform::new(0, 65_536).unwrap();
+    let mut data: Vec<i32> = (0..65_536).map(|_| rng.sample(range)).collect();
     data.sort();
 
     (data, rng.sample(range))
diff --git a/vortex-array/benches/take_fsl.rs b/vortex-array/benches/take_fsl.rs
index c4eea1890e8..5c66847669e 100644
--- a/vortex-array/benches/take_fsl.rs
+++ b/vortex-array/benches/take_fsl.rs
@@ -11,10 +11,9 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
-use vortex_array::Array;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
@@ -28,7 +27,7 @@ fn main() {
 }
 
 /// Number of lists in the source array.
-const NUM_LISTS: usize = 10_000;
+const NUM_LISTS: usize = 500;
 
 /// Number of indices to take.
 const NUM_INDICES: &[usize] = &[100, 1_000];
@@ -66,7 +65,8 @@ fn take_fsl_random<const LIST_SIZE: usize>(bencher: Bencher, num_indices: usize)
         .with_inputs(|| (&fsl, &indices_array, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(array, indices, execution_ctx)| {
             array
-                .take(indices.to_array())
+                .clone()
+                .take(indices.clone())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
@@ -91,7 +91,8 @@ fn take_fsl_nullable_random<const LIST_SIZE: usize>(bencher: Bencher, num_indice
         .with_inputs(|| (&fsl, &indices_array, LEGACY_SESSION.create_execution_ctx()))
         .bench_refs(|(array, indices, execution_ctx)| {
             array
-                .take(indices.to_array())
+                .clone()
+                .take(indices.clone())
                 .unwrap()
                 .execute::<RecursiveCanonical>(execution_ctx)
                 .unwrap()
diff --git a/vortex-array/benches/take_patches.rs b/vortex-array/benches/take_patches.rs
index e671a1abdff..5360aa57c7e 100644
--- a/vortex-array/benches/take_patches.rs
+++ b/vortex-array/benches/take_patches.rs
@@ -5,12 +5,14 @@
 #![allow(clippy::cast_possible_truncation)]
 
 use divan::Bencher;
-use rand::Rng;
+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::ToCanonical;
+use vortex_array::VortexSessionExecute;
 use vortex_array::patches::Patches;
 use vortex_buffer::Buffer;
 
@@ -45,8 +47,10 @@ fn take_search(bencher: Bencher, (patches_sparsity, index_multiple): (f64, f64))
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices))
-        .bench_refs(|(patches, indices)| patches.take_search(indices.to_primitive(), false));
+        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .bench_refs(|(patches, indices, ctx)| {
+            patches.take_search(indices.to_primitive(), false, ctx)
+        });
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -60,8 +64,10 @@ fn take_search_chunked(bencher: Bencher, (patches_sparsity, index_multiple): (f6
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices))
-        .bench_refs(|(patches, indices)| patches.take_search(indices.to_primitive(), false));
+        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .bench_refs(|(patches, indices, ctx)| {
+            patches.take_search(indices.to_primitive(), false, ctx)
+        });
 }
 
 #[divan::bench(args = BENCH_ARGS)]
@@ -75,8 +81,8 @@ fn take_map(bencher: Bencher, (patches_sparsity, index_multiple): (f64, f64)) {
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices))
-        .bench_refs(|(patches, indices)| patches.take_map(indices.to_primitive(), false));
+        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .bench_refs(|(patches, indices, ctx)| patches.take_map(indices.to_primitive(), false, ctx));
 }
 
 fn fixture(len: usize, sparsity: f64, rng: &mut StdRng) -> Patches {
diff --git a/vortex-array/benches/take_struct.rs b/vortex-array/benches/take_struct.rs
index 5720acff0cf..2eabaab62dc 100644
--- a/vortex-array/benches/take_struct.rs
+++ b/vortex-array/benches/take_struct.rs
@@ -4,12 +4,14 @@
 #![allow(clippy::unwrap_used)]
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::rngs::StdRng;
-use vortex_array::Array;
 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::validity::Validity;
@@ -39,7 +41,8 @@ fn take_struct_simple(bencher: Bencher) {
         ARRAY_SIZE,
         Validity::NonNullable,
     )
-    .unwrap();
+    .unwrap()
+    .into_array();
 
     let indices: Buffer<u64> = (0..TAKE_SIZE)
         .map(|_| rng.random_range(0..ARRAY_SIZE) as u64)
@@ -47,8 +50,19 @@ fn take_struct_simple(bencher: Bencher) {
     let indices_array = indices.into_array();
 
     bencher
-        .with_inputs(|| (&struct_array, &indices_array))
-        .bench_refs(|(array, indices)| array.take(indices.to_array()).unwrap());
+        .with_inputs(|| {
+            (
+                &struct_array,
+                &indices_array,
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, indices, ctx)| {
+            array
+                .take((*indices).clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
 }
 
 #[divan::bench(args = [8])]
@@ -69,8 +83,9 @@ fn take_struct_wide(bencher: Bencher, width: usize) {
         "field1", "field2", "field3", "field4", "field5", "field6", "field7", "field8",
     ]);
 
-    let struct_array =
-        StructArray::try_new(field_names, fields, ARRAY_SIZE, Validity::NonNullable).unwrap();
+    let struct_array = StructArray::try_new(field_names, fields, ARRAY_SIZE, Validity::NonNullable)
+        .unwrap()
+        .into_array();
 
     let indices: Buffer<u64> = (0..TAKE_SIZE)
         .map(|_| rng.random_range(0..ARRAY_SIZE) as u64)
@@ -78,8 +93,19 @@ fn take_struct_wide(bencher: Bencher, width: usize) {
     let indices_array = indices.into_array();
 
     bencher
-        .with_inputs(|| (&struct_array, &indices_array))
-        .bench_refs(|(array, indices)| array.take(indices.to_array()).unwrap());
+        .with_inputs(|| {
+            (
+                &struct_array,
+                &indices_array,
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, indices, ctx)| {
+            array
+                .take((*indices).clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
 }
 
 #[divan::bench]
@@ -99,13 +125,25 @@ fn take_struct_sequential_indices(bencher: Bencher) {
         ARRAY_SIZE,
         Validity::NonNullable,
     )
-    .unwrap();
+    .unwrap()
+    .into_array();
 
     // Sequential indices for better cache performance
     let indices: Buffer<u64> = (0..TAKE_SIZE as u64).collect();
     let indices_array = indices.into_array();
 
     bencher
-        .with_inputs(|| (&struct_array, &indices_array))
-        .bench_refs(|(array, indices)| array.take(indices.to_array()).unwrap());
+        .with_inputs(|| {
+            (
+                &struct_array,
+                &indices_array,
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, indices, ctx)| {
+            array
+                .take((*indices).clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+        });
 }
diff --git a/vortex-array/benches/varbinview_compact.rs b/vortex-array/benches/varbinview_compact.rs
index ec0ebefb207..ae763055db1 100644
--- a/vortex-array/benches/varbinview_compact.rs
+++ b/vortex-array/benches/varbinview_compact.rs
@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use divan::Bencher;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::ArrayRef;
@@ -42,6 +42,7 @@ fn compact_impl(bencher: Bencher, (output_size, utilization_pct): (usize, usize)
     let base_array = build_varbinview_fixture(base_size);
     let indices = random_indices(output_size, base_size);
     let taken = base_array
+        .into_array()
         .take(indices)
         .vortex_expect("operation should succeed in benchmark");
     let array = taken.to_varbinview();
@@ -57,7 +58,7 @@ fn compact_sliced_impl(bencher: Bencher, (output_size, utilization_pct): (usize,
     let base_size = (output_size * 100) / utilization_pct;
     let base_array = build_varbinview_fixture(base_size);
     let sliced = base_array
-        .as_ref()
+        .into_array()
         .slice(0..output_size)
         .vortex_expect("slice should succeed");
     let array = sliced.to_varbinview();
diff --git a/vortex-array/benches/varbinview_zip.rs b/vortex-array/benches/varbinview_zip.rs
index f7d01e60bfa..b3ce220f558 100644
--- a/vortex-array/benches/varbinview_zip.rs
+++ b/vortex-array/benches/varbinview_zip.rs
@@ -5,6 +5,9 @@
 
 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;
@@ -24,9 +27,19 @@ fn varbinview_zip_fragmented_mask(bencher: Bencher) {
     let mask = alternating_mask(len);
 
     bencher
-        .with_inputs(|| (&if_true, &if_false, &mask))
-        .bench_refs(|(t, f, m)| {
-            t.zip(f.clone(), m.clone().into_array()).unwrap();
+        .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();
         });
 }
 
@@ -39,9 +52,19 @@ fn varbinview_zip_block_mask(bencher: Bencher) {
     let mask = block_mask(len, 128);
 
     bencher
-        .with_inputs(|| (&if_true, &if_false, &mask))
-        .bench_refs(|(t, f, m)| {
-            t.zip(f.clone(), m.clone().into_array()).unwrap();
+        .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/public-api.lock b/vortex-array/public-api.lock
index d856b621905..e836da72d9d 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -1,5 +1,7 @@
 pub mod vortex_array
 
+pub use vortex_array::array_slots
+
 pub mod vortex_array::accessor
 
 pub trait vortex_array::accessor::ArrayAccessor<Item: ?core::marker::Sized>
@@ -26,18215 +28,25177 @@ impl<T: vortex_array::dtype::NativePType> vortex_array::accessor::ArrayAccessor<
 
 pub fn vortex_array::arrays::PrimitiveArray::with_iterator<F, R>(&self, f: F) -> R where F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a T>>) -> R
 
-pub mod vortex_array::arrays
+pub mod vortex_array::aggregate_fn
 
-pub mod vortex_array::arrays::build_views
+pub mod vortex_array::aggregate_fn::fns
 
-#[repr(C, align(16))] pub union vortex_array::arrays::build_views::BinaryView
+pub mod vortex_array::aggregate_fn::fns::count
 
-impl vortex_array::arrays::BinaryView
+pub struct vortex_array::aggregate_fn::fns::count::Count
 
-pub const vortex_array::arrays::BinaryView::MAX_INLINED_SIZE: usize
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::count::Count
 
-pub fn vortex_array::arrays::BinaryView::as_inlined(&self) -> &vortex_array::arrays::Inlined
+pub fn vortex_array::aggregate_fn::fns::count::Count::clone(&self) -> vortex_array::aggregate_fn::fns::count::Count
 
-pub fn vortex_array::arrays::BinaryView::as_u128(&self) -> u128
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::count::Count
 
-pub fn vortex_array::arrays::BinaryView::as_view(&self) -> &vortex_array::arrays::Ref
+pub fn vortex_array::aggregate_fn::fns::count::Count::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BinaryView::as_view_mut(&mut self) -> &mut vortex_array::arrays::Ref
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::count::Count
 
-pub fn vortex_array::arrays::BinaryView::empty_view() -> Self
+pub type vortex_array::aggregate_fn::fns::count::Count::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::BinaryView::is_empty(&self) -> bool
+pub type vortex_array::aggregate_fn::fns::count::Count::Partial = u64
 
-pub fn vortex_array::arrays::BinaryView::is_inlined(&self) -> bool
+pub fn vortex_array::aggregate_fn::fns::count::Count::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BinaryView::len(&self) -> u32
+pub fn vortex_array::aggregate_fn::fns::count::Count::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BinaryView::make_view(value: &[u8], block: u32, offset: u32) -> Self
+pub fn vortex_array::aggregate_fn::fns::count::Count::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BinaryView::new_inlined(value: &[u8]) -> Self
+pub fn vortex_array::aggregate_fn::fns::count::Count::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::clone::Clone for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::empty_partial(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::BinaryView::clone(&self) -> vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::cmp::Eq for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::cmp::PartialEq for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::BinaryView::eq(&self, other: &Self) -> bool
+pub fn vortex_array::aggregate_fn::fns::count::Count::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-impl core::convert::From<u128> for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BinaryView::from(value: u128) -> Self
+pub fn vortex_array::aggregate_fn::fns::count::Count::reset(&self, partial: &mut Self::Partial)
 
-impl core::convert::From<vortex_array::arrays::Ref> for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::return_dtype(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BinaryView::from(value: vortex_array::arrays::Ref) -> Self
+pub fn vortex_array::aggregate_fn::fns::count::Count::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::default::Default for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::count::Count::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BinaryView::default() -> Self
+pub fn vortex_array::aggregate_fn::fns::count::Count::try_accumulate(&self, state: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-impl core::fmt::Debug for vortex_array::arrays::BinaryView
+pub mod vortex_array::aggregate_fn::fns::first
 
-pub fn vortex_array::arrays::BinaryView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::aggregate_fn::fns::first::First
 
-impl core::hash::Hash for vortex_array::arrays::BinaryView
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::first::First
 
-pub fn vortex_array::arrays::BinaryView::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::aggregate_fn::fns::first::First::clone(&self) -> vortex_array::aggregate_fn::fns::first::First
 
-impl core::marker::Copy for vortex_array::arrays::BinaryView
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::first::First
 
-pub const vortex_array::arrays::build_views::MAX_BUFFER_LEN: usize
+pub fn vortex_array::aggregate_fn::fns::first::First::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::build_views::build_views<P: vortex_array::dtype::NativePType + num_traits::cast::AsPrimitive<usize>>(start_buf_index: u32, max_buffer_len: usize, bytes: vortex_buffer::ByteBufferMut, lens: &[P]) -> (alloc::vec::Vec<vortex_buffer::ByteBuffer>, vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>)
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::first::First
 
-pub fn vortex_array::arrays::build_views::offsets_to_lengths<P: vortex_array::dtype::NativePType>(offsets: &[P]) -> vortex_buffer::buffer::Buffer<P>
+pub type vortex_array::aggregate_fn::fns::first::First::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub mod vortex_array::arrays::builder
+pub type vortex_array::aggregate_fn::fns::first::First::Partial = vortex_array::aggregate_fn::fns::first::FirstPartial
 
-pub struct vortex_array::arrays::builder::VarBinBuilder<O: vortex_array::dtype::IntegerPType>
+pub fn vortex_array::aggregate_fn::fns::first::First::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<O: vortex_array::dtype::IntegerPType> vortex_array::arrays::builder::VarBinBuilder<O>
+pub fn vortex_array::aggregate_fn::fns::first::First::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::append(&mut self, value: core::option::Option<&[u8]>)
+pub fn vortex_array::aggregate_fn::fns::first::First::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::append_n_nulls(&mut self, n: usize)
+pub fn vortex_array::aggregate_fn::fns::first::First::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::append_null(&mut self)
+pub fn vortex_array::aggregate_fn::fns::first::First::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::append_value(&mut self, value: impl core::convert::AsRef<[u8]>)
+pub fn vortex_array::aggregate_fn::fns::first::First::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::append_values(&mut self, values: &[u8], end_offsets: impl core::iter::traits::iterator::Iterator<Item = O>, num: usize) where O: 'static, usize: num_traits::cast::AsPrimitive<O>
+pub fn vortex_array::aggregate_fn::fns::first::First::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::finish(self, dtype: vortex_array::dtype::DType) -> vortex_array::arrays::VarBinArray
+pub fn vortex_array::aggregate_fn::fns::first::First::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::new() -> Self
+pub fn vortex_array::aggregate_fn::fns::first::First::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::with_capacity(len: usize) -> Self
+pub fn vortex_array::aggregate_fn::fns::first::First::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl<O: vortex_array::dtype::IntegerPType> core::default::Default for vortex_array::arrays::builder::VarBinBuilder<O>
+pub fn vortex_array::aggregate_fn::fns::first::First::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::builder::VarBinBuilder<O>::default() -> Self
+pub fn vortex_array::aggregate_fn::fns::first::First::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub mod vortex_array::arrays::vtable
+pub fn vortex_array::aggregate_fn::fns::first::First::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_array::arrays::vtable::DictVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::try_accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub const vortex_array::arrays::DictVTable::ID: vortex_array::vtable::ArrayId
+pub struct vortex_array::aggregate_fn::fns::first::FirstPartial
 
-impl core::fmt::Debug for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::first::first(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DictVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod vortex_array::aggregate_fn::fns::is_constant
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::DictVTable
+pub mod vortex_array::aggregate_fn::fns::is_constant::primitive
 
-pub fn vortex_array::arrays::DictVTable::filter(array: &vortex_array::arrays::DictArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub const vortex_array::aggregate_fn::fns::is_constant::primitive::IS_CONST_LANE_WIDTH: usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::primitive::compute_is_constant<T: vortex_array::dtype::NativePType, const WIDTH: usize>(values: &[T]) -> bool
 
-pub fn vortex_array::arrays::DictVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::DictVTable
+impl vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-pub fn vortex_array::arrays::DictVTable::take(array: &vortex_array::arrays::DictArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::make_partial(batch: &vortex_array::ArrayRef, is_constant: bool) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::DictVTable
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-pub fn vortex_array::arrays::DictVTable::is_constant(&self, array: &vortex_array::arrays::DictArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::clone(&self) -> vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::DictVTable
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-pub fn vortex_array::arrays::DictVTable::is_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::DictVTable::is_strict_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::DictVTable
+pub type vortex_array::aggregate_fn::fns::is_constant::IsConstant::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::DictVTable::min_max(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub type vortex_array::aggregate_fn::fns::is_constant::IsConstant::Partial = vortex_array::aggregate_fn::fns::is_constant::IsConstantPartial
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::compare(lhs: &vortex_array::arrays::DictArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::cast(array: &vortex_array::arrays::DictArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::DictVTable::fill_null(array: &vortex_array::arrays::DictArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DictVTable::like(array: &vortex_array::arrays::DictArray, pattern: &dyn vortex_array::Array, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::DictVTable::mask(array: &vortex_array::arrays::DictArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::partial_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::DictVTable::array_eq(array: &vortex_array::arrays::DictArray, other: &vortex_array::arrays::DictArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DictVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::DictArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DictVTable::dtype(array: &vortex_array::arrays::DictArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DictVTable::len(array: &vortex_array::arrays::DictArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DictVTable::stats(array: &vortex_array::arrays::DictArray) -> vortex_array::stats::StatsSetRef<'_>
+pub struct vortex_array::aggregate_fn::fns::is_constant::IsConstantPartial
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::is_constant(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DictVTable::scalar_at(array: &vortex_array::arrays::DictArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::is_constant::make_is_constant_partial_dtype(element_dtype: &vortex_array::dtype::DType) -> vortex_array::dtype::DType
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::DictVTable
+pub mod vortex_array::aggregate_fn::fns::is_sorted
 
-pub type vortex_array::arrays::DictVTable::Array = vortex_array::arrays::DictArray
+pub struct vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub type vortex_array::arrays::DictVTable::ArrayVTable = vortex_array::arrays::DictVTable
+impl vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub type vortex_array::arrays::DictVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::DictMetadata>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::make_partial(batch: &vortex_array::ArrayRef, is_sorted: bool, strict: bool) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::arrays::DictVTable::OperationsVTable = vortex_array::arrays::DictVTable
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub type vortex_array::arrays::DictVTable::ValidityVTable = vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::clone(&self) -> vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub type vortex_array::arrays::DictVTable::VisitorVTable = vortex_array::arrays::DictVTable
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub fn vortex_array::arrays::DictVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::DictArray>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::DictVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub fn vortex_array::arrays::DictVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::aggregate_fn::fns::is_sorted::IsSorted::Options = vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::DictVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::aggregate_fn::fns::is_sorted::IsSorted::Partial = vortex_array::aggregate_fn::fns::is_sorted::IsSortedPartial
 
-pub fn vortex_array::arrays::DictVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::metadata(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DictVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::DictVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::empty_partial(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DictVTable::validity(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::DictVTable::nbuffers(_array: &vortex_array::arrays::DictArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::DictVTable::nchildren(_array: &vortex_array::arrays::DictArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::partial_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DictVTable::nth_child(array: &vortex_array::arrays::DictArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::DictVTable::visit_buffers(_array: &vortex_array::arrays::DictArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DictVTable::visit_children(array: &vortex_array::arrays::DictArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub enum vortex_array::arrays::ListViewRebuildMode
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_array::arrays::ListViewRebuildMode::MakeExact
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub vortex_array::arrays::ListViewRebuildMode::MakeZeroCopyToList
+pub struct vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub vortex_array::arrays::ListViewRebuildMode::OverlapCompression
+pub vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::strict: bool
 
-pub vortex_array::arrays::ListViewRebuildMode::TrimElements
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-#[repr(C, align(16))] pub union vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::clone(&self) -> vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-impl vortex_array::arrays::BinaryView
+impl core::cmp::Eq for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub const vortex_array::arrays::BinaryView::MAX_INLINED_SIZE: usize
+impl core::cmp::PartialEq for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::BinaryView::as_inlined(&self) -> &vortex_array::arrays::Inlined
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::eq(&self, other: &vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions) -> bool
 
-pub fn vortex_array::arrays::BinaryView::as_u128(&self) -> u128
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::BinaryView::as_view(&self) -> &vortex_array::arrays::Ref
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BinaryView::as_view_mut(&mut self) -> &mut vortex_array::arrays::Ref
+impl core::fmt::Display for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::BinaryView::empty_view() -> Self
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BinaryView::is_empty(&self) -> bool
+impl core::hash::Hash for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::BinaryView::is_inlined(&self) -> bool
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::arrays::BinaryView::len(&self) -> u32
+impl core::marker::StructuralPartialEq for vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub fn vortex_array::arrays::BinaryView::make_view(value: &[u8], block: u32, offset: u32) -> Self
+pub struct vortex_array::aggregate_fn::fns::is_sorted::IsSortedPartial
 
-pub fn vortex_array::arrays::BinaryView::new_inlined(value: &[u8]) -> Self
+pub trait vortex_array::aggregate_fn::fns::is_sorted::IsSortedIteratorExt where <Self as core::iter::traits::iterator::Iterator>::Item: core::cmp::PartialOrd: core::iter::traits::iterator::Iterator
 
-impl core::clone::Clone for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSortedIteratorExt::is_strict_sorted(self) -> bool where Self: core::marker::Sized, Self::Item: core::cmp::PartialOrd
 
-pub fn vortex_array::arrays::BinaryView::clone(&self) -> vortex_array::arrays::BinaryView
+impl<T> vortex_array::aggregate_fn::fns::is_sorted::IsSortedIteratorExt for T where T: core::iter::traits::iterator::Iterator + ?core::marker::Sized, <T as core::iter::traits::iterator::Iterator>::Item: core::cmp::PartialOrd
 
-impl core::cmp::Eq for vortex_array::arrays::BinaryView
+pub fn T::is_strict_sorted(self) -> bool where Self: core::marker::Sized, Self::Item: core::cmp::PartialOrd
 
-impl core::cmp::PartialEq for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::is_sorted::is_sorted(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::BinaryView::eq(&self, other: &Self) -> bool
+pub fn vortex_array::aggregate_fn::fns::is_sorted::is_strict_sorted(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-impl core::convert::From<u128> for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::is_sorted::make_is_sorted_partial_dtype(element_dtype: &vortex_array::dtype::DType) -> vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::BinaryView::from(value: u128) -> Self
+pub mod vortex_array::aggregate_fn::fns::last
 
-impl core::convert::From<vortex_array::arrays::Ref> for vortex_array::arrays::BinaryView
+pub struct vortex_array::aggregate_fn::fns::last::Last
 
-pub fn vortex_array::arrays::BinaryView::from(value: vortex_array::arrays::Ref) -> Self
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::last::Last
 
-impl core::default::Default for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::last::Last::clone(&self) -> vortex_array::aggregate_fn::fns::last::Last
 
-pub fn vortex_array::arrays::BinaryView::default() -> Self
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::last::Last
 
-impl core::fmt::Debug for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::last::Last::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BinaryView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::last::Last
 
-impl core::hash::Hash for vortex_array::arrays::BinaryView
+pub type vortex_array::aggregate_fn::fns::last::Last::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::BinaryView::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub type vortex_array::aggregate_fn::fns::last::Last::Partial = vortex_array::aggregate_fn::fns::last::LastPartial
 
-impl core::marker::Copy for vortex_array::arrays::BinaryView
+pub fn vortex_array::aggregate_fn::fns::last::Last::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::arrays::AnyScalarFn
+pub fn vortex_array::aggregate_fn::fns::last::Last::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::fmt::Debug for vortex_array::arrays::AnyScalarFn
+pub fn vortex_array::aggregate_fn::fns::last::Last::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::AnyScalarFn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::fns::last::Last::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl vortex_array::matcher::Matcher for vortex_array::arrays::AnyScalarFn
+pub fn vortex_array::aggregate_fn::fns::last::Last::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub type vortex_array::arrays::AnyScalarFn::Match<'a> = &'a vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::AnyScalarFn::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub fn vortex_array::aggregate_fn::fns::last::Last::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::BoolArray::from_indices<I: core::iter::traits::collect::IntoIterator<Item = usize>>(length: usize, indices: I, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::aggregate_fn::fns::last::Last::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BoolArray::into_bit_buffer(self) -> vortex_buffer::bit::buf::BitBuffer
+pub fn vortex_array::aggregate_fn::fns::last::Last::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::BoolArray::into_parts(self) -> vortex_array::arrays::BoolArrayParts
+pub fn vortex_array::aggregate_fn::fns::last::Last::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BoolArray::maybe_to_mask(&self) -> vortex_error::VortexResult<core::option::Option<vortex_mask::Mask>>
+pub fn vortex_array::aggregate_fn::fns::last::Last::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolArray::new(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::aggregate_fn::fns::last::Last::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolArray::new_handle(handle: vortex_array::buffer::BufferHandle, offset: usize, len: usize, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::aggregate_fn::fns::last::Last::try_accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub unsafe fn vortex_array::arrays::BoolArray::new_unchecked(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> Self
+pub struct vortex_array::aggregate_fn::fns::last::LastPartial
 
-pub fn vortex_array::arrays::BoolArray::to_bit_buffer(&self) -> vortex_buffer::bit::buf::BitBuffer
+pub fn vortex_array::aggregate_fn::fns::last::last(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolArray::to_mask(&self) -> vortex_mask::Mask
+pub mod vortex_array::aggregate_fn::fns::min_max
 
-pub fn vortex_array::arrays::BoolArray::to_mask_fill_null_false(&self) -> vortex_mask::Mask
+pub struct vortex_array::aggregate_fn::fns::min_max::MinMax
 
-pub fn vortex_array::arrays::BoolArray::try_new(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::min_max::MinMax
 
-pub fn vortex_array::arrays::BoolArray::try_new_from_handle(bits: vortex_array::buffer::BufferHandle, offset: usize, len: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::clone(&self) -> vortex_array::aggregate_fn::fns::min_max::MinMax
 
-pub fn vortex_array::arrays::BoolArray::validate(bits: &vortex_buffer::bit::buf::BitBuffer, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::min_max::MinMax
 
-impl vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BoolArray::patch(self, patches: &vortex_array::patches::Patches) -> vortex_error::VortexResult<Self>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::min_max::MinMax
 
-impl core::clone::Clone for vortex_array::arrays::BoolArray
+pub type vortex_array::aggregate_fn::fns::min_max::MinMax::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::BoolArray::clone(&self) -> vortex_array::arrays::BoolArray
+pub type vortex_array::aggregate_fn::fns::min_max::MinMax::Partial = vortex_array::aggregate_fn::fns::min_max::MinMaxPartial
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BoolArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::convert::From<vortex_array::arrays::BoolArray> for vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::BoolArray) -> vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::convert::From<vortex_buffer::bit::buf::BitBuffer> for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::BoolArray::from(value: vortex_buffer::bit::buf::BitBuffer) -> Self
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::fmt::Debug for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl core::iter::traits::collect::FromIterator<bool> for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::BoolArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = bool>>(iter: T) -> Self
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl core::iter::traits::collect::FromIterator<core::option::Option<bool>> for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::BoolArray::from_iter<I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<bool>>>(iter: I) -> Self
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl core::ops::deref::Deref for vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::BoolArray::Target = dyn vortex_array::Array
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolArray::deref(&self) -> &Self::Target
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-impl vortex_array::Executable for vortex_array::arrays::BoolArray
+pub struct vortex_array::aggregate_fn::fns::min_max::MinMaxPartial
 
-pub fn vortex_array::arrays::BoolArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-impl vortex_array::IntoArray for vortex_array::arrays::BoolArray
+pub vortex_array::aggregate_fn::fns::min_max::MinMaxResult::max: vortex_array::scalar::Scalar
 
-pub fn vortex_array::arrays::BoolArray::into_array(self) -> vortex_array::ArrayRef
+pub vortex_array::aggregate_fn::fns::min_max::MinMaxResult::min: vortex_array::scalar::Scalar
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::BoolArray
+impl vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-pub fn vortex_array::arrays::BoolArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMaxResult::from_scalar(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
 
-pub struct vortex_array::arrays::BoolArrayParts
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-pub vortex_array::arrays::BoolArrayParts::bits: vortex_array::buffer::BufferHandle
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMaxResult::clone(&self) -> vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-pub vortex_array::arrays::BoolArrayParts::len: usize
+impl core::cmp::Eq for vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-pub vortex_array::arrays::BoolArrayParts::offset: usize
+impl core::cmp::PartialEq for vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-pub vortex_array::arrays::BoolArrayParts::validity: vortex_array::validity::Validity
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMaxResult::eq(&self, other: &vortex_array::aggregate_fn::fns::min_max::MinMaxResult) -> bool
 
-pub struct vortex_array::arrays::BoolMaskedValidityRule
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-impl core::default::Default for vortex_array::arrays::BoolMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMaxResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::BoolMaskedValidityRule::default() -> vortex_array::arrays::BoolMaskedValidityRule
+impl core::marker::StructuralPartialEq for vortex_array::aggregate_fn::fns::min_max::MinMaxResult
 
-impl core::fmt::Debug for vortex_array::arrays::BoolMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::min_max::make_minmax_dtype(element_dtype: &vortex_array::dtype::DType) -> vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::BoolMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::fns::min_max::min_max(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::aggregate_fn::fns::min_max::MinMaxResult>>
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolMaskedValidityRule
+pub mod vortex_array::aggregate_fn::fns::nan_count
 
-pub type vortex_array::arrays::BoolMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub struct vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-pub fn vortex_array::arrays::BoolMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::BoolArray, parent: &vortex_array::arrays::MaskedArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-pub struct vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::clone(&self) -> vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-impl vortex_array::arrays::BoolVTable
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-pub const vortex_array::arrays::BoolVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::fmt::Debug for vortex_array::arrays::BoolVTable
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-pub fn vortex_array::arrays::BoolVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::aggregate_fn::fns::nan_count::NanCount::Options = vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::BoolVTable
+pub type vortex_array::aggregate_fn::fns::nan_count::NanCount::Partial = u64
 
-pub fn vortex_array::arrays::BoolVTable::filter(array: &vortex_array::arrays::BoolArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BoolVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::BoolVTable::take(array: &vortex_array::arrays::BoolArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::empty_partial(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::BoolVTable::is_constant(&self, array: &vortex_array::arrays::BoolArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::BoolVTable::is_sorted(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::BoolVTable::is_strict_sorted(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::BoolVTable::min_max(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolVTable::sum(&self, array: &vortex_array::arrays::BoolArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub type vortex_array::arrays::BoolMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::nan_count(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_array::arrays::BoolMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::BoolArray, parent: &vortex_array::arrays::MaskedArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub mod vortex_array::aggregate_fn::fns::sum
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::BoolVTable
+pub enum vortex_array::aggregate_fn::fns::sum::SumState
 
-pub fn vortex_array::arrays::BoolVTable::cast(array: &vortex_array::arrays::BoolArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub vortex_array::aggregate_fn::fns::sum::SumState::Decimal
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::BoolVTable
+pub vortex_array::aggregate_fn::fns::sum::SumState::Decimal::dtype: vortex_array::dtype::DecimalDType
 
-pub fn vortex_array::arrays::BoolVTable::fill_null(array: &vortex_array::arrays::BoolArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub vortex_array::aggregate_fn::fns::sum::SumState::Decimal::value: vortex_array::scalar::DecimalValue
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::BoolVTable
+pub vortex_array::aggregate_fn::fns::sum::SumState::Float(f64)
 
-pub fn vortex_array::arrays::BoolVTable::mask(array: &vortex_array::arrays::BoolArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub vortex_array::aggregate_fn::fns::sum::SumState::Signed(i64)
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+pub vortex_array::aggregate_fn::fns::sum::SumState::Unsigned(u64)
 
-pub fn vortex_array::arrays::BoolVTable::array_eq(array: &vortex_array::arrays::BoolArray, other: &vortex_array::arrays::BoolArray, precision: vortex_array::Precision) -> bool
+pub struct vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::BoolVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::BoolArray, state: &mut H, precision: vortex_array::Precision)
+impl core::clone::Clone for vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::BoolVTable::dtype(array: &vortex_array::arrays::BoolArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::clone(&self) -> vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::BoolVTable::len(array: &vortex_array::arrays::BoolArray) -> usize
+impl core::fmt::Debug for vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::BoolVTable::stats(array: &vortex_array::arrays::BoolArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::BoolVTable::scalar_at(array: &vortex_array::arrays::BoolArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::aggregate_fn::fns::sum::Sum::Options = vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::BoolVTable
+pub type vortex_array::aggregate_fn::fns::sum::Sum::Partial = vortex_array::aggregate_fn::fns::sum::SumPartial
 
-pub type vortex_array::arrays::BoolVTable::Array = vortex_array::arrays::BoolArray
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::BoolVTable::ArrayVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub type vortex_array::arrays::BoolVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::bool::vtable::BoolMetadata>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::BoolVTable::OperationsVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type vortex_array::arrays::BoolVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::empty_partial(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub type vortex_array::arrays::BoolVTable::VisitorVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::BoolVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::BoolArray>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::BoolVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::BoolVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BoolVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::BoolVTable::metadata(array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::BoolVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+pub struct vortex_array::aggregate_fn::fns::sum::SumPartial
 
-pub fn vortex_array::arrays::BoolVTable::nbuffers(_array: &vortex_array::arrays::BoolArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::sum::sum(array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::BoolVTable::nchildren(array: &vortex_array::arrays::BoolArray) -> usize
+pub mod vortex_array::aggregate_fn::kernels
 
-pub fn vortex_array::arrays::BoolVTable::nth_child(array: &vortex_array::arrays::BoolArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub trait vortex_array::aggregate_fn::kernels::DynAggregateKernel: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-pub fn vortex_array::arrays::BoolVTable::visit_buffers(array: &vortex_array::arrays::BoolArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::aggregate_fn::kernels::DynAggregateKernel::aggregate(&self, aggregate_fn: &vortex_array::aggregate_fn::AggregateFnRef, batch: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::Scalar>>
 
-pub fn vortex_array::arrays::BoolVTable::visit_children(array: &vortex_array::arrays::BoolArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub trait vortex_array::aggregate_fn::kernels::DynGroupedAggregateKernel: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-pub struct vortex_array::arrays::ChunkedArray
+pub fn vortex_array::aggregate_fn::kernels::DynGroupedAggregateKernel::grouped_aggregate(&self, aggregate_fn: &vortex_array::aggregate_fn::AggregateFnRef, groups: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::ChunkedArray
+pub fn vortex_array::aggregate_fn::kernels::DynGroupedAggregateKernel::grouped_aggregate_fixed_size(&self, aggregate_fn: &vortex_array::aggregate_fn::AggregateFnRef, groups: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedArray::array_iterator(&self) -> impl vortex_array::iter::ArrayIterator + '_
+pub mod vortex_array::aggregate_fn::proto
 
-pub fn vortex_array::arrays::ChunkedArray::array_stream(&self) -> impl vortex_array::stream::ArrayStream + '_
+pub mod vortex_array::aggregate_fn::session
 
-pub fn vortex_array::arrays::ChunkedArray::chunk(&self, idx: usize) -> &vortex_array::ArrayRef
+pub struct vortex_array::aggregate_fn::session::AggregateFnSession
 
-pub fn vortex_array::arrays::ChunkedArray::chunk_offsets(&self) -> vortex_buffer::buffer::Buffer<u64>
+impl vortex_array::aggregate_fn::session::AggregateFnSession
 
-pub fn vortex_array::arrays::ChunkedArray::chunks(&self) -> &[vortex_array::ArrayRef]
+pub fn vortex_array::aggregate_fn::session::AggregateFnSession::register<V: vortex_array::aggregate_fn::AggregateFnVTable>(&self, vtable: V)
 
-pub fn vortex_array::arrays::ChunkedArray::nchunks(&self) -> usize
+pub fn vortex_array::aggregate_fn::session::AggregateFnSession::register_aggregate_kernel(&self, array_id: vortex_array::ArrayId, agg_fn_id: core::option::Option<vortex_array::aggregate_fn::AggregateFnId>, kernel: &'static dyn vortex_array::aggregate_fn::kernels::DynAggregateKernel)
 
-pub unsafe fn vortex_array::arrays::ChunkedArray::new_unchecked(chunks: alloc::vec::Vec<vortex_array::ArrayRef>, dtype: vortex_array::dtype::DType) -> Self
+pub fn vortex_array::aggregate_fn::session::AggregateFnSession::registry(&self) -> &vortex_array::aggregate_fn::session::AggregateFnRegistry
 
-pub fn vortex_array::arrays::ChunkedArray::non_empty_chunks(&self) -> impl core::iter::traits::iterator::Iterator<Item = &vortex_array::ArrayRef> + '_
+impl core::default::Default for vortex_array::aggregate_fn::session::AggregateFnSession
 
-pub fn vortex_array::arrays::ChunkedArray::rechunk(&self, target_bytesize: u64, target_rowsize: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::session::AggregateFnSession::default() -> Self
 
-pub fn vortex_array::arrays::ChunkedArray::try_new(chunks: alloc::vec::Vec<vortex_array::ArrayRef>, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_array::aggregate_fn::session::AggregateFnSession
 
-pub fn vortex_array::arrays::ChunkedArray::validate(chunks: &[vortex_array::ArrayRef], dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+pub fn vortex_array::aggregate_fn::session::AggregateFnSession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::clone::Clone for vortex_array::arrays::ChunkedArray
+pub trait vortex_array::aggregate_fn::session::AggregateFnSessionExt: vortex_session::SessionExt
 
-pub fn vortex_array::arrays::ChunkedArray::clone(&self) -> vortex_array::arrays::ChunkedArray
+pub fn vortex_array::aggregate_fn::session::AggregateFnSessionExt::aggregate_fns(&self) -> vortex_session::Ref<'_, vortex_array::aggregate_fn::session::AggregateFnSession>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ChunkedArray
+impl<S: vortex_session::SessionExt> vortex_array::aggregate_fn::session::AggregateFnSessionExt for S
 
-pub fn vortex_array::arrays::ChunkedArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn S::aggregate_fns(&self) -> vortex_session::Ref<'_, vortex_array::aggregate_fn::session::AggregateFnSession>
 
-impl core::convert::From<vortex_array::arrays::ChunkedArray> for vortex_array::ArrayRef
+pub type vortex_array::aggregate_fn::session::AggregateFnRegistry = vortex_session::registry::Registry<vortex_array::aggregate_fn::AggregateFnPluginRef>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ChunkedArray) -> vortex_array::ArrayRef
+pub struct vortex_array::aggregate_fn::Accumulator<V: vortex_array::aggregate_fn::AggregateFnVTable>
 
-impl core::fmt::Debug for vortex_array::arrays::ChunkedArray
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::Accumulator<V>
 
-pub fn vortex_array::arrays::ChunkedArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::Accumulator<V>::try_new(vtable: V, options: <V as vortex_array::aggregate_fn::AggregateFnVTable>::Options, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
 
-impl core::iter::traits::collect::FromIterator<alloc::sync::Arc<dyn vortex_array::Array>> for vortex_array::arrays::ChunkedArray
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::DynAccumulator for vortex_array::aggregate_fn::Accumulator<V>
 
-pub fn vortex_array::arrays::ChunkedArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::ArrayRef>>(iter: T) -> Self
+pub fn vortex_array::aggregate_fn::Accumulator<V>::accumulate(&mut self, batch: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::ops::deref::Deref for vortex_array::arrays::ChunkedArray
+pub fn vortex_array::aggregate_fn::Accumulator<V>::finish(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::arrays::ChunkedArray::Target = dyn vortex_array::Array
+pub fn vortex_array::aggregate_fn::Accumulator<V>::flush(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ChunkedArray::deref(&self) -> &Self::Target
+pub fn vortex_array::aggregate_fn::Accumulator<V>::is_saturated(&self) -> bool
 
-impl vortex_array::IntoArray for vortex_array::arrays::ChunkedArray
+pub struct vortex_array::aggregate_fn::AggregateFn<V: vortex_array::aggregate_fn::AggregateFnVTable>(_)
 
-pub fn vortex_array::arrays::ChunkedArray::into_array(self) -> vortex_array::ArrayRef
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::AggregateFn<V>
 
-pub struct vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFn<V>::erased(self) -> vortex_array::aggregate_fn::AggregateFnRef
 
-impl vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFn<V>::new(vtable: V, options: <V as vortex_array::aggregate_fn::AggregateFnVTable>::Options) -> Self
 
-pub const vortex_array::arrays::ChunkedVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::AggregateFn<V>::options(&self) -> &<V as vortex_array::aggregate_fn::AggregateFnVTable>::Options
 
-impl core::fmt::Debug for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFn<V>::vtable(&self) -> &V
 
-pub fn vortex_array::arrays::ChunkedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::aggregate_fn::AggregateFnOptions<'a>
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::ChunkedVTable
+impl vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-pub fn vortex_array::arrays::ChunkedVTable::filter(array: &vortex_array::arrays::ChunkedArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'_>::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::arrays::SliceKernel for vortex_array::arrays::ChunkedVTable
+impl<'a> vortex_array::aggregate_fn::AggregateFnOptions<'a>
 
-pub fn vortex_array::arrays::ChunkedVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'a>::as_any(&self) -> &'a dyn core::any::Any
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ChunkedVTable
+impl core::cmp::Eq for vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-pub fn vortex_array::arrays::ChunkedVTable::take(array: &vortex_array::arrays::ChunkedArray, indices: &dyn vortex_array::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::cmp::PartialEq for vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'_>::eq(&self, other: &Self) -> bool
 
-pub fn vortex_array::arrays::ChunkedVTable::is_constant(&self, array: &vortex_array::arrays::ChunkedArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::fmt::Debug for vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ChunkedVTable::is_sorted(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::fmt::Display for vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-pub fn vortex_array::arrays::ChunkedVTable::is_strict_sorted(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ChunkedVTable
+impl core::hash::Hash for vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-pub fn vortex_array::arrays::ChunkedVTable::min_max(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::aggregate_fn::AggregateFnOptions<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ChunkedVTable
+pub struct vortex_array::aggregate_fn::AggregateFnRef(_)
 
-pub fn vortex_array::arrays::ChunkedVTable::sum(&self, array: &vortex_array::arrays::ChunkedArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::aggregate_fn::AggregateFnRef
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::accumulator(&self, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::aggregate_fn::AccumulatorRef>
 
-pub fn vortex_array::arrays::ChunkedVTable::cast(array: &vortex_array::arrays::ChunkedArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::accumulator_grouped(&self, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::aggregate_fn::GroupedAccumulatorRef>
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::as_<V: vortex_array::aggregate_fn::AggregateFnVTable>(&self) -> &<V as vortex_array::aggregate_fn::AggregateFnVTable>::Options
 
-pub fn vortex_array::arrays::ChunkedVTable::fill_null(array: &vortex_array::arrays::ChunkedArray, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::as_opt<V: vortex_array::aggregate_fn::AggregateFnVTable>(&self) -> core::option::Option<&<V as vortex_array::aggregate_fn::AggregateFnVTable>::Options>
 
-impl vortex_array::scalar_fn::fns::mask::MaskKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::coerce_args(&self, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ChunkedVTable::mask(array: &vortex_array::arrays::ChunkedArray, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::scalar_fn::fns::zip::ZipReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::is<V: vortex_array::aggregate_fn::AggregateFnVTable>(&self) -> bool
 
-pub fn vortex_array::arrays::ChunkedVTable::zip(if_true: &vortex_array::arrays::ChunkedArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::options(&self) -> vortex_array::aggregate_fn::AggregateFnOptions<'_>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::return_dtype(&self, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ChunkedVTable::array_eq(array: &vortex_array::arrays::ChunkedArray, other: &vortex_array::arrays::ChunkedArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::aggregate_fn::AggregateFnRef::state_dtype(&self, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ChunkedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ChunkedArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::aggregate_fn::AggregateFnRef::vtable_ref<V: vortex_array::aggregate_fn::AggregateFnVTable>(&self) -> core::option::Option<&V>
 
-pub fn vortex_array::arrays::ChunkedVTable::dtype(array: &vortex_array::arrays::ChunkedArray) -> &vortex_array::dtype::DType
+impl vortex_array::aggregate_fn::AggregateFnRef
 
-pub fn vortex_array::arrays::ChunkedVTable::len(array: &vortex_array::arrays::ChunkedArray) -> usize
+pub fn vortex_array::aggregate_fn::AggregateFnRef::from_proto(proto: &vortex_proto::expr::AggregateFn, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ChunkedVTable::stats(array: &vortex_array::arrays::ChunkedArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::AggregateFn>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+impl core::clone::Clone for vortex_array::aggregate_fn::AggregateFnRef
 
-pub fn vortex_array::arrays::ChunkedVTable::scalar_at(array: &vortex_array::arrays::ChunkedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::clone(&self) -> vortex_array::aggregate_fn::AggregateFnRef
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ChunkedVTable
+impl core::cmp::Eq for vortex_array::aggregate_fn::AggregateFnRef
 
-pub type vortex_array::arrays::ChunkedVTable::Array = vortex_array::arrays::ChunkedArray
+impl core::cmp::PartialEq for vortex_array::aggregate_fn::AggregateFnRef
 
-pub type vortex_array::arrays::ChunkedVTable::ArrayVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::eq(&self, other: &Self) -> bool
 
-pub type vortex_array::arrays::ChunkedVTable::Metadata = vortex_array::EmptyMetadata
+impl core::fmt::Debug for vortex_array::aggregate_fn::AggregateFnRef
 
-pub type vortex_array::arrays::ChunkedVTable::OperationsVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::ChunkedVTable::ValidityVTable = vortex_array::arrays::ChunkedVTable
+impl core::fmt::Display for vortex_array::aggregate_fn::AggregateFnRef
 
-pub type vortex_array::arrays::ChunkedVTable::VisitorVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::AggregateFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ChunkedVTable::append_to_builder(array: &vortex_array::arrays::ChunkedArray, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+impl core::hash::Hash for vortex_array::aggregate_fn::AggregateFnRef
 
-pub fn vortex_array::arrays::ChunkedVTable::build(dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ChunkedArray>
+pub fn vortex_array::aggregate_fn::AggregateFnRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::ChunkedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub struct vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::clone::Clone for vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::EmptyOptions::clone(&self) -> vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+impl core::cmp::Eq for vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::metadata(_array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<Self::Metadata>
+impl core::cmp::PartialEq for vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::EmptyOptions::eq(&self, other: &vortex_array::aggregate_fn::EmptyOptions) -> bool
 
-pub fn vortex_array::arrays::ChunkedVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::aggregate_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ChunkedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl core::fmt::Display for vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ChunkedVTable::validity(array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl core::hash::Hash for vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::aggregate_fn::EmptyOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::arrays::ChunkedVTable::nbuffers(_array: &vortex_array::arrays::ChunkedArray) -> usize
+impl core::marker::StructuralPartialEq for vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ChunkedVTable::nchildren(array: &vortex_array::arrays::ChunkedArray) -> usize
+pub struct vortex_array::aggregate_fn::GroupedAccumulator<V: vortex_array::aggregate_fn::AggregateFnVTable>
 
-pub fn vortex_array::arrays::ChunkedVTable::nth_child(array: &vortex_array::arrays::ChunkedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::GroupedAccumulator<V>
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_buffers(_array: &vortex_array::arrays::ChunkedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::try_new(vtable: V, options: <V as vortex_array::aggregate_fn::AggregateFnVTable>::Options, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_children(array: &vortex_array::arrays::ChunkedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::DynGroupedAccumulator for vortex_array::aggregate_fn::GroupedAccumulator<V>
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_children_unnamed(array: &vortex_array::arrays::ChunkedArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::accumulate_list(&mut self, groups: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::finish(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::flush(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ConstantArray::into_parts(self) -> vortex_array::scalar::Scalar
+pub trait vortex_array::aggregate_fn::AggregateFnPlugin: 'static + core::marker::Send + core::marker::Sync
 
-pub fn vortex_array::arrays::ConstantArray::new<S>(scalar: S, len: usize) -> Self where S: core::convert::Into<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::AggregateFnPlugin::deserialize(&self, metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::aggregate_fn::AggregateFnRef>
 
-pub fn vortex_array::arrays::ConstantArray::scalar(&self) -> &vortex_array::scalar::Scalar
+pub fn vortex_array::aggregate_fn::AggregateFnPlugin::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl core::clone::Clone for vortex_array::arrays::ConstantArray
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::AggregateFnPlugin for V
 
-pub fn vortex_array::arrays::ConstantArray::clone(&self) -> vortex_array::arrays::ConstantArray
+pub fn V::deserialize(&self, metadata: &[u8], session: &vortex_session::VortexSession) -> core::result::Result<vortex_array::aggregate_fn::AggregateFnRef, vortex_error::VortexError>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ConstantArray
+pub fn V::id(&self) -> arcref::ArcRef<str>
 
-pub fn vortex_array::arrays::ConstantArray::as_ref(&self) -> &dyn vortex_array::Array
+pub trait vortex_array::aggregate_fn::AggregateFnVTable: 'static + core::marker::Sized + core::clone::Clone + core::marker::Send + core::marker::Sync
 
-impl core::convert::From<vortex_array::arrays::ConstantArray> for vortex_array::ArrayRef
+pub type vortex_array::aggregate_fn::AggregateFnVTable::Options: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + core::cmp::PartialEq + core::cmp::Eq + core::hash::Hash
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ConstantArray) -> vortex_array::ArrayRef
+pub type vortex_array::aggregate_fn::AggregateFnVTable::Partial: 'static + core::marker::Send
 
-impl core::fmt::Debug for vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::accumulate(&self, state: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ConstantArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::ops::deref::Deref for vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ConstantArray::Target = dyn vortex_array::Array
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::ConstantArray::deref(&self) -> &Self::Target
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::empty_partial(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl vortex_array::IntoArray for vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::finalize(&self, states: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ConstantArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::is_saturated(&self, state: &Self::Partial) -> bool
 
-pub const vortex_array::arrays::ConstantVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::reset(&self, partial: &mut Self::Partial)
 
-pub const vortex_array::arrays::ConstantVTable::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::return_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl core::fmt::Debug for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ConstantVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::AggregateFnVTable::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::ConstantVTable::filter(array: &vortex_array::arrays::ConstantArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::count::Count
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ConstantVTable
+pub type vortex_array::aggregate_fn::fns::count::Count::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ConstantVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::aggregate_fn::fns::count::Count::Partial = u64
 
-impl vortex_array::arrays::TakeReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ConstantVTable::take(array: &vortex_array::arrays::ConstantArray, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::count::Count::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ConstantVTable::min_max(&self, array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::aggregate_fn::fns::count::Count::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::empty_partial(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::ConstantVTable::sum(&self, array: &vortex_array::arrays::ConstantArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::count::Count::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ConstantVTable::cast(array: &vortex_array::arrays::ConstantArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::count::Count::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::ConstantVTable::fill_null(array: &vortex_array::arrays::ConstantArray, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::count::Count::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::scalar_fn::fns::not::NotReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::ConstantVTable::invert(array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::count::Count::return_dtype(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::count::Count::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ConstantVTable::array_eq(array: &vortex_array::arrays::ConstantArray, other: &vortex_array::arrays::ConstantArray, _precision: vortex_array::Precision) -> bool
+pub fn vortex_array::aggregate_fn::fns::count::Count::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ConstantVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ConstantArray, state: &mut H, _precision: vortex_array::Precision)
+pub fn vortex_array::aggregate_fn::fns::count::Count::try_accumulate(&self, state: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::ConstantVTable::dtype(array: &vortex_array::arrays::ConstantArray) -> &vortex_array::dtype::DType
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::first::First
 
-pub fn vortex_array::arrays::ConstantVTable::len(array: &vortex_array::arrays::ConstantArray) -> usize
+pub type vortex_array::aggregate_fn::fns::first::First::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::ConstantVTable::stats(array: &vortex_array::arrays::ConstantArray) -> vortex_array::stats::StatsSetRef<'_>
+pub type vortex_array::aggregate_fn::fns::first::First::Partial = vortex_array::aggregate_fn::fns::first::FirstPartial
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ConstantVTable::scalar_at(array: &vortex_array::arrays::ConstantArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::first::First::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ConstantVTable::Array = vortex_array::arrays::ConstantArray
+pub fn vortex_array::aggregate_fn::fns::first::First::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type vortex_array::arrays::ConstantVTable::ArrayVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub type vortex_array::arrays::ConstantVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::aggregate_fn::fns::first::First::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::ConstantVTable::OperationsVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::arrays::ConstantVTable::ValidityVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub type vortex_array::arrays::ConstantVTable::VisitorVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::first::First::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::ConstantVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ConstantArray>
+pub fn vortex_array::aggregate_fn::fns::first::First::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ConstantVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::first::First::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::ConstantVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::fns::first::First::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ConstantVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::first::First::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ConstantVTable::metadata(_array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::first::First::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ConstantVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::first::First::try_accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::ConstantVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::is_constant::IsConstant
 
-pub fn vortex_array::arrays::ConstantVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::aggregate_fn::fns::is_constant::IsConstant::Options = vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub type vortex_array::aggregate_fn::fns::is_constant::IsConstant::Partial = vortex_array::aggregate_fn::fns::is_constant::IsConstantPartial
 
-pub fn vortex_array::arrays::ConstantVTable::validity(array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::ConstantVTable::nbuffers(_array: &vortex_array::arrays::ConstantArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ConstantVTable::nchildren(_array: &vortex_array::arrays::ConstantArray) -> usize
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::ConstantVTable::nth_child(_array: &vortex_array::arrays::ConstantArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::ConstantVTable::visit_buffers(array: &vortex_array::arrays::ConstantArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ConstantVTable::visit_children(_array: &vortex_array::arrays::ConstantArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::DecimalArray::buffer<T: vortex_array::dtype::NativeDecimalType>(&self) -> vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::partial_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalArray::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::DecimalArray::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalArray::from_iter<T: vortex_array::dtype::NativeDecimalType, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DecimalArray::from_option_iter<T: vortex_array::dtype::NativeDecimalType, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalArray::into_parts(self) -> vortex_array::arrays::DecimalArrayParts
+pub fn vortex_array::aggregate_fn::fns::is_constant::IsConstant::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DecimalArray::new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::is_sorted::IsSorted
 
-pub fn vortex_array::arrays::DecimalArray::new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
+pub type vortex_array::aggregate_fn::fns::is_sorted::IsSorted::Options = vortex_array::aggregate_fn::fns::is_sorted::IsSortedOptions
 
-pub unsafe fn vortex_array::arrays::DecimalArray::new_unchecked<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
+pub type vortex_array::aggregate_fn::fns::is_sorted::IsSorted::Partial = vortex_array::aggregate_fn::fns::is_sorted::IsSortedPartial
 
-pub unsafe fn vortex_array::arrays::DecimalArray::new_unchecked_from_byte_buffer(byte_buffer: vortex_buffer::ByteBuffer, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub unsafe fn vortex_array::arrays::DecimalArray::new_unchecked_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalArray::patch(self, patches: &vortex_array::patches::Patches) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DecimalArray::precision(&self) -> u8
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::DecimalArray::scale(&self) -> i8
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::empty_partial(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub fn vortex_array::arrays::DecimalArray::try_new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DecimalArray::try_new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalArray::values_type(&self) -> vortex_array::dtype::DecimalType
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-impl core::clone::Clone for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub fn vortex_array::arrays::DecimalArray::clone(&self) -> vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::partial_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::DecimalArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-impl core::convert::From<vortex_array::arrays::DecimalArray> for vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::DecimalArray) -> vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::fmt::Debug for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::is_sorted::IsSorted::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DecimalArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::last::Last
 
-impl core::ops::deref::Deref for vortex_array::arrays::DecimalArray
+pub type vortex_array::aggregate_fn::fns::last::Last::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub type vortex_array::arrays::DecimalArray::Target = dyn vortex_array::Array
+pub type vortex_array::aggregate_fn::fns::last::Last::Partial = vortex_array::aggregate_fn::fns::last::LastPartial
 
-pub fn vortex_array::arrays::DecimalArray::deref(&self) -> &Self::Target
+pub fn vortex_array::aggregate_fn::fns::last::Last::accumulate(&self, _partial: &mut Self::Partial, _batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::Executable for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::fns::last::Last::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl vortex_array::IntoArray for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::DecimalArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::fns::last::Last::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::last::Last::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DecimalArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::aggregate_fn::fns::last::Last::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::DecimalArrayParts
+pub fn vortex_array::aggregate_fn::fns::last::Last::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub vortex_array::arrays::DecimalArrayParts::decimal_dtype: vortex_array::dtype::DecimalDType
+pub fn vortex_array::aggregate_fn::fns::last::Last::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-pub vortex_array::arrays::DecimalArrayParts::validity: vortex_array::validity::Validity
+pub fn vortex_array::aggregate_fn::fns::last::Last::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub vortex_array::arrays::DecimalArrayParts::values: vortex_array::buffer::BufferHandle
+pub fn vortex_array::aggregate_fn::fns::last::Last::reset(&self, partial: &mut Self::Partial)
 
-pub vortex_array::arrays::DecimalArrayParts::values_type: vortex_array::dtype::DecimalType
+pub fn vortex_array::aggregate_fn::fns::last::Last::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub struct vortex_array::arrays::DecimalMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::last::Last::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::default::Default for vortex_array::arrays::DecimalMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::last::Last::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalMaskedValidityRule::default() -> vortex_array::arrays::DecimalMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::last::Last::try_accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-impl core::fmt::Debug for vortex_array::arrays::DecimalMaskedValidityRule
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::min_max::MinMax
 
-pub fn vortex_array::arrays::DecimalMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::aggregate_fn::fns::min_max::MinMax::Options = vortex_array::aggregate_fn::EmptyOptions
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalMaskedValidityRule
+pub type vortex_array::aggregate_fn::fns::min_max::MinMax::Partial = vortex_array::aggregate_fn::fns::min_max::MinMaxPartial
 
-pub type vortex_array::arrays::DecimalMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DecimalMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::DecimalArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub struct vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub const vortex_array::arrays::DecimalVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::empty_partial(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl core::fmt::Debug for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DecimalVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::DecimalVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::take(array: &vortex_array::arrays::DecimalArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::reset(&self, partial: &mut Self::Partial)
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::is_constant(&self, array: &vortex_array::arrays::DecimalArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalVTable::is_sorted(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::aggregate_fn::fns::min_max::MinMax::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DecimalVTable::is_strict_sorted(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::nan_count::NanCount
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::DecimalVTable
+pub type vortex_array::aggregate_fn::fns::nan_count::NanCount::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::DecimalVTable::min_max(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub type vortex_array::aggregate_fn::fns::nan_count::NanCount::Partial = u64
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DecimalVTable::sum(&self, array: &vortex_array::arrays::DecimalArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalMaskedValidityRule
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::DecimalMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::arrays::DecimalMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::DecimalArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::empty_partial(&self, _options: &Self::Options, _input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DecimalVTable::between(arr: &vortex_array::arrays::DecimalArray, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub fn vortex_array::arrays::DecimalVTable::cast(array: &vortex_array::arrays::DecimalArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::is_saturated(&self, _partial: &Self::Partial) -> bool
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::fill_null(array: &vortex_array::arrays::DecimalArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::reset(&self, partial: &mut Self::Partial)
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::mask(array: &vortex_array::arrays::DecimalArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalVTable::array_eq(array: &vortex_array::arrays::DecimalArray, other: &vortex_array::arrays::DecimalArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::aggregate_fn::fns::nan_count::NanCount::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DecimalVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::DecimalArray, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::aggregate_fn::AggregateFnVTable for vortex_array::aggregate_fn::fns::sum::Sum
 
-pub fn vortex_array::arrays::DecimalVTable::dtype(array: &vortex_array::arrays::DecimalArray) -> &vortex_array::dtype::DType
+pub type vortex_array::aggregate_fn::fns::sum::Sum::Options = vortex_array::aggregate_fn::EmptyOptions
 
-pub fn vortex_array::arrays::DecimalVTable::len(array: &vortex_array::arrays::DecimalArray) -> usize
+pub type vortex_array::aggregate_fn::fns::sum::Sum::Partial = vortex_array::aggregate_fn::fns::sum::SumPartial
 
-pub fn vortex_array::arrays::DecimalVTable::stats(array: &vortex_array::arrays::DecimalArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::accumulate(&self, partial: &mut Self::Partial, batch: &vortex_array::Columnar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::coerce_args(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::scalar_at(array: &vortex_array::arrays::DecimalArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::combine_partials(&self, partial: &mut Self::Partial, other: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type vortex_array::arrays::DecimalVTable::Array = vortex_array::arrays::DecimalArray
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::empty_partial(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self::Partial>
 
-pub type vortex_array::arrays::DecimalVTable::ArrayVTable = vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::finalize(&self, partials: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::DecimalVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::decimal::vtable::DecimalMetadata>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::finalize_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::arrays::DecimalVTable::OperationsVTable = vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::id(&self) -> vortex_array::aggregate_fn::AggregateFnId
 
-pub type vortex_array::arrays::DecimalVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::is_saturated(&self, partial: &Self::Partial) -> bool
 
-pub type vortex_array::arrays::DecimalVTable::VisitorVTable = vortex_array::arrays::DecimalVTable
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::partial_dtype(&self, options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::DecimalArray>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::reset(&self, partial: &mut Self::Partial)
 
-pub fn vortex_array::arrays::DecimalVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::return_dtype(&self, _options: &Self::Options, input_dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
 
-pub fn vortex_array::arrays::DecimalVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DecimalVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::to_scalar(&self, partial: &Self::Partial) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::aggregate_fn::fns::sum::Sum::try_accumulate(&self, _state: &mut Self::Partial, _batch: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::arrays::DecimalVTable::metadata(array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<Self::Metadata>
+pub trait vortex_array::aggregate_fn::AggregateFnVTableExt: vortex_array::aggregate_fn::AggregateFnVTable
 
-pub fn vortex_array::arrays::DecimalVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::aggregate_fn::AggregateFnVTableExt::bind(&self, options: Self::Options) -> vortex_array::aggregate_fn::AggregateFnRef
 
-pub fn vortex_array::arrays::DecimalVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::AggregateFnVTableExt for V
 
-pub fn vortex_array::arrays::DecimalVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn V::bind(&self, options: Self::Options) -> vortex_array::aggregate_fn::AggregateFnRef
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub trait vortex_array::aggregate_fn::DynAccumulator: 'static + core::marker::Send
 
-pub fn vortex_array::arrays::DecimalVTable::nbuffers(_array: &vortex_array::arrays::DecimalArray) -> usize
+pub fn vortex_array::aggregate_fn::DynAccumulator::accumulate(&mut self, batch: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DecimalVTable::nchildren(array: &vortex_array::arrays::DecimalArray) -> usize
+pub fn vortex_array::aggregate_fn::DynAccumulator::finish(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalVTable::nth_child(array: &vortex_array::arrays::DecimalArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::aggregate_fn::DynAccumulator::flush(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DecimalVTable::visit_buffers(array: &vortex_array::arrays::DecimalArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::aggregate_fn::DynAccumulator::is_saturated(&self) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::visit_children(array: &vortex_array::arrays::DecimalArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::DynAccumulator for vortex_array::aggregate_fn::Accumulator<V>
 
-pub struct vortex_array::arrays::DictArray
+pub fn vortex_array::aggregate_fn::Accumulator<V>::accumulate(&mut self, batch: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::DictArray
+pub fn vortex_array::aggregate_fn::Accumulator<V>::finish(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DictArray::codes(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::Accumulator<V>::flush(&mut self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::DictArray::compute_referenced_values_mask(&self, referenced: bool) -> vortex_error::VortexResult<vortex_buffer::bit::buf::BitBuffer>
+pub fn vortex_array::aggregate_fn::Accumulator<V>::is_saturated(&self) -> bool
 
-pub fn vortex_array::arrays::DictArray::has_all_values_referenced(&self) -> bool
+pub trait vortex_array::aggregate_fn::DynGroupedAccumulator: 'static + core::marker::Send
 
-pub fn vortex_array::arrays::DictArray::into_parts(self) -> vortex_array::arrays::DictArrayParts
+pub fn vortex_array::aggregate_fn::DynGroupedAccumulator::accumulate_list(&mut self, groups: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictArray::new(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> Self
+pub fn vortex_array::aggregate_fn::DynGroupedAccumulator::finish(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub unsafe fn vortex_array::arrays::DictArray::new_unchecked(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> Self
+pub fn vortex_array::aggregate_fn::DynGroupedAccumulator::flush(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub unsafe fn vortex_array::arrays::DictArray::set_all_values_referenced(self, all_values_referenced: bool) -> Self
+impl<V: vortex_array::aggregate_fn::AggregateFnVTable> vortex_array::aggregate_fn::DynGroupedAccumulator for vortex_array::aggregate_fn::GroupedAccumulator<V>
 
-pub fn vortex_array::arrays::DictArray::try_new(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::accumulate_list(&mut self, groups: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictArray::validate_all_values_referenced(&self) -> vortex_error::VortexResult<()>
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::finish(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::DictArray::values(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::aggregate_fn::GroupedAccumulator<V>::flush(&mut self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::clone::Clone for vortex_array::arrays::DictArray
+pub type vortex_array::aggregate_fn::AccumulatorRef = alloc::boxed::Box<dyn vortex_array::aggregate_fn::DynAccumulator>
 
-pub fn vortex_array::arrays::DictArray::clone(&self) -> vortex_array::arrays::DictArray
+pub type vortex_array::aggregate_fn::AggregateFnId = arcref::ArcRef<str>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::DictArray
+pub type vortex_array::aggregate_fn::AggregateFnPluginRef = alloc::sync::Arc<dyn vortex_array::aggregate_fn::AggregateFnPlugin>
 
-pub fn vortex_array::arrays::DictArray::as_ref(&self) -> &dyn vortex_array::Array
+pub type vortex_array::aggregate_fn::GroupedAccumulatorRef = alloc::boxed::Box<dyn vortex_array::aggregate_fn::DynGroupedAccumulator>
 
-impl core::convert::From<vortex_array::arrays::DictArray> for vortex_array::ArrayRef
+pub mod vortex_array::arrays
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::DictArray) -> vortex_array::ArrayRef
+pub mod vortex_array::arrays::bool
 
-impl core::fmt::Debug for vortex_array::arrays::DictArray
+pub struct vortex_array::arrays::bool::Bool
 
-pub fn vortex_array::arrays::DictArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::Bool
 
-impl core::ops::deref::Deref for vortex_array::arrays::DictArray
+pub const vortex_array::arrays::Bool::ID: vortex_array::ArrayId
 
-pub type vortex_array::arrays::DictArray::Target = dyn vortex_array::Array
+impl core::clone::Clone for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::Bool::clone(&self) -> vortex_array::arrays::Bool
 
-impl vortex_array::IntoArray for vortex_array::arrays::DictArray
+impl core::fmt::Debug for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<K: arrow_array::types::ArrowDictionaryKeyType> vortex_array::arrow::FromArrowArray<&arrow_array::array::dictionary_array::DictionaryArray<K>> for vortex_array::arrays::DictArray
+impl vortex_array::OperationsVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictArray::from_arrow(array: &arrow_array::array::dictionary_array::DictionaryArray<K>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Bool::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::DictArrayParts
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-pub vortex_array::arrays::DictArrayParts::codes: vortex_array::ArrayRef
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-pub vortex_array::arrays::DictArrayParts::dtype: vortex_array::dtype::DType
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-pub vortex_array::arrays::DictArrayParts::values: vortex_array::ArrayRef
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-pub struct vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::DictMetadata::all_values_referenced(&self) -> bool
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::DictMetadata::codes_ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::DictMetadata::is_nullable_codes(&self) -> bool
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::DictMetadata::set_codes_ptype(&mut self, value: vortex_array::dtype::PType)
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::clone::Clone for vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::DictMetadata::clone(&self) -> vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::default::Default for vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::DictMetadata::default() -> Self
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::DictMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl prost::message::Message for vortex_array::arrays::DictMetadata
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DictMetadata::clear(&mut self)
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DictMetadata::encoded_len(&self) -> usize
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::DictVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub const vortex_array::arrays::DictVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Bool::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Debug for vortex_array::arrays::DictVTable
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::DictVTable
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictVTable::filter(array: &vortex_array::arrays::DictArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Bool::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::DictVTable
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Bool::slice(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::DictVTable
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Bool> for vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub fn vortex_array::arrays::DictVTable::take(array: &vortex_array::arrays::DictArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::bool::BoolMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DictVTable::is_constant(&self, array: &vortex_array::arrays::DictArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Bool
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::Bool::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DictVTable::is_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictVTable::is_strict_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::Bool::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::DictVTable
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::DictVTable::min_max(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::Bool::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::DictVTable
+pub struct vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::arrays::DictVTable::compare(lhs: &vortex_array::arrays::DictArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::bool::BoolData
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolData::into_parts(self, len: usize) -> vortex_array::arrays::bool::BoolDataParts
 
-pub fn vortex_array::arrays::DictVTable::cast(array: &vortex_array::arrays::DictArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::arrays::bool::BoolData
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolData::clone(&self) -> vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::arrays::DictVTable::fill_null(array: &vortex_array::arrays::DictArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::arrays::bool::BoolData
 
-impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::DictVTable::like(array: &vortex_array::arrays::DictArray, pattern: &dyn vortex_array::Array, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Display for vortex_array::arrays::bool::BoolData
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::DictVTable::mask(array: &vortex_array::arrays::DictArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ArrayEq for vortex_array::arrays::bool::BoolData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DictVTable::array_eq(array: &vortex_array::arrays::DictArray, other: &vortex_array::arrays::DictArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::arrays::DictVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::DictArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::bool::BoolData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::DictVTable::dtype(array: &vortex_array::arrays::DictArray) -> &vortex_array::dtype::DType
+pub struct vortex_array::arrays::bool::BoolDataParts
 
-pub fn vortex_array::arrays::DictVTable::len(array: &vortex_array::arrays::DictArray) -> usize
+pub vortex_array::arrays::bool::BoolDataParts::bits: vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::DictVTable::stats(array: &vortex_array::arrays::DictArray) -> vortex_array::stats::StatsSetRef<'_>
+pub vortex_array::arrays::bool::BoolDataParts::len: usize
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub vortex_array::arrays::bool::BoolDataParts::offset: usize
 
-pub fn vortex_array::arrays::DictVTable::scalar_at(array: &vortex_array::arrays::DictArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub struct vortex_array::arrays::bool::BoolMaskedValidityRule
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::DictVTable
+impl core::default::Default for vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub type vortex_array::arrays::DictVTable::Array = vortex_array::arrays::DictArray
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::default() -> vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub type vortex_array::arrays::DictVTable::ArrayVTable = vortex_array::arrays::DictVTable
+impl core::fmt::Debug for vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub type vortex_array::arrays::DictVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::DictMetadata>
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::DictVTable::OperationsVTable = vortex_array::arrays::DictVTable
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Bool> for vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub type vortex_array::arrays::DictVTable::ValidityVTable = vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::bool::BoolMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-pub type vortex_array::arrays::DictVTable::VisitorVTable = vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DictVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::DictArray>
+pub trait vortex_array::arrays::bool::BoolArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Bool>
 
-pub fn vortex_array::arrays::DictVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::bool::BoolArrayExt::bool_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::bool::BoolArrayExt::maybe_to_mask(&self) -> vortex_error::VortexResult<core::option::Option<vortex_mask::Mask>>
 
-pub fn vortex_array::arrays::DictVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::bool::BoolArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::DictVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::bool::BoolArrayExt::to_bit_buffer(&self) -> vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::arrays::DictVTable::metadata(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::bool::BoolArrayExt::to_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::bool::BoolArrayExt::to_mask_fill_null_false(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::bool::BoolArrayExt::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::DictVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Bool>> vortex_array::arrays::bool::BoolArrayExt for T
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn T::bool_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::validity(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn T::maybe_to_mask(&self) -> vortex_error::VortexResult<core::option::Option<vortex_mask::Mask>>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::DictVTable::nbuffers(_array: &vortex_array::arrays::DictArray) -> usize
+pub fn T::to_bit_buffer(&self) -> vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::arrays::DictVTable::nchildren(_array: &vortex_array::arrays::DictArray) -> usize
+pub fn T::to_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::nth_child(array: &vortex_array::arrays::DictArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn T::to_mask_fill_null_false(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::DictVTable::visit_buffers(_array: &vortex_array::arrays::DictArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn T::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::DictVTable::visit_children(array: &vortex_array::arrays::DictArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub type vortex_array::arrays::bool::BoolArray = vortex_array::Array<vortex_array::arrays::Bool>
 
-pub struct vortex_array::arrays::ExactScalarFn<F: vortex_array::scalar_fn::ScalarFnVTable>(_)
+pub mod vortex_array::arrays::chunked
 
-impl<F: core::default::Default + vortex_array::scalar_fn::ScalarFnVTable> core::default::Default for vortex_array::arrays::ExactScalarFn<F>
+pub struct vortex_array::arrays::chunked::Chunked
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::default() -> vortex_array::arrays::ExactScalarFn<F>
+impl vortex_array::arrays::Chunked
 
-impl<F: core::fmt::Debug + vortex_array::scalar_fn::ScalarFnVTable> core::fmt::Debug for vortex_array::arrays::ExactScalarFn<F>
+pub const vortex_array::arrays::Chunked::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_array::arrays::Chunked
 
-impl<F: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::matcher::Matcher for vortex_array::arrays::ExactScalarFn<F>
+pub fn vortex_array::arrays::Chunked::clone(&self) -> vortex_array::arrays::Chunked
 
-pub type vortex_array::arrays::ExactScalarFn<F>::Match<'a> = vortex_array::arrays::ScalarFnArrayView<'a, F>
+impl core::fmt::Debug for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::matches(array: &dyn vortex_array::Array) -> bool
+pub fn vortex_array::arrays::Chunked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub struct vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::ExtensionArray
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionArray::ext_dtype(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionArray::id(&self) -> vortex_array::dtype::extension::ExtId
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionArray::new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage: vortex_array::ArrayRef) -> Self
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionArray::storage(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::clone::Clone for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ExtensionArray::clone(&self) -> vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ExtensionArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::convert::From<&vortex_array::arrays::TemporalArray> for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ExtensionArray::from(value: &vortex_array::arrays::TemporalArray) -> Self
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::convert::From<vortex_array::arrays::ExtensionArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ExtensionArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-impl core::convert::From<vortex_array::arrays::TemporalArray> for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ExtensionArray::from(value: vortex_array::arrays::TemporalArray) -> Self
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::convert::TryFrom<vortex_array::arrays::ExtensionArray> for vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::TemporalArray::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::TemporalArray::try_from(ext: vortex_array::arrays::ExtensionArray) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::fmt::Debug for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ExtensionArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl core::ops::deref::Deref for vortex_array::arrays::ExtensionArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub type vortex_array::arrays::ExtensionArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::Chunked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ExtensionArray::deref(&self) -> &Self::Target
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Chunked
 
-impl vortex_array::Executable for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ExtensionArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::Chunked
 
-impl vortex_array::IntoArray for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Chunked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ExtensionArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceKernel for vortex_array::arrays::Chunked
 
-pub struct vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Chunked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::ExtensionVTable
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Chunked
 
-pub const vortex_array::arrays::ExtensionVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Chunked::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::arrays::ExtensionVTable
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Chunked::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::ExtensionVTable
+impl vortex_array::scalar_fn::fns::mask::MaskKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionVTable::filter(array: &vortex_array::arrays::ExtensionArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ExtensionVTable
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::ExtensionVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ExtensionVTable
+pub struct vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::take(array: &vortex_array::arrays::ExtensionArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::chunked::ChunkedData
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::chunked::ChunkedData::validate(chunks: &[vortex_array::ArrayRef], dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionVTable::is_constant(&self, array: &vortex_array::arrays::ExtensionArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::clone::Clone for vortex_array::arrays::chunked::ChunkedData
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::chunked::ChunkedData::clone(&self) -> vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::is_sorted(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::fmt::Debug for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::is_strict_sorted(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::chunked::ChunkedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ExtensionVTable
+impl core::fmt::Display for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::min_max(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::chunked::ChunkedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ExtensionVTable
+impl vortex_array::ArrayEq for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::sum(&self, array: &vortex_array::arrays::ExtensionArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::chunked::ChunkedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::ExtensionVTable
+impl vortex_array::ArrayHash for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::ExtensionVTable::compare(lhs: &vortex_array::arrays::ExtensionArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::chunked::ChunkedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ExtensionVTable
+pub trait vortex_array::arrays::chunked::ChunkedArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Chunked>
 
-pub fn vortex_array::arrays::ExtensionVTable::cast(array: &vortex_array::arrays::ExtensionArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::array_iterator(&self) -> impl vortex_array::iter::ArrayIterator + '_
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::array_stream(&self) -> impl vortex_array::stream::ArrayStream + '_
 
-pub fn vortex_array::arrays::ExtensionVTable::mask(array: &vortex_array::arrays::ExtensionArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::chunk(&self, idx: usize) -> &vortex_array::ArrayRef
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::chunk_offsets(&self) -> &[usize]
 
-pub fn vortex_array::arrays::ExtensionVTable::array_eq(array: &vortex_array::arrays::ExtensionArray, other: &vortex_array::arrays::ExtensionArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::chunk_offsets_array(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ExtensionVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ExtensionArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::chunks(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ExtensionVTable::dtype(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::find_chunk_idx(&self, index: usize) -> vortex_error::VortexResult<(usize, usize)>
 
-pub fn vortex_array::arrays::ExtensionVTable::len(array: &vortex_array::arrays::ExtensionArray) -> usize
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::iter_chunks<'a>(&'a self) -> alloc::boxed::Box<(dyn core::iter::traits::iterator::Iterator<Item = &'a vortex_array::ArrayRef> + 'a)>
 
-pub fn vortex_array::arrays::ExtensionVTable::stats(array: &vortex_array::arrays::ExtensionArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::nchunks(&self) -> usize
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::chunked::ChunkedArrayExt::non_empty_chunks<'a>(&'a self) -> alloc::boxed::Box<(dyn core::iter::traits::iterator::Iterator<Item = &'a vortex_array::ArrayRef> + 'a)>
 
-pub fn vortex_array::arrays::ExtensionVTable::scalar_at(array: &vortex_array::arrays::ExtensionArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Chunked>> vortex_array::arrays::chunked::ChunkedArrayExt for T
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ExtensionVTable
+pub fn T::array_iterator(&self) -> impl vortex_array::iter::ArrayIterator + '_
 
-pub type vortex_array::arrays::ExtensionVTable::Array = vortex_array::arrays::ExtensionArray
+pub fn T::array_stream(&self) -> impl vortex_array::stream::ArrayStream + '_
 
-pub type vortex_array::arrays::ExtensionVTable::ArrayVTable = vortex_array::arrays::ExtensionVTable
+pub fn T::chunk(&self, idx: usize) -> &vortex_array::ArrayRef
 
-pub type vortex_array::arrays::ExtensionVTable::Metadata = vortex_array::EmptyMetadata
+pub fn T::chunk_offsets(&self) -> &[usize]
 
-pub type vortex_array::arrays::ExtensionVTable::OperationsVTable = vortex_array::arrays::ExtensionVTable
+pub fn T::chunk_offsets_array(&self) -> &vortex_array::ArrayRef
 
-pub type vortex_array::arrays::ExtensionVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromChild
+pub fn T::chunks(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::ExtensionVTable::VisitorVTable = vortex_array::arrays::ExtensionVTable
+pub fn T::find_chunk_idx(&self, index: usize) -> vortex_error::VortexResult<(usize, usize)>
 
-pub fn vortex_array::arrays::ExtensionVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ExtensionArray>
+pub fn T::iter_chunks<'a>(&'a self) -> alloc::boxed::Box<(dyn core::iter::traits::iterator::Iterator<Item = &'a vortex_array::ArrayRef> + 'a)>
 
-pub fn vortex_array::arrays::ExtensionVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn T::nchunks(&self) -> usize
 
-pub fn vortex_array::arrays::ExtensionVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn T::non_empty_chunks<'a>(&'a self) -> alloc::boxed::Box<(dyn core::iter::traits::iterator::Iterator<Item = &'a vortex_array::ArrayRef> + 'a)>
 
-pub fn vortex_array::arrays::ExtensionVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::chunked::ChunkedArray = vortex_array::Array<vortex_array::arrays::Chunked>
 
-pub fn vortex_array::arrays::ExtensionVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub mod vortex_array::arrays::constant
 
-pub fn vortex_array::arrays::ExtensionVTable::metadata(_array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<Self::Metadata>
+pub struct vortex_array::arrays::constant::Constant
 
-pub fn vortex_array::arrays::ExtensionVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::ExtensionVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub const vortex_array::arrays::Constant::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ExtensionVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl vortex_array::arrays::Constant
 
-impl vortex_array::vtable::ValidityChild<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub const vortex_array::arrays::Constant::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
-pub fn vortex_array::arrays::ExtensionVTable::validity_child(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::ArrayRef
+impl core::clone::Clone for vortex_array::arrays::Constant
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Constant::clone(&self) -> vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::ExtensionVTable::nbuffers(_array: &vortex_array::arrays::ExtensionArray) -> usize
+impl core::fmt::Debug for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::ExtensionVTable::nchildren(_array: &vortex_array::arrays::ExtensionArray) -> usize
+pub fn vortex_array::arrays::Constant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ExtensionVTable::nth_child(array: &vortex_array::arrays::ExtensionArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::ExtensionVTable::visit_buffers(_array: &vortex_array::arrays::ExtensionArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Constant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ExtensionVTable::visit_children(array: &vortex_array::arrays::ExtensionArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-pub struct vortex_array::arrays::FilterArray
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-impl vortex_array::arrays::FilterArray
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::FilterArray::child(&self) -> &vortex_array::ArrayRef
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::FilterArray::filter_mask(&self) -> &vortex_mask::Mask
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FilterArray::into_parts(self) -> vortex_array::arrays::FilterArrayParts
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::FilterArray::new(array: vortex_array::ArrayRef, mask: vortex_mask::Mask) -> Self
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::FilterArray::try_new(array: vortex_array::ArrayRef, mask: vortex_mask::Mask) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::FilterArray::clone(&self) -> vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::FilterArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::arrays::FilterArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::FilterArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FilterArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::ops::deref::Deref for vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::FilterArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::FilterArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FilterArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::ValidityVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub struct vortex_array::arrays::FilterArrayParts
+pub fn vortex_array::arrays::Constant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::arrays::FilterArrayParts::child: vortex_array::ArrayRef
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Constant
 
-pub vortex_array::arrays::FilterArrayParts::mask: vortex_mask::Mask
+pub fn vortex_array::arrays::Constant::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::arrays::FilterExecuteAdaptor<V>(pub V)
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Constant
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::FilterExecuteAdaptor<V>
+pub fn vortex_array::arrays::Constant::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterExecuteAdaptor<V>::default() -> vortex_array::arrays::FilterExecuteAdaptor<V>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Constant
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::FilterExecuteAdaptor<V>
+pub fn vortex_array::arrays::Constant::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::scalar_fn::fns::between::BetweenReduce for vortex_array::arrays::Constant
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::FilterExecuteAdaptor<V> where V: vortex_array::arrays::FilterKernel
+pub fn vortex_array::arrays::Constant::between(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::FilterExecuteAdaptor<V>::Parent = vortex_array::arrays::FilterVTable
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::FilterExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Constant::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::arrays::FilterReduceAdaptor<V>(pub V)
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Constant
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::FilterReduceAdaptor<V>
+pub fn vortex_array::arrays::Constant::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterReduceAdaptor<V>::default() -> vortex_array::arrays::FilterReduceAdaptor<V>
+impl vortex_array::scalar_fn::fns::not::NotReduce for vortex_array::arrays::Constant
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::FilterReduceAdaptor<V>
+pub fn vortex_array::arrays::Constant::invert(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::arrays::constant::ConstantData
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::FilterReduceAdaptor<V> where V: vortex_array::arrays::FilterReduce
+impl vortex_array::arrays::constant::ConstantData
 
-pub type vortex_array::arrays::FilterReduceAdaptor<V>::Parent = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::constant::ConstantData::into_parts(self) -> vortex_array::scalar::Scalar
 
-pub fn vortex_array::arrays::FilterReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::arrays::FilterArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::constant::ConstantData::new<S>(scalar: S) -> Self where S: core::convert::Into<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::constant::ConstantData::scalar(&self) -> &vortex_array::scalar::Scalar
 
-impl vortex_array::arrays::FilterVTable
+impl core::clone::Clone for vortex_array::arrays::constant::ConstantData
 
-pub const vortex_array::arrays::FilterVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::constant::ConstantData::clone(&self) -> vortex_array::arrays::constant::ConstantData
 
-impl core::fmt::Debug for vortex_array::arrays::FilterVTable
+impl core::fmt::Debug for vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::FilterVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::constant::ConstantData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+impl core::fmt::Display for vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::FilterVTable::array_eq(array: &vortex_array::arrays::FilterArray, other: &vortex_array::arrays::FilterArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::constant::ConstantData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::FilterVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::FilterArray, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::ArrayEq for vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::FilterVTable::dtype(array: &vortex_array::arrays::FilterArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::constant::ConstantData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FilterVTable::len(array: &vortex_array::arrays::FilterArray) -> usize
+impl vortex_array::ArrayHash for vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::FilterVTable::stats(array: &vortex_array::arrays::FilterArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::constant::ConstantData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+pub type vortex_array::arrays::constant::ConstantArray = vortex_array::Array<vortex_array::arrays::Constant>
 
-pub fn vortex_array::arrays::FilterVTable::scalar_at(array: &vortex_array::arrays::FilterArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub mod vortex_array::arrays::datetime
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::FilterVTable
+pub struct vortex_array::arrays::datetime::TemporalData
 
-pub type vortex_array::arrays::FilterVTable::Array = vortex_array::arrays::FilterArray
+impl vortex_array::arrays::datetime::TemporalData
 
-pub type vortex_array::arrays::FilterVTable::ArrayVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::datetime::TemporalData::dtype(&self) -> &vortex_array::dtype::DType
 
-pub type vortex_array::arrays::FilterVTable::Metadata = vortex_array::arrays::filter::vtable::FilterMetadata
+pub fn vortex_array::arrays::datetime::TemporalData::ext_dtype(&self) -> vortex_array::dtype::extension::ExtDTypeRef
 
-pub type vortex_array::arrays::FilterVTable::OperationsVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::datetime::TemporalData::temporal_metadata(&self) -> vortex_array::extension::datetime::TemporalMetadata<'_>
 
-pub type vortex_array::arrays::FilterVTable::ValidityVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::datetime::TemporalData::temporal_values(&self) -> &vortex_array::ArrayRef
 
-pub type vortex_array::arrays::FilterVTable::VisitorVTable = vortex_array::arrays::FilterVTable
+impl vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FilterVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::filter::vtable::FilterMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::datetime::TemporalData::new_date(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit) -> Self
 
-pub fn vortex_array::arrays::FilterVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::datetime::TemporalData::new_time(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit) -> Self
 
-pub fn vortex_array::arrays::FilterVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::datetime::TemporalData::new_timestamp(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit, time_zone: core::option::Option<alloc::sync::Arc<str>>) -> Self
 
-pub fn vortex_array::arrays::FilterVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+impl core::clone::Clone for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FilterVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::datetime::TemporalData::clone(&self) -> vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FilterVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::convert::From<&vortex_array::arrays::datetime::TemporalData> for vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::arrays::FilterVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::ExtensionArray::from(value: &vortex_array::arrays::datetime::TemporalData) -> Self
 
-pub fn vortex_array::arrays::FilterVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::convert::From<vortex_array::arrays::datetime::TemporalData> for vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::FilterVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::datetime::TemporalData) -> Self
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+impl core::convert::From<vortex_array::arrays::datetime::TemporalData> for vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::arrays::FilterVTable::validity(array: &vortex_array::arrays::FilterArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::ExtensionArray::from(value: vortex_array::arrays::datetime::TemporalData) -> Self
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+impl core::convert::TryFrom<vortex_array::Array<vortex_array::arrays::Extension>> for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FilterVTable::nchildren(_array: &vortex_array::arrays::FilterArray) -> usize
+pub type vortex_array::arrays::datetime::TemporalData::Error = vortex_error::VortexError
 
-pub fn vortex_array::arrays::FilterVTable::nth_child(array: &vortex_array::arrays::FilterArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::datetime::TemporalData::try_from(ext: vortex_array::arrays::ExtensionArray) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::arrays::FilterVTable::visit_buffers(_array: &vortex_array::arrays::FilterArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl core::convert::TryFrom<vortex_array::ArrayRef> for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FilterVTable::visit_children(array: &vortex_array::arrays::FilterArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub type vortex_array::arrays::datetime::TemporalData::Error = vortex_error::VortexError
 
-pub struct vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::datetime::TemporalData::try_from(value: vortex_array::ArrayRef) -> core::result::Result<Self, Self::Error>
 
-impl vortex_array::arrays::FixedSizeListArray
+impl core::fmt::Debug for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FixedSizeListArray::elements(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::datetime::TemporalData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::FixedSizeListArray::fixed_size_list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::IntoArray for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FixedSizeListArray::into_parts(self) -> (vortex_array::ArrayRef, vortex_array::validity::Validity, vortex_array::dtype::DType)
+pub fn vortex_array::arrays::datetime::TemporalData::into_array(self) -> vortex_array::ArrayRef
 
-pub const fn vortex_array::arrays::FixedSizeListArray::list_size(&self) -> u32
+pub type vortex_array::arrays::datetime::TemporalArray = vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::FixedSizeListArray::new(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> Self
+pub mod vortex_array::arrays::decimal
 
-pub unsafe fn vortex_array::arrays::FixedSizeListArray::new_unchecked(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> Self
+pub struct vortex_array::arrays::decimal::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::try_new(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::validate(elements: &dyn vortex_array::Array, len: usize, list_size: u32, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+pub const vortex_array::arrays::Decimal::ID: vortex_array::ArrayId
 
-impl core::clone::Clone for vortex_array::arrays::FixedSizeListArray
+impl core::clone::Clone for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::clone(&self) -> vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::Decimal::clone(&self) -> vortex_array::arrays::Decimal
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::FixedSizeListArray
+impl core::fmt::Debug for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::Decimal::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<vortex_array::arrays::FixedSizeListArray> for vortex_array::ArrayRef
+impl vortex_array::OperationsVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::FixedSizeListArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Decimal::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::fmt::Debug for vortex_array::arrays::FixedSizeListArray
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-impl core::ops::deref::Deref for vortex_array::arrays::FixedSizeListArray
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub type vortex_array::arrays::FixedSizeListArray::Target = dyn vortex_array::Array
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::Executable for vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::FixedSizeListArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::IntoArray for vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::FixedSizeListArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::FixedSizeListArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-pub const vortex_array::arrays::FixedSizeListVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FixedSizeListVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::FixedSizeListVTable::take(array: &vortex_array::arrays::FixedSizeListArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_constant(&self, array: &vortex_array::arrays::FixedSizeListArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::Decimal::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_sorted(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::Decimal::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Decimal
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::Decimal::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::min_max(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Decimal> for vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::FixedSizeListVTable
+pub type vortex_array::arrays::decimal::DecimalMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::FixedSizeListVTable::cast(array: &vortex_array::arrays::FixedSizeListArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::mask(array: &vortex_array::arrays::FixedSizeListArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Decimal::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::array_eq(array: &vortex_array::arrays::FixedSizeListArray, other: &vortex_array::arrays::FixedSizeListArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Decimal::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::FixedSizeListArray, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::dtype(array: &vortex_array::arrays::FixedSizeListArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Decimal::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::len(array: &vortex_array::arrays::FixedSizeListArray) -> usize
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::FixedSizeListVTable::stats(array: &vortex_array::arrays::FixedSizeListArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::Decimal::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+pub struct vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::scalar_at(array: &vortex_array::arrays::FixedSizeListArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::arrays::decimal::DecimalData
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::decimal::DecimalData::buffer<T: vortex_array::dtype::NativeDecimalType>(&self) -> vortex_buffer::buffer::Buffer<T>
 
-pub type vortex_array::arrays::FixedSizeListVTable::Array = vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::decimal::DecimalData::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::FixedSizeListVTable::ArrayVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::decimal::DecimalData::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
 
-pub type vortex_array::arrays::FixedSizeListVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::decimal::DecimalData::is_empty(&self) -> bool
 
-pub type vortex_array::arrays::FixedSizeListVTable::OperationsVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::decimal::DecimalData::len(&self) -> usize
 
-pub type vortex_array::arrays::FixedSizeListVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::decimal::DecimalData::new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub type vortex_array::arrays::FixedSizeListVTable::VisitorVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::decimal::DecimalData::new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::arrays::FixedSizeListVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::FixedSizeListArray>
+pub unsafe fn vortex_array::arrays::decimal::DecimalData::new_unchecked<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::arrays::FixedSizeListVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub unsafe fn vortex_array::arrays::decimal::DecimalData::new_unchecked_from_byte_buffer(byte_buffer: vortex_buffer::ByteBuffer, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::arrays::FixedSizeListVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub unsafe fn vortex_array::arrays::decimal::DecimalData::new_unchecked_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::arrays::FixedSizeListVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::decimal::DecimalData::precision(&self) -> u8
 
-pub fn vortex_array::arrays::FixedSizeListVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::decimal::DecimalData::scale(&self) -> i8
 
-pub fn vortex_array::arrays::FixedSizeListVTable::metadata(_array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::decimal::DecimalData::try_new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::decimal::DecimalData::try_new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::decimal::DecimalData::values_type(&self) -> vortex_array::dtype::DecimalType
 
-pub fn vortex_array::arrays::FixedSizeListVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl core::clone::Clone for vortex_array::arrays::decimal::DecimalData
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::decimal::DecimalData::clone(&self) -> vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nbuffers(_array: &vortex_array::arrays::FixedSizeListArray) -> usize
+impl core::fmt::Debug for vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nchildren(array: &vortex_array::arrays::FixedSizeListArray) -> usize
+pub fn vortex_array::arrays::decimal::DecimalData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nth_child(array: &vortex_array::arrays::FixedSizeListArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl core::fmt::Display for vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::visit_buffers(_array: &vortex_array::arrays::FixedSizeListArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::decimal::DecimalData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::FixedSizeListVTable::visit_children(array: &vortex_array::arrays::FixedSizeListArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::ArrayEq for vortex_array::arrays::decimal::DecimalData
 
-#[repr(C, align(8))] pub struct vortex_array::arrays::Inlined
+pub fn vortex_array::arrays::decimal::DecimalData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub vortex_array::arrays::Inlined::data: [u8; 12]
+impl vortex_array::ArrayHash for vortex_array::arrays::decimal::DecimalData
 
-pub vortex_array::arrays::Inlined::size: u32
+pub fn vortex_array::arrays::decimal::DecimalData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-impl vortex_array::arrays::Inlined
+pub struct vortex_array::arrays::decimal::DecimalDataParts
 
-pub fn vortex_array::arrays::Inlined::value(&self) -> &[u8]
+pub vortex_array::arrays::decimal::DecimalDataParts::decimal_dtype: vortex_array::dtype::DecimalDType
 
-impl core::clone::Clone for vortex_array::arrays::Inlined
+pub vortex_array::arrays::decimal::DecimalDataParts::validity: vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::Inlined::clone(&self) -> vortex_array::arrays::Inlined
+pub vortex_array::arrays::decimal::DecimalDataParts::values: vortex_array::buffer::BufferHandle
 
-impl core::cmp::Eq for vortex_array::arrays::Inlined
+pub vortex_array::arrays::decimal::DecimalDataParts::values_type: vortex_array::dtype::DecimalType
 
-impl core::cmp::PartialEq for vortex_array::arrays::Inlined
+pub struct vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-pub fn vortex_array::arrays::Inlined::eq(&self, other: &vortex_array::arrays::Inlined) -> bool
+impl core::default::Default for vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-impl core::fmt::Debug for vortex_array::arrays::Inlined
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::default() -> vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-pub fn vortex_array::arrays::Inlined::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Debug for vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-impl core::marker::Copy for vortex_array::arrays::Inlined
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::marker::StructuralPartialEq for vortex_array::arrays::Inlined
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Decimal> for vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-pub struct vortex_array::arrays::ListArray
+pub type vortex_array::arrays::decimal::DecimalMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-impl vortex_array::arrays::ListArray
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListArray::element_dtype(&self) -> &alloc::sync::Arc<vortex_array::dtype::DType>
+pub trait vortex_array::arrays::decimal::DecimalArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Decimal>
 
-pub fn vortex_array::arrays::ListArray::elements(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::buffer<T: vortex_array::dtype::NativeDecimalType>(&self) -> vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::arrays::ListArray::into_parts(self) -> vortex_array::arrays::ListArrayParts
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListArray::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
 
-pub fn vortex_array::arrays::ListArray::new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub unsafe fn vortex_array::arrays::ListArray::new_unchecked(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::precision(&self) -> u8
 
-pub fn vortex_array::arrays::ListArray::offset_at(&self, index: usize) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::scale(&self) -> i8
 
-pub fn vortex_array::arrays::ListArray::offsets(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::ListArray::reset_offsets(&self, recurse: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ListArray::sliced_elements(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::decimal::DecimalArrayExt::values_type(&self) -> vortex_array::dtype::DecimalType
 
-pub fn vortex_array::arrays::ListArray::try_new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Decimal>> vortex_array::arrays::decimal::DecimalArrayExt for T
 
-pub fn vortex_array::arrays::ListArray::validate(elements: &dyn vortex_array::Array, offsets: &dyn vortex_array::Array, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+pub fn T::buffer<T: vortex_array::dtype::NativeDecimalType>(&self) -> vortex_buffer::buffer::Buffer<T>
 
-impl core::clone::Clone for vortex_array::arrays::ListArray
+pub fn T::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListArray::clone(&self) -> vortex_array::arrays::ListArray
+pub fn T::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ListArray
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::ListArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn T::precision(&self) -> u8
 
-impl core::convert::From<vortex_array::arrays::ListArray> for vortex_array::ArrayRef
+pub fn T::scale(&self) -> i8
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ListArray) -> vortex_array::ArrayRef
+pub fn T::validity(&self) -> vortex_array::validity::Validity
 
-impl core::fmt::Debug for vortex_array::arrays::ListArray
+pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ListArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn T::values_type(&self) -> vortex_array::dtype::DecimalType
 
-impl core::ops::deref::Deref for vortex_array::arrays::ListArray
+pub fn vortex_array::arrays::decimal::narrowed_decimal(decimal_array: vortex_array::arrays::DecimalArray) -> vortex_array::arrays::DecimalArray
 
-pub type vortex_array::arrays::ListArray::Target = dyn vortex_array::Array
+pub type vortex_array::arrays::decimal::DecimalArray = vortex_array::Array<vortex_array::arrays::Decimal>
 
-pub fn vortex_array::arrays::ListArray::deref(&self) -> &Self::Target
+pub mod vortex_array::arrays::dict
 
-impl vortex_array::IntoArray for vortex_array::arrays::ListArray
+pub mod vortex_array::arrays::dict::vtable
 
-pub fn vortex_array::arrays::ListArray::into_array(self) -> vortex_array::ArrayRef
+pub struct vortex_array::arrays::dict::vtable::Dict
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::ListArray
+impl vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListArray::validity(&self) -> &vortex_array::validity::Validity
+pub const vortex_array::arrays::dict::Dict::ID: vortex_array::ArrayId
 
-pub struct vortex_array::arrays::ListArrayParts
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
 
-pub vortex_array::arrays::ListArrayParts::dtype: vortex_array::dtype::DType
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
 
-pub vortex_array::arrays::ListArrayParts::elements: vortex_array::ArrayRef
+impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
-pub vortex_array::arrays::ListArrayParts::offsets: vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::arrays::ListArrayParts::validity: vortex_array::validity::Validity
+impl vortex_array::OperationsVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::ListVTable
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub const vortex_array::arrays::ListVTable::ID: vortex_array::vtable::ArrayId
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-impl core::fmt::Debug for vortex_array::arrays::ListVTable
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ListVTable::filter(array: &vortex_array::arrays::ListArray, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListVTable::take(array: &vortex_array::arrays::ListArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ListVTable::is_constant(&self, array: &vortex_array::arrays::ListArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ListVTable::is_sorted(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ListVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::min_max(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ListVTable::cast(array: &vortex_array::arrays::ListArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ListVTable::mask(array: &vortex_array::arrays::ListArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ValidityVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ListVTable::array_eq(array: &vortex_array::arrays::ListArray, other: &vortex_array::arrays::ListArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ListArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::dict::Dict::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::dtype(array: &vortex_array::arrays::ListArray) -> &vortex_array::dtype::DType
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::len(array: &vortex_array::arrays::ListArray) -> usize
+pub fn vortex_array::arrays::dict::Dict::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::stats(array: &vortex_array::arrays::ListArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::dict::Dict
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::scalar_at(array: &vortex_array::arrays::ListArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::dict::Dict
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListVTable::Array = vortex_array::arrays::ListArray
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::arrays::ListVTable::ArrayVTable = vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::list::vtable::ListMetadata>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::arrays::ListVTable::OperationsVTable = vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::arrays::ListVTable::VisitorVTable = vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::like(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ListArray>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::dict::Dict::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::dict::vtable::DictArray = vortex_array::Array<vortex_array::arrays::dict::Dict>
 
-pub fn vortex_array::arrays::ListVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+impl vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::metadata(array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<Self::Metadata>
+pub const vortex_array::arrays::dict::Dict::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ListVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ListVTable::nbuffers(_array: &vortex_array::arrays::ListArray) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::nchildren(array: &vortex_array::arrays::ListArray) -> usize
+pub fn vortex_array::arrays::dict::Dict::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ListVTable::nth_child(array: &vortex_array::arrays::ListArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListVTable::visit_buffers(_array: &vortex_array::arrays::ListArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::ListVTable::visit_children(array: &vortex_array::arrays::ListArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::arrays::ListViewArray
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-impl vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ListViewArray::elements(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListViewArray::into_parts(self) -> vortex_array::arrays::ListViewArrayParts
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListViewArray::is_zero_copy_to_list(&self) -> bool
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewArray::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListViewArray::new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub unsafe fn vortex_array::arrays::ListViewArray::new_unchecked(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ListViewArray::offset_at(&self, index: usize) -> usize
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewArray::offsets(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ListViewArray::size_at(&self, index: usize) -> usize
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ListViewArray::sizes(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ListViewArray::try_new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewArray::validate(elements: &dyn vortex_array::Array, offsets: &dyn vortex_array::Array, sizes: &dyn vortex_array::Array, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewArray::verify_is_zero_copy_to_list(&self) -> bool
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub unsafe fn vortex_array::arrays::ListViewArray::with_zero_copy_to_list(self, is_zctl: bool) -> Self
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ListViewArray::rebuild(&self, mode: vortex_array::arrays::ListViewRebuildMode) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
+impl vortex_array::ValidityVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-impl core::clone::Clone for vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ListViewArray::clone(&self) -> vortex_array::arrays::ListViewArray
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::dict::Dict
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewArray::as_ref(&self) -> &dyn vortex_array::Array
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::dict::Dict
 
-impl core::convert::From<vortex_array::arrays::ListViewArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ListViewArray) -> vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::dict::Dict
 
-impl core::fmt::Debug for vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::dict::Dict
 
-impl core::ops::deref::Deref for vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::dict::Dict::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListViewArray::Target = dyn vortex_array::Array
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListViewArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::dict::Dict::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::Executable for vortex_array::arrays::ListViewArray
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::dict::Dict::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::IntoArray for vortex_array::arrays::ListViewArray
+impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListViewArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::Dict::like(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::ListViewArray
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ListViewArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::dict::Dict::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::arrays::ListViewArrayParts
+pub struct vortex_array::arrays::dict::DictData
 
-pub vortex_array::arrays::ListViewArrayParts::elements: vortex_array::ArrayRef
+impl vortex_array::arrays::dict::DictData
 
-pub vortex_array::arrays::ListViewArrayParts::elements_dtype: alloc::sync::Arc<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::dict::DictData::new(codes_dtype: &vortex_array::dtype::DType) -> Self
 
-pub vortex_array::arrays::ListViewArrayParts::offsets: vortex_array::ArrayRef
+pub unsafe fn vortex_array::arrays::dict::DictData::new_unchecked() -> Self
 
-pub vortex_array::arrays::ListViewArrayParts::sizes: vortex_array::ArrayRef
+pub unsafe fn vortex_array::arrays::dict::DictData::set_all_values_referenced(self, all_values_referenced: bool) -> Self
 
-pub vortex_array::arrays::ListViewArrayParts::validity: vortex_array::validity::Validity
+impl core::clone::Clone for vortex_array::arrays::dict::DictData
 
-pub struct vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictData::clone(&self) -> vortex_array::arrays::dict::DictData
 
-impl vortex_array::arrays::ListViewVTable
+impl core::fmt::Debug for vortex_array::arrays::dict::DictData
 
-pub const vortex_array::arrays::ListViewVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::dict::DictData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::fmt::Debug for vortex_array::arrays::ListViewVTable
+impl core::fmt::Display for vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::ListViewVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::dict::DictData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ListViewVTable
+impl vortex_array::ArrayEq for vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::ListViewVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::DictData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ListViewVTable
+impl vortex_array::ArrayHash for vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::ListViewVTable::take(array: &vortex_array::arrays::ListViewArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::DictData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ListViewVTable
+pub struct vortex_array::arrays::dict::DictMetadata
 
-pub fn vortex_array::arrays::ListViewVTable::is_constant(&self, array: &vortex_array::arrays::ListViewArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::dict::DictMetadata
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictMetadata::all_values_referenced(&self) -> bool
 
-pub fn vortex_array::arrays::ListViewVTable::is_sorted(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::dict::DictMetadata::codes_ptype(&self) -> vortex_array::dtype::PType
 
-pub fn vortex_array::arrays::ListViewVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::dict::DictMetadata::is_nullable_codes(&self) -> bool
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictMetadata::set_codes_ptype(&mut self, value: vortex_array::dtype::PType)
 
-pub fn vortex_array::arrays::ListViewVTable::min_max(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl core::clone::Clone for vortex_array::arrays::dict::DictMetadata
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictMetadata::clone(&self) -> vortex_array::arrays::dict::DictMetadata
 
-pub fn vortex_array::arrays::ListViewVTable::cast(array: &vortex_array::arrays::ListViewArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::default::Default for vortex_array::arrays::dict::DictMetadata
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictMetadata::default() -> Self
 
-pub fn vortex_array::arrays::ListViewVTable::mask(array: &vortex_array::arrays::ListViewArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::arrays::dict::DictMetadata
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ListViewVTable::array_eq(array: &vortex_array::arrays::ListViewArray, other: &vortex_array::arrays::ListViewArray, precision: vortex_array::Precision) -> bool
+impl prost::message::Message for vortex_array::arrays::dict::DictMetadata
 
-pub fn vortex_array::arrays::ListViewVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ListViewArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::dict::DictMetadata::clear(&mut self)
 
-pub fn vortex_array::arrays::ListViewVTable::dtype(array: &vortex_array::arrays::ListViewArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::dict::DictMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_array::arrays::ListViewVTable::len(array: &vortex_array::arrays::ListViewArray) -> usize
+pub struct vortex_array::arrays::dict::DictSlots
 
-pub fn vortex_array::arrays::ListViewVTable::stats(array: &vortex_array::arrays::ListViewArray) -> vortex_array::stats::StatsSetRef<'_>
+pub vortex_array::arrays::dict::DictSlots::codes: vortex_array::ArrayRef
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+pub vortex_array::arrays::dict::DictSlots::values: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewVTable::scalar_at(array: &vortex_array::arrays::ListViewArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::arrays::dict::DictSlots
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ListViewVTable
+pub const vortex_array::arrays::dict::DictSlots::CODES: usize
 
-pub type vortex_array::arrays::ListViewVTable::Array = vortex_array::arrays::ListViewArray
+pub const vortex_array::arrays::dict::DictSlots::COUNT: usize
 
-pub type vortex_array::arrays::ListViewVTable::ArrayVTable = vortex_array::arrays::ListViewVTable
+pub const vortex_array::arrays::dict::DictSlots::NAMES: [&'static str; 2]
 
-pub type vortex_array::arrays::ListViewVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::listview::vtable::ListViewMetadata>
+pub const vortex_array::arrays::dict::DictSlots::VALUES: usize
 
-pub type vortex_array::arrays::ListViewVTable::OperationsVTable = vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::DictSlots::from_slots(slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> Self
 
-pub type vortex_array::arrays::ListViewVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::dict::DictSlots::into_slots(self) -> alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListViewVTable::VisitorVTable = vortex_array::arrays::ListViewVTable
+pub struct vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
+pub vortex_array::arrays::dict::DictSlotsView::codes: &'a vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub vortex_array::arrays::dict::DictSlotsView::values: &'a vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl<'a> vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::DictSlotsView<'a>::from_slots(slots: &'a [core::option::Option<vortex_array::ArrayRef>]) -> Self
 
-pub fn vortex_array::arrays::ListViewVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::dict::DictSlotsView<'a>::to_owned(&self) -> vortex_array::arrays::dict::DictSlots
 
-pub fn vortex_array::arrays::ListViewVTable::metadata(array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<Self::Metadata>
+impl<'a> core::clone::Clone for vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::DictSlotsView<'a>::clone(&self) -> vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl<'a> core::fmt::Debug for vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::dict::DictSlotsView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+impl<'a> core::marker::Copy for vortex_array::arrays::dict::DictSlotsView<'a>
 
-pub fn vortex_array::arrays::ListViewVTable::nbuffers(_array: &vortex_array::arrays::ListViewArray) -> usize
+pub struct vortex_array::arrays::dict::TakeExecuteAdaptor<V>(pub V)
 
-pub fn vortex_array::arrays::ListViewVTable::nchildren(array: &vortex_array::arrays::ListViewArray) -> usize
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::dict::TakeExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::ListViewVTable::nth_child(array: &vortex_array::arrays::ListViewArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::dict::TakeExecuteAdaptor<V>::default() -> vortex_array::arrays::dict::TakeExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::ListViewVTable::visit_buffers(_array: &vortex_array::arrays::ListViewArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::dict::TakeExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::ListViewVTable::visit_children(array: &vortex_array::arrays::ListViewArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::dict::TakeExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_array::arrays::MaskedArray
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::dict::TakeExecuteAdaptor<V> where V: vortex_array::arrays::dict::TakeExecute
 
-impl vortex_array::arrays::MaskedArray
+pub type vortex_array::arrays::dict::TakeExecuteAdaptor<V>::Parent = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::MaskedArray::child(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::dict::TakeExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedArray::try_new(child: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::arrays::dict::TakeReduceAdaptor<V>(pub V)
 
-impl core::clone::Clone for vortex_array::arrays::MaskedArray
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::dict::TakeReduceAdaptor<V>
 
-pub fn vortex_array::arrays::MaskedArray::clone(&self) -> vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::dict::TakeReduceAdaptor<V>::default() -> vortex_array::arrays::dict::TakeReduceAdaptor<V>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::MaskedArray
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::dict::TakeReduceAdaptor<V>
 
-pub fn vortex_array::arrays::MaskedArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::dict::TakeReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<vortex_array::arrays::MaskedArray> for vortex_array::ArrayRef
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::dict::TakeReduceAdaptor<V> where V: vortex_array::arrays::dict::TakeReduce
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::MaskedArray) -> vortex_array::ArrayRef
+pub type vortex_array::arrays::dict::TakeReduceAdaptor<V>::Parent = vortex_array::arrays::dict::Dict
 
-impl core::fmt::Debug for vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::dict::TakeReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub trait vortex_array::arrays::dict::DictArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::dict::Dict> + vortex_array::arrays::dict::DictArraySlotsExt
 
-impl core::ops::deref::Deref for vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::dict::DictArrayExt::compute_referenced_values_mask(&self, referenced: bool) -> vortex_error::VortexResult<vortex_buffer::bit::buf::BitBuffer>
 
-pub type vortex_array::arrays::MaskedArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::dict::DictArrayExt::has_all_values_referenced(&self) -> bool
 
-pub fn vortex_array::arrays::MaskedArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::dict::DictArrayExt::validate_all_values_referenced(&self) -> vortex_error::VortexResult<()>
 
-impl vortex_array::IntoArray for vortex_array::arrays::MaskedArray
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::dict::Dict>> vortex_array::arrays::dict::DictArrayExt for T
 
-pub fn vortex_array::arrays::MaskedArray::into_array(self) -> vortex_array::ArrayRef
+pub fn T::compute_referenced_values_mask(&self, referenced: bool) -> vortex_error::VortexResult<vortex_buffer::bit::buf::BitBuffer>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::MaskedArray
+pub fn T::has_all_values_referenced(&self) -> bool
 
-pub fn vortex_array::arrays::MaskedArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn T::validate_all_values_referenced(&self) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::arrays::MaskedVTable
+pub trait vortex_array::arrays::dict::DictArraySlotsExt: vortex_array::TypedArrayRef<vortex_array::arrays::dict::Dict>
 
-impl vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::dict::DictArraySlotsExt::codes(&self) -> &vortex_array::ArrayRef
 
-pub const vortex_array::arrays::MaskedVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::dict::DictArraySlotsExt::slots_view(&self) -> vortex_array::arrays::dict::DictSlotsView<'_>
 
-impl core::fmt::Debug for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::dict::DictArraySlotsExt::values(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::MaskedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::dict::Dict>> vortex_array::arrays::dict::DictArraySlotsExt for T
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::MaskedVTable
+pub fn T::codes(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::MaskedVTable::filter(array: &vortex_array::arrays::MaskedArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::slots_view(&self) -> vortex_array::arrays::dict::DictSlotsView<'_>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::MaskedVTable
+pub fn T::values(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::MaskedVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::arrays::dict::TakeExecute: vortex_array::VTable
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::dict::TakeExecute::take(array: vortex_array::ArrayView<'_, Self>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::take(array: &vortex_array::arrays::MaskedArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Bool
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Bool::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::mask(array: &vortex_array::arrays::MaskedArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Chunked
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Chunked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::array_eq(array: &vortex_array::arrays::MaskedArray, other: &vortex_array::arrays::MaskedArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::MaskedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::MaskedArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::Decimal::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::dtype(array: &vortex_array::arrays::MaskedArray) -> &vortex_array::dtype::DType
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::MaskedVTable::len(array: &vortex_array::arrays::MaskedArray) -> usize
+pub fn vortex_array::arrays::Extension::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::stats(array: &vortex_array::arrays::MaskedArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::FixedSizeList::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::scalar_at(array: &vortex_array::arrays::MaskedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::List
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::List::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::Array = vortex_array::arrays::MaskedArray
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Primitive
 
-pub type vortex_array::arrays::MaskedVTable::ArrayVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Primitive::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::Metadata = vortex_array::EmptyMetadata
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBin
 
-pub type vortex_array::arrays::MaskedVTable::OperationsVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::VarBin::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBinView
 
-pub type vortex_array::arrays::MaskedVTable::VisitorVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::VarBinView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::MaskedArray>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::MaskedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::dict::Dict::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::MaskedVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::patched::Patched::take(array: vortex_array::ArrayView<'_, Self>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub trait vortex_array::arrays::dict::TakeReduce: vortex_array::VTable
 
-pub fn vortex_array::arrays::MaskedVTable::metadata(_array: &vortex_array::arrays::MaskedArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::dict::TakeReduce::take(array: vortex_array::ArrayView<'_, Self>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::MaskedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Constant::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::ListView
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::ListView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::nchildren(array: &vortex_array::arrays::MaskedArray) -> usize
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::MaskedVTable::nth_child(array: &vortex_array::arrays::MaskedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::MaskedVTable::visit_buffers(_array: &vortex_array::arrays::MaskedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Struct
 
-pub fn vortex_array::arrays::MaskedVTable::visit_children(array: &vortex_array::arrays::MaskedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::Struct::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-#[repr(transparent)] pub struct vortex_array::arrays::NativeValue<T>(pub T)
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::null::Null
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<f32>
+pub fn vortex_array::arrays::null::Null::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NativeValue<f32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::dict::take_canonical(values: vortex_array::Canonical, codes: &vortex_array::arrays::PrimitiveArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<f64>
+pub type vortex_array::arrays::dict::DictArray = vortex_array::Array<vortex_array::arrays::dict::Dict>
 
-pub fn vortex_array::arrays::NativeValue<f64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub mod vortex_array::arrays::extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<half::binary16::f16>
+pub struct vortex_array::arrays::extension::Extension
 
-pub fn vortex_array::arrays::NativeValue<half::binary16::f16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<i16>
+pub const vortex_array::arrays::Extension::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::NativeValue<i16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl core::clone::Clone for vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<i32>
+pub fn vortex_array::arrays::Extension::clone(&self) -> vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::NativeValue<i32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl core::fmt::Debug for vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<i64>
+pub fn vortex_array::arrays::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::NativeValue<i64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<i8>
+pub fn vortex_array::arrays::Extension::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::NativeValue<i8>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<u16>
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NativeValue<u16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<u32>
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::arrays::NativeValue<u32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<u64>
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::NativeValue<u64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::hash::Hash for vortex_array::arrays::NativeValue<u8>
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NativeValue<u8>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::NativeValue<T>::clone(&self) -> vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NativeValue<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-impl<T: core::marker::Copy> core::marker::Copy for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<T: vortex_array::dtype::NativePType> core::cmp::Eq for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<T: vortex_array::dtype::NativePType> core::cmp::PartialEq for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NativeValue<T>::eq(&self, other: &vortex_array::arrays::NativeValue<T>) -> bool
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: vortex_array::dtype::NativePType> core::cmp::PartialOrd for vortex_array::arrays::NativeValue<T>
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::NativeValue<T>::partial_cmp(&self, other: &vortex_array::arrays::NativeValue<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::arrays::NullArray
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrays::NullArray
+impl vortex_array::ValidityChild<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::NullArray::new(len: usize) -> Self
+pub fn vortex_array::arrays::Extension::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>) -> vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::arrays::NullArray
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::NullArray::clone(&self) -> vortex_array::arrays::NullArray
+pub fn vortex_array::arrays::Extension::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::NullArray
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::NullArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::Extension::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::arrays::NullArray> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Extension
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::NullArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Extension::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::arrays::NullArray
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::NullArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::ops::deref::Deref for vortex_array::arrays::NullArray
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Extension
 
-pub type vortex_array::arrays::NullArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::Extension::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullArray::deref(&self) -> &Self::Target
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Extension
 
-impl vortex_array::Executable for vortex_array::arrays::NullArray
+pub fn vortex_array::arrays::Extension::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::arrays::extension::ExtensionData
 
-impl vortex_array::IntoArray for vortex_array::arrays::NullArray
+impl vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NullArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::extension::ExtensionData::ext_dtype(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
 
-pub struct vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::extension::ExtensionData::new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_dtype: &vortex_array::dtype::DType) -> Self
 
-impl vortex_array::arrays::NullVTable
+pub unsafe fn vortex_array::arrays::extension::ExtensionData::new_unchecked(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_dtype: &vortex_array::dtype::DType) -> Self
 
-pub const vortex_array::arrays::NullVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::extension::ExtensionData::try_new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::arrays::NullVTable
+impl core::clone::Clone for vortex_array::arrays::extension::ExtensionData
 
-pub const vortex_array::arrays::NullVTable::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
+pub fn vortex_array::arrays::extension::ExtensionData::clone(&self) -> vortex_array::arrays::extension::ExtensionData
 
-impl core::fmt::Debug for vortex_array::arrays::NullVTable
+impl core::fmt::Debug for vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NullVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::extension::ExtensionData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::NullVTable
+impl core::fmt::Display for vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NullVTable::filter(_array: &vortex_array::arrays::NullArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::extension::ExtensionData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::NullVTable
+impl vortex_array::ArrayEq for vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NullVTable::slice(_array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::extension::ExtensionData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl vortex_array::arrays::TakeReduce for vortex_array::arrays::NullVTable
+impl vortex_array::ArrayHash for vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::NullVTable::take(array: &vortex_array::arrays::NullArray, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::extension::ExtensionData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::NullVTable
+pub trait vortex_array::arrays::extension::ExtensionArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Extension>
 
-pub fn vortex_array::arrays::NullVTable::min_max(&self, _array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::extension::ExtensionArrayExt::storage_array(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::NullVTable
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Extension>> vortex_array::arrays::extension::ExtensionArrayExt for T
 
-pub fn vortex_array::arrays::NullVTable::cast(array: &vortex_array::arrays::NullArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::storage_array(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::NullVTable
+pub type vortex_array::arrays::extension::ExtensionArray = vortex_array::Array<vortex_array::arrays::Extension>
 
-pub fn vortex_array::arrays::NullVTable::mask(array: &vortex_array::arrays::NullArray, _mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub mod vortex_array::arrays::filter
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub struct vortex_array::arrays::filter::Filter
 
-pub fn vortex_array::arrays::NullVTable::array_eq(array: &vortex_array::arrays::NullArray, other: &vortex_array::arrays::NullArray, _precision: vortex_array::Precision) -> bool
+impl vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::NullVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::NullArray, state: &mut H, _precision: vortex_array::Precision)
+pub const vortex_array::arrays::Filter::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::NullVTable::dtype(_array: &vortex_array::arrays::NullArray) -> &vortex_array::dtype::DType
+impl core::clone::Clone for vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::NullVTable::len(array: &vortex_array::arrays::NullArray) -> usize
+pub fn vortex_array::arrays::Filter::clone(&self) -> vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::NullVTable::stats(array: &vortex_array::arrays::NullArray) -> vortex_array::stats::StatsSetRef<'_>
+impl core::fmt::Debug for vortex_array::arrays::Filter
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::NullVTable::scalar_at(_array: &vortex_array::arrays::NullArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::arrays::NullVTable::Array = vortex_array::arrays::NullArray
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-pub type vortex_array::arrays::NullVTable::ArrayVTable = vortex_array::arrays::NullVTable
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-pub type vortex_array::arrays::NullVTable::Metadata = vortex_array::EmptyMetadata
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-pub type vortex_array::arrays::NullVTable::OperationsVTable = vortex_array::arrays::NullVTable
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-pub type vortex_array::arrays::NullVTable::ValidityVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::NullVTable::VisitorVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::NullVTable::build(_dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::NullArray>
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::NullVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NullVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::NullVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::NullVTable::metadata(_array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::NullVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::NullVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::NullVTable::validity(_array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullVTable::nchildren(_array: &vortex_array::arrays::NullArray) -> usize
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::NullVTable::nth_child(_array: &vortex_array::arrays::NullArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::NullVTable::visit_buffers(_array: &vortex_array::arrays::NullArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::NullVTable::visit_children(_array: &vortex_array::arrays::NullArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::ValidityVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub struct vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::Filter::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::arrays::PrimitiveArray
+pub struct vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::as_slice<T: vortex_array::dtype::NativePType>(&self) -> &[T]
+impl vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::narrow(&self) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray>
+pub fn vortex_array::arrays::filter::FilterData::filter_mask(&self) -> &vortex_mask::Mask
 
-pub fn vortex_array::arrays::PrimitiveArray::reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::arrays::filter::FilterData::into_parts(self) -> vortex_array::arrays::filter::FilterDataParts
 
-impl vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::filter::FilterData::is_empty(&self) -> bool
 
-pub fn vortex_array::arrays::PrimitiveArray::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::filter::FilterData::len(&self) -> usize
 
-pub fn vortex_array::arrays::PrimitiveArray::from_buffer_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::filter::FilterData::new(mask: vortex_mask::Mask) -> Self
 
-pub fn vortex_array::arrays::PrimitiveArray::from_byte_buffer(buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
+impl core::clone::Clone for vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::from_values_byte_buffer(valid_elems_buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity, n_rows: usize) -> Self
+pub fn vortex_array::arrays::filter::FilterData::clone(&self) -> vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::map_each<T, R, F>(self, f: F) -> vortex_array::arrays::PrimitiveArray where T: vortex_array::dtype::NativePType, R: vortex_array::dtype::NativePType, F: core::ops::function::FnMut(T) -> R
+impl core::fmt::Debug for vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::map_each_with_validity<T, R, F>(self, f: F) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray> where T: vortex_array::dtype::NativePType, R: vortex_array::dtype::NativePType, F: core::ops::function::FnMut((T, bool)) -> R
+pub fn vortex_array::arrays::filter::FilterData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveArray::ptype(&self) -> vortex_array::dtype::PType
+impl core::fmt::Display for vortex_array::arrays::filter::FilterData
 
-impl vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::filter::FilterData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveArray::empty<T: vortex_array::dtype::NativePType>(nullability: vortex_array::dtype::Nullability) -> Self
+impl vortex_array::ArrayEq for vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::PrimitiveArray::new<T: vortex_array::dtype::NativePType>(buffer: impl core::convert::Into<vortex_buffer::buffer::Buffer<T>>, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::filter::FilterData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub unsafe fn vortex_array::arrays::PrimitiveArray::new_unchecked<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, validity: vortex_array::validity::Validity) -> Self
+impl vortex_array::ArrayHash for vortex_array::arrays::filter::FilterData
 
-pub unsafe fn vortex_array::arrays::PrimitiveArray::new_unchecked_from_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::filter::FilterData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::PrimitiveArray::try_new<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::arrays::filter::FilterDataParts
 
-pub fn vortex_array::arrays::PrimitiveArray::validate<T: vortex_array::dtype::NativePType>(buffer: &vortex_buffer::buffer::Buffer<T>, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+pub vortex_array::arrays::filter::FilterDataParts::mask: vortex_mask::Mask
 
-impl vortex_array::arrays::PrimitiveArray
+pub struct vortex_array::arrays::filter::FilterExecuteAdaptor<V>(pub V)
 
-pub fn vortex_array::arrays::PrimitiveArray::from_option_iter<T: vortex_array::dtype::NativePType, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::filter::FilterExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::PrimitiveArray::into_buffer<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::arrays::filter::FilterExecuteAdaptor<V>::default() -> vortex_array::arrays::filter::FilterExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::PrimitiveArray::into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer_mut::BufferMut<T>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::filter::FilterExecuteAdaptor<V>
 
-pub fn vortex_array::arrays::PrimitiveArray::to_buffer<T: vortex_array::dtype::NativePType>(&self) -> vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::arrays::filter::FilterExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveArray::try_into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> core::result::Result<vortex_buffer::buffer_mut::BufferMut<T>, vortex_buffer::buffer::Buffer<T>>
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::filter::FilterExecuteAdaptor<V> where V: vortex_array::arrays::filter::FilterKernel
 
-impl vortex_array::arrays::PrimitiveArray
+pub type vortex_array::arrays::filter::FilterExecuteAdaptor<V>::Parent = vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::PrimitiveArray::into_parts(self) -> vortex_array::arrays::PrimitiveArrayParts
+pub fn vortex_array::arrays::filter::FilterExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::PrimitiveArray
+pub struct vortex_array::arrays::filter::FilterReduceAdaptor<V>(pub V)
 
-pub fn vortex_array::arrays::PrimitiveArray::patch(self, patches: &vortex_array::patches::Patches) -> vortex_error::VortexResult<Self>
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::filter::FilterReduceAdaptor<V>
 
-impl vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::filter::FilterReduceAdaptor<V>::default() -> vortex_array::arrays::filter::FilterReduceAdaptor<V>
 
-pub fn vortex_array::arrays::PrimitiveArray::top_value(&self) -> vortex_error::VortexResult<core::option::Option<(vortex_array::scalar::PValue, usize)>>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::filter::FilterReduceAdaptor<V>
 
-impl core::clone::Clone for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::filter::FilterReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveArray::clone(&self) -> vortex_array::arrays::PrimitiveArray
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::filter::FilterReduceAdaptor<V> where V: vortex_array::arrays::filter::FilterReduce
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::PrimitiveArray
+pub type vortex_array::arrays::filter::FilterReduceAdaptor<V>::Parent = vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::PrimitiveArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::filter::FilterReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::arrays::PrimitiveArray> for vortex_array::ArrayRef
+pub trait vortex_array::arrays::filter::FilterArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Filter>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::PrimitiveArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::filter::FilterArrayExt::child(&self) -> &vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::arrays::PrimitiveArray
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Filter>> vortex_array::arrays::filter::FilterArrayExt for T
 
-pub fn vortex_array::arrays::PrimitiveArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn T::child(&self) -> &vortex_array::ArrayRef
 
-impl core::ops::deref::Deref for vortex_array::arrays::PrimitiveArray
+pub trait vortex_array::arrays::filter::FilterKernel: vortex_array::VTable
 
-pub type vortex_array::arrays::PrimitiveArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::filter::FilterKernel::filter(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::deref(&self) -> &Self::Target
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::Chunked
 
-impl vortex_array::Executable for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::Chunked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::List
 
-impl vortex_array::IntoArray for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::List::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::VarBin
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::VarBin::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::validity(&self) -> &vortex_array::validity::Validity
+pub trait vortex_array::arrays::filter::FilterReduce: vortex_array::VTable
 
-impl<T: vortex_array::dtype::NativePType> core::iter::traits::collect::FromIterator<T> for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::filter::FilterReduce::filter(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::from_iter<I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Bool
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::accessor::ArrayAccessor<T> for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::Bool::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveArray::with_iterator<F, R>(&self, f: F) -> R where F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a T>>) -> R
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Constant
 
-pub struct vortex_array::arrays::PrimitiveArrayParts
+pub fn vortex_array::arrays::Constant::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::arrays::PrimitiveArrayParts::buffer: vortex_array::buffer::BufferHandle
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Extension
 
-pub vortex_array::arrays::PrimitiveArrayParts::ptype: vortex_array::dtype::PType
+pub fn vortex_array::arrays::Extension::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::arrays::PrimitiveArrayParts::validity: vortex_array::validity::Validity
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Masked
 
-pub struct vortex_array::arrays::PrimitiveMaskedValidityRule
+pub fn vortex_array::arrays::Masked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::default::Default for vortex_array::arrays::PrimitiveMaskedValidityRule
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::PrimitiveMaskedValidityRule::default() -> vortex_array::arrays::PrimitiveMaskedValidityRule
+pub fn vortex_array::arrays::dict::Dict::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::arrays::PrimitiveMaskedValidityRule
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::PrimitiveMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::null::Null::filter(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveMaskedValidityRule
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::patched::Patched
 
-pub type vortex_array::arrays::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::patched::Patched::filter(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::PrimitiveArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::filter::FilterArray = vortex_array::Array<vortex_array::arrays::Filter>
 
-pub struct vortex_array::arrays::PrimitiveVTable
+pub mod vortex_array::arrays::fixed_size_list
 
-impl vortex_array::arrays::PrimitiveVTable
+pub struct vortex_array::arrays::fixed_size_list::FixedSizeList
 
-pub const vortex_array::arrays::PrimitiveVTable::ID: vortex_array::vtable::ArrayId
+impl vortex_array::arrays::FixedSizeList
 
-impl core::fmt::Debug for vortex_array::arrays::PrimitiveVTable
+pub const vortex_array::arrays::FixedSizeList::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::PrimitiveVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::clone(&self) -> vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::PrimitiveVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveVTable::take(array: &vortex_array::arrays::PrimitiveArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_constant(&self, array: &vortex_array::arrays::PrimitiveArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::PrimitiveVTable
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_sorted(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_strict_sorted(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::PrimitiveVTable::min_max(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::compute::NaNCountKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::PrimitiveVTable::nan_count(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::PrimitiveVTable::sum(&self, array: &vortex_array::arrays::PrimitiveArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveMaskedValidityRule
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::PrimitiveArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::PrimitiveVTable::between(arr: &vortex_array::arrays::PrimitiveArray, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::cast(array: &vortex_array::arrays::PrimitiveArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::fill_null(array: &vortex_array::arrays::PrimitiveArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::PrimitiveVTable::mask(array: &vortex_array::arrays::PrimitiveArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ValidityVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::PrimitiveVTable::array_eq(array: &vortex_array::arrays::PrimitiveArray, other: &vortex_array::arrays::PrimitiveArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::PrimitiveVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::PrimitiveArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::FixedSizeList::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::dtype(array: &vortex_array::arrays::PrimitiveArray) -> &vortex_array::dtype::DType
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::PrimitiveVTable::len(array: &vortex_array::arrays::PrimitiveArray) -> usize
+pub fn vortex_array::arrays::FixedSizeList::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::stats(array: &vortex_array::arrays::PrimitiveArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::scalar_at(array: &vortex_array::arrays::PrimitiveArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::PrimitiveVTable::Array = vortex_array::arrays::PrimitiveArray
+pub struct vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub type vortex_array::arrays::PrimitiveVTable::ArrayVTable = vortex_array::arrays::PrimitiveVTable
+impl vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub type vortex_array::arrays::PrimitiveVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::build(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> Self
 
-pub type vortex_array::arrays::PrimitiveVTable::OperationsVTable = vortex_array::arrays::PrimitiveVTable
+pub unsafe fn vortex_array::arrays::fixed_size_list::FixedSizeListData::new_unchecked(list_size: u32, len: usize) -> Self
 
-pub type vortex_array::arrays::PrimitiveVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::validate(elements: &vortex_array::ArrayRef, len: usize, list_size: u32, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::PrimitiveVTable::VisitorVTable = vortex_array::arrays::PrimitiveVTable
+impl core::clone::Clone for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray>
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::clone(&self) -> vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl core::fmt::Debug for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Display for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::PrimitiveVTable::metadata(_array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::ArrayEq for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::PrimitiveVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::ArrayHash for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::PrimitiveVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub struct vortex_array::arrays::fixed_size_list::FixedSizeListDataParts
 
-pub fn vortex_array::arrays::PrimitiveVTable::nbuffers(_array: &vortex_array::arrays::PrimitiveArray) -> usize
+pub vortex_array::arrays::fixed_size_list::FixedSizeListDataParts::dtype: vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::PrimitiveVTable::nchildren(array: &vortex_array::arrays::PrimitiveArray) -> usize
+pub vortex_array::arrays::fixed_size_list::FixedSizeListDataParts::elements: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::nth_child(array: &vortex_array::arrays::PrimitiveArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub vortex_array::arrays::fixed_size_list::FixedSizeListDataParts::validity: vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::PrimitiveVTable::visit_buffers(array: &vortex_array::arrays::PrimitiveArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub trait vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::FixedSizeList>
 
-pub fn vortex_array::arrays::PrimitiveVTable::visit_children(array: &vortex_array::arrays::PrimitiveArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::dtype_parts(&self) -> (&vortex_array::dtype::DType, u32, vortex_array::dtype::Nullability)
 
-#[repr(C, align(8))] pub struct vortex_array::arrays::Ref
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::elements(&self) -> &vortex_array::ArrayRef
 
-pub vortex_array::arrays::Ref::buffer_index: u32
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::fixed_size_list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub vortex_array::arrays::Ref::offset: u32
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::fixed_size_list_validity(&self) -> vortex_array::validity::Validity
 
-pub vortex_array::arrays::Ref::prefix: [u8; 4]
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::fixed_size_list_validity_mask(&self) -> vortex_mask::Mask
 
-pub vortex_array::arrays::Ref::size: u32
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt::list_size(&self) -> u32
 
-impl vortex_array::arrays::Ref
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::FixedSizeList>> vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt for T
 
-pub fn vortex_array::arrays::Ref::as_range(&self) -> core::ops::range::Range<usize>
+pub fn T::dtype_parts(&self) -> (&vortex_array::dtype::DType, u32, vortex_array::dtype::Nullability)
 
-pub fn vortex_array::arrays::Ref::with_buffer_and_offset(&self, buffer_index: u32, offset: u32) -> vortex_array::arrays::Ref
+pub fn T::elements(&self) -> &vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::arrays::Ref
+pub fn T::fixed_size_list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::Ref::clone(&self) -> vortex_array::arrays::Ref
+pub fn T::fixed_size_list_validity(&self) -> vortex_array::validity::Validity
 
-impl core::convert::From<vortex_array::arrays::Ref> for vortex_array::arrays::BinaryView
+pub fn T::fixed_size_list_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::BinaryView::from(value: vortex_array::arrays::Ref) -> Self
+pub fn T::list_size(&self) -> u32
 
-impl core::fmt::Debug for vortex_array::arrays::Ref
+pub type vortex_array::arrays::fixed_size_list::FixedSizeListArray = vortex_array::Array<vortex_array::arrays::FixedSizeList>
 
-pub fn vortex_array::arrays::Ref::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod vortex_array::arrays::list
 
-impl core::marker::Copy for vortex_array::arrays::Ref
+pub struct vortex_array::arrays::list::List
 
-pub struct vortex_array::arrays::ScalarFnArray
+impl vortex_array::arrays::List
 
-impl vortex_array::arrays::ScalarFnArray
+pub const vortex_array::arrays::List::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ScalarFnArray::children(&self) -> &[vortex_array::ArrayRef]
+impl core::clone::Clone for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ScalarFnArray::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::arrays::List::clone(&self) -> vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ScalarFnArray::try_new(bound: vortex_array::scalar_fn::ScalarFnRef, children: alloc::vec::Vec<vortex_array::ArrayRef>, len: usize) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_array::arrays::List
 
-impl core::clone::Clone for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::List::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ScalarFnArray::clone(&self) -> vortex_array::arrays::ScalarFnArray
+impl vortex_array::OperationsVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::List::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::ScalarFnArray::as_ref(&self) -> &dyn vortex_array::Array
+impl vortex_array::VTable for vortex_array::arrays::List
 
-impl core::convert::From<vortex_array::arrays::ScalarFnArray> for vortex_array::ArrayRef
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::ScalarFnArray) -> vortex_array::ArrayRef
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-impl core::fmt::Debug for vortex_array::arrays::ScalarFnArray
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ScalarFnArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::ops::deref::Deref for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::ScalarFnArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ScalarFnArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::IntoArray for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ScalarFnArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::scalar_fn::ReduceNode for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ScalarFnArray::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnArray::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ScalarFnArray::child_count(&self) -> usize
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ScalarFnArray::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ScalarFnArray::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::arrays::ScalarFnArrayView<'a, F: vortex_array::scalar_fn::ScalarFnVTable>
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::arrays::ScalarFnArrayView::options: &'a <F as vortex_array::scalar_fn::ScalarFnVTable>::Options
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::arrays::ScalarFnArrayView::vtable: &'a F
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<F: vortex_array::scalar_fn::ScalarFnVTable> core::ops::deref::Deref for vortex_array::arrays::ScalarFnArrayView<'_, F>
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ScalarFnArrayView<'_, F>::Target = dyn vortex_array::Array
+impl vortex_array::ValidityVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ScalarFnArrayView<'_, F>::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::List::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub struct vortex_array::arrays::ScalarFnVTable
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::List
 
-impl core::clone::Clone for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::List::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::clone(&self) -> vortex_array::arrays::ScalarFnVTable
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::List
 
-impl core::fmt::Debug for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::List::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::List
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::List::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::List
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::List::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::array_eq(array: &vortex_array::arrays::ScalarFnArray, other: &vortex_array::arrays::ScalarFnArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ScalarFnVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ScalarFnArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::List::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::dtype(array: &vortex_array::arrays::ScalarFnArray) -> &vortex_array::dtype::DType
+pub struct vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ScalarFnVTable::len(array: &vortex_array::arrays::ScalarFnArray) -> usize
+impl vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ScalarFnVTable::stats(array: &vortex_array::arrays::ScalarFnArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::list::ListData::build(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub unsafe fn vortex_array::arrays::list::ListData::new_unchecked() -> Self
 
-pub fn vortex_array::arrays::ScalarFnVTable::scalar_at(array: &vortex_array::arrays::ScalarFnArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::list::ListData::validate(elements: &vortex_array::ArrayRef, offsets: &vortex_array::ArrayRef, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ScalarFnVTable
+impl core::clone::Clone for vortex_array::arrays::list::ListData
 
-pub type vortex_array::arrays::ScalarFnVTable::Array = vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::list::ListData::clone(&self) -> vortex_array::arrays::list::ListData
 
-pub type vortex_array::arrays::ScalarFnVTable::ArrayVTable = vortex_array::arrays::ScalarFnVTable
+impl core::default::Default for vortex_array::arrays::list::ListData
 
-pub type vortex_array::arrays::ScalarFnVTable::Metadata = vortex_array::arrays::scalar_fn::metadata::ScalarFnMetadata
+pub fn vortex_array::arrays::list::ListData::default() -> vortex_array::arrays::list::ListData
 
-pub type vortex_array::arrays::ScalarFnVTable::OperationsVTable = vortex_array::arrays::ScalarFnVTable
+impl core::fmt::Debug for vortex_array::arrays::list::ListData
 
-pub type vortex_array::arrays::ScalarFnVTable::ValidityVTable = vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::list::ListData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::ScalarFnVTable::VisitorVTable = vortex_array::arrays::ScalarFnVTable
+impl core::fmt::Display for vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ScalarFnVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::scalar_fn::metadata::ScalarFnMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::list::ListData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ScalarFnVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::ArrayEq for vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ScalarFnVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::list::ListData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ScalarFnVTable::id(array: &Self::Array) -> vortex_array::vtable::ArrayId
+impl vortex_array::ArrayHash for vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ScalarFnVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::list::ListData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::ScalarFnVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::arrays::list::ListDataParts
 
-pub fn vortex_array::arrays::ScalarFnVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub vortex_array::arrays::list::ListDataParts::dtype: vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::ScalarFnVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub vortex_array::arrays::list::ListDataParts::elements: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub vortex_array::arrays::list::ListDataParts::offsets: vortex_array::ArrayRef
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub vortex_array::arrays::list::ListDataParts::validity: vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::ScalarFnVTable::validity(array: &vortex_array::arrays::ScalarFnArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub trait vortex_array::arrays::list::ListArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::List>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::list::ListArrayExt::element_dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::ScalarFnVTable::nbuffers(_array: &vortex_array::arrays::ScalarFnArray) -> usize
+pub fn vortex_array::arrays::list::ListArrayExt::elements(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::nchildren(array: &vortex_array::arrays::ScalarFnArray) -> usize
+pub fn vortex_array::arrays::list::ListArrayExt::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ScalarFnVTable::nth_child(array: &vortex_array::arrays::ScalarFnArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::list::ListArrayExt::list_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_buffers(_array: &vortex_array::arrays::ScalarFnArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::list::ListArrayExt::list_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_children(array: &vortex_array::arrays::ScalarFnArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::list::ListArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_children_unnamed(array: &vortex_array::arrays::ScalarFnArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+pub fn vortex_array::arrays::list::ListArrayExt::offset_at(&self, index: usize) -> vortex_error::VortexResult<usize>
 
-pub struct vortex_array::arrays::SharedArray
+pub fn vortex_array::arrays::list::ListArrayExt::offsets(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::arrays::SharedArray
+pub fn vortex_array::arrays::list::ListArrayExt::reset_offsets(&self, recurse: bool) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::List>>
 
-pub fn vortex_array::arrays::SharedArray::get_or_compute(&self, f: impl core::ops::function::FnOnce(&vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::Canonical>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::list::ListArrayExt::sliced_elements(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub async fn vortex_array::arrays::SharedArray::get_or_compute_async<F, Fut>(&self, f: F) -> vortex_error::VortexResult<vortex_array::ArrayRef> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> Fut, Fut: core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::Canonical>>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::List>> vortex_array::arrays::list::ListArrayExt for T
 
-pub fn vortex_array::arrays::SharedArray::new(source: vortex_array::ArrayRef) -> Self
+pub fn T::element_dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::clone::Clone for vortex_array::arrays::SharedArray
+pub fn T::elements(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SharedArray::clone(&self) -> vortex_array::arrays::SharedArray
+pub fn T::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::SharedArray
+pub fn T::list_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::SharedArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn T::list_validity_mask(&self) -> vortex_mask::Mask
 
-impl core::convert::From<vortex_array::arrays::SharedArray> for vortex_array::ArrayRef
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::SharedArray) -> vortex_array::ArrayRef
+pub fn T::offset_at(&self, index: usize) -> vortex_error::VortexResult<usize>
 
-impl core::fmt::Debug for vortex_array::arrays::SharedArray
+pub fn T::offsets(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SharedArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn T::reset_offsets(&self, recurse: bool) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::List>>
 
-impl core::ops::deref::Deref for vortex_array::arrays::SharedArray
+pub fn T::sliced_elements(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::SharedArray::Target = dyn vortex_array::Array
+pub type vortex_array::arrays::list::ListArray = vortex_array::Array<vortex_array::arrays::List>
 
-pub fn vortex_array::arrays::SharedArray::deref(&self) -> &Self::Target
+pub mod vortex_array::arrays::listview
 
-impl vortex_array::IntoArray for vortex_array::arrays::SharedArray
+pub enum vortex_array::arrays::listview::ListViewRebuildMode
 
-pub fn vortex_array::arrays::SharedArray::into_array(self) -> vortex_array::ArrayRef
+pub vortex_array::arrays::listview::ListViewRebuildMode::MakeExact
 
-pub struct vortex_array::arrays::SharedVTable
+pub vortex_array::arrays::listview::ListViewRebuildMode::MakeZeroCopyToList
 
-impl vortex_array::arrays::SharedVTable
+pub vortex_array::arrays::listview::ListViewRebuildMode::OverlapCompression
 
-pub const vortex_array::arrays::SharedVTable::ID: vortex_array::vtable::ArrayId
+pub vortex_array::arrays::listview::ListViewRebuildMode::TrimElements
 
-impl core::fmt::Debug for vortex_array::arrays::SharedVTable
+pub struct vortex_array::arrays::listview::ListView
 
-pub fn vortex_array::arrays::SharedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::ListView
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub const vortex_array::arrays::ListView::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::SharedVTable::array_eq(array: &vortex_array::arrays::SharedArray, other: &vortex_array::arrays::SharedArray, precision: vortex_array::Precision) -> bool
+impl core::clone::Clone for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SharedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::SharedArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::ListView::clone(&self) -> vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SharedVTable::dtype(array: &vortex_array::arrays::SharedArray) -> &vortex_array::dtype::DType
+impl core::fmt::Debug for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SharedVTable::len(array: &vortex_array::arrays::SharedArray) -> usize
+pub fn vortex_array::arrays::ListView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::SharedVTable::stats(array: &vortex_array::arrays::SharedArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::OperationsVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::SharedVTable::scalar_at(array: &vortex_array::arrays::SharedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::SharedVTable
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-pub type vortex_array::arrays::SharedVTable::Array = vortex_array::arrays::SharedArray
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-pub type vortex_array::arrays::SharedVTable::ArrayVTable = vortex_array::arrays::SharedVTable
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-pub type vortex_array::arrays::SharedVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::SharedVTable::OperationsVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::SharedVTable::ValidityVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::SharedVTable::VisitorVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SharedVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::SharedArray>
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::SharedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::SharedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::SharedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SharedVTable::metadata(_array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::SharedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::SharedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SharedVTable::validity(array: &vortex_array::arrays::SharedArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::SharedVTable::nchildren(_array: &vortex_array::arrays::SharedArray) -> usize
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::SharedVTable::nth_child(array: &vortex_array::arrays::SharedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::SharedVTable::visit_buffers(_array: &vortex_array::arrays::SharedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::ValidityVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SharedVTable::visit_children(array: &vortex_array::arrays::SharedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::ListView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub struct vortex_array::arrays::SliceArray
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::ListView
 
-impl vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::ListView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceArray::child(&self) -> &vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SliceArray::into_parts(self) -> vortex_array::arrays::SliceArrayParts
+pub fn vortex_array::arrays::ListView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceArray::new(child: vortex_array::ArrayRef, range: core::ops::range::Range<usize>) -> Self
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::SliceArray::slice_range(&self) -> &core::ops::range::Range<usize>
+pub fn vortex_array::arrays::ListView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceArray::try_new(child: vortex_array::ArrayRef, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListView
 
-impl core::clone::Clone for vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::ListView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceArray::clone(&self) -> vortex_array::arrays::SliceArray
+pub struct vortex_array::arrays::listview::ListViewData
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::SliceArray
+impl vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::listview::ListViewData::is_zero_copy_to_list(&self) -> bool
 
-impl core::convert::From<vortex_array::arrays::SliceArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::listview::ListViewData::new() -> Self
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::SliceArray) -> vortex_array::ArrayRef
+pub unsafe fn vortex_array::arrays::listview::ListViewData::new_unchecked() -> Self
 
-impl core::fmt::Debug for vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::listview::ListViewData::try_new() -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::SliceArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::listview::ListViewData::validate(elements: &vortex_array::ArrayRef, offsets: &vortex_array::ArrayRef, sizes: &vortex_array::ArrayRef, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-impl core::ops::deref::Deref for vortex_array::arrays::SliceArray
+pub unsafe fn vortex_array::arrays::listview::ListViewData::with_zero_copy_to_list(self, is_zctl: bool) -> Self
 
-pub type vortex_array::arrays::SliceArray::Target = dyn vortex_array::Array
+impl core::clone::Clone for vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::listview::ListViewData::clone(&self) -> vortex_array::arrays::listview::ListViewData
 
-impl vortex_array::IntoArray for vortex_array::arrays::SliceArray
+impl core::default::Default for vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::listview::ListViewData::default() -> Self
 
-pub struct vortex_array::arrays::SliceArrayParts
+impl core::fmt::Debug for vortex_array::arrays::listview::ListViewData
 
-pub vortex_array::arrays::SliceArrayParts::child: vortex_array::ArrayRef
+pub fn vortex_array::arrays::listview::ListViewData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::arrays::SliceArrayParts::range: core::ops::range::Range<usize>
+impl core::fmt::Display for vortex_array::arrays::listview::ListViewData
 
-pub struct vortex_array::arrays::SliceExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::listview::ListViewData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::SliceExecuteAdaptor<V>
+impl vortex_array::ArrayEq for vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceExecuteAdaptor<V>::default() -> vortex_array::arrays::SliceExecuteAdaptor<V>
+pub fn vortex_array::arrays::listview::ListViewData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::SliceExecuteAdaptor<V>
+impl vortex_array::ArrayHash for vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::listview::ListViewData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::SliceExecuteAdaptor<V> where V: vortex_array::arrays::SliceKernel
+pub struct vortex_array::arrays::listview::ListViewDataParts
 
-pub type vortex_array::arrays::SliceExecuteAdaptor<V>::Parent = vortex_array::arrays::SliceVTable
+pub vortex_array::arrays::listview::ListViewDataParts::elements: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub vortex_array::arrays::listview::ListViewDataParts::elements_dtype: alloc::sync::Arc<vortex_array::dtype::DType>
 
-pub struct vortex_array::arrays::SliceMetadata(_)
+pub vortex_array::arrays::listview::ListViewDataParts::offsets: vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::arrays::SliceMetadata
+pub vortex_array::arrays::listview::ListViewDataParts::sizes: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub vortex_array::arrays::listview::ListViewDataParts::validity: vortex_array::validity::Validity
 
-pub struct vortex_array::arrays::SliceReduceAdaptor<V>(pub V)
+pub trait vortex_array::arrays::listview::ListViewArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::ListView>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::SliceReduceAdaptor<V>
+pub fn vortex_array::arrays::listview::ListViewArrayExt::elements(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceReduceAdaptor<V>::default() -> vortex_array::arrays::SliceReduceAdaptor<V>
+pub fn vortex_array::arrays::listview::ListViewArrayExt::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::SliceReduceAdaptor<V>
+pub fn vortex_array::arrays::listview::ListViewArrayExt::listview_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::SliceReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::listview::ListViewArrayExt::listview_validity_mask(&self) -> vortex_mask::Mask
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::SliceReduceAdaptor<V> where V: vortex_array::arrays::SliceReduce
+pub fn vortex_array::arrays::listview::ListViewArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub type vortex_array::arrays::SliceReduceAdaptor<V>::Parent = vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::listview::ListViewArrayExt::offset_at(&self, index: usize) -> usize
 
-pub fn vortex_array::arrays::SliceReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::listview::ListViewArrayExt::offsets(&self) -> &vortex_array::ArrayRef
 
-pub struct vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::listview::ListViewArrayExt::size_at(&self, index: usize) -> usize
 
-impl vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::listview::ListViewArrayExt::sizes(&self) -> &vortex_array::ArrayRef
 
-pub const vortex_array::arrays::SliceVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::listview::ListViewArrayExt::verify_is_zero_copy_to_list(&self) -> bool
 
-impl core::fmt::Debug for vortex_array::arrays::SliceVTable
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::ListView>> vortex_array::arrays::listview::ListViewArrayExt for T
 
-pub fn vortex_array::arrays::SliceVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn T::elements(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::SliceVTable
+pub fn T::list_elements_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::SliceVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::listview_validity(&self) -> vortex_array::validity::Validity
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn T::listview_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::SliceVTable::array_eq(array: &vortex_array::arrays::SliceArray, other: &vortex_array::arrays::SliceArray, precision: vortex_array::Precision) -> bool
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::SliceVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::SliceArray, state: &mut H, precision: vortex_array::Precision)
+pub fn T::offset_at(&self, index: usize) -> usize
 
-pub fn vortex_array::arrays::SliceVTable::dtype(array: &vortex_array::arrays::SliceArray) -> &vortex_array::dtype::DType
+pub fn T::offsets(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceVTable::len(array: &vortex_array::arrays::SliceArray) -> usize
+pub fn T::size_at(&self, index: usize) -> usize
 
-pub fn vortex_array::arrays::SliceVTable::stats(array: &vortex_array::arrays::SliceArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn T::sizes(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn T::verify_is_zero_copy_to_list(&self) -> bool
 
-pub fn vortex_array::arrays::SliceVTable::scalar_at(array: &vortex_array::arrays::SliceArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::listview::list_from_list_view(list_view: vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<vortex_array::arrays::ListArray>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::listview::list_view_from_list(list: vortex_array::arrays::ListArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
 
-pub type vortex_array::arrays::SliceVTable::Array = vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::listview::recursive_list_from_list_view(array: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::SliceVTable::ArrayVTable = vortex_array::arrays::SliceVTable
+pub type vortex_array::arrays::listview::ListViewArray = vortex_array::Array<vortex_array::arrays::ListView>
 
-pub type vortex_array::arrays::SliceVTable::Metadata = vortex_array::arrays::SliceMetadata
+pub mod vortex_array::arrays::masked
 
-pub type vortex_array::arrays::SliceVTable::OperationsVTable = vortex_array::arrays::SliceVTable
+pub struct vortex_array::arrays::masked::Masked
 
-pub type vortex_array::arrays::SliceVTable::ValidityVTable = vortex_array::arrays::SliceVTable
+impl vortex_array::arrays::Masked
 
-pub type vortex_array::arrays::SliceVTable::VisitorVTable = vortex_array::arrays::SliceVTable
+pub const vortex_array::arrays::Masked::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::SliceVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::SliceMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+impl core::clone::Clone for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Masked::clone(&self) -> vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::fmt::Debug for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Masked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::SliceVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Masked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::SliceVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::SliceVTable::validity(array: &vortex_array::arrays::SliceArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::SliceVTable::nchildren(_array: &vortex_array::arrays::SliceArray) -> usize
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::SliceVTable::nth_child(array: &vortex_array::arrays::SliceArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::SliceVTable::visit_buffers(_array: &vortex_array::arrays::SliceArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceVTable::visit_children(array: &vortex_array::arrays::SliceArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::StructArray::from_fields<N: core::convert::AsRef<str>>(items: &[(N, vortex_array::ArrayRef)]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructArray::into_fields(self) -> alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::StructArray::into_parts(self) -> vortex_array::arrays::StructArrayParts
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::StructArray::names(&self) -> &vortex_array::dtype::FieldNames
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::StructArray::new(names: vortex_array::dtype::FieldNames, fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, length: usize, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructArray::new_fieldless_with_len(len: usize) -> Self
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::arrays::StructArray::new_unchecked(fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, dtype: vortex_array::dtype::StructFields, length: usize, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::StructArray::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::StructArray::remove_column(&mut self, name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::StructArray::struct_fields(&self) -> &vortex_array::dtype::StructFields
+impl vortex_array::ValidityVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructArray::try_from_iter<N: core::convert::AsRef<str>, A: vortex_array::IntoArray, T: core::iter::traits::collect::IntoIterator<Item = (N, A)>>(iter: T) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::StructArray::try_from_iter_with_validity<N: core::convert::AsRef<str>, A: vortex_array::IntoArray, T: core::iter::traits::collect::IntoIterator<Item = (N, A)>>(iter: T, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructArray::try_new(names: vortex_array::dtype::FieldNames, fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, length: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructArray::try_new_with_dtype(fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, dtype: vortex_array::dtype::StructFields, length: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructArray::unmasked_field_by_name(&self, name: impl core::convert::AsRef<str>) -> vortex_error::VortexResult<&vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructArray::unmasked_field_by_name_opt(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<&vortex_array::ArrayRef>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructArray::unmasked_fields(&self) -> &alloc::sync::Arc<[vortex_array::ArrayRef]>
+pub fn vortex_array::arrays::Masked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructArray::validate(fields: &[vortex_array::ArrayRef], dtype: &vortex_array::dtype::StructFields, length: usize, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructArray::with_column(&self, name: impl core::convert::Into<vortex_array::dtype::FieldName>, array: vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::StructArray
+pub struct vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::arrays::StructArray::into_record_batch_with_schema(self, schema: impl core::convert::AsRef<arrow_schema::schema::Schema>) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
+impl core::clone::Clone for vortex_array::arrays::masked::MaskedData
 
-impl core::clone::Clone for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedData::clone(&self) -> vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::arrays::StructArray::clone(&self) -> vortex_array::arrays::StructArray
+impl core::fmt::Debug for vortex_array::arrays::masked::MaskedData
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::StructArray::as_ref(&self) -> &dyn vortex_array::Array
+impl core::fmt::Display for vortex_array::arrays::masked::MaskedData
 
-impl core::convert::From<vortex_array::arrays::StructArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::masked::MaskedData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::StructArray) -> vortex_array::ArrayRef
+impl vortex_array::ArrayEq for vortex_array::arrays::masked::MaskedData
 
-impl core::fmt::Debug for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::StructArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::ArrayHash for vortex_array::arrays::masked::MaskedData
 
-impl core::ops::deref::Deref for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub type vortex_array::arrays::StructArray::Target = dyn vortex_array::Array
+pub trait vortex_array::arrays::masked::MaskedArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Masked>
 
-pub fn vortex_array::arrays::StructArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::masked::MaskedArrayExt::child(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::Executable for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedArrayExt::masked_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::StructArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::masked::MaskedArrayExt::masked_validity_mask(&self) -> vortex_mask::Mask
 
-impl vortex_array::IntoArray for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::masked::MaskedArrayExt::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::StructArray::into_array(self) -> vortex_array::ArrayRef
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Masked>> vortex_array::arrays::masked::MaskedArrayExt for T
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::StructArray
+pub fn T::child(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn T::masked_validity(&self) -> vortex_array::validity::Validity
 
-pub struct vortex_array::arrays::StructArrayParts
+pub fn T::masked_validity_mask(&self) -> vortex_mask::Mask
 
-pub vortex_array::arrays::StructArrayParts::fields: alloc::sync::Arc<[vortex_array::ArrayRef]>
+pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub vortex_array::arrays::StructArrayParts::struct_fields: vortex_array::dtype::StructFields
+pub fn vortex_array::arrays::masked::mask_validity_canonical(canonical: vortex_array::Canonical, validity_mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-pub vortex_array::arrays::StructArrayParts::validity: vortex_array::validity::Validity
+pub type vortex_array::arrays::masked::MaskedArray = vortex_array::Array<vortex_array::arrays::Masked>
 
-pub struct vortex_array::arrays::StructVTable
+pub mod vortex_array::arrays::null
 
-impl vortex_array::arrays::StructVTable
+pub struct vortex_array::arrays::null::Null
 
-pub const vortex_array::arrays::StructVTable::ID: vortex_array::vtable::ArrayId
+impl vortex_array::arrays::null::Null
 
-impl core::fmt::Debug for vortex_array::arrays::StructVTable
+pub const vortex_array::arrays::null::Null::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::StructVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::null::Null
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::StructVTable
+pub const vortex_array::arrays::null::Null::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
-pub fn vortex_array::arrays::StructVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::arrays::null::Null
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::clone(&self) -> vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::take(array: &vortex_array::arrays::StructArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::arrays::null::Null
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::StructVTable::is_constant(&self, array: &vortex_array::arrays::StructArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::scalar_at(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::StructVTable::min_max(&self, _array: &vortex_array::arrays::StructArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::StructVTable
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::arrays::StructVTable::cast(array: &vortex_array::arrays::StructArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::StructVTable
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::mask(array: &vortex_array::arrays::StructArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::StructVTable::zip(if_true: &vortex_array::arrays::StructArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructVTable::array_eq(array: &vortex_array::arrays::StructArray, other: &vortex_array::arrays::StructArray, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::StructVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::StructArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::StructVTable::dtype(array: &vortex_array::arrays::StructArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::StructVTable::len(array: &vortex_array::arrays::StructArray) -> usize
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::stats(array: &vortex_array::arrays::StructArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::StructVTable::scalar_at(array: &vortex_array::arrays::StructArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::StructVTable::Array = vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::StructVTable::ArrayVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::StructVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::StructVTable::OperationsVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::StructVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::ValidityVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub type vortex_array::arrays::StructVTable::VisitorVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::validity(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::StructVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::StructArray>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::null::Null::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::null::Null::filter(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::metadata(_array: &vortex_array::arrays::StructArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::null::Null::slice(_array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrays::StructVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::null::Null::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::null::Null
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::null::Null::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::nbuffers(_array: &vortex_array::arrays::StructArray) -> usize
+pub type vortex_array::arrays::null::NullArray = vortex_array::Array<vortex_array::arrays::null::Null>
 
-pub fn vortex_array::arrays::StructVTable::nchildren(array: &vortex_array::arrays::StructArray) -> usize
+pub mod vortex_array::arrays::patched
 
-pub fn vortex_array::arrays::StructVTable::nth_child(array: &vortex_array::arrays::StructArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub struct vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::StructVTable::visit_buffers(_array: &vortex_array::arrays::StructArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::StructVTable::visit_children(array: &vortex_array::arrays::StructArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::patched::Patched::from_array_and_patches(inner: vortex_array::ArrayRef, patches: &vortex_array::patches::Patches, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::patched::Patched>>
 
-pub fn vortex_array::arrays::StructVTable::visit_children_unnamed(array: &vortex_array::arrays::StructArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+impl core::clone::Clone for vortex_array::arrays::patched::Patched
 
-pub struct vortex_array::arrays::TakeExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::patched::Patched::clone(&self) -> vortex_array::arrays::patched::Patched
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::TakeExecuteAdaptor<V>
+impl core::fmt::Debug for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::TakeExecuteAdaptor<V>::default() -> vortex_array::arrays::TakeExecuteAdaptor<V>
+pub fn vortex_array::arrays::patched::Patched::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::TakeExecuteAdaptor<V>
+impl vortex_array::OperationsVTable<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::TakeExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::Patched::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::TakeExecuteAdaptor<V> where V: vortex_array::arrays::TakeExecute
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-pub type vortex_array::arrays::TakeExecuteAdaptor<V>::Parent = vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::TakeExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-pub struct vortex_array::arrays::TakeReduceAdaptor<V>(pub V)
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-impl<V: core::default::Default> core::default::Default for vortex_array::arrays::TakeReduceAdaptor<V>
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::TakeReduceAdaptor<V>::default() -> vortex_array::arrays::TakeReduceAdaptor<V>
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::TakeReduceAdaptor<V>
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::TakeReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::TakeReduceAdaptor<V> where V: vortex_array::arrays::TakeReduce
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::TakeReduceAdaptor<V>::Parent = vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::TakeReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::arrays::DictArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::TemporalArray::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::TemporalArray::ext_dtype(&self) -> vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::TemporalArray::temporal_metadata(&self) -> vortex_array::extension::datetime::TemporalMetadata<'_>
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::TemporalArray::temporal_values(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::TemporalArray::new_date(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit) -> Self
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::TemporalArray::new_time(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit) -> Self
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::TemporalArray::new_timestamp(array: vortex_array::ArrayRef, time_unit: vortex_array::extension::datetime::TimeUnit, time_zone: core::option::Option<alloc::sync::Arc<str>>) -> Self
+impl vortex_array::ValidityChild<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-impl core::clone::Clone for vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::Patched::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::TemporalArray::clone(&self) -> vortex_array::arrays::TemporalArray
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::patched::Patched
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::Patched::take(array: vortex_array::ArrayView<'_, Self>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::TemporalArray::as_ref(&self) -> &dyn vortex_array::Array
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::patched::Patched
 
-impl core::convert::From<&vortex_array::arrays::TemporalArray> for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::patched::Patched::filter(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ExtensionArray::from(value: &vortex_array::arrays::TemporalArray) -> Self
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::patched::Patched
 
-impl core::convert::From<vortex_array::arrays::TemporalArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::Patched::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::TemporalArray) -> Self
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::patched::Patched
 
-impl core::convert::From<vortex_array::arrays::TemporalArray> for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::patched::Patched::compare(lhs: vortex_array::ArrayView<'_, Self>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ExtensionArray::from(value: vortex_array::arrays::TemporalArray) -> Self
+pub struct vortex_array::arrays::patched::PatchedData
 
-impl core::convert::TryFrom<alloc::sync::Arc<dyn vortex_array::Array>> for vortex_array::arrays::TemporalArray
+impl core::clone::Clone for vortex_array::arrays::patched::PatchedData
 
-pub type vortex_array::arrays::TemporalArray::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::patched::PatchedData::clone(&self) -> vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::TemporalArray::try_from(value: vortex_array::ArrayRef) -> core::result::Result<Self, Self::Error>
+impl core::fmt::Debug for vortex_array::arrays::patched::PatchedData
 
-impl core::convert::TryFrom<vortex_array::arrays::ExtensionArray> for vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::patched::PatchedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::TemporalArray::Error = vortex_error::VortexError
+impl core::fmt::Display for vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::TemporalArray::try_from(ext: vortex_array::arrays::ExtensionArray) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::patched::PatchedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::fmt::Debug for vortex_array::arrays::TemporalArray
+impl vortex_array::ArrayEq for vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::TemporalArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::PatchedData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl vortex_array::IntoArray for vortex_array::arrays::TemporalArray
+impl vortex_array::ArrayHash for vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::TemporalArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::PatchedData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub struct vortex_array::arrays::VarBinArray
+pub struct vortex_array::arrays::patched::PatchedMetadata
 
-impl vortex_array::arrays::VarBinArray
+impl core::clone::Clone for vortex_array::arrays::patched::PatchedMetadata
 
-pub fn vortex_array::arrays::VarBinArray::bytes(&self) -> &vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::patched::PatchedMetadata::clone(&self) -> vortex_array::arrays::patched::PatchedMetadata
 
-pub fn vortex_array::arrays::VarBinArray::bytes_at(&self, index: usize) -> vortex_buffer::ByteBuffer
+impl core::default::Default for vortex_array::arrays::patched::PatchedMetadata
 
-pub fn vortex_array::arrays::VarBinArray::bytes_handle(&self) -> &vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::patched::PatchedMetadata::default() -> Self
 
-pub fn vortex_array::arrays::VarBinArray::from_iter<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
+impl core::fmt::Debug for vortex_array::arrays::patched::PatchedMetadata
 
-pub fn vortex_array::arrays::VarBinArray::from_iter_nonnull<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
+pub fn vortex_array::arrays::patched::PatchedMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinArray::from_vec<T: core::convert::AsRef<[u8]>>(vec: alloc::vec::Vec<T>, dtype: vortex_array::dtype::DType) -> Self
+impl prost::message::Message for vortex_array::arrays::patched::PatchedMetadata
 
-pub fn vortex_array::arrays::VarBinArray::into_parts(self) -> (vortex_array::dtype::DType, vortex_array::buffer::BufferHandle, vortex_array::ArrayRef, vortex_array::validity::Validity)
+pub fn vortex_array::arrays::patched::PatchedMetadata::clear(&mut self)
 
-pub fn vortex_array::arrays::VarBinArray::new(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::patched::PatchedMetadata::encoded_len(&self) -> usize
 
-pub fn vortex_array::arrays::VarBinArray::new_from_handle(offset: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub struct vortex_array::arrays::patched::PatchedSlots
 
-pub unsafe fn vortex_array::arrays::VarBinArray::new_unchecked(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub vortex_array::arrays::patched::PatchedSlots::inner: vortex_array::ArrayRef
 
-pub unsafe fn vortex_array::arrays::VarBinArray::new_unchecked_from_handle(offsets: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub vortex_array::arrays::patched::PatchedSlots::lane_offsets: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::offset_at(&self, index: usize) -> usize
+pub vortex_array::arrays::patched::PatchedSlots::patch_indices: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::offsets(&self) -> &vortex_array::ArrayRef
+pub vortex_array::arrays::patched::PatchedSlots::patch_values: vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::sliced_bytes(&self) -> vortex_buffer::ByteBuffer
+impl vortex_array::arrays::patched::PatchedSlots
 
-pub fn vortex_array::arrays::VarBinArray::try_new(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub const vortex_array::arrays::patched::PatchedSlots::COUNT: usize
 
-pub fn vortex_array::arrays::VarBinArray::try_new_from_handle(offsets: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub const vortex_array::arrays::patched::PatchedSlots::INNER: usize
 
-pub fn vortex_array::arrays::VarBinArray::validate(offsets: &dyn vortex_array::Array, bytes: &vortex_array::buffer::BufferHandle, dtype: &vortex_array::dtype::DType, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+pub const vortex_array::arrays::patched::PatchedSlots::LANE_OFFSETS: usize
 
-impl core::clone::Clone for vortex_array::arrays::VarBinArray
+pub const vortex_array::arrays::patched::PatchedSlots::NAMES: [&'static str; 4]
 
-pub fn vortex_array::arrays::VarBinArray::clone(&self) -> vortex_array::arrays::VarBinArray
+pub const vortex_array::arrays::patched::PatchedSlots::PATCH_INDICES: usize
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::VarBinArray
+pub const vortex_array::arrays::patched::PatchedSlots::PATCH_VALUES: usize
 
-pub fn vortex_array::arrays::VarBinArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::patched::PatchedSlots::from_slots(slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> Self
 
-impl core::convert::From<alloc::vec::Vec<&[u8]>> for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedSlots::into_slots(self) -> alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<&[u8]>) -> Self
+pub struct vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-impl core::convert::From<alloc::vec::Vec<&str>> for vortex_array::arrays::VarBinArray
+pub vortex_array::arrays::patched::PatchedSlotsView::inner: &'a vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<&str>) -> Self
+pub vortex_array::arrays::patched::PatchedSlotsView::lane_offsets: &'a vortex_array::ArrayRef
 
-impl core::convert::From<alloc::vec::Vec<alloc::string::String>> for vortex_array::arrays::VarBinArray
+pub vortex_array::arrays::patched::PatchedSlotsView::patch_indices: &'a vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<alloc::string::String>) -> Self
+pub vortex_array::arrays::patched::PatchedSlotsView::patch_values: &'a vortex_array::ArrayRef
 
-impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for vortex_array::arrays::VarBinArray
+impl<'a> vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
+pub fn vortex_array::arrays::patched::PatchedSlotsView<'a>::from_slots(slots: &'a [core::option::Option<vortex_array::ArrayRef>]) -> Self
 
-impl core::convert::From<alloc::vec::Vec<core::option::Option<&[u8]>>> for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedSlotsView<'a>::to_owned(&self) -> vortex_array::arrays::patched::PatchedSlots
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<core::option::Option<&[u8]>>) -> Self
+impl<'a> core::clone::Clone for vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-impl core::convert::From<alloc::vec::Vec<core::option::Option<&str>>> for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedSlotsView<'a>::clone(&self) -> vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<core::option::Option<&str>>) -> Self
+impl<'a> core::fmt::Debug for vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-impl core::convert::From<alloc::vec::Vec<core::option::Option<alloc::string::String>>> for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedSlotsView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<core::option::Option<alloc::string::String>>) -> Self
+impl<'a> core::marker::Copy for vortex_array::arrays::patched::PatchedSlotsView<'a>
 
-impl core::convert::From<alloc::vec::Vec<core::option::Option<alloc::vec::Vec<u8>>>> for vortex_array::arrays::VarBinArray
+pub trait vortex_array::arrays::patched::PatchedArrayExt: vortex_array::arrays::patched::PatchedArraySlotsExt
 
-pub fn vortex_array::arrays::VarBinArray::from(value: alloc::vec::Vec<core::option::Option<alloc::vec::Vec<u8>>>) -> Self
+pub fn vortex_array::arrays::patched::PatchedArrayExt::lane_range(&self, chunk: usize, lane: usize) -> vortex_error::VortexResult<core::ops::range::Range<usize>>
 
-impl core::convert::From<vortex_array::arrays::VarBinArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::PatchedArrayExt::n_lanes(&self) -> usize
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::VarBinArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::PatchedArrayExt::offset(&self) -> usize
 
-impl core::fmt::Debug for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedArrayExt::slice_chunks(&self, chunks: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::patched::Patched>>
 
-pub fn vortex_array::arrays::VarBinArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::patched::Patched>> vortex_array::arrays::patched::PatchedArrayExt for T
 
-impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::string::String>> for vortex_array::arrays::VarBinArray
+pub fn T::lane_range(&self, chunk: usize, lane: usize) -> vortex_error::VortexResult<core::ops::range::Range<usize>>
 
-pub fn vortex_array::arrays::VarBinArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::string::String>>>(iter: T) -> Self
+pub fn T::n_lanes(&self) -> usize
 
-impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::vec::Vec<u8>>> for vortex_array::arrays::VarBinArray
+pub fn T::offset(&self) -> usize
 
-pub fn vortex_array::arrays::VarBinArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::vec::Vec<u8>>>>(iter: T) -> Self
+pub fn T::slice_chunks(&self, chunks: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::patched::Patched>>
 
-impl core::ops::deref::Deref for vortex_array::arrays::VarBinArray
+pub trait vortex_array::arrays::patched::PatchedArraySlotsExt: vortex_array::TypedArrayRef<vortex_array::arrays::patched::Patched>
 
-pub type vortex_array::arrays::VarBinArray::Target = dyn vortex_array::Array
+pub fn vortex_array::arrays::patched::PatchedArraySlotsExt::inner(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::patched::PatchedArraySlotsExt::lane_offsets(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::IntoArray for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedArraySlotsExt::patch_indices(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::PatchedArraySlotsExt::patch_values(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::accessor::ArrayAccessor<[u8]> for &vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::PatchedArraySlotsExt::slots_view(&self) -> vortex_array::arrays::patched::PatchedSlotsView<'_>
 
-pub fn &vortex_array::arrays::VarBinArray::with_iterator<F, R>(&self, f: F) -> R where F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a [u8]>>) -> R
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::patched::Patched>> vortex_array::arrays::patched::PatchedArraySlotsExt for T
 
-impl vortex_array::accessor::ArrayAccessor<[u8]> for vortex_array::arrays::VarBinArray
+pub fn T::inner(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::with_iterator<F, R>(&self, f: F) -> R where F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a [u8]>>) -> R
+pub fn T::lane_offsets(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::VarBinArray
+pub fn T::patch_indices(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn T::patch_values(&self) -> &vortex_array::ArrayRef
 
-impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a [u8]>> for vortex_array::arrays::VarBinArray
+pub fn T::slots_view(&self) -> vortex_array::arrays::patched::PatchedSlotsView<'_>
 
-pub fn vortex_array::arrays::VarBinArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a [u8]>>>(iter: T) -> Self
+pub type vortex_array::arrays::patched::PatchedArray = vortex_array::Array<vortex_array::arrays::patched::Patched>
 
-impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a str>> for vortex_array::arrays::VarBinArray
+pub mod vortex_array::arrays::primitive
 
-pub fn vortex_array::arrays::VarBinArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a str>>>(iter: T) -> Self
+#[repr(transparent)] pub struct vortex_array::arrays::primitive::NativeValue<T>(pub T)
 
-pub struct vortex_array::arrays::VarBinVTable
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<f32>
 
-impl vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<f32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub const vortex_array::arrays::VarBinVTable::ID: vortex_array::vtable::ArrayId
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<f64>
 
-impl vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<f64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::_slice(array: &vortex_array::arrays::VarBinArray, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<half::binary16::f16>
 
-impl core::fmt::Debug for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<half::binary16::f16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<i16>
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<i16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::filter(array: &vortex_array::arrays::VarBinArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<i32>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<i32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<i64>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<i64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::take(array: &vortex_array::arrays::VarBinArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<i8>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<i8>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::is_constant(&self, array: &vortex_array::arrays::VarBinArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<u16>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::primitive::NativeValue<u16>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::arrays::VarBinVTable::is_sorted(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<u32>
 
-pub fn vortex_array::arrays::VarBinVTable::is_strict_sorted(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::primitive::NativeValue<u32>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::VarBinVTable
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<u64>
 
-pub fn vortex_array::arrays::VarBinVTable::min_max(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::primitive::NativeValue<u64>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::VarBinVTable
+impl core::hash::Hash for vortex_array::arrays::primitive::NativeValue<u8>
 
-pub fn vortex_array::arrays::VarBinVTable::compare(lhs: &vortex_array::arrays::VarBinArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::primitive::NativeValue<u8>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinVTable
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::cast(array: &vortex_array::arrays::VarBinArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::primitive::NativeValue<T>::clone(&self) -> vortex_array::arrays::primitive::NativeValue<T>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinVTable
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::mask(array: &vortex_array::arrays::VarBinArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::primitive::NativeValue<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+impl<T: core::marker::Copy> core::marker::Copy for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::array_eq(array: &vortex_array::arrays::VarBinArray, other: &vortex_array::arrays::VarBinArray, precision: vortex_array::Precision) -> bool
+impl<T: vortex_array::dtype::NativePType> core::cmp::Eq for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::VarBinArray, state: &mut H, precision: vortex_array::Precision)
+impl<T: vortex_array::dtype::NativePType> core::cmp::PartialEq for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::dtype(array: &vortex_array::arrays::VarBinArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::primitive::NativeValue<T>::eq(&self, other: &vortex_array::arrays::primitive::NativeValue<T>) -> bool
 
-pub fn vortex_array::arrays::VarBinVTable::len(array: &vortex_array::arrays::VarBinArray) -> usize
+impl<T: vortex_array::dtype::NativePType> core::cmp::PartialOrd for vortex_array::arrays::primitive::NativeValue<T>
 
-pub fn vortex_array::arrays::VarBinVTable::stats(array: &vortex_array::arrays::VarBinArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::primitive::NativeValue<T>::partial_cmp(&self, other: &vortex_array::arrays::primitive::NativeValue<T>) -> core::option::Option<core::cmp::Ordering>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+pub struct vortex_array::arrays::primitive::Primitive
 
-pub fn vortex_array::arrays::VarBinVTable::scalar_at(array: &vortex_array::arrays::VarBinArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl vortex_array::arrays::Primitive
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::VarBinVTable
+pub const vortex_array::arrays::Primitive::ID: vortex_array::ArrayId
 
-pub type vortex_array::arrays::VarBinVTable::Array = vortex_array::arrays::VarBinArray
+impl core::clone::Clone for vortex_array::arrays::Primitive
 
-pub type vortex_array::arrays::VarBinVTable::ArrayVTable = vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Primitive::clone(&self) -> vortex_array::arrays::Primitive
 
-pub type vortex_array::arrays::VarBinVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::varbin::vtable::VarBinMetadata>
+impl core::fmt::Debug for vortex_array::arrays::Primitive
 
-pub type vortex_array::arrays::VarBinVTable::OperationsVTable = vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Primitive::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::VarBinVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::OperationsVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub type vortex_array::arrays::VarBinVTable::VisitorVTable = vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Primitive::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::VarBinArray>
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::VarBinVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::VarBinVTable::metadata(array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::VarBinVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::VarBinVTable::nbuffers(_array: &vortex_array::arrays::VarBinArray) -> usize
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::VarBinVTable::nchildren(array: &vortex_array::arrays::VarBinArray) -> usize
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinVTable::nth_child(array: &vortex_array::arrays::VarBinArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::VarBinVTable::visit_buffers(array: &vortex_array::arrays::VarBinArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::VarBinVTable::visit_children(array: &vortex_array::arrays::VarBinArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::buffer(&self, idx: usize) -> &vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::VarBinViewArray::buffers(&self) -> &alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::VarBinViewArray::bytes_at(&self, index: usize) -> vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
+impl vortex_array::ValidityVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
+pub fn vortex_array::arrays::Primitive::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter_nullable_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter_nullable_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
+pub fn vortex_array::arrays::Primitive::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinViewArray::into_parts(self) -> vortex_array::arrays::VarBinViewArrayParts
+pub fn vortex_array::arrays::Primitive::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::nbuffers(&self) -> usize
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Primitive> for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-pub fn vortex_array::arrays::VarBinViewArray::new(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub type vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::VarBinViewArray::new_handle(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::arrays::VarBinViewArray::new_handle_unchecked(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Primitive
 
-pub unsafe fn vortex_array::arrays::VarBinViewArray::new_unchecked(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
+pub fn vortex_array::arrays::Primitive::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::try_new(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinViewArray::try_new_handle(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Primitive::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, dtype: &vortex_array::dtype::DType, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::validate(views: &vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>, buffers: &alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: &vortex_array::dtype::DType, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::VarBinViewArray::views(&self) -> &[vortex_array::arrays::BinaryView]
+pub fn vortex_array::arrays::Primitive::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::views_handle(&self) -> &vortex_array::buffer::BufferHandle
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Primitive
 
-impl vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::Primitive::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewArray::compact_buffers(&self) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
+pub struct vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::VarBinViewArray::compact_with_threshold(&self, buffer_utilization_threshold: f64) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
+impl vortex_array::arrays::primitive::PrimitiveData
 
-impl core::clone::Clone for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::as_slice<T: vortex_array::dtype::NativePType>(&self) -> &[T]
 
-pub fn vortex_array::arrays::VarBinViewArray::clone(&self) -> vortex_array::arrays::VarBinViewArray
+impl vortex_array::arrays::primitive::PrimitiveData
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinViewArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::primitive::PrimitiveData::from_buffer_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, _validity: vortex_array::validity::Validity) -> Self
 
-impl core::convert::From<vortex_array::arrays::VarBinViewArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::primitive::PrimitiveData::from_byte_buffer(buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::VarBinViewArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::primitive::PrimitiveData::from_values_byte_buffer(valid_elems_buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity, n_rows: usize) -> Self
 
-impl core::fmt::Debug for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::into_buffer<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::arrays::VarBinViewArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::primitive::PrimitiveData::into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer_mut::BufferMut<T>
 
-impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::string::String>> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::is_empty(&self) -> bool
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::string::String>>>(iter: T) -> Self
+pub fn vortex_array::arrays::primitive::PrimitiveData::len(&self) -> usize
 
-impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::vec::Vec<u8>>> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::ptype(&self) -> vortex_array::dtype::PType
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::vec::Vec<u8>>>>(iter: T) -> Self
+pub fn vortex_array::arrays::primitive::PrimitiveData::to_buffer<T: vortex_array::dtype::NativePType>(&self) -> vortex_buffer::buffer::Buffer<T>
 
-impl core::ops::deref::Deref for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::try_into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> core::result::Result<vortex_buffer::buffer_mut::BufferMut<T>, vortex_buffer::buffer::Buffer<T>>
 
-pub type vortex_array::arrays::VarBinViewArray::Target = dyn vortex_array::Array
+impl vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::VarBinViewArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::primitive::PrimitiveData::empty<T: vortex_array::dtype::NativePType>(nullability: vortex_array::dtype::Nullability) -> Self
 
-impl vortex_array::Executable for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::new<T: vortex_array::dtype::NativePType>(buffer: impl core::convert::Into<vortex_buffer::buffer::Buffer<T>>, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::arrays::VarBinViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub unsafe fn vortex_array::arrays::primitive::PrimitiveData::new_unchecked<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, _validity: vortex_array::validity::Validity) -> Self
 
-impl vortex_array::IntoArray for vortex_array::arrays::VarBinViewArray
+pub unsafe fn vortex_array::arrays::primitive::PrimitiveData::new_unchecked_from_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, _validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::arrays::VarBinViewArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::primitive::PrimitiveData::try_new<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::accessor::ArrayAccessor<[u8]> for &vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::validate<T: vortex_array::dtype::NativePType>(buffer: &vortex_buffer::buffer::Buffer<T>, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub fn &vortex_array::arrays::VarBinViewArray::with_iterator<F, R>(&self, f: F) -> R where F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a [u8]>>) -> R
+impl core::clone::Clone for vortex_array::arrays::primitive::PrimitiveData
 
-impl vortex_array::accessor::ArrayAccessor<[u8]> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::clone(&self) -> vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::VarBinViewArray::with_iterator<F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = core::option::Option<&'a [u8]>>) -> R, R>(&self, f: F) -> R
+impl core::fmt::Debug for vortex_array::arrays::primitive::PrimitiveData
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinViewArray::validity(&self) -> &vortex_array::validity::Validity
+impl core::fmt::Display for vortex_array::arrays::primitive::PrimitiveData
 
-impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a [u8]>> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a [u8]>>>(iter: T) -> Self
+impl vortex_array::ArrayEq for vortex_array::arrays::primitive::PrimitiveData
 
-impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a str>> for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::primitive::PrimitiveData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::VarBinViewArray::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a str>>>(iter: T) -> Self
+impl vortex_array::ArrayHash for vortex_array::arrays::primitive::PrimitiveData
 
-pub struct vortex_array::arrays::VarBinViewArrayParts
+pub fn vortex_array::arrays::primitive::PrimitiveData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub vortex_array::arrays::VarBinViewArrayParts::buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>
+pub struct vortex_array::arrays::primitive::PrimitiveDataParts
 
-pub vortex_array::arrays::VarBinViewArrayParts::dtype: vortex_array::dtype::DType
+pub vortex_array::arrays::primitive::PrimitiveDataParts::buffer: vortex_array::buffer::BufferHandle
 
-pub vortex_array::arrays::VarBinViewArrayParts::validity: vortex_array::validity::Validity
+pub vortex_array::arrays::primitive::PrimitiveDataParts::ptype: vortex_array::dtype::PType
 
-pub vortex_array::arrays::VarBinViewArrayParts::views: vortex_array::buffer::BufferHandle
+pub vortex_array::arrays::primitive::PrimitiveDataParts::validity: vortex_array::validity::Validity
 
-pub struct vortex_array::arrays::VarBinViewVTable
+pub struct vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-impl vortex_array::arrays::VarBinViewVTable
+impl core::default::Default for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-pub const vortex_array::arrays::VarBinViewVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::default() -> vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-impl core::fmt::Debug for vortex_array::arrays::VarBinViewVTable
+impl core::fmt::Debug for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-pub fn vortex_array::arrays::VarBinViewVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::VarBinViewVTable
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Primitive> for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-pub fn vortex_array::arrays::VarBinViewVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinViewVTable::take(array: &vortex_array::arrays::VarBinViewArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::arrays::primitive::PrimitiveArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Primitive>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_constant(&self, array: &vortex_array::arrays::VarBinViewArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::narrow(&self) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_sorted(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::ptype(&self) -> vortex_array::dtype::PType
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_strict_sorted(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> vortex_array::arrays::PrimitiveArray
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::VarBinViewVTable::min_max(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::primitive::PrimitiveArrayExt::validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::VarBinViewVTable::cast(array: &vortex_array::arrays::VarBinViewArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Primitive>> vortex_array::arrays::primitive::PrimitiveArrayExt for T
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinViewVTable
+pub fn T::buffer_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinViewVTable::mask(array: &vortex_array::arrays::VarBinViewArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::narrow(&self) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray>
 
-impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::VarBinViewVTable
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::arrays::VarBinViewVTable::zip(if_true: &vortex_array::arrays::VarBinViewArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::ptype(&self) -> vortex_array::dtype::PType
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub fn T::reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> vortex_array::arrays::PrimitiveArray
 
-pub fn vortex_array::arrays::VarBinViewVTable::array_eq(array: &vortex_array::arrays::VarBinViewArray, other: &vortex_array::arrays::VarBinViewArray, precision: vortex_array::Precision) -> bool
+pub fn T::validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::VarBinViewVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::VarBinViewArray, state: &mut H, precision: vortex_array::Precision)
+pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::VarBinViewVTable::dtype(array: &vortex_array::arrays::VarBinViewArray) -> &vortex_array::dtype::DType
+pub fn T::validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::arrays::VarBinViewVTable::len(array: &vortex_array::arrays::VarBinViewArray) -> usize
+pub fn vortex_array::arrays::primitive::chunk_range(chunk_idx: usize, offset: usize, array_len: usize) -> core::ops::range::Range<usize>
 
-pub fn vortex_array::arrays::VarBinViewVTable::stats(array: &vortex_array::arrays::VarBinViewArray) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::primitive::patch_chunk<T, I, C>(decoded_values: &mut [T], patches_indices: &[I], patches_values: &[T], patches_offset: usize, chunk_offsets_slice: &[C], chunk_idx: usize, offset_within_chunk: usize) where T: vortex_array::dtype::NativePType, I: vortex_array::dtype::UnsignedPType, C: vortex_array::dtype::UnsignedPType
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub type vortex_array::arrays::primitive::PrimitiveArray = vortex_array::Array<vortex_array::arrays::Primitive>
 
-pub fn vortex_array::arrays::VarBinViewVTable::scalar_at(array: &vortex_array::arrays::VarBinViewArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub mod vortex_array::arrays::scalar_fn
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::VarBinViewVTable
+pub struct vortex_array::arrays::scalar_fn::AnyScalarFn
 
-pub type vortex_array::arrays::VarBinViewVTable::Array = vortex_array::arrays::VarBinViewArray
+impl core::fmt::Debug for vortex_array::arrays::scalar_fn::AnyScalarFn
 
-pub type vortex_array::arrays::VarBinViewVTable::ArrayVTable = vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::scalar_fn::AnyScalarFn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::VarBinViewVTable::Metadata = vortex_array::EmptyMetadata
+impl vortex_array::matcher::Matcher for vortex_array::arrays::scalar_fn::AnyScalarFn
 
-pub type vortex_array::arrays::VarBinViewVTable::OperationsVTable = vortex_array::arrays::VarBinViewVTable
+pub type vortex_array::arrays::scalar_fn::AnyScalarFn::Match<'a> = vortex_array::ArrayView<'a, vortex_array::arrays::scalar_fn::ScalarFnVTable>
 
-pub type vortex_array::arrays::VarBinViewVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::scalar_fn::AnyScalarFn::matches(array: &vortex_array::ArrayRef) -> bool
 
-pub type vortex_array::arrays::VarBinViewVTable::VisitorVTable = vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::scalar_fn::AnyScalarFn::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
 
-pub fn vortex_array::arrays::VarBinViewVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
+pub struct vortex_array::arrays::scalar_fn::ExactScalarFn<F: vortex_array::scalar_fn::ScalarFnVTable>(_)
 
-pub fn vortex_array::arrays::VarBinViewVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+impl<F: core::default::Default + vortex_array::scalar_fn::ScalarFnVTable> core::default::Default for vortex_array::arrays::scalar_fn::ExactScalarFn<F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::default() -> vortex_array::arrays::scalar_fn::ExactScalarFn<F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<F: core::fmt::Debug + vortex_array::scalar_fn::ScalarFnVTable> core::fmt::Debug for vortex_array::arrays::scalar_fn::ExactScalarFn<F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinViewVTable::metadata(_array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<Self::Metadata>
+impl<F: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::matcher::Matcher for vortex_array::arrays::scalar_fn::ExactScalarFn<F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::scalar_fn::ExactScalarFn<F>::Match<'a> = vortex_array::arrays::scalar_fn::ScalarFnArrayView<'a, F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::matches(array: &vortex_array::ArrayRef) -> bool
 
-pub fn vortex_array::arrays::VarBinViewVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub struct vortex_array::arrays::scalar_fn::ScalarFnArrayView<'a, F: vortex_array::scalar_fn::ScalarFnVTable>
 
-pub fn vortex_array::arrays::VarBinViewVTable::nbuffers(array: &vortex_array::arrays::VarBinViewArray) -> usize
+pub vortex_array::arrays::scalar_fn::ScalarFnArrayView::options: &'a <F as vortex_array::scalar_fn::ScalarFnVTable>::Options
 
-pub fn vortex_array::arrays::VarBinViewVTable::nchildren(array: &vortex_array::arrays::VarBinViewArray) -> usize
+pub vortex_array::arrays::scalar_fn::ScalarFnArrayView::vtable: &'a F
 
-pub fn vortex_array::arrays::VarBinViewVTable::nth_child(array: &vortex_array::arrays::VarBinViewArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl<F: vortex_array::scalar_fn::ScalarFnVTable> core::ops::deref::Deref for vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, F>
 
-pub fn vortex_array::arrays::VarBinViewVTable::visit_buffers(array: &vortex_array::arrays::VarBinViewArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub type vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, F>::Target = vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinViewVTable::visit_children(array: &vortex_array::arrays::VarBinViewArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, F>::deref(&self) -> &Self::Target
 
-pub const vortex_array::arrays::IS_CONST_LANE_WIDTH: usize
+pub struct vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub trait vortex_array::arrays::FilterKernel: vortex_array::vtable::VTable
+impl vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::arrays::FilterKernel::filter(array: &Self::Array, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::build(scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: alloc::vec::Vec<vortex_array::ArrayRef>, len: usize) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::arrays::BoolVTable::filter(array: &vortex_array::arrays::BoolArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::arrays::scalar_fn::ScalarFnData
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::clone(&self) -> vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::arrays::ChunkedVTable::filter(array: &vortex_array::arrays::ChunkedArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::arrays::scalar_fn::ScalarFnData
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ListVTable::filter(array: &vortex_array::arrays::ListArray, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Display for vortex_array::arrays::scalar_fn::ScalarFnData
 
-impl vortex_array::arrays::FilterKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinVTable::filter(array: &vortex_array::arrays::VarBinArray, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ArrayEq for vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub trait vortex_array::arrays::FilterReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FilterReduce::filter(array: &Self::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ArrayHash for vortex_array::arrays::scalar_fn::ScalarFnData
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::ConstantVTable::filter(array: &vortex_array::arrays::ConstantArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::DictVTable
+impl core::clone::Clone for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::DictVTable::filter(array: &vortex_array::arrays::DictArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::clone(&self) -> vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::ExtensionVTable
+impl core::fmt::Debug for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::ExtensionVTable::filter(array: &vortex_array::arrays::ExtensionArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::MaskedVTable
+impl vortex_array::OperationsVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::MaskedVTable::filter(array: &vortex_array::arrays::MaskedArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::FilterReduce for vortex_array::arrays::NullVTable
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::NullVTable::filter(_array: &vortex_array::arrays::NullArray, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub trait vortex_array::arrays::ScalarFnArrayExt: vortex_array::scalar_fn::ScalarFnVTable
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::ScalarFnArrayExt::try_new_array(&self, len: usize, options: Self::Options, children: impl core::convert::Into<alloc::vec::Vec<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::arrays::ScalarFnArrayExt for V
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::arrays::SliceKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::SliceKernel::slice(array: &Self::Array, range: core::ops::range::Range<usize>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::arrays::SliceKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ChunkedVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::arrays::SliceReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::SliceReduce::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::BoolVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ConstantVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DictVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::ValidityVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::arrays::scalar_fn::ScalarFnArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::scalar_fn::ScalarFnVTable>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::child_at(&self, idx: usize) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::child_count(&self) -> usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ListViewVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::get_child(&self, idx: usize) -> &vortex_array::ArrayRef
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::iter_children(&self) -> impl core::iter::traits::iterator::Iterator<Item = &vortex_array::ArrayRef> + '_
 
-pub fn vortex_array::arrays::MaskedVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::nchildren(&self) -> usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnArrayExt::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::arrays::NullVTable::slice(_array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::scalar_fn::ScalarFnVTable>> vortex_array::arrays::scalar_fn::ScalarFnArrayExt for T
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::PrimitiveVTable
+pub fn T::child_at(&self, idx: usize) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::child_count(&self) -> usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::ScalarFnVTable
+pub fn T::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::ScalarFnVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::get_child(&self, idx: usize) -> &vortex_array::ArrayRef
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::SliceVTable
+pub fn T::iter_children(&self) -> impl core::iter::traits::iterator::Iterator<Item = &vortex_array::ArrayRef> + '_
 
-pub fn vortex_array::arrays::SliceVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn T::nchildren(&self) -> usize
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::StructVTable
+pub fn T::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::arrays::StructVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::arrays::scalar_fn::ScalarFnFactoryExt: vortex_array::scalar_fn::ScalarFnVTable
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::VarBinVTable
+pub trait vortex_array::arrays::scalar_fn::ScalarFnFactoryExt: vortex_array::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::VarBinVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnFactoryExt::try_new_array(&self, len: usize, options: Self::Options, children: impl core::convert::Into<alloc::vec::Vec<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::arrays::SliceReduce for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnFactoryExt::try_new_array(&self, len: usize, options: Self::Options, children: impl core::convert::Into<alloc::vec::Vec<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::VarBinViewVTable::slice(array: &Self::Array, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::arrays::scalar_fn::ScalarFnFactoryExt for V
 
-pub trait vortex_array::arrays::TakeExecute: vortex_array::vtable::VTable
+impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::arrays::scalar_fn::ScalarFnFactoryExt for V
 
-pub fn vortex_array::arrays::TakeExecute::take(array: &Self::Array, indices: &dyn vortex_array::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn V::try_new_array(&self, len: usize, options: Self::Options, children: impl core::convert::Into<alloc::vec::Vec<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::BoolVTable
+pub fn V::try_new_array(&self, len: usize, options: Self::Options, children: impl core::convert::Into<alloc::vec::Vec<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::BoolVTable::take(array: &vortex_array::arrays::BoolArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::scalar_fn::ScalarFnArray = vortex_array::Array<vortex_array::arrays::scalar_fn::ScalarFnVTable>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ChunkedVTable
+pub mod vortex_array::arrays::shared
 
-pub fn vortex_array::arrays::ChunkedVTable::take(array: &vortex_array::arrays::ChunkedArray, indices: &dyn vortex_array::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::arrays::shared::Shared
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::DecimalVTable
+impl vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::DecimalVTable::take(array: &vortex_array::arrays::DecimalArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub const vortex_array::arrays::Shared::ID: vortex_array::ArrayId
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::DictVTable
+impl core::clone::Clone for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::DictVTable::take(array: &vortex_array::arrays::DictArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::clone(&self) -> vortex_array::arrays::Shared
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ExtensionVTable
+impl core::fmt::Debug for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::ExtensionVTable::take(array: &vortex_array::arrays::ExtensionArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::OperationsVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::FixedSizeListVTable::take(array: &vortex_array::arrays::FixedSizeListArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ListVTable
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::ListVTable::take(array: &vortex_array::arrays::ListArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::ListViewVTable
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::ListViewVTable::take(array: &vortex_array::arrays::ListViewArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::MaskedVTable::take(array: &vortex_array::arrays::MaskedArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::PrimitiveVTable::take(array: &vortex_array::arrays::PrimitiveArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::StructVTable::take(array: &vortex_array::arrays::StructArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::VarBinVTable::take(array: &vortex_array::arrays::VarBinArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TakeExecute for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::VarBinViewVTable::take(array: &vortex_array::arrays::VarBinViewArray, indices: &dyn vortex_array::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub trait vortex_array::arrays::TakeReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::TakeReduce::take(array: &Self::Array, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrays::TakeReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::take(array: &vortex_array::arrays::ConstantArray, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::arrays::TakeReduce for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::NullVTable::take(array: &vortex_array::arrays::NullArray, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::chunk_range(chunk_idx: usize, offset: usize, array_len: usize) -> core::ops::range::Range<usize>
+impl vortex_array::ValidityVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::compute_is_constant<T: vortex_array::dtype::NativePType, const WIDTH: usize>(values: &[T]) -> bool
+pub fn vortex_array::arrays::Shared::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::list_from_list_view(list_view: vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<vortex_array::arrays::ListArray>
+pub struct vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::list_view_from_list(list: vortex_array::arrays::ListArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
+impl vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::mask_validity_canonical(canonical: vortex_array::Canonical, validity_mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::arrays::shared::SharedData::new() -> Self
 
-pub fn vortex_array::arrays::narrowed_decimal(decimal_array: vortex_array::arrays::DecimalArray) -> vortex_array::arrays::DecimalArray
+impl core::clone::Clone for vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::patch_chunk<T, I, C>(decoded_values: &mut [T], patches_indices: &[I], patches_values: &[T], patches_offset: usize, chunk_offsets_slice: &[C], chunk_idx: usize, offset_within_chunk: usize) where T: vortex_array::dtype::NativePType, I: vortex_array::dtype::UnsignedPType, C: vortex_array::dtype::UnsignedPType
+pub fn vortex_array::arrays::shared::SharedData::clone(&self) -> vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::recursive_list_from_list_view(array: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::default::Default for vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::take_canonical(values: vortex_array::Canonical, codes: &vortex_array::arrays::PrimitiveArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::arrays::shared::SharedData::default() -> Self
 
-pub fn vortex_array::arrays::varbin_scalar(value: vortex_buffer::ByteBuffer, dtype: &vortex_array::dtype::DType) -> vortex_array::scalar::Scalar
+impl core::fmt::Debug for vortex_array::arrays::shared::SharedData
 
-pub mod vortex_array::arrow
+pub fn vortex_array::arrays::shared::SharedData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::arrow::bool
+impl core::fmt::Display for vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrow::bool::canonical_bool_to_arrow(array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn vortex_array::arrays::shared::SharedData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::arrow::byte_view
+impl vortex_array::ArrayEq for vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrow::byte_view::canonical_varbinview_to_arrow<T: arrow_array::types::ByteViewType>(array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn vortex_array::arrays::shared::SharedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrow::byte_view::execute_varbinview_to_arrow<T: arrow_array::types::ByteViewType>(array: &vortex_array::arrays::VarBinViewArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+impl vortex_array::ArrayHash for vortex_array::arrays::shared::SharedData
 
-pub mod vortex_array::arrow::compute
+pub fn vortex_array::arrays::shared::SharedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub struct vortex_array::arrow::compute::ToArrowOptions
+pub trait vortex_array::arrays::shared::SharedArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Shared>
 
-pub vortex_array::arrow::compute::ToArrowOptions::arrow_type: core::option::Option<arrow_schema::datatype::DataType>
+pub fn vortex_array::arrays::shared::SharedArrayExt::current_array_ref(&self) -> &vortex_array::ArrayRef
 
-impl vortex_array::compute::Options for vortex_array::arrow::compute::ToArrowOptions
+pub fn vortex_array::arrays::shared::SharedArrayExt::get_or_compute(&self, f: impl core::ops::function::FnOnce(&vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::Canonical>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrow::compute::ToArrowOptions::as_any(&self) -> &dyn core::any::Any
+pub async fn vortex_array::arrays::shared::SharedArrayExt::get_or_compute_async<F, Fut>(&self, f: F) -> vortex_error::VortexResult<vortex_array::ArrayRef> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> Fut, Fut: core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::Canonical>>
 
-pub fn vortex_array::arrow::compute::to_arrow(array: &dyn vortex_array::Array, arrow_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn vortex_array::arrays::shared::SharedArrayExt::source(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrow::compute::to_arrow_opts(array: &dyn vortex_array::Array, options: &vortex_array::arrow::compute::ToArrowOptions) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Shared>> vortex_array::arrays::shared::SharedArrayExt for T
 
-pub fn vortex_array::arrow::compute::to_arrow_preferred(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn T::current_array_ref(&self) -> &vortex_array::ArrayRef
 
-pub mod vortex_array::arrow::null
+pub fn T::get_or_compute(&self, f: impl core::ops::function::FnOnce(&vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::Canonical>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrow::null::canonical_null_to_arrow(array: &vortex_array::arrays::NullArray) -> arrow_array::array::ArrayRef
+pub async fn T::get_or_compute_async<F, Fut>(&self, f: F) -> vortex_error::VortexResult<vortex_array::ArrayRef> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> Fut, Fut: core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::Canonical>>
 
-pub mod vortex_array::arrow::primitive
+pub fn T::source(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::arrow::primitive::canonical_primitive_to_arrow<T: arrow_array::types::ArrowPrimitiveType>(array: vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef> where <T as arrow_array::types::ArrowPrimitiveType>::Native: vortex_array::dtype::NativePType
+pub type vortex_array::arrays::shared::SharedArray = vortex_array::Array<vortex_array::arrays::Shared>
 
-pub struct vortex_array::arrow::ArrowArray
+pub mod vortex_array::arrays::slice
 
-impl vortex_array::arrow::ArrowArray
+pub struct vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::inner(&self) -> &arrow_array::array::ArrayRef
+impl vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::new(arrow_array: arrow_array::array::ArrayRef, nullability: vortex_array::dtype::Nullability) -> Self
+pub const vortex_array::arrays::slice::Slice::ID: vortex_array::ArrayId
 
-impl core::clone::Clone for vortex_array::arrow::ArrowArray
+impl core::clone::Clone for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::clone(&self) -> vortex_array::arrow::ArrowArray
+pub fn vortex_array::arrays::slice::Slice::clone(&self) -> vortex_array::arrays::slice::Slice
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::arrow::ArrowArray
+impl core::fmt::Debug for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::arrays::slice::Slice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<vortex_array::arrow::ArrowArray> for vortex_array::ArrayRef
+impl vortex_array::OperationsVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::arrow::ArrowArray) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::fmt::Debug for vortex_array::arrow::ArrowArray
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-impl core::ops::deref::Deref for vortex_array::arrow::ArrowArray
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-pub type vortex_array::arrow::ArrowArray::Target = dyn vortex_array::Array
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArray::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::IntoArray for vortex_array::arrow::ArrowArray
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrow::ArrowArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub struct vortex_array::arrow::ArrowArrayStreamAdapter
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::arrow::ArrowArrayStreamAdapter
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrow::ArrowArrayStreamAdapter::new(stream: arrow_array::ffi_stream::ArrowArrayStreamReader, dtype: vortex_array::dtype::DType) -> Self
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::iter::traits::iterator::Iterator for vortex_array::arrow::ArrowArrayStreamAdapter
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrow::ArrowArrayStreamAdapter::Item = core::result::Result<alloc::sync::Arc<dyn vortex_array::Array>, vortex_error::VortexError>
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::ArrowArrayStreamAdapter::next(&mut self) -> core::option::Option<Self::Item>
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::iter::ArrayIterator for vortex_array::arrow::ArrowArrayStreamAdapter
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrow::ArrowArrayStreamAdapter::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::arrow::ArrowVTable::ID: vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::fmt::Debug for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrow::ArrowVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowVTable::array_eq(array: &vortex_array::arrow::ArrowArray, other: &vortex_array::arrow::ArrowArray, _precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::slice::Slice::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrow::ArrowVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrow::ArrowArray, state: &mut H, _precision: vortex_array::Precision)
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowVTable::dtype(array: &vortex_array::arrow::ArrowArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::slice::Slice::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::ArrowVTable::len(array: &vortex_array::arrow::ArrowArray) -> usize
+pub struct vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrow::ArrowVTable::stats(array: &vortex_array::arrow::ArrowArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::arrays::slice::SliceData
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::SliceData::into_parts(self) -> vortex_array::arrays::slice::SliceDataParts
 
-pub fn vortex_array::arrow::ArrowVTable::scalar_at(_array: &vortex_array::arrow::ArrowArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::slice::SliceData::is_empty(&self) -> bool
 
-impl vortex_array::vtable::VTable for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::SliceData::len(&self) -> usize
 
-pub type vortex_array::arrow::ArrowVTable::Array = vortex_array::arrow::ArrowArray
+pub fn vortex_array::arrays::slice::SliceData::new(range: core::ops::range::Range<usize>) -> Self
 
-pub type vortex_array::arrow::ArrowVTable::ArrayVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::SliceData::slice_range(&self) -> &core::ops::range::Range<usize>
 
-pub type vortex_array::arrow::ArrowVTable::Metadata = vortex_array::EmptyMetadata
+impl core::clone::Clone for vortex_array::arrays::slice::SliceData
 
-pub type vortex_array::arrow::ArrowVTable::OperationsVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::SliceData::clone(&self) -> vortex_array::arrays::slice::SliceData
 
-pub type vortex_array::arrow::ArrowVTable::ValidityVTable = vortex_array::arrow::ArrowVTable
+impl core::fmt::Debug for vortex_array::arrays::slice::SliceData
 
-pub type vortex_array::arrow::ArrowVTable::VisitorVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::slice::SliceData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrow::ArrowVTable::build(_dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+impl core::fmt::Display for vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrow::ArrowVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::slice::SliceData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrow::ArrowVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::ArrayEq for vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrow::ArrowVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::slice::SliceData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrow::ArrowVTable::metadata(_array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::ArrayHash for vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrow::ArrowVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::slice::SliceData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrow::ArrowVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub struct vortex_array::arrays::slice::SliceDataParts
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub vortex_array::arrays::slice::SliceDataParts::range: core::ops::range::Range<usize>
 
-pub fn vortex_array::arrow::ArrowVTable::validity(array: &vortex_array::arrow::ArrowArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub struct vortex_array::arrays::slice::SliceExecuteAdaptor<V>(pub V)
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::slice::SliceExecuteAdaptor<V>
 
-pub fn vortex_array::arrow::ArrowVTable::nchildren(_array: &vortex_array::arrow::ArrowArray) -> usize
+pub fn vortex_array::arrays::slice::SliceExecuteAdaptor<V>::default() -> vortex_array::arrays::slice::SliceExecuteAdaptor<V>
 
-pub fn vortex_array::arrow::ArrowVTable::nth_child(_array: &vortex_array::arrow::ArrowArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::slice::SliceExecuteAdaptor<V>
 
-pub fn vortex_array::arrow::ArrowVTable::visit_buffers(_array: &vortex_array::arrow::ArrowArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::slice::SliceExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrow::ArrowVTable::visit_children(_array: &vortex_array::arrow::ArrowArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::slice::SliceExecuteAdaptor<V> where V: vortex_array::arrays::slice::SliceKernel
 
-pub struct vortex_array::arrow::Datum
+pub type vortex_array::arrays::slice::SliceExecuteAdaptor<V>::Parent = vortex_array::arrays::slice::Slice
 
-impl vortex_array::arrow::Datum
+pub fn vortex_array::arrays::slice::SliceExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::Datum::data_type(&self) -> &arrow_schema::datatype::DataType
+pub struct vortex_array::arrays::slice::SliceMetadata(_)
 
-pub fn vortex_array::arrow::Datum::try_new(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_array::arrays::slice::SliceMetadata
 
-pub fn vortex_array::arrow::Datum::try_new_array(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::slice::SliceMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrow::Datum::try_new_with_target_datatype(array: &dyn vortex_array::Array, target_datatype: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::arrays::slice::SliceReduceAdaptor<V>(pub V)
 
-impl arrow_array::scalar::Datum for vortex_array::arrow::Datum
+impl<V: core::default::Default> core::default::Default for vortex_array::arrays::slice::SliceReduceAdaptor<V>
 
-pub fn vortex_array::arrow::Datum::get(&self) -> (&dyn arrow_array::array::Array, bool)
+pub fn vortex_array::arrays::slice::SliceReduceAdaptor<V>::default() -> vortex_array::arrays::slice::SliceReduceAdaptor<V>
 
-impl core::fmt::Debug for vortex_array::arrow::Datum
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::arrays::slice::SliceReduceAdaptor<V>
 
-pub fn vortex_array::arrow::Datum::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::slice::SliceReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub trait vortex_array::arrow::ArrowArrayExecutor: core::marker::Sized
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::slice::SliceReduceAdaptor<V> where V: vortex_array::arrays::slice::SliceReduce
 
-pub fn vortex_array::arrow::ArrowArrayExecutor::execute_arrow(self, data_type: core::option::Option<&arrow_schema::datatype::DataType>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub type vortex_array::arrays::slice::SliceReduceAdaptor<V>::Parent = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrow::ArrowArrayExecutor::execute_record_batch(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
+pub fn vortex_array::arrays::slice::SliceReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::ArrowArrayExecutor::execute_record_batches(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<alloc::vec::Vec<arrow_array::record_batch::RecordBatch>>
+pub trait vortex_array::arrays::slice::SliceArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::slice::Slice>
 
-impl vortex_array::arrow::ArrowArrayExecutor for vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::SliceArrayExt::child(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayRef::execute_arrow(self, data_type: core::option::Option<&arrow_schema::datatype::DataType>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::slice::Slice>> vortex_array::arrays::slice::SliceArrayExt for T
 
-pub fn vortex_array::ArrayRef::execute_record_batches(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<alloc::vec::Vec<arrow_array::record_batch::RecordBatch>>
+pub fn T::child(&self) -> &vortex_array::ArrayRef
 
-pub trait vortex_array::arrow::FromArrowArray<A>
+pub trait vortex_array::arrays::slice::SliceKernel: vortex_array::VTable
 
-pub fn vortex_array::arrow::FromArrowArray::from_arrow(array: A, nullable: bool) -> vortex_error::VortexResult<Self> where Self: core::marker::Sized
+pub fn vortex_array::arrays::slice::SliceKernel::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::boolean_array::BooleanArray> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::boolean_array::BooleanArray, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Chunked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::fixed_size_list_array::FixedSizeListArray> for vortex_array::ArrayRef
+pub trait vortex_array::arrays::slice::SliceReduce: vortex_array::VTable
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::fixed_size_list_array::FixedSizeListArray, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::slice::SliceReduce::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::null_array::NullArray> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::null_array::NullArray, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Bool::slice(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Decimal
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Decimal::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Extension
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Extension::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::FixedSizeList::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::List
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::List::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::ListView
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::ListView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Masked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Primitive
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Primitive::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Struct
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::VarBin::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::VarBinView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::dict::Dict::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::slice(_array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>> for vortex_array::ArrayRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::slice::Slice::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>> for vortex_array::ArrayRef
+pub type vortex_array::arrays::slice::SliceArray = vortex_array::Array<vortex_array::arrays::slice::Slice>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub mod vortex_array::arrays::struct_
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>> for vortex_array::ArrayRef
+pub struct vortex_array::arrays::struct_::Struct
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>> for vortex_array::ArrayRef
+pub const vortex_array::arrays::Struct::ID: vortex_array::ArrayId
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::clone(&self) -> vortex_array::arrays::Struct
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>> for vortex_array::ArrayRef
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>> for vortex_array::ArrayRef
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::array::struct_array::StructArray> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::struct_array::StructArray, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::arrow::FromArrowArray<&arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::arrow::FromArrowArray<&dyn arrow_array::array::Array> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &dyn arrow_array::array::Array, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::arrow::FromArrowArray<arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from_arrow(array: arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<K: arrow_array::types::ArrowDictionaryKeyType> vortex_array::arrow::FromArrowArray<&arrow_array::array::dictionary_array::DictionaryArray<K>> for vortex_array::arrays::DictArray
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DictArray::from_arrow(array: &arrow_array::array::dictionary_array::DictionaryArray<K>, nullable: bool) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<O: arrow_array::array::list_array::OffsetSizeTrait + vortex_array::dtype::NativePType> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_view_array::GenericListViewArray<O>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::list_view_array::GenericListViewArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::ValidityVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-impl<O: vortex_array::dtype::IntegerPType + arrow_array::array::list_array::OffsetSizeTrait> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_array::GenericListArray<O>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::list_array::GenericListArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Struct
 
-impl<T: arrow_array::types::ByteArrayType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_array::GenericByteArray<T>> for vortex_array::ArrayRef where <T as arrow_array::types::ByteArrayType>::Offset: vortex_array::dtype::IntegerPType
+pub fn vortex_array::arrays::Struct::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_array::GenericByteArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Struct
 
-impl<T: arrow_array::types::ByteViewType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_view_array::GenericByteViewArray<T>> for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_view_array::GenericByteViewArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Struct
 
-pub trait vortex_array::arrow::IntoArrowArray
+pub fn vortex_array::arrays::Struct::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::IntoArrowArray::into_arrow(self, data_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Struct
 
-pub fn vortex_array::arrow::IntoArrowArray::into_arrow_preferred(self) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn vortex_array::arrays::Struct::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::arrow::IntoArrowArray for vortex_array::ArrayRef
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Struct
 
-pub fn vortex_array::ArrayRef::into_arrow(self, data_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub fn vortex_array::arrays::Struct::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::into_arrow_preferred(self) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
+pub struct vortex_array::arrays::struct_::StructDataParts
 
-pub fn vortex_array::arrow::from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> vortex_error::VortexResult<vortex_array::ArrayRef> where vortex_array::ArrayRef: vortex_array::arrow::FromArrowArray<A>
+pub vortex_array::arrays::struct_::StructDataParts::fields: alloc::sync::Arc<[vortex_array::ArrayRef]>
 
-pub mod vortex_array::buffer
+pub vortex_array::arrays::struct_::StructDataParts::struct_fields: vortex_array::dtype::StructFields
 
-pub struct vortex_array::buffer::BufferHandle(_)
+pub vortex_array::arrays::struct_::StructDataParts::validity: vortex_array::validity::Validity
 
-impl vortex_array::buffer::BufferHandle
+pub trait vortex_array::arrays::struct_::StructArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Struct>
 
-pub fn vortex_array::buffer::BufferHandle::alignment(&self) -> vortex_buffer::alignment::Alignment
+pub fn vortex_array::arrays::struct_::StructArrayExt::iter_unmasked_fields(&self) -> impl core::iter::traits::iterator::Iterator<Item = &vortex_array::ArrayRef> + '_
 
-pub fn vortex_array::buffer::BufferHandle::as_device(&self) -> &alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
+pub fn vortex_array::arrays::struct_::StructArrayExt::names(&self) -> &vortex_array::dtype::FieldNames
 
-pub fn vortex_array::buffer::BufferHandle::as_device_opt(&self) -> core::option::Option<&alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>>
+pub fn vortex_array::arrays::struct_::StructArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::buffer::BufferHandle::as_host(&self) -> &vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::struct_::StructArrayExt::struct_fields(&self) -> &vortex_array::dtype::StructFields
 
-pub fn vortex_array::buffer::BufferHandle::as_host_opt(&self) -> core::option::Option<&vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::struct_::StructArrayExt::struct_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::buffer::BufferHandle::ensure_aligned(self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::struct_::StructArrayExt::unmasked_field(&self, idx: usize) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::buffer::BufferHandle::into_host(self) -> futures_core::future::BoxFuture<'static, vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::struct_::StructArrayExt::unmasked_field_by_name(&self, name: impl core::convert::AsRef<str>) -> vortex_error::VortexResult<&vortex_array::ArrayRef>
 
-pub fn vortex_array::buffer::BufferHandle::into_host_sync(self) -> vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::struct_::StructArrayExt::unmasked_field_by_name_opt(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::buffer::BufferHandle::is_aligned_to(&self, alignment: vortex_buffer::alignment::Alignment) -> bool
+pub fn vortex_array::arrays::struct_::StructArrayExt::unmasked_fields(&self) -> alloc::sync::Arc<[vortex_array::ArrayRef]>
 
-pub fn vortex_array::buffer::BufferHandle::is_empty(&self) -> bool
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Struct>> vortex_array::arrays::struct_::StructArrayExt for T
 
-pub fn vortex_array::buffer::BufferHandle::is_on_device(&self) -> bool
+pub fn T::iter_unmasked_fields(&self) -> impl core::iter::traits::iterator::Iterator<Item = &vortex_array::ArrayRef> + '_
 
-pub fn vortex_array::buffer::BufferHandle::is_on_host(&self) -> bool
+pub fn T::names(&self) -> &vortex_array::dtype::FieldNames
 
-pub fn vortex_array::buffer::BufferHandle::len(&self) -> usize
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::buffer::BufferHandle::slice(&self, range: core::ops::range::Range<usize>) -> Self
+pub fn T::struct_fields(&self) -> &vortex_array::dtype::StructFields
 
-pub fn vortex_array::buffer::BufferHandle::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> Self
+pub fn T::struct_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::buffer::BufferHandle::to_host(&self) -> futures_core::future::BoxFuture<'static, vortex_buffer::ByteBuffer>
+pub fn T::unmasked_field(&self, idx: usize) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::buffer::BufferHandle::to_host_sync(&self) -> vortex_buffer::ByteBuffer
+pub fn T::unmasked_field_by_name(&self, name: impl core::convert::AsRef<str>) -> vortex_error::VortexResult<&vortex_array::ArrayRef>
 
-pub fn vortex_array::buffer::BufferHandle::try_into_host(self) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
+pub fn T::unmasked_field_by_name_opt(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::buffer::BufferHandle::try_into_host_sync(self) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
+pub fn T::unmasked_fields(&self) -> alloc::sync::Arc<[vortex_array::ArrayRef]>
 
-pub fn vortex_array::buffer::BufferHandle::try_to_host(&self) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
+pub type vortex_array::arrays::struct_::StructArray = vortex_array::Array<vortex_array::arrays::Struct>
 
-pub fn vortex_array::buffer::BufferHandle::try_to_host_sync(&self) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
+pub mod vortex_array::arrays::varbin
 
-pub fn vortex_array::buffer::BufferHandle::unwrap_device(self) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
+pub mod vortex_array::arrays::varbin::builder
 
-pub fn vortex_array::buffer::BufferHandle::unwrap_host(self) -> vortex_buffer::ByteBuffer
+pub struct vortex_array::arrays::varbin::builder::VarBinBuilder<O: vortex_array::dtype::IntegerPType>
 
-impl vortex_array::buffer::BufferHandle
+impl<O: vortex_array::dtype::IntegerPType> vortex_array::arrays::varbin::builder::VarBinBuilder<O>
 
-pub fn vortex_array::buffer::BufferHandle::new_device(device: alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>) -> Self
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::append(&mut self, value: core::option::Option<&[u8]>)
 
-pub fn vortex_array::buffer::BufferHandle::new_host(byte_buffer: vortex_buffer::ByteBuffer) -> Self
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::append_n_nulls(&mut self, n: usize)
 
-impl core::clone::Clone for vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::append_null(&mut self)
 
-pub fn vortex_array::buffer::BufferHandle::clone(&self) -> vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::append_value(&mut self, value: impl core::convert::AsRef<[u8]>)
 
-impl core::convert::TryFrom<vortex_array::buffer::BufferHandle> for vortex_array::serde::ArrayParts
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::append_values(&mut self, values: &[u8], end_offsets: impl core::iter::traits::iterator::Iterator<Item = O>, num: usize) where O: 'static, usize: num_traits::cast::AsPrimitive<O>
 
-pub type vortex_array::serde::ArrayParts::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::finish(self, dtype: vortex_array::dtype::DType) -> vortex_array::arrays::VarBinArray
 
-pub fn vortex_array::serde::ArrayParts::try_from(value: vortex_array::buffer::BufferHandle) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::new() -> Self
 
-impl core::fmt::Debug for vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::with_capacity(len: usize) -> Self
 
-pub fn vortex_array::buffer::BufferHandle::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<O: vortex_array::dtype::IntegerPType> core::default::Default for vortex_array::arrays::varbin::builder::VarBinBuilder<O>
 
-impl vortex_array::ArrayEq for vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::varbin::builder::VarBinBuilder<O>::default() -> Self
 
-pub fn vortex_array::buffer::BufferHandle::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub struct vortex_array::arrays::varbin::VarBin
 
-impl vortex_array::ArrayHash for vortex_array::buffer::BufferHandle
+impl vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::BufferHandle::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub const vortex_array::arrays::VarBin::ID: vortex_array::ArrayId
 
-pub trait vortex_array::buffer::DeviceBuffer: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug + vortex_utils::dyn_traits::DynEq + vortex_utils::dyn_traits::DynHash
+impl vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::DeviceBuffer::aligned(self: alloc::sync::Arc<Self>, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>>
+pub fn vortex_array::arrays::VarBin::_slice(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::buffer::DeviceBuffer::alignment(&self) -> vortex_buffer::alignment::Alignment
+impl core::clone::Clone for vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::DeviceBuffer::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::VarBin::clone(&self) -> vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::DeviceBuffer::copy_to_host(&self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
+impl core::fmt::Debug for vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::DeviceBuffer::copy_to_host_sync(&self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::VarBin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::buffer::DeviceBuffer::is_empty(&self) -> bool
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub fn vortex_array::buffer::DeviceBuffer::len(&self) -> usize
+pub fn vortex_array::arrays::VarBin::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::buffer::DeviceBuffer::slice(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-pub trait vortex_array::buffer::DeviceBufferExt: vortex_array::buffer::DeviceBuffer
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::buffer::DeviceBufferExt::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-impl<B: vortex_array::buffer::DeviceBuffer> vortex_array::buffer::DeviceBufferExt for B
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn B::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub mod vortex_array::builders
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub mod vortex_array::builders::dict
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub struct vortex_array::builders::dict::DictConstraints
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub vortex_array::builders::dict::DictConstraints::max_bytes: usize
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::builders::dict::DictConstraints::max_len: usize
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::clone::Clone for vortex_array::builders::dict::DictConstraints
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::builders::dict::DictConstraints::clone(&self) -> vortex_array::builders::dict::DictConstraints
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::builders::dict::UNCONSTRAINED: vortex_array::builders::dict::DictConstraints
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-pub trait vortex_array::builders::dict::DictEncoder: core::marker::Send
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::dict::DictEncoder::codes_ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::dict::DictEncoder::encode(&mut self, array: &dyn vortex_array::Array) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::dict::DictEncoder::reset(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::dict::dict_encode(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::arrays::DictArray>
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::builders::dict::dict_encode_with_constraints(array: &dyn vortex_array::Array, constraints: &vortex_array::builders::dict::DictConstraints) -> vortex_error::VortexResult<vortex_array::arrays::DictArray>
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::dict::dict_encoder(array: &dyn vortex_array::Array, constraints: &vortex_array::builders::dict::DictConstraints) -> alloc::boxed::Box<dyn vortex_array::builders::dict::DictEncoder>
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub enum vortex_array::builders::BufferGrowthStrategy
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub vortex_array::builders::BufferGrowthStrategy::Exponential
+pub fn vortex_array::arrays::VarBin::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::builders::BufferGrowthStrategy::Exponential::current_size: u32
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBin
 
-pub vortex_array::builders::BufferGrowthStrategy::Exponential::max_size: u32
+pub fn vortex_array::arrays::VarBin::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::builders::BufferGrowthStrategy::Fixed
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::VarBin
 
-pub vortex_array::builders::BufferGrowthStrategy::Fixed::size: u32
+pub fn vortex_array::arrays::VarBin::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::builders::BufferGrowthStrategy
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::builders::BufferGrowthStrategy::exponential(initial_size: u32, max_size: u32) -> Self
+pub fn vortex_array::arrays::VarBin::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::BufferGrowthStrategy::fixed(size: u32) -> Self
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::VarBin
 
-pub fn vortex_array::builders::BufferGrowthStrategy::next_size(&mut self) -> u32
+pub fn vortex_array::arrays::VarBin::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::builders::BufferGrowthStrategy
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::builders::BufferGrowthStrategy::clone(&self) -> vortex_array::builders::BufferGrowthStrategy
+pub fn vortex_array::arrays::VarBin::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::default::Default for vortex_array::builders::BufferGrowthStrategy
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::builders::BufferGrowthStrategy::default() -> Self
+pub fn vortex_array::arrays::VarBin::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::builders::BufferGrowthStrategy
+pub struct vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BufferGrowthStrategy::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::varbin::VarBinData
 
-pub enum vortex_array::builders::CompletedBuffers
+pub fn vortex_array::arrays::varbin::VarBinData::build(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub vortex_array::builders::CompletedBuffers::Deduplicated(vortex_array::builders::DeduplicatedBuffers)
+pub fn vortex_array::arrays::varbin::VarBinData::build_from_handle(offset: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub vortex_array::builders::CompletedBuffers::Default(alloc::vec::Vec<vortex_buffer::ByteBuffer>)
+pub fn vortex_array::arrays::varbin::VarBinData::bytes(&self) -> &vortex_buffer::ByteBuffer
 
-impl core::default::Default for vortex_array::builders::CompletedBuffers
+pub fn vortex_array::arrays::varbin::VarBinData::bytes_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::CompletedBuffers::default() -> Self
+pub unsafe fn vortex_array::arrays::varbin::VarBinData::new_unchecked(bytes: vortex_buffer::ByteBuffer) -> Self
 
-pub struct vortex_array::builders::BoolBuilder
+pub unsafe fn vortex_array::arrays::varbin::VarBinData::new_unchecked_from_handle(bytes: vortex_array::buffer::BufferHandle) -> Self
 
-impl vortex_array::builders::BoolBuilder
+pub fn vortex_array::arrays::varbin::VarBinData::try_build(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::builders::BoolBuilder::append_value(&mut self, value: bool)
+pub fn vortex_array::arrays::varbin::VarBinData::try_build_from_handle(offsets: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::builders::BoolBuilder::append_values(&mut self, value: bool, n: usize)
+pub fn vortex_array::arrays::varbin::VarBinData::validate(offsets: &vortex_array::ArrayRef, bytes: &vortex_array::buffer::BufferHandle, dtype: &vortex_array::dtype::DType, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::BoolBuilder::finish_into_bool(&mut self) -> vortex_array::arrays::BoolArray
+impl core::clone::Clone for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BoolBuilder::new(nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::varbin::VarBinData::clone(&self) -> vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BoolBuilder::with_capacity(nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
+impl core::fmt::Debug for vortex_array::arrays::varbin::VarBinData
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::BoolBuilder
+pub fn vortex_array::arrays::varbin::VarBinData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub unsafe fn vortex_array::builders::BoolBuilder::append_nulls_unchecked(&mut self, n: usize)
+impl core::fmt::Display for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BoolBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbin::VarBinData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::BoolBuilder::append_zeros(&mut self, n: usize)
+impl vortex_array::ArrayEq for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BoolBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::varbin::VarBinData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::builders::BoolBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl vortex_array::ArrayHash for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::builders::BoolBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbin::VarBinData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub unsafe fn vortex_array::builders::BoolBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub struct vortex_array::arrays::varbin::VarBinDataParts
 
-pub fn vortex_array::builders::BoolBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub vortex_array::arrays::varbin::VarBinDataParts::bytes: vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::BoolBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub vortex_array::arrays::varbin::VarBinDataParts::dtype: vortex_array::dtype::DType
 
-pub fn vortex_array::builders::BoolBuilder::len(&self) -> usize
+pub vortex_array::arrays::varbin::VarBinDataParts::offsets: vortex_array::ArrayRef
 
-pub fn vortex_array::builders::BoolBuilder::reserve_exact(&mut self, additional: usize)
+pub vortex_array::arrays::varbin::VarBinDataParts::validity: vortex_array::validity::Validity
 
-pub unsafe fn vortex_array::builders::BoolBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub trait vortex_array::arrays::varbin::VarBinArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::VarBin>
 
-pub struct vortex_array::builders::DecimalBuilder
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::bytes_at(&self, index: usize) -> vortex_buffer::ByteBuffer
 
-impl vortex_array::builders::DecimalBuilder
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::dtype_parts(&self) -> (bool, vortex_array::dtype::Nullability)
 
-pub fn vortex_array::builders::DecimalBuilder::append_value<V: vortex_array::dtype::NativeDecimalType>(&mut self, value: V)
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::is_utf8(&self) -> bool
 
-pub fn vortex_array::builders::DecimalBuilder::decimal_dtype(&self) -> &vortex_array::dtype::DecimalDType
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::builders::DecimalBuilder::finish_into_decimal(&mut self) -> vortex_array::arrays::DecimalArray
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::offset_at(&self, index: usize) -> usize
 
-pub fn vortex_array::builders::DecimalBuilder::new<T: vortex_array::dtype::NativeDecimalType>(decimal: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::offsets(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::builders::DecimalBuilder::with_capacity<T: vortex_array::dtype::NativeDecimalType>(capacity: usize, decimal: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::sliced_bytes(&self) -> vortex_buffer::ByteBuffer
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::DecimalBuilder
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::varbin_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::builders::DecimalBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbin::VarBinArrayExt::varbin_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::builders::DecimalBuilder::append_zeros(&mut self, n: usize)
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::VarBin>> vortex_array::arrays::varbin::VarBinArrayExt for T
 
-pub fn vortex_array::builders::DecimalBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn T::bytes_at(&self, index: usize) -> vortex_buffer::ByteBuffer
 
-pub fn vortex_array::builders::DecimalBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn T::dtype_parts(&self) -> (bool, vortex_array::dtype::Nullability)
 
-pub fn vortex_array::builders::DecimalBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn T::is_utf8(&self) -> bool
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn T::nullability(&self) -> vortex_array::dtype::Nullability
 
-pub fn vortex_array::builders::DecimalBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn T::offset_at(&self, index: usize) -> usize
 
-pub fn vortex_array::builders::DecimalBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn T::offsets(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::builders::DecimalBuilder::len(&self) -> usize
+pub fn T::sliced_bytes(&self) -> vortex_buffer::ByteBuffer
 
-pub fn vortex_array::builders::DecimalBuilder::reserve_exact(&mut self, additional: usize)
+pub fn T::validity_child(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn T::varbin_validity(&self) -> vortex_array::validity::Validity
 
-pub struct vortex_array::builders::DeduplicatedBuffers
+pub fn T::varbin_validity_mask(&self) -> vortex_mask::Mask
 
-impl core::default::Default for vortex_array::builders::DeduplicatedBuffers
+pub fn vortex_array::arrays::varbin::varbin_scalar(value: vortex_buffer::ByteBuffer, dtype: &vortex_array::dtype::DType) -> vortex_array::scalar::Scalar
 
-pub fn vortex_array::builders::DeduplicatedBuffers::default() -> vortex_array::builders::DeduplicatedBuffers
+pub type vortex_array::arrays::varbin::VarBinArray = vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub struct vortex_array::builders::ExtensionBuilder
+pub mod vortex_array::arrays::varbinview
 
-impl vortex_array::builders::ExtensionBuilder
+pub mod vortex_array::arrays::varbinview::build_views
 
-pub fn vortex_array::builders::ExtensionBuilder::append_value(&mut self, value: vortex_array::scalar::ExtScalar<'_>) -> vortex_error::VortexResult<()>
+#[repr(C, align(16))] pub union vortex_array::arrays::varbinview::build_views::BinaryView
 
-pub fn vortex_array::builders::ExtensionBuilder::finish_into_extension(&mut self) -> vortex_array::arrays::ExtensionArray
+impl vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ExtensionBuilder::new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef) -> Self
+pub const vortex_array::arrays::varbinview::BinaryView::MAX_INLINED_SIZE: usize
 
-pub fn vortex_array::builders::ExtensionBuilder::with_capacity(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, capacity: usize) -> Self
+pub fn vortex_array::arrays::varbinview::BinaryView::as_inlined(&self) -> &vortex_array::arrays::varbinview::Inlined
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::ExtensionBuilder
+pub fn vortex_array::arrays::varbinview::BinaryView::as_u128(&self) -> u128
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::as_view(&self) -> &vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::ExtensionBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbinview::BinaryView::as_view_mut(&mut self) -> &mut vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::ExtensionBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::empty_view() -> Self
 
-pub fn vortex_array::builders::ExtensionBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::BinaryView::is_empty(&self) -> bool
 
-pub fn vortex_array::builders::ExtensionBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::BinaryView::is_inlined(&self) -> bool
 
-pub fn vortex_array::builders::ExtensionBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbinview::BinaryView::len(&self) -> u32
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::varbinview::BinaryView::make_view(value: &[u8], block: u32, offset: u32) -> Self
 
-pub fn vortex_array::builders::ExtensionBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::varbinview::BinaryView::new_inlined(value: &[u8]) -> Self
 
-pub fn vortex_array::builders::ExtensionBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+impl core::clone::Clone for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ExtensionBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::varbinview::BinaryView::clone(&self) -> vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ExtensionBuilder::reserve_exact(&mut self, capacity: usize)
+impl core::cmp::Eq for vortex_array::arrays::varbinview::BinaryView
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl core::cmp::PartialEq for vortex_array::arrays::varbinview::BinaryView
 
-pub struct vortex_array::builders::FixedSizeListBuilder
+pub fn vortex_array::arrays::varbinview::BinaryView::eq(&self, other: &Self) -> bool
 
-impl vortex_array::builders::FixedSizeListBuilder
+impl core::convert::From<u128> for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_array_as_list(&mut self, array: &dyn vortex_array::Array) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbinview::BinaryView::from(value: u128) -> Self
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
+impl core::convert::From<vortex_array::arrays::varbinview::Ref> for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::element_dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbinview::BinaryView::from(value: vortex_array::arrays::varbinview::Ref) -> Self
 
-pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_fixed_size_list(&mut self) -> vortex_array::arrays::FixedSizeListArray
+impl core::default::Default for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::list_size(&self) -> u32
+pub fn vortex_array::arrays::varbinview::BinaryView::default() -> Self
 
-pub fn vortex_array::builders::FixedSizeListBuilder::new(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, list_size: u32, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::fmt::Debug for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::with_capacity(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, list_size: u32, nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
+pub fn vortex_array::arrays::varbinview::BinaryView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::FixedSizeListBuilder
+impl core::hash::Hash for vortex_array::arrays::varbinview::BinaryView
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl core::marker::Copy for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_zeros(&mut self, n: usize)
+pub const vortex_array::arrays::varbinview::build_views::MAX_BUFFER_LEN: usize
 
-pub fn vortex_array::builders::FixedSizeListBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::build_views::build_views<P: vortex_array::dtype::NativePType + num_traits::cast::AsPrimitive<usize>>(start_buf_index: u32, max_buffer_len: usize, bytes: vortex_buffer::ByteBufferMut, lens: &[P]) -> (alloc::vec::Vec<vortex_buffer::ByteBuffer>, vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>)
 
-pub fn vortex_array::builders::FixedSizeListBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::build_views::offsets_to_lengths<P: vortex_array::dtype::NativePType>(offsets: &[P]) -> vortex_buffer::buffer::Buffer<P>
 
-pub fn vortex_array::builders::FixedSizeListBuilder::dtype(&self) -> &vortex_array::dtype::DType
+#[repr(C, align(16))] pub union vortex_array::arrays::varbinview::BinaryView
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::FixedSizeListBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub const vortex_array::arrays::varbinview::BinaryView::MAX_INLINED_SIZE: usize
 
-pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::varbinview::BinaryView::as_inlined(&self) -> &vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::FixedSizeListBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::varbinview::BinaryView::as_u128(&self) -> u128
 
-pub fn vortex_array::builders::FixedSizeListBuilder::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::as_view(&self) -> &vortex_array::arrays::varbinview::Ref
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::varbinview::BinaryView::as_view_mut(&mut self) -> &mut vortex_array::arrays::varbinview::Ref
 
-pub struct vortex_array::builders::ListBuilder<O: vortex_array::dtype::IntegerPType>
+pub fn vortex_array::arrays::varbinview::BinaryView::empty_view() -> Self
 
-impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ListBuilder<O>
+pub fn vortex_array::arrays::varbinview::BinaryView::is_empty(&self) -> bool
 
-pub fn vortex_array::builders::ListBuilder<O>::append_array_as_list(&mut self, array: &dyn vortex_array::Array) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbinview::BinaryView::is_inlined(&self) -> bool
 
-pub fn vortex_array::builders::ListBuilder<O>::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbinview::BinaryView::len(&self) -> u32
 
-pub fn vortex_array::builders::ListBuilder<O>::element_dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbinview::BinaryView::make_view(value: &[u8], block: u32, offset: u32) -> Self
 
-pub fn vortex_array::builders::ListBuilder<O>::finish_into_list(&mut self) -> vortex_array::arrays::ListArray
+pub fn vortex_array::arrays::varbinview::BinaryView::new_inlined(value: &[u8]) -> Self
 
-pub fn vortex_array::builders::ListBuilder<O>::new(value_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::clone::Clone for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::with_capacity(value_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability, elements_capacity: usize, capacity: usize) -> Self
+pub fn vortex_array::arrays::varbinview::BinaryView::clone(&self) -> vortex_array::arrays::varbinview::BinaryView
 
-impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListBuilder<O>
+impl core::cmp::Eq for vortex_array::arrays::varbinview::BinaryView
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::append_nulls_unchecked(&mut self, n: usize)
+impl core::cmp::PartialEq for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::varbinview::BinaryView::eq(&self, other: &Self) -> bool
 
-pub fn vortex_array::builders::ListBuilder<O>::append_zeros(&mut self, n: usize)
+impl core::convert::From<u128> for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::BinaryView::from(value: u128) -> Self
 
-pub fn vortex_array::builders::ListBuilder<O>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl core::convert::From<vortex_array::arrays::varbinview::Ref> for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbinview::BinaryView::from(value: vortex_array::arrays::varbinview::Ref) -> Self
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl core::default::Default for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::varbinview::BinaryView::default() -> Self
 
-pub fn vortex_array::builders::ListBuilder<O>::len(&self) -> usize
+impl core::fmt::Debug for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListBuilder<O>::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl core::hash::Hash for vortex_array::arrays::varbinview::BinaryView
 
-pub struct vortex_array::builders::ListViewBuilder<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType>
+pub fn vortex_array::arrays::varbinview::BinaryView::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ListViewBuilder<O, S>
+impl core::marker::Copy for vortex_array::arrays::varbinview::BinaryView
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_array_as_list(&mut self, array: &dyn vortex_array::Array) -> vortex_error::VortexResult<()>
+#[repr(C, align(8))] pub struct vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
+pub vortex_array::arrays::varbinview::Inlined::data: [u8; 12]
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::element_dtype(&self) -> &vortex_array::dtype::DType
+pub vortex_array::arrays::varbinview::Inlined::size: u32
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_listview(&mut self) -> vortex_array::arrays::ListViewArray
+impl vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::new(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::varbinview::Inlined::value(&self) -> &[u8]
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::with_capacity(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability, elements_capacity: usize, capacity: usize) -> Self
+impl core::clone::Clone for vortex_array::arrays::varbinview::Inlined
 
-impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListViewBuilder<O, S>
+pub fn vortex_array::arrays::varbinview::Inlined::clone(&self) -> vortex_array::arrays::varbinview::Inlined
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls_unchecked(&mut self, n: usize)
+impl core::cmp::Eq for vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl core::cmp::PartialEq for vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::Inlined::eq(&self, other: &vortex_array::arrays::varbinview::Inlined) -> bool
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any(&self) -> &dyn core::any::Any
+impl core::fmt::Debug for vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::Inlined::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::dtype(&self) -> &vortex_array::dtype::DType
+impl core::marker::Copy for vortex_array::arrays::varbinview::Inlined
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl core::marker::StructuralPartialEq for vortex_array::arrays::varbinview::Inlined
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::finish(&mut self) -> vortex_array::ArrayRef
+#[repr(C, align(8))] pub struct vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub vortex_array::arrays::varbinview::Ref::buffer_index: u32
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::len(&self) -> usize
+pub vortex_array::arrays::varbinview::Ref::offset: u32
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::reserve_exact(&mut self, capacity: usize)
+pub vortex_array::arrays::varbinview::Ref::prefix: [u8; 4]
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub vortex_array::arrays::varbinview::Ref::size: u32
 
-pub struct vortex_array::builders::NullBuilder
+impl vortex_array::arrays::varbinview::Ref
 
-impl vortex_array::builders::NullBuilder
+pub fn vortex_array::arrays::varbinview::Ref::as_range(&self) -> core::ops::range::Range<usize>
 
-pub fn vortex_array::builders::NullBuilder::new() -> Self
+pub fn vortex_array::arrays::varbinview::Ref::with_buffer_and_offset(&self, buffer_index: u32, offset: u32) -> vortex_array::arrays::varbinview::Ref
 
-impl core::default::Default for vortex_array::builders::NullBuilder
+impl core::clone::Clone for vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::NullBuilder::default() -> Self
+pub fn vortex_array::arrays::varbinview::Ref::clone(&self) -> vortex_array::arrays::varbinview::Ref
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::NullBuilder
+impl core::convert::From<vortex_array::arrays::varbinview::Ref> for vortex_array::arrays::varbinview::BinaryView
 
-pub unsafe fn vortex_array::builders::NullBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::BinaryView::from(value: vortex_array::arrays::varbinview::Ref) -> Self
 
-pub fn vortex_array::builders::NullBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl core::fmt::Debug for vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::NullBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::Ref::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::NullBuilder::as_any(&self) -> &dyn core::any::Any
+impl core::marker::Copy for vortex_array::arrays::varbinview::Ref
 
-pub fn vortex_array::builders::NullBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub struct vortex_array::arrays::varbinview::VarBinView
 
-pub fn vortex_array::builders::NullBuilder::dtype(&self) -> &vortex_array::dtype::DType
+impl vortex_array::arrays::VarBinView
 
-pub unsafe fn vortex_array::builders::NullBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub const vortex_array::arrays::VarBinView::ID: vortex_array::ArrayId
 
-pub fn vortex_array::builders::NullBuilder::finish(&mut self) -> vortex_array::ArrayRef
+impl core::clone::Clone for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::NullBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::VarBinView::clone(&self) -> vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::NullBuilder::len(&self) -> usize
+impl core::fmt::Debug for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::NullBuilder::reserve_exact(&mut self, _additional: usize)
+pub fn vortex_array::arrays::VarBinView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub unsafe fn vortex_array::builders::NullBuilder::set_validity_unchecked(&mut self, _validity: vortex_mask::Mask)
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub struct vortex_array::builders::PrimitiveBuilder<T>
+pub fn vortex_array::arrays::VarBinView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::builders::PrimitiveBuilder<T>
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::append_value(&mut self, value: T)
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::extend_with_iterator(&mut self, iter: impl core::iter::traits::collect::IntoIterator<Item = T>, mask: vortex_mask::Mask)
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_primitive(&mut self) -> vortex_array::arrays::PrimitiveArray
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::new(nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::uninit_range(&mut self, len: usize) -> vortex_array::builders::UninitRange<'_, T>
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::values(&self) -> &[T]
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::with_capacity(nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::builders::ArrayBuilder for vortex_array::builders::PrimitiveBuilder<T>
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::len(&self) -> usize
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub struct vortex_array::builders::StructBuilder
+pub fn vortex_array::arrays::VarBinView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::builders::StructBuilder
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::StructBuilder::append_value(&mut self, struct_scalar: vortex_array::scalar::StructScalar<'_>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::VarBinView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::finish_into_struct(&mut self) -> vortex_array::arrays::StructArray
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::StructBuilder::new(struct_dtype: vortex_array::dtype::StructFields, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::VarBinView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::struct_fields(&self) -> &vortex_array::dtype::StructFields
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::StructBuilder::with_capacity(struct_dtype: vortex_array::dtype::StructFields, nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
+pub fn vortex_array::arrays::VarBinView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::StructBuilder
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinView
 
-pub unsafe fn vortex_array::builders::StructBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::VarBinView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::builders::StructBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::VarBinView::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::as_any(&self) -> &dyn core::any::Any
+pub struct vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::StructBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::StructBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::varbinview::VarBinViewData::buffer(&self, idx: usize) -> &vortex_buffer::ByteBuffer
 
-pub unsafe fn vortex_array::builders::StructBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::bytes_at(&self, index: usize) -> vortex_buffer::ByteBuffer
 
-pub fn vortex_array::builders::StructBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::varbinview::VarBinViewData::data_buffers(&self) -> &alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>
 
-pub fn vortex_array::builders::StructBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::builders::StructBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
 
-pub fn vortex_array::builders::StructBuilder::reserve_exact(&mut self, capacity: usize)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter_nullable_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
 
-pub unsafe fn vortex_array::builders::StructBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter_nullable_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
 
-pub struct vortex_array::builders::UninitRange<'a, T>
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
 
-impl<T> vortex_array::builders::UninitRange<'_, T>
+pub fn vortex_array::arrays::varbinview::VarBinViewData::is_empty(&self) -> bool
 
-pub unsafe fn vortex_array::builders::UninitRange<'_, T>::append_mask(&mut self, mask: vortex_mask::Mask)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::len(&self) -> usize
 
-pub fn vortex_array::builders::UninitRange<'_, T>::copy_from_slice(&mut self, local_offset: usize, src: &[T]) where T: core::marker::Copy
+pub fn vortex_array::arrays::varbinview::VarBinViewData::new(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub unsafe fn vortex_array::builders::UninitRange<'_, T>::finish(self)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::new_handle(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::builders::UninitRange<'_, T>::is_empty(&self) -> bool
+pub unsafe fn vortex_array::arrays::varbinview::VarBinViewData::new_handle_unchecked(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, _validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::builders::UninitRange<'_, T>::len(&self) -> usize
+pub unsafe fn vortex_array::arrays::varbinview::VarBinViewData::new_unchecked(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::builders::UninitRange<'_, T>::set_validity_bit(&mut self, index: usize, v: bool)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::try_new(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::builders::UninitRange<'_, T>::set_value(&mut self, index: usize, value: T)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::try_new_handle(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub unsafe fn vortex_array::builders::UninitRange<'_, T>::slice_uninit_mut(&mut self, offset: usize, len: usize) -> &mut [core::mem::maybe_uninit::MaybeUninit<T>]
+pub fn vortex_array::arrays::varbinview::VarBinViewData::validate(views: &vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: &alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: &vortex_array::dtype::DType, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::builders::VarBinViewBuilder
+pub fn vortex_array::arrays::varbinview::VarBinViewData::views(&self) -> &[vortex_array::arrays::varbinview::BinaryView]
 
-impl vortex_array::builders::VarBinViewBuilder
+pub fn vortex_array::arrays::varbinview::VarBinViewData::views_handle(&self) -> &vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::VarBinViewBuilder::append_value<S: core::convert::AsRef<[u8]>>(&mut self, value: S)
+impl core::clone::Clone for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::completed_block_count(&self) -> u32
+pub fn vortex_array::arrays::varbinview::VarBinViewData::clone(&self) -> vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::finish_into_varbinview(&mut self) -> vortex_array::arrays::VarBinViewArray
+impl core::fmt::Debug for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::new(dtype: vortex_array::dtype::DType, capacity: usize, completed: vortex_array::builders::CompletedBuffers, growth_strategy: vortex_array::builders::BufferGrowthStrategy, compaction_threshold: f64) -> Self
+pub fn vortex_array::arrays::varbinview::VarBinViewData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::VarBinViewBuilder::push_buffer_and_adjusted_views(&mut self, buffers: &[vortex_buffer::ByteBuffer], views: &vortex_buffer::buffer::Buffer<vortex_array::arrays::BinaryView>, validity_mask: vortex_mask::Mask)
+impl core::fmt::Display for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::with_buffer_deduplication(dtype: vortex_array::dtype::DType, capacity: usize) -> Self
+pub fn vortex_array::arrays::varbinview::VarBinViewData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::VarBinViewBuilder::with_capacity(dtype: vortex_array::dtype::DType, capacity: usize) -> Self
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::string::String>> for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::with_compaction(dtype: vortex_array::dtype::DType, capacity: usize, compaction_threshold: f64) -> Self
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::string::String>>>(iter: T) -> Self
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::VarBinViewBuilder
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::vec::Vec<u8>>> for vortex_array::arrays::varbinview::VarBinViewData
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::vec::Vec<u8>>>>(iter: T) -> Self
 
-pub fn vortex_array::builders::VarBinViewBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl vortex_array::ArrayEq for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::builders::VarBinViewBuilder::as_any(&self) -> &dyn core::any::Any
+impl vortex_array::ArrayHash for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::varbinview::VarBinViewData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::builders::VarBinViewBuilder::dtype(&self) -> &vortex_array::dtype::DType
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a [u8]>> for vortex_array::arrays::varbinview::VarBinViewData
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a [u8]>>>(iter: T) -> Self
 
-pub fn vortex_array::builders::VarBinViewBuilder::finish(&mut self) -> vortex_array::ArrayRef
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a str>> for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::builders::VarBinViewBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::varbinview::VarBinViewData::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a str>>>(iter: T) -> Self
 
-pub fn vortex_array::builders::VarBinViewBuilder::len(&self) -> usize
+pub struct vortex_array::arrays::varbinview::VarBinViewDataParts
 
-pub fn vortex_array::builders::VarBinViewBuilder::reserve_exact(&mut self, additional: usize)
+pub vortex_array::arrays::varbinview::VarBinViewDataParts::buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub vortex_array::arrays::varbinview::VarBinViewDataParts::dtype: vortex_array::dtype::DType
 
-pub const vortex_array::builders::DEFAULT_BUILDER_CAPACITY: usize
+pub vortex_array::arrays::varbinview::VarBinViewDataParts::validity: vortex_array::validity::Validity
 
-pub trait vortex_array::builders::ArrayBuilder: core::marker::Send
+pub vortex_array::arrays::varbinview::VarBinViewDataParts::views: vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::ArrayBuilder::append_default(&mut self)
+pub trait vortex_array::arrays::varbinview::VarBinViewArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::builders::ArrayBuilder::append_defaults(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::VarBinViewArrayExt::dtype_parts(&self) -> (bool, vortex_array::dtype::Nullability)
 
-pub fn vortex_array::builders::ArrayBuilder::append_null(&mut self)
+pub fn vortex_array::arrays::varbinview::VarBinViewArrayExt::varbinview_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::builders::ArrayBuilder::append_nulls(&mut self, n: usize)
+pub fn vortex_array::arrays::varbinview::VarBinViewArrayExt::varbinview_validity_mask(&self) -> vortex_mask::Mask
 
-pub unsafe fn vortex_array::builders::ArrayBuilder::append_nulls_unchecked(&mut self, n: usize)
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::VarBinView>> vortex_array::arrays::varbinview::VarBinViewArrayExt for T
 
-pub fn vortex_array::builders::ArrayBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn T::dtype_parts(&self) -> (bool, vortex_array::dtype::Nullability)
 
-pub fn vortex_array::builders::ArrayBuilder::append_zero(&mut self)
+pub fn T::varbinview_validity(&self) -> vortex_array::validity::Validity
 
-pub fn vortex_array::builders::ArrayBuilder::append_zeros(&mut self, n: usize)
+pub fn T::varbinview_validity_mask(&self) -> vortex_mask::Mask
 
-pub fn vortex_array::builders::ArrayBuilder::as_any(&self) -> &dyn core::any::Any
+pub type vortex_array::arrays::varbinview::VarBinViewArray = vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::builders::ArrayBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub mod vortex_array::arrays::variant
 
-pub fn vortex_array::builders::ArrayBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub struct vortex_array::arrays::variant::Variant
 
-pub fn vortex_array::builders::ArrayBuilder::extend_from_array(&mut self, array: &dyn vortex_array::Array)
+impl vortex_array::arrays::Variant
 
-pub unsafe fn vortex_array::builders::ArrayBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub const vortex_array::arrays::Variant::ID: vortex_array::ArrayId
 
-pub fn vortex_array::builders::ArrayBuilder::finish(&mut self) -> vortex_array::ArrayRef
+impl core::clone::Clone for vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::ArrayBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Variant::clone(&self) -> vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::ArrayBuilder::is_empty(&self) -> bool
+impl core::fmt::Debug for vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::ArrayBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::Variant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::ArrayBuilder::reserve_exact(&mut self, additional: usize)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::ArrayBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::Variant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub unsafe fn vortex_array::builders::ArrayBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::BoolBuilder
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub unsafe fn vortex_array::builders::BoolBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::BoolBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-pub fn vortex_array::builders::BoolBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::BoolBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::BoolBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::builders::BoolBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub unsafe fn vortex_array::builders::BoolBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::BoolBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::builders::BoolBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::builders::BoolBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::BoolBuilder::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub unsafe fn vortex_array::builders::BoolBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::DecimalBuilder
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::DecimalBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::DecimalBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::builders::DecimalBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::DecimalBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::DecimalBuilder::dtype(&self) -> &vortex_array::dtype::DType
+impl vortex_array::ValidityVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Variant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::builders::DecimalBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub trait vortex_array::arrays::variant::VariantArrayExt: vortex_array::TypedArrayRef<vortex_array::arrays::Variant>
 
-pub fn vortex_array::builders::DecimalBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::variant::VariantArrayExt::child(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::builders::DecimalBuilder::len(&self) -> usize
+impl<T: vortex_array::TypedArrayRef<vortex_array::arrays::Variant>> vortex_array::arrays::variant::VariantArrayExt for T
 
-pub fn vortex_array::builders::DecimalBuilder::reserve_exact(&mut self, additional: usize)
+pub fn T::child(&self) -> &vortex_array::ArrayRef
 
-pub unsafe fn vortex_array::builders::DecimalBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub type vortex_array::arrays::variant::VariantArray = vortex_array::Array<vortex_array::arrays::Variant>
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::ExtensionBuilder
+pub struct vortex_array::arrays::Bool
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::append_nulls_unchecked(&mut self, n: usize)
+impl vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub const vortex_array::arrays::Bool::ID: vortex_array::ArrayId
 
-pub fn vortex_array::builders::ExtensionBuilder::append_zeros(&mut self, n: usize)
+impl core::clone::Clone for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Bool::clone(&self) -> vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl core::fmt::Debug for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Bool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::builders::ExtensionBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::ExtensionBuilder::len(&self) -> usize
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::builders::ExtensionBuilder::reserve_exact(&mut self, capacity: usize)
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-pub unsafe fn vortex_array::builders::ExtensionBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::FixedSizeListBuilder
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::builders::FixedSizeListBuilder::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::builders::FixedSizeListBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::FixedSizeListBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::builders::FixedSizeListBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::FixedSizeListBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::FixedSizeListBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::FixedSizeListBuilder::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::FixedSizeListBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::NullBuilder
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub unsafe fn vortex_array::builders::NullBuilder::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::NullBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::NullBuilder::append_zeros(&mut self, n: usize)
+impl vortex_array::ValidityVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::NullBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Bool::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::builders::NullBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::NullBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Bool::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::NullBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::NullBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::NullBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::NullBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::Bool::slice(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::NullBuilder::reserve_exact(&mut self, _additional: usize)
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Bool> for vortex_array::arrays::bool::BoolMaskedValidityRule
 
-pub unsafe fn vortex_array::builders::NullBuilder::set_validity_unchecked(&mut self, _validity: vortex_mask::Mask)
+pub type vortex_array::arrays::bool::BoolMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::StructBuilder
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::StructBuilder::append_nulls_unchecked(&mut self, n: usize)
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::StructBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Bool::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::append_zeros(&mut self, n: usize)
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::StructBuilder::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Bool::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::StructBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Bool
 
-pub fn vortex_array::builders::StructBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Bool::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::StructBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub struct vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::StructBuilder::finish(&mut self) -> vortex_array::ArrayRef
+impl vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::StructBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub const vortex_array::arrays::Chunked::ID: vortex_array::ArrayId
 
-pub fn vortex_array::builders::StructBuilder::len(&self) -> usize
+impl core::clone::Clone for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::StructBuilder::reserve_exact(&mut self, capacity: usize)
+pub fn vortex_array::arrays::Chunked::clone(&self) -> vortex_array::arrays::Chunked
 
-pub unsafe fn vortex_array::builders::StructBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl core::fmt::Debug for vortex_array::arrays::Chunked
 
-impl vortex_array::builders::ArrayBuilder for vortex_array::builders::VarBinViewBuilder
+pub fn vortex_array::arrays::Chunked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::append_nulls_unchecked(&mut self, n: usize)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::VarBinViewBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Chunked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::builders::VarBinViewBuilder::append_zeros(&mut self, n: usize)
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::VarBinViewBuilder::as_any(&self) -> &dyn core::any::Any
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::builders::VarBinViewBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::VarBinViewBuilder::dtype(&self) -> &vortex_array::dtype::DType
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::VarBinViewBuilder::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builders::VarBinViewBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::builders::VarBinViewBuilder::len(&self) -> usize
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::builders::VarBinViewBuilder::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub unsafe fn vortex_array::builders::VarBinViewBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListViewBuilder<O, S>
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls_unchecked(&mut self, n: usize)
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zeros(&mut self, n: usize)
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::len(&self) -> usize
+impl vortex_array::ValidityVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListViewBuilder<O, S>::reserve_exact(&mut self, capacity: usize)
+pub fn vortex_array::arrays::Chunked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Chunked
 
-impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListBuilder<O>
+pub fn vortex_array::arrays::Chunked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::append_nulls_unchecked(&mut self, n: usize)
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListBuilder<O>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Chunked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::ListBuilder<O>::append_zeros(&mut self, n: usize)
+impl vortex_array::arrays::slice::SliceKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListBuilder<O>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Chunked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::ListBuilder<O>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListBuilder<O>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Chunked::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListBuilder<O>::finish(&mut self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builders::ListBuilder<O>::len(&self) -> usize
+impl vortex_array::scalar_fn::fns::mask::MaskKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::builders::ListBuilder<O>::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::Chunked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::ListBuilder<O>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Chunked
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::builders::ArrayBuilder for vortex_array::builders::PrimitiveBuilder<T>
+pub fn vortex_array::arrays::Chunked::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls_unchecked(&mut self, n: usize)
+pub struct vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
+impl vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zeros(&mut self, n: usize)
+pub const vortex_array::arrays::Constant::ID: vortex_array::ArrayId
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any(&self) -> &dyn core::any::Any
+impl vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any_mut(&mut self) -> &mut dyn core::any::Any
+pub const vortex_array::arrays::Constant::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::dtype(&self) -> &vortex_array::dtype::DType
+impl core::clone::Clone for vortex_array::arrays::Constant
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array_unchecked(&mut self, array: &dyn vortex_array::Array)
+pub fn vortex_array::arrays::Constant::clone(&self) -> vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::finish(&mut self) -> vortex_array::ArrayRef
+impl core::fmt::Debug for vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_canonical(&mut self) -> vortex_array::Canonical
+pub fn vortex_array::arrays::Constant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::len(&self) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::PrimitiveBuilder<T>::reserve_exact(&mut self, additional: usize)
+pub fn vortex_array::arrays::Constant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-pub fn vortex_array::builders::builder_with_capacity(dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-pub mod vortex_array::builtins
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-pub trait vortex_array::builtins::ArrayBuiltins: core::marker::Sized
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::builtins::ArrayBuiltins::between(self, lower: vortex_array::ArrayRef, upper: vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::builtins::ArrayBuiltins::binary(&self, rhs: vortex_array::ArrayRef, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::builtins::ArrayBuiltins::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::builtins::ArrayBuiltins::fill_null(&self, fill_value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::builtins::ArrayBuiltins::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::builtins::ArrayBuiltins::is_null(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::builtins::ArrayBuiltins::list_contains(&self, value: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::builtins::ArrayBuiltins::mask(self, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ArrayBuiltins::not(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::builtins::ArrayBuiltins::zip(&self, if_false: vortex_array::ArrayRef, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::builtins::ArrayBuiltins for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayRef::between(self, lower: vortex_array::ArrayRef, upper: vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::binary(&self, rhs: vortex_array::ArrayRef, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayRef::fill_null(&self, fill_value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayRef::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayRef::is_null(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::ValidityVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::ArrayRef::list_contains(&self, value: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ArrayRef::mask(self, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::ArrayRef::not(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::zip(&self, if_false: vortex_array::ArrayRef, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Constant
 
-pub trait vortex_array::builtins::ExprBuiltins: core::marker::Sized
+pub fn vortex_array::arrays::Constant::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ExprBuiltins::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::builtins::ExprBuiltins::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Constant::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ExprBuiltins::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::between::BetweenReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::builtins::ExprBuiltins::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Constant::between(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ExprBuiltins::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::builtins::ExprBuiltins::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Constant::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ExprBuiltins::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::builtins::ExprBuiltins::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Constant::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::builtins::ExprBuiltins::zip(&self, if_false: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::not::NotReduce for vortex_array::arrays::Constant
 
-impl vortex_array::builtins::ExprBuiltins for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Constant::invert(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub struct vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub const vortex_array::arrays::Decimal::ID: vortex_array::ArrayId
 
-pub fn vortex_array::expr::Expression::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl core::clone::Clone for vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Decimal::clone(&self) -> vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl core::fmt::Debug for vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Decimal::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::Expression::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::expr::Expression::zip(&self, if_false: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Decimal::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub mod vortex_array::compute
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-pub enum vortex_array::compute::Cost
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-pub vortex_array::compute::Cost::Canonicalize
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub vortex_array::compute::Cost::Negligible
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-pub vortex_array::compute::Cost::Specialized
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::clone::Clone for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::compute::Cost::clone(&self) -> vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::cmp::Eq for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::cmp::PartialEq for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::compute::Cost::eq(&self, other: &vortex_array::compute::Cost) -> bool
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::fmt::Debug for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::compute::Cost::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::marker::Copy for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-impl core::marker::StructuralPartialEq for vortex_array::compute::Cost
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub enum vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::compute::Input::Array(&'a dyn vortex_array::Array)
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::compute::Input::Builder(&'a mut dyn vortex_array::builders::ArrayBuilder)
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::compute::Input::DType(&'a vortex_array::dtype::DType)
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::compute::Input::Mask(&'a vortex_mask::Mask)
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::compute::Input::Scalar(&'a vortex_array::scalar::Scalar)
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl<'a> vortex_array::compute::Input<'a>
+impl vortex_array::ValidityVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::compute::Input<'a>::array(&self) -> core::option::Option<&'a dyn vortex_array::Array>
+pub fn vortex_array::arrays::Decimal::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::compute::Input<'a>::builder(&'a mut self) -> core::option::Option<&'a mut dyn vortex_array::builders::ArrayBuilder>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Decimal
 
-pub fn vortex_array::compute::Input<'a>::dtype(&self) -> core::option::Option<&'a vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Decimal::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::Input<'a>::mask(&self) -> core::option::Option<&'a vortex_mask::Mask>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Decimal
 
-pub fn vortex_array::compute::Input<'a>::scalar(&self) -> core::option::Option<&'a vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Decimal::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::compute::Input<'_>
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Decimal> for vortex_array::arrays::decimal::DecimalMaskedValidityRule
 
-pub fn vortex_array::compute::Input<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::decimal::DecimalMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-impl<'a> core::convert::From<&'a (dyn vortex_array::Array + 'static)> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a dyn vortex_array::Array) -> Self
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Decimal
 
-impl<'a> core::convert::From<&'a vortex_array::dtype::DType> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::Decimal::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a vortex_array::dtype::DType) -> Self
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Decimal
 
-impl<'a> core::convert::From<&'a vortex_array::scalar::Scalar> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::Decimal::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a vortex_array::scalar::Scalar) -> Self
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Decimal
 
-impl<'a> core::convert::From<&'a vortex_mask::Mask> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::Decimal::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a vortex_mask::Mask) -> Self
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Decimal
 
-pub enum vortex_array::compute::Output
+pub fn vortex_array::arrays::Decimal::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::compute::Output::Array(vortex_array::ArrayRef)
+pub struct vortex_array::arrays::Dict
 
-pub vortex_array::compute::Output::Scalar(vortex_array::scalar::Scalar)
+impl vortex_array::arrays::dict::Dict
 
-impl vortex_array::compute::Output
+pub const vortex_array::arrays::dict::Dict::ID: vortex_array::ArrayId
 
-pub fn vortex_array::compute::Output::dtype(&self) -> &vortex_array::dtype::DType
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::len(&self) -> usize
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::unwrap_array(self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::unwrap_scalar(self) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<alloc::sync::Arc<dyn vortex_array::Array>> for vortex_array::compute::Output
+impl vortex_array::OperationsVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::from(value: vortex_array::ArrayRef) -> Self
+pub fn vortex_array::arrays::dict::Dict::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::convert::From<vortex_array::scalar::Scalar> for vortex_array::compute::Output
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::from(value: vortex_array::scalar::Scalar) -> Self
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-impl core::fmt::Debug for vortex_array::compute::Output
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::Output::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::compute::BinaryArgs<'a, O: vortex_array::compute::Options>
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub vortex_array::compute::BinaryArgs::lhs: &'a dyn vortex_array::Array
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub vortex_array::compute::BinaryArgs::options: &'a O
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub vortex_array::compute::BinaryArgs::rhs: &'a dyn vortex_array::Array
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<'a, O: vortex_array::compute::Options> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::BinaryArgs<'a, O>
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::compute::BinaryArgs<'a, O>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::compute::BinaryArgs<'a, O>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::compute::ComputeFn
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::ComputeFn
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::compute::ComputeFn::id(&self) -> &arcref::ArcRef<str>
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::ComputeFn::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<vortex_array::compute::Output>
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::ComputeFn::is_elementwise(&self) -> bool
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::ComputeFn::kernels(&self) -> alloc::vec::Vec<arcref::ArcRef<dyn vortex_array::compute::Kernel>>
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::ComputeFn::new(id: arcref::ArcRef<str>, vtable: arcref::ArcRef<dyn vortex_array::compute::ComputeFnVTable>) -> Self
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::compute::ComputeFn::register_kernel(&self, kernel: arcref::ArcRef<dyn vortex_array::compute::Kernel>)
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::compute::ComputeFn::return_dtype(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::compute::ComputeFn::return_len(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<usize>
+impl vortex_array::ValidityVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::compute::InvocationArgs<'a>
+pub fn vortex_array::arrays::dict::Dict::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::compute::InvocationArgs::inputs: &'a [vortex_array::compute::Input<'a>]
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::dict::Dict
 
-pub vortex_array::compute::InvocationArgs::options: &'a dyn vortex_array::compute::Options
+pub fn vortex_array::arrays::dict::Dict::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a, O: vortex_array::compute::Options> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::BinaryArgs<'a, O>
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::compute::BinaryArgs<'a, O>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::dict::Dict::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::BinaryArgs<'a, O>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::dict::Dict
 
-impl<'a, O: vortex_array::compute::Options> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::UnaryArgs<'a, O>
+pub fn vortex_array::arrays::dict::Dict::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::compute::UnaryArgs<'a, O>::Error = vortex_error::VortexError
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::UnaryArgs<'a, O>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::dict::Dict::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::clone::Clone for vortex_array::compute::InvocationArgs<'a>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::compute::InvocationArgs<'a>::clone(&self) -> vortex_array::compute::InvocationArgs<'a>
+pub fn vortex_array::arrays::dict::Dict::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::SumArgs<'a>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::compute::SumArgs<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::dict::Dict::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::SumArgs<'a>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::compute::IsConstantKernelAdapter<V: vortex_array::vtable::VTable>(pub V)
+pub fn vortex_array::arrays::dict::Dict::like(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsConstantKernel> vortex_array::compute::IsConstantKernelAdapter<V>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::dict::Dict
 
-pub const fn vortex_array::compute::IsConstantKernelAdapter<V>::lift(&'static self) -> vortex_array::compute::IsConstantKernelRef
+pub fn vortex_array::arrays::dict::Dict::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::fmt::Debug + vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::compute::IsConstantKernelAdapter<V>
+pub struct vortex_array::arrays::Extension
 
-pub fn vortex_array::compute::IsConstantKernelAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::Extension
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsConstantKernel> vortex_array::compute::Kernel for vortex_array::compute::IsConstantKernelAdapter<V>
+pub const vortex_array::arrays::Extension::ID: vortex_array::ArrayId
 
-pub fn vortex_array::compute::IsConstantKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+impl core::clone::Clone for vortex_array::arrays::Extension
 
-pub struct vortex_array::compute::IsConstantKernelRef(_)
+pub fn vortex_array::arrays::Extension::clone(&self) -> vortex_array::arrays::Extension
 
-impl inventory::Collect for vortex_array::compute::IsConstantKernelRef
+impl core::fmt::Debug for vortex_array::arrays::Extension
 
-pub struct vortex_array::compute::IsConstantOpts
+pub fn vortex_array::arrays::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::compute::IsConstantOpts::cost: vortex_array::compute::Cost
+impl vortex_array::OperationsVTable<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-impl vortex_array::compute::IsConstantOpts
+pub fn vortex_array::arrays::Extension::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::compute::IsConstantOpts::is_negligible_cost(&self) -> bool
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-impl core::clone::Clone for vortex_array::compute::IsConstantOpts
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::compute::IsConstantOpts::clone(&self) -> vortex_array::compute::IsConstantOpts
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-impl core::default::Default for vortex_array::compute::IsConstantOpts
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::compute::IsConstantOpts::default() -> Self
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::fmt::Debug for vortex_array::compute::IsConstantOpts
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::compute::IsConstantOpts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::compute::Options for vortex_array::compute::IsConstantOpts
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::compute::IsConstantOpts::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::compute::IsSortedKernelAdapter<V: vortex_array::vtable::VTable>(pub V)
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsSortedKernel> vortex_array::compute::IsSortedKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub const fn vortex_array::compute::IsSortedKernelAdapter<V>::lift(&'static self) -> vortex_array::compute::IsSortedKernelRef
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::fmt::Debug + vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::compute::IsSortedKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::compute::IsSortedKernelAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsSortedKernel> vortex_array::compute::Kernel for vortex_array::compute::IsSortedKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::IsSortedKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::compute::IsSortedKernelRef(_)
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl inventory::Collect for vortex_array::compute::IsSortedKernelRef
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_array::compute::MinMax
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::compute::ComputeFnVTable for vortex_array::compute::MinMax
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::compute::MinMax::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>, kernels: &[arcref::ArcRef<dyn vortex_array::compute::Kernel>]) -> vortex_error::VortexResult<vortex_array::compute::Output>
+impl vortex_array::ValidityChild<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-pub fn vortex_array::compute::MinMax::is_elementwise(&self) -> bool
+pub fn vortex_array::arrays::Extension::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::compute::MinMax::return_dtype(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Extension
 
-pub fn vortex_array::compute::MinMax::return_len(&self, _args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::Extension::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, indices: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::compute::MinMaxKernelAdapter<V: vortex_array::vtable::VTable>(pub V)
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Extension
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::MinMaxKernel> vortex_array::compute::MinMaxKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const fn vortex_array::compute::MinMaxKernelAdapter<V>::lift(&'static self) -> vortex_array::compute::MinMaxKernelRef
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Extension
 
-impl<V: core::fmt::Debug + vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::compute::MinMaxKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::MinMaxKernelAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::Extension
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::MinMaxKernel> vortex_array::compute::Kernel for vortex_array::compute::MinMaxKernelAdapter<V>
+pub fn vortex_array::arrays::Extension::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::MinMaxKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Extension
 
-pub struct vortex_array::compute::MinMaxKernelRef(_)
+pub fn vortex_array::arrays::Extension::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl inventory::Collect for vortex_array::compute::MinMaxKernelRef
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Extension
 
-pub struct vortex_array::compute::MinMaxResult
+pub fn vortex_array::arrays::Extension::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::compute::MinMaxResult::max: vortex_array::scalar::Scalar
+pub struct vortex_array::arrays::Filter
 
-pub vortex_array::compute::MinMaxResult::min: vortex_array::scalar::Scalar
+impl vortex_array::arrays::Filter
 
-impl vortex_array::compute::MinMaxResult
+pub const vortex_array::arrays::Filter::ID: vortex_array::ArrayId
 
-pub fn vortex_array::compute::MinMaxResult::from_scalar(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
+impl core::clone::Clone for vortex_array::arrays::Filter
 
-impl core::clone::Clone for vortex_array::compute::MinMaxResult
+pub fn vortex_array::arrays::Filter::clone(&self) -> vortex_array::arrays::Filter
 
-pub fn vortex_array::compute::MinMaxResult::clone(&self) -> vortex_array::compute::MinMaxResult
+impl core::fmt::Debug for vortex_array::arrays::Filter
 
-impl core::cmp::Eq for vortex_array::compute::MinMaxResult
+pub fn vortex_array::arrays::Filter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialEq for vortex_array::compute::MinMaxResult
+impl vortex_array::OperationsVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub fn vortex_array::compute::MinMaxResult::eq(&self, other: &vortex_array::compute::MinMaxResult) -> bool
+pub fn vortex_array::arrays::Filter::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::fmt::Debug for vortex_array::compute::MinMaxResult
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-pub fn vortex_array::compute::MinMaxResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-impl core::marker::StructuralPartialEq for vortex_array::compute::MinMaxResult
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-pub struct vortex_array::compute::NaNCountKernelAdapter<V: vortex_array::vtable::VTable>(pub V)
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::NaNCountKernel> vortex_array::compute::NaNCountKernelAdapter<V>
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub const fn vortex_array::compute::NaNCountKernelAdapter<V>::lift(&'static self) -> vortex_array::compute::NaNCountKernelRef
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<V: core::fmt::Debug + vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::compute::NaNCountKernelAdapter<V>
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::compute::NaNCountKernelAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::NaNCountKernel> vortex_array::compute::Kernel for vortex_array::compute::NaNCountKernelAdapter<V>
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::compute::NaNCountKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub struct vortex_array::compute::NaNCountKernelRef(_)
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl inventory::Collect for vortex_array::compute::NaNCountKernelRef
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::compute::SumArgs<'a>
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-pub vortex_array::compute::SumArgs::accumulator: &'a vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::compute::SumArgs::array: &'a dyn vortex_array::Array
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<'a> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::SumArgs<'a>
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::compute::SumArgs<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::SumArgs<'a>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub struct vortex_array::compute::SumKernelAdapter<V: vortex_array::vtable::VTable>(pub V)
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::SumKernel> vortex_array::compute::SumKernelAdapter<V>
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub const fn vortex_array::compute::SumKernelAdapter<V>::lift(&'static self) -> vortex_array::compute::SumKernelRef
+impl vortex_array::ValidityVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-impl<V: core::fmt::Debug + vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::compute::SumKernelAdapter<V>
+pub fn vortex_array::arrays::Filter::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::compute::SumKernelAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::arrays::FixedSizeList
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::SumKernel> vortex_array::compute::Kernel for vortex_array::compute::SumKernelAdapter<V>
+impl vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::compute::SumKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub const vortex_array::arrays::FixedSizeList::ID: vortex_array::ArrayId
 
-pub struct vortex_array::compute::SumKernelRef(_)
+impl core::clone::Clone for vortex_array::arrays::FixedSizeList
 
-impl inventory::Collect for vortex_array::compute::SumKernelRef
+pub fn vortex_array::arrays::FixedSizeList::clone(&self) -> vortex_array::arrays::FixedSizeList
 
-pub struct vortex_array::compute::UnaryArgs<'a, O: vortex_array::compute::Options>
+impl core::fmt::Debug for vortex_array::arrays::FixedSizeList
 
-pub vortex_array::compute::UnaryArgs::array: &'a dyn vortex_array::Array
+pub fn vortex_array::arrays::FixedSizeList::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::compute::UnaryArgs::options: &'a O
+impl vortex_array::OperationsVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-impl<'a, O: vortex_array::compute::Options> core::convert::TryFrom<&vortex_array::compute::InvocationArgs<'a>> for vortex_array::compute::UnaryArgs<'a, O>
+pub fn vortex_array::arrays::FixedSizeList::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::compute::UnaryArgs<'a, O>::Error = vortex_error::VortexError
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::compute::UnaryArgs<'a, O>::try_from(value: &vortex_array::compute::InvocationArgs<'a>) -> core::result::Result<Self, Self::Error>
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub trait vortex_array::compute::ComputeFnVTable: 'static + core::marker::Send + core::marker::Sync
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::compute::ComputeFnVTable::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>, kernels: &[arcref::ArcRef<dyn vortex_array::compute::Kernel>]) -> vortex_error::VortexResult<vortex_array::compute::Output>
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::compute::ComputeFnVTable::is_elementwise(&self) -> bool
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::compute::ComputeFnVTable::return_dtype(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::compute::ComputeFnVTable::return_len(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::compute::ComputeFnVTable for vortex_array::compute::MinMax
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::compute::MinMax::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>, kernels: &[arcref::ArcRef<dyn vortex_array::compute::Kernel>]) -> vortex_error::VortexResult<vortex_array::compute::Output>
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::compute::MinMax::is_elementwise(&self) -> bool
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::compute::MinMax::return_dtype(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::compute::MinMax::return_len(&self, _args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::compute::IsConstantKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::compute::IsConstantKernel::is_constant(&self, array: &Self::Array, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolVTable::is_constant(&self, array: &vortex_array::arrays::BoolArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedVTable::is_constant(&self, array: &vortex_array::arrays::ChunkedArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::DecimalVTable::is_constant(&self, array: &vortex_array::arrays::DecimalArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::DictVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::DictVTable::is_constant(&self, array: &vortex_array::arrays::DictArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ExtensionVTable
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ExtensionVTable::is_constant(&self, array: &vortex_array::arrays::ExtensionArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_constant(&self, array: &vortex_array::arrays::FixedSizeListArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ListVTable
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ListVTable::is_constant(&self, array: &vortex_array::arrays::ListArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::ListViewVTable
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ListViewVTable::is_constant(&self, array: &vortex_array::arrays::ListViewArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::FixedSizeList::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::PrimitiveVTable
+pub struct vortex_array::arrays::List
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_constant(&self, array: &vortex_array::arrays::PrimitiveArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::List
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::StructVTable
+pub const vortex_array::arrays::List::ID: vortex_array::ArrayId
 
-pub fn vortex_array::arrays::StructVTable::is_constant(&self, array: &vortex_array::arrays::StructArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::clone::Clone for vortex_array::arrays::List
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::List::clone(&self) -> vortex_array::arrays::List
 
-pub fn vortex_array::arrays::VarBinVTable::is_constant(&self, array: &vortex_array::arrays::VarBinArray, opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::fmt::Debug for vortex_array::arrays::List
 
-impl vortex_array::compute::IsConstantKernel for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::List::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_constant(&self, array: &vortex_array::arrays::VarBinViewArray, _opts: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub trait vortex_array::compute::IsSortedIteratorExt where <Self as core::iter::traits::iterator::Iterator>::Item: core::cmp::PartialOrd: core::iter::traits::iterator::Iterator
+pub fn vortex_array::arrays::List::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::compute::IsSortedIteratorExt::is_strict_sorted(self) -> bool where Self: core::marker::Sized, Self::Item: core::cmp::PartialOrd
+impl vortex_array::VTable for vortex_array::arrays::List
 
-impl<T> vortex_array::compute::IsSortedIteratorExt for T where T: core::iter::traits::iterator::Iterator + ?core::marker::Sized, <T as core::iter::traits::iterator::Iterator>::Item: core::cmp::PartialOrd
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-pub trait vortex_array::compute::IsSortedKernel: vortex_array::vtable::VTable
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-pub fn vortex_array::compute::IsSortedKernel::is_sorted(&self, array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub fn vortex_array::compute::IsSortedKernel::is_strict_sorted(&self, array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::BoolVTable::is_sorted(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::BoolVTable::is_strict_sorted(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ChunkedVTable::is_sorted(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ChunkedVTable::is_strict_sorted(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalVTable::is_sorted(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::DecimalVTable::is_strict_sorted(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::DictVTable::is_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DictVTable::is_strict_sorted(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ExtensionVTable::is_sorted(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ExtensionVTable::is_strict_sorted(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::FixedSizeListVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_sorted(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::List
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::List::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::is_sorted(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ListVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::ListViewVTable
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::ListViewVTable::is_sorted(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewVTable::is_strict_sorted(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::List
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::List::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_sorted(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::PrimitiveVTable::is_strict_sorted(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::List::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::VarBinVTable
+pub struct vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::VarBinVTable::is_sorted(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::VarBinVTable::is_strict_sorted(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub const vortex_array::arrays::ListView::ID: vortex_array::ArrayId
 
-impl vortex_array::compute::IsSortedKernel for vortex_array::arrays::VarBinViewVTable
+impl core::clone::Clone for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_sorted(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::ListView::clone(&self) -> vortex_array::arrays::ListView
 
-pub fn vortex_array::arrays::VarBinViewVTable::is_strict_sorted(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl core::fmt::Debug for vortex_array::arrays::ListView
 
-pub trait vortex_array::compute::Kernel: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug
+pub fn vortex_array::arrays::ListView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::compute::Kernel::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsConstantKernel> vortex_array::compute::Kernel for vortex_array::compute::IsConstantKernelAdapter<V>
+pub fn vortex_array::arrays::ListView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::compute::IsConstantKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::IsSortedKernel> vortex_array::compute::Kernel for vortex_array::compute::IsSortedKernelAdapter<V>
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::compute::IsSortedKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::MinMaxKernel> vortex_array::compute::Kernel for vortex_array::compute::MinMaxKernelAdapter<V>
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-pub fn vortex_array::compute::MinMaxKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::NaNCountKernel> vortex_array::compute::Kernel for vortex_array::compute::NaNCountKernelAdapter<V>
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::compute::NaNCountKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: vortex_array::vtable::VTable + vortex_array::compute::SumKernel> vortex_array::compute::Kernel for vortex_array::compute::SumKernelAdapter<V>
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::compute::SumKernelAdapter<V>::invoke(&self, args: &vortex_array::compute::InvocationArgs<'_>) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::Output>>
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::compute::MinMaxKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::compute::MinMaxKernel::min_max(&self, array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::BoolVTable::min_max(&self, array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ChunkedVTable::min_max(&self, array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::min_max(&self, array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DecimalVTable::min_max(&self, array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::min_max(&self, array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::ValidityVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::ListView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ExtensionVTable::min_max(&self, array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::ListView
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::ListView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::min_max(&self, _array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::ListView
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::ListView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::min_max(&self, _array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListView
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::ListView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListViewVTable::min_max(&self, _array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListView
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::ListView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullVTable::min_max(&self, _array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub struct vortex_array::arrays::Masked
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::PrimitiveVTable
+impl vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::PrimitiveVTable::min_max(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub const vortex_array::arrays::Masked::ID: vortex_array::ArrayId
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::StructVTable
+impl core::clone::Clone for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::StructVTable::min_max(&self, _array: &vortex_array::arrays::StructArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::Masked::clone(&self) -> vortex_array::arrays::Masked
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::VarBinVTable
+impl core::fmt::Debug for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::VarBinVTable::min_max(&self, array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::Masked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::compute::MinMaxKernel for vortex_array::arrays::VarBinViewVTable
+impl vortex_array::OperationsVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::VarBinViewVTable::min_max(&self, array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::Masked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub trait vortex_array::compute::NaNCountKernel: vortex_array::vtable::VTable
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub fn vortex_array::compute::NaNCountKernel::nan_count(&self, array: &Self::Array) -> vortex_error::VortexResult<usize>
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-impl vortex_array::compute::NaNCountKernel for vortex_array::arrays::PrimitiveVTable
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::PrimitiveVTable::nan_count(&self, array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<usize>
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-pub trait vortex_array::compute::Options: 'static
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::compute::Options::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::compute::Options for ()
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn ()::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::compute::Options for vortex_array::arrow::compute::ToArrowOptions
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrow::compute::ToArrowOptions::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::compute::Options for vortex_array::compute::IsConstantOpts
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::compute::IsConstantOpts::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::Options for vortex_array::scalar::NumericOperator
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar::NumericOperator::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::Options for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::compute::SumKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::SumKernel::sum(&self, array: &Self::Array, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::BoolVTable::sum(&self, array: &vortex_array::arrays::BoolArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ChunkedVTable
+impl vortex_array::ValidityVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::ChunkedVTable::sum(&self, array: &vortex_array::arrays::ChunkedArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ConstantVTable
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::ConstantVTable::sum(&self, array: &vortex_array::arrays::ConstantArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::DecimalVTable
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::DecimalVTable::sum(&self, array: &vortex_array::arrays::DecimalArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::ExtensionVTable
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::ExtensionVTable::sum(&self, array: &vortex_array::arrays::ExtensionArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::compute::SumKernel for vortex_array::arrays::PrimitiveVTable
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::PrimitiveVTable::sum(&self, array: &vortex_array::arrays::PrimitiveArray, accumulator: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::add(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub struct vortex_array::arrays::Null
 
-pub fn vortex_array::compute::add_scalar(lhs: &dyn vortex_array::Array, rhs: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::and_kleene(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub const vortex_array::arrays::null::Null::ID: vortex_array::ArrayId
 
-pub fn vortex_array::compute::arrow_filter_fn(array: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::cast(array: &dyn vortex_array::Array, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub const vortex_array::arrays::null::Null::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
-pub fn vortex_array::compute::compare_lengths_to_empty<P, I>(lengths: I, op: vortex_array::scalar_fn::fns::operators::CompareOperator) -> vortex_buffer::bit::buf::BitBuffer where P: vortex_array::dtype::IntegerPType, I: core::iter::traits::iterator::Iterator<Item = P>
+impl core::clone::Clone for vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::div(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::clone(&self) -> vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::div_scalar(lhs: &dyn vortex_array::Array, rhs: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::fmt::Debug for vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::fill_null(array: &dyn vortex_array::Array, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::compute::filter(array: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::OperationsVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::invert(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::scalar_at(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::compute::is_constant(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<bool>>
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::is_constant_opts(array: &dyn vortex_array::Array, options: &vortex_array::compute::IsConstantOpts) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::compute::is_sorted(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::is_sorted_opts(array: &dyn vortex_array::Array, strict: bool) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::compute::is_strict_sorted(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<bool>>
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::compute::list_contains(array: &dyn vortex_array::Array, value: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::compute::mask(array: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::compute::min_max(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::compute::MinMaxResult>>
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::compute::mul(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::compute::mul_scalar(lhs: &dyn vortex_array::Array, rhs: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::compute::nan_count(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::compute::numeric(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array, op: vortex_array::scalar::NumericOperator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::or_kleene(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::compute::sub(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::sub_scalar(lhs: &dyn vortex_array::Array, rhs: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::sum(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::sum_impl(array: &dyn vortex_array::Array, accumulator: &vortex_array::scalar::Scalar, kernels: &[arcref::ArcRef<dyn vortex_array::compute::Kernel>]) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::compute::warm_up_vtables()
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::compute::zip(if_true: &dyn vortex_array::Array, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub mod vortex_array::display
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub enum vortex_array::display::DisplayOptions
+impl vortex_array::ValidityVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub vortex_array::display::DisplayOptions::CommaSeparatedScalars
+pub fn vortex_array::arrays::null::Null::validity(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::display::DisplayOptions::CommaSeparatedScalars::omit_comma_after_space: bool
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::null::Null
 
-pub vortex_array::display::DisplayOptions::MetadataOnly
+pub fn vortex_array::arrays::null::Null::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::display::DisplayOptions::TreeDisplay
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::null::Null
 
-pub vortex_array::display::DisplayOptions::TreeDisplay::buffers: bool
+pub fn vortex_array::arrays::null::Null::filter(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::display::DisplayOptions::TreeDisplay::metadata: bool
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::null::Null
 
-pub vortex_array::display::DisplayOptions::TreeDisplay::stats: bool
+pub fn vortex_array::arrays::null::Null::slice(_array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::default::Default for vortex_array::display::DisplayOptions
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::display::DisplayOptions::default() -> Self
+pub fn vortex_array::arrays::null::Null::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::display::DisplayArrayAs<'a>(pub &'a dyn vortex_array::Array, pub vortex_array::display::DisplayOptions)
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::null::Null
 
-impl core::fmt::Display for vortex_array::display::DisplayArrayAs<'_>
+pub fn vortex_array::arrays::null::Null::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::display::DisplayArrayAs<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::arrays::Patched
 
-pub mod vortex_array::dtype
+impl vortex_array::arrays::patched::Patched
 
-pub use vortex_array::dtype::half
+pub fn vortex_array::arrays::patched::Patched::from_array_and_patches(inner: vortex_array::ArrayRef, patches: &vortex_array::patches::Patches, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::Array<vortex_array::arrays::patched::Patched>>
 
-pub mod vortex_array::dtype::arrow
+impl core::clone::Clone for vortex_array::arrays::patched::Patched
 
-pub trait vortex_array::dtype::arrow::FromArrowType<T>: core::marker::Sized
+pub fn vortex_array::arrays::patched::Patched::clone(&self) -> vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::dtype::arrow::FromArrowType::from_arrow(value: T) -> Self
+impl core::fmt::Debug for vortex_array::arrays::patched::Patched
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::field::Field> for vortex_array::dtype::DType
+pub fn vortex_array::arrays::patched::Patched::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::DType::from_arrow(field: &arrow_schema::field::Field) -> Self
+impl vortex_array::OperationsVTable<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::fields::Fields> for vortex_array::dtype::StructFields
+pub fn vortex_array::arrays::patched::Patched::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::dtype::StructFields::from_arrow(value: &arrow_schema::fields::Fields) -> Self
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::schema::Schema> for vortex_array::dtype::DType
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::dtype::DType::from_arrow(value: &arrow_schema::schema::Schema) -> Self
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-impl vortex_array::dtype::arrow::FromArrowType<(&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)> for vortex_array::dtype::DType
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::dtype::DType::from_arrow((data_type, nullability): (&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)) -> Self
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::arrow::FromArrowType<alloc::sync::Arc<arrow_schema::schema::Schema>> for vortex_array::dtype::DType
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::DType::from_arrow(value: arrow_schema::schema::SchemaRef) -> Self
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub trait vortex_array::dtype::arrow::TryFromArrowType<T>: core::marker::Sized
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::arrow::TryFromArrowType::try_from_arrow(value: T) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::DecimalDType
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::DecimalDType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::PType
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::PType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-pub mod vortex_array::dtype::extension
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::dtype::extension::ExtDType<V: vortex_array::dtype::extension::ExtVTable>(_)
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: vortex_array::dtype::extension::ExtVTable + core::default::Default> vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::try_new(metadata: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::erased(self) -> vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::metadata(&self) -> &<V as vortex_array::dtype::extension::ExtVTable>::Metadata
+impl vortex_array::ValidityChild<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::storage_dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::patched::Patched::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::try_with_vtable(vtable: V, metadata: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::vtable(&self) -> &V
+pub fn vortex_array::arrays::patched::Patched::take(array: vortex_array::ArrayView<'_, Self>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::clone::Clone + vortex_array::dtype::extension::ExtVTable> core::clone::Clone for vortex_array::dtype::extension::ExtDType<V>
+impl vortex_array::arrays::filter::FilterReduce for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::clone(&self) -> vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::patched::Patched::filter(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::cmp::Eq + vortex_array::dtype::extension::ExtVTable> core::cmp::Eq for vortex_array::dtype::extension::ExtDType<V>
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::patched::Patched
 
-impl<V: core::cmp::PartialEq + vortex_array::dtype::extension::ExtVTable> core::cmp::PartialEq for vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::patched::Patched::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::eq(&self, other: &vortex_array::dtype::extension::ExtDType<V>) -> bool
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::patched::Patched
 
-impl<V: core::fmt::Debug + vortex_array::dtype::extension::ExtVTable> core::fmt::Debug for vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::patched::Patched::compare(lhs: vortex_array::ArrayView<'_, Self>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::arrays::Primitive
 
-impl<V: core::hash::Hash + vortex_array::dtype::extension::ExtVTable> core::hash::Hash for vortex_array::dtype::extension::ExtDType<V>
+impl vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDType<V>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub const vortex_array::arrays::Primitive::ID: vortex_array::ArrayId
 
-impl<V: vortex_array::dtype::extension::ExtVTable> core::marker::StructuralPartialEq for vortex_array::dtype::extension::ExtDType<V>
+impl core::clone::Clone for vortex_array::arrays::Primitive
 
-pub struct vortex_array::dtype::extension::ExtDTypeRef(_)
+pub fn vortex_array::arrays::Primitive::clone(&self) -> vortex_array::arrays::Primitive
 
-impl vortex_array::dtype::extension::ExtDTypeRef
+impl core::fmt::Debug for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::display_metadata(&self) -> impl core::fmt::Display + '_
+pub fn vortex_array::arrays::Primitive::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::eq_ignore_nullability(&self, other: &Self) -> bool
+impl vortex_array::OperationsVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::Primitive::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::is_nullable(&self) -> bool
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::nullability(&self) -> vortex_array::dtype::Nullability
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::serialize_metadata(&self) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::storage_dtype(&self) -> &vortex_array::dtype::DType
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::with_nullability(&self, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> vortex_array::dtype::extension::ExtDType<V>
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::is<M: vortex_array::dtype::extension::Matcher>(&self) -> bool
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::metadata<M: vortex_array::dtype::extension::Matcher>(&self) -> <M as vortex_array::dtype::extension::Matcher>::Match
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::metadata_opt<M: vortex_array::dtype::extension::Matcher>(&self) -> core::option::Option<<M as vortex_array::dtype::extension::Matcher>::Match>
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::try_downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> core::result::Result<vortex_array::dtype::extension::ExtDType<V>, vortex_array::dtype::extension::ExtDTypeRef>
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::clone::Clone for vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::clone(&self) -> vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-impl core::cmp::Eq for vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::cmp::PartialEq for vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::eq(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::fmt::Display for vortex_array::dtype::extension::ExtDTypeRef
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl core::hash::Hash for vortex_array::dtype::extension::ExtDTypeRef
+impl vortex_array::ValidityVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypeRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::Primitive::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub trait vortex_array::dtype::extension::ExtDTypePlugin: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtDTypePlugin::deserialize(&self, data: &[u8], storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDTypeRef>
+pub fn vortex_array::arrays::Primitive::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtDTypePlugin::id(&self) -> vortex_array::dtype::extension::ExtId
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Primitive
 
-impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::ExtDTypePlugin for V
+pub fn vortex_array::arrays::Primitive::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn V::deserialize(&self, data: &[u8], storage_dtype: vortex_array::dtype::DType) -> core::result::Result<vortex_array::dtype::extension::ExtDTypeRef, vortex_error::VortexError>
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Primitive> for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
 
-pub fn V::id(&self) -> arcref::ArcRef<str>
+pub type vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::Masked
 
-pub trait vortex_array::dtype::extension::ExtVTable: 'static + core::marker::Sized + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::cmp::Eq + core::hash::Hash
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::dtype::extension::ExtVTable::Metadata: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + core::cmp::Eq + core::hash::Hash
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Primitive
 
-pub type vortex_array::dtype::extension::ExtVTable::NativeValue<'a>: core::fmt::Display
+pub fn vortex_array::arrays::Primitive::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtVTable::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtVTable::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::Primitive::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, dtype: &vortex_array::dtype::DType, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtVTable::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtVTable::unpack_native<'a>(&self, metadata: &'a Self::Metadata, storage_dtype: &'a vortex_array::dtype::DType, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::arrays::Primitive::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::extension::ExtVTable::validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Primitive
 
-pub fn vortex_array::dtype::extension::ExtVTable::validate_scalar_value(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Primitive::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Date
+pub struct vortex_array::arrays::ScalarFnVTable
 
-pub type vortex_array::extension::datetime::Date::Metadata = vortex_array::extension::datetime::TimeUnit
+impl core::clone::Clone for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub type vortex_array::extension::datetime::Date::NativeValue<'a> = vortex_array::extension::datetime::DateValue
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::clone(&self) -> vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::extension::datetime::Date::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+impl core::fmt::Debug for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::extension::datetime::Date::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::extension::datetime::Date::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::extension::datetime::Date::unpack_native(&self, metadata: &Self::Metadata, _storage_dtype: &vortex_array::dtype::DType, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::extension::datetime::Date::validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Time
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub type vortex_array::extension::datetime::Time::Metadata = vortex_array::extension::datetime::TimeUnit
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub type vortex_array::extension::datetime::Time::NativeValue<'a> = vortex_array::extension::datetime::TimeValue
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::extension::datetime::Time::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::extension::datetime::Time::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::extension::datetime::Time::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::extension::datetime::Time::unpack_native(&self, metadata: &Self::Metadata, _storage_dtype: &vortex_array::dtype::DType, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::extension::datetime::Time::validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::extension::datetime::Timestamp::Metadata = vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::extension::datetime::Timestamp::NativeValue<'a> = vortex_array::extension::datetime::TimestampValue<'a>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::extension::datetime::Timestamp::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::extension::datetime::Timestamp::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::extension::datetime::Timestamp::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::extension::datetime::Timestamp::unpack_native<'a>(&self, metadata: &'a Self::Metadata, _storage_dtype: &'a vortex_array::dtype::DType, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::extension::datetime::Timestamp::validate_dtype(&self, _metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::dtype::extension::Matcher
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::dtype::extension::Matcher::Match<'a>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::extension::Matcher::matches(item: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::extension::Matcher::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+impl vortex_array::ValidityVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::dtype::extension::Matcher for vortex_array::extension::datetime::AnyTemporal
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub type vortex_array::extension::datetime::AnyTemporal::Match<'a> = vortex_array::extension::datetime::TemporalMetadata<'a>
+pub struct vortex_array::arrays::Shared
 
-pub fn vortex_array::extension::datetime::AnyTemporal::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+impl vortex_array::arrays::Shared
 
-impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::Matcher for V
+pub const vortex_array::arrays::Shared::ID: vortex_array::ArrayId
 
-pub type V::Match<'a> = &'a <V as vortex_array::dtype::extension::ExtVTable>::Metadata
+impl core::clone::Clone for vortex_array::arrays::Shared
 
-pub fn V::matches(item: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+pub fn vortex_array::arrays::Shared::clone(&self) -> vortex_array::arrays::Shared
 
-pub fn V::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<<V as vortex_array::dtype::extension::Matcher>::Match>
+impl core::fmt::Debug for vortex_array::arrays::Shared
 
-pub type vortex_array::dtype::extension::ExtId = arcref::ArcRef<str>
+pub fn vortex_array::arrays::Shared::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::dtype::flatbuffers
+impl vortex_array::OperationsVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub use vortex_array::dtype::flatbuffers::<<vortex_flatbuffers::dtype::*>>
+pub fn vortex_array::arrays::Shared::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub mod vortex_array::dtype::proto
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub use vortex_array::dtype::proto::dtype
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-pub mod vortex_array::dtype::serde
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub mod vortex_array::dtype::session
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-pub struct vortex_array::dtype::session::DTypeSession
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::session::DTypeSession
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::session::DTypeSession::register<V: vortex_array::dtype::extension::ExtVTable>(&self, vtable: V)
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::dtype::session::DTypeSession::registry(&self) -> &vortex_array::dtype::session::ExtDTypeRegistry
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::default::Default for vortex_array::dtype::session::DTypeSession
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::session::DTypeSession::default() -> Self
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::fmt::Debug for vortex_array::dtype::session::DTypeSession
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::dtype::session::DTypeSession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::dtype::session::DTypeSessionExt: vortex_session::SessionExt
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::dtype::session::DTypeSessionExt::dtypes(&self) -> vortex_session::Ref<'_, vortex_array::dtype::session::DTypeSession>
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<S: vortex_session::SessionExt> vortex_array::dtype::session::DTypeSessionExt for S
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn S::dtypes(&self) -> vortex_session::Ref<'_, vortex_array::dtype::session::DTypeSession>
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::dtype::session::ExtDTypeRegistry = vortex_session::registry::Registry<alloc::sync::Arc<dyn vortex_array::dtype::extension::ExtDTypePlugin>>
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub enum vortex_array::dtype::DType
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::dtype::DType::Binary(vortex_array::dtype::Nullability)
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::dtype::DType::Bool(vortex_array::dtype::Nullability)
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_array::dtype::DType::Decimal(vortex_array::dtype::DecimalDType, vortex_array::dtype::Nullability)
+impl vortex_array::ValidityVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub vortex_array::dtype::DType::Extension(vortex_array::dtype::extension::ExtDTypeRef)
+pub fn vortex_array::arrays::Shared::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::dtype::DType::FixedSizeList(alloc::sync::Arc<vortex_array::dtype::DType>, u32, vortex_array::dtype::Nullability)
+pub struct vortex_array::arrays::Slice
 
-pub vortex_array::dtype::DType::List(alloc::sync::Arc<vortex_array::dtype::DType>, vortex_array::dtype::Nullability)
+impl vortex_array::arrays::slice::Slice
 
-pub vortex_array::dtype::DType::Null
+pub const vortex_array::arrays::slice::Slice::ID: vortex_array::ArrayId
 
-pub vortex_array::dtype::DType::Primitive(vortex_array::dtype::PType, vortex_array::dtype::Nullability)
+impl core::clone::Clone for vortex_array::arrays::slice::Slice
 
-pub vortex_array::dtype::DType::Struct(vortex_array::dtype::StructFields, vortex_array::dtype::Nullability)
+pub fn vortex_array::arrays::slice::Slice::clone(&self) -> vortex_array::arrays::slice::Slice
 
-pub vortex_array::dtype::DType::Utf8(vortex_array::dtype::Nullability)
+impl core::fmt::Debug for vortex_array::arrays::slice::Slice
 
-impl vortex_array::dtype::DType
+pub fn vortex_array::arrays::slice::Slice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub const vortex_array::dtype::DType::BYTES: Self
+impl vortex_array::OperationsVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::as_any_size_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+pub fn vortex_array::arrays::slice::Slice::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::dtype::DType::as_decimal_opt(&self) -> core::option::Option<&vortex_array::dtype::DecimalDType>
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::as_extension(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::dtype::DType::as_extension_opt(&self) -> core::option::Option<&vortex_array::dtype::extension::ExtDTypeRef>
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::as_fixed_size_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::as_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::DType::as_nonnullable(&self) -> Self
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::DType::as_nullable(&self) -> Self
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::dtype::DType::as_ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DType::as_struct_fields(&self) -> &vortex_array::dtype::StructFields
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::DType::as_struct_fields_opt(&self) -> core::option::Option<&vortex_array::dtype::StructFields>
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::DType::element_size(&self) -> core::option::Option<usize>
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::dtype::DType::eq_ignore_nullability(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::eq_with_nullability_subset(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::dtype::DType::eq_with_nullability_superset(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::dtype::DType::into_any_size_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::dtype::DType::into_decimal_opt(self) -> core::option::Option<vortex_array::dtype::DecimalDType>
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::into_fixed_size_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::into_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::dtype::DType::into_struct_fields(self) -> vortex_array::dtype::StructFields
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::dtype::DType::into_struct_fields_opt(self) -> core::option::Option<vortex_array::dtype::StructFields>
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::DType::is_binary(&self) -> bool
+impl vortex_array::ValidityVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::is_boolean(&self) -> bool
+pub fn vortex_array::arrays::slice::Slice::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::dtype::DType::is_decimal(&self) -> bool
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::dtype::DType::is_extension(&self) -> bool
+pub fn vortex_array::arrays::slice::Slice::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::is_fixed_size_list(&self) -> bool
+pub struct vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_float(&self) -> bool
+impl vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_int(&self) -> bool
+pub const vortex_array::arrays::Struct::ID: vortex_array::ArrayId
 
-pub fn vortex_array::dtype::DType::is_list(&self) -> bool
+impl core::clone::Clone for vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_nested(&self) -> bool
+pub fn vortex_array::arrays::Struct::clone(&self) -> vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_nullable(&self) -> bool
+impl core::fmt::Debug for vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_primitive(&self) -> bool
+pub fn vortex_array::arrays::Struct::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::DType::is_signed_int(&self) -> bool
+impl vortex_array::OperationsVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_struct(&self) -> bool
+pub fn vortex_array::arrays::Struct::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::dtype::DType::is_unsigned_int(&self) -> bool
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::is_utf8(&self) -> bool
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::dtype::DType::list(dtype: impl core::convert::Into<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::nullability(&self) -> vortex_array::dtype::Nullability
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DType::struct_<I: core::iter::traits::collect::IntoIterator<Item = (impl core::convert::Into<vortex_array::dtype::FieldName>, impl core::convert::Into<vortex_array::dtype::FieldDType>)>>(iter: I, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::DType::union_nullability(&self, other: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::DType::with_nullability(&self, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DType::from_flatbuffer(buffer: vortex_flatbuffers::FlatBuffer, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::DType::from_proto(value: &vortex_proto::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::to_arrow_dtype(&self) -> vortex_error::VortexResult<arrow_schema::datatype::DataType>
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::dtype::DType::to_arrow_schema(&self) -> vortex_error::VortexResult<arrow_schema::schema::Schema>
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::clone::Clone for vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::dtype::DType::clone(&self) -> vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::Eq for vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::PartialEq for vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::dtype::DType::eq(&self, other: &vortex_array::dtype::DType) -> bool
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::convert::From<vortex_array::dtype::DType> for vortex_array::dtype::FieldDType
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::DType) -> Self
+impl vortex_array::ValidityVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-impl core::convert::From<vortex_array::dtype::PType> for &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn &vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+impl vortex_array::arrays::dict::TakeReduce for vortex_array::arrays::Struct
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::DType
+pub fn vortex_array::arrays::Struct::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::Struct
 
-impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+pub fn vortex_array::arrays::Struct::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Struct
 
-pub fn vortex_array::dtype::DecimalDType::try_from(value: &vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Struct::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::PType
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Struct
 
-pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Struct::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::PType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Struct
 
-impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_proto::dtype::DType
+pub fn vortex_array::arrays::Struct::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_proto::dtype::DType::Error = vortex_error::VortexError
+pub struct vortex_array::arrays::VarBin
 
-pub fn vortex_proto::dtype::DType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrays::VarBin
 
-impl core::convert::TryFrom<vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+pub const vortex_array::arrays::VarBin::ID: vortex_array::ArrayId
 
-pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+impl vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DecimalDType::try_from(value: vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::VarBin::_slice(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::fmt::Debug for vortex_array::dtype::DType
+impl core::clone::Clone for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBin::clone(&self) -> vortex_array::arrays::VarBin
 
-impl core::fmt::Display for vortex_array::dtype::DType
+impl core::fmt::Debug for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::hash::Hash for vortex_array::dtype::DType
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::VarBin::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::DType
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::field::Field> for vortex_array::dtype::DType
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::dtype::DType::from_arrow(field: &arrow_schema::field::Field) -> Self
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::schema::Schema> for vortex_array::dtype::DType
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DType::from_arrow(value: &arrow_schema::schema::Schema) -> Self
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::arrow::FromArrowType<(&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)> for vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::DType::from_arrow((data_type, nullability): (&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)) -> Self
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::dtype::arrow::FromArrowType<alloc::sync::Arc<arrow_schema::schema::Schema>> for vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DType::from_arrow(value: arrow_schema::schema::SchemaRef) -> Self
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_flatbuffers::FlatBufferRoot for vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::dtype::DType::Target<'a> = vortex_flatbuffers::dtype::DType<'a>
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DType::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-impl<'a> core::convert::From<&'a vortex_array::dtype::DType> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a vortex_array::dtype::DType) -> Self
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-#[repr(u8)] pub enum vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::dtype::DecimalType::I128 = 4
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::dtype::DecimalType::I16 = 1
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::dtype::DecimalType::I256 = 5
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::dtype::DecimalType::I32 = 2
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_array::dtype::DecimalType::I64 = 3
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub vortex_array::dtype::DecimalType::I8 = 0
+pub fn vortex_array::arrays::VarBin::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::dtype::DecimalType
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DecimalType::byte_width(&self) -> usize
+pub fn vortex_array::arrays::VarBin::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DecimalType::is_compatible_decimal_value_type(self, dtype: vortex_array::dtype::DecimalDType) -> bool
+impl vortex_array::arrays::filter::FilterKernel for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DecimalType::smallest_decimal_value_type(decimal_dtype: &vortex_array::dtype::DecimalDType) -> vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBin::filter(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::dtype::DecimalType
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DecimalType::from_i32(value: i32) -> core::option::Option<vortex_array::dtype::DecimalType>
+pub fn vortex_array::arrays::VarBin::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DecimalType::is_valid(value: i32) -> bool
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::VarBin
 
-impl core::clone::Clone for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBin::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::DecimalType::clone(&self) -> vortex_array::dtype::DecimalType
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBin
 
-impl core::cmp::Eq for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBin::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::Ord for vortex_array::dtype::DecimalType
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::dtype::DecimalType::cmp(&self, other: &vortex_array::dtype::DecimalType) -> core::cmp::Ordering
+pub fn vortex_array::arrays::VarBin::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::PartialEq for vortex_array::dtype::DecimalType
+pub struct vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::DecimalType::eq(&self, other: &vortex_array::dtype::DecimalType) -> bool
+impl vortex_array::arrays::VarBinView
 
-impl core::cmp::PartialOrd for vortex_array::dtype::DecimalType
+pub const vortex_array::arrays::VarBinView::ID: vortex_array::ArrayId
 
-pub fn vortex_array::dtype::DecimalType::partial_cmp(&self, other: &vortex_array::dtype::DecimalType) -> core::option::Option<core::cmp::Ordering>
+impl core::clone::Clone for vortex_array::arrays::VarBinView
 
-impl core::convert::From<vortex_array::dtype::DecimalType> for i32
+pub fn vortex_array::arrays::VarBinView::clone(&self) -> vortex_array::arrays::VarBinView
 
-pub fn i32::from(value: vortex_array::dtype::DecimalType) -> i32
+impl core::fmt::Debug for vortex_array::arrays::VarBinView
 
-impl core::convert::TryFrom<i32> for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::dtype::DecimalType::Error = prost::error::UnknownEnumValue
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::DecimalType::try_from(value: i32) -> core::result::Result<vortex_array::dtype::DecimalType, prost::error::UnknownEnumValue>
+pub fn vortex_array::arrays::VarBinView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::convert::TryFrom<vortex_array::dtype::PType> for vortex_array::dtype::DecimalType
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-pub type vortex_array::dtype::DecimalType::Error = vortex_error::VortexError
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::dtype::DecimalType::try_from(value: vortex_array::dtype::PType) -> core::result::Result<Self, Self::Error>
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-impl core::default::Default for vortex_array::dtype::DecimalType
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::DecimalType::default() -> vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::fmt::Debug for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::DecimalType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::fmt::Display for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::hash::Hash for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::DecimalType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::marker::Copy for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::DecimalType
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-pub enum vortex_array::dtype::Field
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::dtype::Field::ElementType
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::dtype::Field::Name(vortex_array::dtype::FieldName)
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::dtype::Field
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::dtype::Field::as_name(&self) -> core::option::Option<&str>
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::dtype::Field::is_named(&self) -> bool
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::dtype::Field
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::Field::clone(&self) -> vortex_array::dtype::Field
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-impl core::cmp::Eq for vortex_array::dtype::Field
+pub fn vortex_array::arrays::VarBinView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::cmp::PartialEq for vortex_array::dtype::Field
+impl vortex_array::arrays::dict::TakeExecute for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::Field::eq(&self, other: &vortex_array::dtype::Field) -> bool
+pub fn vortex_array::arrays::VarBinView::take(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<&str> for vortex_array::dtype::Field
+impl vortex_array::arrays::slice::SliceReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::Field::from(value: &str) -> Self
+pub fn vortex_array::arrays::VarBinView::slice(array: vortex_array::ArrayView<'_, Self>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<alloc::sync::Arc<str>> for vortex_array::dtype::Field
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::Field::from(value: alloc::sync::Arc<str>) -> Self
+pub fn vortex_array::arrays::VarBinView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::FieldPath::from(value: vortex_array::dtype::Field) -> Self
+pub fn vortex_array::arrays::VarBinView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::dtype::FieldName> for vortex_array::dtype::Field
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::dtype::Field::from(value: vortex_array::dtype::FieldName) -> Self
+pub fn vortex_array::arrays::VarBinView::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::dtype::Field
+pub struct vortex_array::arrays::Variant
 
-pub fn vortex_array::dtype::Field::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrays::Variant
 
-impl core::fmt::Display for vortex_array::dtype::Field
+pub const vortex_array::arrays::Variant::ID: vortex_array::ArrayId
 
-pub fn vortex_array::dtype::Field::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_array::arrays::Variant
 
-impl core::hash::Hash for vortex_array::dtype::Field
+pub fn vortex_array::arrays::Variant::clone(&self) -> vortex_array::arrays::Variant
 
-pub fn vortex_array::dtype::Field::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+impl core::fmt::Debug for vortex_array::arrays::Variant
 
-impl core::iter::traits::collect::FromIterator<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+pub fn vortex_array::arrays::Variant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::FieldPath::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::Field>>(iter: T) -> Self
+impl vortex_array::OperationsVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::Field
+pub fn vortex_array::arrays::Variant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub enum vortex_array::dtype::FieldMask
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-pub vortex_array::dtype::FieldMask::All
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub vortex_array::dtype::FieldMask::Exact(vortex_array::dtype::FieldPath)
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-pub vortex_array::dtype::FieldMask::Prefix(vortex_array::dtype::FieldPath)
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-impl vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::FieldMask::matches_all(&self) -> bool
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::FieldMask::matches_root(&self) -> bool
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::dtype::FieldMask::starting_field(&self) -> vortex_error::VortexResult<core::option::Option<&vortex_array::dtype::Field>>
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::FieldMask::step_into(self) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::dtype::FieldMask::clone(&self) -> vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::Eq for vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::PartialEq for vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::dtype::FieldMask::eq(&self, other: &vortex_array::dtype::FieldMask) -> bool
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::dtype::FieldMask::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldMask
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub enum vortex_array::dtype::Nullability
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::dtype::Nullability::NonNullable
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::dtype::Nullability::Nullable
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::Nullability
+impl vortex_array::ValidityVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub fn vortex_array::dtype::Nullability::is_nullable(&self) -> bool
+pub fn vortex_array::arrays::Variant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::clone::Clone for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::BoolArray = vortex_array::Array<vortex_array::arrays::Bool>
 
-pub fn vortex_array::dtype::Nullability::clone(&self) -> vortex_array::dtype::Nullability
+pub type vortex_array::arrays::ChunkedArray = vortex_array::Array<vortex_array::arrays::Chunked>
 
-impl core::cmp::Eq for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::ConstantArray = vortex_array::Array<vortex_array::arrays::Constant>
 
-impl core::cmp::PartialEq for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::DecimalArray = vortex_array::Array<vortex_array::arrays::Decimal>
 
-pub fn vortex_array::dtype::Nullability::eq(&self, other: &vortex_array::dtype::Nullability) -> bool
+pub type vortex_array::arrays::DictArray = vortex_array::Array<vortex_array::arrays::dict::Dict>
 
-impl core::convert::From<&vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+pub type vortex_array::arrays::ExtensionArray = vortex_array::Array<vortex_array::arrays::Extension>
 
-pub fn vortex_array::validity::Validity::from(value: &vortex_array::dtype::Nullability) -> Self
+pub type vortex_array::arrays::FilterArray = vortex_array::Array<vortex_array::arrays::Filter>
 
-impl core::convert::From<bool> for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::FixedSizeListArray = vortex_array::Array<vortex_array::arrays::FixedSizeList>
 
-pub fn vortex_array::dtype::Nullability::from(value: bool) -> Self
+pub type vortex_array::arrays::ListArray = vortex_array::Array<vortex_array::arrays::List>
 
-impl core::convert::From<vortex_array::dtype::Nullability> for bool
+pub type vortex_array::arrays::ListViewArray = vortex_array::Array<vortex_array::arrays::ListView>
 
-pub fn bool::from(value: vortex_array::dtype::Nullability) -> Self
+pub type vortex_array::arrays::MaskedArray = vortex_array::Array<vortex_array::arrays::Masked>
 
-impl core::convert::From<vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+pub type vortex_array::arrays::NullArray = vortex_array::Array<vortex_array::arrays::null::Null>
 
-pub fn vortex_array::validity::Validity::from(value: vortex_array::dtype::Nullability) -> Self
+pub type vortex_array::arrays::PatchedArray = vortex_array::Array<vortex_array::arrays::patched::Patched>
 
-impl core::default::Default for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::PrimitiveArray = vortex_array::Array<vortex_array::arrays::Primitive>
 
-pub fn vortex_array::dtype::Nullability::default() -> vortex_array::dtype::Nullability
+pub type vortex_array::arrays::ScalarFnArray = vortex_array::Array<vortex_array::arrays::scalar_fn::ScalarFnVTable>
 
-impl core::fmt::Debug for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::SharedArray = vortex_array::Array<vortex_array::arrays::Shared>
 
-pub fn vortex_array::dtype::Nullability::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::SliceArray = vortex_array::Array<vortex_array::arrays::slice::Slice>
 
-impl core::fmt::Display for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::StructArray = vortex_array::Array<vortex_array::arrays::Struct>
 
-pub fn vortex_array::dtype::Nullability::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::TemporalArray = vortex_array::arrays::datetime::TemporalData
 
-impl core::hash::Hash for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::VarBinArray = vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::dtype::Nullability::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub type vortex_array::arrays::VarBinViewArray = vortex_array::Array<vortex_array::arrays::VarBinView>
 
-impl core::marker::Copy for vortex_array::dtype::Nullability
+pub type vortex_array::arrays::VariantArray = vortex_array::Array<vortex_array::arrays::Variant>
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::Nullability
+pub mod vortex_array::arrow
 
-impl core::ops::bit::BitOr for vortex_array::dtype::Nullability
+pub mod vortex_array::arrow::bool
 
-pub type vortex_array::dtype::Nullability::Output = vortex_array::dtype::Nullability
+pub fn vortex_array::arrow::bool::canonical_bool_to_arrow(array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::dtype::Nullability::bitor(self, rhs: Self) -> Self::Output
+pub mod vortex_array::arrow::byte_view
 
-impl core::ops::bit::BitOrAssign for vortex_array::dtype::Nullability
+pub fn vortex_array::arrow::byte_view::canonical_varbinview_to_arrow<T: arrow_array::types::ByteViewType>(array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::dtype::Nullability::bitor_assign(&mut self, rhs: Self)
+pub fn vortex_array::arrow::byte_view::execute_varbinview_to_arrow<T: arrow_array::types::ByteViewType>(array: &vortex_array::arrays::VarBinViewArray, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-#[repr(u8)] pub enum vortex_array::dtype::PType
+pub mod vortex_array::arrow::null
 
-pub vortex_array::dtype::PType::F16 = 8
+pub fn vortex_array::arrow::null::canonical_null_to_arrow(array: &vortex_array::arrays::null::NullArray) -> arrow_array::array::ArrayRef
 
-pub vortex_array::dtype::PType::F32 = 9
+pub mod vortex_array::arrow::primitive
 
-pub vortex_array::dtype::PType::F64 = 10
+pub fn vortex_array::arrow::primitive::canonical_primitive_to_arrow<T: arrow_array::types::ArrowPrimitiveType>(array: vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<arrow_array::array::ArrayRef> where <T as arrow_array::types::ArrowPrimitiveType>::Native: vortex_array::dtype::NativePType
 
-pub vortex_array::dtype::PType::I16 = 5
+pub struct vortex_array::arrow::ArrowArrayStreamAdapter
 
-pub vortex_array::dtype::PType::I32 = 6
+impl vortex_array::arrow::ArrowArrayStreamAdapter
 
-pub vortex_array::dtype::PType::I64 = 7
+pub fn vortex_array::arrow::ArrowArrayStreamAdapter::new(stream: arrow_array::ffi_stream::ArrowArrayStreamReader, dtype: vortex_array::dtype::DType) -> Self
 
-pub vortex_array::dtype::PType::I8 = 4
+impl core::iter::traits::iterator::Iterator for vortex_array::arrow::ArrowArrayStreamAdapter
 
-pub vortex_array::dtype::PType::U16 = 1
+pub type vortex_array::arrow::ArrowArrayStreamAdapter::Item = core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
 
-pub vortex_array::dtype::PType::U32 = 2
+pub fn vortex_array::arrow::ArrowArrayStreamAdapter::next(&mut self) -> core::option::Option<Self::Item>
 
-pub vortex_array::dtype::PType::U64 = 3
+impl vortex_array::iter::ArrayIterator for vortex_array::arrow::ArrowArrayStreamAdapter
 
-pub vortex_array::dtype::PType::U8 = 0
+pub fn vortex_array::arrow::ArrowArrayStreamAdapter::dtype(&self) -> &vortex_array::dtype::DType
 
-impl vortex_array::dtype::PType
+pub struct vortex_array::arrow::Datum
 
-pub const fn vortex_array::dtype::PType::bit_width(&self) -> usize
+impl vortex_array::arrow::Datum
 
-pub const fn vortex_array::dtype::PType::byte_width(&self) -> usize
+pub fn vortex_array::arrow::Datum::data_type(&self) -> &arrow_schema::datatype::DataType
 
-pub const fn vortex_array::dtype::PType::is_float(self) -> bool
+pub fn vortex_array::arrow::Datum::try_new(array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub const fn vortex_array::dtype::PType::is_int(self) -> bool
+pub fn vortex_array::arrow::Datum::try_new_array(array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub const fn vortex_array::dtype::PType::is_signed_int(self) -> bool
+pub fn vortex_array::arrow::Datum::try_new_with_target_datatype(array: &vortex_array::ArrayRef, target_datatype: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
 
-pub const fn vortex_array::dtype::PType::is_unsigned_int(self) -> bool
+impl arrow_array::scalar::Datum for vortex_array::arrow::Datum
 
-pub const fn vortex_array::dtype::PType::max_signed_ptype(self, other: Self) -> Self
+pub fn vortex_array::arrow::Datum::get(&self) -> (&dyn arrow_array::array::Array, bool)
 
-pub const fn vortex_array::dtype::PType::max_unsigned_ptype(self, other: Self) -> Self
+impl core::fmt::Debug for vortex_array::arrow::Datum
 
-pub fn vortex_array::dtype::PType::max_value_as_u64(&self) -> u64
+pub fn vortex_array::arrow::Datum::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub const fn vortex_array::dtype::PType::min_signed_ptype_for_value(value: i64) -> Self
+pub trait vortex_array::arrow::ArrowArrayExecutor: core::marker::Sized
 
-pub const fn vortex_array::dtype::PType::min_unsigned_ptype_for_value(value: u64) -> Self
+pub fn vortex_array::arrow::ArrowArrayExecutor::execute_arrow(self, data_type: core::option::Option<&arrow_schema::datatype::DataType>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub const fn vortex_array::dtype::PType::to_signed(self) -> Self
+pub fn vortex_array::arrow::ArrowArrayExecutor::execute_record_batch(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
 
-pub const fn vortex_array::dtype::PType::to_unsigned(self) -> Self
+pub fn vortex_array::arrow::ArrowArrayExecutor::execute_record_batches(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<alloc::vec::Vec<arrow_array::record_batch::RecordBatch>>
 
-impl vortex_array::dtype::PType
+impl vortex_array::arrow::ArrowArrayExecutor for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::from_i32(value: i32) -> core::option::Option<vortex_array::dtype::PType>
+pub fn vortex_array::ArrayRef::execute_arrow(self, data_type: core::option::Option<&arrow_schema::datatype::DataType>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::dtype::PType::is_valid(value: i32) -> bool
+pub fn vortex_array::ArrayRef::execute_record_batch(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
 
-impl core::clone::Clone for vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::execute_record_batches(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<alloc::vec::Vec<arrow_array::record_batch::RecordBatch>>
 
-pub fn vortex_array::dtype::PType::clone(&self) -> vortex_array::dtype::PType
+pub trait vortex_array::arrow::FromArrowArray<A>
 
-impl core::cmp::Eq for vortex_array::dtype::PType
+pub fn vortex_array::arrow::FromArrowArray::from_arrow(array: A, nullable: bool) -> vortex_error::VortexResult<Self> where Self: core::marker::Sized
 
-impl core::cmp::PartialEq for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::boolean_array::BooleanArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::eq(&self, other: &vortex_array::dtype::PType) -> bool
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::boolean_array::BooleanArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::cmp::PartialOrd for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::fixed_size_list_array::FixedSizeListArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::partial_cmp(&self, other: &vortex_array::dtype::PType) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::fixed_size_list_array::FixedSizeListArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for &vortex_array::dtype::DType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::map_array::MapArray> for vortex_array::ArrayRef
 
-pub fn &vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::map_array::MapArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for i32
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::null_array::NullArray> for vortex_array::ArrayRef
 
-pub fn i32::from(value: vortex_array::dtype::PType) -> i32
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::null_array::NullArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::DType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::FieldDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_flatbuffers::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>> for vortex_array::ArrayRef
 
-pub fn vortex_flatbuffers::dtype::PType::from(value: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_proto::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>> for vortex_array::ArrayRef
 
-pub fn vortex_proto::dtype::PType::from(value: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<vortex_proto::dtype::PType> for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::from(value: vortex_proto::dtype::PType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>> for vortex_array::ArrayRef
 
-pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::PType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>> for vortex_array::ArrayRef
 
-impl core::convert::TryFrom<i32> for vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::dtype::PType::Error = prost::error::UnknownEnumValue
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::try_from(value: i32) -> core::result::Result<vortex_array::dtype::PType, prost::error::UnknownEnumValue>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::TryFrom<vortex_array::dtype::PType> for vortex_array::dtype::DecimalType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>> for vortex_array::ArrayRef
 
-pub type vortex_array::dtype::DecimalType::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalType::try_from(value: vortex_array::dtype::PType) -> core::result::Result<Self, Self::Error>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>> for vortex_array::ArrayRef
 
-impl core::convert::TryFrom<vortex_flatbuffers::dtype::PType> for vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::try_from(value: vortex_flatbuffers::dtype::PType) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::default::Default for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::default() -> vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::fmt::Debug for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::fmt::Display for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::hash::Hash for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::marker::Copy for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>> for vortex_array::ArrayRef
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::PType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub struct vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>> for vortex_array::ArrayRef
 
-impl vortex_array::dtype::DecimalDType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalDType::new(precision: u8, scale: i8) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::precision(&self) -> u8
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalDType::required_bit_width(&self) -> usize
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::scale(&self) -> i8
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalDType::try_new(precision: u8, scale: i8) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>> for vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::dtype::DecimalDType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalDType::clone(&self) -> vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>> for vortex_array::ArrayRef
 
-impl core::cmp::Eq for vortex_array::dtype::DecimalDType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::cmp::PartialEq for vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::eq(&self, other: &vortex_array::dtype::DecimalDType) -> bool
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>> for vortex_array::ArrayRef
 
-pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::DecimalDType::try_from(value: &vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>> for vortex_array::ArrayRef
 
-impl core::convert::TryFrom<vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::struct_array::StructArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::try_from(value: vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::struct_array::StructArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::fmt::Debug for vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::fmt::Display for vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<&dyn arrow_array::array::Array> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::from_arrow(array: &dyn arrow_array::array::Array, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::hash::Hash for vortex_array::dtype::DecimalDType
+impl vortex_array::arrow::FromArrowArray<arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::ArrayRef::from_arrow(array: arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl core::marker::Copy for vortex_array::dtype::DecimalDType
+impl<K: arrow_array::types::ArrowDictionaryKeyType> vortex_array::arrow::FromArrowArray<&arrow_array::array::dictionary_array::DictionaryArray<K>> for vortex_array::arrays::dict::DictArray
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::DecimalDType
+pub fn vortex_array::arrays::dict::DictArray::from_arrow(array: &arrow_array::array::dictionary_array::DictionaryArray<K>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::DecimalDType
+impl<O: arrow_array::array::list_array::OffsetSizeTrait + vortex_array::dtype::NativePType> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_view_array::GenericListViewArray<O>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::list_view_array::GenericListViewArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl<D: vortex_array::dtype::NativeDecimalType> core::convert::From<vortex_array::dtype::PrecisionScale<D>> for vortex_array::dtype::DecimalDType
+impl<O: vortex_array::dtype::IntegerPType + arrow_array::array::list_array::OffsetSizeTrait> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_array::GenericListArray<O>> for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::from(value: vortex_array::dtype::PrecisionScale<D>) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::list_array::GenericListArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl<D: vortex_array::dtype::NativeDecimalType> core::convert::TryFrom<&vortex_array::dtype::DecimalDType> for vortex_array::dtype::PrecisionScale<D>
+impl<T: arrow_array::types::ByteArrayType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_array::GenericByteArray<T>> for vortex_array::ArrayRef where <T as arrow_array::types::ByteArrayType>::Offset: vortex_array::dtype::IntegerPType
 
-pub type vortex_array::dtype::PrecisionScale<D>::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_array::GenericByteArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::PrecisionScale<D>::try_from(value: &vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
+impl<T: arrow_array::types::ByteViewType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_view_array::GenericByteViewArray<T>> for vortex_array::ArrayRef
 
-pub struct vortex_array::dtype::FieldDType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_view_array::GenericByteViewArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::dtype::FieldDType
+pub trait vortex_array::arrow::IntoArrowArray
 
-pub fn vortex_array::dtype::FieldDType::value(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrow::IntoArrowArray::into_arrow(self, data_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-impl core::clone::Clone for vortex_array::dtype::FieldDType
+pub fn vortex_array::arrow::IntoArrowArray::into_arrow_preferred(self) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::dtype::FieldDType::clone(&self) -> vortex_array::dtype::FieldDType
+impl vortex_array::arrow::IntoArrowArray for vortex_array::ArrayRef
 
-impl core::cmp::Eq for vortex_array::dtype::FieldDType
+pub fn vortex_array::ArrayRef::into_arrow(self, data_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-impl core::cmp::PartialEq for vortex_array::dtype::FieldDType
+pub fn vortex_array::ArrayRef::into_arrow_preferred(self) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::dtype::FieldDType::eq(&self, other: &vortex_array::dtype::FieldDType) -> bool
+pub fn vortex_array::arrow::from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> vortex_error::VortexResult<vortex_array::ArrayRef> where vortex_array::ArrayRef: vortex_array::arrow::FromArrowArray<A>
 
-impl core::convert::From<vortex_array::dtype::DType> for vortex_array::dtype::FieldDType
+pub fn vortex_array::arrow::to_arrow_null_buffer(validity: vortex_array::validity::Validity, len: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<arrow_buffer::buffer::null::NullBuffer>>
 
-pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::DType) -> Self
+pub fn vortex_array::arrow::to_null_buffer(mask: vortex_mask::Mask) -> core::option::Option<arrow_buffer::buffer::null::NullBuffer>
 
-impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::FieldDType
+pub mod vortex_array::buffer
 
-pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::PType) -> Self
+pub struct vortex_array::buffer::BufferHandle(_)
 
-impl core::fmt::Debug for vortex_array::dtype::FieldDType
+impl vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::FieldDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::buffer::BufferHandle::alignment(&self) -> vortex_buffer::alignment::Alignment
 
-impl core::hash::Hash for vortex_array::dtype::FieldDType
+pub fn vortex_array::buffer::BufferHandle::as_device(&self) -> &alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
 
-pub fn vortex_array::dtype::FieldDType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::buffer::BufferHandle::as_device_opt(&self) -> core::option::Option<&alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>>
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldDType
+pub fn vortex_array::buffer::BufferHandle::as_host(&self) -> &vortex_buffer::ByteBuffer
 
-pub struct vortex_array::dtype::FieldName(_)
+pub fn vortex_array::buffer::BufferHandle::as_host_opt(&self) -> core::option::Option<&vortex_buffer::ByteBuffer>
 
-impl vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::ensure_aligned(self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::FieldName::inner(&self) -> &alloc::sync::Arc<str>
+pub fn vortex_array::buffer::BufferHandle::into_host(self) -> futures_core::future::BoxFuture<'static, vortex_buffer::ByteBuffer>
 
-impl core::borrow::Borrow<str> for &vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::into_host_sync(self) -> vortex_buffer::ByteBuffer
 
-pub fn &vortex_array::dtype::FieldName::borrow(&self) -> &str
+pub fn vortex_array::buffer::BufferHandle::is_aligned_to(&self, alignment: vortex_buffer::alignment::Alignment) -> bool
 
-impl core::borrow::Borrow<str> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::is_empty(&self) -> bool
 
-pub fn vortex_array::dtype::FieldName::borrow(&self) -> &str
+pub fn vortex_array::buffer::BufferHandle::is_on_device(&self) -> bool
 
-impl core::clone::Clone for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::is_on_host(&self) -> bool
 
-pub fn vortex_array::dtype::FieldName::clone(&self) -> vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::len(&self) -> usize
 
-impl core::cmp::Eq for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::slice(&self, range: core::ops::range::Range<usize>) -> Self
 
-impl core::cmp::Ord for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> Self
 
-pub fn vortex_array::dtype::FieldName::cmp(&self, other: &vortex_array::dtype::FieldName) -> core::cmp::Ordering
+pub fn vortex_array::buffer::BufferHandle::to_host(&self) -> futures_core::future::BoxFuture<'static, vortex_buffer::ByteBuffer>
 
-impl core::cmp::PartialEq for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::to_host_sync(&self) -> vortex_buffer::ByteBuffer
 
-pub fn vortex_array::dtype::FieldName::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+pub fn vortex_array::buffer::BufferHandle::try_into_host(self) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
 
-impl core::cmp::PartialEq<&alloc::string::String> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::try_into_host_sync(self) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
 
-pub fn vortex_array::dtype::FieldName::eq(&self, other: &&alloc::string::String) -> bool
+pub fn vortex_array::buffer::BufferHandle::try_to_host(&self) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
 
-impl core::cmp::PartialEq<&str> for &vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::try_to_host_sync(&self) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
 
-pub fn &vortex_array::dtype::FieldName::eq(&self, other: &&str) -> bool
+pub fn vortex_array::buffer::BufferHandle::unwrap_device(self) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
 
-impl core::cmp::PartialEq<&str> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::unwrap_host(self) -> vortex_buffer::ByteBuffer
 
-pub fn vortex_array::dtype::FieldName::eq(&self, other: &&str) -> bool
+impl vortex_array::buffer::BufferHandle
 
-impl core::cmp::PartialEq<&vortex_array::dtype::FieldName> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::new_device(device: alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>) -> Self
 
-pub fn vortex_array::dtype::FieldName::eq(&self, other: &&vortex_array::dtype::FieldName) -> bool
+pub fn vortex_array::buffer::BufferHandle::new_host(byte_buffer: vortex_buffer::ByteBuffer) -> Self
 
-impl core::cmp::PartialEq<alloc::string::String> for vortex_array::dtype::FieldName
+impl core::clone::Clone for vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::dtype::FieldName::eq(&self, other: &alloc::string::String) -> bool
+pub fn vortex_array::buffer::BufferHandle::clone(&self) -> vortex_array::buffer::BufferHandle
 
-impl core::cmp::PartialEq<vortex_array::dtype::FieldName> for &vortex_array::dtype::FieldName
+impl core::convert::TryFrom<vortex_array::buffer::BufferHandle> for vortex_array::serde::SerializedArray
 
-pub fn &vortex_array::dtype::FieldName::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+pub type vortex_array::serde::SerializedArray::Error = vortex_error::VortexError
 
-impl core::cmp::PartialEq<vortex_array::dtype::FieldName> for str
+pub fn vortex_array::serde::SerializedArray::try_from(value: vortex_array::buffer::BufferHandle) -> core::result::Result<Self, Self::Error>
 
-pub fn str::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+impl core::fmt::Debug for vortex_array::buffer::BufferHandle
 
-impl core::cmp::PartialOrd for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::FieldName::partial_cmp(&self, other: &vortex_array::dtype::FieldName) -> core::option::Option<core::cmp::Ordering>
+impl vortex_array::ArrayEq for vortex_array::buffer::BufferHandle
 
-impl core::convert::AsRef<str> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::dtype::FieldName::as_ref(&self) -> &str
+impl vortex_array::ArrayHash for vortex_array::buffer::BufferHandle
 
-impl core::convert::From<&str> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::BufferHandle::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::dtype::FieldName::from(value: &str) -> Self
+pub trait vortex_array::buffer::DeviceBuffer: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug + vortex_utils::dyn_traits::DynEq + vortex_utils::dyn_traits::DynHash
 
-impl core::convert::From<alloc::string::String> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::DeviceBuffer::aligned(self: alloc::sync::Arc<Self>, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>>
 
-pub fn vortex_array::dtype::FieldName::from(value: alloc::string::String) -> Self
+pub fn vortex_array::buffer::DeviceBuffer::alignment(&self) -> vortex_buffer::alignment::Alignment
 
-impl core::convert::From<alloc::sync::Arc<str>> for vortex_array::dtype::FieldName
+pub fn vortex_array::buffer::DeviceBuffer::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::FieldName::from(value: alloc::sync::Arc<str>) -> Self
+pub fn vortex_array::buffer::DeviceBuffer::copy_to_host(&self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_buffer::ByteBuffer>>>
 
-impl core::convert::From<vortex_array::dtype::FieldName> for alloc::string::String
+pub fn vortex_array::buffer::DeviceBuffer::copy_to_host_sync(&self, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_buffer::ByteBuffer>
 
-pub fn alloc::string::String::from(value: vortex_array::dtype::FieldName) -> Self
+pub fn vortex_array::buffer::DeviceBuffer::is_empty(&self) -> bool
 
-impl core::convert::From<vortex_array::dtype::FieldName> for alloc::sync::Arc<str>
+pub fn vortex_array::buffer::DeviceBuffer::len(&self) -> usize
 
-pub fn alloc::sync::Arc<str>::from(value: vortex_array::dtype::FieldName) -> Self
+pub fn vortex_array::buffer::DeviceBuffer::slice(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
 
-impl core::convert::From<vortex_array::dtype::FieldName> for vortex_array::dtype::Field
+pub trait vortex_array::buffer::DeviceBufferExt: vortex_array::buffer::DeviceBuffer
 
-pub fn vortex_array::dtype::Field::from(value: vortex_array::dtype::FieldName) -> Self
+pub fn vortex_array::buffer::DeviceBufferExt::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
 
-impl core::fmt::Debug for vortex_array::dtype::FieldName
+impl<B: vortex_array::buffer::DeviceBuffer> vortex_array::buffer::DeviceBufferExt for B
 
-pub fn vortex_array::dtype::FieldName::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn B::slice_typed<T: core::marker::Sized>(&self, range: core::ops::range::Range<usize>) -> alloc::sync::Arc<dyn vortex_array::buffer::DeviceBuffer>
 
-impl core::fmt::Display for vortex_array::dtype::FieldName
+pub mod vortex_array::builders
 
-pub fn vortex_array::dtype::FieldName::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod vortex_array::builders::dict
 
-impl core::hash::Hash for vortex_array::dtype::FieldName
+pub struct vortex_array::builders::dict::DictConstraints
 
-pub fn vortex_array::dtype::FieldName::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub vortex_array::builders::dict::DictConstraints::max_bytes: usize
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldName
+pub vortex_array::builders::dict::DictConstraints::max_len: usize
 
-pub struct vortex_array::dtype::FieldNames(_)
+impl core::clone::Clone for vortex_array::builders::dict::DictConstraints
 
-impl vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::dict::DictConstraints::clone(&self) -> vortex_array::builders::dict::DictConstraints
 
-pub fn vortex_array::dtype::FieldNames::empty() -> Self
+pub const vortex_array::builders::dict::UNCONSTRAINED: vortex_array::builders::dict::DictConstraints
 
-pub fn vortex_array::dtype::FieldNames::find(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<usize>
+pub trait vortex_array::builders::dict::DictEncoder: core::marker::Send
 
-pub fn vortex_array::dtype::FieldNames::get(&self, index: usize) -> core::option::Option<&vortex_array::dtype::FieldName>
+pub fn vortex_array::builders::dict::DictEncoder::codes_ptype(&self) -> vortex_array::dtype::PType
 
-pub fn vortex_array::dtype::FieldNames::is_empty(&self) -> bool
+pub fn vortex_array::builders::dict::DictEncoder::encode(&mut self, array: &vortex_array::ArrayRef) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::FieldNames::iter(&self) -> impl core::iter::traits::exact_size::ExactSizeIterator<Item = &vortex_array::dtype::FieldName>
+pub fn vortex_array::builders::dict::DictEncoder::reset(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::FieldNames::len(&self) -> usize
+pub fn vortex_array::builders::dict::dict_encode(array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::arrays::dict::DictArray>
 
-impl core::clone::Clone for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::dict::dict_encode_with_constraints(array: &vortex_array::ArrayRef, constraints: &vortex_array::builders::dict::DictConstraints) -> vortex_error::VortexResult<vortex_array::arrays::dict::DictArray>
 
-pub fn vortex_array::dtype::FieldNames::clone(&self) -> vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::dict::dict_encoder(array: &vortex_array::ArrayRef, constraints: &vortex_array::builders::dict::DictConstraints) -> alloc::boxed::Box<dyn vortex_array::builders::dict::DictEncoder>
 
-impl core::cmp::Eq for vortex_array::dtype::FieldNames
+pub enum vortex_array::builders::BufferGrowthStrategy
 
-impl core::cmp::PartialEq for vortex_array::dtype::FieldNames
+pub vortex_array::builders::BufferGrowthStrategy::Exponential
 
-pub fn vortex_array::dtype::FieldNames::eq(&self, other: &vortex_array::dtype::FieldNames) -> bool
+pub vortex_array::builders::BufferGrowthStrategy::Exponential::current_size: u32
 
-impl core::cmp::PartialEq<&[&str]> for &vortex_array::dtype::FieldNames
+pub vortex_array::builders::BufferGrowthStrategy::Exponential::max_size: u32
 
-pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &&[&str]) -> bool
+pub vortex_array::builders::BufferGrowthStrategy::Fixed
 
-impl core::cmp::PartialEq<&[&str]> for vortex_array::dtype::FieldNames
+pub vortex_array::builders::BufferGrowthStrategy::Fixed::size: u32
 
-pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&[&str]) -> bool
+impl vortex_array::builders::BufferGrowthStrategy
 
-impl core::cmp::PartialEq<&[vortex_array::dtype::FieldName]> for &vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BufferGrowthStrategy::exponential(initial_size: u32, max_size: u32) -> Self
 
-pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &&[vortex_array::dtype::FieldName]) -> bool
+pub fn vortex_array::builders::BufferGrowthStrategy::fixed(size: u32) -> Self
 
-impl core::cmp::PartialEq<&[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BufferGrowthStrategy::next_size(&mut self) -> u32
 
-pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&[vortex_array::dtype::FieldName]) -> bool
+impl core::clone::Clone for vortex_array::builders::BufferGrowthStrategy
 
-impl core::cmp::PartialEq<&vortex_array::dtype::FieldNames> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BufferGrowthStrategy::clone(&self) -> vortex_array::builders::BufferGrowthStrategy
 
-pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&vortex_array::dtype::FieldNames) -> bool
+impl core::default::Default for vortex_array::builders::BufferGrowthStrategy
 
-impl core::convert::AsRef<[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BufferGrowthStrategy::default() -> Self
 
-pub fn vortex_array::dtype::FieldNames::as_ref(&self) -> &[vortex_array::dtype::FieldName]
+impl core::fmt::Debug for vortex_array::builders::BufferGrowthStrategy
 
-impl core::convert::From<&[&'static str]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BufferGrowthStrategy::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::FieldNames::from(value: &[&'static str]) -> Self
+pub enum vortex_array::builders::CompletedBuffers
 
-impl core::convert::From<&[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+pub vortex_array::builders::CompletedBuffers::Deduplicated(vortex_array::builders::DeduplicatedBuffers)
 
-pub fn vortex_array::dtype::FieldNames::from(value: &[vortex_array::dtype::FieldName]) -> Self
+pub vortex_array::builders::CompletedBuffers::Default(alloc::vec::Vec<vortex_buffer::ByteBuffer>)
 
-impl core::convert::From<alloc::vec::Vec<&str>> for vortex_array::dtype::FieldNames
+impl core::default::Default for vortex_array::builders::CompletedBuffers
 
-pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<&str>) -> Self
+pub fn vortex_array::builders::CompletedBuffers::default() -> Self
 
-impl core::convert::From<alloc::vec::Vec<alloc::sync::Arc<str>>> for vortex_array::dtype::FieldNames
+pub struct vortex_array::builders::BoolBuilder
 
-pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<alloc::sync::Arc<str>>) -> Self
+impl vortex_array::builders::BoolBuilder
 
-impl core::convert::From<alloc::vec::Vec<vortex_array::dtype::FieldName>> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::append_value(&mut self, value: bool)
 
-pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<vortex_array::dtype::FieldName>) -> Self
+pub fn vortex_array::builders::BoolBuilder::append_values(&mut self, value: bool, n: usize)
 
-impl core::default::Default for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::finish_into_bool(&mut self) -> vortex_array::arrays::BoolArray
 
-pub fn vortex_array::dtype::FieldNames::default() -> vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::new(nullability: vortex_array::dtype::Nullability) -> Self
 
-impl core::fmt::Debug for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::with_capacity(nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
 
-pub fn vortex_array::dtype::FieldNames::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::BoolBuilder
 
-impl core::fmt::Display for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::append_default(&mut self)
 
-pub fn vortex_array::dtype::FieldNames::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::BoolBuilder::append_defaults(&mut self, n: usize)
 
-impl core::hash::Hash for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::append_null(&mut self)
 
-pub fn vortex_array::dtype::FieldNames::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::builders::BoolBuilder::append_nulls(&mut self, n: usize)
 
-impl core::iter::traits::collect::IntoIterator for vortex_array::dtype::FieldNames
+pub unsafe fn vortex_array::builders::BoolBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub type vortex_array::dtype::FieldNames::IntoIter = vortex_array::dtype::FieldNamesIntoIter
+pub fn vortex_array::builders::BoolBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::dtype::FieldNames::Item = vortex_array::dtype::FieldName
+pub fn vortex_array::builders::BoolBuilder::append_zero(&mut self)
 
-pub fn vortex_array::dtype::FieldNames::into_iter(self) -> Self::IntoIter
+pub fn vortex_array::builders::BoolBuilder::append_zeros(&mut self, n: usize)
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::as_any(&self) -> &dyn core::any::Any
 
-impl core::ops::index::Index<usize> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub type vortex_array::dtype::FieldNames::Output = vortex_array::dtype::FieldName
+pub fn vortex_array::builders::BoolBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::FieldNames::index(&self, index: usize) -> &Self::Output
+pub fn vortex_array::builders::BoolBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl<F: core::convert::Into<vortex_array::dtype::FieldName>> core::iter::traits::collect::FromIterator<F> for vortex_array::dtype::FieldNames
+pub unsafe fn vortex_array::builders::BoolBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::FieldNames::from_iter<T: core::iter::traits::collect::IntoIterator<Item = F>>(iter: T) -> Self
+pub fn vortex_array::builders::BoolBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-impl<const N: usize> core::cmp::PartialEq<[&str; N]> for &vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &[&str; N]) -> bool
+pub fn vortex_array::builders::BoolBuilder::is_empty(&self) -> bool
 
-impl<const N: usize> core::cmp::PartialEq<[&str; N]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::FieldNames::eq(&self, other: &[&str; N]) -> bool
+pub fn vortex_array::builders::BoolBuilder::reserve_exact(&mut self, additional: usize)
 
-impl<const N: usize> core::convert::From<&[&str; N]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::BoolBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::FieldNames::from(value: &[&str; N]) -> Self
+pub unsafe fn vortex_array::builders::BoolBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl<const N: usize> core::convert::From<[&str; N]> for vortex_array::dtype::FieldNames
+pub struct vortex_array::builders::DecimalBuilder
 
-pub fn vortex_array::dtype::FieldNames::from(value: [&str; N]) -> Self
+impl vortex_array::builders::DecimalBuilder
 
-impl<const N: usize> core::convert::From<[vortex_array::dtype::FieldName; N]> for vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::DecimalBuilder::append_n_values<V: vortex_array::dtype::NativeDecimalType>(&mut self, value: V, n: usize)
 
-pub fn vortex_array::dtype::FieldNames::from(value: [vortex_array::dtype::FieldName; N]) -> Self
+pub fn vortex_array::builders::DecimalBuilder::append_value<V: vortex_array::dtype::NativeDecimalType>(&mut self, value: V)
 
-pub struct vortex_array::dtype::FieldNamesIntoIter
+pub fn vortex_array::builders::DecimalBuilder::decimal_dtype(&self) -> &vortex_array::dtype::DecimalDType
 
-impl core::iter::traits::exact_size::ExactSizeIterator for vortex_array::dtype::FieldNamesIntoIter
+pub fn vortex_array::builders::DecimalBuilder::finish_into_decimal(&mut self) -> vortex_array::arrays::DecimalArray
 
-impl core::iter::traits::iterator::Iterator for vortex_array::dtype::FieldNamesIntoIter
+pub fn vortex_array::builders::DecimalBuilder::new<T: vortex_array::dtype::NativeDecimalType>(decimal: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub type vortex_array::dtype::FieldNamesIntoIter::Item = vortex_array::dtype::FieldName
+pub fn vortex_array::builders::DecimalBuilder::with_capacity<T: vortex_array::dtype::NativeDecimalType>(capacity: usize, decimal: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::dtype::FieldNamesIntoIter::next(&mut self) -> core::option::Option<Self::Item>
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::DecimalBuilder
 
-pub fn vortex_array::dtype::FieldNamesIntoIter::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn vortex_array::builders::DecimalBuilder::append_default(&mut self)
 
-pub struct vortex_array::dtype::FieldNamesIter<'a>
+pub fn vortex_array::builders::DecimalBuilder::append_defaults(&mut self, n: usize)
 
-impl core::iter::traits::exact_size::ExactSizeIterator for vortex_array::dtype::FieldNamesIter<'_>
+pub fn vortex_array::builders::DecimalBuilder::append_null(&mut self)
 
-impl<'a> core::iter::traits::iterator::Iterator for vortex_array::dtype::FieldNamesIter<'a>
+pub fn vortex_array::builders::DecimalBuilder::append_nulls(&mut self, n: usize)
 
-pub type vortex_array::dtype::FieldNamesIter<'a>::Item = &'a vortex_array::dtype::FieldName
+pub unsafe fn vortex_array::builders::DecimalBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::FieldNamesIter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn vortex_array::builders::DecimalBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::FieldNamesIter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn vortex_array::builders::DecimalBuilder::append_zero(&mut self)
 
-pub struct vortex_array::dtype::FieldPath(_)
+pub fn vortex_array::builders::DecimalBuilder::append_zeros(&mut self, n: usize)
 
-impl vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::DecimalBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::FieldPath::exists_in(&self, dtype: vortex_array::dtype::DType) -> bool
+pub fn vortex_array::builders::DecimalBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn vortex_array::dtype::FieldPath::from_name<F: core::convert::Into<vortex_array::dtype::FieldName>>(name: F) -> Self
+pub fn vortex_array::builders::DecimalBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::FieldPath::is_root(&self) -> bool
+pub fn vortex_array::builders::DecimalBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::FieldPath::overlap(&self, other: &vortex_array::dtype::FieldPath) -> bool
+pub unsafe fn vortex_array::builders::DecimalBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::FieldPath::parts(&self) -> &[vortex_array::dtype::Field]
+pub fn vortex_array::builders::DecimalBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::FieldPath::push<F: core::convert::Into<vortex_array::dtype::Field>>(self, field: F) -> Self
+pub fn vortex_array::builders::DecimalBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn vortex_array::dtype::FieldPath::resolve(&self, dtype: vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+pub fn vortex_array::builders::DecimalBuilder::is_empty(&self) -> bool
 
-pub fn vortex_array::dtype::FieldPath::root() -> Self
+pub fn vortex_array::builders::DecimalBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::FieldPath::starts_with_field(&self, field: &vortex_array::dtype::Field) -> bool
+pub fn vortex_array::builders::DecimalBuilder::reserve_exact(&mut self, additional: usize)
 
-pub fn vortex_array::dtype::FieldPath::step_into(self) -> core::option::Option<Self>
+pub fn vortex_array::builders::DecimalBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-impl core::clone::Clone for vortex_array::dtype::FieldPath
+pub unsafe fn vortex_array::builders::DecimalBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::FieldPath::clone(&self) -> vortex_array::dtype::FieldPath
+pub struct vortex_array::builders::DeduplicatedBuffers
 
-impl core::cmp::Eq for vortex_array::dtype::FieldPath
+impl core::default::Default for vortex_array::builders::DeduplicatedBuffers
 
-impl core::cmp::PartialEq for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::DeduplicatedBuffers::default() -> vortex_array::builders::DeduplicatedBuffers
 
-pub fn vortex_array::dtype::FieldPath::eq(&self, other: &vortex_array::dtype::FieldPath) -> bool
+pub struct vortex_array::builders::ExtensionBuilder
 
-impl core::convert::From<alloc::vec::Vec<vortex_array::dtype::Field>> for vortex_array::dtype::FieldPath
+impl vortex_array::builders::ExtensionBuilder
 
-pub fn vortex_array::dtype::FieldPath::from(value: alloc::vec::Vec<vortex_array::dtype::Field>) -> Self
+pub fn vortex_array::builders::ExtensionBuilder::append_value(&mut self, value: vortex_array::scalar::ExtScalar<'_>) -> vortex_error::VortexResult<()>
 
-impl core::convert::From<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::finish_into_extension(&mut self) -> vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::dtype::FieldPath::from(value: vortex_array::dtype::Field) -> Self
+pub fn vortex_array::builders::ExtensionBuilder::new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef) -> Self
 
-impl core::convert::TryFrom<&vortex_proto::dtype::FieldPath> for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::with_capacity(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, capacity: usize) -> Self
 
-pub type vortex_array::dtype::FieldPath::Error = vortex_error::VortexError
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::ExtensionBuilder
 
-pub fn vortex_array::dtype::FieldPath::try_from(value: &vortex_proto::dtype::FieldPath) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::builders::ExtensionBuilder::append_default(&mut self)
 
-impl core::default::Default for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::FieldPath::default() -> vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::append_null(&mut self)
 
-impl core::fmt::Debug for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::FieldPath::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub unsafe fn vortex_array::builders::ExtensionBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl core::fmt::Display for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::FieldPath::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::ExtensionBuilder::append_zero(&mut self)
 
-impl core::hash::Hash for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::FieldPath::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::builders::ExtensionBuilder::as_any(&self) -> &dyn core::any::Any
 
-impl core::iter::traits::collect::FromIterator<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn vortex_array::dtype::FieldPath::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::Field>>(iter: T) -> Self
+pub fn vortex_array::builders::ExtensionBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::iter::traits::collect::FromIterator<vortex_array::dtype::FieldPath> for vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::ExtensionBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::FieldPathSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::FieldPath>>(iter: T) -> Self
+pub unsafe fn vortex_array::builders::ExtensionBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldPath
+pub fn vortex_array::builders::ExtensionBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub struct vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::ExtensionBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::ExtensionBuilder::is_empty(&self) -> bool
 
-pub fn vortex_array::dtype::FieldPathSet::contains(&self, path: &vortex_array::dtype::FieldPath) -> bool
+pub fn vortex_array::builders::ExtensionBuilder::len(&self) -> usize
 
-impl core::clone::Clone for vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::ExtensionBuilder::reserve_exact(&mut self, capacity: usize)
 
-pub fn vortex_array::dtype::FieldPathSet::clone(&self) -> vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::ExtensionBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-impl core::default::Default for vortex_array::dtype::FieldPathSet
+pub unsafe fn vortex_array::builders::ExtensionBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::FieldPathSet::default() -> vortex_array::dtype::FieldPathSet
+pub struct vortex_array::builders::FixedSizeListBuilder
 
-impl core::fmt::Debug for vortex_array::dtype::FieldPathSet
+impl vortex_array::builders::FixedSizeListBuilder
 
-pub fn vortex_array::dtype::FieldPathSet::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::FixedSizeListBuilder::append_array_as_list(&mut self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<()>
 
-impl core::iter::traits::collect::FromIterator<vortex_array::dtype::FieldPath> for vortex_array::dtype::FieldPathSet
+pub fn vortex_array::builders::FixedSizeListBuilder::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::FieldPathSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::FieldPath>>(iter: T) -> Self
+pub fn vortex_array::builders::FixedSizeListBuilder::element_dtype(&self) -> &vortex_array::dtype::DType
 
-pub struct vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_fixed_size_list(&mut self) -> vortex_array::arrays::FixedSizeListArray
 
-impl<D: vortex_array::dtype::NativeDecimalType> vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::list_size(&self) -> u32
 
-pub fn vortex_array::dtype::PrecisionScale<D>::is_valid(&self, value: D) -> bool
+pub fn vortex_array::builders::FixedSizeListBuilder::new(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, list_size: u32, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::dtype::PrecisionScale<D>::new(precision: u8, scale: i8) -> Self
+pub fn vortex_array::builders::FixedSizeListBuilder::with_capacity(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, list_size: u32, nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
 
-pub unsafe fn vortex_array::dtype::PrecisionScale<D>::new_unchecked(precision: u8, scale: i8) -> Self
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::FixedSizeListBuilder
 
-pub fn vortex_array::dtype::PrecisionScale<D>::precision(&self) -> u8
+pub fn vortex_array::builders::FixedSizeListBuilder::append_default(&mut self)
 
-pub fn vortex_array::dtype::PrecisionScale<D>::scale(&self) -> i8
+pub fn vortex_array::builders::FixedSizeListBuilder::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::PrecisionScale<D>::try_new(precision: u8, scale: i8) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::builders::FixedSizeListBuilder::append_null(&mut self)
 
-impl<D: core::clone::Clone> core::clone::Clone for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::PrecisionScale<D>::clone(&self) -> vortex_array::dtype::PrecisionScale<D>
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl<D: core::cmp::Eq> core::cmp::Eq for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl<D: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::append_zero(&mut self)
 
-pub fn vortex_array::dtype::PrecisionScale<D>::eq(&self, other: &vortex_array::dtype::PrecisionScale<D>) -> bool
+pub fn vortex_array::builders::FixedSizeListBuilder::append_zeros(&mut self, n: usize)
 
-impl<D: core::fmt::Debug> core::fmt::Debug for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::PrecisionScale<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::FixedSizeListBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl<D: core::hash::Hash> core::hash::Hash for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::PrecisionScale<D>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::builders::FixedSizeListBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl<D: core::marker::Copy> core::marker::Copy for vortex_array::dtype::PrecisionScale<D>
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl<D: vortex_array::dtype::NativeDecimalType> core::convert::From<vortex_array::dtype::PrecisionScale<D>> for vortex_array::dtype::DecimalDType
+pub fn vortex_array::builders::FixedSizeListBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalDType::from(value: vortex_array::dtype::PrecisionScale<D>) -> Self
+pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl<D: vortex_array::dtype::NativeDecimalType> core::convert::TryFrom<&vortex_array::dtype::DecimalDType> for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::is_empty(&self) -> bool
 
-pub type vortex_array::dtype::PrecisionScale<D>::Error = vortex_error::VortexError
+pub fn vortex_array::builders::FixedSizeListBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::PrecisionScale<D>::try_from(value: &vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::builders::FixedSizeListBuilder::reserve_exact(&mut self, additional: usize)
 
-impl<D: vortex_array::dtype::NativeDecimalType> core::fmt::Display for vortex_array::dtype::PrecisionScale<D>
+pub fn vortex_array::builders::FixedSizeListBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::PrecisionScale<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl<D> core::marker::StructuralPartialEq for vortex_array::dtype::PrecisionScale<D>
+pub struct vortex_array::builders::ListBuilder<O: vortex_array::dtype::IntegerPType>
 
-pub struct vortex_array::dtype::StructFields(_)
+impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ListBuilder<O>
 
-impl vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::append_array_as_list(&mut self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::StructFields::disjoint_merge(&self, other: &Self) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::builders::ListBuilder<O>::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::StructFields::empty() -> Self
+pub fn vortex_array::builders::ListBuilder<O>::element_dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::StructFields::field(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<vortex_array::dtype::DType>
+pub fn vortex_array::builders::ListBuilder<O>::finish_into_list(&mut self) -> vortex_array::arrays::ListArray
 
-pub fn vortex_array::dtype::StructFields::field_by_index(&self, index: usize) -> core::option::Option<vortex_array::dtype::DType>
+pub fn vortex_array::builders::ListBuilder<O>::new(value_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::dtype::StructFields::field_name(&self, index: usize) -> core::option::Option<&vortex_array::dtype::FieldName>
+pub fn vortex_array::builders::ListBuilder<O>::with_capacity(value_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability, elements_capacity: usize, capacity: usize) -> Self
 
-pub fn vortex_array::dtype::StructFields::fields(&self) -> impl core::iter::traits::exact_size::ExactSizeIterator<Item = vortex_array::dtype::DType> + '_
+impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListBuilder<O>
 
-pub fn vortex_array::dtype::StructFields::find(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<usize>
+pub fn vortex_array::builders::ListBuilder<O>::append_default(&mut self)
 
-pub fn vortex_array::dtype::StructFields::from_fields(names: vortex_array::dtype::FieldNames, dtypes: alloc::vec::Vec<vortex_array::dtype::FieldDType>) -> Self
+pub fn vortex_array::builders::ListBuilder<O>::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::StructFields::names(&self) -> &vortex_array::dtype::FieldNames
+pub fn vortex_array::builders::ListBuilder<O>::append_null(&mut self)
 
-pub fn vortex_array::dtype::StructFields::new(names: vortex_array::dtype::FieldNames, dtypes: alloc::vec::Vec<vortex_array::dtype::DType>) -> Self
+pub fn vortex_array::builders::ListBuilder<O>::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::StructFields::nfields(&self) -> usize
+pub unsafe fn vortex_array::builders::ListBuilder<O>::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::StructFields::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::builders::ListBuilder<O>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::StructFields::without_field(&self, index: usize) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::builders::ListBuilder<O>::append_zero(&mut self)
 
-impl core::clone::Clone for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::StructFields::clone(&self) -> vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::as_any(&self) -> &dyn core::any::Any
 
-impl core::cmp::Eq for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl core::cmp::PartialEq for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::StructFields::eq(&self, other: &vortex_array::dtype::StructFields) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl core::default::Default for vortex_array::dtype::StructFields
+pub unsafe fn vortex_array::builders::ListBuilder<O>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::StructFields::default() -> Self
+pub fn vortex_array::builders::ListBuilder<O>::finish(&mut self) -> vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn vortex_array::dtype::StructFields::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::ListBuilder<O>::is_empty(&self) -> bool
 
-impl core::fmt::Display for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::len(&self) -> usize
 
-pub fn vortex_array::dtype::StructFields::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::ListBuilder<O>::reserve_exact(&mut self, additional: usize)
 
-impl core::hash::Hash for vortex_array::dtype::StructFields
+pub fn vortex_array::builders::ListBuilder<O>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::StructFields::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub unsafe fn vortex_array::builders::ListBuilder<O>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::StructFields
+pub struct vortex_array::builders::ListViewBuilder<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType>
 
-impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::fields::Fields> for vortex_array::dtype::StructFields
+impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ListViewBuilder<O, S>
 
-pub fn vortex_array::dtype::StructFields::from_arrow(value: &arrow_schema::fields::Fields) -> Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_array_as_list(&mut self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<()>
 
-impl<T, V> core::iter::traits::collect::FromIterator<(T, V)> for vortex_array::dtype::StructFields where T: core::convert::Into<vortex_array::dtype::FieldName>, V: core::convert::Into<vortex_array::dtype::FieldDType>
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_value(&mut self, value: vortex_array::scalar::ListScalar<'_>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::StructFields::from_iter<I: core::iter::traits::collect::IntoIterator<Item = (T, V)>>(iter: I) -> Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::element_dtype(&self) -> &vortex_array::dtype::DType
 
-#[repr(transparent)] pub struct vortex_array::dtype::i256(_)
+pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_listview(&mut self) -> vortex_array::arrays::ListViewArray
 
-impl vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::new(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub const vortex_array::dtype::i256::MAX: Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::with_capacity(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability, elements_capacity: usize, capacity: usize) -> Self
 
-pub const vortex_array::dtype::i256::MIN: Self
+impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListViewBuilder<O, S>
 
-pub const vortex_array::dtype::i256::ONE: Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_default(&mut self)
 
-pub const vortex_array::dtype::i256::ZERO: Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::checked_pow(&self, exp: u32) -> core::option::Option<Self>
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_null(&mut self)
 
-pub const fn vortex_array::dtype::i256::from_i128(i: i128) -> Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls(&mut self, n: usize)
 
-pub const fn vortex_array::dtype::i256::from_le_bytes(bytes: [u8; 32]) -> Self
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls_unchecked(&mut self, n: usize)
 
-pub const fn vortex_array::dtype::i256::from_parts(lower: u128, upper: i128) -> Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub const fn vortex_array::dtype::i256::into_parts(self) -> (u128, i128)
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zero(&mut self)
 
-pub fn vortex_array::dtype::i256::maybe_i128(self) -> core::option::Option<i128>
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zeros(&mut self, n: usize)
 
-pub const fn vortex_array::dtype::i256::to_be_bytes(&self) -> [u8; 32]
+pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any(&self) -> &dyn core::any::Any
 
-pub const fn vortex_array::dtype::i256::to_le_bytes(&self) -> [u8; 32]
+pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub const fn vortex_array::dtype::i256::to_parts(&self) -> (u128, i128)
+pub fn vortex_array::builders::ListViewBuilder<O, S>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::i256::wrapping_add(&self, other: Self) -> Self
+pub fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::i256::wrapping_pow(&self, exp: u32) -> Self
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl core::clone::Clone for vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::i256::clone(&self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl core::cmp::Eq for vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::is_empty(&self) -> bool
 
-impl core::cmp::Ord for vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::len(&self) -> usize
 
-pub fn vortex_array::dtype::i256::cmp(&self, other: &vortex_array::dtype::i256) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListViewBuilder<O, S>::reserve_exact(&mut self, capacity: usize)
 
-impl core::cmp::PartialEq for vortex_array::dtype::i256
+pub fn vortex_array::builders::ListViewBuilder<O, S>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::eq(&self, other: &vortex_array::dtype::i256) -> bool
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl core::cmp::PartialOrd for vortex_array::dtype::i256
+pub struct vortex_array::builders::NullBuilder
 
-pub fn vortex_array::dtype::i256::partial_cmp(&self, other: &vortex_array::dtype::i256) -> core::option::Option<core::cmp::Ordering>
+impl vortex_array::builders::NullBuilder
 
-impl core::convert::From<arrow_buffer::bigint::i256> for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::new() -> Self
 
-pub fn vortex_array::dtype::i256::from(i: arrow_buffer::bigint::i256) -> Self
+impl core::default::Default for vortex_array::builders::NullBuilder
 
-impl core::convert::From<vortex_array::dtype::i256> for arrow_buffer::bigint::i256
+pub fn vortex_array::builders::NullBuilder::default() -> Self
 
-pub fn arrow_buffer::bigint::i256::from(i: vortex_array::dtype::i256) -> Self
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::NullBuilder
 
-impl core::convert::From<vortex_array::dtype::i256> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::builders::NullBuilder::append_default(&mut self)
 
-pub fn vortex_array::scalar::DecimalValue::from(value: vortex_array::dtype::i256) -> Self
+pub fn vortex_array::builders::NullBuilder::append_defaults(&mut self, n: usize)
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::append_null(&mut self)
 
-pub type vortex_array::dtype::i256::Error = vortex_error::VortexError
+pub fn vortex_array::builders::NullBuilder::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub unsafe fn vortex_array::builders::NullBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl core::default::Default for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::i256::default() -> vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::append_zero(&mut self)
 
-impl core::fmt::Debug for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::NullBuilder::as_any(&self) -> &dyn core::any::Any
 
-impl core::fmt::Display for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn vortex_array::dtype::i256::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::builders::NullBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::hash::Hash for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::i256::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub unsafe fn vortex_array::builders::NullBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl core::marker::Copy for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-impl core::marker::StructuralPartialEq for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl core::ops::arith::Add for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::is_empty(&self) -> bool
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::i256::add(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::NullBuilder::reserve_exact(&mut self, _additional: usize)
 
-impl core::ops::arith::AddAssign for vortex_array::dtype::i256
+pub fn vortex_array::builders::NullBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::add_assign(&mut self, rhs: Self)
+pub unsafe fn vortex_array::builders::NullBuilder::set_validity_unchecked(&mut self, _validity: vortex_mask::Mask)
 
-impl core::ops::arith::Div for vortex_array::dtype::i256
+pub struct vortex_array::builders::PrimitiveBuilder<T>
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+impl<T: vortex_array::dtype::NativePType> vortex_array::builders::PrimitiveBuilder<T>
 
-pub fn vortex_array::dtype::i256::div(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_n_values(&mut self, value: T, n: usize)
 
-impl core::ops::arith::Mul for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_value(&mut self, value: T)
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::extend_with_iterator(&mut self, iter: impl core::iter::traits::collect::IntoIterator<Item = T>, mask: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::mul(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_primitive(&mut self) -> vortex_array::arrays::PrimitiveArray
 
-impl core::ops::arith::Neg for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::new(nullability: vortex_array::dtype::Nullability) -> Self
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::uninit_range(&mut self, len: usize) -> vortex_array::builders::UninitRange<'_, T>
 
-pub fn vortex_array::dtype::i256::neg(self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::values(&self) -> &[T]
 
-impl core::ops::arith::Rem for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::values_mut(&mut self) -> &mut [T]
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::with_capacity(nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
 
-pub fn vortex_array::dtype::i256::rem(self, rhs: Self) -> Self::Output
+impl<T: vortex_array::dtype::NativePType> vortex_array::builders::ArrayBuilder for vortex_array::builders::PrimitiveBuilder<T>
 
-impl core::ops::arith::Sub for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_default(&mut self)
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::sub(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_null(&mut self)
 
-impl core::ops::bit::BitOr for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls(&mut self, n: usize)
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::bitor(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl core::ops::bit::Shl<usize> for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zero(&mut self)
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::shl(self, rhs: usize) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any(&self) -> &dyn core::any::Any
 
-impl core::ops::bit::Shr for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::dtype::i256::shr(self, rhs: Self) -> Self::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl num_traits::cast::AsPrimitive<i128> for vortex_array::dtype::i256
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::i256::as_(self) -> i128
+pub fn vortex_array::builders::PrimitiveBuilder<T>::finish(&mut self) -> vortex_array::ArrayRef
 
-impl num_traits::cast::AsPrimitive<i16> for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn vortex_array::dtype::i256::as_(self) -> i16
+pub fn vortex_array::builders::PrimitiveBuilder<T>::is_empty(&self) -> bool
 
-impl num_traits::cast::AsPrimitive<i32> for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::len(&self) -> usize
 
-pub fn vortex_array::dtype::i256::as_(self) -> i32
+pub fn vortex_array::builders::PrimitiveBuilder<T>::reserve_exact(&mut self, additional: usize)
 
-impl num_traits::cast::AsPrimitive<i64> for vortex_array::dtype::i256
+pub fn vortex_array::builders::PrimitiveBuilder<T>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::as_(self) -> i64
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl num_traits::cast::AsPrimitive<i8> for vortex_array::dtype::i256
+pub struct vortex_array::builders::StructBuilder
 
-pub fn vortex_array::dtype::i256::as_(self) -> i8
+impl vortex_array::builders::StructBuilder
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i128
+pub fn vortex_array::builders::StructBuilder::append_value(&mut self, struct_scalar: vortex_array::scalar::StructScalar<'_>) -> vortex_error::VortexResult<()>
 
-pub fn i128::as_(self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::finish_into_struct(&mut self) -> vortex_array::arrays::StructArray
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i16
+pub fn vortex_array::builders::StructBuilder::new(struct_dtype: vortex_array::dtype::StructFields, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn i16::as_(self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::struct_fields(&self) -> &vortex_array::dtype::StructFields
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i32
+pub fn vortex_array::builders::StructBuilder::with_capacity(struct_dtype: vortex_array::dtype::StructFields, nullability: vortex_array::dtype::Nullability, capacity: usize) -> Self
 
-pub fn i32::as_(self) -> vortex_array::dtype::i256
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::StructBuilder
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i64
+pub fn vortex_array::builders::StructBuilder::append_default(&mut self)
 
-pub fn i64::as_(self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::append_defaults(&mut self, n: usize)
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i8
+pub fn vortex_array::builders::StructBuilder::append_null(&mut self)
 
-pub fn i8::as_(self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::append_nulls(&mut self, n: usize)
 
-impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for vortex_array::dtype::i256
+pub unsafe fn vortex_array::builders::StructBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::as_(self) -> vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl num_traits::cast::ToPrimitive for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::append_zero(&mut self)
 
-pub fn vortex_array::dtype::i256::to_i128(&self) -> core::option::Option<i128>
+pub fn vortex_array::builders::StructBuilder::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::to_i64(&self) -> core::option::Option<i64>
+pub fn vortex_array::builders::StructBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::i256::to_u128(&self) -> core::option::Option<u128>
+pub fn vortex_array::builders::StructBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn vortex_array::dtype::i256::to_u64(&self) -> core::option::Option<u64>
+pub fn vortex_array::builders::StructBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-impl num_traits::identities::ConstZero for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub const vortex_array::dtype::i256::ZERO: Self
+pub unsafe fn vortex_array::builders::StructBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl num_traits::identities::One for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::i256::one() -> Self
+pub fn vortex_array::builders::StructBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl num_traits::identities::Zero for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::is_empty(&self) -> bool
 
-pub fn vortex_array::dtype::i256::is_zero(&self) -> bool
+pub fn vortex_array::builders::StructBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::i256::zero() -> Self
+pub fn vortex_array::builders::StructBuilder::reserve_exact(&mut self, capacity: usize)
 
-impl num_traits::ops::checked::CheckedAdd for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::checked_add(&self, v: &Self) -> core::option::Option<Self>
+pub unsafe fn vortex_array::builders::StructBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl num_traits::ops::checked::CheckedDiv for vortex_array::dtype::i256
+pub struct vortex_array::builders::UninitRange<'a, T>
 
-pub fn vortex_array::dtype::i256::checked_div(&self, v: &Self) -> core::option::Option<Self>
+impl<T> vortex_array::builders::UninitRange<'_, T>
 
-impl num_traits::ops::checked::CheckedMul for vortex_array::dtype::i256
+pub unsafe fn vortex_array::builders::UninitRange<'_, T>::append_mask(&mut self, mask: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::checked_mul(&self, v: &Self) -> core::option::Option<Self>
+pub fn vortex_array::builders::UninitRange<'_, T>::copy_from_slice(&mut self, local_offset: usize, src: &[T]) where T: core::marker::Copy
 
-impl num_traits::ops::checked::CheckedSub for vortex_array::dtype::i256
+pub unsafe fn vortex_array::builders::UninitRange<'_, T>::finish(self)
 
-pub fn vortex_array::dtype::i256::checked_sub(&self, v: &Self) -> core::option::Option<Self>
+pub fn vortex_array::builders::UninitRange<'_, T>::is_empty(&self) -> bool
 
-impl num_traits::ops::wrapping::WrappingAdd for vortex_array::dtype::i256
+pub fn vortex_array::builders::UninitRange<'_, T>::len(&self) -> usize
 
-pub fn vortex_array::dtype::i256::wrapping_add(&self, v: &Self) -> Self
+pub fn vortex_array::builders::UninitRange<'_, T>::set_validity_bit(&mut self, index: usize, v: bool)
 
-impl num_traits::ops::wrapping::WrappingSub for vortex_array::dtype::i256
+pub fn vortex_array::builders::UninitRange<'_, T>::set_value(&mut self, index: usize, value: T)
 
-pub fn vortex_array::dtype::i256::wrapping_sub(&self, v: &Self) -> Self
+pub unsafe fn vortex_array::builders::UninitRange<'_, T>::slice_uninit_mut(&mut self, offset: usize, len: usize) -> &mut [core::mem::maybe_uninit::MaybeUninit<T>]
 
-impl vortex_array::dtype::BigCast for vortex_array::dtype::i256
+pub struct vortex_array::builders::VarBinViewBuilder
 
-pub fn vortex_array::dtype::i256::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+impl vortex_array::builders::VarBinViewBuilder
 
-impl vortex_array::dtype::NativeDecimalType for vortex_array::dtype::i256
+pub fn vortex_array::builders::VarBinViewBuilder::append_n_values<S: core::convert::AsRef<[u8]>>(&mut self, value: S, n: usize)
 
-pub const vortex_array::dtype::i256::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::VarBinViewBuilder::append_value<S: core::convert::AsRef<[u8]>>(&mut self, value: S)
 
-pub const vortex_array::dtype::i256::MAX_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::VarBinViewBuilder::completed_block_count(&self) -> u32
 
-pub const vortex_array::dtype::i256::MAX_PRECISION: u8
+pub fn vortex_array::builders::VarBinViewBuilder::finish_into_varbinview(&mut self) -> vortex_array::arrays::VarBinViewArray
 
-pub const vortex_array::dtype::i256::MAX_SCALE: i8
+pub fn vortex_array::builders::VarBinViewBuilder::in_progress(&self) -> bool
 
-pub const vortex_array::dtype::i256::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::VarBinViewBuilder::new(dtype: vortex_array::dtype::DType, capacity: usize, completed: vortex_array::builders::CompletedBuffers, growth_strategy: vortex_array::builders::BufferGrowthStrategy, compaction_threshold: f64) -> Self
 
-pub fn vortex_array::dtype::i256::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::VarBinViewBuilder::push_buffer_and_adjusted_views(&mut self, buffers: &[vortex_buffer::ByteBuffer], views: &vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, validity_mask: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::i256::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::VarBinViewBuilder::with_buffer_deduplication(dtype: vortex_array::dtype::DType, capacity: usize) -> Self
 
-impl vortex_array::dtype::ToI256 for vortex_array::dtype::i256
+pub fn vortex_array::builders::VarBinViewBuilder::with_capacity(dtype: vortex_array::dtype::DType, capacity: usize) -> Self
 
-pub fn vortex_array::dtype::i256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_array::builders::VarBinViewBuilder::with_compaction(dtype: vortex_array::dtype::DType, capacity: usize, compaction_threshold: f64) -> Self
 
-pub const vortex_array::dtype::MAX_PRECISION: u8
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::VarBinViewBuilder
 
-pub const vortex_array::dtype::MAX_SCALE: i8
+pub fn vortex_array::builders::VarBinViewBuilder::append_default(&mut self)
 
-pub trait vortex_array::dtype::BigCast: core::marker::Sized + num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256
+pub fn vortex_array::builders::VarBinViewBuilder::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::BigCast::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::append_null(&mut self)
 
-impl vortex_array::dtype::BigCast for i128
+pub fn vortex_array::builders::VarBinViewBuilder::append_nulls(&mut self, n: usize)
 
-pub fn i128::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl vortex_array::dtype::BigCast for i16
+pub fn vortex_array::builders::VarBinViewBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn i16::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::append_zero(&mut self)
 
-impl vortex_array::dtype::BigCast for i32
+pub fn vortex_array::builders::VarBinViewBuilder::append_zeros(&mut self, n: usize)
 
-pub fn i32::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::as_any(&self) -> &dyn core::any::Any
 
-impl vortex_array::dtype::BigCast for i64
+pub fn vortex_array::builders::VarBinViewBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn i64::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-impl vortex_array::dtype::BigCast for i8
+pub fn vortex_array::builders::VarBinViewBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i8::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::BigCast for u128
+pub fn vortex_array::builders::VarBinViewBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn u128::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl vortex_array::dtype::BigCast for u16
+pub fn vortex_array::builders::VarBinViewBuilder::is_empty(&self) -> bool
 
-pub fn u16::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::len(&self) -> usize
 
-impl vortex_array::dtype::BigCast for u32
+pub fn vortex_array::builders::VarBinViewBuilder::reserve_exact(&mut self, additional: usize)
 
-pub fn u32::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::VarBinViewBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-impl vortex_array::dtype::BigCast for u64
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn u64::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub const vortex_array::builders::DEFAULT_BUILDER_CAPACITY: usize
 
-impl vortex_array::dtype::BigCast for u8
+pub trait vortex_array::builders::ArrayBuilder: core::marker::Send
 
-pub fn u8::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::ArrayBuilder::append_default(&mut self)
 
-impl vortex_array::dtype::BigCast for vortex_array::dtype::i256
+pub fn vortex_array::builders::ArrayBuilder::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::i256::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+pub fn vortex_array::builders::ArrayBuilder::append_null(&mut self)
 
-pub trait vortex_array::dtype::DecimalTypeDowncast
+pub fn vortex_array::builders::ArrayBuilder::append_nulls(&mut self, n: usize)
 
-pub type vortex_array::dtype::DecimalTypeDowncast::Output<T: vortex_array::dtype::NativeDecimalType>
+pub unsafe fn vortex_array::builders::ArrayBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i128(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i16(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::append_zero(&mut self)
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i256(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i32(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i64(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn vortex_array::dtype::DecimalTypeDowncast::into_i8(self) -> Self::Output
+pub fn vortex_array::builders::ArrayBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub trait vortex_array::dtype::DecimalTypeUpcast
+pub fn vortex_array::builders::ArrayBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub type vortex_array::dtype::DecimalTypeUpcast::Input<T: vortex_array::dtype::NativeDecimalType>
+pub unsafe fn vortex_array::builders::ArrayBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i128(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i16(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i256(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::is_empty(&self) -> bool
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i32(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::len(&self) -> usize
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i64(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::reserve_exact(&mut self, additional: usize)
 
-pub fn vortex_array::dtype::DecimalTypeUpcast::from_i8(input: Self::Input) -> Self
+pub fn vortex_array::builders::ArrayBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub trait vortex_array::dtype::FromPrimitiveOrF16: num_traits::cast::FromPrimitive
+pub unsafe fn vortex_array::builders::ArrayBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::FromPrimitiveOrF16::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::BoolBuilder
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for f32
+pub fn vortex_array::builders::BoolBuilder::append_default(&mut self)
 
-pub fn f32::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::append_defaults(&mut self, n: usize)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for f64
+pub fn vortex_array::builders::BoolBuilder::append_null(&mut self)
 
-pub fn f64::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::append_nulls(&mut self, n: usize)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for half::binary16::f16
+pub unsafe fn vortex_array::builders::BoolBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn half::binary16::f16::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for i16
+pub fn vortex_array::builders::BoolBuilder::append_zero(&mut self)
 
-pub fn i16::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::append_zeros(&mut self, n: usize)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for i32
+pub fn vortex_array::builders::BoolBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn i32::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for i64
+pub fn vortex_array::builders::BoolBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn i64::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for i8
+pub unsafe fn vortex_array::builders::BoolBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i8::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for u16
+pub fn vortex_array::builders::BoolBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn u16::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::is_empty(&self) -> bool
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for u32
+pub fn vortex_array::builders::BoolBuilder::len(&self) -> usize
 
-pub fn u32::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::BoolBuilder::reserve_exact(&mut self, additional: usize)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for u64
+pub fn vortex_array::builders::BoolBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn u64::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+pub unsafe fn vortex_array::builders::BoolBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for u8
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::DecimalBuilder
 
-pub fn u8::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::DecimalBuilder::append_default(&mut self)
 
-impl vortex_array::dtype::FromPrimitiveOrF16 for usize
+pub fn vortex_array::builders::DecimalBuilder::append_defaults(&mut self, n: usize)
 
-pub fn usize::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+pub fn vortex_array::builders::DecimalBuilder::append_null(&mut self)
 
-pub trait vortex_array::dtype::IntegerPType: vortex_array::dtype::NativePType + num_traits::int::PrimInt + num_traits::cast::ToPrimitive + num_traits::bounds::Bounded + core::ops::arith::AddAssign + num_traits::cast::AsPrimitive<usize>
+pub fn vortex_array::builders::DecimalBuilder::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::IntegerPType::max_value_as_u64() -> u64
+pub unsafe fn vortex_array::builders::DecimalBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl<T> vortex_array::dtype::IntegerPType for T where T: vortex_array::dtype::NativePType + num_traits::int::PrimInt + num_traits::cast::ToPrimitive + num_traits::bounds::Bounded + core::ops::arith::AddAssign + num_traits::cast::AsPrimitive<usize>
+pub fn vortex_array::builders::DecimalBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::dtype::NativeDType
+pub fn vortex_array::builders::DecimalBuilder::append_zero(&mut self)
 
-pub fn vortex_array::dtype::NativeDType::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::append_zeros(&mut self, n: usize)
 
-impl vortex_array::dtype::NativeDType for &[u8]
+pub fn vortex_array::builders::DecimalBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn &[u8]::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl vortex_array::dtype::NativeDType for &str
+pub fn vortex_array::builders::DecimalBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn &str::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::NativeDType for alloc::string::String
+pub unsafe fn vortex_array::builders::DecimalBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn alloc::string::String::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-impl vortex_array::dtype::NativeDType for bool
+pub fn vortex_array::builders::DecimalBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn bool::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::is_empty(&self) -> bool
 
-impl vortex_array::dtype::NativeDType for f32
+pub fn vortex_array::builders::DecimalBuilder::len(&self) -> usize
 
-pub fn f32::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::DecimalBuilder::reserve_exact(&mut self, additional: usize)
 
-impl vortex_array::dtype::NativeDType for f64
+pub fn vortex_array::builders::DecimalBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn f64::dtype() -> vortex_array::dtype::DType
+pub unsafe fn vortex_array::builders::DecimalBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-impl vortex_array::dtype::NativeDType for half::binary16::f16
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::ExtensionBuilder
 
-pub fn half::binary16::f16::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::append_default(&mut self)
 
-impl vortex_array::dtype::NativeDType for i16
+pub fn vortex_array::builders::ExtensionBuilder::append_defaults(&mut self, n: usize)
 
-pub fn i16::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::append_null(&mut self)
 
-impl vortex_array::dtype::NativeDType for i32
+pub fn vortex_array::builders::ExtensionBuilder::append_nulls(&mut self, n: usize)
 
-pub fn i32::dtype() -> vortex_array::dtype::DType
+pub unsafe fn vortex_array::builders::ExtensionBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl vortex_array::dtype::NativeDType for i64
+pub fn vortex_array::builders::ExtensionBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn i64::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::append_zero(&mut self)
 
-impl vortex_array::dtype::NativeDType for i8
+pub fn vortex_array::builders::ExtensionBuilder::append_zeros(&mut self, n: usize)
 
-pub fn i8::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::as_any(&self) -> &dyn core::any::Any
 
-impl vortex_array::dtype::NativeDType for u16
+pub fn vortex_array::builders::ExtensionBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn u16::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-impl vortex_array::dtype::NativeDType for u32
+pub fn vortex_array::builders::ExtensionBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn u32::dtype() -> vortex_array::dtype::DType
+pub unsafe fn vortex_array::builders::ExtensionBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::NativeDType for u64
+pub fn vortex_array::builders::ExtensionBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn u64::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl vortex_array::dtype::NativeDType for u8
+pub fn vortex_array::builders::ExtensionBuilder::is_empty(&self) -> bool
 
-pub fn u8::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::len(&self) -> usize
 
-impl vortex_array::dtype::NativeDType for vortex_buffer::ByteBuffer
+pub fn vortex_array::builders::ExtensionBuilder::reserve_exact(&mut self, capacity: usize)
 
-pub fn vortex_buffer::ByteBuffer::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::ExtensionBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-impl<T> vortex_array::dtype::NativeDType for alloc::vec::Vec<T> where T: vortex_array::dtype::NativeDType
+pub unsafe fn vortex_array::builders::ExtensionBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn alloc::vec::Vec<T>::dtype() -> vortex_array::dtype::DType
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::FixedSizeListBuilder
 
-impl<T> vortex_array::dtype::NativeDType for core::option::Option<T> where T: vortex_array::dtype::NativeDType
+pub fn vortex_array::builders::FixedSizeListBuilder::append_default(&mut self)
 
-pub fn core::option::Option<T>::dtype() -> vortex_array::dtype::DType
+pub fn vortex_array::builders::FixedSizeListBuilder::append_defaults(&mut self, n: usize)
 
-pub trait vortex_array::dtype::NativeDecimalType: core::marker::Send + core::marker::Sync + core::clone::Clone + core::marker::Copy + core::fmt::Debug + core::fmt::Display + core::default::Default + core::panic::unwind_safe::RefUnwindSafe + core::cmp::Eq + core::cmp::Ord + vortex_array::dtype::BigCast + 'static
+pub fn vortex_array::builders::FixedSizeListBuilder::append_null(&mut self)
 
-pub const vortex_array::dtype::NativeDecimalType::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::FixedSizeListBuilder::append_nulls(&mut self, n: usize)
 
-pub const vortex_array::dtype::NativeDecimalType::MAX_BY_PRECISION: &'static [Self]
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub const vortex_array::dtype::NativeDecimalType::MAX_PRECISION: u8
+pub fn vortex_array::builders::FixedSizeListBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub const vortex_array::dtype::NativeDecimalType::MAX_SCALE: i8
+pub fn vortex_array::builders::FixedSizeListBuilder::append_zero(&mut self)
 
-pub const vortex_array::dtype::NativeDecimalType::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::FixedSizeListBuilder::append_zeros(&mut self, n: usize)
 
-pub fn vortex_array::dtype::NativeDecimalType::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::FixedSizeListBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::dtype::NativeDecimalType::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::FixedSizeListBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl vortex_array::dtype::NativeDecimalType for i128
+pub fn vortex_array::builders::FixedSizeListBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub const i128::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::FixedSizeListBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub const i128::MAX_BY_PRECISION: &'static [Self]
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub const i128::MAX_PRECISION: u8
+pub fn vortex_array::builders::FixedSizeListBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub const i128::MAX_SCALE: i8
+pub fn vortex_array::builders::FixedSizeListBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub const i128::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::FixedSizeListBuilder::is_empty(&self) -> bool
 
-pub fn i128::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::FixedSizeListBuilder::len(&self) -> usize
 
-pub fn i128::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::FixedSizeListBuilder::reserve_exact(&mut self, additional: usize)
 
-impl vortex_array::dtype::NativeDecimalType for i16
+pub fn vortex_array::builders::FixedSizeListBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub const i16::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub unsafe fn vortex_array::builders::FixedSizeListBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub const i16::MAX_BY_PRECISION: &'static [Self]
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::NullBuilder
 
-pub const i16::MAX_PRECISION: u8
+pub fn vortex_array::builders::NullBuilder::append_default(&mut self)
 
-pub const i16::MAX_SCALE: i8
+pub fn vortex_array::builders::NullBuilder::append_defaults(&mut self, n: usize)
 
-pub const i16::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::NullBuilder::append_null(&mut self)
 
-pub fn i16::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::NullBuilder::append_nulls(&mut self, n: usize)
 
-pub fn i16::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub unsafe fn vortex_array::builders::NullBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-impl vortex_array::dtype::NativeDecimalType for i32
+pub fn vortex_array::builders::NullBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub const i32::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::NullBuilder::append_zero(&mut self)
 
-pub const i32::MAX_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::NullBuilder::append_zeros(&mut self, n: usize)
 
-pub const i32::MAX_PRECISION: u8
+pub fn vortex_array::builders::NullBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub const i32::MAX_SCALE: i8
+pub fn vortex_array::builders::NullBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub const i32::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::NullBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn i32::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::NullBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i32::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub unsafe fn vortex_array::builders::NullBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::NativeDecimalType for i64
+pub fn vortex_array::builders::NullBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub const i64::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::NullBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub const i64::MAX_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::NullBuilder::is_empty(&self) -> bool
 
-pub const i64::MAX_PRECISION: u8
+pub fn vortex_array::builders::NullBuilder::len(&self) -> usize
 
-pub const i64::MAX_SCALE: i8
+pub fn vortex_array::builders::NullBuilder::reserve_exact(&mut self, _additional: usize)
 
-pub const i64::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::NullBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn i64::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub unsafe fn vortex_array::builders::NullBuilder::set_validity_unchecked(&mut self, _validity: vortex_mask::Mask)
 
-pub fn i64::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::StructBuilder
 
-impl vortex_array::dtype::NativeDecimalType for i8
+pub fn vortex_array::builders::StructBuilder::append_default(&mut self)
 
-pub const i8::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::StructBuilder::append_defaults(&mut self, n: usize)
 
-pub const i8::MAX_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::StructBuilder::append_null(&mut self)
 
-pub const i8::MAX_PRECISION: u8
+pub fn vortex_array::builders::StructBuilder::append_nulls(&mut self, n: usize)
 
-pub const i8::MAX_SCALE: i8
+pub unsafe fn vortex_array::builders::StructBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub const i8::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::StructBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn i8::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::StructBuilder::append_zero(&mut self)
 
-pub fn i8::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::StructBuilder::append_zeros(&mut self, n: usize)
 
-impl vortex_array::dtype::NativeDecimalType for vortex_array::dtype::i256
+pub fn vortex_array::builders::StructBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub const vortex_array::dtype::i256::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+pub fn vortex_array::builders::StructBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub const vortex_array::dtype::i256::MAX_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::StructBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub const vortex_array::dtype::i256::MAX_PRECISION: u8
+pub fn vortex_array::builders::StructBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub const vortex_array::dtype::i256::MAX_SCALE: i8
+pub unsafe fn vortex_array::builders::StructBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub const vortex_array::dtype::i256::MIN_BY_PRECISION: &'static [Self]
+pub fn vortex_array::builders::StructBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::i256::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+pub fn vortex_array::builders::StructBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn vortex_array::dtype::i256::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::StructBuilder::is_empty(&self) -> bool
 
-pub trait vortex_array::dtype::NativePType: core::marker::Send + core::marker::Sync + core::clone::Clone + core::marker::Copy + core::fmt::Debug + core::fmt::Display + core::default::Default + core::panic::unwind_safe::RefUnwindSafe + num_traits::Num + num_traits::cast::NumCast + vortex_array::dtype::FromPrimitiveOrF16 + vortex_array::dtype::ToBytes + vortex_array::dtype::TryFromBytes + vortex_array::dtype::ptype::private::Sealed + 'static
+pub fn vortex_array::builders::StructBuilder::len(&self) -> usize
 
-pub const vortex_array::dtype::NativePType::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::StructBuilder::reserve_exact(&mut self, capacity: usize)
 
-pub fn vortex_array::dtype::NativePType::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::StructBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::NativePType::is_eq(self, other: Self) -> bool
+pub unsafe fn vortex_array::builders::StructBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn vortex_array::dtype::NativePType::is_ge(self, other: Self) -> bool
+impl vortex_array::builders::ArrayBuilder for vortex_array::builders::VarBinViewBuilder
 
-pub fn vortex_array::dtype::NativePType::is_gt(self, other: Self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::append_default(&mut self)
 
-pub fn vortex_array::dtype::NativePType::is_infinite(self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::append_defaults(&mut self, n: usize)
 
-pub fn vortex_array::dtype::NativePType::is_le(self, other: Self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::append_null(&mut self)
 
-pub fn vortex_array::dtype::NativePType::is_lt(self, other: Self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::append_nulls(&mut self, n: usize)
 
-pub fn vortex_array::dtype::NativePType::is_nan(self) -> bool
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn vortex_array::dtype::NativePType::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::VarBinViewBuilder::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::dtype::NativePType::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::VarBinViewBuilder::append_zero(&mut self)
 
-impl vortex_array::dtype::NativePType for f32
+pub fn vortex_array::builders::VarBinViewBuilder::append_zeros(&mut self, n: usize)
 
-pub const f32::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::VarBinViewBuilder::as_any(&self) -> &dyn core::any::Any
 
-pub fn f32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::VarBinViewBuilder::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn f32::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn f32::is_infinite(self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn f32::is_nan(self) -> bool
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn f32::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::VarBinViewBuilder::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn f32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::VarBinViewBuilder::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-impl vortex_array::dtype::NativePType for f64
+pub fn vortex_array::builders::VarBinViewBuilder::is_empty(&self) -> bool
 
-pub const f64::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::VarBinViewBuilder::len(&self) -> usize
 
-pub fn f64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::VarBinViewBuilder::reserve_exact(&mut self, additional: usize)
 
-pub fn f64::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::VarBinViewBuilder::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn f64::is_infinite(self) -> bool
+pub unsafe fn vortex_array::builders::VarBinViewBuilder::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn f64::is_nan(self) -> bool
+impl<O: vortex_array::dtype::IntegerPType, S: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListViewBuilder<O, S>
 
-pub fn f64::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_default(&mut self)
 
-pub fn f64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_defaults(&mut self, n: usize)
 
-impl vortex_array::dtype::NativePType for half::binary16::f16
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_null(&mut self)
 
-pub const half::binary16::f16::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls(&mut self, n: usize)
 
-pub fn half::binary16::f16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn half::binary16::f16::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn half::binary16::f16::is_infinite(self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zero(&mut self)
 
-pub fn half::binary16::f16::is_nan(self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::append_zeros(&mut self, n: usize)
 
-pub fn half::binary16::f16::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any(&self) -> &dyn core::any::Any
 
-pub fn half::binary16::f16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::ListViewBuilder<O, S>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-impl vortex_array::dtype::NativePType for i16
+pub fn vortex_array::builders::ListViewBuilder<O, S>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub const i16::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i16::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn i16::is_infinite(self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn i16::is_nan(self) -> bool
+pub fn vortex_array::builders::ListViewBuilder<O, S>::is_empty(&self) -> bool
 
-pub fn i16::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListViewBuilder<O, S>::len(&self) -> usize
 
-pub fn i16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::ListViewBuilder<O, S>::reserve_exact(&mut self, capacity: usize)
 
-impl vortex_array::dtype::NativePType for i32
+pub fn vortex_array::builders::ListViewBuilder<O, S>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub const i32::PTYPE: vortex_array::dtype::PType
+pub unsafe fn vortex_array::builders::ListViewBuilder<O, S>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn i32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+impl<O: vortex_array::dtype::IntegerPType> vortex_array::builders::ArrayBuilder for vortex_array::builders::ListBuilder<O>
 
-pub fn i32::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::append_default(&mut self)
 
-pub fn i32::is_infinite(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::append_defaults(&mut self, n: usize)
 
-pub fn i32::is_nan(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::append_null(&mut self)
 
-pub fn i32::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListBuilder<O>::append_nulls(&mut self, n: usize)
 
-pub fn i32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub unsafe fn vortex_array::builders::ListBuilder<O>::append_nulls_unchecked(&mut self, n: usize)
 
-impl vortex_array::dtype::NativePType for i64
+pub fn vortex_array::builders::ListBuilder<O>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub const i64::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::ListBuilder<O>::append_zero(&mut self)
 
-pub fn i64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::ListBuilder<O>::append_zeros(&mut self, n: usize)
 
-pub fn i64::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::as_any(&self) -> &dyn core::any::Any
 
-pub fn i64::is_infinite(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn i64::is_nan(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn i64::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::ListBuilder<O>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn i64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub unsafe fn vortex_array::builders::ListBuilder<O>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-impl vortex_array::dtype::NativePType for i8
+pub fn vortex_array::builders::ListBuilder<O>::finish(&mut self) -> vortex_array::ArrayRef
 
-pub const i8::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::ListBuilder<O>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn i8::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::ListBuilder<O>::is_empty(&self) -> bool
 
-pub fn i8::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::len(&self) -> usize
 
-pub fn i8::is_infinite(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::reserve_exact(&mut self, additional: usize)
 
-pub fn i8::is_nan(self) -> bool
+pub fn vortex_array::builders::ListBuilder<O>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn i8::total_compare(self, other: Self) -> core::cmp::Ordering
+pub unsafe fn vortex_array::builders::ListBuilder<O>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn i8::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+impl<T: vortex_array::dtype::NativePType> vortex_array::builders::ArrayBuilder for vortex_array::builders::PrimitiveBuilder<T>
 
-impl vortex_array::dtype::NativePType for u16
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_default(&mut self)
 
-pub const u16::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_defaults(&mut self, n: usize)
 
-pub fn u16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_null(&mut self)
 
-pub fn u16::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls(&mut self, n: usize)
 
-pub fn u16::is_infinite(self) -> bool
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::append_nulls_unchecked(&mut self, n: usize)
 
-pub fn u16::is_nan(self) -> bool
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_scalar(&mut self, scalar: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<()>
 
-pub fn u16::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zero(&mut self)
 
-pub fn u16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::PrimitiveBuilder<T>::append_zeros(&mut self, n: usize)
 
-impl vortex_array::dtype::NativePType for u32
+pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any(&self) -> &dyn core::any::Any
 
-pub const u32::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::PrimitiveBuilder<T>::as_any_mut(&mut self) -> &mut dyn core::any::Any
 
-pub fn u32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn u32::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn u32::is_infinite(self) -> bool
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::extend_from_array_unchecked(&mut self, array: &vortex_array::ArrayRef)
 
-pub fn u32::is_nan(self) -> bool
+pub fn vortex_array::builders::PrimitiveBuilder<T>::finish(&mut self) -> vortex_array::ArrayRef
 
-pub fn u32::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builders::PrimitiveBuilder<T>::finish_into_canonical(&mut self) -> vortex_array::Canonical
 
-pub fn u32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builders::PrimitiveBuilder<T>::is_empty(&self) -> bool
 
-impl vortex_array::dtype::NativePType for u64
+pub fn vortex_array::builders::PrimitiveBuilder<T>::len(&self) -> usize
 
-pub const u64::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builders::PrimitiveBuilder<T>::reserve_exact(&mut self, additional: usize)
 
-pub fn u64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builders::PrimitiveBuilder<T>::set_validity(&mut self, validity: vortex_mask::Mask)
 
-pub fn u64::is_eq(self, other: Self) -> bool
+pub unsafe fn vortex_array::builders::PrimitiveBuilder<T>::set_validity_unchecked(&mut self, validity: vortex_mask::Mask)
 
-pub fn u64::is_infinite(self) -> bool
+pub fn vortex_array::builders::builder_with_capacity(dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
 
-pub fn u64::is_nan(self) -> bool
+pub fn vortex_array::builders::builder_with_capacity_in(allocator: vortex_array::memory::HostAllocatorRef, dtype: &vortex_array::dtype::DType, capacity: usize) -> alloc::boxed::Box<dyn vortex_array::builders::ArrayBuilder>
 
-pub fn u64::total_compare(self, other: Self) -> core::cmp::Ordering
+pub mod vortex_array::builtins
 
-pub fn u64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub trait vortex_array::builtins::ArrayBuiltins: core::marker::Sized
 
-impl vortex_array::dtype::NativePType for u8
+pub fn vortex_array::builtins::ArrayBuiltins::between(self, lower: vortex_array::ArrayRef, upper: vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub const u8::PTYPE: vortex_array::dtype::PType
+pub fn vortex_array::builtins::ArrayBuiltins::binary(&self, rhs: vortex_array::ArrayRef, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+pub fn vortex_array::builtins::ArrayBuiltins::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::is_eq(self, other: Self) -> bool
+pub fn vortex_array::builtins::ArrayBuiltins::fill_null(&self, fill_value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::is_infinite(self) -> bool
+pub fn vortex_array::builtins::ArrayBuiltins::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::is_nan(self) -> bool
+pub fn vortex_array::builtins::ArrayBuiltins::is_null(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::total_compare(self, other: Self) -> core::cmp::Ordering
+pub fn vortex_array::builtins::ArrayBuiltins::list_contains(&self, value: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u8::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+pub fn vortex_array::builtins::ArrayBuiltins::mask(self, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub trait vortex_array::dtype::PTypeDowncast
+pub fn vortex_array::builtins::ArrayBuiltins::not(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::dtype::PTypeDowncast::Output<T: vortex_array::dtype::NativePType>
+pub fn vortex_array::builtins::ArrayBuiltins::zip(&self, if_true: vortex_array::ArrayRef, if_false: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_f16(self) -> Self::Output
+impl vortex_array::builtins::ArrayBuiltins for vortex_array::ArrayRef
 
-pub fn vortex_array::dtype::PTypeDowncast::into_f32(self) -> Self::Output
+pub fn vortex_array::ArrayRef::between(self, lower: vortex_array::ArrayRef, upper: vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_f64(self) -> Self::Output
+pub fn vortex_array::ArrayRef::binary(&self, rhs: vortex_array::ArrayRef, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_i16(self) -> Self::Output
+pub fn vortex_array::ArrayRef::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_i32(self) -> Self::Output
+pub fn vortex_array::ArrayRef::fill_null(&self, fill_value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_i64(self) -> Self::Output
+pub fn vortex_array::ArrayRef::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_i8(self) -> Self::Output
+pub fn vortex_array::ArrayRef::is_null(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_u16(self) -> Self::Output
+pub fn vortex_array::ArrayRef::list_contains(&self, value: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_u32(self) -> Self::Output
+pub fn vortex_array::ArrayRef::mask(self, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_u64(self) -> Self::Output
+pub fn vortex_array::ArrayRef::not(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::dtype::PTypeDowncast::into_u8(self) -> Self::Output
+pub fn vortex_array::ArrayRef::zip(&self, if_true: vortex_array::ArrayRef, if_false: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub trait vortex_array::dtype::PTypeDowncastExt: vortex_array::dtype::PTypeDowncast
+pub trait vortex_array::builtins::ExprBuiltins: core::marker::Sized
 
-pub fn vortex_array::dtype::PTypeDowncastExt::downcast<T: vortex_array::dtype::NativePType>(self) -> Self::Output where Self: core::marker::Sized
+pub fn vortex_array::builtins::ExprBuiltins::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
 
-impl<T: vortex_array::dtype::PTypeDowncast> vortex_array::dtype::PTypeDowncastExt for T
+pub fn vortex_array::builtins::ExprBuiltins::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::builtins::ExprBuiltins::zip(&self, if_true: vortex_array::expr::Expression, if_false: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+impl vortex_array::builtins::ExprBuiltins for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::zip(&self, if_true: vortex_array::expr::Expression, if_false: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub mod vortex_array::compute
+
+pub mod vortex_array::display
+
+pub enum vortex_array::display::DisplayOptions
+
+pub vortex_array::display::DisplayOptions::CommaSeparatedScalars
+
+pub vortex_array::display::DisplayOptions::CommaSeparatedScalars::omit_comma_after_space: bool
+
+pub vortex_array::display::DisplayOptions::MetadataOnly
+
+pub vortex_array::display::DisplayOptions::TreeDisplay
+
+pub vortex_array::display::DisplayOptions::TreeDisplay::buffers: bool
+
+pub vortex_array::display::DisplayOptions::TreeDisplay::metadata: bool
+
+pub vortex_array::display::DisplayOptions::TreeDisplay::stats: bool
+
+impl core::default::Default for vortex_array::display::DisplayOptions
+
+pub fn vortex_array::display::DisplayOptions::default() -> Self
+
+pub struct vortex_array::display::BufferExtractor
+
+pub vortex_array::display::BufferExtractor::show_percent: bool
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::BufferExtractor
+
+pub fn vortex_array::display::BufferExtractor::write_details(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::BufferExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::DisplayArrayAs<'a>(pub &'a vortex_array::ArrayRef, pub vortex_array::display::DisplayOptions)
+
+impl core::fmt::Display for vortex_array::display::DisplayArrayAs<'_>
+
+pub fn vortex_array::display::DisplayArrayAs<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::EncodingSummaryExtractor
+
+impl vortex_array::display::EncodingSummaryExtractor
+
+pub fn vortex_array::display::EncodingSummaryExtractor::write(array: &vortex_array::ArrayRef, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::EncodingSummaryExtractor
+
+pub fn vortex_array::display::EncodingSummaryExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::EncodingSummaryExtractor::write_header(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::IndentedFormatter<'a, 'b>
+
+impl<'a, 'b> vortex_array::display::IndentedFormatter<'a, 'b>
+
+pub fn vortex_array::display::IndentedFormatter<'a, 'b>::formatter(&mut self) -> &mut core::fmt::Formatter<'b>
+
+pub fn vortex_array::display::IndentedFormatter<'a, 'b>::indent(&self) -> &str
+
+pub fn vortex_array::display::IndentedFormatter<'a, 'b>::parts(&mut self) -> (&str, &mut core::fmt::Formatter<'b>)
+
+pub struct vortex_array::display::MetadataExtractor
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::MetadataExtractor
+
+pub fn vortex_array::display::MetadataExtractor::write_details(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::MetadataExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::NbytesExtractor
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::NbytesExtractor
+
+pub fn vortex_array::display::NbytesExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::NbytesExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::StatsExtractor
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::StatsExtractor
+
+pub fn vortex_array::display::StatsExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::StatsExtractor::write_header(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::display::TreeContext
+
+impl vortex_array::display::TreeContext
+
+pub fn vortex_array::display::TreeContext::parent_total_size(&self) -> core::option::Option<u64>
+
+pub struct vortex_array::display::TreeDisplay
+
+impl vortex_array::display::TreeDisplay
+
+pub fn vortex_array::display::TreeDisplay::default_display(array: vortex_array::ArrayRef) -> Self
+
+pub fn vortex_array::display::TreeDisplay::new(array: vortex_array::ArrayRef) -> Self
+
+pub fn vortex_array::display::TreeDisplay::with<E: vortex_array::display::TreeExtractor + 'static>(self, extractor: E) -> Self
+
+pub fn vortex_array::display::TreeDisplay::with_boxed(self, extractor: alloc::boxed::Box<dyn vortex_array::display::TreeExtractor>) -> Self
+
+impl core::fmt::Display for vortex_array::display::TreeDisplay
+
+pub fn vortex_array::display::TreeDisplay::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub trait vortex_array::display::TreeExtractor: core::marker::Send + core::marker::Sync
+
+pub fn vortex_array::display::TreeExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::TreeExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::BufferExtractor
+
+pub fn vortex_array::display::BufferExtractor::write_details(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::BufferExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::EncodingSummaryExtractor
+
+pub fn vortex_array::display::EncodingSummaryExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::EncodingSummaryExtractor::write_header(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::MetadataExtractor
+
+pub fn vortex_array::display::MetadataExtractor::write_details(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::MetadataExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::NbytesExtractor
+
+pub fn vortex_array::display::NbytesExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::NbytesExtractor::write_header(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::display::TreeExtractor for vortex_array::display::StatsExtractor
+
+pub fn vortex_array::display::StatsExtractor::write_details(&self, array: &vortex_array::ArrayRef, ctx: &vortex_array::display::TreeContext, f: &mut vortex_array::display::IndentedFormatter<'_, '_>) -> core::fmt::Result
+
+pub fn vortex_array::display::StatsExtractor::write_header(&self, array: &vortex_array::ArrayRef, _ctx: &vortex_array::display::TreeContext, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub mod vortex_array::dtype
+
+pub use vortex_array::dtype::half
+
+pub mod vortex_array::dtype::arrow
+
+pub trait vortex_array::dtype::arrow::FromArrowType<T>: core::marker::Sized
+
+pub fn vortex_array::dtype::arrow::FromArrowType::from_arrow(value: T) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::field::Field> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(field: &arrow_schema::field::Field) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::fields::Fields> for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::from_arrow(value: &arrow_schema::fields::Fields) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::schema::Schema> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(value: &arrow_schema::schema::Schema) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<(&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow((data_type, nullability): (&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<alloc::sync::Arc<arrow_schema::schema::Schema>> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(value: arrow_schema::schema::SchemaRef) -> Self
+
+pub trait vortex_array::dtype::arrow::TryFromArrowType<T>: core::marker::Sized
+
+pub fn vortex_array::dtype::arrow::TryFromArrowType::try_from_arrow(value: T) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+
+pub mod vortex_array::dtype::extension
+
+pub struct vortex_array::dtype::extension::ExtDType<V: vortex_array::dtype::extension::ExtVTable>
+
+impl<V: vortex_array::dtype::extension::ExtVTable + core::default::Default> vortex_array::dtype::extension::ExtDType<V>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::try_new(metadata: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::ExtDType<V>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::can_coerce_from(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::can_coerce_to(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::erased(self) -> vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::least_supertype(&self, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::metadata(&self) -> &<V as vortex_array::dtype::extension::ExtVTable>::Metadata
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::serialize_metadata(&self) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::storage_dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::try_with_vtable(vtable: V, metadata: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::validate_scalar_value(&self, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::vtable(&self) -> &V
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::with_nullability(&self, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDTypeRef
+
+impl<V: core::clone::Clone + vortex_array::dtype::extension::ExtVTable> core::clone::Clone for vortex_array::dtype::extension::ExtDType<V> where <V as vortex_array::dtype::extension::ExtVTable>::Metadata: core::clone::Clone
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::clone(&self) -> vortex_array::dtype::extension::ExtDType<V>
+
+impl<V: core::cmp::Eq + vortex_array::dtype::extension::ExtVTable> core::cmp::Eq for vortex_array::dtype::extension::ExtDType<V> where <V as vortex_array::dtype::extension::ExtVTable>::Metadata: core::cmp::Eq
+
+impl<V: core::cmp::PartialEq + vortex_array::dtype::extension::ExtVTable> core::cmp::PartialEq for vortex_array::dtype::extension::ExtDType<V> where <V as vortex_array::dtype::extension::ExtVTable>::Metadata: core::cmp::PartialEq
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::eq(&self, other: &vortex_array::dtype::extension::ExtDType<V>) -> bool
+
+impl<V: core::fmt::Debug + vortex_array::dtype::extension::ExtVTable> core::fmt::Debug for vortex_array::dtype::extension::ExtDType<V> where <V as vortex_array::dtype::extension::ExtVTable>::Metadata: core::fmt::Debug
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<V: core::hash::Hash + vortex_array::dtype::extension::ExtVTable> core::hash::Hash for vortex_array::dtype::extension::ExtDType<V> where <V as vortex_array::dtype::extension::ExtVTable>::Metadata: core::hash::Hash
+
+pub fn vortex_array::dtype::extension::ExtDType<V>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl<V: vortex_array::dtype::extension::ExtVTable> core::marker::StructuralPartialEq for vortex_array::dtype::extension::ExtDType<V>
+
+pub struct vortex_array::dtype::extension::ExtDTypeRef(_)
+
+impl vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::can_coerce_from(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::can_coerce_to(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::display_metadata(&self) -> impl core::fmt::Display + '_
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::eq_ignore_nullability(&self, other: &Self) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::is_nullable(&self) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::least_supertype(&self, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::nullability(&self) -> vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::serialize_metadata(&self) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::storage_dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::with_nullability(&self, nullability: vortex_array::dtype::Nullability) -> Self
+
+impl vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> alloc::sync::Arc<vortex_array::dtype::extension::ExtDType<V>>
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::is<M: vortex_array::dtype::extension::Matcher>(&self) -> bool
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::metadata<M: vortex_array::dtype::extension::Matcher>(&self) -> <M as vortex_array::dtype::extension::Matcher>::Match
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::metadata_opt<M: vortex_array::dtype::extension::Matcher>(&self) -> core::option::Option<<M as vortex_array::dtype::extension::Matcher>::Match>
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::try_downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> core::result::Result<alloc::sync::Arc<vortex_array::dtype::extension::ExtDType<V>>, vortex_array::dtype::extension::ExtDTypeRef>
+
+impl core::clone::Clone for vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::clone(&self) -> vortex_array::dtype::extension::ExtDTypeRef
+
+impl core::cmp::Eq for vortex_array::dtype::extension::ExtDTypeRef
+
+impl core::cmp::PartialEq for vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::eq(&self, other: &Self) -> bool
+
+impl core::fmt::Debug for vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::extension::ExtDTypeRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+pub trait vortex_array::dtype::extension::ExtDTypePlugin: 'static + core::marker::Send + core::marker::Sync + core::fmt::Debug
+
+pub fn vortex_array::dtype::extension::ExtDTypePlugin::deserialize(&self, data: &[u8], storage_dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDTypeRef>
+
+pub fn vortex_array::dtype::extension::ExtDTypePlugin::id(&self) -> vortex_array::dtype::extension::ExtId
+
+impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::ExtDTypePlugin for V
+
+pub fn V::deserialize(&self, data: &[u8], storage_dtype: vortex_array::dtype::DType) -> core::result::Result<vortex_array::dtype::extension::ExtDTypeRef, vortex_error::VortexError>
+
+pub fn V::id(&self) -> arcref::ArcRef<str>
+
+pub trait vortex_array::dtype::extension::ExtVTable: 'static + core::marker::Sized + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::cmp::Eq + core::hash::Hash
+
+pub type vortex_array::dtype::extension::ExtVTable::Metadata: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + core::cmp::Eq + core::hash::Hash
+
+pub type vortex_array::dtype::extension::ExtVTable::NativeValue<'a>: core::fmt::Display
+
+pub fn vortex_array::dtype::extension::ExtVTable::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtVTable::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::extension::ExtVTable::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::dtype::extension::ExtVTable::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::dtype::extension::ExtVTable::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::extension::ExtVTable::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::dtype::extension::ExtVTable::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::dtype::extension::ExtVTable::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::dtype::extension::ExtVTable::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Date
+
+pub type vortex_array::extension::datetime::Date::Metadata = vortex_array::extension::datetime::TimeUnit
+
+pub type vortex_array::extension::datetime::Date::NativeValue<'a> = vortex_array::extension::datetime::DateValue
+
+pub fn vortex_array::extension::datetime::Date::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Date::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Date::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Date::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Date::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Date::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Date::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Date::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Date::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Time
+
+pub type vortex_array::extension::datetime::Time::Metadata = vortex_array::extension::datetime::TimeUnit
+
+pub type vortex_array::extension::datetime::Time::NativeValue<'a> = vortex_array::extension::datetime::TimeValue
+
+pub fn vortex_array::extension::datetime::Time::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Time::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Time::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Time::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Time::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Time::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Time::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Time::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Time::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Timestamp
+
+pub type vortex_array::extension::datetime::Timestamp::Metadata = vortex_array::extension::datetime::TimestampOptions
+
+pub type vortex_array::extension::datetime::Timestamp::NativeValue<'a> = vortex_array::extension::datetime::TimestampValue<'a>
+
+pub fn vortex_array::extension::datetime::Timestamp::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Timestamp::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Timestamp::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Timestamp::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Timestamp::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Timestamp::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Timestamp::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Timestamp::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Timestamp::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::uuid::Uuid
+
+pub type vortex_array::extension::uuid::Uuid::Metadata = vortex_array::extension::uuid::UuidMetadata
+
+pub type vortex_array::extension::uuid::Uuid::NativeValue<'a> = uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::uuid::Uuid::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::uuid::Uuid::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::uuid::Uuid::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::uuid::Uuid::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::uuid::Uuid::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::uuid::Uuid::unpack_native<'a>(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::uuid::Uuid::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::uuid::Uuid::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub trait vortex_array::dtype::extension::Matcher
+
+pub type vortex_array::dtype::extension::Matcher::Match<'a>
+
+pub fn vortex_array::dtype::extension::Matcher::matches(item: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+
+pub fn vortex_array::dtype::extension::Matcher::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+impl vortex_array::dtype::extension::Matcher for vortex_array::extension::datetime::AnyTemporal
+
+pub type vortex_array::extension::datetime::AnyTemporal::Match<'a> = vortex_array::extension::datetime::TemporalMetadata<'a>
+
+pub fn vortex_array::extension::datetime::AnyTemporal::matches(item: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+
+pub fn vortex_array::extension::datetime::AnyTemporal::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::dtype::extension::Matcher for V
+
+pub type V::Match<'a> = &'a <V as vortex_array::dtype::extension::ExtVTable>::Metadata
+
+pub fn V::matches(ext_dtype: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+
+pub fn V::try_match<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<<V as vortex_array::dtype::extension::Matcher>::Match>
+
+pub type vortex_array::dtype::extension::ExtDTypePluginRef = alloc::sync::Arc<dyn vortex_array::dtype::extension::ExtDTypePlugin>
+
+pub type vortex_array::dtype::extension::ExtId = arcref::ArcRef<str>
+
+pub mod vortex_array::dtype::flatbuffers
+
+pub use vortex_array::dtype::flatbuffers::<<vortex_flatbuffers::dtype::*>>
+
+pub mod vortex_array::dtype::proto
+
+pub use vortex_array::dtype::proto::dtype
+
+pub mod vortex_array::dtype::serde
+
+pub mod vortex_array::dtype::session
+
+pub struct vortex_array::dtype::session::DTypeSession
+
+impl vortex_array::dtype::session::DTypeSession
+
+pub fn vortex_array::dtype::session::DTypeSession::register<V: vortex_array::dtype::extension::ExtVTable>(&self, vtable: V)
+
+pub fn vortex_array::dtype::session::DTypeSession::registry(&self) -> &vortex_array::dtype::session::ExtDTypeRegistry
+
+impl core::default::Default for vortex_array::dtype::session::DTypeSession
+
+pub fn vortex_array::dtype::session::DTypeSession::default() -> Self
+
+impl core::fmt::Debug for vortex_array::dtype::session::DTypeSession
+
+pub fn vortex_array::dtype::session::DTypeSession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub trait vortex_array::dtype::session::DTypeSessionExt: vortex_session::SessionExt
+
+pub fn vortex_array::dtype::session::DTypeSessionExt::dtypes(&self) -> vortex_session::Ref<'_, vortex_array::dtype::session::DTypeSession>
+
+impl<S: vortex_session::SessionExt> vortex_array::dtype::session::DTypeSessionExt for S
+
+pub fn S::dtypes(&self) -> vortex_session::Ref<'_, vortex_array::dtype::session::DTypeSession>
+
+pub type vortex_array::dtype::session::ExtDTypeRegistry = vortex_session::registry::Registry<vortex_array::dtype::extension::ExtDTypePluginRef>
+
+pub enum vortex_array::dtype::DType
+
+pub vortex_array::dtype::DType::Binary(vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Bool(vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Decimal(vortex_array::dtype::DecimalDType, vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Extension(vortex_array::dtype::extension::ExtDTypeRef)
+
+pub vortex_array::dtype::DType::FixedSizeList(alloc::sync::Arc<vortex_array::dtype::DType>, u32, vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::List(alloc::sync::Arc<vortex_array::dtype::DType>, vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Null
+
+pub vortex_array::dtype::DType::Primitive(vortex_array::dtype::PType, vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Struct(vortex_array::dtype::StructFields, vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Utf8(vortex_array::dtype::Nullability)
+
+pub vortex_array::dtype::DType::Variant(vortex_array::dtype::Nullability)
+
+impl vortex_array::dtype::DType
+
+pub const vortex_array::dtype::DType::BYTES: Self
+
+pub fn vortex_array::dtype::DType::as_any_size_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::as_decimal_opt(&self) -> core::option::Option<&vortex_array::dtype::DecimalDType>
+
+pub fn vortex_array::dtype::DType::as_extension(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::dtype::DType::as_extension_opt(&self) -> core::option::Option<&vortex_array::dtype::extension::ExtDTypeRef>
+
+pub fn vortex_array::dtype::DType::as_fixed_size_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::as_list_element_opt(&self) -> core::option::Option<&alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::as_nonnullable(&self) -> Self
+
+pub fn vortex_array::dtype::DType::as_nullable(&self) -> Self
+
+pub fn vortex_array::dtype::DType::as_ptype(&self) -> vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::DType::as_struct_fields(&self) -> &vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::DType::as_struct_fields_opt(&self) -> core::option::Option<&vortex_array::dtype::StructFields>
+
+pub fn vortex_array::dtype::DType::element_size(&self) -> core::option::Option<usize>
+
+pub fn vortex_array::dtype::DType::eq_ignore_nullability(&self, other: &Self) -> bool
+
+pub fn vortex_array::dtype::DType::eq_with_nullability_subset(&self, other: &Self) -> bool
+
+pub fn vortex_array::dtype::DType::eq_with_nullability_superset(&self, other: &Self) -> bool
+
+pub fn vortex_array::dtype::DType::into_any_size_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::into_decimal_opt(self) -> core::option::Option<vortex_array::dtype::DecimalDType>
+
+pub fn vortex_array::dtype::DType::into_fixed_size_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::into_list_element_opt(self) -> core::option::Option<alloc::sync::Arc<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::into_struct_fields(self) -> vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::DType::into_struct_fields_opt(self) -> core::option::Option<vortex_array::dtype::StructFields>
+
+pub fn vortex_array::dtype::DType::is_binary(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_boolean(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_decimal(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_extension(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_fixed_size_list(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_float(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_int(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_list(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_nested(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_nullable(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_primitive(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_signed_int(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_struct(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_unsigned_int(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_utf8(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_variant(&self) -> bool
+
+pub fn vortex_array::dtype::DType::list(dtype: impl core::convert::Into<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::dtype::DType::nullability(&self) -> vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::DType::struct_<I: core::iter::traits::collect::IntoIterator<Item = (impl core::convert::Into<vortex_array::dtype::FieldName>, impl core::convert::Into<vortex_array::dtype::FieldDType>)>>(iter: I, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::dtype::DType::union_nullability(&self, other: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::dtype::DType::with_nullability(&self, nullability: vortex_array::dtype::Nullability) -> Self
+
+impl vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::all_coercible_to(types: &[vortex_array::dtype::DType], target: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::DType::are_coercible(types: &[vortex_array::dtype::DType]) -> bool
+
+pub fn vortex_array::dtype::DType::can_coerce_from(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::DType::can_coerce_to(&self, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::DType::coerce_all_to(types: &[vortex_array::dtype::DType], target: &vortex_array::dtype::DType) -> core::option::Option<alloc::vec::Vec<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::coerce_to_supertype(types: &[vortex_array::dtype::DType]) -> core::option::Option<alloc::vec::Vec<vortex_array::dtype::DType>>
+
+pub fn vortex_array::dtype::DType::is_numeric(&self) -> bool
+
+pub fn vortex_array::dtype::DType::is_temporal(&self) -> bool
+
+pub fn vortex_array::dtype::DType::least_supertype(&self, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::DType::least_supertype_of(types: &[vortex_array::dtype::DType]) -> core::option::Option<vortex_array::dtype::DType>
+
+impl vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_flatbuffer(buffer: vortex_flatbuffers::FlatBuffer, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_proto(value: &vortex_proto::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::to_arrow_dtype(&self) -> vortex_error::VortexResult<arrow_schema::datatype::DataType>
+
+pub fn vortex_array::dtype::DType::to_arrow_schema(&self) -> vortex_error::VortexResult<arrow_schema::schema::Schema>
+
+impl core::clone::Clone for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::clone(&self) -> vortex_array::dtype::DType
+
+impl core::cmp::Eq for vortex_array::dtype::DType
+
+impl core::cmp::PartialEq for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::eq(&self, other: &vortex_array::dtype::DType) -> bool
+
+impl core::convert::From<vortex_array::dtype::DType> for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::DType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for &vortex_array::dtype::DType
+
+pub fn &vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+
+impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+
+pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalDType::try_from(value: &vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::PType
+
+pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::PType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_proto::dtype::DType
+
+pub type vortex_proto::dtype::DType::Error = vortex_error::VortexError
+
+pub fn vortex_proto::dtype::DType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+
+pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalDType::try_from(value: vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::DType
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::field::Field> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(field: &arrow_schema::field::Field) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::schema::Schema> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(value: &arrow_schema::schema::Schema) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<(&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow((data_type, nullability): (&arrow_schema::datatype::DataType, vortex_array::dtype::Nullability)) -> Self
+
+impl vortex_array::dtype::arrow::FromArrowType<alloc::sync::Arc<arrow_schema::schema::Schema>> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from_arrow(value: arrow_schema::schema::SchemaRef) -> Self
+
+impl vortex_flatbuffers::FlatBufferRoot for vortex_array::dtype::DType
+
+impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::dtype::DType
+
+pub type vortex_array::dtype::DType::Target<'a> = vortex_flatbuffers::dtype::DType<'a>
+
+pub fn vortex_array::dtype::DType::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
+
+#[repr(u8)] pub enum vortex_array::dtype::DecimalType
+
+pub vortex_array::dtype::DecimalType::I128 = 4
+
+pub vortex_array::dtype::DecimalType::I16 = 1
+
+pub vortex_array::dtype::DecimalType::I256 = 5
+
+pub vortex_array::dtype::DecimalType::I32 = 2
+
+pub vortex_array::dtype::DecimalType::I64 = 3
+
+pub vortex_array::dtype::DecimalType::I8 = 0
+
+impl vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::byte_width(&self) -> usize
+
+pub fn vortex_array::dtype::DecimalType::is_compatible_decimal_value_type(self, dtype: vortex_array::dtype::DecimalDType) -> bool
+
+pub fn vortex_array::dtype::DecimalType::smallest_decimal_value_type(decimal_dtype: &vortex_array::dtype::DecimalDType) -> vortex_array::dtype::DecimalType
+
+impl vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::from_i32(value: i32) -> core::option::Option<vortex_array::dtype::DecimalType>
+
+pub fn vortex_array::dtype::DecimalType::is_valid(value: i32) -> bool
+
+impl core::clone::Clone for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::clone(&self) -> vortex_array::dtype::DecimalType
+
+impl core::cmp::Eq for vortex_array::dtype::DecimalType
+
+impl core::cmp::Ord for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::cmp(&self, other: &vortex_array::dtype::DecimalType) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::eq(&self, other: &vortex_array::dtype::DecimalType) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::partial_cmp(&self, other: &vortex_array::dtype::DecimalType) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<vortex_array::dtype::DecimalType> for i32
+
+pub fn i32::from(value: vortex_array::dtype::DecimalType) -> i32
+
+impl core::convert::TryFrom<i32> for vortex_array::dtype::DecimalType
+
+pub type vortex_array::dtype::DecimalType::Error = prost::error::UnknownEnumValue
+
+pub fn vortex_array::dtype::DecimalType::try_from(value: i32) -> core::result::Result<vortex_array::dtype::DecimalType, prost::error::UnknownEnumValue>
+
+impl core::convert::TryFrom<vortex_array::dtype::PType> for vortex_array::dtype::DecimalType
+
+pub type vortex_array::dtype::DecimalType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalType::try_from(value: vortex_array::dtype::PType) -> core::result::Result<Self, Self::Error>
+
+impl core::default::Default for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::default() -> vortex_array::dtype::DecimalType
+
+impl core::fmt::Debug for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::DecimalType
+
+pub fn vortex_array::dtype::DecimalType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::dtype::DecimalType
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::DecimalType
+
+pub enum vortex_array::dtype::Field
+
+pub vortex_array::dtype::Field::ElementType
+
+pub vortex_array::dtype::Field::Name(vortex_array::dtype::FieldName)
+
+impl vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::as_name(&self) -> core::option::Option<&str>
+
+pub fn vortex_array::dtype::Field::is_named(&self) -> bool
+
+impl core::clone::Clone for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::clone(&self) -> vortex_array::dtype::Field
+
+impl core::cmp::Eq for vortex_array::dtype::Field
+
+impl core::cmp::PartialEq for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::eq(&self, other: &vortex_array::dtype::Field) -> bool
+
+impl core::convert::From<&str> for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::from(value: &str) -> Self
+
+impl core::convert::From<alloc::sync::Arc<str>> for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::from(value: alloc::sync::Arc<str>) -> Self
+
+impl core::convert::From<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::from(value: vortex_array::dtype::Field) -> Self
+
+impl core::convert::From<vortex_array::dtype::FieldName> for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::from(value: vortex_array::dtype::FieldName) -> Self
+
+impl core::fmt::Debug for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::iter::traits::collect::FromIterator<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::Field>>(iter: T) -> Self
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::Field
+
+pub enum vortex_array::dtype::FieldMask
+
+pub vortex_array::dtype::FieldMask::All
+
+pub vortex_array::dtype::FieldMask::Exact(vortex_array::dtype::FieldPath)
+
+pub vortex_array::dtype::FieldMask::Prefix(vortex_array::dtype::FieldPath)
+
+impl vortex_array::dtype::FieldMask
+
+pub fn vortex_array::dtype::FieldMask::matches_all(&self) -> bool
+
+pub fn vortex_array::dtype::FieldMask::matches_root(&self) -> bool
+
+pub fn vortex_array::dtype::FieldMask::starting_field(&self) -> vortex_error::VortexResult<core::option::Option<&vortex_array::dtype::Field>>
+
+pub fn vortex_array::dtype::FieldMask::step_into(self) -> vortex_error::VortexResult<Self>
+
+impl core::clone::Clone for vortex_array::dtype::FieldMask
+
+pub fn vortex_array::dtype::FieldMask::clone(&self) -> vortex_array::dtype::FieldMask
+
+impl core::cmp::Eq for vortex_array::dtype::FieldMask
+
+impl core::cmp::PartialEq for vortex_array::dtype::FieldMask
+
+pub fn vortex_array::dtype::FieldMask::eq(&self, other: &vortex_array::dtype::FieldMask) -> bool
+
+impl core::fmt::Debug for vortex_array::dtype::FieldMask
+
+pub fn vortex_array::dtype::FieldMask::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldMask
+
+pub enum vortex_array::dtype::Nullability
+
+pub vortex_array::dtype::Nullability::NonNullable
+
+pub vortex_array::dtype::Nullability::Nullable
+
+impl vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::is_nullable(&self) -> bool
+
+impl core::clone::Clone for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::clone(&self) -> vortex_array::dtype::Nullability
+
+impl core::cmp::Eq for vortex_array::dtype::Nullability
+
+impl core::cmp::PartialEq for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::eq(&self, other: &vortex_array::dtype::Nullability) -> bool
+
+impl core::convert::From<&vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+
+pub fn vortex_array::validity::Validity::from(value: &vortex_array::dtype::Nullability) -> Self
+
+impl core::convert::From<bool> for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::from(value: bool) -> Self
+
+impl core::convert::From<vortex_array::dtype::Nullability> for bool
+
+pub fn bool::from(value: vortex_array::dtype::Nullability) -> Self
+
+impl core::convert::From<vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+
+pub fn vortex_array::validity::Validity::from(value: vortex_array::dtype::Nullability) -> Self
+
+impl core::default::Default for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::default() -> vortex_array::dtype::Nullability
+
+impl core::fmt::Debug for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::dtype::Nullability
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::Nullability
+
+impl core::ops::bit::BitOr for vortex_array::dtype::Nullability
+
+pub type vortex_array::dtype::Nullability::Output = vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::bitor(self, rhs: Self) -> Self::Output
+
+impl core::ops::bit::BitOrAssign for vortex_array::dtype::Nullability
+
+pub fn vortex_array::dtype::Nullability::bitor_assign(&mut self, rhs: Self)
+
+#[repr(u8)] pub enum vortex_array::dtype::PType
+
+pub vortex_array::dtype::PType::F16 = 8
+
+pub vortex_array::dtype::PType::F32 = 9
+
+pub vortex_array::dtype::PType::F64 = 10
+
+pub vortex_array::dtype::PType::I16 = 5
+
+pub vortex_array::dtype::PType::I32 = 6
+
+pub vortex_array::dtype::PType::I64 = 7
+
+pub vortex_array::dtype::PType::I8 = 4
+
+pub vortex_array::dtype::PType::U16 = 1
+
+pub vortex_array::dtype::PType::U32 = 2
+
+pub vortex_array::dtype::PType::U64 = 3
+
+pub vortex_array::dtype::PType::U8 = 0
+
+impl vortex_array::dtype::PType
+
+pub const fn vortex_array::dtype::PType::bit_width(&self) -> usize
+
+pub const fn vortex_array::dtype::PType::byte_width(&self) -> usize
+
+pub const fn vortex_array::dtype::PType::is_float(self) -> bool
+
+pub const fn vortex_array::dtype::PType::is_int(self) -> bool
+
+pub const fn vortex_array::dtype::PType::is_signed_int(self) -> bool
+
+pub const fn vortex_array::dtype::PType::is_unsigned_int(self) -> bool
+
+pub const fn vortex_array::dtype::PType::max_signed_ptype(self, other: Self) -> Self
+
+pub const fn vortex_array::dtype::PType::max_unsigned_ptype(self, other: Self) -> Self
+
+pub fn vortex_array::dtype::PType::max_value_as_u64(&self) -> u64
+
+pub const fn vortex_array::dtype::PType::min_signed_ptype_for_value(value: i64) -> Self
+
+pub const fn vortex_array::dtype::PType::min_unsigned_ptype_for_value(value: u64) -> Self
+
+pub const fn vortex_array::dtype::PType::to_signed(self) -> Self
+
+pub const fn vortex_array::dtype::PType::to_unsigned(self) -> Self
+
+impl vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::from_i32(value: i32) -> core::option::Option<vortex_array::dtype::PType>
+
+pub fn vortex_array::dtype::PType::is_valid(value: i32) -> bool
+
+impl vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::least_supertype(self, other: vortex_array::dtype::PType) -> core::option::Option<vortex_array::dtype::PType>
+
+impl core::clone::Clone for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::clone(&self) -> vortex_array::dtype::PType
+
+impl core::cmp::Eq for vortex_array::dtype::PType
+
+impl core::cmp::PartialEq for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::eq(&self, other: &vortex_array::dtype::PType) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::partial_cmp(&self, other: &vortex_array::dtype::PType) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<vortex_array::dtype::PType> for &vortex_array::dtype::DType
+
+pub fn &vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for i32
+
+pub fn i32::from(value: vortex_array::dtype::PType) -> i32
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::DType
+
+pub fn vortex_array::dtype::DType::from(item: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_flatbuffers::dtype::PType
+
+pub fn vortex_flatbuffers::dtype::PType::from(value: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_proto::dtype::PType
+
+pub fn vortex_proto::dtype::PType::from(value: vortex_array::dtype::PType) -> Self
+
+impl core::convert::From<vortex_proto::dtype::PType> for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::from(value: vortex_proto::dtype::PType) -> Self
+
+impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::PType
+
+pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::PType::try_from(value: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<i32> for vortex_array::dtype::PType
+
+pub type vortex_array::dtype::PType::Error = prost::error::UnknownEnumValue
+
+pub fn vortex_array::dtype::PType::try_from(value: i32) -> core::result::Result<vortex_array::dtype::PType, prost::error::UnknownEnumValue>
+
+impl core::convert::TryFrom<vortex_array::dtype::PType> for vortex_array::dtype::DecimalType
+
+pub type vortex_array::dtype::DecimalType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalType::try_from(value: vortex_array::dtype::PType) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_flatbuffers::dtype::PType> for vortex_array::dtype::PType
+
+pub type vortex_array::dtype::PType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::PType::try_from(value: vortex_flatbuffers::dtype::PType) -> core::result::Result<Self, Self::Error>
+
+impl core::default::Default for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::default() -> vortex_array::dtype::PType
+
+impl core::fmt::Debug for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::dtype::PType
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::PType
+
+impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::PType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+
+pub struct vortex_array::dtype::DecimalDType
+
+impl vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::new(precision: u8, scale: i8) -> Self
+
+pub fn vortex_array::dtype::DecimalDType::precision(&self) -> u8
+
+pub fn vortex_array::dtype::DecimalDType::required_bit_width(&self) -> usize
+
+pub fn vortex_array::dtype::DecimalDType::scale(&self) -> i8
+
+pub fn vortex_array::dtype::DecimalDType::try_new(precision: u8, scale: i8) -> vortex_error::VortexResult<Self>
+
+impl core::clone::Clone for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::clone(&self) -> vortex_array::dtype::DecimalDType
+
+impl core::cmp::Eq for vortex_array::dtype::DecimalDType
+
+impl core::cmp::PartialEq for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::eq(&self, other: &vortex_array::dtype::DecimalDType) -> bool
+
+impl core::convert::TryFrom<&vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+
+pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalDType::try_from(value: &vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::dtype::DType> for vortex_array::dtype::DecimalDType
+
+pub type vortex_array::dtype::DecimalDType::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::DecimalDType::try_from(value: vortex_array::dtype::DType) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::dtype::DecimalDType
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::DecimalDType
+
+impl vortex_array::dtype::arrow::TryFromArrowType<&arrow_schema::datatype::DataType> for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::try_from_arrow(value: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<Self>
+
+impl<D: vortex_array::dtype::NativeDecimalType> core::convert::From<vortex_array::dtype::PrecisionScale<D>> for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::from(value: vortex_array::dtype::PrecisionScale<D>) -> Self
+
+impl<D: vortex_array::dtype::NativeDecimalType> core::convert::TryFrom<&vortex_array::dtype::DecimalDType> for vortex_array::dtype::PrecisionScale<D>
+
+pub type vortex_array::dtype::PrecisionScale<D>::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::PrecisionScale<D>::try_from(value: &vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
+
+pub struct vortex_array::dtype::FieldDType
+
+impl vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::value(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+impl core::clone::Clone for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::clone(&self) -> vortex_array::dtype::FieldDType
+
+impl core::cmp::Eq for vortex_array::dtype::FieldDType
+
+impl core::cmp::PartialEq for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::eq(&self, other: &vortex_array::dtype::FieldDType) -> bool
+
+impl core::convert::From<vortex_array::dtype::DType> for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::DType) -> Self
+
+impl core::convert::From<vortex_array::dtype::PType> for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::from(value: vortex_array::dtype::PType) -> Self
+
+impl core::fmt::Debug for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::FieldDType
+
+pub fn vortex_array::dtype::FieldDType::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldDType
+
+pub struct vortex_array::dtype::FieldName(_)
+
+impl vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::inner(&self) -> &alloc::sync::Arc<str>
+
+impl core::borrow::Borrow<str> for &vortex_array::dtype::FieldName
+
+pub fn &vortex_array::dtype::FieldName::borrow(&self) -> &str
+
+impl core::borrow::Borrow<str> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::borrow(&self) -> &str
+
+impl core::clone::Clone for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::clone(&self) -> vortex_array::dtype::FieldName
+
+impl core::cmp::Eq for vortex_array::dtype::FieldName
+
+impl core::cmp::Ord for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::cmp(&self, other: &vortex_array::dtype::FieldName) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+
+impl core::cmp::PartialEq<&alloc::string::String> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::eq(&self, other: &&alloc::string::String) -> bool
+
+impl core::cmp::PartialEq<&str> for &vortex_array::dtype::FieldName
+
+pub fn &vortex_array::dtype::FieldName::eq(&self, other: &&str) -> bool
+
+impl core::cmp::PartialEq<&str> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::eq(&self, other: &&str) -> bool
+
+impl core::cmp::PartialEq<&vortex_array::dtype::FieldName> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::eq(&self, other: &&vortex_array::dtype::FieldName) -> bool
+
+impl core::cmp::PartialEq<alloc::string::String> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::eq(&self, other: &alloc::string::String) -> bool
+
+impl core::cmp::PartialEq<vortex_array::dtype::FieldName> for &vortex_array::dtype::FieldName
+
+pub fn &vortex_array::dtype::FieldName::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+
+impl core::cmp::PartialEq<vortex_array::dtype::FieldName> for str
+
+pub fn str::eq(&self, other: &vortex_array::dtype::FieldName) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::partial_cmp(&self, other: &vortex_array::dtype::FieldName) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::AsRef<str> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::as_ref(&self) -> &str
+
+impl core::convert::From<&str> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::from(value: &str) -> Self
+
+impl core::convert::From<alloc::string::String> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::from(value: alloc::string::String) -> Self
+
+impl core::convert::From<alloc::sync::Arc<str>> for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::from(value: alloc::sync::Arc<str>) -> Self
+
+impl core::convert::From<vortex_array::dtype::FieldName> for alloc::string::String
+
+pub fn alloc::string::String::from(value: vortex_array::dtype::FieldName) -> Self
+
+impl core::convert::From<vortex_array::dtype::FieldName> for alloc::sync::Arc<str>
+
+pub fn alloc::sync::Arc<str>::from(value: vortex_array::dtype::FieldName) -> Self
+
+impl core::convert::From<vortex_array::dtype::FieldName> for vortex_array::dtype::Field
+
+pub fn vortex_array::dtype::Field::from(value: vortex_array::dtype::FieldName) -> Self
+
+impl core::fmt::Debug for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldName::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldName
+
+pub struct vortex_array::dtype::FieldNames(_)
+
+impl vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::empty() -> Self
+
+pub fn vortex_array::dtype::FieldNames::find(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<usize>
+
+pub fn vortex_array::dtype::FieldNames::get(&self, index: usize) -> core::option::Option<&vortex_array::dtype::FieldName>
+
+pub fn vortex_array::dtype::FieldNames::is_empty(&self) -> bool
+
+pub fn vortex_array::dtype::FieldNames::iter(&self) -> impl core::iter::traits::exact_size::ExactSizeIterator<Item = &vortex_array::dtype::FieldName>
+
+pub fn vortex_array::dtype::FieldNames::len(&self) -> usize
+
+impl core::clone::Clone for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::clone(&self) -> vortex_array::dtype::FieldNames
+
+impl core::cmp::Eq for vortex_array::dtype::FieldNames
+
+impl core::cmp::PartialEq for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::eq(&self, other: &vortex_array::dtype::FieldNames) -> bool
+
+impl core::cmp::PartialEq<&[&str]> for &vortex_array::dtype::FieldNames
+
+pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &&[&str]) -> bool
+
+impl core::cmp::PartialEq<&[&str]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&[&str]) -> bool
+
+impl core::cmp::PartialEq<&[vortex_array::dtype::FieldName]> for &vortex_array::dtype::FieldNames
+
+pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &&[vortex_array::dtype::FieldName]) -> bool
+
+impl core::cmp::PartialEq<&[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&[vortex_array::dtype::FieldName]) -> bool
+
+impl core::cmp::PartialEq<&vortex_array::dtype::FieldNames> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::eq(&self, other: &&vortex_array::dtype::FieldNames) -> bool
+
+impl core::convert::AsRef<[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::as_ref(&self) -> &[vortex_array::dtype::FieldName]
+
+impl core::convert::From<&[&'static str]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: &[&'static str]) -> Self
+
+impl core::convert::From<&[vortex_array::dtype::FieldName]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: &[vortex_array::dtype::FieldName]) -> Self
+
+impl core::convert::From<alloc::vec::Vec<&str>> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<&str>) -> Self
+
+impl core::convert::From<alloc::vec::Vec<alloc::sync::Arc<str>>> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<alloc::sync::Arc<str>>) -> Self
+
+impl core::convert::From<alloc::vec::Vec<vortex_array::dtype::FieldName>> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: alloc::vec::Vec<vortex_array::dtype::FieldName>) -> Self
+
+impl core::default::Default for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::default() -> vortex_array::dtype::FieldNames
+
+impl core::fmt::Debug for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::iter::traits::collect::IntoIterator for vortex_array::dtype::FieldNames
+
+pub type vortex_array::dtype::FieldNames::IntoIter = vortex_array::dtype::FieldNamesIntoIter
+
+pub type vortex_array::dtype::FieldNames::Item = vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldNames::into_iter(self) -> Self::IntoIter
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldNames
+
+impl core::ops::index::Index<usize> for vortex_array::dtype::FieldNames
+
+pub type vortex_array::dtype::FieldNames::Output = vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldNames::index(&self, index: usize) -> &Self::Output
+
+impl<F: core::convert::Into<vortex_array::dtype::FieldName>> core::iter::traits::collect::FromIterator<F> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from_iter<T: core::iter::traits::collect::IntoIterator<Item = F>>(iter: T) -> Self
+
+impl<const N: usize> core::cmp::PartialEq<[&str; N]> for &vortex_array::dtype::FieldNames
+
+pub fn &vortex_array::dtype::FieldNames::eq(&self, other: &[&str; N]) -> bool
+
+impl<const N: usize> core::cmp::PartialEq<[&str; N]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::eq(&self, other: &[&str; N]) -> bool
+
+impl<const N: usize> core::convert::From<&[&str; N]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: &[&str; N]) -> Self
+
+impl<const N: usize> core::convert::From<[&str; N]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: [&str; N]) -> Self
+
+impl<const N: usize> core::convert::From<[vortex_array::dtype::FieldName; N]> for vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::FieldNames::from(value: [vortex_array::dtype::FieldName; N]) -> Self
+
+pub struct vortex_array::dtype::FieldNamesIntoIter
+
+impl core::iter::traits::exact_size::ExactSizeIterator for vortex_array::dtype::FieldNamesIntoIter
+
+impl core::iter::traits::iterator::Iterator for vortex_array::dtype::FieldNamesIntoIter
+
+pub type vortex_array::dtype::FieldNamesIntoIter::Item = vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldNamesIntoIter::next(&mut self) -> core::option::Option<Self::Item>
+
+pub fn vortex_array::dtype::FieldNamesIntoIter::size_hint(&self) -> (usize, core::option::Option<usize>)
+
+pub struct vortex_array::dtype::FieldNamesIter<'a>
+
+impl core::iter::traits::exact_size::ExactSizeIterator for vortex_array::dtype::FieldNamesIter<'_>
+
+impl<'a> core::iter::traits::iterator::Iterator for vortex_array::dtype::FieldNamesIter<'a>
+
+pub type vortex_array::dtype::FieldNamesIter<'a>::Item = &'a vortex_array::dtype::FieldName
+
+pub fn vortex_array::dtype::FieldNamesIter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+
+pub fn vortex_array::dtype::FieldNamesIter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+
+pub struct vortex_array::dtype::FieldPath(_)
+
+impl vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::exists_in(&self, dtype: vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::dtype::FieldPath::from_name<F: core::convert::Into<vortex_array::dtype::FieldName>>(name: F) -> Self
+
+pub fn vortex_array::dtype::FieldPath::is_root(&self) -> bool
+
+pub fn vortex_array::dtype::FieldPath::overlap(&self, other: &vortex_array::dtype::FieldPath) -> bool
+
+pub fn vortex_array::dtype::FieldPath::parts(&self) -> &[vortex_array::dtype::Field]
+
+pub fn vortex_array::dtype::FieldPath::push<F: core::convert::Into<vortex_array::dtype::Field>>(self, field: F) -> Self
+
+pub fn vortex_array::dtype::FieldPath::resolve(&self, dtype: vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::FieldPath::root() -> Self
+
+pub fn vortex_array::dtype::FieldPath::starts_with_field(&self, field: &vortex_array::dtype::Field) -> bool
+
+pub fn vortex_array::dtype::FieldPath::step_into(self) -> core::option::Option<Self>
+
+impl core::clone::Clone for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::clone(&self) -> vortex_array::dtype::FieldPath
+
+impl core::cmp::Eq for vortex_array::dtype::FieldPath
+
+impl core::cmp::PartialEq for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::eq(&self, other: &vortex_array::dtype::FieldPath) -> bool
+
+impl core::convert::From<alloc::vec::Vec<vortex_array::dtype::Field>> for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::from(value: alloc::vec::Vec<vortex_array::dtype::Field>) -> Self
+
+impl core::convert::From<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::from(value: vortex_array::dtype::Field) -> Self
+
+impl core::convert::TryFrom<&vortex_proto::dtype::FieldPath> for vortex_array::dtype::FieldPath
+
+pub type vortex_array::dtype::FieldPath::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::FieldPath::try_from(value: &vortex_proto::dtype::FieldPath) -> core::result::Result<Self, Self::Error>
+
+impl core::default::Default for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::default() -> vortex_array::dtype::FieldPath
+
+impl core::fmt::Debug for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::iter::traits::collect::FromIterator<vortex_array::dtype::Field> for vortex_array::dtype::FieldPath
+
+pub fn vortex_array::dtype::FieldPath::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::Field>>(iter: T) -> Self
+
+impl core::iter::traits::collect::FromIterator<vortex_array::dtype::FieldPath> for vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::FieldPath>>(iter: T) -> Self
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::FieldPath
+
+pub struct vortex_array::dtype::FieldPathSet
+
+impl vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::contains(&self, path: &vortex_array::dtype::FieldPath) -> bool
+
+impl core::clone::Clone for vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::clone(&self) -> vortex_array::dtype::FieldPathSet
+
+impl core::default::Default for vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::default() -> vortex_array::dtype::FieldPathSet
+
+impl core::fmt::Debug for vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::iter::traits::collect::FromIterator<vortex_array::dtype::FieldPath> for vortex_array::dtype::FieldPathSet
+
+pub fn vortex_array::dtype::FieldPathSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::dtype::FieldPath>>(iter: T) -> Self
+
+pub struct vortex_array::dtype::PrecisionScale<D>
+
+impl<D: vortex_array::dtype::NativeDecimalType> vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::is_valid(&self, value: D) -> bool
+
+pub fn vortex_array::dtype::PrecisionScale<D>::new(precision: u8, scale: i8) -> Self
+
+pub unsafe fn vortex_array::dtype::PrecisionScale<D>::new_unchecked(precision: u8, scale: i8) -> Self
+
+pub fn vortex_array::dtype::PrecisionScale<D>::precision(&self) -> u8
+
+pub fn vortex_array::dtype::PrecisionScale<D>::scale(&self) -> i8
+
+pub fn vortex_array::dtype::PrecisionScale<D>::try_new(precision: u8, scale: i8) -> vortex_error::VortexResult<Self>
+
+impl<D: core::clone::Clone> core::clone::Clone for vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::clone(&self) -> vortex_array::dtype::PrecisionScale<D>
+
+impl<D: core::cmp::Eq> core::cmp::Eq for vortex_array::dtype::PrecisionScale<D>
+
+impl<D: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::eq(&self, other: &vortex_array::dtype::PrecisionScale<D>) -> bool
+
+impl<D: core::fmt::Debug> core::fmt::Debug for vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<D: core::hash::Hash> core::hash::Hash for vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl<D: core::marker::Copy> core::marker::Copy for vortex_array::dtype::PrecisionScale<D>
+
+impl<D: vortex_array::dtype::NativeDecimalType> core::convert::From<vortex_array::dtype::PrecisionScale<D>> for vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::dtype::DecimalDType::from(value: vortex_array::dtype::PrecisionScale<D>) -> Self
+
+impl<D: vortex_array::dtype::NativeDecimalType> core::convert::TryFrom<&vortex_array::dtype::DecimalDType> for vortex_array::dtype::PrecisionScale<D>
+
+pub type vortex_array::dtype::PrecisionScale<D>::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::PrecisionScale<D>::try_from(value: &vortex_array::dtype::DecimalDType) -> vortex_error::VortexResult<Self>
+
+impl<D: vortex_array::dtype::NativeDecimalType> core::fmt::Display for vortex_array::dtype::PrecisionScale<D>
+
+pub fn vortex_array::dtype::PrecisionScale<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<D> core::marker::StructuralPartialEq for vortex_array::dtype::PrecisionScale<D>
+
+pub struct vortex_array::dtype::StructFields(_)
+
+impl vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::disjoint_merge(&self, other: &Self) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::dtype::StructFields::empty() -> Self
+
+pub fn vortex_array::dtype::StructFields::field(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::StructFields::field_by_index(&self, index: usize) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::dtype::StructFields::field_name(&self, index: usize) -> core::option::Option<&vortex_array::dtype::FieldName>
+
+pub fn vortex_array::dtype::StructFields::fields(&self) -> impl core::iter::traits::exact_size::ExactSizeIterator<Item = vortex_array::dtype::DType> + '_
+
+pub fn vortex_array::dtype::StructFields::find(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<usize>
+
+pub fn vortex_array::dtype::StructFields::from_fields(names: vortex_array::dtype::FieldNames, dtypes: alloc::vec::Vec<vortex_array::dtype::FieldDType>) -> Self
+
+pub fn vortex_array::dtype::StructFields::names(&self) -> &vortex_array::dtype::FieldNames
+
+pub fn vortex_array::dtype::StructFields::new(names: vortex_array::dtype::FieldNames, dtypes: alloc::vec::Vec<vortex_array::dtype::DType>) -> Self
+
+pub fn vortex_array::dtype::StructFields::nfields(&self) -> usize
+
+pub fn vortex_array::dtype::StructFields::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::dtype::StructFields::without_field(&self, index: usize) -> vortex_error::VortexResult<Self>
+
+impl core::clone::Clone for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::clone(&self) -> vortex_array::dtype::StructFields
+
+impl core::cmp::Eq for vortex_array::dtype::StructFields
+
+impl core::cmp::PartialEq for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::eq(&self, other: &vortex_array::dtype::StructFields) -> bool
+
+impl core::default::Default for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::default() -> Self
+
+impl core::fmt::Debug for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::StructFields
+
+impl vortex_array::dtype::arrow::FromArrowType<&arrow_schema::fields::Fields> for vortex_array::dtype::StructFields
+
+pub fn vortex_array::dtype::StructFields::from_arrow(value: &arrow_schema::fields::Fields) -> Self
+
+impl<T, V> core::iter::traits::collect::FromIterator<(T, V)> for vortex_array::dtype::StructFields where T: core::convert::Into<vortex_array::dtype::FieldName>, V: core::convert::Into<vortex_array::dtype::FieldDType>
+
+pub fn vortex_array::dtype::StructFields::from_iter<I: core::iter::traits::collect::IntoIterator<Item = (T, V)>>(iter: I) -> Self
+
+#[repr(transparent)] pub struct vortex_array::dtype::i256(_)
+
+impl vortex_array::dtype::i256
+
+pub const vortex_array::dtype::i256::MAX: Self
+
+pub const vortex_array::dtype::i256::MIN: Self
+
+pub const vortex_array::dtype::i256::ONE: Self
+
+pub const vortex_array::dtype::i256::ZERO: Self
+
+pub fn vortex_array::dtype::i256::checked_pow(&self, exp: u32) -> core::option::Option<Self>
+
+pub const fn vortex_array::dtype::i256::from_i128(i: i128) -> Self
+
+pub const fn vortex_array::dtype::i256::from_le_bytes(bytes: [u8; 32]) -> Self
+
+pub const fn vortex_array::dtype::i256::from_parts(lower: u128, upper: i128) -> Self
+
+pub const fn vortex_array::dtype::i256::into_parts(self) -> (u128, i128)
+
+pub fn vortex_array::dtype::i256::maybe_i128(self) -> core::option::Option<i128>
+
+pub const fn vortex_array::dtype::i256::to_be_bytes(&self) -> [u8; 32]
+
+pub const fn vortex_array::dtype::i256::to_le_bytes(&self) -> [u8; 32]
+
+pub const fn vortex_array::dtype::i256::to_parts(&self) -> (u128, i128)
+
+pub fn vortex_array::dtype::i256::wrapping_add(&self, other: Self) -> Self
+
+pub fn vortex_array::dtype::i256::wrapping_pow(&self, exp: u32) -> Self
+
+impl core::clone::Clone for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::clone(&self) -> vortex_array::dtype::i256
+
+impl core::cmp::Eq for vortex_array::dtype::i256
+
+impl core::cmp::Ord for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::cmp(&self, other: &vortex_array::dtype::i256) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::eq(&self, other: &vortex_array::dtype::i256) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::partial_cmp(&self, other: &vortex_array::dtype::i256) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<arrow_buffer::bigint::i256> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::from(i: arrow_buffer::bigint::i256) -> Self
+
+impl core::convert::From<vortex_array::dtype::i256> for arrow_buffer::bigint::i256
+
+pub fn arrow_buffer::bigint::i256::from(i: vortex_array::dtype::i256) -> Self
+
+impl core::convert::From<vortex_array::dtype::i256> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: vortex_array::dtype::i256) -> Self
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::i256::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::default::Default for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::default() -> vortex_array::dtype::i256
+
+impl core::fmt::Debug for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::dtype::i256
+
+impl core::marker::StructuralPartialEq for vortex_array::dtype::i256
+
+impl core::ops::arith::Add for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::add(self, rhs: Self) -> Self::Output
+
+impl core::ops::arith::AddAssign for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::add_assign(&mut self, rhs: Self)
+
+impl core::ops::arith::Div for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::div(self, rhs: Self) -> Self::Output
+
+impl core::ops::arith::Mul for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::mul(self, rhs: Self) -> Self::Output
+
+impl core::ops::arith::Neg for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::neg(self) -> Self::Output
+
+impl core::ops::arith::Rem for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::rem(self, rhs: Self) -> Self::Output
+
+impl core::ops::arith::Sub for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::sub(self, rhs: Self) -> Self::Output
+
+impl core::ops::bit::BitOr for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::bitor(self, rhs: Self) -> Self::Output
+
+impl core::ops::bit::Shl<usize> for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::shl(self, rhs: usize) -> Self::Output
+
+impl core::ops::bit::Shr for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Output = vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::shr(self, rhs: Self) -> Self::Output
+
+impl num_traits::cast::AsPrimitive<i128> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> i128
+
+impl num_traits::cast::AsPrimitive<i16> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> i16
+
+impl num_traits::cast::AsPrimitive<i32> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> i32
+
+impl num_traits::cast::AsPrimitive<i64> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> i64
+
+impl num_traits::cast::AsPrimitive<i8> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> i8
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for bool
+
+pub fn bool::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i128
+
+pub fn i128::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i16
+
+pub fn i16::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i32
+
+pub fn i32::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i64
+
+pub fn i64::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for i8
+
+pub fn i8::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::AsPrimitive<vortex_array::dtype::i256> for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::as_(self) -> vortex_array::dtype::i256
+
+impl num_traits::cast::ToPrimitive for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::to_i128(&self) -> core::option::Option<i128>
+
+pub fn vortex_array::dtype::i256::to_i64(&self) -> core::option::Option<i64>
+
+pub fn vortex_array::dtype::i256::to_u128(&self) -> core::option::Option<u128>
+
+pub fn vortex_array::dtype::i256::to_u64(&self) -> core::option::Option<u64>
+
+impl num_traits::identities::ConstZero for vortex_array::dtype::i256
+
+pub const vortex_array::dtype::i256::ZERO: Self
+
+impl num_traits::identities::One for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::one() -> Self
+
+impl num_traits::identities::Zero for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::is_zero(&self) -> bool
+
+pub fn vortex_array::dtype::i256::zero() -> Self
+
+impl num_traits::ops::checked::CheckedAdd for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::checked_add(&self, v: &Self) -> core::option::Option<Self>
+
+impl num_traits::ops::checked::CheckedDiv for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::checked_div(&self, v: &Self) -> core::option::Option<Self>
+
+impl num_traits::ops::checked::CheckedMul for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::checked_mul(&self, v: &Self) -> core::option::Option<Self>
+
+impl num_traits::ops::checked::CheckedSub for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::checked_sub(&self, v: &Self) -> core::option::Option<Self>
+
+impl num_traits::ops::wrapping::WrappingAdd for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::wrapping_add(&self, v: &Self) -> Self
+
+impl num_traits::ops::wrapping::WrappingSub for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::wrapping_sub(&self, v: &Self) -> Self
+
+impl vortex_array::dtype::BigCast for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::NativeDecimalType for vortex_array::dtype::i256
+
+pub const vortex_array::dtype::i256::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const vortex_array::dtype::i256::MAX_BY_PRECISION: &'static [Self]
+
+pub const vortex_array::dtype::i256::MAX_PRECISION: u8
+
+pub const vortex_array::dtype::i256::MAX_SCALE: i8
+
+pub const vortex_array::dtype::i256::MIN_BY_PRECISION: &'static [Self]
+
+pub fn vortex_array::dtype::i256::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn vortex_array::dtype::i256::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::ToI256 for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+pub const vortex_array::dtype::MAX_PRECISION: u8
+
+pub const vortex_array::dtype::MAX_SCALE: i8
+
+pub trait vortex_array::dtype::BigCast: core::marker::Sized + num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256
+
+pub fn vortex_array::dtype::BigCast::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for i128
+
+pub fn i128::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for i16
+
+pub fn i16::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for i32
+
+pub fn i32::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for i64
+
+pub fn i64::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for i8
+
+pub fn i8::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for u128
+
+pub fn u128::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for u16
+
+pub fn u16::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for u32
+
+pub fn u32::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for u64
+
+pub fn u64::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for u8
+
+pub fn u8::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+impl vortex_array::dtype::BigCast for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::from<T: num_traits::cast::ToPrimitive + vortex_array::dtype::ToI256>(n: T) -> core::option::Option<Self>
+
+pub trait vortex_array::dtype::DecimalTypeDowncast
+
+pub type vortex_array::dtype::DecimalTypeDowncast::Output<T: vortex_array::dtype::NativeDecimalType>
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i128(self) -> Self::Output
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i16(self) -> Self::Output
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i256(self) -> Self::Output
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i32(self) -> Self::Output
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i64(self) -> Self::Output
+
+pub fn vortex_array::dtype::DecimalTypeDowncast::into_i8(self) -> Self::Output
+
+pub trait vortex_array::dtype::DecimalTypeUpcast
+
+pub type vortex_array::dtype::DecimalTypeUpcast::Input<T: vortex_array::dtype::NativeDecimalType>
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i128(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i16(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i256(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i32(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i64(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::DecimalTypeUpcast::from_i8(input: Self::Input) -> Self
+
+pub trait vortex_array::dtype::FromPrimitiveOrF16: num_traits::cast::FromPrimitive
+
+pub fn vortex_array::dtype::FromPrimitiveOrF16::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for f32
+
+pub fn f32::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for f64
+
+pub fn f64::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for half::binary16::f16
+
+pub fn half::binary16::f16::from_f16(v: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for i16
+
+pub fn i16::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for i32
+
+pub fn i32::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for i64
+
+pub fn i64::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for i8
+
+pub fn i8::from_f16(_: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for u16
+
+pub fn u16::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for u32
+
+pub fn u32::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for u64
+
+pub fn u64::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for u8
+
+pub fn u8::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+
+impl vortex_array::dtype::FromPrimitiveOrF16 for usize
+
+pub fn usize::from_f16(value: half::binary16::f16) -> core::option::Option<Self>
+
+pub trait vortex_array::dtype::IntegerPType: vortex_array::dtype::NativePType + num_traits::int::PrimInt + num_traits::cast::ToPrimitive + num_traits::bounds::Bounded + core::ops::arith::AddAssign + num_traits::cast::AsPrimitive<usize>
+
+pub fn vortex_array::dtype::IntegerPType::max_value_as_u64() -> u64
+
+impl<T> vortex_array::dtype::IntegerPType for T where T: vortex_array::dtype::NativePType + num_traits::int::PrimInt + num_traits::cast::ToPrimitive + num_traits::bounds::Bounded + core::ops::arith::AddAssign + num_traits::cast::AsPrimitive<usize>
+
+pub fn T::max_value_as_u64() -> u64
+
+pub trait vortex_array::dtype::NativeDType
+
+pub fn vortex_array::dtype::NativeDType::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for &[u8]
+
+pub fn &[u8]::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for &str
+
+pub fn &str::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for alloc::string::String
+
+pub fn alloc::string::String::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for bool
+
+pub fn bool::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for f32
+
+pub fn f32::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for f64
+
+pub fn f64::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for half::binary16::f16
+
+pub fn half::binary16::f16::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for i16
+
+pub fn i16::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for i32
+
+pub fn i32::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for i64
+
+pub fn i64::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for i8
+
+pub fn i8::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for u16
+
+pub fn u16::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for u32
+
+pub fn u32::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for u64
+
+pub fn u64::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for u8
+
+pub fn u8::dtype() -> vortex_array::dtype::DType
+
+impl vortex_array::dtype::NativeDType for vortex_buffer::ByteBuffer
+
+pub fn vortex_buffer::ByteBuffer::dtype() -> vortex_array::dtype::DType
+
+impl<T> vortex_array::dtype::NativeDType for alloc::vec::Vec<T> where T: vortex_array::dtype::NativeDType
+
+pub fn alloc::vec::Vec<T>::dtype() -> vortex_array::dtype::DType
+
+impl<T> vortex_array::dtype::NativeDType for core::option::Option<T> where T: vortex_array::dtype::NativeDType
+
+pub fn core::option::Option<T>::dtype() -> vortex_array::dtype::DType
+
+pub trait vortex_array::dtype::NativeDecimalType: core::marker::Send + core::marker::Sync + core::clone::Clone + core::marker::Copy + core::fmt::Debug + core::fmt::Display + core::default::Default + core::panic::unwind_safe::RefUnwindSafe + core::cmp::Eq + core::cmp::Ord + vortex_array::dtype::BigCast + 'static
+
+pub const vortex_array::dtype::NativeDecimalType::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const vortex_array::dtype::NativeDecimalType::MAX_BY_PRECISION: &'static [Self]
+
+pub const vortex_array::dtype::NativeDecimalType::MAX_PRECISION: u8
+
+pub const vortex_array::dtype::NativeDecimalType::MAX_SCALE: i8
+
+pub const vortex_array::dtype::NativeDecimalType::MIN_BY_PRECISION: &'static [Self]
+
+pub fn vortex_array::dtype::NativeDecimalType::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn vortex_array::dtype::NativeDecimalType::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for i128
+
+pub const i128::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const i128::MAX_BY_PRECISION: &'static [Self]
+
+pub const i128::MAX_PRECISION: u8
+
+pub const i128::MAX_SCALE: i8
+
+pub const i128::MIN_BY_PRECISION: &'static [Self]
+
+pub fn i128::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn i128::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for i16
+
+pub const i16::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const i16::MAX_BY_PRECISION: &'static [Self]
+
+pub const i16::MAX_PRECISION: u8
+
+pub const i16::MAX_SCALE: i8
+
+pub const i16::MIN_BY_PRECISION: &'static [Self]
+
+pub fn i16::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn i16::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for i32
+
+pub const i32::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const i32::MAX_BY_PRECISION: &'static [Self]
+
+pub const i32::MAX_PRECISION: u8
+
+pub const i32::MAX_SCALE: i8
+
+pub const i32::MIN_BY_PRECISION: &'static [Self]
+
+pub fn i32::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn i32::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for i64
+
+pub const i64::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const i64::MAX_BY_PRECISION: &'static [Self]
+
+pub const i64::MAX_PRECISION: u8
+
+pub const i64::MAX_SCALE: i8
+
+pub const i64::MIN_BY_PRECISION: &'static [Self]
+
+pub fn i64::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn i64::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for i8
+
+pub const i8::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const i8::MAX_BY_PRECISION: &'static [Self]
+
+pub const i8::MAX_PRECISION: u8
+
+pub const i8::MAX_SCALE: i8
+
+pub const i8::MIN_BY_PRECISION: &'static [Self]
+
+pub fn i8::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn i8::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativeDecimalType for vortex_array::dtype::i256
+
+pub const vortex_array::dtype::i256::DECIMAL_TYPE: vortex_array::dtype::DecimalType
+
+pub const vortex_array::dtype::i256::MAX_BY_PRECISION: &'static [Self]
+
+pub const vortex_array::dtype::i256::MAX_PRECISION: u8
+
+pub const vortex_array::dtype::i256::MAX_SCALE: i8
+
+pub const vortex_array::dtype::i256::MIN_BY_PRECISION: &'static [Self]
+
+pub fn vortex_array::dtype::i256::downcast<V: vortex_array::dtype::DecimalTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::DecimalTypeDowncast>::Output
+
+pub fn vortex_array::dtype::i256::upcast<V: vortex_array::dtype::DecimalTypeUpcast>(input: <V as vortex_array::dtype::DecimalTypeUpcast>::Input) -> V
+
+pub trait vortex_array::dtype::NativePType: core::marker::Send + core::marker::Sync + core::clone::Clone + core::marker::Copy + core::fmt::Debug + core::fmt::Display + core::default::Default + core::panic::unwind_safe::RefUnwindSafe + num_traits::Num + num_traits::cast::NumCast + vortex_array::dtype::FromPrimitiveOrF16 + vortex_array::dtype::ToBytes + vortex_array::dtype::TryFromBytes + vortex_array::dtype::ptype::private::Sealed + 'static
+
+pub const vortex_array::dtype::NativePType::PTYPE: vortex_array::dtype::PType
+
+pub fn vortex_array::dtype::NativePType::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn vortex_array::dtype::NativePType::is_eq(self, other: Self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_ge(self, other: Self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_gt(self, other: Self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_infinite(self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_le(self, other: Self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_lt(self, other: Self) -> bool
+
+pub fn vortex_array::dtype::NativePType::is_nan(self) -> bool
+
+pub fn vortex_array::dtype::NativePType::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn vortex_array::dtype::NativePType::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for f32
+
+pub const f32::PTYPE: vortex_array::dtype::PType
+
+pub fn f32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn f32::is_eq(self, other: Self) -> bool
+
+pub fn f32::is_ge(self, other: Self) -> bool
+
+pub fn f32::is_gt(self, other: Self) -> bool
+
+pub fn f32::is_infinite(self) -> bool
+
+pub fn f32::is_le(self, other: Self) -> bool
+
+pub fn f32::is_lt(self, other: Self) -> bool
+
+pub fn f32::is_nan(self) -> bool
+
+pub fn f32::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn f32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for f64
+
+pub const f64::PTYPE: vortex_array::dtype::PType
+
+pub fn f64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn f64::is_eq(self, other: Self) -> bool
+
+pub fn f64::is_ge(self, other: Self) -> bool
+
+pub fn f64::is_gt(self, other: Self) -> bool
+
+pub fn f64::is_infinite(self) -> bool
+
+pub fn f64::is_le(self, other: Self) -> bool
+
+pub fn f64::is_lt(self, other: Self) -> bool
+
+pub fn f64::is_nan(self) -> bool
+
+pub fn f64::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn f64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for half::binary16::f16
+
+pub const half::binary16::f16::PTYPE: vortex_array::dtype::PType
+
+pub fn half::binary16::f16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn half::binary16::f16::is_eq(self, other: Self) -> bool
+
+pub fn half::binary16::f16::is_ge(self, other: Self) -> bool
+
+pub fn half::binary16::f16::is_gt(self, other: Self) -> bool
+
+pub fn half::binary16::f16::is_infinite(self) -> bool
+
+pub fn half::binary16::f16::is_le(self, other: Self) -> bool
+
+pub fn half::binary16::f16::is_lt(self, other: Self) -> bool
+
+pub fn half::binary16::f16::is_nan(self) -> bool
+
+pub fn half::binary16::f16::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn half::binary16::f16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for i16
+
+pub const i16::PTYPE: vortex_array::dtype::PType
+
+pub fn i16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn i16::is_eq(self, other: Self) -> bool
+
+pub fn i16::is_ge(self, other: Self) -> bool
+
+pub fn i16::is_gt(self, other: Self) -> bool
+
+pub fn i16::is_infinite(self) -> bool
+
+pub fn i16::is_le(self, other: Self) -> bool
+
+pub fn i16::is_lt(self, other: Self) -> bool
+
+pub fn i16::is_nan(self) -> bool
+
+pub fn i16::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn i16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for i32
+
+pub const i32::PTYPE: vortex_array::dtype::PType
+
+pub fn i32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn i32::is_eq(self, other: Self) -> bool
+
+pub fn i32::is_ge(self, other: Self) -> bool
+
+pub fn i32::is_gt(self, other: Self) -> bool
+
+pub fn i32::is_infinite(self) -> bool
+
+pub fn i32::is_le(self, other: Self) -> bool
+
+pub fn i32::is_lt(self, other: Self) -> bool
+
+pub fn i32::is_nan(self) -> bool
+
+pub fn i32::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn i32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for i64
+
+pub const i64::PTYPE: vortex_array::dtype::PType
+
+pub fn i64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn i64::is_eq(self, other: Self) -> bool
+
+pub fn i64::is_ge(self, other: Self) -> bool
+
+pub fn i64::is_gt(self, other: Self) -> bool
+
+pub fn i64::is_infinite(self) -> bool
+
+pub fn i64::is_le(self, other: Self) -> bool
+
+pub fn i64::is_lt(self, other: Self) -> bool
+
+pub fn i64::is_nan(self) -> bool
+
+pub fn i64::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn i64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for i8
+
+pub const i8::PTYPE: vortex_array::dtype::PType
+
+pub fn i8::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn i8::is_eq(self, other: Self) -> bool
+
+pub fn i8::is_ge(self, other: Self) -> bool
+
+pub fn i8::is_gt(self, other: Self) -> bool
+
+pub fn i8::is_infinite(self) -> bool
+
+pub fn i8::is_le(self, other: Self) -> bool
+
+pub fn i8::is_lt(self, other: Self) -> bool
+
+pub fn i8::is_nan(self) -> bool
+
+pub fn i8::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn i8::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for u16
+
+pub const u16::PTYPE: vortex_array::dtype::PType
+
+pub fn u16::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn u16::is_eq(self, other: Self) -> bool
+
+pub fn u16::is_ge(self, other: Self) -> bool
+
+pub fn u16::is_gt(self, other: Self) -> bool
+
+pub fn u16::is_infinite(self) -> bool
+
+pub fn u16::is_le(self, other: Self) -> bool
+
+pub fn u16::is_lt(self, other: Self) -> bool
+
+pub fn u16::is_nan(self) -> bool
+
+pub fn u16::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn u16::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for u32
+
+pub const u32::PTYPE: vortex_array::dtype::PType
+
+pub fn u32::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn u32::is_eq(self, other: Self) -> bool
+
+pub fn u32::is_ge(self, other: Self) -> bool
+
+pub fn u32::is_gt(self, other: Self) -> bool
+
+pub fn u32::is_infinite(self) -> bool
+
+pub fn u32::is_le(self, other: Self) -> bool
+
+pub fn u32::is_lt(self, other: Self) -> bool
+
+pub fn u32::is_nan(self) -> bool
+
+pub fn u32::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn u32::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for u64
+
+pub const u64::PTYPE: vortex_array::dtype::PType
+
+pub fn u64::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn u64::is_eq(self, other: Self) -> bool
+
+pub fn u64::is_ge(self, other: Self) -> bool
+
+pub fn u64::is_gt(self, other: Self) -> bool
+
+pub fn u64::is_infinite(self) -> bool
+
+pub fn u64::is_le(self, other: Self) -> bool
+
+pub fn u64::is_lt(self, other: Self) -> bool
+
+pub fn u64::is_nan(self) -> bool
+
+pub fn u64::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn u64::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+impl vortex_array::dtype::NativePType for u8
+
+pub const u8::PTYPE: vortex_array::dtype::PType
+
+pub fn u8::downcast<V: vortex_array::dtype::PTypeDowncast>(visitor: V) -> <V as vortex_array::dtype::PTypeDowncast>::Output
+
+pub fn u8::is_eq(self, other: Self) -> bool
+
+pub fn u8::is_ge(self, other: Self) -> bool
+
+pub fn u8::is_gt(self, other: Self) -> bool
+
+pub fn u8::is_infinite(self) -> bool
+
+pub fn u8::is_le(self, other: Self) -> bool
+
+pub fn u8::is_lt(self, other: Self) -> bool
+
+pub fn u8::is_nan(self) -> bool
+
+pub fn u8::total_compare(self, other: Self) -> core::cmp::Ordering
+
+pub fn u8::upcast<V: vortex_array::dtype::PTypeUpcast>(input: <V as vortex_array::dtype::PTypeUpcast>::Input) -> V
+
+pub trait vortex_array::dtype::PTypeDowncast
+
+pub type vortex_array::dtype::PTypeDowncast::Output<T: vortex_array::dtype::NativePType>
+
+pub fn vortex_array::dtype::PTypeDowncast::into_f16(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_f32(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_f64(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_i16(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_i32(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_i64(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_i8(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_u16(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_u32(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_u64(self) -> Self::Output
+
+pub fn vortex_array::dtype::PTypeDowncast::into_u8(self) -> Self::Output
+
+pub trait vortex_array::dtype::PTypeDowncastExt: vortex_array::dtype::PTypeDowncast
+
+pub fn vortex_array::dtype::PTypeDowncastExt::downcast<T: vortex_array::dtype::NativePType>(self) -> Self::Output where Self: core::marker::Sized
+
+impl<T: vortex_array::dtype::PTypeDowncast> vortex_array::dtype::PTypeDowncastExt for T
+
+pub fn T::downcast<T: vortex_array::dtype::NativePType>(self) -> Self::Output where Self: core::marker::Sized
+
+pub trait vortex_array::dtype::PTypeUpcast
+
+pub type vortex_array::dtype::PTypeUpcast::Input<T: vortex_array::dtype::NativePType>
+
+pub fn vortex_array::dtype::PTypeUpcast::from_f16(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_f32(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_f64(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_i16(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_i32(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_i64(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_i8(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_u16(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_u32(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_u64(input: Self::Input) -> Self
+
+pub fn vortex_array::dtype::PTypeUpcast::from_u8(input: Self::Input) -> Self
+
+pub trait vortex_array::dtype::PhysicalPType: vortex_array::dtype::NativePType
+
+pub type vortex_array::dtype::PhysicalPType::Physical: vortex_array::dtype::NativePType + num_traits::sign::Unsigned
+
+impl vortex_array::dtype::PhysicalPType for i16
+
+pub type i16::Physical = u16
+
+impl vortex_array::dtype::PhysicalPType for i32
+
+pub type i32::Physical = u32
+
+impl vortex_array::dtype::PhysicalPType for i64
+
+pub type i64::Physical = u64
+
+impl vortex_array::dtype::PhysicalPType for i8
+
+pub type i8::Physical = u8
+
+impl vortex_array::dtype::PhysicalPType for u16
+
+pub type u16::Physical = u16
+
+impl vortex_array::dtype::PhysicalPType for u32
+
+pub type u32::Physical = u32
+
+impl vortex_array::dtype::PhysicalPType for u64
+
+pub type u64::Physical = u64
+
+impl vortex_array::dtype::PhysicalPType for u8
+
+pub type u8::Physical = u8
+
+pub trait vortex_array::dtype::ToBytes: core::marker::Sized
+
+pub fn vortex_array::dtype::ToBytes::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for f32
+
+pub fn f32::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for f64
+
+pub fn f64::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for half::binary16::f16
+
+pub fn half::binary16::f16::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for i16
+
+pub fn i16::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for i32
+
+pub fn i32::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for i64
+
+pub fn i64::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for i8
+
+pub fn i8::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for u16
+
+pub fn u16::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for u32
+
+pub fn u32::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for u64
+
+pub fn u64::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for u8
+
+pub fn u8::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::dtype::ToBytes for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::to_le_bytes(&self) -> &[u8]
+
+pub trait vortex_array::dtype::ToI256
+
+pub fn vortex_array::dtype::ToI256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for i128
+
+pub fn i128::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for i16
+
+pub fn i16::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for i32
+
+pub fn i32::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for i64
+
+pub fn i64::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for i8
+
+pub fn i8::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for u128
+
+pub fn u128::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for u16
+
+pub fn u16::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for u32
+
+pub fn u32::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for u64
+
+pub fn u64::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for u8
+
+pub fn u8::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+impl vortex_array::dtype::ToI256 for vortex_array::dtype::i256
+
+pub fn vortex_array::dtype::i256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+
+pub trait vortex_array::dtype::TryFromBytes: core::marker::Sized
+
+pub fn vortex_array::dtype::TryFromBytes::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for f32
+
+pub fn f32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for f64
+
+pub fn f64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for half::binary16::f16
+
+pub fn half::binary16::f16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for i16
+
+pub fn i16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for i32
+
+pub fn i32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for i64
+
+pub fn i64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for i8
+
+pub fn i8::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for u16
+
+pub fn u16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for u32
+
+pub fn u32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for u64
+
+pub fn u64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::dtype::TryFromBytes for u8
+
+pub fn u8::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+
+pub trait vortex_array::dtype::UnsignedPType: vortex_array::dtype::IntegerPType + num_traits::sign::Unsigned
+
+impl<T> vortex_array::dtype::UnsignedPType for T where T: vortex_array::dtype::IntegerPType + num_traits::sign::Unsigned
+
+pub mod vortex_array::expr
+
+pub mod vortex_array::expr::aliases
+
+pub mod vortex_array::expr::aliases::paste
+
+pub use vortex_array::expr::aliases::paste::paste
+
+pub mod vortex_array::expr::analysis
+
+pub mod vortex_array::expr::analysis::annotation
+
+pub trait vortex_array::expr::analysis::annotation::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+pub trait vortex_array::expr::analysis::annotation::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+
+pub type vortex_array::expr::analysis::annotation::AnnotationFn::Annotation: vortex_array::expr::Annotation
+
+impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+
+pub type F::Annotation = A
+
+pub fn vortex_array::expr::analysis::annotation::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+
+pub type vortex_array::expr::analysis::annotation::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+
+pub mod vortex_array::expr::analysis::immediate_access
+
+pub fn vortex_array::expr::analysis::immediate_access::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::analysis::immediate_access::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+
+pub fn vortex_array::expr::analysis::immediate_access::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+
+pub type vortex_array::expr::analysis::immediate_access::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+
+pub trait vortex_array::expr::analysis::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+pub trait vortex_array::expr::analysis::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+
+pub type vortex_array::expr::analysis::AnnotationFn::Annotation: vortex_array::expr::Annotation
+
+impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+
+pub type F::Annotation = A
+
+pub fn vortex_array::expr::analysis::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+
+pub fn vortex_array::expr::analysis::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::analysis::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+
+pub fn vortex_array::expr::analysis::label_is_fallible(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+
+pub fn vortex_array::expr::analysis::label_null_sensitive(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+
+pub fn vortex_array::expr::analysis::label_tree<L: core::clone::Clone>(expr: &vortex_array::expr::Expression, self_label: impl core::ops::function::Fn(&vortex_array::expr::Expression) -> L, merge_child: impl core::ops::function::FnMut(L, &L) -> L) -> vortex_utils::aliases::hash_map::HashMap<&vortex_array::expr::Expression, L>
+
+pub fn vortex_array::expr::analysis::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+
+pub type vortex_array::expr::analysis::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+
+pub type vortex_array::expr::analysis::BooleanLabels<'a> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, bool>
+
+pub type vortex_array::expr::analysis::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+
+pub mod vortex_array::expr::annotation
+
+pub trait vortex_array::expr::annotation::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+pub trait vortex_array::expr::annotation::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+
+pub type vortex_array::expr::annotation::AnnotationFn::Annotation: vortex_array::expr::Annotation
+
+impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+
+pub type F::Annotation = A
+
+pub fn vortex_array::expr::annotation::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+
+pub type vortex_array::expr::annotation::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+
+pub mod vortex_array::expr::display
+
+pub enum vortex_array::expr::display::DisplayFormat
+
+pub vortex_array::expr::display::DisplayFormat::Compact
+
+pub vortex_array::expr::display::DisplayFormat::Tree
+
+pub struct vortex_array::expr::display::DisplayTreeExpr<'a>(pub &'a vortex_array::expr::Expression)
+
+impl core::fmt::Display for vortex_array::expr::display::DisplayTreeExpr<'_>
+
+pub fn vortex_array::expr::display::DisplayTreeExpr<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub mod vortex_array::expr::forms
+
+pub fn vortex_array::expr::forms::conjuncts(expr: &vortex_array::expr::Expression) -> alloc::vec::Vec<vortex_array::expr::Expression>
+
+pub mod vortex_array::expr::immediate_access
+
+pub fn vortex_array::expr::immediate_access::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::immediate_access::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+
+pub fn vortex_array::expr::immediate_access::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+
+pub type vortex_array::expr::immediate_access::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+
+pub mod vortex_array::expr::proto
+
+pub trait vortex_array::expr::proto::ExprSerializeProtoExt
+
+pub fn vortex_array::expr::proto::ExprSerializeProtoExt::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+
+impl vortex_array::expr::proto::ExprSerializeProtoExt for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+
+pub fn vortex_array::expr::proto::deserialize_expr_proto(expr: &vortex_proto::expr::Expr, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub mod vortex_array::expr::pruning
+
+pub struct vortex_array::expr::pruning::Relation<K, V>
+
+impl<K: core::hash::Hash + core::cmp::Eq, V: core::hash::Hash + core::cmp::Eq> vortex_array::expr::pruning::Relation<K, V>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::insert(&mut self, k: K, v: V)
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::map(&self) -> &vortex_utils::aliases::hash_map::HashMap<K, vortex_utils::aliases::hash_set::HashSet<V>>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::new() -> Self
+
+impl<K, V> core::convert::From<hashbrown::map::HashMap<K, hashbrown::set::HashSet<V>>> for vortex_array::expr::pruning::Relation<K, V>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::from(value: vortex_utils::aliases::hash_map::HashMap<K, vortex_utils::aliases::hash_set::HashSet<V>>) -> Self
+
+impl<K, V> core::iter::traits::collect::IntoIterator for vortex_array::expr::pruning::Relation<K, V>
+
+pub type vortex_array::expr::pruning::Relation<K, V>::IntoIter = hashbrown::map::IntoIter<K, hashbrown::set::HashSet<V>>
+
+pub type vortex_array::expr::pruning::Relation<K, V>::Item = (K, hashbrown::set::HashSet<V>)
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::into_iter(self) -> Self::IntoIter
+
+impl<K: core::clone::Clone, V: core::clone::Clone> core::clone::Clone for vortex_array::expr::pruning::Relation<K, V>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::clone(&self) -> vortex_array::expr::pruning::Relation<K, V>
+
+impl<K: core::fmt::Debug, V: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::pruning::Relation<K, V>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<K: core::hash::Hash + core::cmp::Eq, V: core::hash::Hash + core::cmp::Eq> core::default::Default for vortex_array::expr::pruning::Relation<K, V>
+
+pub fn vortex_array::expr::pruning::Relation<K, V>::default() -> Self
+
+pub trait vortex_array::expr::pruning::StatsCatalog
+
+pub fn vortex_array::expr::pruning::StatsCatalog::stats_ref(&self, _field_path: &vortex_array::dtype::FieldPath, _stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::pruning::checked_pruning_expr(expr: &vortex_array::expr::Expression, available_stats: &vortex_array::dtype::FieldPathSet) -> core::option::Option<(vortex_array::expr::Expression, vortex_array::expr::pruning::RequiredStats)>
+
+pub type vortex_array::expr::pruning::RequiredStats = vortex_array::expr::pruning::Relation<vortex_array::dtype::FieldPath, vortex_array::expr::stats::Stat>
+
+pub mod vortex_array::expr::stats
+
+pub enum vortex_array::expr::stats::IntersectionResult<T>
+
+pub vortex_array::expr::stats::IntersectionResult::None
+
+pub vortex_array::expr::stats::IntersectionResult::Value(T)
+
+impl<T> vortex_array::expr::stats::IntersectionResult<T>
+
+pub fn vortex_array::expr::stats::IntersectionResult<T>::ok_or_else<F>(self, err: F) -> vortex_error::VortexResult<T> where F: core::ops::function::FnOnce() -> vortex_error::VortexError
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::IntersectionResult<T>
+
+pub fn vortex_array::expr::stats::IntersectionResult<T>::clone(&self) -> vortex_array::expr::stats::IntersectionResult<T>
+
+impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::IntersectionResult<T>
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::IntersectionResult<T>
+
+pub fn vortex_array::expr::stats::IntersectionResult<T>::eq(&self, other: &vortex_array::expr::stats::IntersectionResult<T>) -> bool
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::IntersectionResult<T>
+
+pub fn vortex_array::expr::stats::IntersectionResult<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::IntersectionResult<T>
+
+pub enum vortex_array::expr::stats::Precision<T>
+
+pub vortex_array::expr::stats::Precision::Exact(T)
+
+pub vortex_array::expr::stats::Precision::Inexact(T)
+
+impl vortex_array::expr::stats::Precision<&vortex_array::scalar::ScalarValue>
+
+pub fn vortex_array::expr::stats::Precision<&vortex_array::scalar::ScalarValue>::into_scalar(self, dtype: vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
+
+impl vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>
+
+pub fn vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>::into_scalar(self, dtype: vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
+
+impl<T> vortex_array::expr::stats::Precision<T> where T: core::marker::Copy
+
+pub fn vortex_array::expr::stats::Precision<T>::to_inexact(&self) -> Self
+
+impl<T> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::as_exact(self) -> core::option::Option<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::as_inexact(self) -> core::option::Option<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::as_ref(&self) -> vortex_array::expr::stats::Precision<&T>
+
+pub fn vortex_array::expr::stats::Precision<T>::exact<S: core::convert::Into<T>>(s: S) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::inexact<S: core::convert::Into<T>>(s: S) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::into_inexact(self) -> Self
+
+pub fn vortex_array::expr::stats::Precision<T>::into_inner(self) -> T
+
+pub fn vortex_array::expr::stats::Precision<T>::is_exact(&self) -> bool
+
+pub fn vortex_array::expr::stats::Precision<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, f: F) -> vortex_array::expr::stats::Precision<U>
+
+pub fn vortex_array::expr::stats::Precision<T>::try_map<U, F: core::ops::function::FnOnce(T) -> vortex_error::VortexResult<U>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::stats::Precision<U>>
+
+pub fn vortex_array::expr::stats::Precision<T>::zip<U>(self, other: vortex_array::expr::stats::Precision<U>) -> vortex_array::expr::stats::Precision<(T, U)>
+
+impl<T> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::bound<S: vortex_array::expr::stats::StatType<T>>(self) -> <S as vortex_array::expr::stats::StatType>::Bound
+
+impl<T> vortex_array::expr::stats::Precision<core::option::Option<T>>
+
+pub fn vortex_array::expr::stats::Precision<core::option::Option<T>>::transpose(self) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::clone(&self) -> vortex_array::expr::stats::Precision<T>
+
+impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::Precision<T>
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::eq(&self, other: &vortex_array::expr::stats::Precision<T>) -> bool
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq<T> for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::eq(&self, other: &T) -> bool
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+
+pub fn vortex_array::expr::stats::Precision<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::Precision<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::Precision<T>::union(&self, other: &Self) -> core::option::Option<Self>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<T: core::fmt::Display> core::fmt::Display for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<T: core::marker::Copy> core::marker::Copy for vortex_array::expr::stats::Precision<T>
+
+impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::Precision<T>
+
+#[repr(u8)] pub enum vortex_array::expr::stats::Stat
+
+pub vortex_array::expr::stats::Stat::IsConstant = 0
+
+pub vortex_array::expr::stats::Stat::IsSorted = 1
+
+pub vortex_array::expr::stats::Stat::IsStrictSorted = 2
+
+pub vortex_array::expr::stats::Stat::Max = 3
+
+pub vortex_array::expr::stats::Stat::Min = 4
+
+pub vortex_array::expr::stats::Stat::NaNCount = 8
+
+pub vortex_array::expr::stats::Stat::NullCount = 6
+
+pub vortex_array::expr::stats::Stat::Sum = 5
+
+pub vortex_array::expr::stats::Stat::UncompressedSizeInBytes = 7
+
+impl vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::all() -> impl core::iter::traits::iterator::Iterator<Item = vortex_array::expr::stats::Stat>
+
+pub fn vortex_array::expr::stats::Stat::dtype(&self, data_type: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::expr::stats::Stat::has_same_dtype_as_array(&self) -> bool
+
+pub fn vortex_array::expr::stats::Stat::is_commutative(&self) -> bool
+
+pub fn vortex_array::expr::stats::Stat::name(&self) -> &str
+
+impl core::clone::Clone for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::clone(&self) -> vortex_array::expr::stats::Stat
+
+impl core::cmp::Eq for vortex_array::expr::stats::Stat
+
+impl core::cmp::Ord for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::cmp(&self, other: &vortex_array::expr::stats::Stat) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::eq(&self, other: &vortex_array::expr::stats::Stat) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::partial_cmp(&self, other: &vortex_array::expr::stats::Stat) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<vortex_array::expr::stats::Stat> for u8
+
+pub fn u8::from(enum_value: vortex_array::expr::stats::Stat) -> Self
+
+impl core::convert::TryFrom<u8> for vortex_array::expr::stats::Stat
+
+pub type vortex_array::expr::stats::Stat::Error = num_enum::TryFromPrimitiveError<vortex_array::expr::stats::Stat>
+
+pub fn vortex_array::expr::stats::Stat::try_from(number: u8) -> core::result::Result<Self, num_enum::TryFromPrimitiveError<Self>>
+
+impl core::fmt::Debug for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::expr::stats::Stat
+
+pub fn vortex_array::expr::stats::Stat::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::expr::stats::Stat
+
+impl core::marker::StructuralPartialEq for vortex_array::expr::stats::Stat
+
+impl enum_iterator::Sequence for vortex_array::expr::stats::Stat
+
+pub const vortex_array::expr::stats::Stat::CARDINALITY: usize
+
+pub fn vortex_array::expr::stats::Stat::first() -> core::option::Option<Self>
+
+pub fn vortex_array::expr::stats::Stat::last() -> core::option::Option<Self>
+
+pub fn vortex_array::expr::stats::Stat::next(&self) -> core::option::Option<Self>
+
+pub fn vortex_array::expr::stats::Stat::previous(&self) -> core::option::Option<Self>
+
+impl num_enum::TryFromPrimitive for vortex_array::expr::stats::Stat
+
+pub type vortex_array::expr::stats::Stat::Error = num_enum::TryFromPrimitiveError<vortex_array::expr::stats::Stat>
+
+pub type vortex_array::expr::stats::Stat::Primitive = u8
+
+pub const vortex_array::expr::stats::Stat::NAME: &'static str
+
+pub fn vortex_array::expr::stats::Stat::try_from_primitive(number: Self::Primitive) -> core::result::Result<Self, num_enum::TryFromPrimitiveError<Self>>
+
+pub struct vortex_array::expr::stats::IsConstant
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsConstant
+
+pub type vortex_array::expr::stats::IsConstant::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsConstant::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::IsSorted
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsSorted
+
+pub type vortex_array::expr::stats::IsSorted::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsSorted::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::IsStrictSorted
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsStrictSorted
+
+pub type vortex_array::expr::stats::IsStrictSorted::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsStrictSorted::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::LowerBound<T>(_)
+
+impl<T> vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::is_exact(&self) -> bool
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::clone(&self) -> vortex_array::expr::stats::LowerBound<T>
+
+impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::LowerBound<T>
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::eq(&self, other: &vortex_array::expr::stats::LowerBound<T>) -> bool
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::LowerBound<T>>>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::LowerBound<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::LowerBound<T>>
+
+impl<T: core::cmp::PartialOrd> core::cmp::PartialEq<T> for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::eq(&self, other: &T) -> bool
+
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<T> for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::partial_cmp(&self, other: &T) -> core::option::Option<core::cmp::Ordering>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::LowerBound<T>
+
+pub struct vortex_array::expr::stats::Max
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Max
+
+pub type vortex_array::expr::stats::Max::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::Max::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::Min
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Min
+
+pub type vortex_array::expr::stats::Min::Bound = vortex_array::expr::stats::LowerBound<T>
+
+pub const vortex_array::expr::stats::Min::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::NaNCount
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NaNCount
+
+pub type vortex_array::expr::stats::NaNCount::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::NaNCount::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::NullCount
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NullCount
+
+pub type vortex_array::expr::stats::NullCount::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::NullCount::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::Sum
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Sum
+
+pub type vortex_array::expr::stats::Sum::Bound = vortex_array::expr::stats::Precision<T>
+
+pub const vortex_array::expr::stats::Sum::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::UncompressedSizeInBytes
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::UncompressedSizeInBytes
+
+pub type vortex_array::expr::stats::UncompressedSizeInBytes::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::UncompressedSizeInBytes::STAT: vortex_array::expr::stats::Stat
+
+pub struct vortex_array::expr::stats::UpperBound<T>(_)
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::clone(&self) -> vortex_array::expr::stats::UpperBound<T>
+
+impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::UpperBound<T>
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::eq(&self, other: &vortex_array::expr::stats::UpperBound<T>) -> bool
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::UpperBound<T>>>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::UpperBound<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::UpperBound<T>>
+
+impl<T: core::cmp::PartialOrd> core::cmp::PartialEq<T> for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::eq(&self, other: &T) -> bool
+
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<T> for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::partial_cmp(&self, other: &T) -> core::option::Option<core::cmp::Ordering>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::UpperBound<T>
+
+pub trait vortex_array::expr::stats::StatBound<T>: core::marker::Sized
+
+pub fn vortex_array::expr::stats::StatBound::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+
+pub fn vortex_array::expr::stats::StatBound::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::StatBound::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::StatBound::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::StatBound::union(&self, other: &Self) -> core::option::Option<Self>
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::LowerBound<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::LowerBound<T>>>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::LowerBound<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::LowerBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::LowerBound<T>>
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+
+pub fn vortex_array::expr::stats::Precision<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::Precision<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::Precision<T>::union(&self, other: &Self) -> core::option::Option<Self>
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::UpperBound<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::UpperBound<T>>>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+
+pub fn vortex_array::expr::stats::UpperBound<T>::to_exact(&self) -> core::option::Option<&T>
+
+pub fn vortex_array::expr::stats::UpperBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::UpperBound<T>>
+
+pub trait vortex_array::expr::stats::StatType<T>
+
+pub type vortex_array::expr::stats::StatType::Bound: vortex_array::expr::stats::StatBound<T>
+
+pub const vortex_array::expr::stats::StatType::STAT: vortex_array::expr::stats::Stat
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsConstant
+
+pub type vortex_array::expr::stats::IsConstant::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsConstant::STAT: vortex_array::expr::stats::Stat
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsSorted
+
+pub type vortex_array::expr::stats::IsSorted::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsSorted::STAT: vortex_array::expr::stats::Stat
+
+impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsStrictSorted
+
+pub type vortex_array::expr::stats::IsStrictSorted::Bound = vortex_array::expr::stats::Precision<bool>
+
+pub const vortex_array::expr::stats::IsStrictSorted::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Max
+
+pub type vortex_array::expr::stats::Max::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::Max::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Min
+
+pub type vortex_array::expr::stats::Min::Bound = vortex_array::expr::stats::LowerBound<T>
+
+pub const vortex_array::expr::stats::Min::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Sum
+
+pub type vortex_array::expr::stats::Sum::Bound = vortex_array::expr::stats::Precision<T>
+
+pub const vortex_array::expr::stats::Sum::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NaNCount
+
+pub type vortex_array::expr::stats::NaNCount::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::NaNCount::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NullCount
+
+pub type vortex_array::expr::stats::NullCount::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::NullCount::STAT: vortex_array::expr::stats::Stat
+
+impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::UncompressedSizeInBytes
+
+pub type vortex_array::expr::stats::UncompressedSizeInBytes::Bound = vortex_array::expr::stats::UpperBound<T>
+
+pub const vortex_array::expr::stats::UncompressedSizeInBytes::STAT: vortex_array::expr::stats::Stat
+
+pub trait vortex_array::expr::stats::StatsProvider
+
+pub fn vortex_array::expr::stats::StatsProvider::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::expr::stats::StatsProvider::is_empty(&self) -> bool
+
+pub fn vortex_array::expr::stats::StatsProvider::len(&self) -> usize
+
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
+
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
+
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::len(&self) -> usize
+
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
+
+pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::stats::StatsSetRef<'_>::is_empty(&self) -> bool
+
+pub fn vortex_array::stats::StatsSetRef<'_>::len(&self) -> usize
+
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
+
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
+
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::len(&self) -> usize
+
+pub trait vortex_array::expr::stats::StatsProviderExt: vortex_array::expr::stats::StatsProvider
+
+pub fn vortex_array::expr::stats::StatsProviderExt::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+
+pub fn vortex_array::expr::stats::StatsProviderExt::get_as_bound<S, U>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound> where S: vortex_array::expr::stats::StatType<U>, U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+
+pub fn vortex_array::expr::stats::StatsProviderExt::get_scalar_bound<S: vortex_array::expr::stats::StatType<vortex_array::scalar::Scalar>>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound>
+
+impl<S> vortex_array::expr::stats::StatsProviderExt for S where S: vortex_array::expr::stats::StatsProvider
+
+pub fn S::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+
+pub fn S::get_as_bound<S, U>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound> where S: vortex_array::expr::stats::StatType<U>, U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+
+pub fn S::get_scalar_bound<S: vortex_array::expr::stats::StatType<vortex_array::scalar::Scalar>>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound>
+
+pub mod vortex_array::expr::transform
+
+pub struct vortex_array::expr::transform::PartitionedExpr<A>
+
+pub vortex_array::expr::transform::PartitionedExpr::partition_annotations: alloc::boxed::Box<[A]>
+
+pub vortex_array::expr::transform::PartitionedExpr::partition_dtypes: alloc::boxed::Box<[vortex_array::dtype::DType]>
+
+pub vortex_array::expr::transform::PartitionedExpr::partition_names: vortex_array::dtype::FieldNames
+
+pub vortex_array::expr::transform::PartitionedExpr::partitions: alloc::boxed::Box<[vortex_array::expr::Expression]>
+
+pub vortex_array::expr::transform::PartitionedExpr::root: vortex_array::expr::Expression
+
+impl<A: vortex_array::expr::Annotation> vortex_array::expr::transform::PartitionedExpr<A> where vortex_array::dtype::FieldName: core::convert::From<A>
+
+pub fn vortex_array::expr::transform::PartitionedExpr<A>::find_partition(&self, id: &A) -> core::option::Option<&vortex_array::expr::Expression>
+
+impl<A: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::transform::PartitionedExpr<A>
+
+pub fn vortex_array::expr::transform::PartitionedExpr<A>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<A: core::fmt::Display> core::fmt::Display for vortex_array::expr::transform::PartitionedExpr<A>
+
+pub fn vortex_array::expr::transform::PartitionedExpr<A>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_array::expr::transform::coerce_expression(expr: vortex_array::expr::Expression, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::transform::partition<A: vortex_array::expr::AnnotationFn>(expr: vortex_array::expr::Expression, scope: &vortex_array::dtype::DType, annotate_fn: A) -> vortex_error::VortexResult<vortex_array::expr::transform::PartitionedExpr<<A as vortex_array::expr::AnnotationFn>::Annotation>> where <A as vortex_array::expr::AnnotationFn>::Annotation: core::fmt::Display, vortex_array::dtype::FieldName: core::convert::From<<A as vortex_array::expr::AnnotationFn>::Annotation>
+
+pub fn vortex_array::expr::transform::replace(expr: vortex_array::expr::Expression, needle: &vortex_array::expr::Expression, replacement: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::transform::replace_root_fields(expr: vortex_array::expr::Expression, fields: &vortex_array::dtype::StructFields) -> vortex_array::expr::Expression
+
+pub mod vortex_array::expr::traversal
+
+pub enum vortex_array::expr::traversal::FoldDown<R>
+
+pub vortex_array::expr::traversal::FoldDown::Continue
+
+pub vortex_array::expr::traversal::FoldDown::Skip(R)
+
+pub vortex_array::expr::traversal::FoldDown::Stop(R)
+
+impl<R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldDown<R>
+
+pub fn vortex_array::expr::traversal::FoldDown<R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::expr::traversal::FoldDownContext<C, R>
+
+pub vortex_array::expr::traversal::FoldDownContext::Continue(C)
+
+pub vortex_array::expr::traversal::FoldDownContext::Skip(R)
+
+pub vortex_array::expr::traversal::FoldDownContext::Stop(R)
+
+impl<C: core::fmt::Debug, R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldDownContext<C, R>
+
+pub fn vortex_array::expr::traversal::FoldDownContext<C, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::expr::traversal::FoldUp<R>
+
+pub vortex_array::expr::traversal::FoldUp::Continue(R)
+
+pub vortex_array::expr::traversal::FoldUp::Stop(R)
+
+impl<R> vortex_array::expr::traversal::FoldUp<R>
+
+pub fn vortex_array::expr::traversal::FoldUp<R>::value(self) -> R
+
+impl<R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldUp<R>
+
+pub fn vortex_array::expr::traversal::FoldUp<R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::expr::traversal::TraversalOrder
+
+pub vortex_array::expr::traversal::TraversalOrder::Continue
+
+pub vortex_array::expr::traversal::TraversalOrder::Skip
+
+pub vortex_array::expr::traversal::TraversalOrder::Stop
+
+impl vortex_array::expr::traversal::TraversalOrder
+
+pub fn vortex_array::expr::traversal::TraversalOrder::visit_children<F: core::ops::function::FnOnce() -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::TraversalOrder::visit_parent<F: core::ops::function::FnOnce() -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+impl core::clone::Clone for vortex_array::expr::traversal::TraversalOrder
+
+pub fn vortex_array::expr::traversal::TraversalOrder::clone(&self) -> vortex_array::expr::traversal::TraversalOrder
+
+impl core::cmp::Eq for vortex_array::expr::traversal::TraversalOrder
+
+impl core::cmp::PartialEq for vortex_array::expr::traversal::TraversalOrder
+
+pub fn vortex_array::expr::traversal::TraversalOrder::eq(&self, other: &vortex_array::expr::traversal::TraversalOrder) -> bool
+
+impl core::fmt::Debug for vortex_array::expr::traversal::TraversalOrder
+
+pub fn vortex_array::expr::traversal::TraversalOrder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::StructuralPartialEq for vortex_array::expr::traversal::TraversalOrder
+
+pub struct vortex_array::expr::traversal::ReferenceCollector
+
+impl vortex_array::expr::traversal::ReferenceCollector
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::into_fields(self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::new() -> Self
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::with_set(set: vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>) -> Self
+
+impl core::default::Default for vortex_array::expr::traversal::ReferenceCollector
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::default() -> vortex_array::expr::traversal::ReferenceCollector
+
+impl vortex_array::expr::traversal::NodeVisitor<'_> for vortex_array::expr::traversal::ReferenceCollector
+
+pub type vortex_array::expr::traversal::ReferenceCollector::NodeTy = vortex_array::expr::Expression
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::visit_down(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::visit_up(&mut self, node: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub struct vortex_array::expr::traversal::Transformed<T>
+
+pub vortex_array::expr::traversal::Transformed::changed: bool
+
+pub vortex_array::expr::traversal::Transformed::order: vortex_array::expr::traversal::TraversalOrder
+
+pub vortex_array::expr::traversal::Transformed::value: T
+
+impl<T> vortex_array::expr::traversal::Transformed<T>
+
+pub fn vortex_array::expr::traversal::Transformed<T>::into_inner(self) -> T
+
+pub fn vortex_array::expr::traversal::Transformed<T>::map<O, F: core::ops::function::FnOnce(T) -> O>(self, f: F) -> vortex_array::expr::traversal::Transformed<O>
+
+pub fn vortex_array::expr::traversal::Transformed<T>::no(value: T) -> Self
+
+pub fn vortex_array::expr::traversal::Transformed<T>::yes(value: T) -> Self
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::traversal::Transformed<T>
+
+pub fn vortex_array::expr::traversal::Transformed<T>::clone(&self) -> vortex_array::expr::traversal::Transformed<T>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::Transformed<T>
+
+pub fn vortex_array::expr::traversal::Transformed<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub trait vortex_array::expr::traversal::Node: core::marker::Sized + core::clone::Clone
+
+pub fn vortex_array::expr::traversal::Node::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::Node::children_count(&self) -> usize
+
+pub fn vortex_array::expr::traversal::Node::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+
+pub fn vortex_array::expr::traversal::Node::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+impl vortex_array::expr::traversal::Node for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::Expression::children_count(&self) -> usize
+
+pub fn vortex_array::expr::Expression::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+
+pub fn vortex_array::expr::Expression::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub trait vortex_array::expr::traversal::NodeContainer<'a, T: 'a>: core::marker::Sized
+
+pub fn vortex_array::expr::traversal::NodeContainer::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::NodeContainer::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+impl<'a, T, C> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::sync::Arc<C> where T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T> + core::clone::Clone
+
+pub fn alloc::sync::Arc<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn alloc::sync::Arc<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<alloc::sync::Arc<C>>>
+
+impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for [C; 2]
+
+pub fn [C; 2]::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn [C; 2]::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<[C; 2]>>
+
+impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::boxed::Box<C>
+
+pub fn alloc::boxed::Box<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn alloc::boxed::Box<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<alloc::boxed::Box<C>>>
+
+impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::vec::Vec<C>
+
+pub fn alloc::vec::Vec<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn alloc::vec::Vec<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+impl<'a> vortex_array::expr::traversal::NodeContainer<'a, vortex_array::expr::Expression> for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::apply_elements<F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::Expression::map_elements<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub trait vortex_array::expr::traversal::NodeExt: vortex_array::expr::traversal::Node
+
+pub fn vortex_array::expr::traversal::NodeExt::accept<'a, V: vortex_array::expr::traversal::NodeVisitor<'a, NodeTy = Self>>(&'a self, visitor: &mut V) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::NodeExt::fold<R, F: vortex_array::expr::traversal::NodeFolder<NodeTy = Self, Result = R>>(self, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+
+pub fn vortex_array::expr::traversal::NodeExt::fold_context<R, F: vortex_array::expr::traversal::NodeFolderContext<NodeTy = Self, Result = R>>(self, ctx: &<F as vortex_array::expr::traversal::NodeFolderContext>::Context, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+
+pub fn vortex_array::expr::traversal::NodeExt::rewrite<R: vortex_array::expr::traversal::NodeRewriter<NodeTy = Self>>(self, rewriter: &mut R) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn vortex_array::expr::traversal::NodeExt::transform<F, G>(self, down: F, up: G) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>> where F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>, G: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn vortex_array::expr::traversal::NodeExt::transform_down<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn vortex_array::expr::traversal::NodeExt::transform_up<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+impl<T: vortex_array::expr::traversal::Node> vortex_array::expr::traversal::NodeExt for T
+
+pub fn T::accept<'a, V: vortex_array::expr::traversal::NodeVisitor<'a, NodeTy = Self>>(&'a self, visitor: &mut V) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn T::fold<R, F: vortex_array::expr::traversal::NodeFolder<NodeTy = Self, Result = R>>(self, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+
+pub fn T::fold_context<R, F: vortex_array::expr::traversal::NodeFolderContext<NodeTy = Self, Result = R>>(self, ctx: &<F as vortex_array::expr::traversal::NodeFolderContext>::Context, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+
+pub fn T::rewrite<R: vortex_array::expr::traversal::NodeRewriter<NodeTy = Self>>(self, rewriter: &mut R) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn T::transform<F, G>(self, down: F, up: G) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>> where F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>, G: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn T::transform_down<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub fn T::transform_up<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub trait vortex_array::expr::traversal::NodeFolder
+
+pub type vortex_array::expr::traversal::NodeFolder::NodeTy: vortex_array::expr::traversal::Node
+
+pub type vortex_array::expr::traversal::NodeFolder::Result
+
+pub fn vortex_array::expr::traversal::NodeFolder::visit_down(&mut self, _node: &Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldDown<Self::Result>>
+
+pub fn vortex_array::expr::traversal::NodeFolder::visit_up(&mut self, _node: Self::NodeTy, _children: alloc::vec::Vec<Self::Result>) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<Self::Result>>
+
+pub trait vortex_array::expr::traversal::NodeFolderContext
+
+pub type vortex_array::expr::traversal::NodeFolderContext::Context
+
+pub type vortex_array::expr::traversal::NodeFolderContext::NodeTy: vortex_array::expr::traversal::Node
+
+pub type vortex_array::expr::traversal::NodeFolderContext::Result
+
+pub fn vortex_array::expr::traversal::NodeFolderContext::visit_down(&mut self, _ctx: &Self::Context, _node: &Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldDownContext<Self::Context, Self::Result>>
+
+pub fn vortex_array::expr::traversal::NodeFolderContext::visit_up(&mut self, _node: Self::NodeTy, _context: &Self::Context, _children: alloc::vec::Vec<Self::Result>) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<Self::Result>>
+
+pub trait vortex_array::expr::traversal::NodeRefContainer<'a, T: 'a>: core::marker::Sized
+
+pub fn vortex_array::expr::traversal::NodeRefContainer::apply_ref_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeRefContainer<'a, T> for &'a [C]
+
+pub fn &'a [C]::apply_ref_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub trait vortex_array::expr::traversal::NodeRewriter: core::marker::Sized
+
+pub type vortex_array::expr::traversal::NodeRewriter::NodeTy: vortex_array::expr::traversal::Node
+
+pub fn vortex_array::expr::traversal::NodeRewriter::visit_down(&mut self, node: Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self::NodeTy>>
+
+pub fn vortex_array::expr::traversal::NodeRewriter::visit_up(&mut self, node: Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self::NodeTy>>
+
+pub trait vortex_array::expr::traversal::NodeVisitor<'a>
+
+pub type vortex_array::expr::traversal::NodeVisitor::NodeTy: vortex_array::expr::traversal::Node
+
+pub fn vortex_array::expr::traversal::NodeVisitor::visit_down(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::NodeVisitor::visit_up(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+impl vortex_array::expr::traversal::NodeVisitor<'_> for vortex_array::expr::traversal::ReferenceCollector
+
+pub type vortex_array::expr::traversal::ReferenceCollector::NodeTy = vortex_array::expr::Expression
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::visit_down(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::ReferenceCollector::visit_up(&mut self, node: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::traversal::pre_order_visit_down<'a, T: 'a + vortex_array::expr::traversal::Node>(tree: &'a T, f: impl core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::expr::traversal::pre_order_visit_up<'a, T: 'a + vortex_array::expr::traversal::Node>(tree: &'a T, f: impl core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>) -> vortex_error::VortexResult<()>
+
+pub struct vortex_array::expr::ExactExpr(pub vortex_array::expr::Expression)
+
+impl core::clone::Clone for vortex_array::expr::ExactExpr
+
+pub fn vortex_array::expr::ExactExpr::clone(&self) -> vortex_array::expr::ExactExpr
+
+impl core::cmp::Eq for vortex_array::expr::ExactExpr
+
+impl core::cmp::PartialEq for vortex_array::expr::ExactExpr
+
+pub fn vortex_array::expr::ExactExpr::eq(&self, other: &Self) -> bool
+
+impl core::hash::Hash for vortex_array::expr::ExactExpr
+
+pub fn vortex_array::expr::ExactExpr::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+pub struct vortex_array::expr::Expression
+
+impl vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::child(&self, n: usize) -> &vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::children(&self) -> &alloc::sync::Arc<alloc::vec::Vec<vortex_array::expr::Expression>>
+
+pub fn vortex_array::expr::Expression::display_tree(&self) -> impl core::fmt::Display
+
+pub fn vortex_array::expr::Expression::fmt_sql(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_array::expr::Expression::return_dtype(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_array::expr::Expression::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
+
+pub fn vortex_array::expr::Expression::stat_expression(&self, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::stat_falsification(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::stat_max(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::stat_min(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::try_new(scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::expr::Expression::validity(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::with_children(self, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::from_proto(expr: &vortex_proto::expr::Expr, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+impl vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::optimize(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::optimize_recursive(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::simplify(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::simplify_untyped(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::try_optimize(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+
+pub fn vortex_array::expr::Expression::try_optimize_recursive(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+
+impl core::clone::Clone for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::clone(&self) -> vortex_array::expr::Expression
+
+impl core::cmp::Eq for vortex_array::expr::Expression
+
+impl core::cmp::PartialEq for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::eq(&self, other: &vortex_array::expr::Expression) -> bool
+
+impl core::fmt::Debug for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::expr::Expression
+
+impl core::ops::deref::Deref for vortex_array::expr::Expression
+
+pub type vortex_array::expr::Expression::Target = vortex_array::scalar_fn::ScalarFnRef
+
+pub fn vortex_array::expr::Expression::deref(&self) -> &Self::Target
+
+impl core::ops::drop::Drop for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::drop(&mut self)
+
+impl vortex_array::builtins::ExprBuiltins for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::Expression::zip(&self, if_true: vortex_array::expr::Expression, if_false: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+
+impl vortex_array::expr::VortexExprExt for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+impl vortex_array::expr::proto::ExprSerializeProtoExt for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+
+impl vortex_array::expr::traversal::Node for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::Expression::children_count(&self) -> usize
+
+pub fn vortex_array::expr::Expression::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+
+pub fn vortex_array::expr::Expression::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+impl<'a> vortex_array::expr::traversal::NodeContainer<'a, vortex_array::expr::Expression> for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::apply_elements<F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+
+pub fn vortex_array::expr::Expression::map_elements<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+
+pub trait vortex_array::expr::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+
+pub trait vortex_array::expr::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+
+pub type vortex_array::expr::AnnotationFn::Annotation: vortex_array::expr::Annotation
+
+impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+
+pub type F::Annotation = A
+
+pub trait vortex_array::expr::StatsCatalog
+
+pub fn vortex_array::expr::StatsCatalog::stats_ref(&self, _field_path: &vortex_array::dtype::FieldPath, _stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::Expression>
+
+pub trait vortex_array::expr::VortexExprExt
+
+pub fn vortex_array::expr::VortexExprExt::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+impl vortex_array::expr::VortexExprExt for vortex_array::expr::Expression
+
+pub fn vortex_array::expr::Expression::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::and(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::and_collect<I>(iter: I) -> core::option::Option<vortex_array::expr::Expression> where I: core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::between(arr: vortex_array::expr::Expression, lower: vortex_array::expr::Expression, upper: vortex_array::expr::Expression, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::case_when(condition: vortex_array::expr::Expression, then_value: vortex_array::expr::Expression, else_value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::case_when_no_else(condition: vortex_array::expr::Expression, then_value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::cast(child: vortex_array::expr::Expression, target: vortex_array::dtype::DType) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::checked_add(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::col(field: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+
+pub fn vortex_array::expr::dynamic(operator: vortex_array::scalar_fn::fns::operators::CompareOperator, rhs_value: impl core::ops::function::Fn() -> core::option::Option<vortex_array::scalar::ScalarValue> + core::marker::Send + core::marker::Sync + 'static, rhs_dtype: vortex_array::dtype::DType, default: bool, lhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::fill_null(child: vortex_array::expr::Expression, fill_value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::get_item(field: impl core::convert::Into<vortex_array::dtype::FieldName>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::gt(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::gt_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::ilike(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+
+pub fn vortex_array::expr::is_null(child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::is_root(expr: &vortex_array::expr::Expression) -> bool
+
+pub fn vortex_array::expr::label_is_fallible(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+
+pub fn vortex_array::expr::label_null_sensitive(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+
+pub fn vortex_array::expr::label_tree<L: core::clone::Clone>(expr: &vortex_array::expr::Expression, self_label: impl core::ops::function::Fn(&vortex_array::expr::Expression) -> L, merge_child: impl core::ops::function::FnMut(L, &L) -> L) -> vortex_utils::aliases::hash_map::HashMap<&vortex_array::expr::Expression, L>
+
+pub fn vortex_array::expr::like(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::list_contains(list: vortex_array::expr::Expression, value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::lit(value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::lt(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::lt_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+
+pub fn vortex_array::expr::mask(array: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::merge(elements: impl core::iter::traits::collect::IntoIterator<Item = impl core::convert::Into<vortex_array::expr::Expression>>) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::merge_opts(elements: impl core::iter::traits::collect::IntoIterator<Item = impl core::convert::Into<vortex_array::expr::Expression>>, duplicate_handling: vortex_array::scalar_fn::fns::merge::DuplicateHandling) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::nested_case_when(when_then_pairs: alloc::vec::Vec<(vortex_array::expr::Expression, vortex_array::expr::Expression)>, else_value: core::option::Option<vortex_array::expr::Expression>) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::not(operand: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::not_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::not_ilike(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::not_like(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::or(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::or_collect<I>(iter: I) -> core::option::Option<vortex_array::expr::Expression> where I: core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::pack(elements: impl core::iter::traits::collect::IntoIterator<Item = (impl core::convert::Into<vortex_array::dtype::FieldName>, vortex_array::expr::Expression)>, nullability: vortex_array::dtype::Nullability) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::root() -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::select(field_names: impl core::convert::Into<vortex_array::dtype::FieldNames>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::select_exclude(fields: impl core::convert::Into<vortex_array::dtype::FieldNames>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub fn vortex_array::expr::split_conjunction(expr: &vortex_array::expr::Expression) -> alloc::vec::Vec<vortex_array::expr::Expression>
+
+pub fn vortex_array::expr::zip_expr(mask: vortex_array::expr::Expression, if_true: vortex_array::expr::Expression, if_false: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+
+pub type vortex_array::expr::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+
+pub type vortex_array::expr::BooleanLabels<'a> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, bool>
+
+pub type vortex_array::expr::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+
+pub mod vortex_array::extension
+
+pub mod vortex_array::extension::datetime
+
+pub enum vortex_array::extension::datetime::DateValue
+
+pub vortex_array::extension::datetime::DateValue::Days(i32)
+
+pub vortex_array::extension::datetime::DateValue::Milliseconds(i64)
+
+impl core::fmt::Display for vortex_array::extension::datetime::DateValue
+
+pub fn vortex_array::extension::datetime::DateValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::extension::datetime::TemporalJiff
+
+pub vortex_array::extension::datetime::TemporalJiff::Date(jiff::civil::date::Date)
+
+pub vortex_array::extension::datetime::TemporalJiff::Time(jiff::civil::time::Time)
+
+pub vortex_array::extension::datetime::TemporalJiff::Unzoned(jiff::civil::datetime::DateTime)
+
+pub vortex_array::extension::datetime::TemporalJiff::Zoned(jiff::zoned::Zoned)
+
+impl core::fmt::Display for vortex_array::extension::datetime::TemporalJiff
+
+pub fn vortex_array::extension::datetime::TemporalJiff::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::extension::datetime::TemporalMetadata<'a>
+
+pub vortex_array::extension::datetime::TemporalMetadata::Date(&'a <vortex_array::extension::datetime::Date as vortex_array::dtype::extension::ExtVTable>::Metadata)
+
+pub vortex_array::extension::datetime::TemporalMetadata::Time(&'a <vortex_array::extension::datetime::Time as vortex_array::dtype::extension::ExtVTable>::Metadata)
+
+pub vortex_array::extension::datetime::TemporalMetadata::Timestamp(&'a vortex_array::extension::datetime::TimeUnit, &'a core::option::Option<alloc::sync::Arc<str>>)
+
+impl vortex_array::extension::datetime::TemporalMetadata<'_>
+
+pub fn vortex_array::extension::datetime::TemporalMetadata<'_>::time_unit(&self) -> vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TemporalMetadata<'_>::to_jiff(&self, v: i64) -> vortex_error::VortexResult<vortex_array::extension::datetime::TemporalJiff>
+
+impl<'a> core::cmp::Eq for vortex_array::extension::datetime::TemporalMetadata<'a>
+
+impl<'a> core::cmp::PartialEq for vortex_array::extension::datetime::TemporalMetadata<'a>
+
+pub fn vortex_array::extension::datetime::TemporalMetadata<'a>::eq(&self, other: &vortex_array::extension::datetime::TemporalMetadata<'a>) -> bool
+
+impl<'a> core::fmt::Debug for vortex_array::extension::datetime::TemporalMetadata<'a>
+
+pub fn vortex_array::extension::datetime::TemporalMetadata<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::marker::StructuralPartialEq for vortex_array::extension::datetime::TemporalMetadata<'a>
+
+#[repr(u8)] pub enum vortex_array::extension::datetime::TimeUnit
+
+pub vortex_array::extension::datetime::TimeUnit::Days = 4
+
+pub vortex_array::extension::datetime::TimeUnit::Microseconds = 1
+
+pub vortex_array::extension::datetime::TimeUnit::Milliseconds = 2
+
+pub vortex_array::extension::datetime::TimeUnit::Nanoseconds = 0
+
+pub vortex_array::extension::datetime::TimeUnit::Seconds = 3
+
+impl vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::to_jiff_span(&self, v: i64) -> vortex_error::VortexResult<jiff::span::Span>
+
+impl core::clone::Clone for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::clone(&self) -> vortex_array::extension::datetime::TimeUnit
+
+impl core::cmp::Eq for vortex_array::extension::datetime::TimeUnit
+
+impl core::cmp::Ord for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::cmp(&self, other: &vortex_array::extension::datetime::TimeUnit) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::eq(&self, other: &vortex_array::extension::datetime::TimeUnit) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::partial_cmp(&self, other: &vortex_array::extension::datetime::TimeUnit) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<&arrow_schema::datatype::TimeUnit> for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::from(value: &arrow_schema::datatype::TimeUnit) -> Self
+
+impl core::convert::From<arrow_schema::datatype::TimeUnit> for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::from(value: arrow_schema::datatype::TimeUnit) -> Self
+
+impl core::convert::From<vortex_array::extension::datetime::TimeUnit> for u8
+
+pub fn u8::from(enum_value: vortex_array::extension::datetime::TimeUnit) -> Self
+
+impl core::convert::TryFrom<u8> for vortex_array::extension::datetime::TimeUnit
+
+pub type vortex_array::extension::datetime::TimeUnit::Error = vortex_error::VortexError
+
+pub fn vortex_array::extension::datetime::TimeUnit::try_from(value: u8) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::extension::datetime::TimeUnit> for arrow_schema::datatype::TimeUnit
+
+pub type arrow_schema::datatype::TimeUnit::Error = vortex_error::VortexError
+
+pub fn arrow_schema::datatype::TimeUnit::try_from(value: vortex_array::extension::datetime::TimeUnit) -> vortex_error::VortexResult<Self>
+
+impl core::fmt::Debug for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::datetime::TimeUnit
+
+pub fn vortex_array::extension::datetime::TimeUnit::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_array::extension::datetime::TimeUnit
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::TimeUnit
+
+pub enum vortex_array::extension::datetime::TimeValue
+
+pub vortex_array::extension::datetime::TimeValue::Microseconds(i64)
+
+pub vortex_array::extension::datetime::TimeValue::Milliseconds(i32)
+
+pub vortex_array::extension::datetime::TimeValue::Nanoseconds(i64)
+
+pub vortex_array::extension::datetime::TimeValue::Seconds(i32)
+
+impl core::fmt::Display for vortex_array::extension::datetime::TimeValue
+
+pub fn vortex_array::extension::datetime::TimeValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_array::extension::datetime::TimestampValue<'a>
+
+pub vortex_array::extension::datetime::TimestampValue::Microseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+
+pub vortex_array::extension::datetime::TimestampValue::Milliseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+
+pub vortex_array::extension::datetime::TimestampValue::Nanoseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+
+pub vortex_array::extension::datetime::TimestampValue::Seconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+
+impl core::fmt::Display for vortex_array::extension::datetime::TimestampValue<'_>
+
+pub fn vortex_array::extension::datetime::TimestampValue<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::extension::datetime::AnyTemporal
+
+impl vortex_array::dtype::extension::Matcher for vortex_array::extension::datetime::AnyTemporal
+
+pub type vortex_array::extension::datetime::AnyTemporal::Match<'a> = vortex_array::extension::datetime::TemporalMetadata<'a>
+
+pub fn vortex_array::extension::datetime::AnyTemporal::matches(item: &vortex_array::dtype::extension::ExtDTypeRef) -> bool
+
+pub fn vortex_array::extension::datetime::AnyTemporal::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+pub struct vortex_array::extension::datetime::Date
+
+impl vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+
+pub fn vortex_array::extension::datetime::Date::try_new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDType<Self>>
+
+impl core::clone::Clone for vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::clone(&self) -> vortex_array::extension::datetime::Date
+
+impl core::cmp::Eq for vortex_array::extension::datetime::Date
+
+impl core::cmp::PartialEq for vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::eq(&self, other: &vortex_array::extension::datetime::Date) -> bool
+
+impl core::default::Default for vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::default() -> vortex_array::extension::datetime::Date
+
+impl core::fmt::Debug for vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::datetime::Date
+
+pub fn vortex_array::extension::datetime::Date::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Date
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Date
+
+pub type vortex_array::extension::datetime::Date::Metadata = vortex_array::extension::datetime::TimeUnit
+
+pub type vortex_array::extension::datetime::Date::NativeValue<'a> = vortex_array::extension::datetime::DateValue
+
+pub fn vortex_array::extension::datetime::Date::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Date::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Date::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Date::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Date::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Date::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Date::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Date::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Date::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub struct vortex_array::extension::datetime::Time
+
+impl vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+
+pub fn vortex_array::extension::datetime::Time::try_new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDType<Self>>
+
+impl core::clone::Clone for vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::clone(&self) -> vortex_array::extension::datetime::Time
+
+impl core::cmp::Eq for vortex_array::extension::datetime::Time
+
+impl core::cmp::PartialEq for vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::eq(&self, other: &vortex_array::extension::datetime::Time) -> bool
+
+impl core::default::Default for vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::default() -> vortex_array::extension::datetime::Time
+
+impl core::fmt::Debug for vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::datetime::Time
+
+pub fn vortex_array::extension::datetime::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Time
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Time
+
+pub type vortex_array::extension::datetime::Time::Metadata = vortex_array::extension::datetime::TimeUnit
+
+pub type vortex_array::extension::datetime::Time::NativeValue<'a> = vortex_array::extension::datetime::TimeValue
+
+pub fn vortex_array::extension::datetime::Time::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Time::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Time::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Time::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Time::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Time::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Time::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Time::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Time::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub struct vortex_array::extension::datetime::Timestamp
+
+impl vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+
+pub fn vortex_array::extension::datetime::Timestamp::new_with_options(options: vortex_array::extension::datetime::TimestampOptions, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+
+pub fn vortex_array::extension::datetime::Timestamp::new_with_tz(time_unit: vortex_array::extension::datetime::TimeUnit, timezone: core::option::Option<alloc::sync::Arc<str>>, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+
+impl core::clone::Clone for vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::clone(&self) -> vortex_array::extension::datetime::Timestamp
+
+impl core::cmp::Eq for vortex_array::extension::datetime::Timestamp
+
+impl core::cmp::PartialEq for vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::eq(&self, other: &vortex_array::extension::datetime::Timestamp) -> bool
+
+impl core::default::Default for vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::default() -> vortex_array::extension::datetime::Timestamp
+
+impl core::fmt::Debug for vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::datetime::Timestamp
+
+pub fn vortex_array::extension::datetime::Timestamp::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Timestamp
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Timestamp
+
+pub type vortex_array::extension::datetime::Timestamp::Metadata = vortex_array::extension::datetime::TimestampOptions
+
+pub type vortex_array::extension::datetime::Timestamp::NativeValue<'a> = vortex_array::extension::datetime::TimestampValue<'a>
+
+pub fn vortex_array::extension::datetime::Timestamp::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Timestamp::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::datetime::Timestamp::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::datetime::Timestamp::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::datetime::Timestamp::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::datetime::Timestamp::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::datetime::Timestamp::unpack_native<'a>(ext_dtype: &'a vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::datetime::Timestamp::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::datetime::Timestamp::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub struct vortex_array::extension::datetime::TimestampOptions
+
+pub vortex_array::extension::datetime::TimestampOptions::tz: core::option::Option<alloc::sync::Arc<str>>
+
+pub vortex_array::extension::datetime::TimestampOptions::unit: vortex_array::extension::datetime::TimeUnit
+
+impl core::clone::Clone for vortex_array::extension::datetime::TimestampOptions
+
+pub fn vortex_array::extension::datetime::TimestampOptions::clone(&self) -> vortex_array::extension::datetime::TimestampOptions
+
+impl core::cmp::Eq for vortex_array::extension::datetime::TimestampOptions
+
+impl core::cmp::PartialEq for vortex_array::extension::datetime::TimestampOptions
+
+pub fn vortex_array::extension::datetime::TimestampOptions::eq(&self, other: &vortex_array::extension::datetime::TimestampOptions) -> bool
+
+impl core::fmt::Debug for vortex_array::extension::datetime::TimestampOptions
+
+pub fn vortex_array::extension::datetime::TimestampOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::extension::datetime::TimestampOptions
+
+pub fn vortex_array::extension::datetime::TimestampOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::datetime::TimestampOptions
+
+pub fn vortex_array::extension::datetime::TimestampOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::TimestampOptions
+
+pub mod vortex_array::extension::uuid
+
+pub struct vortex_array::extension::uuid::Uuid
+
+impl core::clone::Clone for vortex_array::extension::uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::clone(&self) -> vortex_array::extension::uuid::Uuid
+
+impl core::cmp::Eq for vortex_array::extension::uuid::Uuid
+
+impl core::cmp::PartialEq for vortex_array::extension::uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::eq(&self, other: &vortex_array::extension::uuid::Uuid) -> bool
+
+impl core::default::Default for vortex_array::extension::uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::default() -> vortex_array::extension::uuid::Uuid
+
+impl core::fmt::Debug for vortex_array::extension::uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::uuid::Uuid
+
+impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::uuid::Uuid
+
+pub type vortex_array::extension::uuid::Uuid::Metadata = vortex_array::extension::uuid::UuidMetadata
+
+pub type vortex_array::extension::uuid::Uuid::NativeValue<'a> = uuid::Uuid
+
+pub fn vortex_array::extension::uuid::Uuid::can_coerce_from(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::uuid::Uuid::can_coerce_to(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> bool
+
+pub fn vortex_array::extension::uuid::Uuid::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_array::extension::uuid::Uuid::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_array::extension::uuid::Uuid::least_supertype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, other: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+
+pub fn vortex_array::extension::uuid::Uuid::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_array::extension::uuid::Uuid::unpack_native<'a>(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_array::extension::uuid::Uuid::validate_dtype(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub fn vortex_array::extension::uuid::Uuid::validate_scalar_value(ext_dtype: &vortex_array::dtype::extension::ExtDType<Self>, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<()>
+
+pub struct vortex_array::extension::uuid::UuidMetadata
+
+pub vortex_array::extension::uuid::UuidMetadata::version: core::option::Option<uuid::Version>
+
+impl core::clone::Clone for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::clone(&self) -> vortex_array::extension::uuid::UuidMetadata
+
+impl core::cmp::Eq for vortex_array::extension::uuid::UuidMetadata
+
+impl core::cmp::PartialEq for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::eq(&self, other: &Self) -> bool
+
+impl core::default::Default for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::default() -> vortex_array::extension::uuid::UuidMetadata
+
+impl core::fmt::Debug for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::uuid::UuidMetadata
+
+pub fn vortex_array::extension::uuid::UuidMetadata::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+pub struct vortex_array::extension::EmptyMetadata
+
+impl core::clone::Clone for vortex_array::extension::EmptyMetadata
+
+pub fn vortex_array::extension::EmptyMetadata::clone(&self) -> vortex_array::extension::EmptyMetadata
+
+impl core::cmp::Eq for vortex_array::extension::EmptyMetadata
+
+impl core::cmp::PartialEq for vortex_array::extension::EmptyMetadata
+
+pub fn vortex_array::extension::EmptyMetadata::eq(&self, other: &vortex_array::extension::EmptyMetadata) -> bool
+
+impl core::fmt::Debug for vortex_array::extension::EmptyMetadata
+
+pub fn vortex_array::extension::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::extension::EmptyMetadata
+
+pub fn vortex_array::extension::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::extension::EmptyMetadata
+
+pub fn vortex_array::extension::EmptyMetadata::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::extension::EmptyMetadata
+
+pub mod vortex_array::flatbuffers
+
+pub use vortex_array::flatbuffers::<<vortex_flatbuffers::array::*>>
+
+pub mod vortex_array::iter
+
+pub struct vortex_array::iter::ArrayIteratorAdapter<I>
+
+impl<I> vortex_array::iter::ArrayIteratorAdapter<I>
+
+pub fn vortex_array::iter::ArrayIteratorAdapter<I>::new(dtype: vortex_array::dtype::DType, inner: I) -> Self
+
+impl<I> core::iter::traits::iterator::Iterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+
+pub type vortex_array::iter::ArrayIteratorAdapter<I>::Item = core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
+
+pub fn vortex_array::iter::ArrayIteratorAdapter<I>::next(&mut self) -> core::option::Option<Self::Item>
+
+impl<I> vortex_array::iter::ArrayIterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+
+pub fn vortex_array::iter::ArrayIteratorAdapter<I>::dtype(&self) -> &vortex_array::dtype::DType
+
+pub trait vortex_array::iter::ArrayIterator: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+
+pub fn vortex_array::iter::ArrayIterator::dtype(&self) -> &vortex_array::dtype::DType
+
+impl vortex_array::iter::ArrayIterator for alloc::boxed::Box<(dyn vortex_array::iter::ArrayIterator + core::marker::Send)>
+
+pub fn alloc::boxed::Box<(dyn vortex_array::iter::ArrayIterator + core::marker::Send)>::dtype(&self) -> &vortex_array::dtype::DType
+
+impl vortex_array::iter::ArrayIterator for vortex_array::arrow::ArrowArrayStreamAdapter
+
+pub fn vortex_array::arrow::ArrowArrayStreamAdapter::dtype(&self) -> &vortex_array::dtype::DType
+
+impl<I> vortex_array::iter::ArrayIterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+
+pub fn vortex_array::iter::ArrayIteratorAdapter<I>::dtype(&self) -> &vortex_array::dtype::DType
+
+pub trait vortex_array::iter::ArrayIteratorExt: vortex_array::iter::ArrayIterator
+
+pub fn vortex_array::iter::ArrayIteratorExt::into_array_stream(self) -> impl vortex_array::stream::ArrayStream where Self: core::marker::Sized
+
+pub fn vortex_array::iter::ArrayIteratorExt::read_all(self) -> vortex_error::VortexResult<vortex_array::ArrayRef> where Self: core::marker::Sized
+
+impl<I: vortex_array::iter::ArrayIterator> vortex_array::iter::ArrayIteratorExt for I
+
+pub fn I::into_array_stream(self) -> impl vortex_array::stream::ArrayStream where Self: core::marker::Sized
+
+pub fn I::read_all(self) -> vortex_error::VortexResult<vortex_array::ArrayRef> where Self: core::marker::Sized
+
+pub mod vortex_array::kernel
+
+pub struct vortex_array::kernel::ParentKernelAdapter<V, K>
+
+impl<V: vortex_array::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> core::fmt::Debug for vortex_array::kernel::ParentKernelAdapter<V, K>
+
+pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<V: vortex_array::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> vortex_array::kernel::DynParentKernel<V> for vortex_array::kernel::ParentKernelAdapter<V, K>
+
+pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::execute_parent(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+pub struct vortex_array::kernel::ParentKernelSet<V: vortex_array::VTable>
+
+impl<V: vortex_array::VTable> vortex_array::kernel::ParentKernelSet<V>
+
+pub fn vortex_array::kernel::ParentKernelSet<V>::execute(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub const fn vortex_array::kernel::ParentKernelSet<V>::lift<K: vortex_array::kernel::ExecuteParentKernel<V>>(kernel: &'static K) -> &'static dyn vortex_array::kernel::DynParentKernel<V>
+
+pub const fn vortex_array::kernel::ParentKernelSet<V>::new(kernels: &'static [&'static dyn vortex_array::kernel::DynParentKernel<V>]) -> Self
+
+pub trait vortex_array::kernel::DynParentKernel<V: vortex_array::VTable>: core::marker::Send + core::marker::Sync
+
+pub fn vortex_array::kernel::DynParentKernel::execute_parent(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub fn vortex_array::kernel::DynParentKernel::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+impl<V: vortex_array::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> vortex_array::kernel::DynParentKernel<V> for vortex_array::kernel::ParentKernelAdapter<V, K>
+
+pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::execute_parent(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+pub trait vortex_array::kernel::ExecuteParentKernel<V: vortex_array::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub type vortex_array::kernel::ExecuteParentKernel::Parent: vortex_array::matcher::Matcher
+
+pub fn vortex_array::kernel::ExecuteParentKernel::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::dict::TakeExecuteAdaptor<V> where V: vortex_array::arrays::dict::TakeExecute
+
+pub type vortex_array::arrays::dict::TakeExecuteAdaptor<V>::Parent = vortex_array::arrays::dict::Dict
+
+pub fn vortex_array::arrays::dict::TakeExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::filter::FilterExecuteAdaptor<V> where V: vortex_array::arrays::filter::FilterKernel
+
+pub type vortex_array::arrays::filter::FilterExecuteAdaptor<V>::Parent = vortex_array::arrays::Filter
+
+pub fn vortex_array::arrays::filter::FilterExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::slice::SliceExecuteAdaptor<V> where V: vortex_array::arrays::slice::SliceKernel
+
+pub type vortex_array::arrays::slice::SliceExecuteAdaptor<V>::Parent = vortex_array::arrays::slice::Slice
+
+pub fn vortex_array::arrays::slice::SliceExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenKernel
+
+pub type vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+
+pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::binary::CompareKernel
+
+pub type vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::binary::Binary>
+
+pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::binary::Binary>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastKernel
+
+pub type vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+
+pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullKernel
+
+pub type vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeKernel
+
+pub type vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+
+pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel
+
+pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskKernel
+
+pub type vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+
+pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotKernel
+
+pub type vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+
+pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, _parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipKernel
+
+pub type vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+
+pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub mod vortex_array::mask
+
+pub mod vortex_array::matcher
+
+pub struct vortex_array::matcher::AnyArray
+
+impl core::fmt::Debug for vortex_array::matcher::AnyArray
+
+pub fn vortex_array::matcher::AnyArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::matcher::Matcher for vortex_array::matcher::AnyArray
+
+pub type vortex_array::matcher::AnyArray::Match<'a> = &'a vortex_array::ArrayRef
+
+pub fn vortex_array::matcher::AnyArray::matches(_array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::matcher::AnyArray::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+pub trait vortex_array::matcher::Matcher
+
+pub type vortex_array::matcher::Matcher::Match<'a>
+
+pub fn vortex_array::matcher::Matcher::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::matcher::Matcher::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl vortex_array::matcher::Matcher for vortex_array::AnyCanonical
+
+pub type vortex_array::AnyCanonical::Match<'a> = vortex_array::CanonicalView<'a>
+
+pub fn vortex_array::AnyCanonical::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::AnyCanonical::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl vortex_array::matcher::Matcher for vortex_array::AnyColumnar
+
+pub type vortex_array::AnyColumnar::Match<'a> = vortex_array::ColumnarView<'a>
+
+pub fn vortex_array::AnyColumnar::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::AnyColumnar::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl vortex_array::matcher::Matcher for vortex_array::arrays::scalar_fn::AnyScalarFn
+
+pub type vortex_array::arrays::scalar_fn::AnyScalarFn::Match<'a> = vortex_array::ArrayView<'a, vortex_array::arrays::scalar_fn::ScalarFnVTable>
+
+pub fn vortex_array::arrays::scalar_fn::AnyScalarFn::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::arrays::scalar_fn::AnyScalarFn::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl vortex_array::matcher::Matcher for vortex_array::matcher::AnyArray
+
+pub type vortex_array::matcher::AnyArray::Match<'a> = &'a vortex_array::ArrayRef
+
+pub fn vortex_array::matcher::AnyArray::matches(_array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::matcher::AnyArray::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl<F: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::matcher::Matcher for vortex_array::arrays::scalar_fn::ExactScalarFn<F>
+
+pub type vortex_array::arrays::scalar_fn::ExactScalarFn<F>::Match<'a> = vortex_array::arrays::scalar_fn::ScalarFnArrayView<'a, F>
+
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::arrays::scalar_fn::ExactScalarFn<F>::try_match(array: &vortex_array::ArrayRef) -> core::option::Option<Self::Match>
+
+impl<V: vortex_array::VTable> vortex_array::matcher::Matcher for V
+
+pub type V::Match<'a> = vortex_array::ArrayView<'a, V>
+
+pub fn V::matches(array: &vortex_array::ArrayRef) -> bool
+
+pub fn V::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<vortex_array::ArrayView<'a, V>>
+
+pub mod vortex_array::memory
+
+pub struct vortex_array::memory::DefaultHostAllocator
+
+impl core::default::Default for vortex_array::memory::DefaultHostAllocator
+
+pub fn vortex_array::memory::DefaultHostAllocator::default() -> vortex_array::memory::DefaultHostAllocator
+
+impl core::fmt::Debug for vortex_array::memory::DefaultHostAllocator
+
+pub fn vortex_array::memory::DefaultHostAllocator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::memory::HostAllocator for vortex_array::memory::DefaultHostAllocator
+
+pub fn vortex_array::memory::DefaultHostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub struct vortex_array::memory::MemorySession
+
+impl vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::allocator(&self) -> vortex_array::memory::HostAllocatorRef
+
+pub fn vortex_array::memory::MemorySession::new(allocator: vortex_array::memory::HostAllocatorRef) -> Self
+
+pub fn vortex_array::memory::MemorySession::set_allocator(&mut self, allocator: vortex_array::memory::HostAllocatorRef)
+
+impl core::default::Default for vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::default() -> Self
+
+impl core::fmt::Debug for vortex_array::memory::MemorySession
+
+pub fn vortex_array::memory::MemorySession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::memory::WritableHostBuffer
+
+impl vortex_array::memory::WritableHostBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::alignment(&self) -> vortex_buffer::alignment::Alignment
+
+pub fn vortex_array::memory::WritableHostBuffer::as_mut_slice(&mut self) -> &mut [u8]
+
+pub fn vortex_array::memory::WritableHostBuffer::as_mut_slice_typed<T>(&mut self) -> vortex_error::VortexResult<&mut [T]>
+
+pub fn vortex_array::memory::WritableHostBuffer::freeze(self) -> vortex_buffer::ByteBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::freeze_typed<T>(self) -> vortex_error::VortexResult<vortex_buffer::buffer::Buffer<T>>
+
+pub fn vortex_array::memory::WritableHostBuffer::is_empty(&self) -> bool
+
+pub fn vortex_array::memory::WritableHostBuffer::len(&self) -> usize
+
+pub fn vortex_array::memory::WritableHostBuffer::new(inner: alloc::boxed::Box<dyn vortex_array::memory::HostBufferMut>) -> Self
+
+impl core::fmt::Debug for vortex_array::memory::WritableHostBuffer
+
+pub fn vortex_array::memory::WritableHostBuffer::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub trait vortex_array::memory::HostAllocator: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub fn vortex_array::memory::HostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+impl vortex_array::memory::HostAllocator for vortex_array::memory::DefaultHostAllocator
+
+pub fn vortex_array::memory::DefaultHostAllocator::allocate(&self, len: usize, alignment: vortex_buffer::alignment::Alignment) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub trait vortex_array::memory::HostAllocatorExt: vortex_array::memory::HostAllocator
+
+pub fn vortex_array::memory::HostAllocatorExt::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+impl<A: vortex_array::memory::HostAllocator + ?core::marker::Sized> vortex_array::memory::HostAllocatorExt for A
+
+pub fn A::allocate_typed<T>(&self, len: usize) -> vortex_error::VortexResult<vortex_array::memory::WritableHostBuffer>
+
+pub trait vortex_array::memory::HostBufferMut: core::marker::Send + 'static
+
+pub fn vortex_array::memory::HostBufferMut::alignment(&self) -> vortex_buffer::alignment::Alignment
+
+pub fn vortex_array::memory::HostBufferMut::as_mut_slice(&mut self) -> &mut [u8]
+
+pub fn vortex_array::memory::HostBufferMut::freeze(self: alloc::boxed::Box<Self>) -> vortex_buffer::ByteBuffer
+
+pub fn vortex_array::memory::HostBufferMut::is_empty(&self) -> bool
+
+pub fn vortex_array::memory::HostBufferMut::len(&self) -> usize
+
+pub trait vortex_array::memory::MemorySessionExt: vortex_session::SessionExt
+
+pub fn vortex_array::memory::MemorySessionExt::allocator(&self) -> vortex_array::memory::HostAllocatorRef
+
+pub fn vortex_array::memory::MemorySessionExt::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
+
+pub fn vortex_array::memory::MemorySessionExt::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
+
+impl<S: vortex_session::SessionExt> vortex_array::memory::MemorySessionExt for S
+
+pub fn S::allocator(&self) -> vortex_array::memory::HostAllocatorRef
+
+pub fn S::memory(&self) -> vortex_session::Ref<'_, vortex_array::memory::MemorySession>
+
+pub fn S::memory_mut(&self) -> vortex_session::RefMut<'_, vortex_array::memory::MemorySession>
+
+pub type vortex_array::memory::HostAllocatorRef = alloc::sync::Arc<dyn vortex_array::memory::HostAllocator>
+
+pub mod vortex_array::normalize
+
+pub enum vortex_array::normalize::Operation<'a>
+
+pub vortex_array::normalize::Operation::Error
+
+pub vortex_array::normalize::Operation::Execute(&'a mut vortex_array::ExecutionCtx)
+
+pub struct vortex_array::normalize::NormalizeOptions<'a>
+
+pub vortex_array::normalize::NormalizeOptions::allowed: &'a vortex_utils::aliases::hash_set::HashSet<vortex_session::registry::Id>
+
+pub vortex_array::normalize::NormalizeOptions::operation: vortex_array::normalize::Operation<'a>
+
+pub mod vortex_array::optimizer
+
+pub mod vortex_array::optimizer::rules
+
+pub struct vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>
+
+impl<V: vortex_array::VTable, K: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> vortex_array::optimizer::rules::DynArrayParentReduceRule<V> for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>
+
+pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::reduce_parent(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V: vortex_array::VTable, R: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> core::fmt::Debug for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>
+
+pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::optimizer::rules::ParentRuleSet<V: vortex_array::VTable>
+
+impl<V: vortex_array::VTable> vortex_array::optimizer::rules::ParentRuleSet<V>
+
+pub fn vortex_array::optimizer::rules::ParentRuleSet<V>::evaluate(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub const fn vortex_array::optimizer::rules::ParentRuleSet<V>::lift<R: vortex_array::optimizer::rules::ArrayParentReduceRule<V>>(rule: &'static R) -> &'static dyn vortex_array::optimizer::rules::DynArrayParentReduceRule<V>
+
+pub const fn vortex_array::optimizer::rules::ParentRuleSet<V>::new(rules: &'static [&'static dyn vortex_array::optimizer::rules::DynArrayParentReduceRule<V>]) -> Self
+
+pub struct vortex_array::optimizer::rules::ReduceRuleSet<V: vortex_array::VTable>
+
+impl<V: vortex_array::VTable> vortex_array::optimizer::rules::ReduceRuleSet<V>
+
+pub fn vortex_array::optimizer::rules::ReduceRuleSet<V>::evaluate(&self, array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub const fn vortex_array::optimizer::rules::ReduceRuleSet<V>::new(rules: &'static [&'static dyn vortex_array::optimizer::rules::ArrayReduceRule<V>]) -> Self
+
+pub trait vortex_array::optimizer::rules::ArrayParentReduceRule<V: vortex_array::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub type vortex_array::optimizer::rules::ArrayParentReduceRule::Parent: vortex_array::matcher::Matcher
+
+pub fn vortex_array::optimizer::rules::ArrayParentReduceRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Bool> for vortex_array::arrays::bool::BoolMaskedValidityRule
+
+pub type vortex_array::arrays::bool::BoolMaskedValidityRule::Parent = vortex_array::arrays::Masked
+
+pub fn vortex_array::arrays::bool::BoolMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Decimal> for vortex_array::arrays::decimal::DecimalMaskedValidityRule
+
+pub type vortex_array::arrays::decimal::DecimalMaskedValidityRule::Parent = vortex_array::arrays::Masked
+
+pub fn vortex_array::arrays::decimal::DecimalMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::Primitive> for vortex_array::arrays::primitive::PrimitiveMaskedValidityRule
+
+pub type vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::Masked
+
+pub fn vortex_array::arrays::primitive::PrimitiveMaskedValidityRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::dict::TakeReduceAdaptor<V> where V: vortex_array::arrays::dict::TakeReduce
+
+pub type vortex_array::arrays::dict::TakeReduceAdaptor<V>::Parent = vortex_array::arrays::dict::Dict
+
+pub fn vortex_array::arrays::dict::TakeReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::filter::FilterReduceAdaptor<V> where V: vortex_array::arrays::filter::FilterReduce
+
+pub type vortex_array::arrays::filter::FilterReduceAdaptor<V>::Parent = vortex_array::arrays::Filter
+
+pub fn vortex_array::arrays::filter::FilterReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::slice::SliceReduceAdaptor<V> where V: vortex_array::arrays::slice::SliceReduce
+
+pub type vortex_array::arrays::slice::SliceReduceAdaptor<V>::Parent = vortex_array::arrays::slice::Slice
+
+pub fn vortex_array::arrays::slice::SliceReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenReduce
+
+pub type vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+
+pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastReduce
+
+pub type vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+
+pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::cast::Cast>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullReduce
+
+pub type vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeReduce
+
+pub type vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+
+pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce
+
+pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskReduce
+
+pub type vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+
+pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotReduce
+
+pub type vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+
+pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, _parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipReduce
+
+pub type vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+
+pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub trait vortex_array::optimizer::rules::ArrayReduceRule<V: vortex_array::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub fn vortex_array::optimizer::rules::ArrayReduceRule::reduce(&self, array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub trait vortex_array::optimizer::rules::DynArrayParentReduceRule<V: vortex_array::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync
+
+pub fn vortex_array::optimizer::rules::DynArrayParentReduceRule::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::optimizer::rules::DynArrayParentReduceRule::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+impl<V: vortex_array::VTable, K: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> vortex_array::optimizer::rules::DynArrayParentReduceRule<V> for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>
+
+pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+
+pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::reduce_parent(&self, child: vortex_array::ArrayView<'_, V>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+
+pub trait vortex_array::optimizer::ArrayOptimizer
+
+pub fn vortex_array::optimizer::ArrayOptimizer::optimize(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+
+pub fn vortex_array::optimizer::ArrayOptimizer::optimize_recursive(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+
+impl vortex_array::optimizer::ArrayOptimizer for vortex_array::ArrayRef
+
+pub fn vortex_array::ArrayRef::optimize(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+
+pub fn vortex_array::ArrayRef::optimize_recursive(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+
+pub mod vortex_array::patches
+
+pub struct vortex_array::patches::Patches
+
+impl vortex_array::patches::Patches
+
+pub unsafe fn vortex_array::patches::Patches::apply_to_buffer<P: vortex_array::dtype::NativePType>(&self, buffer: &mut [P], validity: &mut vortex_mask::mask_mut::MaskMut, ctx: &mut vortex_array::ExecutionCtx)
+
+pub fn vortex_array::patches::Patches::array_len(&self) -> usize
+
+pub fn vortex_array::patches::Patches::cast_values(self, values_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::patches::Patches::chunk_offset_at(&self, idx: usize) -> vortex_error::VortexResult<usize>
+
+pub fn vortex_array::patches::Patches::chunk_offsets(&self) -> &core::option::Option<vortex_array::ArrayRef>
+
+pub fn vortex_array::patches::Patches::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::patches::Patches::filter(&self, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::get_patched(&self, index: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::patches::Patches::indices(&self) -> &vortex_array::ArrayRef
+
+pub fn vortex_array::patches::Patches::indices_mut(&mut self) -> &mut vortex_array::ArrayRef
+
+pub fn vortex_array::patches::Patches::indices_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::PType>
+
+pub fn vortex_array::patches::Patches::into_indices(self) -> vortex_array::ArrayRef
+
+pub fn vortex_array::patches::Patches::into_values(self) -> vortex_array::ArrayRef
+
+pub fn vortex_array::patches::Patches::map_values<F>(self, f: F) -> vortex_error::VortexResult<Self> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+
+pub fn vortex_array::patches::Patches::mask(&self, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::max_index(&self) -> vortex_error::VortexResult<usize>
+
+pub fn vortex_array::patches::Patches::min_index(&self) -> vortex_error::VortexResult<usize>
+
+pub fn vortex_array::patches::Patches::new(array_len: usize, offset: usize, indices: vortex_array::ArrayRef, values: vortex_array::ArrayRef, chunk_offsets: core::option::Option<vortex_array::ArrayRef>) -> vortex_error::VortexResult<Self>
+
+pub unsafe fn vortex_array::patches::Patches::new_unchecked(array_len: usize, offset: usize, indices: vortex_array::ArrayRef, values: vortex_array::ArrayRef, chunk_offsets: core::option::Option<vortex_array::ArrayRef>, offset_within_chunk: core::option::Option<usize>) -> Self
+
+pub fn vortex_array::patches::Patches::num_patches(&self) -> usize
+
+pub fn vortex_array::patches::Patches::offset(&self) -> usize
+
+pub fn vortex_array::patches::Patches::offset_within_chunk(&self) -> core::option::Option<usize>
+
+pub fn vortex_array::patches::Patches::search_index(&self, index: usize) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult>
+
+pub fn vortex_array::patches::Patches::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::take(&self, take_indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::take_map(&self, take_indices: vortex_array::arrays::PrimitiveArray, include_nulls: bool, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::take_search(&self, take_indices: vortex_array::arrays::PrimitiveArray, include_nulls: bool, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::take_with_nulls(&self, take_indices: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::patches::Patches::to_metadata(&self, len: usize, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::patches::PatchesMetadata>
+
+pub fn vortex_array::patches::Patches::values(&self) -> &vortex_array::ArrayRef
+
+pub fn vortex_array::patches::Patches::values_mut(&mut self) -> &mut vortex_array::ArrayRef
+
+impl core::clone::Clone for vortex_array::patches::Patches
+
+pub fn vortex_array::patches::Patches::clone(&self) -> vortex_array::patches::Patches
+
+impl core::fmt::Debug for vortex_array::patches::Patches
+
+pub fn vortex_array::patches::Patches::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::ArrayEq for vortex_array::patches::Patches
+
+pub fn vortex_array::patches::Patches::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+
+impl vortex_array::ArrayHash for vortex_array::patches::Patches
+
+pub fn vortex_array::patches::Patches::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+
+pub struct vortex_array::patches::PatchesMetadata
+
+impl vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_dtype(&self) -> vortex_error::VortexResult<core::option::Option<vortex_array::dtype::DType>>
+
+pub fn vortex_array::patches::PatchesMetadata::indices_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_array::patches::PatchesMetadata::is_empty(&self) -> bool
+
+pub fn vortex_array::patches::PatchesMetadata::len(&self) -> vortex_error::VortexResult<usize>
+
+pub fn vortex_array::patches::PatchesMetadata::new(len: usize, offset: usize, indices_ptype: vortex_array::dtype::PType, chunk_offsets_len: core::option::Option<usize>, chunk_offsets_ptype: core::option::Option<vortex_array::dtype::PType>, offset_within_chunk: core::option::Option<usize>) -> Self
+
+pub fn vortex_array::patches::PatchesMetadata::offset(&self) -> vortex_error::VortexResult<usize>
+
+impl vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_len(&self) -> u64
+
+pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_ptype(&self) -> vortex_array::dtype::PType
+
+pub fn vortex_array::patches::PatchesMetadata::indices_ptype(&self) -> vortex_array::dtype::PType
+
+pub fn vortex_array::patches::PatchesMetadata::offset_within_chunk(&self) -> u64
+
+pub fn vortex_array::patches::PatchesMetadata::set_chunk_offsets_ptype(&mut self, value: vortex_array::dtype::PType)
+
+pub fn vortex_array::patches::PatchesMetadata::set_indices_ptype(&mut self, value: vortex_array::dtype::PType)
+
+impl core::clone::Clone for vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::clone(&self) -> vortex_array::patches::PatchesMetadata
+
+impl core::default::Default for vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::default() -> Self
+
+impl core::fmt::Debug for vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_array::patches::PatchesMetadata
+
+impl prost::message::Message for vortex_array::patches::PatchesMetadata
+
+pub fn vortex_array::patches::PatchesMetadata::clear(&mut self)
+
+pub fn vortex_array::patches::PatchesMetadata::encoded_len(&self) -> usize
+
+pub const vortex_array::patches::PATCH_CHUNK_SIZE: usize
+
+pub mod vortex_array::scalar
+
+pub enum vortex_array::scalar::DecimalValue
+
+pub vortex_array::scalar::DecimalValue::I128(i128)
+
+pub vortex_array::scalar::DecimalValue::I16(i16)
+
+pub vortex_array::scalar::DecimalValue::I256(vortex_array::dtype::i256)
+
+pub vortex_array::scalar::DecimalValue::I32(i32)
+
+pub vortex_array::scalar::DecimalValue::I64(i64)
+
+pub vortex_array::scalar::DecimalValue::I8(i8)
+
+impl vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::cast<T: vortex_array::dtype::NativeDecimalType>(&self) -> core::option::Option<T>
+
+pub fn vortex_array::scalar::DecimalValue::checked_add(&self, other: &Self) -> core::option::Option<Self>
+
+pub fn vortex_array::scalar::DecimalValue::checked_div(&self, other: &Self) -> core::option::Option<Self>
+
+pub fn vortex_array::scalar::DecimalValue::checked_mul(&self, other: &Self) -> core::option::Option<Self>
+
+pub fn vortex_array::scalar::DecimalValue::checked_sub(&self, other: &Self) -> core::option::Option<Self>
+
+pub fn vortex_array::scalar::DecimalValue::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
+
+pub fn vortex_array::scalar::DecimalValue::decimal_type(&self) -> vortex_array::dtype::DecimalType
+
+pub fn vortex_array::scalar::DecimalValue::fits_in_precision(&self, decimal_type: vortex_array::dtype::DecimalDType) -> bool
+
+pub fn vortex_array::scalar::DecimalValue::is_zero(&self) -> bool
+
+pub fn vortex_array::scalar::DecimalValue::zero(decimal_type: &vortex_array::dtype::DecimalDType) -> Self
+
+impl core::clone::Clone for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::clone(&self) -> vortex_array::scalar::DecimalValue
+
+impl core::cmp::Eq for vortex_array::scalar::DecimalValue
+
+impl core::cmp::PartialEq for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<i128> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: i128) -> Self
+
+impl core::convert::From<i16> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: i16) -> Self
+
+impl core::convert::From<i32> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: i32) -> Self
+
+impl core::convert::From<i64> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: i64) -> Self
+
+impl core::convert::From<i8> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: i8) -> Self
+
+impl core::convert::From<u16> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: u16) -> Self
+
+impl core::convert::From<u32> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: u32) -> Self
+
+impl core::convert::From<u64> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: u64) -> Self
+
+impl core::convert::From<u8> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: u8) -> Self
+
+impl core::convert::From<vortex_array::dtype::i256> for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::from(value: vortex_array::dtype::i256) -> Self
+
+impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: vortex_array::scalar::DecimalValue) -> Self
+
+impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::DecimalValue) -> Self
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+
+pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalValue::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+
+pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalValue::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::DecimalValue::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+impl core::marker::Copy for vortex_array::scalar::DecimalValue
+
+pub enum vortex_array::scalar::NumericOperator
+
+pub vortex_array::scalar::NumericOperator::Add
+
+pub vortex_array::scalar::NumericOperator::Div
+
+pub vortex_array::scalar::NumericOperator::Mul
+
+pub vortex_array::scalar::NumericOperator::Sub
+
+impl core::clone::Clone for vortex_array::scalar::NumericOperator
+
+pub fn vortex_array::scalar::NumericOperator::clone(&self) -> vortex_array::scalar::NumericOperator
+
+impl core::cmp::Eq for vortex_array::scalar::NumericOperator
+
+impl core::cmp::PartialEq for vortex_array::scalar::NumericOperator
+
+pub fn vortex_array::scalar::NumericOperator::eq(&self, other: &vortex_array::scalar::NumericOperator) -> bool
+
+impl core::convert::From<vortex_array::scalar::NumericOperator> for vortex_array::scalar_fn::fns::operators::Operator
+
+pub fn vortex_array::scalar_fn::fns::operators::Operator::from(op: vortex_array::scalar::NumericOperator) -> Self
+
+impl core::fmt::Debug for vortex_array::scalar::NumericOperator
+
+pub fn vortex_array::scalar::NumericOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::scalar::NumericOperator
+
+pub fn vortex_array::scalar::NumericOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_array::scalar::NumericOperator
+
+impl core::marker::StructuralPartialEq for vortex_array::scalar::NumericOperator
+
+pub enum vortex_array::scalar::PValue
+
+pub vortex_array::scalar::PValue::F16(half::binary16::f16)
+
+pub vortex_array::scalar::PValue::F32(f32)
+
+pub vortex_array::scalar::PValue::F64(f64)
+
+pub vortex_array::scalar::PValue::I16(i16)
+
+pub vortex_array::scalar::PValue::I32(i32)
+
+pub vortex_array::scalar::PValue::I64(i64)
+
+pub vortex_array::scalar::PValue::I8(i8)
+
+pub vortex_array::scalar::PValue::U16(u16)
+
+pub vortex_array::scalar::PValue::U32(u32)
+
+pub vortex_array::scalar::PValue::U64(u64)
+
+pub vortex_array::scalar::PValue::U8(u8)
+
+impl vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::as_f16(self) -> core::option::Option<half::binary16::f16>
+
+pub fn vortex_array::scalar::PValue::as_f32(self) -> core::option::Option<f32>
+
+pub fn vortex_array::scalar::PValue::as_f64(self) -> core::option::Option<f64>
+
+pub fn vortex_array::scalar::PValue::as_i16(self) -> core::option::Option<i16>
+
+pub fn vortex_array::scalar::PValue::as_i32(self) -> core::option::Option<i32>
+
+pub fn vortex_array::scalar::PValue::as_i64(self) -> core::option::Option<i64>
+
+pub fn vortex_array::scalar::PValue::as_i8(self) -> core::option::Option<i8>
+
+pub fn vortex_array::scalar::PValue::as_u16(self) -> core::option::Option<u16>
+
+pub fn vortex_array::scalar::PValue::as_u32(self) -> core::option::Option<u32>
+
+pub fn vortex_array::scalar::PValue::as_u64(self) -> core::option::Option<u64>
+
+pub fn vortex_array::scalar::PValue::as_u8(self) -> core::option::Option<u8>
+
+pub fn vortex_array::scalar::PValue::cast<T: vortex_array::dtype::NativePType>(&self) -> vortex_error::VortexResult<T>
+
+pub fn vortex_array::scalar::PValue::is_instance_of(&self, ptype: &vortex_array::dtype::PType) -> bool
+
+pub fn vortex_array::scalar::PValue::is_nan(&self) -> bool
+
+pub fn vortex_array::scalar::PValue::is_zero(&self) -> bool
+
+pub fn vortex_array::scalar::PValue::ptype(&self) -> vortex_array::dtype::PType
+
+pub fn vortex_array::scalar::PValue::reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> Self
+
+pub fn vortex_array::scalar::PValue::zero(ptype: &vortex_array::dtype::PType) -> vortex_array::scalar::PValue
+
+impl core::clone::Clone for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::clone(&self) -> vortex_array::scalar::PValue
+
+impl core::cmp::Eq for vortex_array::scalar::PValue
+
+impl core::cmp::PartialEq for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<&vortex_array::scalar::PValue> for vortex_proto::scalar::ScalarValue
+
+pub fn vortex_proto::scalar::ScalarValue::from(value: &vortex_array::scalar::PValue) -> Self
+
+impl core::convert::From<f32> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: f32) -> Self
+
+impl core::convert::From<f64> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: f64) -> Self
+
+impl core::convert::From<half::binary16::f16> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: half::binary16::f16) -> Self
+
+impl core::convert::From<i16> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: i16) -> Self
+
+impl core::convert::From<i32> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: i32) -> Self
+
+impl core::convert::From<i64> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: i64) -> Self
+
+impl core::convert::From<i8> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: i8) -> Self
+
+impl core::convert::From<u16> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: u16) -> Self
+
+impl core::convert::From<u32> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: u32) -> Self
+
+impl core::convert::From<u64> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: u64) -> Self
+
+impl core::convert::From<u8> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: u8) -> Self
+
+impl core::convert::From<usize> for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::from(value: usize) -> vortex_array::scalar::PValue
+
+impl core::convert::From<vortex_array::scalar::PValue> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::PValue) -> Self
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for f32
+
+pub type f32::Error = vortex_error::VortexError
+
+pub fn f32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for f64
+
+pub type f64::Error = vortex_error::VortexError
+
+pub fn f64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for half::binary16::f16
+
+pub type half::binary16::f16::Error = vortex_error::VortexError
+
+pub fn half::binary16::f16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for i16
+
+pub type i16::Error = vortex_error::VortexError
+
+pub fn i16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for i32
+
+pub type i32::Error = vortex_error::VortexError
+
+pub fn i32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for i64
+
+pub type i64::Error = vortex_error::VortexError
+
+pub fn i64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for i8
+
+pub type i8::Error = vortex_error::VortexError
+
+pub fn i8::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for u16
+
+pub type u16::Error = vortex_error::VortexError
+
+pub fn u16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for u32
+
+pub type u32::Error = vortex_error::VortexError
+
+pub fn u32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for u64
+
+pub type u64::Error = vortex_error::VortexError
+
+pub fn u64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for u8
+
+pub type u8::Error = vortex_error::VortexError
+
+pub fn u8::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::PValue> for usize
+
+pub type usize::Error = vortex_error::VortexError
+
+pub fn usize::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+impl core::marker::Copy for vortex_array::scalar::PValue
+
+impl vortex_array::dtype::ToBytes for vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::PValue::to_le_bytes(&self) -> &[u8]
+
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub enum vortex_array::scalar::ScalarValue
+
+pub vortex_array::scalar::ScalarValue::Binary(vortex_buffer::ByteBuffer)
+
+pub vortex_array::scalar::ScalarValue::Bool(bool)
+
+pub vortex_array::scalar::ScalarValue::Decimal(vortex_array::scalar::DecimalValue)
+
+pub vortex_array::scalar::ScalarValue::List(alloc::vec::Vec<core::option::Option<vortex_array::scalar::ScalarValue>>)
+
+pub vortex_array::scalar::ScalarValue::Primitive(vortex_array::scalar::PValue)
+
+pub vortex_array::scalar::ScalarValue::Utf8(vortex_buffer::string::BufferString)
+
+pub vortex_array::scalar::ScalarValue::Variant(alloc::boxed::Box<vortex_array::scalar::Scalar>)
+
+impl vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::as_binary(&self) -> &vortex_buffer::ByteBuffer
+
+pub fn vortex_array::scalar::ScalarValue::as_bool(&self) -> bool
+
+pub fn vortex_array::scalar::ScalarValue::as_decimal(&self) -> &vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::ScalarValue::as_list(&self) -> &[core::option::Option<vortex_array::scalar::ScalarValue>]
+
+pub fn vortex_array::scalar::ScalarValue::as_primitive(&self) -> &vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::ScalarValue::as_utf8(&self) -> &vortex_buffer::string::BufferString
+
+pub fn vortex_array::scalar::ScalarValue::as_variant(&self) -> &vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::ScalarValue::into_binary(self) -> vortex_buffer::ByteBuffer
+
+pub fn vortex_array::scalar::ScalarValue::into_bool(self) -> bool
+
+pub fn vortex_array::scalar::ScalarValue::into_decimal(self) -> vortex_array::scalar::DecimalValue
+
+pub fn vortex_array::scalar::ScalarValue::into_list(self) -> alloc::vec::Vec<core::option::Option<vortex_array::scalar::ScalarValue>>
+
+pub fn vortex_array::scalar::ScalarValue::into_primitive(self) -> vortex_array::scalar::PValue
+
+pub fn vortex_array::scalar::ScalarValue::into_utf8(self) -> vortex_buffer::string::BufferString
+
+pub fn vortex_array::scalar::ScalarValue::into_variant(self) -> vortex_array::scalar::Scalar
+
+impl vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from_proto(value: &vortex_proto::scalar::ScalarValue, dtype: &vortex_array::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+pub fn vortex_array::scalar::ScalarValue::from_proto_bytes(bytes: &[u8], dtype: &vortex_array::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<Self>>
+
+impl vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::to_proto(this: core::option::Option<&Self>) -> vortex_proto::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::to_proto_bytes<B: core::default::Default + bytes::buf::buf_mut::BufMut>(value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> B
+
+impl core::clone::Clone for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::clone(&self) -> vortex_array::scalar::ScalarValue
+
+impl core::cmp::Eq for vortex_array::scalar::ScalarValue
+
+impl core::cmp::PartialEq for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::eq(&self, other: &vortex_array::scalar::ScalarValue) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<&[u8]> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: &[u8]) -> Self
+
+impl core::convert::From<&str> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: &str) -> Self
+
+impl core::convert::From<&vortex_array::scalar::ScalarValue> for vortex_proto::scalar::ScalarValue
+
+pub fn vortex_proto::scalar::ScalarValue::from(value: &vortex_array::scalar::ScalarValue) -> Self
+
+impl core::convert::From<alloc::string::String> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: alloc::string::String) -> Self
+
+impl core::convert::From<bool> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: bool) -> Self
+
+impl core::convert::From<f32> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: f32) -> Self
+
+impl core::convert::From<f64> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: f64) -> Self
+
+impl core::convert::From<half::binary16::f16> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: half::binary16::f16) -> Self
+
+impl core::convert::From<i16> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: i16) -> Self
+
+impl core::convert::From<i32> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: i32) -> Self
+
+impl core::convert::From<i64> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: i64) -> Self
+
+impl core::convert::From<i8> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: i8) -> Self
+
+impl core::convert::From<u16> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: u16) -> Self
+
+impl core::convert::From<u32> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: u32) -> Self
+
+impl core::convert::From<u64> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: u64) -> Self
+
+impl core::convert::From<u8> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: u8) -> Self
+
+impl core::convert::From<usize> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: usize) -> Self
+
+impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::DecimalValue) -> Self
+
+impl core::convert::From<vortex_array::scalar::PValue> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::PValue) -> Self
+
+impl core::convert::From<vortex_buffer::buffer::Buffer<u8>> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_buffer::ByteBuffer) -> Self
+
+impl core::convert::From<vortex_buffer::string::BufferString> for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::from(value: vortex_buffer::string::BufferString) -> Self
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for f32
+
+pub type f32::Error = vortex_error::VortexError
+
+pub fn f32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for f64
+
+pub type f64::Error = vortex_error::VortexError
+
+pub fn f64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for half::binary16::f16
+
+pub type half::binary16::f16::Error = vortex_error::VortexError
+
+pub fn half::binary16::f16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i16
+
+pub type i16::Error = vortex_error::VortexError
+
+pub fn i16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i32
+
+pub type i32::Error = vortex_error::VortexError
+
+pub fn i32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i64
+
+pub type i64::Error = vortex_error::VortexError
+
+pub fn i64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i8
+
+pub type i8::Error = vortex_error::VortexError
+
+pub fn i8::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u16
+
+pub type u16::Error = vortex_error::VortexError
+
+pub fn u16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u32
+
+pub type u32::Error = vortex_error::VortexError
+
+pub fn u32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u64
+
+pub type u64::Error = vortex_error::VortexError
+
+pub fn u64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u8
+
+pub type u8::Error = vortex_error::VortexError
+
+pub fn u8::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for usize
+
+pub type usize::Error = vortex_error::VortexError
+
+pub fn usize::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+
+impl core::fmt::Debug for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::ScalarValue
+
+pub fn vortex_array::scalar::ScalarValue::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_array::scalar::ScalarValue
+
+impl<T> core::convert::From<alloc::vec::Vec<T>> for vortex_array::scalar::ScalarValue where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+
+pub fn vortex_array::scalar::ScalarValue::from(vec: alloc::vec::Vec<T>) -> Self
+
+pub struct vortex_array::scalar::BinaryScalar<'a>
+
+impl<'a> vortex_array::scalar::BinaryScalar<'a>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::is_empty(&self) -> core::option::Option<bool>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::len(&self) -> core::option::Option<usize>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::value(&self) -> core::option::Option<&'a vortex_buffer::ByteBuffer>
+
+impl core::cmp::Eq for vortex_array::scalar::BinaryScalar<'_>
+
+impl core::cmp::Ord for vortex_array::scalar::BinaryScalar<'_>
+
+pub fn vortex_array::scalar::BinaryScalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::scalar::BinaryScalar<'_>
+
+pub fn vortex_array::scalar::BinaryScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::BinaryScalar<'_>
+
+pub fn vortex_array::scalar::BinaryScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::fmt::Display for vortex_array::scalar::BinaryScalar<'_>
+
+pub fn vortex_array::scalar::BinaryScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::clone::Clone for vortex_array::scalar::BinaryScalar<'a>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::clone(&self) -> vortex_array::scalar::BinaryScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BinaryScalar<'a>
+
+pub type vortex_array::scalar::BinaryScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::BinaryScalar<'a>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::hash::Hash for vortex_array::scalar::BinaryScalar<'a>
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+pub struct vortex_array::scalar::BoolScalar<'a>
+
+impl<'a> vortex_array::scalar::BoolScalar<'a>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::BoolScalar<'a>::into_scalar(self) -> vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::BoolScalar<'a>::invert(self) -> vortex_array::scalar::BoolScalar<'a>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::value(&self) -> core::option::Option<bool>
+
+impl core::cmp::Ord for vortex_array::scalar::BoolScalar<'_>
+
+pub fn vortex_array::scalar::BoolScalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
+
+impl core::cmp::PartialEq for vortex_array::scalar::BoolScalar<'_>
+
+pub fn vortex_array::scalar::BoolScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::BoolScalar<'_>
+
+pub fn vortex_array::scalar::BoolScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::fmt::Display for vortex_array::scalar::BoolScalar<'_>
+
+pub fn vortex_array::scalar::BoolScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::clone::Clone for vortex_array::scalar::BoolScalar<'a>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::clone(&self) -> vortex_array::scalar::BoolScalar<'a>
+
+impl<'a> core::cmp::Eq for vortex_array::scalar::BoolScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BoolScalar<'a>
+
+pub type vortex_array::scalar::BoolScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::BoolScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::BoolScalar<'a>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::hash::Hash for vortex_array::scalar::BoolScalar<'a>
+
+pub fn vortex_array::scalar::BoolScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+pub struct vortex_array::scalar::DecimalScalar<'a>
+
+impl<'a> vortex_array::scalar::DecimalScalar<'a>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::checked_binary_numeric(&self, other: &vortex_array::scalar::DecimalScalar<'a>, op: vortex_array::scalar::NumericOperator) -> core::option::Option<vortex_array::scalar::DecimalScalar<'a>>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::decimal_value(&self) -> core::option::Option<vortex_array::scalar::DecimalValue>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::is_zero(&self) -> core::option::Option<bool>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+impl core::cmp::Eq for vortex_array::scalar::DecimalScalar<'_>
+
+impl core::cmp::PartialEq for vortex_array::scalar::DecimalScalar<'_>
+
+pub fn vortex_array::scalar::DecimalScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::DecimalScalar<'_>
+
+pub fn vortex_array::scalar::DecimalScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(ds: vortex_array::scalar::DecimalScalar<'_>) -> Self
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i128>
+
+pub type core::option::Option<i128>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i128>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i16>
+
+pub type core::option::Option<i16>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i16>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i32>
+
+pub type core::option::Option<i32>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i32>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i64>
+
+pub type core::option::Option<i64>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i64>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i8>
+
+pub type core::option::Option<i8>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i8>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<vortex_array::dtype::i256>
+
+pub type core::option::Option<vortex_array::dtype::i256>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_array::dtype::i256>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i128
+
+pub type i128::Error = vortex_error::VortexError
+
+pub fn i128::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i16
+
+pub type i16::Error = vortex_error::VortexError
+
+pub fn i16::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i32
+
+pub type i32::Error = vortex_error::VortexError
+
+pub fn i32::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i64
+
+pub type i64::Error = vortex_error::VortexError
+
+pub fn i64::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i8
+
+pub type i8::Error = vortex_error::VortexError
+
+pub fn i8::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::dtype::i256
+
+pub type vortex_array::dtype::i256::Error = vortex_error::VortexError
+
+pub fn vortex_array::dtype::i256::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Display for vortex_array::scalar::DecimalScalar<'_>
+
+pub fn vortex_array::scalar::DecimalScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::clone::Clone for vortex_array::scalar::DecimalScalar<'a>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::clone(&self) -> vortex_array::scalar::DecimalScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalScalar<'a>
+
+pub type vortex_array::scalar::DecimalScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::DecimalScalar<'a>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::hash::Hash for vortex_array::scalar::DecimalScalar<'a>
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl<'a> core::marker::Copy for vortex_array::scalar::DecimalScalar<'a>
+
+pub struct vortex_array::scalar::ExtScalar<'a>
+
+impl<'a> vortex_array::scalar::ExtScalar<'a>
+
+pub fn vortex_array::scalar::ExtScalar<'a>::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::ExtScalar<'a>::ext_dtype(&self) -> &'a vortex_array::dtype::extension::ExtDTypeRef
+
+pub fn vortex_array::scalar::ExtScalar<'a>::to_storage_scalar(&self) -> vortex_array::scalar::Scalar
+
+impl core::cmp::Eq for vortex_array::scalar::ExtScalar<'_>
+
+impl core::cmp::PartialEq for vortex_array::scalar::ExtScalar<'_>
+
+pub fn vortex_array::scalar::ExtScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::ExtScalar<'_>
+
+pub fn vortex_array::scalar::ExtScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::fmt::Display for vortex_array::scalar::ExtScalar<'_>
+
+pub fn vortex_array::scalar::ExtScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::ExtScalar<'_>
+
+pub fn vortex_array::scalar::ExtScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+impl<'a> core::clone::Clone for vortex_array::scalar::ExtScalar<'a>
+
+pub fn vortex_array::scalar::ExtScalar<'a>::clone(&self) -> vortex_array::scalar::ExtScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ExtScalar<'a>
+
+pub type vortex_array::scalar::ExtScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::ExtScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::ExtScalar<'a>
+
+pub fn vortex_array::scalar::ExtScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::scalar::ListScalar<'a>
+
+impl<'a> vortex_array::scalar::ListScalar<'a>
+
+pub fn vortex_array::scalar::ListScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::ListScalar<'a>::element(&self, idx: usize) -> core::option::Option<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::ListScalar<'a>::element_dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::ListScalar<'a>::elements(&self) -> core::option::Option<alloc::vec::Vec<vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::scalar::ListScalar<'a>::is_empty(&self) -> bool
+
+pub fn vortex_array::scalar::ListScalar<'a>::is_null(&self) -> bool
+
+pub fn vortex_array::scalar::ListScalar<'a>::len(&self) -> usize
+
+pub fn vortex_array::scalar::ListScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+impl core::cmp::Eq for vortex_array::scalar::ListScalar<'_>
+
+impl core::cmp::PartialEq for vortex_array::scalar::ListScalar<'_>
+
+pub fn vortex_array::scalar::ListScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::ListScalar<'_>
+
+pub fn vortex_array::scalar::ListScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::fmt::Display for vortex_array::scalar::ListScalar<'_>
+
+pub fn vortex_array::scalar::ListScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::ListScalar<'_>
+
+pub fn vortex_array::scalar::ListScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+impl<'a> core::clone::Clone for vortex_array::scalar::ListScalar<'a>
+
+pub fn vortex_array::scalar::ListScalar<'a>::clone(&self) -> vortex_array::scalar::ListScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ListScalar<'a>
+
+pub type vortex_array::scalar::ListScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::ListScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::ListScalar<'a>
+
+pub fn vortex_array::scalar::ListScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_array::scalar::PrimitiveScalar<'a>
+
+impl<'a> vortex_array::scalar::PrimitiveScalar<'a>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::as_<T: vortex_array::dtype::FromPrimitiveOrF16>(&self) -> core::option::Option<T>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::as_opt<T: vortex_array::dtype::FromPrimitiveOrF16>(&self) -> core::option::Option<core::option::Option<T>>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::is_nan(&self) -> bool
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::is_zero(&self) -> core::option::Option<bool>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::ptype(&self) -> vortex_array::dtype::PType
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::pvalue(&self) -> core::option::Option<vortex_array::scalar::PValue>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_typed_value<T: vortex_array::dtype::NativePType>(&self) -> vortex_error::VortexResult<core::option::Option<T>>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::typed_value<T: vortex_array::dtype::NativePType>(&self) -> core::option::Option<T>
+
+impl<'a> vortex_array::scalar::PrimitiveScalar<'a>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::checked_binary_numeric(&self, other: &vortex_array::scalar::PrimitiveScalar<'a>, op: vortex_array::scalar::NumericOperator) -> core::option::Option<vortex_array::scalar::PrimitiveScalar<'a>>
+
+impl core::cmp::Eq for vortex_array::scalar::PrimitiveScalar<'_>
+
+impl core::cmp::PartialEq for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<vortex_array::scalar::PrimitiveScalar<'_>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(ps: vortex_array::scalar::PrimitiveScalar<'_>) -> Self
+
+impl core::fmt::Display for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::ops::arith::Add for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub type vortex_array::scalar::PrimitiveScalar<'_>::Output = vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::add(self, rhs: Self) -> Self::Output
+
+impl core::ops::arith::Sub for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub type vortex_array::scalar::PrimitiveScalar<'_>::Output = vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::sub(self, rhs: Self) -> Self::Output
+
+impl num_traits::ops::checked::CheckedAdd for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::checked_add(&self, rhs: &Self) -> core::option::Option<Self>
+
+impl num_traits::ops::checked::CheckedSub for vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'_>::checked_sub(&self, rhs: &Self) -> core::option::Option<Self>
+
+impl<'a> core::clone::Clone for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::clone(&self) -> vortex_array::scalar::PrimitiveScalar<'a>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub type vortex_array::scalar::PrimitiveScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Debug for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::hash::Hash for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl<'a> core::marker::Copy for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub struct vortex_array::scalar::Scalar
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::approx_nbytes(&self) -> usize
+
+pub fn vortex_array::scalar::Scalar::default_value(dtype: &vortex_array::dtype::DType) -> Self
+
+pub fn vortex_array::scalar::Scalar::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::Scalar::eq_ignore_nullability(&self, other: &Self) -> bool
+
+pub fn vortex_array::scalar::Scalar::into_parts(self) -> (vortex_array::dtype::DType, core::option::Option<vortex_array::scalar::ScalarValue>)
+
+pub fn vortex_array::scalar::Scalar::into_value(self) -> core::option::Option<vortex_array::scalar::ScalarValue>
+
+pub fn vortex_array::scalar::Scalar::is_null(&self) -> bool
+
+pub fn vortex_array::scalar::Scalar::is_valid(&self) -> bool
+
+pub fn vortex_array::scalar::Scalar::is_zero(&self) -> core::option::Option<bool>
+
+pub unsafe fn vortex_array::scalar::Scalar::new_unchecked(dtype: vortex_array::dtype::DType, value: core::option::Option<vortex_array::scalar::ScalarValue>) -> Self
+
+pub fn vortex_array::scalar::Scalar::null(dtype: vortex_array::dtype::DType) -> Self
+
+pub fn vortex_array::scalar::Scalar::null_native<T: vortex_array::dtype::NativeDType>() -> Self
+
+pub fn vortex_array::scalar::Scalar::primitive_reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::Scalar::try_new(dtype: vortex_array::dtype::DType, value: core::option::Option<vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::Scalar::value(&self) -> core::option::Option<&vortex_array::scalar::ScalarValue>
+
+pub fn vortex_array::scalar::Scalar::zero_value(dtype: &vortex_array::dtype::DType) -> Self
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::as_binary(&self) -> vortex_array::scalar::BinaryScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_binary_opt(&self) -> core::option::Option<vortex_array::scalar::BinaryScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_bool(&self) -> vortex_array::scalar::BoolScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_bool_opt(&self) -> core::option::Option<vortex_array::scalar::BoolScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_decimal(&self) -> vortex_array::scalar::DecimalScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_decimal_opt(&self) -> core::option::Option<vortex_array::scalar::DecimalScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_extension(&self) -> vortex_array::scalar::ExtScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_extension_opt(&self) -> core::option::Option<vortex_array::scalar::ExtScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_list(&self) -> vortex_array::scalar::ListScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_list_opt(&self) -> core::option::Option<vortex_array::scalar::ListScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_primitive(&self) -> vortex_array::scalar::PrimitiveScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_primitive_opt(&self) -> core::option::Option<vortex_array::scalar::PrimitiveScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_struct(&self) -> vortex_array::scalar::StructScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_struct_opt(&self) -> core::option::Option<vortex_array::scalar::StructScalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_utf8(&self) -> vortex_array::scalar::Utf8Scalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_utf8_opt(&self) -> core::option::Option<vortex_array::scalar::Utf8Scalar<'_>>
+
+pub fn vortex_array::scalar::Scalar::as_variant(&self) -> vortex_array::scalar::VariantScalar<'_>
+
+pub fn vortex_array::scalar::Scalar::as_variant_opt(&self) -> core::option::Option<vortex_array::scalar::VariantScalar<'_>>
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::binary(buffer: impl core::convert::Into<vortex_buffer::ByteBuffer>, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::bool(value: bool, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::decimal(value: vortex_array::scalar::DecimalValue, decimal_type: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::extension<V: vortex_array::dtype::extension::ExtVTable + core::default::Default>(options: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, storage_scalar: vortex_array::scalar::Scalar) -> Self
+
+pub fn vortex_array::scalar::Scalar::extension_ref(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_scalar: vortex_array::scalar::Scalar) -> Self
+
+pub fn vortex_array::scalar::Scalar::fixed_size_list(element_dtype: impl core::convert::Into<alloc::sync::Arc<vortex_array::dtype::DType>>, children: alloc::vec::Vec<vortex_array::scalar::Scalar>, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::list(element_dtype: impl core::convert::Into<alloc::sync::Arc<vortex_array::dtype::DType>>, children: alloc::vec::Vec<vortex_array::scalar::Scalar>, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::list_empty(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::primitive<T: vortex_array::dtype::NativePType + core::convert::Into<vortex_array::scalar::PValue>>(value: T, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::primitive_value(value: vortex_array::scalar::PValue, ptype: vortex_array::dtype::PType, nullability: vortex_array::dtype::Nullability) -> Self
+
+pub fn vortex_array::scalar::Scalar::try_utf8<B>(str: B, nullability: vortex_array::dtype::Nullability) -> core::result::Result<Self, <B as core::convert::TryInto<vortex_buffer::string::BufferString>>::Error> where B: core::convert::TryInto<vortex_buffer::string::BufferString>
+
+pub fn vortex_array::scalar::Scalar::utf8<B>(str: B, nullability: vortex_array::dtype::Nullability) -> Self where B: core::convert::Into<vortex_buffer::string::BufferString>
+
+pub fn vortex_array::scalar::Scalar::variant(value: vortex_array::scalar::Scalar) -> Self
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::cast(&self, target_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::Scalar::into_nullable(self) -> vortex_array::scalar::Scalar
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from_proto(value: &vortex_proto::scalar::Scalar, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_array::scalar::Scalar::from_proto_value(value: &vortex_proto::scalar::ScalarValue, dtype: &vortex_array::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::struct_(dtype: vortex_array::dtype::DType, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::scalar::Scalar>) -> Self
+
+pub unsafe fn vortex_array::scalar::Scalar::struct_unchecked(dtype: vortex_array::dtype::DType, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::scalar::Scalar>) -> Self
+
+impl vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::validate(dtype: &vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<()>
+
+impl core::clone::Clone for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::clone(&self) -> vortex_array::scalar::Scalar
+
+impl core::cmp::Eq for vortex_array::scalar::Scalar
+
+impl core::cmp::PartialEq for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+
+impl core::convert::From<&[u8]> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: &[u8]) -> Self
+
+impl core::convert::From<&str> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: &str) -> Self
+
+impl core::convert::From<&vortex_array::scalar::Scalar> for vortex_proto::scalar::Scalar
+
+pub fn vortex_proto::scalar::Scalar::from(value: &vortex_array::scalar::Scalar) -> Self
+
+impl core::convert::From<alloc::string::String> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: alloc::string::String) -> Self
+
+impl core::convert::From<bool> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: bool) -> Self
+
+impl core::convert::From<core::option::Option<&[u8]>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<&[u8]>) -> Self
+
+impl core::convert::From<core::option::Option<&str>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<&str>) -> Self
+
+impl core::convert::From<core::option::Option<alloc::string::String>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<alloc::string::String>) -> Self
+
+impl core::convert::From<core::option::Option<bool>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<bool>) -> Self
+
+impl core::convert::From<core::option::Option<f32>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<f32>) -> Self
+
+impl core::convert::From<core::option::Option<f64>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<f64>) -> Self
+
+impl core::convert::From<core::option::Option<half::binary16::f16>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<half::binary16::f16>) -> Self
+
+impl core::convert::From<core::option::Option<i16>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i16>) -> Self
+
+impl core::convert::From<core::option::Option<i32>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i32>) -> Self
+
+impl core::convert::From<core::option::Option<i64>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i64>) -> Self
+
+impl core::convert::From<core::option::Option<i8>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i8>) -> Self
+
+impl core::convert::From<core::option::Option<u16>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u16>) -> Self
+
+impl core::convert::From<core::option::Option<u32>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u32>) -> Self
+
+impl core::convert::From<core::option::Option<u64>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u64>) -> Self
+
+impl core::convert::From<core::option::Option<u8>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u8>) -> Self
+
+impl core::convert::From<core::option::Option<usize>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<usize>) -> Self
+
+impl core::convert::From<core::option::Option<vortex_array::scalar::DecimalValue>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_array::scalar::DecimalValue>) -> Self
+
+impl core::convert::From<core::option::Option<vortex_buffer::buffer::Buffer<u8>>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_buffer::ByteBuffer>) -> Self
+
+impl core::convert::From<core::option::Option<vortex_buffer::string::BufferString>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_buffer::string::BufferString>) -> Self
+
+impl core::convert::From<f32> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: f32) -> Self
+
+impl core::convert::From<f64> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: f64) -> Self
+
+impl core::convert::From<half::binary16::f16> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: half::binary16::f16) -> Self
+
+impl core::convert::From<i16> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: i16) -> Self
+
+impl core::convert::From<i32> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: i32) -> Self
+
+impl core::convert::From<i64> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: i64) -> Self
+
+impl core::convert::From<i8> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: i8) -> Self
+
+impl core::convert::From<u16> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: u16) -> Self
+
+impl core::convert::From<u32> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: u32) -> Self
+
+impl core::convert::From<u64> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: u64) -> Self
+
+impl core::convert::From<u8> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: u8) -> Self
+
+impl core::convert::From<usize> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: usize) -> Self
+
+impl core::convert::From<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(ds: vortex_array::scalar::DecimalScalar<'_>) -> Self
+
+impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: vortex_array::scalar::DecimalValue) -> Self
+
+impl core::convert::From<vortex_array::scalar::PrimitiveScalar<'_>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(ps: vortex_array::scalar::PrimitiveScalar<'_>) -> Self
+
+impl core::convert::From<vortex_buffer::buffer::Buffer<u8>> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: vortex_buffer::ByteBuffer) -> Self
+
+impl core::convert::From<vortex_buffer::string::BufferString> for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::from(value: vortex_buffer::string::BufferString) -> Self
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for alloc::sync::Arc<dyn arrow_array::scalar::Datum>
+
+pub type alloc::sync::Arc<dyn arrow_array::scalar::Datum>::Error = vortex_error::VortexError
+
+pub fn alloc::sync::Arc<dyn arrow_array::scalar::Datum>::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<alloc::sync::Arc<dyn arrow_array::scalar::Datum>, Self::Error>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for bool
+
+pub type bool::Error = vortex_error::VortexError
+
+pub fn bool::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<bool>
+
+pub type core::option::Option<bool>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<bool>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<f32>
+
+pub type core::option::Option<f32>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<f32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<f64>
+
+pub type core::option::Option<f64>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<f64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<half::binary16::f16>
+
+pub type core::option::Option<half::binary16::f16>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<half::binary16::f16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i16>
+
+pub type core::option::Option<i16>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i32>
+
+pub type core::option::Option<i32>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i64>
+
+pub type core::option::Option<i64>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i8>
+
+pub type core::option::Option<i8>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<i8>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u16>
+
+pub type core::option::Option<u16>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<u16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u32>
+
+pub type core::option::Option<u32>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<u32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u64>
+
+pub type core::option::Option<u64>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<u64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u8>
+
+pub type core::option::Option<u8>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<u8>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<usize>
+
+pub type core::option::Option<usize>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<usize>::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<vortex_array::scalar::DecimalValue>
+
+pub type core::option::Option<vortex_array::scalar::DecimalValue>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_array::scalar::DecimalValue>::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for f32
+
+pub type f32::Error = vortex_error::VortexError
+
+pub fn f32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for f64
+
+pub type f64::Error = vortex_error::VortexError
+
+pub fn f64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for half::binary16::f16
+
+pub type half::binary16::f16::Error = vortex_error::VortexError
+
+pub fn half::binary16::f16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i16
+
+pub type i16::Error = vortex_error::VortexError
+
+pub fn i16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i32
+
+pub type i32::Error = vortex_error::VortexError
+
+pub fn i32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i64
+
+pub type i64::Error = vortex_error::VortexError
+
+pub fn i64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i8
+
+pub type i8::Error = vortex_error::VortexError
+
+pub fn i8::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u16
+
+pub type u16::Error = vortex_error::VortexError
+
+pub fn u16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u32
+
+pub type u32::Error = vortex_error::VortexError
+
+pub fn u32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u64
+
+pub type u64::Error = vortex_error::VortexError
+
+pub fn u64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u8
+
+pub type u8::Error = vortex_error::VortexError
+
+pub fn u8::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for usize
+
+pub type usize::Error = vortex_error::VortexError
+
+pub fn usize::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+
+pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalValue::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for alloc::string::String
+
+pub type alloc::string::String::Error = vortex_error::VortexError
+
+pub fn alloc::string::String::try_from(value: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for bool
+
+pub type bool::Error = vortex_error::VortexError
+
+pub fn bool::try_from(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<bool>
+
+pub type core::option::Option<bool>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<bool>::try_from(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_array::scalar::DecimalValue>
+
+pub type core::option::Option<vortex_array::scalar::DecimalValue>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_array::scalar::DecimalValue>::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::ByteBuffer>
+
+pub type core::option::Option<vortex_buffer::ByteBuffer>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_buffer::ByteBuffer>::try_from(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::string::BufferString>
+
+pub type core::option::Option<vortex_buffer::string::BufferString>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_buffer::string::BufferString>::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+
+pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalValue::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_buffer::ByteBuffer
+
+pub type vortex_buffer::ByteBuffer::Error = vortex_error::VortexError
+
+pub fn vortex_buffer::ByteBuffer::try_from(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_buffer::string::BufferString
+
+pub type vortex_buffer::string::BufferString::Error = vortex_error::VortexError
+
+pub fn vortex_buffer::string::BufferString::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_array::scalar::Scalar
+
+pub fn vortex_array::scalar::Scalar::hash<H: core::hash::Hasher>(&self, state: &mut H)
+
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::Scalar> for vortex_array::ArrayRef
+
+pub fn vortex_array::ArrayRef::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+
+pub fn vortex_array::ArrayRef::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::ArrayRef::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::ArrayRef::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+pub fn vortex_array::ArrayRef::index_len(&self) -> usize
+
+pub fn vortex_array::ArrayRef::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+
+impl<'a, T> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for alloc::vec::Vec<T> where T: for<'b> core::convert::TryFrom<&'b vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+
+pub type alloc::vec::Vec<T>::Error = vortex_error::VortexError
+
+pub fn alloc::vec::Vec<T>::try_from(value: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for alloc::string::String
+
+pub type alloc::string::String::Error = vortex_error::VortexError
+
+pub fn alloc::string::String::try_from(value: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::ByteBuffer>
+
+pub type core::option::Option<vortex_buffer::ByteBuffer>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_buffer::ByteBuffer>::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::string::BufferString>
+
+pub type core::option::Option<vortex_buffer::string::BufferString>::Error = vortex_error::VortexError
+
+pub fn core::option::Option<vortex_buffer::string::BufferString>::try_from(scalar: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BinaryScalar<'a>
+
+pub type vortex_array::scalar::BinaryScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::BinaryScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BoolScalar<'a>
+
+pub type vortex_array::scalar::BoolScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::BoolScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalScalar<'a>
+
+pub type vortex_array::scalar::DecimalScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::DecimalScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ExtScalar<'a>
+
+pub type vortex_array::scalar::ExtScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::ExtScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ListScalar<'a>
+
+pub type vortex_array::scalar::ListScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::ListScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::PrimitiveScalar<'a>
+
+pub type vortex_array::scalar::PrimitiveScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::StructScalar<'a>
+
+pub type vortex_array::scalar::StructScalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::StructScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::Utf8Scalar<'a>
+
+pub type vortex_array::scalar::Utf8Scalar<'a>::Error = vortex_error::VortexError
+
+pub fn vortex_array::scalar::Utf8Scalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_buffer::ByteBuffer
+
+pub type vortex_buffer::ByteBuffer::Error = vortex_error::VortexError
+
+pub fn vortex_buffer::ByteBuffer::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_buffer::string::BufferString
+
+pub type vortex_buffer::string::BufferString::Error = vortex_error::VortexError
+
+pub fn vortex_buffer::string::BufferString::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+
+impl<T> core::convert::From<alloc::vec::Vec<T>> for vortex_array::scalar::Scalar where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+
+pub fn vortex_array::scalar::Scalar::from(vec: alloc::vec::Vec<T>) -> Self
+
+impl<T> core::convert::From<core::option::Option<alloc::vec::Vec<T>>> for vortex_array::scalar::Scalar where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+
+pub fn vortex_array::scalar::Scalar::from(vec: core::option::Option<alloc::vec::Vec<T>>) -> Self
+
+impl<T> core::convert::TryFrom<vortex_array::scalar::Scalar> for alloc::vec::Vec<T> where T: for<'b> core::convert::TryFrom<&'b vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+
+pub type alloc::vec::Vec<T>::Error = vortex_error::VortexError
+
+pub fn alloc::vec::Vec<T>::try_from(value: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+
+pub struct vortex_array::scalar::StructScalar<'a>
+
+impl<'a> vortex_array::scalar::StructScalar<'a>
+
+pub fn vortex_array::scalar::StructScalar<'a>::cast(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::StructScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+
+pub fn vortex_array::scalar::StructScalar<'a>::field(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::StructScalar<'a>::field_by_idx(&self, idx: usize) -> core::option::Option<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::StructScalar<'a>::fields_iter(&self) -> core::option::Option<impl core::iter::traits::exact_size::ExactSizeIterator<Item = vortex_array::scalar::Scalar>>
+
+pub fn vortex_array::scalar::StructScalar<'a>::is_null(&self) -> bool
+
+pub fn vortex_array::scalar::StructScalar<'a>::names(&self) -> &vortex_array::dtype::FieldNames
+
+pub fn vortex_array::scalar::StructScalar<'a>::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+
+pub fn vortex_array::scalar::StructScalar<'a>::struct_fields(&self) -> &vortex_array::dtype::StructFields
+
+impl core::cmp::Eq for vortex_array::scalar::StructScalar<'_>
+
+impl core::cmp::PartialEq for vortex_array::scalar::StructScalar<'_>
+
+pub fn vortex_array::scalar::StructScalar<'_>::eq(&self, other: &Self) -> bool
+
+impl core::cmp::PartialOrd for vortex_array::scalar::StructScalar<'_>
+
+pub fn vortex_array::scalar::StructScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
 
-pub trait vortex_array::dtype::PTypeUpcast
+impl core::fmt::Display for vortex_array::scalar::StructScalar<'_>
 
-pub type vortex_array::dtype::PTypeUpcast::Input<T: vortex_array::dtype::NativePType>
+pub fn vortex_array::scalar::StructScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::PTypeUpcast::from_f16(input: Self::Input) -> Self
+impl core::hash::Hash for vortex_array::scalar::StructScalar<'_>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_f32(input: Self::Input) -> Self
+pub fn vortex_array::scalar::StructScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::dtype::PTypeUpcast::from_f64(input: Self::Input) -> Self
+impl<'a> core::clone::Clone for vortex_array::scalar::StructScalar<'a>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_i16(input: Self::Input) -> Self
+pub fn vortex_array::scalar::StructScalar<'a>::clone(&self) -> vortex_array::scalar::StructScalar<'a>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_i32(input: Self::Input) -> Self
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::StructScalar<'a>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_i64(input: Self::Input) -> Self
+pub type vortex_array::scalar::StructScalar<'a>::Error = vortex_error::VortexError
 
-pub fn vortex_array::dtype::PTypeUpcast::from_i8(input: Self::Input) -> Self
+pub fn vortex_array::scalar::StructScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_u16(input: Self::Input) -> Self
+impl<'a> core::fmt::Debug for vortex_array::scalar::StructScalar<'a>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_u32(input: Self::Input) -> Self
+pub fn vortex_array::scalar::StructScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::dtype::PTypeUpcast::from_u64(input: Self::Input) -> Self
+pub struct vortex_array::scalar::Utf8Scalar<'a>
 
-pub fn vortex_array::dtype::PTypeUpcast::from_u8(input: Self::Input) -> Self
+impl<'a> vortex_array::scalar::Utf8Scalar<'a>
 
-pub trait vortex_array::dtype::PhysicalPType: vortex_array::dtype::NativePType
+pub fn vortex_array::scalar::Utf8Scalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
 
-pub type vortex_array::dtype::PhysicalPType::Physical: vortex_array::dtype::NativePType + num_traits::sign::Unsigned
+pub fn vortex_array::scalar::Utf8Scalar<'a>::is_empty(&self) -> core::option::Option<bool>
 
-impl vortex_array::dtype::PhysicalPType for i16
+pub fn vortex_array::scalar::Utf8Scalar<'a>::len(&self) -> core::option::Option<usize>
 
-pub type i16::Physical = u16
+pub fn vortex_array::scalar::Utf8Scalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::dtype::PhysicalPType for i32
+pub fn vortex_array::scalar::Utf8Scalar<'a>::value(&self) -> core::option::Option<&'a vortex_buffer::string::BufferString>
 
-pub type i32::Physical = u32
+impl core::cmp::Ord for vortex_array::scalar::Utf8Scalar<'_>
 
-impl vortex_array::dtype::PhysicalPType for i64
+pub fn vortex_array::scalar::Utf8Scalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
 
-pub type i64::Physical = u64
+impl core::cmp::PartialEq for vortex_array::scalar::Utf8Scalar<'_>
 
-impl vortex_array::dtype::PhysicalPType for i8
+pub fn vortex_array::scalar::Utf8Scalar<'_>::eq(&self, other: &Self) -> bool
 
-pub type i8::Physical = u8
+impl core::cmp::PartialOrd for vortex_array::scalar::Utf8Scalar<'_>
 
-impl vortex_array::dtype::PhysicalPType for u16
+pub fn vortex_array::scalar::Utf8Scalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
 
-pub type u16::Physical = u16
+impl core::fmt::Display for vortex_array::scalar::Utf8Scalar<'_>
 
-impl vortex_array::dtype::PhysicalPType for u32
+pub fn vortex_array::scalar::Utf8Scalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type u32::Physical = u32
+impl<'a> core::clone::Clone for vortex_array::scalar::Utf8Scalar<'a>
 
-impl vortex_array::dtype::PhysicalPType for u64
+pub fn vortex_array::scalar::Utf8Scalar<'a>::clone(&self) -> vortex_array::scalar::Utf8Scalar<'a>
 
-pub type u64::Physical = u64
+impl<'a> core::cmp::Eq for vortex_array::scalar::Utf8Scalar<'a>
 
-impl vortex_array::dtype::PhysicalPType for u8
+impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::Utf8Scalar<'a>
 
-pub type u8::Physical = u8
+pub type vortex_array::scalar::Utf8Scalar<'a>::Error = vortex_error::VortexError
 
-pub trait vortex_array::dtype::ToBytes: core::marker::Sized
+pub fn vortex_array::scalar::Utf8Scalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::dtype::ToBytes::to_le_bytes(&self) -> &[u8]
+impl<'a> core::fmt::Debug for vortex_array::scalar::Utf8Scalar<'a>
 
-impl vortex_array::dtype::ToBytes for f32
+pub fn vortex_array::scalar::Utf8Scalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn f32::to_le_bytes(&self) -> &[u8]
+impl<'a> core::hash::Hash for vortex_array::scalar::Utf8Scalar<'a>
 
-impl vortex_array::dtype::ToBytes for f64
+pub fn vortex_array::scalar::Utf8Scalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn f64::to_le_bytes(&self) -> &[u8]
+pub struct vortex_array::scalar::VariantScalar<'a>
 
-impl vortex_array::dtype::ToBytes for half::binary16::f16
+impl<'a> vortex_array::scalar::VariantScalar<'a>
 
-pub fn half::binary16::f16::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
 
-impl vortex_array::dtype::ToBytes for i16
+pub fn vortex_array::scalar::VariantScalar<'a>::is_null(&self) -> bool
 
-pub fn i16::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'a>::is_variant_null(&self) -> core::option::Option<bool>
 
-impl vortex_array::dtype::ToBytes for i32
+pub fn vortex_array::scalar::VariantScalar<'a>::is_zero(&self) -> core::option::Option<bool>
 
-pub fn i32::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'a>::value(&self) -> core::option::Option<&'a vortex_array::scalar::Scalar>
 
-impl vortex_array::dtype::ToBytes for i64
+impl core::fmt::Display for vortex_array::scalar::VariantScalar<'_>
 
-pub fn i64::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::dtype::ToBytes for i8
+impl<'a> core::clone::Clone for vortex_array::scalar::VariantScalar<'a>
 
-pub fn i8::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'a>::clone(&self) -> vortex_array::scalar::VariantScalar<'a>
 
-impl vortex_array::dtype::ToBytes for u16
+impl<'a> core::fmt::Debug for vortex_array::scalar::VariantScalar<'a>
 
-pub fn u16::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::VariantScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::dtype::ToBytes for u32
+impl<'a> core::marker::Copy for vortex_array::scalar::VariantScalar<'a>
 
-pub fn u32::to_le_bytes(&self) -> &[u8]
+pub trait vortex_array::scalar::ScalarTruncation: core::marker::Send + core::marker::Sized
 
-impl vortex_array::dtype::ToBytes for u64
+pub fn vortex_array::scalar::ScalarTruncation::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
 
-pub fn u64::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::ScalarTruncation::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
 
-impl vortex_array::dtype::ToBytes for u8
+pub fn vortex_array::scalar::ScalarTruncation::len(&self) -> usize
 
-pub fn u8::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar::ScalarTruncation::lower_bound(self, max_length: usize) -> Self
 
-impl vortex_array::dtype::ToBytes for vortex_array::scalar::PValue
+pub fn vortex_array::scalar::ScalarTruncation::upper_bound(self, max_length: usize) -> core::option::Option<Self>
 
-pub fn vortex_array::scalar::PValue::to_le_bytes(&self) -> &[u8]
+impl vortex_array::scalar::ScalarTruncation for vortex_buffer::ByteBuffer
 
-pub trait vortex_array::dtype::ToI256
+pub fn vortex_buffer::ByteBuffer::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
 
-pub fn vortex_array::dtype::ToI256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_buffer::ByteBuffer::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
 
-impl vortex_array::dtype::ToI256 for i128
+pub fn vortex_buffer::ByteBuffer::len(&self) -> usize
 
-pub fn i128::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_buffer::ByteBuffer::lower_bound(self, max_length: usize) -> Self
 
-impl vortex_array::dtype::ToI256 for i16
+pub fn vortex_buffer::ByteBuffer::upper_bound(self, max_length: usize) -> core::option::Option<Self>
 
-pub fn i16::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+impl vortex_array::scalar::ScalarTruncation for vortex_buffer::string::BufferString
 
-impl vortex_array::dtype::ToI256 for i32
+pub fn vortex_buffer::string::BufferString::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
 
-pub fn i32::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_buffer::string::BufferString::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
 
-impl vortex_array::dtype::ToI256 for i64
+pub fn vortex_buffer::string::BufferString::len(&self) -> usize
 
-pub fn i64::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_buffer::string::BufferString::lower_bound(self, max_length: usize) -> Self
 
-impl vortex_array::dtype::ToI256 for i8
+pub fn vortex_buffer::string::BufferString::upper_bound(self, max_length: usize) -> core::option::Option<Self>
 
-pub fn i8::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub trait vortex_array::scalar::StringLike: vortex_array::scalar::typed_view::utf8::private::Sealed + core::marker::Sized
 
-impl vortex_array::dtype::ToI256 for u128
+pub fn vortex_array::scalar::StringLike::increment(self) -> core::result::Result<Self, Self>
 
-pub fn u128::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+impl vortex_array::scalar::StringLike for alloc::string::String
 
-impl vortex_array::dtype::ToI256 for u16
+pub fn alloc::string::String::increment(self) -> core::result::Result<alloc::string::String, alloc::string::String>
 
-pub fn u16::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+impl vortex_array::scalar::StringLike for vortex_buffer::string::BufferString
 
-impl vortex_array::dtype::ToI256 for u32
+pub fn vortex_buffer::string::BufferString::increment(self) -> core::result::Result<vortex_buffer::string::BufferString, vortex_buffer::string::BufferString>
 
-pub fn u32::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_array::scalar::lower_bound(value: core::option::Option<impl vortex_array::scalar::ScalarTruncation>, max_length: usize, nullability: vortex_array::dtype::Nullability) -> core::option::Option<(vortex_array::scalar::Scalar, bool)>
 
-impl vortex_array::dtype::ToI256 for u64
+pub fn vortex_array::scalar::upper_bound(value: core::option::Option<impl vortex_array::scalar::ScalarTruncation>, max_length: usize, nullability: vortex_array::dtype::Nullability) -> core::option::Option<(vortex_array::scalar::Scalar, bool)>
 
-pub fn u64::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub mod vortex_array::scalar_fn
 
-impl vortex_array::dtype::ToI256 for u8
+pub mod vortex_array::scalar_fn::fns
 
-pub fn u8::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub mod vortex_array::scalar_fn::fns::between
 
-impl vortex_array::dtype::ToI256 for vortex_array::dtype::i256
+pub enum vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn vortex_array::dtype::i256::to_i256(&self) -> core::option::Option<vortex_array::dtype::i256>
+pub vortex_array::scalar_fn::fns::between::StrictComparison::NonStrict
 
-pub trait vortex_array::dtype::TryFromBytes: core::marker::Sized
+pub vortex_array::scalar_fn::fns::between::StrictComparison::Strict
 
-pub fn vortex_array::dtype::TryFromBytes::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::fns::between::StrictComparison
 
-impl vortex_array::dtype::TryFromBytes for f32
+pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::is_strict(&self) -> bool
 
-pub fn f32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::to_compare_operator(&self) -> vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl vortex_array::dtype::TryFromBytes for f64
+pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::to_operator(&self) -> vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn f64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::between::StrictComparison
 
-impl vortex_array::dtype::TryFromBytes for half::binary16::f16
+pub fn vortex_array::scalar_fn::fns::between::StrictComparison::clone(&self) -> vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn half::binary16::f16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::between::StrictComparison
 
-impl vortex_array::dtype::TryFromBytes for i16
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn i16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::between::StrictComparison::eq(&self, other: &vortex_array::scalar_fn::fns::between::StrictComparison) -> bool
 
-impl vortex_array::dtype::TryFromBytes for i32
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn i32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::between::StrictComparison::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::dtype::TryFromBytes for i64
+impl core::hash::Hash for vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn i64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::between::StrictComparison::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-impl vortex_array::dtype::TryFromBytes for i8
+impl core::marker::Copy for vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub fn i8::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::between::StrictComparison
 
-impl vortex_array::dtype::TryFromBytes for u16
+pub struct vortex_array::scalar_fn::fns::between::Between
 
-pub fn u16::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::between::Between
 
-impl vortex_array::dtype::TryFromBytes for u32
+pub fn vortex_array::scalar_fn::fns::between::Between::clone(&self) -> vortex_array::scalar_fn::fns::between::Between
 
-pub fn u32::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::between::Between
 
-impl vortex_array::dtype::TryFromBytes for u64
+pub type vortex_array::scalar_fn::fns::between::Between::Options = vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn u64::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::between::Between::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl vortex_array::dtype::TryFromBytes for u8
+pub fn vortex_array::scalar_fn::fns::between::Between::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn u8::try_from_le_bytes(bytes: &[u8]) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::between::Between::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub trait vortex_array::dtype::UnsignedPType: vortex_array::dtype::IntegerPType + num_traits::sign::Unsigned
+pub fn vortex_array::scalar_fn::fns::between::Between::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl<T> vortex_array::dtype::UnsignedPType for T where T: vortex_array::dtype::IntegerPType + num_traits::sign::Unsigned
+pub fn vortex_array::scalar_fn::fns::between::Between::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub mod vortex_array::expr
+pub fn vortex_array::scalar_fn::fns::between::Between::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::expr::aliases
+pub fn vortex_array::scalar_fn::fns::between::Between::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub mod vortex_array::expr::aliases::paste
+pub fn vortex_array::scalar_fn::fns::between::Between::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub use vortex_array::expr::aliases::paste::paste
+pub fn vortex_array::scalar_fn::fns::between::Between::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub mod vortex_array::expr::analysis
+pub fn vortex_array::scalar_fn::fns::between::Between::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub mod vortex_array::expr::analysis::annotation
+pub fn vortex_array::scalar_fn::fns::between::Between::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub trait vortex_array::expr::analysis::annotation::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub fn vortex_array::scalar_fn::fns::between::Between::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub fn vortex_array::scalar_fn::fns::between::Between::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub trait vortex_array::expr::analysis::annotation::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+pub fn vortex_array::scalar_fn::fns::between::Between::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::expr::analysis::annotation::AnnotationFn::Annotation: vortex_array::expr::Annotation
+pub fn vortex_array::scalar_fn::fns::between::Between::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+pub fn vortex_array::scalar_fn::fns::between::Between::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type F::Annotation = A
+pub fn vortex_array::scalar_fn::fns::between::Between::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::analysis::annotation::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+pub struct vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>(pub V)
 
-pub type vortex_array::expr::analysis::annotation::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
 
-pub mod vortex_array::expr::analysis::immediate_access
+pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
 
-pub fn vortex_array::expr::analysis::immediate_access::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
 
-pub fn vortex_array::expr::analysis::immediate_access::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::analysis::immediate_access::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenKernel
 
-pub type vortex_array::expr::analysis::immediate_access::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+pub type vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
 
-pub trait vortex_array::expr::analysis::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub struct vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub trait vortex_array::expr::analysis::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+pub vortex_array::scalar_fn::fns::between::BetweenOptions::lower_strict: vortex_array::scalar_fn::fns::between::StrictComparison
 
-pub type vortex_array::expr::analysis::AnnotationFn::Annotation: vortex_array::expr::Annotation
+pub vortex_array::scalar_fn::fns::between::BetweenOptions::upper_strict: vortex_array::scalar_fn::fns::between::StrictComparison
 
-impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub type F::Annotation = A
+pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::clone(&self) -> vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::expr::analysis::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::expr::analysis::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::expr::analysis::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::eq(&self, other: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> bool
 
-pub fn vortex_array::expr::analysis::label_is_fallible(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::expr::analysis::label_null_sensitive(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::analysis::label_tree<L: core::clone::Clone>(expr: &vortex_array::expr::Expression, self_label: impl core::ops::function::Fn(&vortex_array::expr::Expression) -> L, merge_child: impl core::ops::function::FnMut(L, &L) -> L) -> vortex_utils::aliases::hash_map::HashMap<&vortex_array::expr::Expression, L>
+impl core::fmt::Display for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::expr::analysis::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::expr::analysis::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+impl core::hash::Hash for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub type vortex_array::expr::analysis::BooleanLabels<'a> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, bool>
+pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub type vortex_array::expr::analysis::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub mod vortex_array::expr::annotation
+pub struct vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>(pub V)
 
-pub trait vortex_array::expr::annotation::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
 
-impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
 
-pub trait vortex_array::expr::annotation::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
 
-pub type vortex_array::expr::annotation::AnnotationFn::Annotation: vortex_array::expr::Annotation
+pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenReduce
 
-pub type F::Annotation = A
+pub type vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
 
-pub fn vortex_array::expr::annotation::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::annotation::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+pub trait vortex_array::scalar_fn::fns::between::BetweenKernel: vortex_array::VTable
 
-pub mod vortex_array::expr::display
+pub fn vortex_array::scalar_fn::fns::between::BetweenKernel::between(array: vortex_array::ArrayView<'_, Self>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub enum vortex_array::expr::display::DisplayFormat
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Decimal
 
-pub vortex_array::expr::display::DisplayFormat::Compact
+pub fn vortex_array::arrays::Decimal::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::expr::display::DisplayFormat::Tree
+impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::Primitive
 
-pub struct vortex_array::expr::display::DisplayTreeExpr<'a>(pub &'a vortex_array::expr::Expression)
+pub fn vortex_array::arrays::Primitive::between(arr: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Display for vortex_array::expr::display::DisplayTreeExpr<'_>
+pub trait vortex_array::scalar_fn::fns::between::BetweenReduce: vortex_array::VTable
 
-pub fn vortex_array::expr::display::DisplayTreeExpr<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::between::BetweenReduce::between(array: vortex_array::ArrayView<'_, Self>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::expr::forms
+impl vortex_array::scalar_fn::fns::between::BetweenReduce for vortex_array::arrays::Constant
 
-pub fn vortex_array::expr::forms::conjuncts(expr: &vortex_array::expr::Expression) -> alloc::vec::Vec<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Constant::between(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, lower: &vortex_array::ArrayRef, upper: &vortex_array::ArrayRef, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::expr::immediate_access
+pub mod vortex_array::scalar_fn::fns::binary
 
-pub fn vortex_array::expr::immediate_access::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+pub struct vortex_array::scalar_fn::fns::binary::Binary
 
-pub fn vortex_array::expr::immediate_access::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::binary::Binary
 
-pub fn vortex_array::expr::immediate_access::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::clone(&self) -> vortex_array::scalar_fn::fns::binary::Binary
 
-pub type vortex_array::expr::immediate_access::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::binary::Binary
 
-pub mod vortex_array::expr::proto
+pub type vortex_array::scalar_fn::fns::binary::Binary::Options = vortex_array::scalar_fn::fns::operators::Operator
 
-pub trait vortex_array::expr::proto::ExprSerializeProtoExt
+pub fn vortex_array::scalar_fn::fns::binary::Binary::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::proto::ExprSerializeProtoExt::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl vortex_array::expr::proto::ExprSerializeProtoExt for vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::binary::Binary::coerce_args(&self, operator: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::Expression::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::proto::deserialize_expr_proto(expr: &vortex_proto::expr::Expr, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::execute(&self, op: &vortex_array::scalar_fn::fns::operators::Operator, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub mod vortex_array::expr::pruning
+pub fn vortex_array::scalar_fn::fns::binary::Binary::fmt_sql(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl<K: core::hash::Hash + core::cmp::Eq, V: core::hash::Hash + core::cmp::Eq> vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::is_fallible(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::insert(&mut self, k: K, v: V)
+pub fn vortex_array::scalar_fn::fns::binary::Binary::is_null_sensitive(&self, _operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::map(&self) -> &vortex_utils::aliases::hash_map::HashMap<K, vortex_utils::aliases::hash_set::HashSet<V>>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::new() -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::return_dtype(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl<K, V> core::convert::From<hashbrown::map::HashMap<K, hashbrown::set::HashSet<V>>> for vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::from(value: vortex_utils::aliases::hash_map::HashMap<K, vortex_utils::aliases::hash_set::HashSet<V>>) -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<K, V> core::iter::traits::collect::IntoIterator for vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::expr::pruning::Relation<K, V>::IntoIter = hashbrown::map::IntoIter<K, hashbrown::set::HashSet<V>>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type vortex_array::expr::pruning::Relation<K, V>::Item = (K, hashbrown::set::HashSet<V>)
+pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_falsification(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::into_iter(self) -> Self::IntoIter
+pub fn vortex_array::scalar_fn::fns::binary::Binary::validity(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<K: core::clone::Clone, V: core::clone::Clone> core::clone::Clone for vortex_array::expr::pruning::Relation<K, V>
+pub struct vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>(pub V)
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::clone(&self) -> vortex_array::expr::pruning::Relation<K, V>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
 
-impl<K: core::fmt::Debug, V: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
 
-impl<K: core::hash::Hash + core::cmp::Eq, V: core::hash::Hash + core::cmp::Eq> core::default::Default for vortex_array::expr::pruning::Relation<K, V>
+pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::pruning::Relation<K, V>::default() -> Self
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::binary::CompareKernel
 
-pub trait vortex_array::expr::pruning::StatsCatalog
+pub type vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::binary::Binary>
 
-pub fn vortex_array::expr::pruning::StatsCatalog::stats_ref(&self, _field_path: &vortex_array::dtype::FieldPath, _stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::binary::Binary>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::pruning::checked_pruning_expr(expr: &vortex_array::expr::Expression, available_stats: &vortex_array::dtype::FieldPathSet) -> core::option::Option<(vortex_array::expr::Expression, vortex_array::expr::pruning::RequiredStats)>
+pub trait vortex_array::scalar_fn::fns::binary::CompareKernel: vortex_array::VTable
 
-pub type vortex_array::expr::pruning::RequiredStats = vortex_array::expr::pruning::Relation<vortex_array::dtype::FieldPath, vortex_array::expr::stats::Stat>
+pub fn vortex_array::scalar_fn::fns::binary::CompareKernel::compare(lhs: vortex_array::ArrayView<'_, Self>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::expr::stats
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::Extension
 
-pub enum vortex_array::expr::stats::IntersectionResult<T>
+pub fn vortex_array::arrays::Extension::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::expr::stats::IntersectionResult::None
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::VarBin
 
-pub vortex_array::expr::stats::IntersectionResult::Value(T)
+pub fn vortex_array::arrays::VarBin::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T> vortex_array::expr::stats::IntersectionResult<T>
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::expr::stats::IntersectionResult<T>::ok_or_else<F>(self, err: F) -> vortex_error::VortexResult<T> where F: core::ops::function::FnOnce() -> vortex_error::VortexError
+pub fn vortex_array::arrays::dict::Dict::compare(lhs: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::IntersectionResult<T>
+impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::expr::stats::IntersectionResult<T>::clone(&self) -> vortex_array::expr::stats::IntersectionResult<T>
+pub fn vortex_array::arrays::patched::Patched::compare(lhs: vortex_array::ArrayView<'_, Self>, rhs: &vortex_array::ArrayRef, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::IntersectionResult<T>
+pub fn vortex_array::scalar_fn::fns::binary::and_kleene(lhs: &vortex_array::ArrayRef, rhs: &vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::IntersectionResult<T>
+pub fn vortex_array::scalar_fn::fns::binary::compare_nested_arrow_arrays(lhs: &dyn arrow_array::array::Array, rhs: &dyn arrow_array::array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator) -> vortex_error::VortexResult<arrow_array::array::boolean_array::BooleanArray>
 
-pub fn vortex_array::expr::stats::IntersectionResult<T>::eq(&self, other: &vortex_array::expr::stats::IntersectionResult<T>) -> bool
+pub fn vortex_array::scalar_fn::fns::binary::or_kleene(lhs: &vortex_array::ArrayRef, rhs: &vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::IntersectionResult<T>
+pub fn vortex_array::scalar_fn::fns::binary::scalar_cmp(lhs: &vortex_array::scalar::Scalar, rhs: &vortex_array::scalar::Scalar, operator: vortex_array::scalar_fn::fns::operators::CompareOperator) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::expr::stats::IntersectionResult<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod vortex_array::scalar_fn::fns::case_when
 
-impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::IntersectionResult<T>
+pub struct vortex_array::scalar_fn::fns::case_when::CaseWhen
 
-pub enum vortex_array::expr::stats::Precision<T>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::case_when::CaseWhen
 
-pub vortex_array::expr::stats::Precision::Exact(T)
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::clone(&self) -> vortex_array::scalar_fn::fns::case_when::CaseWhen
 
-pub vortex_array::expr::stats::Precision::Inexact(T)
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::case_when::CaseWhen
 
-impl vortex_array::expr::stats::Precision<&vortex_array::scalar::ScalarValue>
+pub type vortex_array::scalar_fn::fns::case_when::CaseWhen::Options = vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<&vortex_array::scalar::ScalarValue>::into_scalar(self, dtype: vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::child_name(&self, options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>::into_scalar(self, dtype: vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl<T> vortex_array::expr::stats::Precision<T> where T: core::marker::Copy
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::deserialize(&self, metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::stats::Precision<T>::to_inexact(&self) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::Precision<T>::as_exact(self) -> core::option::Option<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::expr::stats::Precision<T>::as_inexact(self) -> core::option::Option<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::stats::Precision<T>::as_ref(&self) -> vortex_array::expr::stats::Precision<&T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::stats::Precision<T>::exact<S: core::convert::Into<T>>(s: S) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::stats::Precision<T>::inexact<S: core::convert::Into<T>>(s: S) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::expr::stats::Precision<T>::into_inexact(self) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::stats::Precision<T>::into_inner(self) -> T
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::Precision<T>::is_exact(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::Precision<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, f: F) -> vortex_array::expr::stats::Precision<U>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::stats::Precision<T>::try_map<U, F: core::ops::function::FnOnce(T) -> vortex_error::VortexResult<U>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::stats::Precision<U>>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::stats::Precision<T>::zip<U>(self, other: vortex_array::expr::stats::Precision<U>) -> vortex_array::expr::stats::Precision<(T, U)>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<T> vortex_array::expr::stats::Precision<T>
+pub struct vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<T>::bound<S: vortex_array::expr::stats::StatType<T>>(self) -> <S as vortex_array::expr::stats::StatType>::Bound
+pub vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::has_else: bool
 
-impl<T> vortex_array::expr::stats::Precision<core::option::Option<T>>
+pub vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::num_when_then_pairs: u32
 
-pub fn vortex_array::expr::stats::Precision<core::option::Option<T>>::transpose(self) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+impl vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::num_children(&self) -> usize
 
-pub fn vortex_array::expr::stats::Precision<T>::clone(&self) -> vortex_array::expr::stats::Precision<T>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::clone(&self) -> vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::Precision<T>
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<T>::eq(&self, other: &vortex_array::expr::stats::Precision<T>) -> bool
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq<T> for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::eq(&self, other: &vortex_array::scalar_fn::fns::case_when::CaseWhenOptions) -> bool
 
-pub fn vortex_array::expr::stats::Precision<T>::eq(&self, other: &T) -> bool
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::Precision<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+impl core::fmt::Display for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::Precision<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+impl core::hash::Hash for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<T>::to_exact(&self) -> core::option::Option<&T>
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhenOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::expr::stats::Precision<T>::union(&self, other: &Self) -> core::option::Option<Self>
+impl core::marker::Copy for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::Precision<T>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-pub fn vortex_array::expr::stats::Precision<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub mod vortex_array::scalar_fn::fns::cast
 
-impl<T: core::fmt::Display> core::fmt::Display for vortex_array::expr::stats::Precision<T>
+pub struct vortex_array::scalar_fn::fns::cast::Cast
 
-pub fn vortex_array::expr::stats::Precision<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_array::scalar_fn::fns::cast::Cast
 
-impl<T: core::marker::Copy> core::marker::Copy for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::cast::Cast::clone(&self) -> vortex_array::scalar_fn::fns::cast::Cast
 
-impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::Precision<T>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::cast::Cast
 
-#[repr(u8)] pub enum vortex_array::expr::stats::Stat
+pub type vortex_array::scalar_fn::fns::cast::Cast::Options = vortex_array::dtype::DType
 
-pub vortex_array::expr::stats::Stat::IsConstant = 0
+pub fn vortex_array::scalar_fn::fns::cast::Cast::arity(&self, _options: &vortex_array::dtype::DType) -> vortex_array::scalar_fn::Arity
 
-pub vortex_array::expr::stats::Stat::IsSorted = 1
+pub fn vortex_array::scalar_fn::fns::cast::Cast::child_name(&self, _instance: &vortex_array::dtype::DType, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub vortex_array::expr::stats::Stat::IsStrictSorted = 2
+pub fn vortex_array::scalar_fn::fns::cast::Cast::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub vortex_array::expr::stats::Stat::Max = 3
+pub fn vortex_array::scalar_fn::fns::cast::Cast::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub vortex_array::expr::stats::Stat::Min = 4
+pub fn vortex_array::scalar_fn::fns::cast::Cast::execute(&self, target_dtype: &vortex_array::dtype::DType, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub vortex_array::expr::stats::Stat::NaNCount = 8
+pub fn vortex_array::scalar_fn::fns::cast::Cast::fmt_sql(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::expr::stats::Stat::NullCount = 6
+pub fn vortex_array::scalar_fn::fns::cast::Cast::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub vortex_array::expr::stats::Stat::Sum = 5
+pub fn vortex_array::scalar_fn::fns::cast::Cast::is_fallible(&self, options: &Self::Options) -> bool
 
-pub vortex_array::expr::stats::Stat::UncompressedSizeInBytes = 7
+pub fn vortex_array::scalar_fn::fns::cast::Cast::is_null_sensitive(&self, _instance: &vortex_array::dtype::DType) -> bool
 
-impl vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::cast::Cast::reduce(&self, target_dtype: &vortex_array::dtype::DType, node: &dyn vortex_array::scalar_fn::ReduceNode, _ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::stats::Stat::all() -> impl core::iter::traits::iterator::Iterator<Item = vortex_array::expr::stats::Stat>
+pub fn vortex_array::scalar_fn::fns::cast::Cast::return_dtype(&self, dtype: &vortex_array::dtype::DType, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::expr::stats::Stat::dtype(&self, data_type: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::dtype::DType>
+pub fn vortex_array::scalar_fn::fns::cast::Cast::serialize(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::stats::Stat::has_same_dtype_as_array(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::cast::Cast::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::Stat::is_commutative(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::cast::Cast::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::Stat::name(&self) -> &str
+pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_expression(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::clone::Clone for vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::stats::Stat::clone(&self) -> vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::cast::Cast::validity(&self, dtype: &vortex_array::dtype::DType, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::cmp::Eq for vortex_array::expr::stats::Stat
+pub struct vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>(pub V)
 
-impl core::cmp::Ord for vortex_array::expr::stats::Stat
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
 
-pub fn vortex_array::expr::stats::Stat::cmp(&self, other: &vortex_array::expr::stats::Stat) -> core::cmp::Ordering
+pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
 
-impl core::cmp::PartialEq for vortex_array::expr::stats::Stat
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
 
-pub fn vortex_array::expr::stats::Stat::eq(&self, other: &vortex_array::expr::stats::Stat) -> bool
+pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialOrd for vortex_array::expr::stats::Stat
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastKernel
 
-pub fn vortex_array::expr::stats::Stat::partial_cmp(&self, other: &vortex_array::expr::stats::Stat) -> core::option::Option<core::cmp::Ordering>
+pub type vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
 
-impl core::convert::From<vortex_array::expr::stats::Stat> for u8
+pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn u8::from(enum_value: vortex_array::expr::stats::Stat) -> Self
+pub struct vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>(pub V)
 
-impl core::convert::TryFrom<u8> for vortex_array::expr::stats::Stat
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
 
-pub type vortex_array::expr::stats::Stat::Error = num_enum::TryFromPrimitiveError<vortex_array::expr::stats::Stat>
+pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
 
-pub fn vortex_array::expr::stats::Stat::try_from(number: u8) -> core::result::Result<Self, num_enum::TryFromPrimitiveError<Self>>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
 
-impl core::fmt::Debug for vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::Stat::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastReduce
 
-impl core::fmt::Display for vortex_array::expr::stats::Stat
+pub type vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
 
-pub fn vortex_array::expr::stats::Stat::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::cast::Cast>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::hash::Hash for vortex_array::expr::stats::Stat
+pub trait vortex_array::scalar_fn::fns::cast::CastKernel: vortex_array::VTable
 
-pub fn vortex_array::expr::stats::Stat::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::cast::CastKernel::cast(array: vortex_array::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::marker::Copy for vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Decimal
 
-impl core::marker::StructuralPartialEq for vortex_array::expr::stats::Stat
+pub fn vortex_array::arrays::Decimal::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl enum_iterator::Sequence for vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Primitive
 
-pub const vortex_array::expr::stats::Stat::CARDINALITY: usize
+pub fn vortex_array::arrays::Primitive::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, dtype: &vortex_array::dtype::DType, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::Stat::first() -> core::option::Option<Self>
+impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::Struct
 
-pub fn vortex_array::expr::stats::Stat::last() -> core::option::Option<Self>
+pub fn vortex_array::arrays::Struct::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::Stat::next(&self) -> core::option::Option<Self>
+pub trait vortex_array::scalar_fn::fns::cast::CastReduce: vortex_array::VTable
 
-pub fn vortex_array::expr::stats::Stat::previous(&self) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::cast::CastReduce::cast(array: vortex_array::ArrayView<'_, Self>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl num_enum::TryFromPrimitive for vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Bool
 
-pub type vortex_array::expr::stats::Stat::Error = num_enum::TryFromPrimitiveError<vortex_array::expr::stats::Stat>
+pub fn vortex_array::arrays::Bool::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::stats::Stat::Primitive = u8
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Chunked
 
-pub const vortex_array::expr::stats::Stat::NAME: &'static str
+pub fn vortex_array::arrays::Chunked::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::Stat::try_from_primitive(number: Self::Primitive) -> core::result::Result<Self, num_enum::TryFromPrimitiveError<Self>>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Constant
 
-pub struct vortex_array::expr::stats::IsConstant
+pub fn vortex_array::arrays::Constant::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsConstant
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::Extension
 
-pub type vortex_array::expr::stats::IsConstant::Bound = vortex_array::expr::stats::Precision<bool>
+pub fn vortex_array::arrays::Extension::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::expr::stats::IsConstant::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::FixedSizeList
 
-pub struct vortex_array::expr::stats::IsSorted
+pub fn vortex_array::arrays::FixedSizeList::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsSorted
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::List
 
-pub type vortex_array::expr::stats::IsSorted::Bound = vortex_array::expr::stats::Precision<bool>
+pub fn vortex_array::arrays::List::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::expr::stats::IsSorted::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListView
 
-pub struct vortex_array::expr::stats::IsStrictSorted
+pub fn vortex_array::arrays::ListView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsStrictSorted
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBin
 
-pub type vortex_array::expr::stats::IsStrictSorted::Bound = vortex_array::expr::stats::Precision<bool>
+pub fn vortex_array::arrays::VarBin::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::expr::stats::IsStrictSorted::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinView
 
-pub struct vortex_array::expr::stats::LowerBound<T>(_)
+pub fn vortex_array::arrays::VarBinView::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T> vortex_array::expr::stats::LowerBound<T>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::expr::stats::LowerBound<T>::is_exact(&self) -> bool
+pub fn vortex_array::arrays::dict::Dict::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::LowerBound<T>
+impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::null::Null
 
-pub fn vortex_array::expr::stats::LowerBound<T>::clone(&self) -> vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::arrays::null::Null::cast(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::LowerBound<T>
+pub mod vortex_array::scalar_fn::fns::dynamic
 
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::LowerBound<T>
+pub struct vortex_array::scalar_fn::fns::dynamic::DynamicComparison
 
-pub fn vortex_array::expr::stats::LowerBound<T>::eq(&self, other: &vortex_array::expr::stats::LowerBound<T>) -> bool
+impl core::clone::Clone for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::clone(&self) -> vortex_array::scalar_fn::fns::dynamic::DynamicComparison
 
-pub fn vortex_array::expr::stats::LowerBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::LowerBound<T>>>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
 
-pub fn vortex_array::expr::stats::LowerBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+pub type vortex_array::scalar_fn::fns::dynamic::DynamicComparison::Options = vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub fn vortex_array::expr::stats::LowerBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::stats::LowerBound<T>::to_exact(&self) -> core::option::Option<&T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::stats::LowerBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::LowerBound<T>>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl<T: core::cmp::PartialOrd> core::cmp::PartialEq<T> for vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::stats::LowerBound<T>::eq(&self, other: &T) -> bool
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::execute(&self, data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<T> for vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::fmt_sql(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::LowerBound<T>::partial_cmp(&self, other: &T) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::stats::LowerBound<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub struct vortex_array::expr::stats::Max
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::return_dtype(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Max
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::expr::stats::Max::Bound = vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub const vortex_array::expr::stats::Max::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub struct vortex_array::expr::stats::Min
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Min
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_falsification(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type vortex_array::expr::stats::Min::Bound = vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub const vortex_array::expr::stats::Min::STAT: vortex_array::expr::stats::Stat
+pub struct vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub struct vortex_array::expr::stats::NaNCount
+impl vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NaNCount
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::scalar(&self) -> core::option::Option<vortex_array::scalar::Scalar>
 
-pub type vortex_array::expr::stats::NaNCount::Bound = vortex_array::expr::stats::UpperBound<T>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub const vortex_array::expr::stats::NaNCount::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::clone(&self) -> vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub struct vortex_array::expr::stats::NullCount
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NullCount
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub type vortex_array::expr::stats::NullCount::Bound = vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::eq(&self, other: &Self) -> bool
 
-pub const vortex_array::expr::stats::NullCount::STAT: vortex_array::expr::stats::Stat
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub struct vortex_array::expr::stats::Sum
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Sum
+impl core::fmt::Display for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub type vortex_array::expr::stats::Sum::Bound = vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub const vortex_array::expr::stats::Sum::STAT: vortex_array::expr::stats::Stat
+impl core::hash::Hash for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub struct vortex_array::expr::stats::UncompressedSizeInBytes
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::UncompressedSizeInBytes
+pub struct vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates
 
-pub type vortex_array::expr::stats::UncompressedSizeInBytes::Bound = vortex_array::expr::stats::UpperBound<T>
+impl vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates
 
-pub const vortex_array::expr::stats::UncompressedSizeInBytes::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates::new(expr: &vortex_array::expr::Expression) -> core::option::Option<Self>
 
-pub struct vortex_array::expr::stats::UpperBound<T>(_)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates::version(&self) -> u64
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::stats::UpperBound<T>
+pub mod vortex_array::scalar_fn::fns::fill_null
 
-pub fn vortex_array::expr::stats::UpperBound<T>::clone(&self) -> vortex_array::expr::stats::UpperBound<T>
+pub struct vortex_array::scalar_fn::fns::fill_null::FillNull
 
-impl<T: core::cmp::Eq> core::cmp::Eq for vortex_array::expr::stats::UpperBound<T>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::fill_null::FillNull
 
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::clone(&self) -> vortex_array::scalar_fn::fns::fill_null::FillNull
 
-pub fn vortex_array::expr::stats::UpperBound<T>::eq(&self, other: &vortex_array::expr::stats::UpperBound<T>) -> bool
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::fill_null::FillNull
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::UpperBound<T>
+pub type vortex_array::scalar_fn::fns::fill_null::FillNull::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::expr::stats::UpperBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::UpperBound<T>>>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::stats::UpperBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::stats::UpperBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::to_exact(&self) -> core::option::Option<&T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::UpperBound<T>>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T: core::cmp::PartialOrd> core::cmp::PartialEq<T> for vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::UpperBound<T>::eq(&self, other: &T) -> bool
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<T> for vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::stats::UpperBound<T>::partial_cmp(&self, other: &T) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub trait vortex_array::expr::stats::StatBound<T>: core::marker::Sized
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::StatBound::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::StatBound::into_value(self) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::stats::StatBound::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::stats::StatBound::to_exact(&self) -> core::option::Option<&T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::StatBound::union(&self, other: &Self) -> core::option::Option<Self>
+pub struct vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>(pub V)
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::LowerBound<T>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
 
-pub fn vortex_array::expr::stats::LowerBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::LowerBound<T>>>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
 
-pub fn vortex_array::expr::stats::LowerBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
 
-pub fn vortex_array::expr::stats::LowerBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::stats::LowerBound<T>::to_exact(&self) -> core::option::Option<&T>
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullKernel
 
-pub fn vortex_array::expr::stats::LowerBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::LowerBound<T>>
+pub type vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::Precision<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<Self>>
+pub struct vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>(pub V)
 
-pub fn vortex_array::expr::stats::Precision<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
 
-pub fn vortex_array::expr::stats::Precision<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
 
-pub fn vortex_array::expr::stats::Precision<T>::to_exact(&self) -> core::option::Option<&T>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
 
-pub fn vortex_array::expr::stats::Precision<T>::union(&self, other: &Self) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatBound<T> for vortex_array::expr::stats::UpperBound<T>
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullReduce
 
-pub fn vortex_array::expr::stats::UpperBound<T>::intersection(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::IntersectionResult<vortex_array::expr::stats::UpperBound<T>>>
+pub type vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::into_value(self) -> vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::lift(value: vortex_array::expr::stats::Precision<T>) -> Self
+pub trait vortex_array::scalar_fn::fns::fill_null::FillNullKernel: vortex_array::VTable
 
-pub fn vortex_array::expr::stats::UpperBound<T>::to_exact(&self) -> core::option::Option<&T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullKernel::fill_null(array: vortex_array::ArrayView<'_, Self>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::stats::UpperBound<T>::union(&self, other: &Self) -> core::option::Option<vortex_array::expr::stats::UpperBound<T>>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Bool
 
-pub trait vortex_array::expr::stats::StatType<T>
+pub fn vortex_array::arrays::Bool::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::stats::StatType::Bound: vortex_array::expr::stats::StatBound<T>
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Decimal
 
-pub const vortex_array::expr::stats::StatType::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::arrays::Decimal::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsConstant
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::Primitive
 
-pub type vortex_array::expr::stats::IsConstant::Bound = vortex_array::expr::stats::Precision<bool>
+pub fn vortex_array::arrays::Primitive::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::expr::stats::IsConstant::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::dict::Dict
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsSorted
+pub fn vortex_array::arrays::dict::Dict::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::stats::IsSorted::Bound = vortex_array::expr::stats::Precision<bool>
+pub trait vortex_array::scalar_fn::fns::fill_null::FillNullReduce: vortex_array::VTable
 
-pub const vortex_array::expr::stats::IsSorted::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduce::fill_null(array: vortex_array::ArrayView<'_, Self>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::expr::stats::StatType<bool> for vortex_array::expr::stats::IsStrictSorted
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Chunked
 
-pub type vortex_array::expr::stats::IsStrictSorted::Bound = vortex_array::expr::stats::Precision<bool>
+pub fn vortex_array::arrays::Chunked::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub const vortex_array::expr::stats::IsStrictSorted::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::Constant
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Max
+pub fn vortex_array::arrays::Constant::fill_null(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::stats::Max::Bound = vortex_array::expr::stats::UpperBound<T>
+pub mod vortex_array::scalar_fn::fns::get_item
 
-pub const vortex_array::expr::stats::Max::STAT: vortex_array::expr::stats::Stat
+pub struct vortex_array::scalar_fn::fns::get_item::GetItem
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Min
+impl core::clone::Clone for vortex_array::scalar_fn::fns::get_item::GetItem
 
-pub type vortex_array::expr::stats::Min::Bound = vortex_array::expr::stats::LowerBound<T>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::clone(&self) -> vortex_array::scalar_fn::fns::get_item::GetItem
 
-pub const vortex_array::expr::stats::Min::STAT: vortex_array::expr::stats::Stat
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::get_item::GetItem
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone + core::fmt::Debug> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::Sum
+pub type vortex_array::scalar_fn::fns::get_item::GetItem::Options = vortex_array::dtype::FieldName
 
-pub type vortex_array::expr::stats::Sum::Bound = vortex_array::expr::stats::Precision<T>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::arity(&self, _field_name: &vortex_array::dtype::FieldName) -> vortex_array::scalar_fn::Arity
 
-pub const vortex_array::expr::stats::Sum::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NaNCount
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub type vortex_array::expr::stats::NaNCount::Bound = vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub const vortex_array::expr::stats::NaNCount::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::execute(&self, field_name: &vortex_array::dtype::FieldName, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::NullCount
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::fmt_sql(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::expr::stats::NullCount::Bound = vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub const vortex_array::expr::stats::NullCount::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_fallible(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
 
-impl<T: core::cmp::PartialOrd + core::clone::Clone> vortex_array::expr::stats::StatType<T> for vortex_array::expr::stats::UncompressedSizeInBytes
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_null_sensitive(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
 
-pub type vortex_array::expr::stats::UncompressedSizeInBytes::Bound = vortex_array::expr::stats::UpperBound<T>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::reduce(&self, field_name: &vortex_array::dtype::FieldName, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub const vortex_array::expr::stats::UncompressedSizeInBytes::STAT: vortex_array::expr::stats::Stat
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::return_dtype(&self, field_name: &vortex_array::dtype::FieldName, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub trait vortex_array::expr::stats::StatsProvider
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::stats::StatsProvider::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::StatsProvider::is_empty(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify_untyped(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::stats::StatsProvider::len(&self) -> usize
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_expression(&self, field_name: &vortex_array::dtype::FieldName, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::len(&self) -> usize
+pub mod vortex_array::scalar_fn::fns::is_null
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
+pub struct vortex_array::scalar_fn::fns::is_null::IsNull
 
-pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::is_null::IsNull
 
-pub fn vortex_array::stats::StatsSetRef<'_>::len(&self) -> usize
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::clone(&self) -> vortex_array::scalar_fn::fns::is_null::IsNull
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::is_null::IsNull
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub type vortex_array::scalar_fn::fns::is_null::IsNull::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::len(&self) -> usize
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub trait vortex_array::expr::stats::StatsProviderExt: vortex_array::expr::stats::StatsProvider
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::stats::StatsProviderExt::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::stats::StatsProviderExt::get_as_bound<S, U>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound> where S: vortex_array::expr::stats::StatType<U>, U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::stats::StatsProviderExt::get_scalar_bound<S: vortex_array::expr::stats::StatType<vortex_array::scalar::Scalar>>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::execute(&self, _data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<S> vortex_array::expr::stats::StatsProviderExt for S where S: vortex_array::expr::stats::StatsProvider
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::expr::transform
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub struct vortex_array::expr::transform::PartitionedExpr<A>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_fallible(&self, _instance: &Self::Options) -> bool
 
-pub vortex_array::expr::transform::PartitionedExpr::partition_annotations: alloc::boxed::Box<[A]>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub vortex_array::expr::transform::PartitionedExpr::partition_dtypes: alloc::boxed::Box<[vortex_array::dtype::DType]>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub vortex_array::expr::transform::PartitionedExpr::partition_names: vortex_array::dtype::FieldNames
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub vortex_array::expr::transform::PartitionedExpr::partitions: alloc::boxed::Box<[vortex_array::expr::Expression]>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::expr::transform::PartitionedExpr::root: vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<A: vortex_array::expr::Annotation> vortex_array::expr::transform::PartitionedExpr<A> where vortex_array::dtype::FieldName: core::convert::From<A>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::transform::PartitionedExpr<A>::find_partition(&self, id: &A) -> core::option::Option<&vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<A: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::transform::PartitionedExpr<A>
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::transform::PartitionedExpr<A>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<A: core::fmt::Display> core::fmt::Display for vortex_array::expr::transform::PartitionedExpr<A>
+pub mod vortex_array::scalar_fn::fns::like
 
-pub fn vortex_array::expr::transform::PartitionedExpr<A>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::scalar_fn::fns::like::Like
 
-pub fn vortex_array::expr::transform::partition<A: vortex_array::expr::AnnotationFn>(expr: vortex_array::expr::Expression, scope: &vortex_array::dtype::DType, annotate_fn: A) -> vortex_error::VortexResult<vortex_array::expr::transform::PartitionedExpr<<A as vortex_array::expr::AnnotationFn>::Annotation>> where <A as vortex_array::expr::AnnotationFn>::Annotation: core::fmt::Display, vortex_array::dtype::FieldName: core::convert::From<<A as vortex_array::expr::AnnotationFn>::Annotation>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::like::Like
 
-pub fn vortex_array::expr::transform::replace(expr: vortex_array::expr::Expression, needle: &vortex_array::expr::Expression, replacement: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::like::Like::clone(&self) -> vortex_array::scalar_fn::fns::like::Like
 
-pub fn vortex_array::expr::transform::replace_root_fields(expr: vortex_array::expr::Expression, fields: &vortex_array::dtype::StructFields) -> vortex_array::expr::Expression
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::like::Like
 
-pub mod vortex_array::expr::traversal
+pub type vortex_array::scalar_fn::fns::like::Like::Options = vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub enum vortex_array::expr::traversal::FoldDown<R>
+pub fn vortex_array::scalar_fn::fns::like::Like::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub vortex_array::expr::traversal::FoldDown::Continue
+pub fn vortex_array::scalar_fn::fns::like::Like::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub vortex_array::expr::traversal::FoldDown::Skip(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub vortex_array::expr::traversal::FoldDown::Stop(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl<R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldDown<R>
+pub fn vortex_array::scalar_fn::fns::like::Like::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::traversal::FoldDown<R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::like::Like::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub enum vortex_array::expr::traversal::FoldDownContext<C, R>
+pub fn vortex_array::scalar_fn::fns::like::Like::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub vortex_array::expr::traversal::FoldDownContext::Continue(C)
+pub fn vortex_array::scalar_fn::fns::like::Like::is_fallible(&self, options: &Self::Options) -> bool
 
-pub vortex_array::expr::traversal::FoldDownContext::Skip(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub vortex_array::expr::traversal::FoldDownContext::Stop(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl<C: core::fmt::Debug, R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldDownContext<C, R>
+pub fn vortex_array::scalar_fn::fns::like::Like::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::expr::traversal::FoldDownContext<C, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::like::Like::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub enum vortex_array::expr::traversal::FoldUp<R>
+pub fn vortex_array::scalar_fn::fns::like::Like::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::expr::traversal::FoldUp::Continue(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::expr::traversal::FoldUp::Stop(R)
+pub fn vortex_array::scalar_fn::fns::like::Like::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<R> vortex_array::expr::traversal::FoldUp<R>
+pub fn vortex_array::scalar_fn::fns::like::Like::stat_falsification(&self, like_opts: &vortex_array::scalar_fn::fns::like::LikeOptions, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::traversal::FoldUp<R>::value(self) -> R
+pub fn vortex_array::scalar_fn::fns::like::Like::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<R: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::FoldUp<R>
+pub struct vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>(pub V)
 
-pub fn vortex_array::expr::traversal::FoldUp<R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
 
-pub enum vortex_array::expr::traversal::TraversalOrder
+pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
 
-pub vortex_array::expr::traversal::TraversalOrder::Continue
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
 
-pub vortex_array::expr::traversal::TraversalOrder::Skip
+pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::expr::traversal::TraversalOrder::Stop
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeKernel
 
-impl vortex_array::expr::traversal::TraversalOrder
+pub type vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
 
-pub fn vortex_array::expr::traversal::TraversalOrder::visit_children<F: core::ops::function::FnOnce() -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::traversal::TraversalOrder::visit_parent<F: core::ops::function::FnOnce() -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub struct vortex_array::scalar_fn::fns::like::LikeOptions
 
-impl core::clone::Clone for vortex_array::expr::traversal::TraversalOrder
+pub vortex_array::scalar_fn::fns::like::LikeOptions::case_insensitive: bool
 
-pub fn vortex_array::expr::traversal::TraversalOrder::clone(&self) -> vortex_array::expr::traversal::TraversalOrder
+pub vortex_array::scalar_fn::fns::like::LikeOptions::negated: bool
 
-impl core::cmp::Eq for vortex_array::expr::traversal::TraversalOrder
+impl core::clone::Clone for vortex_array::scalar_fn::fns::like::LikeOptions
 
-impl core::cmp::PartialEq for vortex_array::expr::traversal::TraversalOrder
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::clone(&self) -> vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::TraversalOrder::eq(&self, other: &vortex_array::expr::traversal::TraversalOrder) -> bool
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::like::LikeOptions
 
-impl core::fmt::Debug for vortex_array::expr::traversal::TraversalOrder
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::TraversalOrder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::eq(&self, other: &vortex_array::scalar_fn::fns::like::LikeOptions) -> bool
 
-impl core::marker::StructuralPartialEq for vortex_array::expr::traversal::TraversalOrder
+impl core::default::Default for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub struct vortex_array::expr::traversal::ReferenceCollector
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::default() -> vortex_array::scalar_fn::fns::like::LikeOptions
 
-impl vortex_array::expr::traversal::ReferenceCollector
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::into_fields(self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::new() -> Self
+impl core::fmt::Display for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::with_set(set: vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>) -> Self
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::default::Default for vortex_array::expr::traversal::ReferenceCollector
+impl core::hash::Hash for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::default() -> vortex_array::expr::traversal::ReferenceCollector
+pub fn vortex_array::scalar_fn::fns::like::LikeOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-impl vortex_array::expr::traversal::NodeVisitor<'_> for vortex_array::expr::traversal::ReferenceCollector
+impl core::marker::Copy for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub type vortex_array::expr::traversal::ReferenceCollector::NodeTy = vortex_array::expr::Expression
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::visit_up(&mut self, node: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub struct vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>(pub V)
 
-pub struct vortex_array::expr::traversal::Transformed<T>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
 
-pub vortex_array::expr::traversal::Transformed::changed: bool
+pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
 
-pub vortex_array::expr::traversal::Transformed::order: vortex_array::expr::traversal::TraversalOrder
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
 
-pub vortex_array::expr::traversal::Transformed::value: T
+pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<T> vortex_array::expr::traversal::Transformed<T>
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeReduce
 
-pub fn vortex_array::expr::traversal::Transformed<T>::into_inner(self) -> T
+pub type vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
 
-pub fn vortex_array::expr::traversal::Transformed<T>::map<O, F: core::ops::function::FnOnce(T) -> O>(self, f: F) -> vortex_array::expr::traversal::Transformed<O>
+pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::traversal::Transformed<T>::no(value: T) -> Self
+pub trait vortex_array::scalar_fn::fns::like::LikeKernel: vortex_array::VTable
 
-pub fn vortex_array::expr::traversal::Transformed<T>::yes(value: T) -> Self
+pub fn vortex_array::scalar_fn::fns::like::LikeKernel::like(array: vortex_array::ArrayView<'_, Self>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::clone::Clone> core::clone::Clone for vortex_array::expr::traversal::Transformed<T>
+pub trait vortex_array::scalar_fn::fns::like::LikeReduce: vortex_array::VTable
 
-pub fn vortex_array::expr::traversal::Transformed<T>::clone(&self) -> vortex_array::expr::traversal::Transformed<T>
+pub fn vortex_array::scalar_fn::fns::like::LikeReduce::like(array: vortex_array::ArrayView<'_, Self>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T: core::fmt::Debug> core::fmt::Debug for vortex_array::expr::traversal::Transformed<T>
+impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::expr::traversal::Transformed<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::dict::Dict::like(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, pattern: &vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::expr::traversal::Node: core::marker::Sized + core::clone::Clone
+pub mod vortex_array::scalar_fn::fns::list_contains
 
-pub fn vortex_array::expr::traversal::Node::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub struct vortex_array::scalar_fn::fns::list_contains::ListContains
 
-pub fn vortex_array::expr::traversal::Node::children_count(&self) -> usize
+impl core::clone::Clone for vortex_array::scalar_fn::fns::list_contains::ListContains
 
-pub fn vortex_array::expr::traversal::Node::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::clone(&self) -> vortex_array::scalar_fn::fns::list_contains::ListContains
 
-pub fn vortex_array::expr::traversal::Node::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::list_contains::ListContains
 
-impl vortex_array::expr::traversal::Node for vortex_array::expr::Expression
+pub type vortex_array::scalar_fn::fns::list_contains::ListContains::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::expr::Expression::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::Expression::children_count(&self) -> usize
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::Expression::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::Expression::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub trait vortex_array::expr::traversal::NodeContainer<'a, T: 'a>: core::marker::Sized
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::traversal::NodeContainer::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::traversal::NodeContainer::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl<'a, T, C> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::sync::Arc<C> where T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T> + core::clone::Clone
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn alloc::sync::Arc<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn alloc::sync::Arc<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<alloc::sync::Arc<C>>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for [C; 2]
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn [C; 2]::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn [C; 2]::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<[C; 2]>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::boxed::Box<C>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn alloc::boxed::Box<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn alloc::boxed::Box<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<alloc::boxed::Box<C>>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeContainer<'a, T> for alloc::vec::Vec<C>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn alloc::vec::Vec<C>::apply_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub struct vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>(pub V)
 
-pub fn alloc::vec::Vec<C>::map_elements<F: core::ops::function::FnMut(T) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<T>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
 
-impl<'a> vortex_array::expr::traversal::NodeContainer<'a, vortex_array::expr::Expression> for vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
 
-pub fn vortex_array::expr::Expression::apply_elements<F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
 
-pub fn vortex_array::expr::Expression::map_elements<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub trait vortex_array::expr::traversal::NodeExt: vortex_array::expr::traversal::Node
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel
 
-pub fn vortex_array::expr::traversal::NodeExt::accept<'a, V: vortex_array::expr::traversal::NodeVisitor<'a, NodeTy = Self>>(&'a self, visitor: &mut V) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
 
-pub fn vortex_array::expr::traversal::NodeExt::fold<R, F: vortex_array::expr::traversal::NodeFolder<NodeTy = Self, Result = R>>(self, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::traversal::NodeExt::fold_context<R, F: vortex_array::expr::traversal::NodeFolderContext<NodeTy = Self, Result = R>>(self, ctx: &<F as vortex_array::expr::traversal::NodeFolderContext>::Context, folder: &mut F) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<R>>
+pub struct vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>(pub V)
 
-pub fn vortex_array::expr::traversal::NodeExt::rewrite<R: vortex_array::expr::traversal::NodeRewriter<NodeTy = Self>>(self, rewriter: &mut R) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
 
-pub fn vortex_array::expr::traversal::NodeExt::transform<F, G>(self, down: F, up: G) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>> where F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>, G: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
 
-pub fn vortex_array::expr::traversal::NodeExt::transform_down<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
 
-pub fn vortex_array::expr::traversal::NodeExt::transform_up<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<T: vortex_array::expr::traversal::Node> vortex_array::expr::traversal::NodeExt for T
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce
 
-pub trait vortex_array::expr::traversal::NodeFolder
+pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
 
-pub type vortex_array::expr::traversal::NodeFolder::NodeTy: vortex_array::expr::traversal::Node
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::traversal::NodeFolder::Result
+pub trait vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel: vortex_array::VTable
 
-pub fn vortex_array::expr::traversal::NodeFolder::visit_down(&mut self, _node: &Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldDown<Self::Result>>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel::list_contains(list: &vortex_array::ArrayRef, element: vortex_array::ArrayView<'_, Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::traversal::NodeFolder::visit_up(&mut self, _node: Self::NodeTy, _children: alloc::vec::Vec<Self::Result>) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<Self::Result>>
+pub trait vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce: vortex_array::VTable
 
-pub trait vortex_array::expr::traversal::NodeFolderContext
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce::list_contains(list: &vortex_array::ArrayRef, element: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::expr::traversal::NodeFolderContext::Context
+pub mod vortex_array::scalar_fn::fns::literal
 
-pub type vortex_array::expr::traversal::NodeFolderContext::NodeTy: vortex_array::expr::traversal::Node
+pub struct vortex_array::scalar_fn::fns::literal::Literal
 
-pub type vortex_array::expr::traversal::NodeFolderContext::Result
+impl core::clone::Clone for vortex_array::scalar_fn::fns::literal::Literal
 
-pub fn vortex_array::expr::traversal::NodeFolderContext::visit_down(&mut self, _ctx: &Self::Context, _node: &Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldDownContext<Self::Context, Self::Result>>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::clone(&self) -> vortex_array::scalar_fn::fns::literal::Literal
 
-pub fn vortex_array::expr::traversal::NodeFolderContext::visit_up(&mut self, _node: Self::NodeTy, _context: &Self::Context, _children: alloc::vec::Vec<Self::Result>) -> vortex_error::VortexResult<vortex_array::expr::traversal::FoldUp<Self::Result>>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::literal::Literal
 
-pub trait vortex_array::expr::traversal::NodeRefContainer<'a, T: 'a>: core::marker::Sized
+pub type vortex_array::scalar_fn::fns::literal::Literal::Options = vortex_array::scalar::Scalar
 
-pub fn vortex_array::expr::traversal::NodeRefContainer::apply_ref_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl<'a, T: 'a, C: vortex_array::expr::traversal::NodeContainer<'a, T>> vortex_array::expr::traversal::NodeRefContainer<'a, T> for &'a [C]
+pub fn vortex_array::scalar_fn::fns::literal::Literal::child_name(&self, _instance: &Self::Options, _child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn &'a [C]::apply_ref_elements<F: core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub trait vortex_array::expr::traversal::NodeRewriter: core::marker::Sized
+pub fn vortex_array::scalar_fn::fns::literal::Literal::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type vortex_array::expr::traversal::NodeRewriter::NodeTy: vortex_array::expr::traversal::Node
+pub fn vortex_array::scalar_fn::fns::literal::Literal::execute(&self, scalar: &vortex_array::scalar::Scalar, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::traversal::NodeRewriter::visit_down(&mut self, node: Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self::NodeTy>>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::fmt_sql(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::traversal::NodeRewriter::visit_up(&mut self, node: Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self::NodeTy>>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub trait vortex_array::expr::traversal::NodeVisitor<'a>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::is_fallible(&self, _instance: &Self::Options) -> bool
 
-pub type vortex_array::expr::traversal::NodeVisitor::NodeTy: vortex_array::expr::traversal::Node
+pub fn vortex_array::scalar_fn::fns::literal::Literal::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::expr::traversal::NodeVisitor::visit_down(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::traversal::NodeVisitor::visit_up(&mut self, node: &'a Self::NodeTy) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::return_dtype(&self, options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl vortex_array::expr::traversal::NodeVisitor<'_> for vortex_array::expr::traversal::ReferenceCollector
+pub fn vortex_array::scalar_fn::fns::literal::Literal::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::expr::traversal::ReferenceCollector::NodeTy = vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::literal::Literal::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::traversal::ReferenceCollector::visit_up(&mut self, node: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::traversal::pre_order_visit_down<'a, T: 'a + vortex_array::expr::traversal::Node>(tree: &'a T, f: impl core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_expression(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, _catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::traversal::pre_order_visit_up<'a, T: 'a + vortex_array::expr::traversal::Node>(tree: &'a T, f: impl core::ops::function::FnMut(&'a T) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub struct vortex_array::expr::ExactExpr(pub vortex_array::expr::Expression)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::validity(&self, scalar: &vortex_array::scalar::Scalar, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::clone::Clone for vortex_array::expr::ExactExpr
+pub mod vortex_array::scalar_fn::fns::mask
 
-pub fn vortex_array::expr::ExactExpr::clone(&self) -> vortex_array::expr::ExactExpr
+pub struct vortex_array::scalar_fn::fns::mask::Mask
 
-impl core::cmp::Eq for vortex_array::expr::ExactExpr
+impl core::clone::Clone for vortex_array::scalar_fn::fns::mask::Mask
 
-impl core::cmp::PartialEq for vortex_array::expr::ExactExpr
+pub fn vortex_array::scalar_fn::fns::mask::Mask::clone(&self) -> vortex_array::scalar_fn::fns::mask::Mask
 
-pub fn vortex_array::expr::ExactExpr::eq(&self, other: &Self) -> bool
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::mask::Mask
 
-impl core::hash::Hash for vortex_array::expr::ExactExpr
+pub type vortex_array::scalar_fn::fns::mask::Mask::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::expr::ExactExpr::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::scalar_fn::fns::mask::Mask::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub struct vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::Mask::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::Mask::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::Expression::child(&self, n: usize) -> &vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::Mask::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::Expression::children(&self) -> &alloc::sync::Arc<alloc::vec::Vec<vortex_array::expr::Expression>>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::Expression::display_tree(&self) -> impl core::fmt::Display
+pub fn vortex_array::scalar_fn::fns::mask::Mask::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::Expression::fmt_sql(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::mask::Mask::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::expr::Expression::return_dtype(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::Expression::scalar_fn(&self) -> &vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::scalar_fn::fns::mask::Mask::is_null_sensitive(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::expr::Expression::stat_expression(&self, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::Expression::stat_falsification(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::expr::Expression::stat_max(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::Expression::stat_min(&self, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::Expression::try_new(scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::Expression::validity(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::Expression::with_children(self, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::Mask::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::Expression::from_proto(expr: &vortex_proto::expr::Expr, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub struct vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>(pub V)
 
-impl vortex_array::expr::Expression
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
 
-pub fn vortex_array::expr::Expression::optimize(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
 
-pub fn vortex_array::expr::Expression::optimize_recursive(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
 
-pub fn vortex_array::expr::Expression::simplify(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::Expression::simplify_untyped(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskKernel
 
-pub fn vortex_array::expr::Expression::try_optimize(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub type vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
 
-pub fn vortex_array::expr::Expression::try_optimize_recursive(&self, scope: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::expr::Expression
+pub struct vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>(pub V)
 
-pub fn vortex_array::expr::Expression::clone(&self) -> vortex_array::expr::Expression
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
 
-impl core::cmp::Eq for vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
 
-impl core::cmp::PartialEq for vortex_array::expr::Expression
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
 
-pub fn vortex_array::expr::Expression::eq(&self, other: &vortex_array::expr::Expression) -> bool
+pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::fmt::Debug for vortex_array::expr::Expression
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskReduce
 
-pub fn vortex_array::expr::Expression::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
 
-impl core::fmt::Display for vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub trait vortex_array::scalar_fn::fns::mask::MaskKernel: vortex_array::VTable
 
-impl core::hash::Hash for vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::mask::MaskKernel::mask(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+impl vortex_array::scalar_fn::fns::mask::MaskKernel for vortex_array::arrays::Chunked
 
-impl core::marker::StructuralPartialEq for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Chunked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::ops::deref::Deref for vortex_array::expr::Expression
+pub trait vortex_array::scalar_fn::fns::mask::MaskReduce: vortex_array::VTable
 
-pub type vortex_array::expr::Expression::Target = vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::scalar_fn::fns::mask::MaskReduce::mask(array: vortex_array::ArrayView<'_, Self>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::deref(&self) -> &Self::Target
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Bool
 
-impl core::ops::drop::Drop for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Bool::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::drop(&mut self)
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Decimal
 
-impl vortex_array::builtins::ExprBuiltins for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Decimal::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::binary(&self, rhs: vortex_array::expr::Expression, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Extension
 
-pub fn vortex_array::expr::Expression::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Extension::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::fill_null(&self, fill_value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::expr::Expression::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::FixedSizeList::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::is_null(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::List
 
-pub fn vortex_array::expr::Expression::list_contains(&self, value: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::List::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::mask(&self, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListView
 
-pub fn vortex_array::expr::Expression::not(&self) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::ListView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::zip(&self, if_false: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Masked
 
-impl vortex_array::expr::VortexExprExt for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Masked::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Primitive
 
-impl vortex_array::expr::proto::ExprSerializeProtoExt for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Primitive::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::serialize_proto(&self) -> vortex_error::VortexResult<vortex_proto::expr::Expr>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::Struct
 
-impl vortex_array::expr::traversal::Node for vortex_array::expr::Expression
+pub fn vortex_array::arrays::Struct::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::apply_children<'a, F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBin
 
-pub fn vortex_array::expr::Expression::children_count(&self) -> usize
+pub fn vortex_array::arrays::VarBin::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::iter_children<T>(&self, f: impl core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &Self>) -> T) -> T
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::expr::Expression::map_children<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+pub fn vortex_array::arrays::VarBinView::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> vortex_array::expr::traversal::NodeContainer<'a, vortex_array::expr::Expression> for vortex_array::expr::Expression
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::expr::Expression::apply_elements<F: core::ops::function::FnMut(&'a Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>>(&'a self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::TraversalOrder>
+pub fn vortex_array::arrays::dict::Dict::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::expr::Expression::map_elements<F: core::ops::function::FnMut(Self) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>>(self, f: F) -> vortex_error::VortexResult<vortex_array::expr::traversal::Transformed<Self>>
+impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::null::Null
 
-pub trait vortex_array::expr::Annotation: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub fn vortex_array::arrays::null::Null::mask(array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<A> vortex_array::expr::Annotation for A where A: core::clone::Clone + core::hash::Hash + core::cmp::Eq
+pub mod vortex_array::scalar_fn::fns::merge
 
-pub trait vortex_array::expr::AnnotationFn: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<Self::Annotation>
+pub enum vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub type vortex_array::expr::AnnotationFn::Annotation: vortex_array::expr::Annotation
+pub vortex_array::scalar_fn::fns::merge::DuplicateHandling::Error
 
-impl<A, F> vortex_array::expr::AnnotationFn for F where A: vortex_array::expr::Annotation, F: core::ops::function::Fn(&vortex_array::expr::Expression) -> alloc::vec::Vec<A>
+pub vortex_array::scalar_fn::fns::merge::DuplicateHandling::RightMost
 
-pub type F::Annotation = A
+impl core::clone::Clone for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub trait vortex_array::expr::StatsCatalog
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::clone(&self) -> vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::StatsCatalog::stats_ref(&self, _field_path: &vortex_array::dtype::FieldPath, _stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::Expression>
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub trait vortex_array::expr::VortexExprExt
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::VortexExprExt::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::eq(&self, other: &vortex_array::scalar_fn::fns::merge::DuplicateHandling) -> bool
 
-impl vortex_array::expr::VortexExprExt for vortex_array::expr::Expression
+impl core::default::Default for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::Expression::field_references(&self) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::default() -> vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::and(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::and_collect<I>(iter: I) -> core::option::Option<vortex_array::expr::Expression> where I: core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::between(arr: vortex_array::expr::Expression, lower: vortex_array::expr::Expression, upper: vortex_array::expr::Expression, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_array::expr::Expression
+impl core::fmt::Display for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::cast(child: vortex_array::expr::Expression, target: vortex_array::dtype::DType) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::checked_add(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl core::hash::Hash for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::col(field: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::expr::descendent_annotations<A: vortex_array::expr::AnnotationFn>(expr: &vortex_array::expr::Expression, annotate: A) -> vortex_array::expr::Annotations<'_, <A as vortex_array::expr::AnnotationFn>::Annotation>
+impl core::marker::Copy for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::dynamic(operator: vortex_array::scalar_fn::fns::operators::CompareOperator, rhs_value: impl core::ops::function::Fn() -> core::option::Option<vortex_array::scalar::ScalarValue> + core::marker::Send + core::marker::Sync + 'static, rhs_dtype: vortex_array::dtype::DType, default: bool, lhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub struct vortex_array::scalar_fn::fns::merge::Merge
 
-pub fn vortex_array::expr::fill_null(child: vortex_array::expr::Expression, fill_value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl core::clone::Clone for vortex_array::scalar_fn::fns::merge::Merge
 
-pub fn vortex_array::expr::get_item(field: impl core::convert::Into<vortex_array::dtype::FieldName>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::clone(&self) -> vortex_array::scalar_fn::fns::merge::Merge
 
-pub fn vortex_array::expr::gt(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::merge::Merge
 
-pub fn vortex_array::expr::gt_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub type vortex_array::scalar_fn::fns::merge::Merge::Options = vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::expr::ilike(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::immediate_scope_access<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_utils::aliases::hash_set::HashSet<vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::immediate_scope_accesses<'a>(expr: &'a vortex_array::expr::Expression, scope: &'a vortex_array::dtype::StructFields) -> vortex_array::expr::FieldAccesses<'a>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::is_null(child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::is_root(expr: &vortex_array::expr::Expression) -> bool
+pub fn vortex_array::scalar_fn::fns::merge::Merge::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::label_is_fallible(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::expr::label_null_sensitive(expr: &vortex_array::expr::Expression) -> vortex_array::expr::BooleanLabels<'_>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::expr::label_tree<L: core::clone::Clone>(expr: &vortex_array::expr::Expression, self_label: impl core::ops::function::Fn(&vortex_array::expr::Expression) -> L, merge_child: impl core::ops::function::FnMut(L, &L) -> L) -> vortex_utils::aliases::hash_map::HashMap<&vortex_array::expr::Expression, L>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::is_fallible(&self, instance: &Self::Options) -> bool
 
-pub fn vortex_array::expr::like(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::expr::list_contains(list: vortex_array::expr::Expression, value: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::expr::lit(value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::expr::lt(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::expr::lt_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::make_free_field_annotator(scope: &vortex_array::dtype::StructFields) -> impl vortex_array::expr::AnnotationFn<Annotation = vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::mask(array: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::merge(elements: impl core::iter::traits::collect::IntoIterator<Item = impl core::convert::Into<vortex_array::expr::Expression>>) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::expr::merge_opts(elements: impl core::iter::traits::collect::IntoIterator<Item = impl core::convert::Into<vortex_array::expr::Expression>>, duplicate_handling: vortex_array::scalar_fn::fns::merge::DuplicateHandling) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::merge::Merge::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::expr::not(operand: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub mod vortex_array::scalar_fn::fns::not
 
-pub fn vortex_array::expr::not_eq(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub struct vortex_array::scalar_fn::fns::not::Not
 
-pub fn vortex_array::expr::not_ilike(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl core::clone::Clone for vortex_array::scalar_fn::fns::not::Not
 
-pub fn vortex_array::expr::not_like(child: vortex_array::expr::Expression, pattern: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::clone(&self) -> vortex_array::scalar_fn::fns::not::Not
 
-pub fn vortex_array::expr::or(lhs: vortex_array::expr::Expression, rhs: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::not::Not
 
-pub fn vortex_array::expr::or_collect<I>(iter: I) -> core::option::Option<vortex_array::expr::Expression> where I: core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>
+pub type vortex_array::scalar_fn::fns::not::Not::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::expr::pack(elements: impl core::iter::traits::collect::IntoIterator<Item = (impl core::convert::Into<vortex_array::dtype::FieldName>, vortex_array::expr::Expression)>, nullability: vortex_array::dtype::Nullability) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::expr::root() -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::expr::select(field_names: impl core::convert::Into<vortex_array::dtype::FieldNames>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::expr::select_exclude(fields: impl core::convert::Into<vortex_array::dtype::FieldNames>, child: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::expr::split_conjunction(expr: &vortex_array::expr::Expression) -> alloc::vec::Vec<vortex_array::expr::Expression>
+pub fn vortex_array::scalar_fn::fns::not::Not::execute(&self, _data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::expr::zip_expr(if_true: vortex_array::expr::Expression, if_false: vortex_array::expr::Expression, mask: vortex_array::expr::Expression) -> vortex_array::expr::Expression
+pub fn vortex_array::scalar_fn::fns::not::Not::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::expr::Annotations<'a, A> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, vortex_utils::aliases::hash_set::HashSet<A>>
+pub fn vortex_array::scalar_fn::fns::not::Not::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub type vortex_array::expr::BooleanLabels<'a> = vortex_utils::aliases::hash_map::HashMap<&'a vortex_array::expr::Expression, bool>
+pub fn vortex_array::scalar_fn::fns::not::Not::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub type vortex_array::expr::FieldAccesses<'a> = vortex_array::expr::Annotations<'a, vortex_array::dtype::FieldName>
+pub fn vortex_array::scalar_fn::fns::not::Not::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub mod vortex_array::extension
+pub fn vortex_array::scalar_fn::fns::not::Not::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub mod vortex_array::extension::datetime
+pub fn vortex_array::scalar_fn::fns::not::Not::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub enum vortex_array::extension::datetime::DateValue
+pub fn vortex_array::scalar_fn::fns::not::Not::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::extension::datetime::DateValue::Days(i32)
+pub fn vortex_array::scalar_fn::fns::not::Not::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::extension::datetime::DateValue::Milliseconds(i64)
+pub fn vortex_array::scalar_fn::fns::not::Not::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::fmt::Display for vortex_array::extension::datetime::DateValue
+pub fn vortex_array::scalar_fn::fns::not::Not::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::extension::datetime::DateValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::not::Not::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub enum vortex_array::extension::datetime::TemporalJiff
+pub fn vortex_array::scalar_fn::fns::not::Not::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::extension::datetime::TemporalJiff::Date(jiff::civil::date::Date)
+pub struct vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>(pub V)
 
-pub vortex_array::extension::datetime::TemporalJiff::Time(jiff::civil::time::Time)
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
 
-pub vortex_array::extension::datetime::TemporalJiff::Unzoned(jiff::civil::datetime::DateTime)
+pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
 
-pub vortex_array::extension::datetime::TemporalJiff::Zoned(jiff::zoned::Zoned)
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
 
-impl core::fmt::Display for vortex_array::extension::datetime::TemporalJiff
+pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::extension::datetime::TemporalJiff::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotKernel
 
-pub enum vortex_array::extension::datetime::TemporalMetadata<'a>
+pub type vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
 
-pub vortex_array::extension::datetime::TemporalMetadata::Date(&'a <vortex_array::extension::datetime::Date as vortex_array::dtype::extension::ExtVTable>::Metadata)
+pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, _parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::extension::datetime::TemporalMetadata::Time(&'a <vortex_array::extension::datetime::Time as vortex_array::dtype::extension::ExtVTable>::Metadata)
+pub struct vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>(pub V)
 
-pub vortex_array::extension::datetime::TemporalMetadata::Timestamp(&'a vortex_array::extension::datetime::TimeUnit, &'a core::option::Option<alloc::sync::Arc<str>>)
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
 
-impl vortex_array::extension::datetime::TemporalMetadata<'_>
+pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
 
-pub fn vortex_array::extension::datetime::TemporalMetadata<'_>::time_unit(&self) -> vortex_array::extension::datetime::TimeUnit
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
 
-pub fn vortex_array::extension::datetime::TemporalMetadata<'_>::to_jiff(&self, v: i64) -> vortex_error::VortexResult<vortex_array::extension::datetime::TemporalJiff>
+pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<'a> core::cmp::Eq for vortex_array::extension::datetime::TemporalMetadata<'a>
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotReduce
 
-impl<'a> core::cmp::PartialEq for vortex_array::extension::datetime::TemporalMetadata<'a>
+pub type vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
 
-pub fn vortex_array::extension::datetime::TemporalMetadata<'a>::eq(&self, other: &vortex_array::extension::datetime::TemporalMetadata<'a>) -> bool
+pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, _parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::fmt::Debug for vortex_array::extension::datetime::TemporalMetadata<'a>
+pub trait vortex_array::scalar_fn::fns::not::NotKernel: vortex_array::VTable
 
-pub fn vortex_array::extension::datetime::TemporalMetadata<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::not::NotKernel::invert(array: vortex_array::ArrayView<'_, Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::marker::StructuralPartialEq for vortex_array::extension::datetime::TemporalMetadata<'a>
+pub trait vortex_array::scalar_fn::fns::not::NotReduce: vortex_array::VTable
 
-#[repr(u8)] pub enum vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::not::NotReduce::invert(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::extension::datetime::TimeUnit::Days = 4
+impl vortex_array::scalar_fn::fns::not::NotReduce for vortex_array::arrays::Constant
 
-pub vortex_array::extension::datetime::TimeUnit::Microseconds = 1
+pub fn vortex_array::arrays::Constant::invert(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::extension::datetime::TimeUnit::Milliseconds = 2
+pub mod vortex_array::scalar_fn::fns::operators
 
-pub vortex_array::extension::datetime::TimeUnit::Nanoseconds = 0
+pub enum vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub vortex_array::extension::datetime::TimeUnit::Seconds = 3
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::Eq
 
-impl vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::Gt
 
-pub fn vortex_array::extension::datetime::TimeUnit::to_jiff_span(&self, v: i64) -> vortex_error::VortexResult<jiff::span::Span>
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::Gte
 
-impl core::clone::Clone for vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::Lt
 
-pub fn vortex_array::extension::datetime::TimeUnit::clone(&self) -> vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::Lte
 
-impl core::cmp::Eq for vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::CompareOperator::NotEq
 
-impl core::cmp::Ord for vortex_array::extension::datetime::TimeUnit
+impl vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::TimeUnit::cmp(&self, other: &vortex_array::extension::datetime::TimeUnit) -> core::cmp::Ordering
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::inverse(self) -> Self
 
-impl core::cmp::PartialEq for vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::swap(self) -> Self
 
-pub fn vortex_array::extension::datetime::TimeUnit::eq(&self, other: &vortex_array::extension::datetime::TimeUnit) -> bool
+impl core::clone::Clone for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl core::cmp::PartialOrd for vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::clone(&self) -> vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::TimeUnit::partial_cmp(&self, other: &vortex_array::extension::datetime::TimeUnit) -> core::option::Option<core::cmp::Ordering>
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl core::convert::From<&arrow_schema::datatype::TimeUnit> for vortex_array::extension::datetime::TimeUnit
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::TimeUnit::from(value: &arrow_schema::datatype::TimeUnit) -> Self
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::eq(&self, other: &vortex_array::scalar_fn::fns::operators::CompareOperator) -> bool
 
-impl core::convert::From<arrow_schema::datatype::TimeUnit> for vortex_array::extension::datetime::TimeUnit
+impl core::cmp::PartialOrd for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::TimeUnit::from(value: arrow_schema::datatype::TimeUnit) -> Self
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::partial_cmp(&self, other: &vortex_array::scalar_fn::fns::operators::CompareOperator) -> core::option::Option<core::cmp::Ordering>
 
-impl core::convert::From<vortex_array::extension::datetime::TimeUnit> for u8
+impl core::convert::From<vortex_array::scalar_fn::fns::operators::CompareOperator> for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn u8::from(enum_value: vortex_array::extension::datetime::TimeUnit) -> Self
+pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_array::scalar_fn::fns::operators::CompareOperator) -> Self
 
-impl core::convert::TryFrom<u8> for vortex_array::extension::datetime::TimeUnit
+impl core::convert::TryFrom<vortex_array::scalar_fn::fns::operators::Operator> for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub type vortex_array::extension::datetime::TimeUnit::Error = vortex_error::VortexError
+pub type vortex_array::scalar_fn::fns::operators::CompareOperator::Error = vortex_error::VortexError
 
-pub fn vortex_array::extension::datetime::TimeUnit::try_from(value: u8) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::try_from(value: vortex_array::scalar_fn::fns::operators::Operator) -> core::result::Result<Self, Self::Error>
 
-impl core::convert::TryFrom<vortex_array::extension::datetime::TimeUnit> for arrow_schema::datatype::TimeUnit
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub type arrow_schema::datatype::TimeUnit::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn arrow_schema::datatype::TimeUnit::try_from(value: vortex_array::extension::datetime::TimeUnit) -> vortex_error::VortexResult<Self>
+impl core::fmt::Display for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl core::fmt::Debug for vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::extension::datetime::TimeUnit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::hash::Hash for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl core::fmt::Display for vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::extension::datetime::TimeUnit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::marker::Copy for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-impl core::hash::Hash for vortex_array::extension::datetime::TimeUnit
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::TimeUnit::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub enum vortex_array::scalar_fn::fns::operators::Operator
 
-impl core::marker::Copy for vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::Operator::Add
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::TimeUnit
+pub vortex_array::scalar_fn::fns::operators::Operator::And
 
-pub enum vortex_array::extension::datetime::TimeValue
+pub vortex_array::scalar_fn::fns::operators::Operator::Div
 
-pub vortex_array::extension::datetime::TimeValue::Microseconds(i64)
+pub vortex_array::scalar_fn::fns::operators::Operator::Eq
 
-pub vortex_array::extension::datetime::TimeValue::Milliseconds(i32)
+pub vortex_array::scalar_fn::fns::operators::Operator::Gt
 
-pub vortex_array::extension::datetime::TimeValue::Nanoseconds(i64)
+pub vortex_array::scalar_fn::fns::operators::Operator::Gte
 
-pub vortex_array::extension::datetime::TimeValue::Seconds(i32)
+pub vortex_array::scalar_fn::fns::operators::Operator::Lt
 
-impl core::fmt::Display for vortex_array::extension::datetime::TimeValue
+pub vortex_array::scalar_fn::fns::operators::Operator::Lte
 
-pub fn vortex_array::extension::datetime::TimeValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub vortex_array::scalar_fn::fns::operators::Operator::Mul
 
-pub enum vortex_array::extension::datetime::TimestampValue<'a>
+pub vortex_array::scalar_fn::fns::operators::Operator::NotEq
 
-pub vortex_array::extension::datetime::TimestampValue::Microseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+pub vortex_array::scalar_fn::fns::operators::Operator::Or
 
-pub vortex_array::extension::datetime::TimestampValue::Milliseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+pub vortex_array::scalar_fn::fns::operators::Operator::Sub
 
-pub vortex_array::extension::datetime::TimestampValue::Nanoseconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+impl vortex_array::scalar_fn::fns::operators::Operator
 
-pub vortex_array::extension::datetime::TimestampValue::Seconds(i64, core::option::Option<&'a alloc::sync::Arc<str>>)
+pub fn vortex_array::scalar_fn::fns::operators::Operator::inverse(self) -> core::option::Option<Self>
 
-impl core::fmt::Display for vortex_array::extension::datetime::TimestampValue<'_>
+pub fn vortex_array::scalar_fn::fns::operators::Operator::is_arithmetic(&self) -> bool
 
-pub fn vortex_array::extension::datetime::TimestampValue<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::operators::Operator::is_comparison(&self) -> bool
 
-pub struct vortex_array::extension::datetime::AnyTemporal
+pub fn vortex_array::scalar_fn::fns::operators::Operator::logical_inverse(self) -> core::option::Option<Self>
 
-impl vortex_array::dtype::extension::Matcher for vortex_array::extension::datetime::AnyTemporal
+pub fn vortex_array::scalar_fn::fns::operators::Operator::swap(self) -> core::option::Option<Self>
 
-pub type vortex_array::extension::datetime::AnyTemporal::Match<'a> = vortex_array::extension::datetime::TemporalMetadata<'a>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::AnyTemporal::try_match<'a>(item: &'a vortex_array::dtype::extension::ExtDTypeRef) -> core::option::Option<Self::Match>
+pub fn vortex_array::scalar_fn::fns::operators::Operator::clone(&self) -> vortex_array::scalar_fn::fns::operators::Operator
 
-pub struct vortex_array::extension::datetime::Date
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::operators::Operator
 
-impl vortex_array::extension::datetime::Date
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Date::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+pub fn vortex_array::scalar_fn::fns::operators::Operator::eq(&self, other: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
 
-pub fn vortex_array::extension::datetime::Date::try_new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDType<Self>>
+impl core::cmp::PartialOrd for vortex_array::scalar_fn::fns::operators::Operator
 
-impl core::clone::Clone for vortex_array::extension::datetime::Date
+pub fn vortex_array::scalar_fn::fns::operators::Operator::partial_cmp(&self, other: &vortex_array::scalar_fn::fns::operators::Operator) -> core::option::Option<core::cmp::Ordering>
 
-pub fn vortex_array::extension::datetime::Date::clone(&self) -> vortex_array::extension::datetime::Date
+impl core::convert::From<vortex_array::scalar::NumericOperator> for vortex_array::scalar_fn::fns::operators::Operator
 
-impl core::cmp::Eq for vortex_array::extension::datetime::Date
+pub fn vortex_array::scalar_fn::fns::operators::Operator::from(op: vortex_array::scalar::NumericOperator) -> Self
 
-impl core::cmp::PartialEq for vortex_array::extension::datetime::Date
+impl core::convert::From<vortex_array::scalar_fn::fns::operators::CompareOperator> for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Date::eq(&self, other: &vortex_array::extension::datetime::Date) -> bool
+pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_array::scalar_fn::fns::operators::CompareOperator) -> Self
 
-impl core::default::Default for vortex_array::extension::datetime::Date
+impl core::convert::From<vortex_array::scalar_fn::fns::operators::Operator> for i32
 
-pub fn vortex_array::extension::datetime::Date::default() -> vortex_array::extension::datetime::Date
+pub fn i32::from(value: vortex_array::scalar_fn::fns::operators::Operator) -> Self
 
-impl core::fmt::Debug for vortex_array::extension::datetime::Date
+impl core::convert::From<vortex_array::scalar_fn::fns::operators::Operator> for vortex_proto::expr::binary_opts::BinaryOp
 
-pub fn vortex_array::extension::datetime::Date::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_proto::expr::binary_opts::BinaryOp::from(value: vortex_array::scalar_fn::fns::operators::Operator) -> Self
 
-impl core::hash::Hash for vortex_array::extension::datetime::Date
+impl core::convert::From<vortex_proto::expr::binary_opts::BinaryOp> for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Date::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_proto::expr::binary_opts::BinaryOp) -> Self
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Date
+impl core::convert::TryFrom<i32> for vortex_array::scalar_fn::fns::operators::Operator
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Date
+pub type vortex_array::scalar_fn::fns::operators::Operator::Error = vortex_error::VortexError
 
-pub type vortex_array::extension::datetime::Date::Metadata = vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::operators::Operator::try_from(value: i32) -> core::result::Result<Self, Self::Error>
 
-pub type vortex_array::extension::datetime::Date::NativeValue<'a> = vortex_array::extension::datetime::DateValue
+impl core::convert::TryFrom<vortex_array::scalar_fn::fns::operators::Operator> for vortex_array::scalar_fn::fns::operators::CompareOperator
 
-pub fn vortex_array::extension::datetime::Date::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::scalar_fn::fns::operators::CompareOperator::Error = vortex_error::VortexError
 
-pub fn vortex_array::extension::datetime::Date::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::try_from(value: vortex_array::scalar_fn::fns::operators::Operator) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::extension::datetime::Date::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Date::unpack_native(&self, metadata: &Self::Metadata, _storage_dtype: &vortex_array::dtype::DType, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::scalar_fn::fns::operators::Operator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::extension::datetime::Date::validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+impl core::fmt::Display for vortex_array::scalar_fn::fns::operators::Operator
 
-pub struct vortex_array::extension::datetime::Time
+pub fn vortex_array::scalar_fn::fns::operators::Operator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::extension::datetime::Time
+impl core::hash::Hash for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Time::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+pub fn vortex_array::scalar_fn::fns::operators::Operator::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub fn vortex_array::extension::datetime::Time::try_new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_error::VortexResult<vortex_array::dtype::extension::ExtDType<Self>>
+impl core::marker::Copy for vortex_array::scalar_fn::fns::operators::Operator
 
-impl core::clone::Clone for vortex_array::extension::datetime::Time
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::extension::datetime::Time::clone(&self) -> vortex_array::extension::datetime::Time
+pub mod vortex_array::scalar_fn::fns::pack
 
-impl core::cmp::Eq for vortex_array::extension::datetime::Time
+pub struct vortex_array::scalar_fn::fns::pack::Pack
 
-impl core::cmp::PartialEq for vortex_array::extension::datetime::Time
+impl core::clone::Clone for vortex_array::scalar_fn::fns::pack::Pack
 
-pub fn vortex_array::extension::datetime::Time::eq(&self, other: &vortex_array::extension::datetime::Time) -> bool
+pub fn vortex_array::scalar_fn::fns::pack::Pack::clone(&self) -> vortex_array::scalar_fn::fns::pack::Pack
 
-impl core::default::Default for vortex_array::extension::datetime::Time
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::pack::Pack
 
-pub fn vortex_array::extension::datetime::Time::default() -> vortex_array::extension::datetime::Time
+pub type vortex_array::scalar_fn::fns::pack::Pack::Options = vortex_array::scalar_fn::fns::pack::PackOptions
 
-impl core::fmt::Debug for vortex_array::extension::datetime::Time
+pub fn vortex_array::scalar_fn::fns::pack::Pack::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::extension::datetime::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::pack::Pack::child_name(&self, instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::hash::Hash for vortex_array::extension::datetime::Time
+pub fn vortex_array::scalar_fn::fns::pack::Pack::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::extension::datetime::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::pack::Pack::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Time
+pub fn vortex_array::scalar_fn::fns::pack::Pack::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Time
+pub fn vortex_array::scalar_fn::fns::pack::Pack::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::extension::datetime::Time::Metadata = vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::pack::Pack::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub type vortex_array::extension::datetime::Time::NativeValue<'a> = vortex_array::extension::datetime::TimeValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::is_fallible(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::extension::datetime::Time::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::extension::datetime::Time::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::scalar_fn::fns::pack::Pack::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::extension::datetime::Time::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::extension::datetime::Time::unpack_native(&self, metadata: &Self::Metadata, _storage_dtype: &vortex_array::dtype::DType, storage_value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::extension::datetime::Time::validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub struct vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::scalar_fn::fns::pack::Pack::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::scalar_fn::fns::pack::Pack::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::extension::datetime::Timestamp::new(time_unit: vortex_array::extension::datetime::TimeUnit, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::extension::datetime::Timestamp::new_with_options(options: vortex_array::extension::datetime::TimestampOptions, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::extension::datetime::Timestamp::new_with_tz(time_unit: vortex_array::extension::datetime::TimeUnit, timezone: core::option::Option<alloc::sync::Arc<str>>, nullability: vortex_array::dtype::Nullability) -> vortex_array::dtype::extension::ExtDType<Self>
+pub struct vortex_array::scalar_fn::fns::pack::PackOptions
 
-impl core::clone::Clone for vortex_array::extension::datetime::Timestamp
+pub vortex_array::scalar_fn::fns::pack::PackOptions::names: vortex_array::dtype::FieldNames
 
-pub fn vortex_array::extension::datetime::Timestamp::clone(&self) -> vortex_array::extension::datetime::Timestamp
+pub vortex_array::scalar_fn::fns::pack::PackOptions::nullability: vortex_array::dtype::Nullability
 
-impl core::cmp::Eq for vortex_array::extension::datetime::Timestamp
+impl core::clone::Clone for vortex_array::scalar_fn::fns::pack::PackOptions
 
-impl core::cmp::PartialEq for vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::scalar_fn::fns::pack::PackOptions::clone(&self) -> vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub fn vortex_array::extension::datetime::Timestamp::eq(&self, other: &vortex_array::extension::datetime::Timestamp) -> bool
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::pack::PackOptions
 
-impl core::default::Default for vortex_array::extension::datetime::Timestamp
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub fn vortex_array::extension::datetime::Timestamp::default() -> vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::scalar_fn::fns::pack::PackOptions::eq(&self, other: &vortex_array::scalar_fn::fns::pack::PackOptions) -> bool
 
-impl core::fmt::Debug for vortex_array::extension::datetime::Timestamp
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub fn vortex_array::extension::datetime::Timestamp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::pack::PackOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::hash::Hash for vortex_array::extension::datetime::Timestamp
+impl core::fmt::Display for vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub fn vortex_array::extension::datetime::Timestamp::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::pack::PackOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::Timestamp
+impl core::hash::Hash for vortex_array::scalar_fn::fns::pack::PackOptions
 
-impl vortex_array::dtype::extension::ExtVTable for vortex_array::extension::datetime::Timestamp
+pub fn vortex_array::scalar_fn::fns::pack::PackOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub type vortex_array::extension::datetime::Timestamp::Metadata = vortex_array::extension::datetime::TimestampOptions
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub type vortex_array::extension::datetime::Timestamp::NativeValue<'a> = vortex_array::extension::datetime::TimestampValue<'a>
+pub mod vortex_array::scalar_fn::fns::root
 
-pub fn vortex_array::extension::datetime::Timestamp::deserialize_metadata(&self, data: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+pub struct vortex_array::scalar_fn::fns::root::Root
 
-pub fn vortex_array::extension::datetime::Timestamp::id(&self) -> vortex_array::dtype::extension::ExtId
+impl core::clone::Clone for vortex_array::scalar_fn::fns::root::Root
 
-pub fn vortex_array::extension::datetime::Timestamp::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+pub fn vortex_array::scalar_fn::fns::root::Root::clone(&self) -> vortex_array::scalar_fn::fns::root::Root
 
-pub fn vortex_array::extension::datetime::Timestamp::unpack_native<'a>(&self, metadata: &'a Self::Metadata, _storage_dtype: &'a vortex_array::dtype::DType, storage_value: &'a vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::root::Root
 
-pub fn vortex_array::extension::datetime::Timestamp::validate_dtype(&self, _metadata: &Self::Metadata, storage_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+pub type vortex_array::scalar_fn::fns::root::Root::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub struct vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub vortex_array::extension::datetime::TimestampOptions::tz: core::option::Option<alloc::sync::Arc<str>>
+pub fn vortex_array::scalar_fn::fns::root::Root::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub vortex_array::extension::datetime::TimestampOptions::unit: vortex_array::extension::datetime::TimeUnit
+pub fn vortex_array::scalar_fn::fns::root::Root::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::clone::Clone for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::extension::datetime::TimestampOptions::clone(&self) -> vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::execute(&self, _data: &Self::Options, _args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::cmp::Eq for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::fmt_sql(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialEq for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::extension::datetime::TimestampOptions::eq(&self, other: &vortex_array::extension::datetime::TimestampOptions) -> bool
+pub fn vortex_array::scalar_fn::fns::root::Root::is_fallible(&self, _options: &Self::Options) -> bool
 
-impl core::fmt::Debug for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::extension::datetime::TimestampOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::root::Root::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl core::fmt::Display for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::extension::datetime::TimestampOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::root::Root::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::hash::Hash for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::extension::datetime::TimestampOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::root::Root::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::datetime::TimestampOptions
+pub fn vortex_array::scalar_fn::fns::root::Root::stat_expression(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub struct vortex_array::extension::EmptyMetadata
+pub fn vortex_array::scalar_fn::fns::root::Root::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::clone::Clone for vortex_array::extension::EmptyMetadata
+pub fn vortex_array::scalar_fn::fns::root::Root::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::extension::EmptyMetadata::clone(&self) -> vortex_array::extension::EmptyMetadata
+pub mod vortex_array::scalar_fn::fns::select
 
-impl core::cmp::Eq for vortex_array::extension::EmptyMetadata
+pub enum vortex_array::scalar_fn::fns::select::FieldSelection
 
-impl core::cmp::PartialEq for vortex_array::extension::EmptyMetadata
+pub vortex_array::scalar_fn::fns::select::FieldSelection::Exclude(vortex_array::dtype::FieldNames)
 
-pub fn vortex_array::extension::EmptyMetadata::eq(&self, other: &vortex_array::extension::EmptyMetadata) -> bool
+pub vortex_array::scalar_fn::fns::select::FieldSelection::Include(vortex_array::dtype::FieldNames)
 
-impl core::fmt::Debug for vortex_array::extension::EmptyMetadata
+impl vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub fn vortex_array::extension::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::exclude(columns: vortex_array::dtype::FieldNames) -> Self
 
-impl core::fmt::Display for vortex_array::extension::EmptyMetadata
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::field_names(&self) -> &vortex_array::dtype::FieldNames
 
-pub fn vortex_array::extension::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::include(columns: vortex_array::dtype::FieldNames) -> Self
 
-impl core::hash::Hash for vortex_array::extension::EmptyMetadata
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::is_exclude(&self) -> bool
 
-pub fn vortex_array::extension::EmptyMetadata::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::is_include(&self) -> bool
 
-impl core::marker::StructuralPartialEq for vortex_array::extension::EmptyMetadata
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::normalize_to_included_fields(&self, available_fields: &vortex_array::dtype::FieldNames) -> vortex_error::VortexResult<vortex_array::dtype::FieldNames>
 
-pub mod vortex_array::flatbuffers
+impl core::clone::Clone for vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub use vortex_array::flatbuffers::<<vortex_flatbuffers::array::*>>
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::clone(&self) -> vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub mod vortex_array::iter
+impl core::cmp::Eq for vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub struct vortex_array::iter::ArrayIteratorAdapter<I>
+impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::select::FieldSelection
 
-impl<I> vortex_array::iter::ArrayIteratorAdapter<I>
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::eq(&self, other: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
 
-pub fn vortex_array::iter::ArrayIteratorAdapter<I>::new(dtype: vortex_array::dtype::DType, inner: I) -> Self
+impl core::fmt::Debug for vortex_array::scalar_fn::fns::select::FieldSelection
 
-impl<I> core::iter::traits::iterator::Iterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::iter::ArrayIteratorAdapter<I>::Item = core::result::Result<alloc::sync::Arc<dyn vortex_array::Array>, vortex_error::VortexError>
+impl core::fmt::Display for vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub fn vortex_array::iter::ArrayIteratorAdapter<I>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<I> vortex_array::iter::ArrayIterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+impl core::hash::Hash for vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub fn vortex_array::iter::ArrayIteratorAdapter<I>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::scalar_fn::fns::select::FieldSelection::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub trait vortex_array::iter::ArrayIterator: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub fn vortex_array::iter::ArrayIterator::dtype(&self) -> &vortex_array::dtype::DType
+pub struct vortex_array::scalar_fn::fns::select::Select
 
-impl vortex_array::iter::ArrayIterator for alloc::boxed::Box<(dyn vortex_array::iter::ArrayIterator + core::marker::Send)>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::select::Select
 
-pub fn alloc::boxed::Box<(dyn vortex_array::iter::ArrayIterator + core::marker::Send)>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::scalar_fn::fns::select::Select::clone(&self) -> vortex_array::scalar_fn::fns::select::Select
 
-impl vortex_array::iter::ArrayIterator for vortex_array::arrow::ArrowArrayStreamAdapter
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::select::Select
 
-pub fn vortex_array::arrow::ArrowArrayStreamAdapter::dtype(&self) -> &vortex_array::dtype::DType
+pub type vortex_array::scalar_fn::fns::select::Select::Options = vortex_array::scalar_fn::fns::select::FieldSelection
 
-impl<I> vortex_array::iter::ArrayIterator for vortex_array::iter::ArrayIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::select::Select::arity(&self, _options: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::iter::ArrayIteratorAdapter<I>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::scalar_fn::fns::select::Select::child_name(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub trait vortex_array::iter::ArrayIteratorExt: vortex_array::iter::ArrayIterator
+pub fn vortex_array::scalar_fn::fns::select::Select::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::iter::ArrayIteratorExt::into_array_stream(self) -> impl vortex_array::stream::ArrayStream where Self: core::marker::Sized
+pub fn vortex_array::scalar_fn::fns::select::Select::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::fns::select::FieldSelection>
 
-pub fn vortex_array::iter::ArrayIteratorExt::read_all(self) -> vortex_error::VortexResult<vortex_array::ArrayRef> where Self: core::marker::Sized
+pub fn vortex_array::scalar_fn::fns::select::Select::execute(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl<I: vortex_array::iter::ArrayIterator> vortex_array::iter::ArrayIteratorExt for I
+pub fn vortex_array::scalar_fn::fns::select::Select::fmt_sql(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::kernel
+pub fn vortex_array::scalar_fn::fns::select::Select::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub struct vortex_array::kernel::ParentKernelAdapter<V, K>
+pub fn vortex_array::scalar_fn::fns::select::Select::is_fallible(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
 
-impl<V: vortex_array::vtable::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> core::fmt::Debug for vortex_array::kernel::ParentKernelAdapter<V, K>
+pub fn vortex_array::scalar_fn::fns::select::Select::is_null_sensitive(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
 
-pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::select::Select::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl<V: vortex_array::vtable::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> vortex_array::kernel::DynParentKernel<V> for vortex_array::kernel::ParentKernelAdapter<V, K>
+pub fn vortex_array::scalar_fn::fns::select::Select::return_dtype(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::execute_parent(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::select::Select::serialize(&self, instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+pub fn vortex_array::scalar_fn::fns::select::Select::simplify(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub struct vortex_array::kernel::ParentKernelSet<V: vortex_array::vtable::VTable>
+pub fn vortex_array::scalar_fn::fns::select::Select::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::kernel::ParentKernelSet<V>
+pub fn vortex_array::scalar_fn::fns::select::Select::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::kernel::ParentKernelSet<V>::execute(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::select::Select::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub const fn vortex_array::kernel::ParentKernelSet<V>::lift<K: vortex_array::kernel::ExecuteParentKernel<V>>(kernel: &'static K) -> &'static dyn vortex_array::kernel::DynParentKernel<V>
+pub fn vortex_array::scalar_fn::fns::select::Select::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub const fn vortex_array::kernel::ParentKernelSet<V>::new(kernels: &'static [&'static dyn vortex_array::kernel::DynParentKernel<V>]) -> Self
+pub mod vortex_array::scalar_fn::fns::zip
 
-pub trait vortex_array::kernel::DynParentKernel<V: vortex_array::vtable::VTable>: core::marker::Send + core::marker::Sync
+pub struct vortex_array::scalar_fn::fns::zip::Zip
 
-pub fn vortex_array::kernel::DynParentKernel::execute_parent(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::scalar_fn::fns::zip::Zip
 
-pub fn vortex_array::kernel::DynParentKernel::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+pub fn vortex_array::scalar_fn::fns::zip::Zip::clone(&self) -> vortex_array::scalar_fn::fns::zip::Zip
 
-impl<V: vortex_array::vtable::VTable, K: vortex_array::kernel::ExecuteParentKernel<V>> vortex_array::kernel::DynParentKernel<V> for vortex_array::kernel::ParentKernelAdapter<V, K>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::zip::Zip
 
-pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::execute_parent(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::scalar_fn::fns::zip::Zip::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::kernel::ParentKernelAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+pub fn vortex_array::scalar_fn::fns::zip::Zip::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub trait vortex_array::kernel::ExecuteParentKernel<V: vortex_array::vtable::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+pub fn vortex_array::scalar_fn::fns::zip::Zip::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub type vortex_array::kernel::ExecuteParentKernel::Parent: vortex_array::matcher::Matcher
+pub fn vortex_array::scalar_fn::fns::zip::Zip::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::kernel::ExecuteParentKernel::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::FilterExecuteAdaptor<V> where V: vortex_array::arrays::FilterKernel
+pub fn vortex_array::scalar_fn::fns::zip::Zip::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::arrays::FilterExecuteAdaptor<V>::Parent = vortex_array::arrays::FilterVTable
+pub fn vortex_array::scalar_fn::fns::zip::Zip::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::FilterExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::SliceExecuteAdaptor<V> where V: vortex_array::arrays::SliceKernel
+pub fn vortex_array::scalar_fn::fns::zip::Zip::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub type vortex_array::arrays::SliceExecuteAdaptor<V>::Parent = vortex_array::arrays::SliceVTable
+pub fn vortex_array::scalar_fn::fns::zip::Zip::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::arrays::SliceExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::arrays::TakeExecuteAdaptor<V> where V: vortex_array::arrays::TakeExecute
+pub fn vortex_array::scalar_fn::fns::zip::Zip::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub type vortex_array::arrays::TakeExecuteAdaptor<V>::Parent = vortex_array::arrays::DictVTable
+pub fn vortex_array::scalar_fn::fns::zip::Zip::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::TakeExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, _ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenKernel
+pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::binary::CompareKernel
+pub fn vortex_array::scalar_fn::fns::zip::Zip::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::binary::Binary>
+pub struct vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>(pub V)
 
-pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::binary::Binary>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastKernel
+pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
 
-pub type vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullKernel
+impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipKernel
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+pub type vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::execute_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeKernel
+pub struct vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>(pub V)
 
-pub type vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel
+impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipReduce
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskKernel
+pub type vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::Parent = vortex_array::arrays::scalar_fn::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
 
-pub type vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::reduce_parent(&self, array: vortex_array::ArrayView<'_, V>, parent: vortex_array::arrays::scalar_fn::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::scalar_fn::fns::zip::ZipKernel: vortex_array::VTable
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotKernel
+pub fn vortex_array::scalar_fn::fns::zip::ZipKernel::zip(array: vortex_array::ArrayView<'_, Self>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Chunked
 
-pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, _parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipKernel
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::Struct
 
-pub type vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+pub fn vortex_array::arrays::Struct::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::VarBinView
 
-pub mod vortex_array::mask
+pub fn vortex_array::arrays::VarBinView::zip(if_true: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::matcher
+pub trait vortex_array::scalar_fn::fns::zip::ZipReduce: vortex_array::VTable
 
-pub struct vortex_array::matcher::AnyArray
+pub fn vortex_array::scalar_fn::fns::zip::ZipReduce::zip(array: vortex_array::ArrayView<'_, Self>, if_false: &vortex_array::ArrayRef, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::matcher::AnyArray
+pub mod vortex_array::scalar_fn::session
 
-pub fn vortex_array::matcher::AnyArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::scalar_fn::session::ScalarFnSession
 
-impl vortex_array::matcher::Matcher for vortex_array::matcher::AnyArray
+impl vortex_array::scalar_fn::session::ScalarFnSession
 
-pub type vortex_array::matcher::AnyArray::Match<'a> = &'a (dyn vortex_array::Array + 'static)
+pub fn vortex_array::scalar_fn::session::ScalarFnSession::register<V: vortex_array::scalar_fn::ScalarFnVTable>(&self, vtable: V)
 
-pub fn vortex_array::matcher::AnyArray::matches(_array: &dyn vortex_array::Array) -> bool
+pub fn vortex_array::scalar_fn::session::ScalarFnSession::registry(&self) -> &vortex_array::scalar_fn::session::ScalarFnRegistry
 
-pub fn vortex_array::matcher::AnyArray::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+impl core::default::Default for vortex_array::scalar_fn::session::ScalarFnSession
 
-pub trait vortex_array::matcher::Matcher
+pub fn vortex_array::scalar_fn::session::ScalarFnSession::default() -> Self
 
-pub type vortex_array::matcher::Matcher::Match<'a>
+impl core::fmt::Debug for vortex_array::scalar_fn::session::ScalarFnSession
 
-pub fn vortex_array::matcher::Matcher::matches(array: &dyn vortex_array::Array) -> bool
+pub fn vortex_array::scalar_fn::session::ScalarFnSession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::matcher::Matcher::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub trait vortex_array::scalar_fn::session::ScalarFnSessionExt: vortex_session::SessionExt
 
-impl vortex_array::matcher::Matcher for vortex_array::AnyCanonical
+pub fn vortex_array::scalar_fn::session::ScalarFnSessionExt::scalar_fns(&self) -> vortex_session::Ref<'_, vortex_array::scalar_fn::session::ScalarFnSession>
 
-pub type vortex_array::AnyCanonical::Match<'a> = vortex_array::CanonicalView<'a>
+impl<S: vortex_session::SessionExt> vortex_array::scalar_fn::session::ScalarFnSessionExt for S
 
-pub fn vortex_array::AnyCanonical::matches(array: &dyn vortex_array::Array) -> bool
+pub fn S::scalar_fns(&self) -> vortex_session::Ref<'_, vortex_array::scalar_fn::session::ScalarFnSession>
 
-pub fn vortex_array::AnyCanonical::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub type vortex_array::scalar_fn::session::ScalarFnRegistry = vortex_session::registry::Registry<vortex_array::scalar_fn::ScalarFnPluginRef>
 
-impl vortex_array::matcher::Matcher for vortex_array::AnyColumnar
+pub enum vortex_array::scalar_fn::Arity
 
-pub type vortex_array::AnyColumnar::Match<'a> = vortex_array::ColumnarView<'a>
+pub vortex_array::scalar_fn::Arity::Exact(usize)
 
-pub fn vortex_array::AnyColumnar::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub vortex_array::scalar_fn::Arity::Variadic
 
-impl vortex_array::matcher::Matcher for vortex_array::arrays::AnyScalarFn
+pub vortex_array::scalar_fn::Arity::Variadic::max: core::option::Option<usize>
 
-pub type vortex_array::arrays::AnyScalarFn::Match<'a> = &'a vortex_array::arrays::ScalarFnArray
+pub vortex_array::scalar_fn::Arity::Variadic::min: usize
 
-pub fn vortex_array::arrays::AnyScalarFn::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+impl vortex_array::scalar_fn::Arity
 
-impl vortex_array::matcher::Matcher for vortex_array::matcher::AnyArray
+pub fn vortex_array::scalar_fn::Arity::matches(&self, arg_count: usize) -> bool
 
-pub type vortex_array::matcher::AnyArray::Match<'a> = &'a (dyn vortex_array::Array + 'static)
+impl core::clone::Clone for vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::matcher::AnyArray::matches(_array: &dyn vortex_array::Array) -> bool
+pub fn vortex_array::scalar_fn::Arity::clone(&self) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::matcher::AnyArray::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+impl core::cmp::Eq for vortex_array::scalar_fn::Arity
 
-impl<F: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::matcher::Matcher for vortex_array::arrays::ExactScalarFn<F>
+impl core::cmp::PartialEq for vortex_array::scalar_fn::Arity
 
-pub type vortex_array::arrays::ExactScalarFn<F>::Match<'a> = vortex_array::arrays::ScalarFnArrayView<'a, F>
+pub fn vortex_array::scalar_fn::Arity::eq(&self, other: &vortex_array::scalar_fn::Arity) -> bool
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::matches(array: &dyn vortex_array::Array) -> bool
+impl core::fmt::Debug for vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::arrays::ExactScalarFn<F>::try_match(array: &dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub fn vortex_array::scalar_fn::Arity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V: vortex_array::vtable::VTable> vortex_array::matcher::Matcher for V
+impl core::fmt::Display for vortex_array::scalar_fn::Arity
 
-pub type V::Match<'a> = &'a <V as vortex_array::vtable::VTable>::Array
+pub fn vortex_array::scalar_fn::Arity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn V::matches(array: &dyn vortex_array::Array) -> bool
+impl core::marker::Copy for vortex_array::scalar_fn::Arity
 
-pub fn V::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::Arity
 
-pub mod vortex_array::normalize
+pub struct vortex_array::scalar_fn::EmptyOptions
 
-pub enum vortex_array::normalize::Operation
+impl core::clone::Clone for vortex_array::scalar_fn::EmptyOptions
 
-pub vortex_array::normalize::Operation::Error
+pub fn vortex_array::scalar_fn::EmptyOptions::clone(&self) -> vortex_array::scalar_fn::EmptyOptions
 
-pub struct vortex_array::normalize::NormalizeOptions<'a>
+impl core::cmp::Eq for vortex_array::scalar_fn::EmptyOptions
 
-pub vortex_array::normalize::NormalizeOptions::allowed: &'a vortex_array::session::ArrayRegistry
+impl core::cmp::PartialEq for vortex_array::scalar_fn::EmptyOptions
 
-pub vortex_array::normalize::NormalizeOptions::operation: vortex_array::normalize::Operation
+pub fn vortex_array::scalar_fn::EmptyOptions::eq(&self, other: &vortex_array::scalar_fn::EmptyOptions) -> bool
 
-pub mod vortex_array::optimizer
+impl core::fmt::Debug for vortex_array::scalar_fn::EmptyOptions
 
-pub mod vortex_array::optimizer::rules
+pub fn vortex_array::scalar_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>
+impl core::fmt::Display for vortex_array::scalar_fn::EmptyOptions
 
-impl<V: vortex_array::vtable::VTable, K: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> vortex_array::optimizer::rules::DynArrayParentReduceRule<V> for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>
+pub fn vortex_array::scalar_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+impl core::hash::Hash for vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::reduce_parent(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::EmptyOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-impl<V: vortex_array::vtable::VTable, R: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> core::fmt::Debug for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub struct vortex_array::optimizer::rules::ParentRuleSet<V: vortex_array::vtable::VTable>
+impl vortex_array::scalar_fn::ForeignScalarFnOptions
 
-impl<V: vortex_array::vtable::VTable> vortex_array::optimizer::rules::ParentRuleSet<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::new(metadata: alloc::vec::Vec<u8>, arity: usize) -> Self
 
-pub fn vortex_array::optimizer::rules::ParentRuleSet<V>::evaluate(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::clone::Clone for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub const fn vortex_array::optimizer::rules::ParentRuleSet<V>::lift<R: vortex_array::optimizer::rules::ArrayParentReduceRule<V>>(rule: &'static R) -> &'static dyn vortex_array::optimizer::rules::DynArrayParentReduceRule<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::clone(&self) -> vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub const fn vortex_array::optimizer::rules::ParentRuleSet<V>::new(rules: &'static [&'static dyn vortex_array::optimizer::rules::DynArrayParentReduceRule<V>]) -> Self
+impl core::cmp::Eq for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub struct vortex_array::optimizer::rules::ReduceRuleSet<V: vortex_array::vtable::VTable>
+impl core::cmp::PartialEq for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-impl<V: vortex_array::vtable::VTable> vortex_array::optimizer::rules::ReduceRuleSet<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::eq(&self, other: &vortex_array::scalar_fn::ForeignScalarFnOptions) -> bool
 
-pub fn vortex_array::optimizer::rules::ReduceRuleSet<V>::evaluate(&self, array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub const fn vortex_array::optimizer::rules::ReduceRuleSet<V>::new(rules: &'static [&'static dyn vortex_array::optimizer::rules::ArrayReduceRule<V>]) -> Self
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub trait vortex_array::optimizer::rules::ArrayParentReduceRule<V: vortex_array::vtable::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+impl core::fmt::Display for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub type vortex_array::optimizer::rules::ArrayParentReduceRule::Parent: vortex_array::matcher::Matcher
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::optimizer::rules::ArrayParentReduceRule::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::hash::Hash for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolMaskedValidityRule
+pub fn vortex_array::scalar_fn::ForeignScalarFnOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 
-pub type vortex_array::arrays::BoolMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::ForeignScalarFnOptions
 
-pub fn vortex_array::arrays::BoolMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::BoolArray, parent: &vortex_array::arrays::MaskedArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::scalar_fn::ForeignScalarFnVTable
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalMaskedValidityRule
+impl vortex_array::scalar_fn::ForeignScalarFnVTable
 
-pub type vortex_array::arrays::DecimalMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::make_scalar_fn(id: vortex_array::scalar_fn::ScalarFnId, metadata: alloc::vec::Vec<u8>, arity: usize) -> vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::arrays::DecimalMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::DecimalArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::new(id: vortex_array::scalar_fn::ScalarFnId) -> Self
 
-impl vortex_array::optimizer::rules::ArrayParentReduceRule<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveMaskedValidityRule
+impl core::clone::Clone for vortex_array::scalar_fn::ForeignScalarFnVTable
 
-pub type vortex_array::arrays::PrimitiveMaskedValidityRule::Parent = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::clone(&self) -> vortex_array::scalar_fn::ForeignScalarFnVTable
 
-pub fn vortex_array::arrays::PrimitiveMaskedValidityRule::reduce_parent(&self, array: &vortex_array::arrays::PrimitiveArray, parent: &vortex_array::arrays::MaskedArray, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::scalar_fn::ForeignScalarFnVTable
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::FilterReduceAdaptor<V> where V: vortex_array::arrays::FilterReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::arrays::FilterReduceAdaptor<V>::Parent = vortex_array::arrays::FilterVTable
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::ForeignScalarFnVTable
 
-pub fn vortex_array::arrays::FilterReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::arrays::FilterArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::scalar_fn::ForeignScalarFnVTable::Options = vortex_array::scalar_fn::ForeignScalarFnOptions
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::SliceReduceAdaptor<V> where V: vortex_array::arrays::SliceReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub type vortex_array::arrays::SliceReduceAdaptor<V>::Parent = vortex_array::arrays::SliceVTable
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::arrays::SliceReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::arrays::TakeReduceAdaptor<V> where V: vortex_array::arrays::TakeReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::deserialize(&self, metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type vortex_array::arrays::TakeReduceAdaptor<V>::Parent = vortex_array::arrays::DictVTable
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::execute(&self, _options: &Self::Options, _args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::TakeReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::arrays::DictArray, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub type vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::is_null_sensitive(&self, options: &Self::Options) -> bool
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub type vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::return_dtype(&self, _options: &Self::Options, _args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::cast::Cast>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeReduce
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::scalar_fn::ScalarFn<V: vortex_array::scalar_fn::ScalarFnVTable>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce
+impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::scalar_fn::ScalarFn<V>
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+pub fn vortex_array::scalar_fn::ScalarFn<V>::erased(self) -> vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ScalarFn<V>::new(vtable: V, options: <V as vortex_array::scalar_fn::ScalarFnVTable>::Options) -> Self
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskReduce
+pub fn vortex_array::scalar_fn::ScalarFn<V>::options(&self) -> &<V as vortex_array::scalar_fn::ScalarFnVTable>::Options
 
-pub type vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+pub fn vortex_array::scalar_fn::ScalarFn<V>::vtable(&self) -> &V
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::scalar_fn::ScalarFnOptions<'a>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotReduce
+impl vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub type vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, _parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl<'a> vortex_array::scalar_fn::ScalarFnOptions<'a>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipReduce
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'a>::as_any(&self) -> &'a dyn core::any::Any
 
-pub type vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+impl core::cmp::Eq for vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::cmp::PartialEq for vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub trait vortex_array::optimizer::rules::ArrayReduceRule<V: vortex_array::vtable::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::eq(&self, other: &Self) -> bool
 
-pub fn vortex_array::optimizer::rules::ArrayReduceRule::reduce(&self, array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl core::fmt::Debug for vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub trait vortex_array::optimizer::rules::DynArrayParentReduceRule<V: vortex_array::vtable::VTable>: core::fmt::Debug + core::marker::Send + core::marker::Sync
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::optimizer::rules::DynArrayParentReduceRule::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+impl core::fmt::Display for vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub fn vortex_array::optimizer::rules::DynArrayParentReduceRule::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V: vortex_array::vtable::VTable, K: vortex_array::optimizer::rules::ArrayParentReduceRule<V>> vortex_array::optimizer::rules::DynArrayParentReduceRule<V> for vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>
+impl core::hash::Hash for vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::matches(&self, parent: &vortex_array::ArrayRef) -> bool
+pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::optimizer::rules::ParentReduceRuleAdapter<V, K>::reduce_parent(&self, child: &<V as vortex_array::vtable::VTable>::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub struct vortex_array::scalar_fn::ScalarFnRef(_)
 
-pub trait vortex_array::optimizer::ArrayOptimizer
+impl vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::optimizer::ArrayOptimizer::optimize(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::scalar_fn::ScalarFnRef::as_<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> &<V as vortex_array::scalar_fn::ScalarFnVTable>::Options
 
-pub fn vortex_array::optimizer::ArrayOptimizer::optimize_recursive(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::scalar_fn::ScalarFnRef::as_opt<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> core::option::Option<&<V as vortex_array::scalar_fn::ScalarFnVTable>::Options>
 
-impl vortex_array::optimizer::ArrayOptimizer for vortex_array::ArrayRef
+pub fn vortex_array::scalar_fn::ScalarFnRef::coerce_args(&self, arg_types: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::ArrayRef::optimize(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::scalar_fn::ScalarFnRef::downcast<V: vortex_array::scalar_fn::ScalarFnVTable>(self) -> alloc::sync::Arc<vortex_array::scalar_fn::ScalarFn<V>>
 
-pub fn vortex_array::ArrayRef::optimize_recursive(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::scalar_fn::ScalarFnRef::downcast_ref<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFn<V>>
 
-pub mod vortex_array::patches
+pub fn vortex_array::scalar_fn::ScalarFnRef::execute(&self, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub struct vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::ScalarFnRef::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::ScalarFnRef::is<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> bool
 
-pub unsafe fn vortex_array::patches::Patches::apply_to_buffer<P: vortex_array::dtype::NativePType>(&self, buffer: &mut [P], validity: &mut vortex_mask::mask_mut::MaskMut)
+pub fn vortex_array::scalar_fn::ScalarFnRef::options(&self) -> vortex_array::scalar_fn::ScalarFnOptions<'_>
 
-pub fn vortex_array::patches::Patches::array_len(&self) -> usize
+pub fn vortex_array::scalar_fn::ScalarFnRef::reduce(&self, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::patches::Patches::cast_values(self, values_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::ScalarFnRef::return_dtype(&self, arg_types: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::patches::Patches::chunk_offset_at(&self, idx: usize) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::scalar_fn::ScalarFnRef::signature(&self) -> vortex_array::scalar_fn::ScalarFnSignature<'_>
 
-pub fn vortex_array::patches::Patches::chunk_offsets(&self) -> &core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::scalar_fn::ScalarFnRef::try_downcast<V: vortex_array::scalar_fn::ScalarFnVTable>(self) -> core::result::Result<alloc::sync::Arc<vortex_array::scalar_fn::ScalarFn<V>>, vortex_array::scalar_fn::ScalarFnRef>
 
-pub fn vortex_array::patches::Patches::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::scalar_fn::ScalarFnRef::validity(&self, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
 
-pub fn vortex_array::patches::Patches::filter(&self, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<Self>>
+impl core::clone::Clone for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::get_patched(&self, index: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::Scalar>>
+pub fn vortex_array::scalar_fn::ScalarFnRef::clone(&self) -> vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::indices(&self) -> &vortex_array::ArrayRef
+impl core::cmp::Eq for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::indices_mut(&mut self) -> &mut vortex_array::ArrayRef
+impl core::cmp::PartialEq for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::indices_ptype(&self) -> vortex_error::VortexResult<vortex_array::dtype::PType>
+pub fn vortex_array::scalar_fn::ScalarFnRef::eq(&self, other: &Self) -> bool
 
-pub fn vortex_array::patches::Patches::into_indices(self) -> vortex_array::ArrayRef
+impl core::fmt::Debug for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::into_values(self) -> vortex_array::ArrayRef
+pub fn vortex_array::scalar_fn::ScalarFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::patches::Patches::map_values<F>(self, f: F) -> vortex_error::VortexResult<Self> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::fmt::Display for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::mask(&self, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::scalar_fn::ScalarFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::patches::Patches::max_index(&self) -> vortex_error::VortexResult<usize>
+impl core::hash::Hash for vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::patches::Patches::min_index(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::scalar_fn::ScalarFnRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
 
-pub fn vortex_array::patches::Patches::new(array_len: usize, offset: usize, indices: vortex_array::ArrayRef, values: vortex_array::ArrayRef, chunk_offsets: core::option::Option<vortex_array::ArrayRef>) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::scalar_fn::ScalarFnSignature<'a>
 
-pub unsafe fn vortex_array::patches::Patches::new_unchecked(array_len: usize, offset: usize, indices: vortex_array::ArrayRef, values: vortex_array::ArrayRef, chunk_offsets: core::option::Option<vortex_array::ArrayRef>, offset_within_chunk: core::option::Option<usize>) -> Self
+impl vortex_array::scalar_fn::ScalarFnSignature<'_>
 
-pub fn vortex_array::patches::Patches::num_patches(&self) -> usize
+pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::arity(&self) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::patches::Patches::offset(&self) -> usize
+pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::child_name(&self, index: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::patches::Patches::offset_within_chunk(&self) -> core::option::Option<usize>
+pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::is_fallible(&self) -> bool
 
-pub fn vortex_array::patches::Patches::search_index(&self, index: usize) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult>
+pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::is_null_sensitive(&self) -> bool
 
-pub fn vortex_array::patches::Patches::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub struct vortex_array::scalar_fn::VecExecutionArgs
 
-pub fn vortex_array::patches::Patches::take(&self, take_indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<Self>>
+impl vortex_array::scalar_fn::VecExecutionArgs
 
-pub fn vortex_array::patches::Patches::take_map(&self, take_indices: vortex_array::arrays::PrimitiveArray, include_nulls: bool) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::scalar_fn::VecExecutionArgs::new(inputs: alloc::vec::Vec<vortex_array::ArrayRef>, row_count: usize) -> Self
 
-pub fn vortex_array::patches::Patches::take_search(&self, take_indices: vortex_array::arrays::PrimitiveArray, include_nulls: bool) -> vortex_error::VortexResult<core::option::Option<Self>>
+impl vortex_array::scalar_fn::ExecutionArgs for vortex_array::scalar_fn::VecExecutionArgs
 
-pub fn vortex_array::patches::Patches::take_with_nulls(&self, take_indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::scalar_fn::VecExecutionArgs::get(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::patches::Patches::to_metadata(&self, len: usize, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::patches::PatchesMetadata>
+pub fn vortex_array::scalar_fn::VecExecutionArgs::num_inputs(&self) -> usize
 
-pub fn vortex_array::patches::Patches::values(&self) -> &vortex_array::ArrayRef
+pub fn vortex_array::scalar_fn::VecExecutionArgs::row_count(&self) -> usize
 
-pub fn vortex_array::patches::Patches::values_mut(&mut self) -> &mut vortex_array::ArrayRef
+pub trait vortex_array::scalar_fn::ExecutionArgs
 
-impl core::clone::Clone for vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::ExecutionArgs::get(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::patches::Patches::clone(&self) -> vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::ExecutionArgs::num_inputs(&self) -> usize
 
-impl core::fmt::Debug for vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::ExecutionArgs::row_count(&self) -> usize
 
-pub fn vortex_array::patches::Patches::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::scalar_fn::ExecutionArgs for vortex_array::scalar_fn::VecExecutionArgs
 
-impl vortex_array::ArrayEq for vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::VecExecutionArgs::get(&self, index: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::patches::Patches::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::scalar_fn::VecExecutionArgs::num_inputs(&self) -> usize
 
-impl vortex_array::ArrayHash for vortex_array::patches::Patches
+pub fn vortex_array::scalar_fn::VecExecutionArgs::row_count(&self) -> usize
 
-pub fn vortex_array::patches::Patches::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub trait vortex_array::scalar_fn::ReduceCtx
 
-pub struct vortex_array::patches::PatchesMetadata
+pub fn vortex_array::scalar_fn::ReduceCtx::new_node(&self, scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: &[vortex_array::scalar_fn::ReduceNodeRef]) -> vortex_error::VortexResult<vortex_array::scalar_fn::ReduceNodeRef>
 
-impl vortex_array::patches::PatchesMetadata
+pub trait vortex_array::scalar_fn::ReduceNode
 
-pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_dtype(&self) -> vortex_error::VortexResult<core::option::Option<vortex_array::dtype::DType>>
+pub fn vortex_array::scalar_fn::ReduceNode::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::patches::PatchesMetadata::indices_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::scalar_fn::ReduceNode::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
 
-pub fn vortex_array::patches::PatchesMetadata::is_empty(&self) -> bool
+pub fn vortex_array::scalar_fn::ReduceNode::child_count(&self) -> usize
 
-pub fn vortex_array::patches::PatchesMetadata::len(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::scalar_fn::ReduceNode::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::patches::PatchesMetadata::new(len: usize, offset: usize, indices_ptype: vortex_array::dtype::PType, chunk_offsets_len: core::option::Option<usize>, chunk_offsets_ptype: core::option::Option<vortex_array::dtype::PType>, offset_within_chunk: core::option::Option<usize>) -> Self
+pub fn vortex_array::scalar_fn::ReduceNode::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
 
-pub fn vortex_array::patches::PatchesMetadata::offset(&self) -> vortex_error::VortexResult<usize>
+impl vortex_array::scalar_fn::ReduceNode for vortex_array::ArrayRef
 
-impl vortex_array::patches::PatchesMetadata
+pub fn vortex_array::ArrayRef::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_len(&self) -> u64
+pub fn vortex_array::ArrayRef::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
 
-pub fn vortex_array::patches::PatchesMetadata::chunk_offsets_ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::child_count(&self) -> usize
 
-pub fn vortex_array::patches::PatchesMetadata::indices_ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::ArrayRef::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::patches::PatchesMetadata::offset_within_chunk(&self) -> u64
+pub fn vortex_array::ArrayRef::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
 
-pub fn vortex_array::patches::PatchesMetadata::set_chunk_offsets_ptype(&mut self, value: vortex_array::dtype::PType)
+pub trait vortex_array::scalar_fn::ScalarFnPlugin: 'static + core::marker::Send + core::marker::Sync
 
-pub fn vortex_array::patches::PatchesMetadata::set_indices_ptype(&mut self, value: vortex_array::dtype::PType)
+pub fn vortex_array::scalar_fn::ScalarFnPlugin::deserialize(&self, metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::ScalarFnRef>
 
-impl core::clone::Clone for vortex_array::patches::PatchesMetadata
+pub fn vortex_array::scalar_fn::ScalarFnPlugin::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::patches::PatchesMetadata::clone(&self) -> vortex_array::patches::PatchesMetadata
+impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::scalar_fn::ScalarFnPlugin for V
 
-impl core::default::Default for vortex_array::patches::PatchesMetadata
+pub fn V::deserialize(&self, metadata: &[u8], session: &vortex_session::VortexSession) -> core::result::Result<vortex_array::scalar_fn::ScalarFnRef, vortex_error::VortexError>
 
-pub fn vortex_array::patches::PatchesMetadata::default() -> Self
+pub fn V::id(&self) -> arcref::ArcRef<str>
 
-impl core::fmt::Debug for vortex_array::patches::PatchesMetadata
+pub trait vortex_array::scalar_fn::ScalarFnVTable: 'static + core::marker::Sized + core::clone::Clone + core::marker::Send + core::marker::Sync
 
-pub fn vortex_array::patches::PatchesMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::scalar_fn::ScalarFnVTable::Options: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + core::cmp::PartialEq + core::cmp::Eq + core::hash::Hash
 
-impl core::marker::Copy for vortex_array::patches::PatchesMetadata
+pub fn vortex_array::scalar_fn::ScalarFnVTable::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl prost::message::Message for vortex_array::patches::PatchesMetadata
+pub fn vortex_array::scalar_fn::ScalarFnVTable::child_name(&self, options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::patches::PatchesMetadata::clear(&mut self)
+pub fn vortex_array::scalar_fn::ScalarFnVTable::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::patches::PatchesMetadata::encoded_len(&self) -> usize
+pub fn vortex_array::scalar_fn::ScalarFnVTable::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub const vortex_array::patches::PATCH_CHUNK_SIZE: usize
+pub fn vortex_array::scalar_fn::ScalarFnVTable::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub mod vortex_array::scalar
+pub fn vortex_array::scalar_fn::ScalarFnVTable::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::scalar::extension
+pub fn vortex_array::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub struct vortex_array::scalar::extension::ExtScalarValue<V: vortex_array::dtype::extension::ExtVTable>(_)
+pub fn vortex_array::scalar_fn::ScalarFnVTable::is_fallible(&self, options: &Self::Options) -> bool
 
-impl<V: vortex_array::dtype::extension::ExtVTable> vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ScalarFnVTable::is_null_sensitive(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::erased(self) -> vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ScalarFnVTable::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::scalar_fn::ScalarFnVTable::return_dtype(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::storage_value(&self) -> &vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::ScalarFnVTable::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::try_new(ext_dtype: &vortex_array::dtype::extension::ExtDType<V>, storage: vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::ScalarFnVTable::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::vtable(&self) -> &V
+pub fn vortex_array::scalar_fn::ScalarFnVTable::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<V: core::clone::Clone + vortex_array::dtype::extension::ExtVTable> core::clone::Clone for vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ScalarFnVTable::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::clone(&self) -> vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ScalarFnVTable::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl<V: core::cmp::Eq + vortex_array::dtype::extension::ExtVTable> core::cmp::Eq for vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ScalarFnVTable::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<V: core::cmp::PartialEq + vortex_array::dtype::extension::ExtVTable> core::cmp::PartialEq for vortex_array::scalar::extension::ExtScalarValue<V>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::ForeignScalarFnVTable
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::eq(&self, other: &vortex_array::scalar::extension::ExtScalarValue<V>) -> bool
+pub type vortex_array::scalar_fn::ForeignScalarFnVTable::Options = vortex_array::scalar_fn::ForeignScalarFnOptions
 
-impl<V: core::fmt::Debug + vortex_array::dtype::extension::ExtVTable> core::fmt::Debug for vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl<V: core::hash::Hash + vortex_array::dtype::extension::ExtVTable> core::hash::Hash for vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValue<V>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::deserialize(&self, metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl<V: vortex_array::dtype::extension::ExtVTable> core::marker::StructuralPartialEq for vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::execute(&self, _options: &Self::Options, _args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub struct vortex_array::scalar::extension::ExtScalarValueRef(_)
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> vortex_array::scalar::extension::ExtScalarValue<V>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::id(&self) -> vortex_array::dtype::extension::ExtId
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::is_null_sensitive(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::storage_value(&self) -> &vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::try_downcast<V: vortex_array::dtype::extension::ExtVTable>(self) -> core::result::Result<vortex_array::scalar::extension::ExtScalarValue<V>, vortex_array::scalar::extension::ExtScalarValueRef>
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::return_dtype(&self, _options: &Self::Options, _args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::clone::Clone for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::clone(&self) -> vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::cmp::Eq for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::cmp::PartialEq for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::eq(&self, other: &Self) -> bool
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::cmp::PartialOrd for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::ForeignScalarFnVTable::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::between::Between
 
-impl core::fmt::Debug for vortex_array::scalar::extension::ExtScalarValueRef
+pub type vortex_array::scalar_fn::fns::between::Between::Options = vortex_array::scalar_fn::fns::between::BetweenOptions
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::between::Between::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl core::fmt::Display for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::fns::between::Between::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::between::Between::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::hash::Hash for vortex_array::scalar::extension::ExtScalarValueRef
+pub fn vortex_array::scalar_fn::fns::between::Between::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::extension::ExtScalarValueRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::scalar_fn::fns::between::Between::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub enum vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::between::Between::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_array::scalar::DecimalValue::I128(i128)
+pub fn vortex_array::scalar_fn::fns::between::Between::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub vortex_array::scalar::DecimalValue::I16(i16)
+pub fn vortex_array::scalar_fn::fns::between::Between::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub vortex_array::scalar::DecimalValue::I256(vortex_array::dtype::i256)
+pub fn vortex_array::scalar_fn::fns::between::Between::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub vortex_array::scalar::DecimalValue::I32(i32)
+pub fn vortex_array::scalar_fn::fns::between::Between::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub vortex_array::scalar::DecimalValue::I64(i64)
+pub fn vortex_array::scalar_fn::fns::between::Between::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub vortex_array::scalar::DecimalValue::I8(i8)
+pub fn vortex_array::scalar_fn::fns::between::Between::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::between::Between::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::DecimalValue::cast<T: vortex_array::dtype::NativeDecimalType>(&self) -> core::option::Option<T>
+pub fn vortex_array::scalar_fn::fns::between::Between::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::DecimalValue::checked_add(&self, other: &Self) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::between::Between::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::DecimalValue::checked_div(&self, other: &Self) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::between::Between::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::DecimalValue::checked_mul(&self, other: &Self) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::between::Between::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::DecimalValue::checked_sub(&self, other: &Self) -> core::option::Option<Self>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::binary::Binary
 
-pub fn vortex_array::scalar::DecimalValue::decimal_dtype(&self) -> vortex_array::dtype::DecimalDType
+pub type vortex_array::scalar_fn::fns::binary::Binary::Options = vortex_array::scalar_fn::fns::operators::Operator
 
-pub fn vortex_array::scalar::DecimalValue::decimal_type(&self) -> vortex_array::dtype::DecimalType
+pub fn vortex_array::scalar_fn::fns::binary::Binary::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::DecimalValue::fits_in_precision(&self, decimal_type: vortex_array::dtype::DecimalDType) -> bool
+pub fn vortex_array::scalar_fn::fns::binary::Binary::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::DecimalValue::is_zero(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::binary::Binary::coerce_args(&self, operator: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::DecimalValue::zero(decimal_type: &vortex_array::dtype::DecimalDType) -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::clone::Clone for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::execute(&self, op: &vortex_array::scalar_fn::fns::operators::Operator, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::DecimalValue::clone(&self) -> vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::fmt_sql(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::Eq for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::cmp::PartialEq for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::is_fallible(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
 
-pub fn vortex_array::scalar::DecimalValue::eq(&self, other: &Self) -> bool
+pub fn vortex_array::scalar_fn::fns::binary::Binary::is_null_sensitive(&self, _operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
 
-impl core::cmp::PartialOrd for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::DecimalValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::binary::Binary::return_dtype(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::convert::From<i128> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: i128) -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<i16> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: i16) -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::From<i32> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_falsification(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: i32) -> Self
+pub fn vortex_array::scalar_fn::fns::binary::Binary::validity(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<i64> for vortex_array::scalar::DecimalValue
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::case_when::CaseWhen
 
-pub fn vortex_array::scalar::DecimalValue::from(value: i64) -> Self
+pub type vortex_array::scalar_fn::fns::case_when::CaseWhen::Options = vortex_array::scalar_fn::fns::case_when::CaseWhenOptions
 
-impl core::convert::From<i8> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::DecimalValue::from(value: i8) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::child_name(&self, options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::convert::From<u16> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: u16) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::deserialize(&self, metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::convert::From<u32> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: u32) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<u64> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::DecimalValue::from(value: u64) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::is_fallible(&self, _options: &Self::Options) -> bool
 
-impl core::convert::From<u8> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::DecimalValue::from(value: u8) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl core::convert::From<vortex_array::dtype::i256> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::DecimalValue::from(value: vortex_array::dtype::i256) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::Scalar
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::Scalar::from(value: vortex_array::scalar::DecimalValue) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::DecimalValue) -> Self
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::case_when::CaseWhen::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::cast::Cast
 
-pub fn vortex_array::scalar::DecimalValue::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub type vortex_array::scalar_fn::fns::cast::Cast::Options = vortex_array::dtype::DType
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::cast::Cast::arity(&self, _options: &vortex_array::dtype::DType) -> vortex_array::scalar_fn::Arity
 
-pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::cast::Cast::child_name(&self, _instance: &vortex_array::dtype::DType, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::DecimalValue::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::cast::Cast::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::fmt::Debug for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::cast::Cast::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::DecimalValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::cast::Cast::execute(&self, target_dtype: &vortex_array::dtype::DType, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::fmt::Display for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::cast::Cast::fmt_sql(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::DecimalValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::cast::Cast::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::hash::Hash for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::cast::Cast::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::DecimalValue::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::scalar_fn::fns::cast::Cast::is_null_sensitive(&self, _instance: &vortex_array::dtype::DType) -> bool
 
-impl core::marker::Copy for vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::cast::Cast::reduce(&self, target_dtype: &vortex_array::dtype::DType, node: &dyn vortex_array::scalar_fn::ReduceNode, _ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub enum vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::cast::Cast::return_dtype(&self, dtype: &vortex_array::dtype::DType, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub vortex_array::scalar::NumericOperator::Add
+pub fn vortex_array::scalar_fn::fns::cast::Cast::serialize(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::scalar::NumericOperator::Div
+pub fn vortex_array::scalar_fn::fns::cast::Cast::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::NumericOperator::Mul
+pub fn vortex_array::scalar_fn::fns::cast::Cast::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::NumericOperator::Sub
+pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_expression(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::clone::Clone for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::NumericOperator::clone(&self) -> vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::cast::Cast::validity(&self, dtype: &vortex_array::dtype::DType, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::cmp::Eq for vortex_array::scalar::NumericOperator
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
 
-impl core::cmp::PartialEq for vortex_array::scalar::NumericOperator
+pub type vortex_array::scalar_fn::fns::dynamic::DynamicComparison::Options = vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
 
-pub fn vortex_array::scalar::NumericOperator::eq(&self, other: &vortex_array::scalar::NumericOperator) -> bool
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl core::convert::From<vortex_array::scalar::NumericOperator> for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::from(op: vortex_array::scalar::NumericOperator) -> Self
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::fmt::Debug for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::NumericOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::execute(&self, data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::fmt::Display for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::fmt_sql(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::NumericOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::marker::Copy for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_fallible(&self, options: &Self::Options) -> bool
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-impl vortex_array::compute::Options for vortex_array::scalar::NumericOperator
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::NumericOperator::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::return_dtype(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub enum vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::scalar::PValue::F16(half::binary16::f16)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::PValue::F32(f32)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::PValue::F64(f64)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub vortex_array::scalar::PValue::I16(i16)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_falsification(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub vortex_array::scalar::PValue::I32(i32)
+pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::PValue::I64(i64)
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::fill_null::FillNull
 
-pub vortex_array::scalar::PValue::I8(i8)
+pub type vortex_array::scalar_fn::fns::fill_null::FillNull::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub vortex_array::scalar::PValue::U16(u16)
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub vortex_array::scalar::PValue::U32(u32)
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub vortex_array::scalar::PValue::U64(u64)
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub vortex_array::scalar::PValue::U8(u8)
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::PValue::as_f16(self) -> core::option::Option<half::binary16::f16>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::PValue::as_f32(self) -> core::option::Option<f32>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::PValue::as_f64(self) -> core::option::Option<f64>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::PValue::as_i16(self) -> core::option::Option<i16>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::PValue::as_i32(self) -> core::option::Option<i32>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::PValue::as_i64(self) -> core::option::Option<i64>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::PValue::as_i8(self) -> core::option::Option<i8>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::PValue::as_u16(self) -> core::option::Option<u16>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::as_u32(self) -> core::option::Option<u32>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::as_u64(self) -> core::option::Option<u64>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::PValue::as_u8(self) -> core::option::Option<u8>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::PValue::cast<T: vortex_array::dtype::NativePType>(&self) -> vortex_error::VortexResult<T>
+pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::is_instance_of(&self, ptype: &vortex_array::dtype::PType) -> bool
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::get_item::GetItem
 
-pub fn vortex_array::scalar::PValue::is_nan(&self) -> bool
+pub type vortex_array::scalar_fn::fns::get_item::GetItem::Options = vortex_array::dtype::FieldName
 
-pub fn vortex_array::scalar::PValue::is_zero(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::arity(&self, _field_name: &vortex_array::dtype::FieldName) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::PValue::ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::PValue::reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> Self
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::PValue::zero(ptype: &vortex_array::dtype::PType) -> vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::clone::Clone for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::execute(&self, field_name: &vortex_array::dtype::FieldName, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::PValue::clone(&self) -> vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::fmt_sql(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::Eq for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::cmp::PartialEq for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_fallible(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
 
-pub fn vortex_array::scalar::PValue::eq(&self, other: &Self) -> bool
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_null_sensitive(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
 
-impl core::cmp::PartialOrd for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::reduce(&self, field_name: &vortex_array::dtype::FieldName, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::PValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::return_dtype(&self, field_name: &vortex_array::dtype::FieldName, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::convert::From<&vortex_array::scalar::PValue> for vortex_proto::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_proto::scalar::ScalarValue::from(value: &vortex_array::scalar::PValue) -> Self
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<f32> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify_untyped(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::from(value: f32) -> Self
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_expression(&self, field_name: &vortex_array::dtype::FieldName, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::From<f64> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::PValue::from(value: f64) -> Self
+pub fn vortex_array::scalar_fn::fns::get_item::GetItem::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<half::binary16::f16> for vortex_array::scalar::PValue
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::is_null::IsNull
 
-pub fn vortex_array::scalar::PValue::from(value: half::binary16::f16) -> Self
+pub type vortex_array::scalar_fn::fns::is_null::IsNull::Options = vortex_array::scalar_fn::EmptyOptions
 
-impl core::convert::From<i16> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::PValue::from(value: i16) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::convert::From<i32> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::PValue::from(value: i32) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::convert::From<i64> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::execute(&self, _data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::PValue::from(value: i64) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<i8> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::PValue::from(value: i8) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_fallible(&self, _instance: &Self::Options) -> bool
 
-impl core::convert::From<u16> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::PValue::from(value: u16) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl core::convert::From<u32> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::PValue::from(value: u32) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::From<u64> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::from(value: u64) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<u8> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::PValue::from(value: u8) -> Self
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::From<usize> for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::is_null::IsNull::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::PValue::from(value: usize) -> vortex_array::scalar::PValue
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::like::Like
 
-impl core::convert::From<vortex_array::scalar::PValue> for vortex_array::scalar::ScalarValue
+pub type vortex_array::scalar_fn::fns::like::Like::Options = vortex_array::scalar_fn::fns::like::LikeOptions
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::PValue) -> Self
+pub fn vortex_array::scalar_fn::fns::like::Like::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for f32
+pub fn vortex_array::scalar_fn::fns::like::Like::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub type f32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::like::Like::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn f32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::like::Like::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for f64
+pub fn vortex_array::scalar_fn::fns::like::Like::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type f64::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::like::Like::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn f64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::like::Like::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for half::binary16::f16
+pub fn vortex_array::scalar_fn::fns::like::Like::is_fallible(&self, options: &Self::Options) -> bool
 
-pub type half::binary16::f16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::like::Like::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn half::binary16::f16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::like::Like::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for i16
+pub fn vortex_array::scalar_fn::fns::like::Like::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub type i16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::like::Like::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn i16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::like::Like::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for i32
+pub fn vortex_array::scalar_fn::fns::like::Like::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type i32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::like::Like::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn i32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::like::Like::stat_falsification(&self, like_opts: &vortex_array::scalar_fn::fns::like::LikeOptions, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for i64
+pub fn vortex_array::scalar_fn::fns::like::Like::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type i64::Error = vortex_error::VortexError
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::list_contains::ListContains
 
-pub fn i64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub type vortex_array::scalar_fn::fns::list_contains::ListContains::Options = vortex_array::scalar_fn::EmptyOptions
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for i8
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub type i8::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn i8::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for u16
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type u16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u16::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for u32
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub type u32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn u32::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for u64
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub type u64::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn u64::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for u8
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type u8::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn u8::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::TryFrom<vortex_array::scalar::PValue> for usize
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type usize::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn usize::try_from(value: vortex_array::scalar::PValue) -> core::result::Result<Self, Self::Error>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::literal::Literal
 
-impl core::fmt::Debug for vortex_array::scalar::PValue
+pub type vortex_array::scalar_fn::fns::literal::Literal::Options = vortex_array::scalar::Scalar
 
-pub fn vortex_array::scalar::PValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::literal::Literal::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl core::fmt::Display for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::literal::Literal::child_name(&self, _instance: &Self::Options, _child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::PValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::literal::Literal::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::hash::Hash for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::literal::Literal::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::PValue::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::execute(&self, scalar: &vortex_array::scalar::Scalar, args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::marker::Copy for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::literal::Literal::fmt_sql(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::dtype::ToBytes for vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::literal::Literal::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::PValue::to_le_bytes(&self) -> &[u8]
+pub fn vortex_array::scalar_fn::fns::literal::Literal::is_fallible(&self, _instance: &Self::Options) -> bool
 
-impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::scalar_fn::fns::literal::Literal::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+pub fn vortex_array::scalar_fn::fns::literal::Literal::return_dtype(&self, options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub enum vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::literal::Literal::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::scalar::ScalarValue::Binary(vortex_buffer::ByteBuffer)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::ScalarValue::Bool(bool)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::ScalarValue::Decimal(vortex_array::scalar::DecimalValue)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_expression(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, _catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub vortex_array::scalar::ScalarValue::List(alloc::vec::Vec<core::option::Option<vortex_array::scalar::ScalarValue>>)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub vortex_array::scalar::ScalarValue::Primitive(vortex_array::scalar::PValue)
+pub fn vortex_array::scalar_fn::fns::literal::Literal::validity(&self, scalar: &vortex_array::scalar::Scalar, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub vortex_array::scalar::ScalarValue::Utf8(vortex_buffer::string::BufferString)
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::mask::Mask
 
-impl vortex_array::scalar::ScalarValue
+pub type vortex_array::scalar_fn::fns::mask::Mask::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::scalar::ScalarValue::as_binary(&self) -> &vortex_buffer::ByteBuffer
+pub fn vortex_array::scalar_fn::fns::mask::Mask::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::ScalarValue::as_bool(&self) -> bool
+pub fn vortex_array::scalar_fn::fns::mask::Mask::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::ScalarValue::as_decimal(&self) -> &vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::ScalarValue::as_list(&self) -> &[core::option::Option<vortex_array::scalar::ScalarValue>]
+pub fn vortex_array::scalar_fn::fns::mask::Mask::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::ScalarValue::as_primitive(&self) -> &vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::ScalarValue::as_utf8(&self) -> &vortex_buffer::string::BufferString
+pub fn vortex_array::scalar_fn::fns::mask::Mask::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ScalarValue::into_binary(self) -> vortex_buffer::ByteBuffer
+pub fn vortex_array::scalar_fn::fns::mask::Mask::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::ScalarValue::into_bool(self) -> bool
+pub fn vortex_array::scalar_fn::fns::mask::Mask::is_fallible(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::ScalarValue::into_decimal(self) -> vortex_array::scalar::DecimalValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::is_null_sensitive(&self, options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::ScalarValue::into_list(self) -> alloc::vec::Vec<core::option::Option<vortex_array::scalar::ScalarValue>>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::ScalarValue::into_primitive(self) -> vortex_array::scalar::PValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::ScalarValue::into_utf8(self) -> vortex_buffer::string::BufferString
+pub fn vortex_array::scalar_fn::fns::mask::Mask::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::default_value(dtype: &vortex_array::dtype::DType) -> core::option::Option<Self>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::zero_value(dtype: &vortex_array::dtype::DType) -> Self
+pub fn vortex_array::scalar_fn::fns::mask::Mask::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::mask::Mask::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::ScalarValue::from_proto(value: &vortex_proto::scalar::ScalarValue, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::scalar_fn::fns::mask::Mask::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::from_proto_bytes(bytes: &[u8], dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<Self>>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::merge::Merge
 
-impl vortex_array::scalar::ScalarValue
+pub type vortex_array::scalar_fn::fns::merge::Merge::Options = vortex_array::scalar_fn::fns::merge::DuplicateHandling
 
-pub fn vortex_array::scalar::ScalarValue::to_proto(this: core::option::Option<&Self>) -> vortex_proto::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::ScalarValue::to_proto_bytes<B: core::default::Default + bytes::buf::buf_mut::BufMut>(value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> B
+pub fn vortex_array::scalar_fn::fns::merge::Merge::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::clone::Clone for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::ScalarValue::clone(&self) -> vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::cmp::Eq for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::cmp::PartialEq for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ScalarValue::eq(&self, other: &vortex_array::scalar::ScalarValue) -> bool
+pub fn vortex_array::scalar_fn::fns::merge::Merge::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::cmp::PartialOrd for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::is_fallible(&self, instance: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::ScalarValue::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::merge::Merge::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-impl core::convert::From<&[u8]> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: &[u8]) -> Self
+pub fn vortex_array::scalar_fn::fns::merge::Merge::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::convert::From<&str> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: &str) -> Self
+pub fn vortex_array::scalar_fn::fns::merge::Merge::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<&vortex_array::scalar::ScalarValue> for vortex_proto::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_proto::scalar::ScalarValue::from(value: &vortex_array::scalar::ScalarValue) -> Self
+pub fn vortex_array::scalar_fn::fns::merge::Merge::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::From<alloc::string::String> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::merge::Merge::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: alloc::string::String) -> Self
+pub fn vortex_array::scalar_fn::fns::merge::Merge::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<bool> for vortex_array::scalar::ScalarValue
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::not::Not
 
-pub fn vortex_array::scalar::ScalarValue::from(value: bool) -> Self
+pub type vortex_array::scalar_fn::fns::not::Not::Options = vortex_array::scalar_fn::EmptyOptions
 
-impl core::convert::From<f32> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub fn vortex_array::scalar::ScalarValue::from(value: f32) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::convert::From<f64> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: f64) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-impl core::convert::From<half::binary16::f16> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::execute(&self, _data: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: half::binary16::f16) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<i16> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::ScalarValue::from(value: i16) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::is_fallible(&self, _options: &Self::Options) -> bool
 
-impl core::convert::From<i32> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::ScalarValue::from(value: i32) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-impl core::convert::From<i64> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: i64) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::From<i8> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: i8) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::From<u16> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: u16) -> Self
+pub fn vortex_array::scalar_fn::fns::not::Not::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::From<u32> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::not::Not::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: u32) -> Self
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::pack::Pack
 
-impl core::convert::From<u64> for vortex_array::scalar::ScalarValue
+pub type vortex_array::scalar_fn::fns::pack::Pack::Options = vortex_array::scalar_fn::fns::pack::PackOptions
 
-pub fn vortex_array::scalar::ScalarValue::from(value: u64) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-impl core::convert::From<u8> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::child_name(&self, instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn vortex_array::scalar::ScalarValue::from(value: u8) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::convert::From<usize> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: usize) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::DecimalValue) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-impl core::convert::From<vortex_array::scalar::PValue> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::is_fallible(&self, _instance: &Self::Options) -> bool
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_array::scalar::PValue) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::is_null_sensitive(&self, _instance: &Self::Options) -> bool
 
-impl core::convert::From<vortex_buffer::buffer::Buffer<u8>> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_buffer::ByteBuffer) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::convert::From<vortex_buffer::string::BufferString> for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::pack::Pack::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::ScalarValue::from(value: vortex_buffer::string::BufferString) -> Self
+pub fn vortex_array::scalar_fn::fns::pack::Pack::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for f32
+pub fn vortex_array::scalar_fn::fns::pack::Pack::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type f32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::pack::Pack::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn f32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::pack::Pack::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for f64
+pub fn vortex_array::scalar_fn::fns::pack::Pack::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type f64::Error = vortex_error::VortexError
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::root::Root
 
-pub fn f64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub type vortex_array::scalar_fn::fns::root::Root::Options = vortex_array::scalar_fn::EmptyOptions
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for half::binary16::f16
+pub fn vortex_array::scalar_fn::fns::root::Root::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub type half::binary16::f16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-pub fn half::binary16::f16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::root::Root::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i16
+pub fn vortex_array::scalar_fn::fns::root::Root::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub type i16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::execute(&self, _data: &Self::Options, _args: &dyn vortex_array::scalar_fn::ExecutionArgs, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn i16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::root::Root::fmt_sql(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i32
+pub fn vortex_array::scalar_fn::fns::root::Root::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub type i32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::is_fallible(&self, _options: &Self::Options) -> bool
 
-pub fn i32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::root::Root::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i64
+pub fn vortex_array::scalar_fn::fns::root::Root::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub type i64::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn i64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::root::Root::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for i8
+pub fn vortex_array::scalar_fn::fns::root::Root::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub type i8::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn i8::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::root::Root::stat_expression(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u16
+pub fn vortex_array::scalar_fn::fns::root::Root::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub type u16::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::root::Root::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn u16::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::select::Select
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u32
+pub type vortex_array::scalar_fn::fns::select::Select::Options = vortex_array::scalar_fn::fns::select::FieldSelection
 
-pub type u32::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::select::Select::arity(&self, _options: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_array::scalar_fn::Arity
 
-pub fn u32::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::select::Select::child_name(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u64
+pub fn vortex_array::scalar_fn::fns::select::Select::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub type u64::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::select::Select::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::fns::select::FieldSelection>
 
-pub fn u64::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::select::Select::execute(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for u8
+pub fn vortex_array::scalar_fn::fns::select::Select::fmt_sql(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type u8::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::select::Select::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn u8::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::select::Select::is_fallible(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
 
-impl core::convert::TryFrom<&vortex_array::scalar::ScalarValue> for usize
+pub fn vortex_array::scalar_fn::fns::select::Select::is_null_sensitive(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
 
-pub type usize::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::fns::select::Select::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn usize::try_from(value: &vortex_array::scalar::ScalarValue) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::select::Select::return_dtype(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::fmt::Debug for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::select::Select::serialize(&self, instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::ScalarValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::select::Select::simplify(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::fmt::Display for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::select::Select::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::ScalarValue::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::select::Select::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::hash::Hash for vortex_array::scalar::ScalarValue
+pub fn vortex_array::scalar_fn::fns::select::Select::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::ScalarValue::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::scalar_fn::fns::select::Select::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar::ScalarValue
+impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::zip::Zip
 
-impl<T> core::convert::From<alloc::vec::Vec<T>> for vortex_array::scalar::ScalarValue where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+pub type vortex_array::scalar_fn::fns::zip::Zip::Options = vortex_array::scalar_fn::EmptyOptions
 
-pub fn vortex_array::scalar::ScalarValue::from(vec: alloc::vec::Vec<T>) -> Self
+pub fn vortex_array::scalar_fn::fns::zip::Zip::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
 
-pub struct vortex_array::scalar::BinaryScalar<'a>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
 
-impl<'a> vortex_array::scalar::BinaryScalar<'a>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::coerce_args(&self, options: &Self::Options, args: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_array::dtype::DType>>
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+pub fn vortex_array::scalar_fn::fns::zip::Zip::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::is_empty(&self) -> core::option::Option<bool>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::ExecutionArgs, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::len(&self) -> core::option::Option<usize>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::id(&self) -> vortex_array::scalar_fn::ScalarFnId
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::value(&self) -> core::option::Option<&'a vortex_buffer::ByteBuffer>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::is_fallible(&self, _options: &Self::Options) -> bool
 
-impl core::cmp::Eq for vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::is_null_sensitive(&self, _options: &Self::Options) -> bool
 
-impl core::cmp::Ord for vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
 
-pub fn vortex_array::scalar::BinaryScalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn vortex_array::scalar_fn::fns::zip::Zip::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl core::cmp::PartialEq for vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::BinaryScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, _ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl core::cmp::PartialOrd for vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-pub fn vortex_array::scalar::BinaryScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-impl core::fmt::Display for vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::scalar_fn::fns::zip::Zip::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::BinaryScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::scalar_fn::fns::zip::Zip::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
 
-impl<'a> core::clone::Clone for vortex_array::scalar::BinaryScalar<'a>
+pub trait vortex_array::scalar_fn::ScalarFnVTableExt: vortex_array::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::clone(&self) -> vortex_array::scalar::BinaryScalar<'a>
+pub fn vortex_array::scalar_fn::ScalarFnVTableExt::bind(&self, options: Self::Options) -> vortex_array::scalar_fn::ScalarFnRef
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BinaryScalar<'a>
+pub fn vortex_array::scalar_fn::ScalarFnVTableExt::new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_array::expr::Expression
 
-pub type vortex_array::scalar::BinaryScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::scalar_fn::ScalarFnVTableExt::try_new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::scalar_fn::ScalarFnVTableExt for V
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::BinaryScalar<'a>
+pub fn V::bind(&self, options: Self::Options) -> vortex_array::scalar_fn::ScalarFnRef
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn V::new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_array::expr::Expression
 
-impl<'a> core::hash::Hash for vortex_array::scalar::BinaryScalar<'a>
+pub fn V::try_new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub trait vortex_array::scalar_fn::SimplifyCtx
 
-pub struct vortex_array::scalar::BoolScalar<'a>
+pub fn vortex_array::scalar_fn::SimplifyCtx::return_dtype(&self, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-impl<'a> vortex_array::scalar::BoolScalar<'a>
+pub type vortex_array::scalar_fn::ChildName = arcref::ArcRef<str>
 
-pub fn vortex_array::scalar::BoolScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+pub type vortex_array::scalar_fn::ReduceNodeRef = alloc::sync::Arc<dyn vortex_array::scalar_fn::ReduceNode>
 
-pub fn vortex_array::scalar::BoolScalar<'a>::into_scalar(self) -> vortex_array::scalar::Scalar
+pub type vortex_array::scalar_fn::ScalarFnId = arcref::ArcRef<str>
 
-pub fn vortex_array::scalar::BoolScalar<'a>::invert(self) -> vortex_array::scalar::BoolScalar<'a>
+pub type vortex_array::scalar_fn::ScalarFnPluginRef = alloc::sync::Arc<dyn vortex_array::scalar_fn::ScalarFnPlugin>
 
-pub fn vortex_array::scalar::BoolScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub mod vortex_array::search_sorted
 
-pub fn vortex_array::scalar::BoolScalar<'a>::value(&self) -> core::option::Option<bool>
+pub enum vortex_array::search_sorted::SearchResult
 
-impl core::cmp::Ord for vortex_array::scalar::BoolScalar<'_>
+pub vortex_array::search_sorted::SearchResult::Found(usize)
 
-pub fn vortex_array::scalar::BoolScalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub vortex_array::search_sorted::SearchResult::NotFound(usize)
 
-impl core::cmp::PartialEq for vortex_array::scalar::BoolScalar<'_>
+impl vortex_array::search_sorted::SearchResult
 
-pub fn vortex_array::scalar::BoolScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::search_sorted::SearchResult::to_ends_index(self, len: usize) -> usize
 
-impl core::cmp::PartialOrd for vortex_array::scalar::BoolScalar<'_>
+pub fn vortex_array::search_sorted::SearchResult::to_found(self) -> core::option::Option<usize>
 
-pub fn vortex_array::scalar::BoolScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::search_sorted::SearchResult::to_index(self) -> usize
 
-impl core::fmt::Display for vortex_array::scalar::BoolScalar<'_>
+pub fn vortex_array::search_sorted::SearchResult::to_offsets_index(self, len: usize, side: vortex_array::search_sorted::SearchSortedSide) -> usize
 
-pub fn vortex_array::scalar::BoolScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::clone::Clone for vortex_array::search_sorted::SearchResult
 
-impl<'a> core::clone::Clone for vortex_array::scalar::BoolScalar<'a>
+pub fn vortex_array::search_sorted::SearchResult::clone(&self) -> vortex_array::search_sorted::SearchResult
 
-pub fn vortex_array::scalar::BoolScalar<'a>::clone(&self) -> vortex_array::scalar::BoolScalar<'a>
+impl core::cmp::Eq for vortex_array::search_sorted::SearchResult
 
-impl<'a> core::cmp::Eq for vortex_array::scalar::BoolScalar<'a>
+impl core::cmp::PartialEq for vortex_array::search_sorted::SearchResult
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BoolScalar<'a>
+pub fn vortex_array::search_sorted::SearchResult::eq(&self, other: &vortex_array::search_sorted::SearchResult) -> bool
 
-pub type vortex_array::scalar::BoolScalar<'a>::Error = vortex_error::VortexError
+impl core::fmt::Debug for vortex_array::search_sorted::SearchResult
 
-pub fn vortex_array::scalar::BoolScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::search_sorted::SearchResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::BoolScalar<'a>
+impl core::fmt::Display for vortex_array::search_sorted::SearchResult
 
-pub fn vortex_array::scalar::BoolScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::search_sorted::SearchResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<'a> core::hash::Hash for vortex_array::scalar::BoolScalar<'a>
+impl core::marker::Copy for vortex_array::search_sorted::SearchResult
 
-pub fn vortex_array::scalar::BoolScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+impl core::marker::StructuralPartialEq for vortex_array::search_sorted::SearchResult
 
-pub struct vortex_array::scalar::DecimalScalar<'a>
+pub enum vortex_array::search_sorted::SearchSortedSide
 
-impl<'a> vortex_array::scalar::DecimalScalar<'a>
+pub vortex_array::search_sorted::SearchSortedSide::Left
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::checked_binary_numeric(&self, other: &vortex_array::scalar::DecimalScalar<'a>, op: vortex_array::scalar::NumericOperator) -> core::option::Option<vortex_array::scalar::DecimalScalar<'a>>
+pub vortex_array::search_sorted::SearchSortedSide::Right
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::decimal_value(&self) -> core::option::Option<vortex_array::scalar::DecimalValue>
+impl core::clone::Clone for vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+pub fn vortex_array::search_sorted::SearchSortedSide::clone(&self) -> vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::is_zero(&self) -> core::option::Option<bool>
+impl core::cmp::Eq for vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+impl core::cmp::PartialEq for vortex_array::search_sorted::SearchSortedSide
 
-impl core::cmp::Eq for vortex_array::scalar::DecimalScalar<'_>
+pub fn vortex_array::search_sorted::SearchSortedSide::eq(&self, other: &vortex_array::search_sorted::SearchSortedSide) -> bool
 
-impl core::cmp::PartialEq for vortex_array::scalar::DecimalScalar<'_>
+impl core::fmt::Debug for vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::DecimalScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::search_sorted::SearchSortedSide::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialOrd for vortex_array::scalar::DecimalScalar<'_>
+impl core::fmt::Display for vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::DecimalScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::search_sorted::SearchSortedSide::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::scalar::Scalar
+impl core::marker::Copy for vortex_array::search_sorted::SearchSortedSide
 
-pub fn vortex_array::scalar::Scalar::from(ds: vortex_array::scalar::DecimalScalar<'_>) -> Self
+impl core::marker::StructuralPartialEq for vortex_array::search_sorted::SearchSortedSide
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i128>
+pub trait vortex_array::search_sorted::IndexOrd<V>
 
-pub type core::option::Option<i128>::Error = vortex_error::VortexError
+pub fn vortex_array::search_sorted::IndexOrd::index_cmp(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-pub fn core::option::Option<i128>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::search_sorted::IndexOrd::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i16>
+pub fn vortex_array::search_sorted::IndexOrd::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<i16>::Error = vortex_error::VortexError
+pub fn vortex_array::search_sorted::IndexOrd::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<i16>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::search_sorted::IndexOrd::index_len(&self) -> usize
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i32>
+pub fn vortex_array::search_sorted::IndexOrd::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<i32>::Error = vortex_error::VortexError
+impl vortex_array::search_sorted::IndexOrd<core::option::Option<vortex_array::scalar::PValue>> for vortex_array::variants::PrimitiveTyped<'_>
 
-pub fn core::option::Option<i32>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &core::option::Option<vortex_array::scalar::PValue>) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i64>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<i64>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<i64>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<i8>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
 
-pub type core::option::Option<i8>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<i8>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for core::option::Option<vortex_array::dtype::i256>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-pub type core::option::Option<vortex_array::dtype::i256>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<vortex_array::dtype::i256>::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i128
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type i128::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
 
-pub fn i128::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i16
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::Scalar> for vortex_array::ArrayRef
 
-pub type i16::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-pub fn i16::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i32
+pub fn vortex_array::ArrayRef::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type i32::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn i32::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::index_len(&self) -> usize
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i64
+pub fn vortex_array::ArrayRef::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type i64::Error = vortex_error::VortexError
+impl<T: core::cmp::PartialOrd> vortex_array::search_sorted::IndexOrd<T> for [T]
 
-pub fn i64::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn [T]::index_cmp(&self, idx: usize, elem: &T) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for i8
+pub fn [T]::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type i8::Error = vortex_error::VortexError
+pub fn [T]::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn i8::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub fn [T]::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::dtype::i256
+pub fn [T]::index_len(&self) -> usize
 
-pub type vortex_array::dtype::i256::Error = vortex_error::VortexError
+pub fn [T]::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::dtype::i256::try_from(value: vortex_array::scalar::DecimalScalar<'_>) -> core::result::Result<Self, Self::Error>
+pub trait vortex_array::search_sorted::SearchSorted<T>
 
-impl core::fmt::Display for vortex_array::scalar::DecimalScalar<'_>
+pub fn vortex_array::search_sorted::SearchSorted::search_sorted(&self, value: &T, side: vortex_array::search_sorted::SearchSortedSide) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult> where Self: vortex_array::search_sorted::IndexOrd<T>
 
-pub fn vortex_array::scalar::DecimalScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::search_sorted::SearchSorted::search_sorted_by<F: core::ops::function::FnMut(usize) -> vortex_error::VortexResult<core::cmp::Ordering>, N: core::ops::function::FnMut(usize) -> vortex_error::VortexResult<core::cmp::Ordering>>(&self, find: F, side_find: N, side: vortex_array::search_sorted::SearchSortedSide) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult>
 
-impl<'a> core::clone::Clone for vortex_array::scalar::DecimalScalar<'a>
+impl<S, T> vortex_array::search_sorted::SearchSorted<T> for S where S: vortex_array::search_sorted::IndexOrd<T> + ?core::marker::Sized
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::clone(&self) -> vortex_array::scalar::DecimalScalar<'a>
+pub fn S::search_sorted(&self, value: &T, side: vortex_array::search_sorted::SearchSortedSide) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult> where Self: vortex_array::search_sorted::IndexOrd<T>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalScalar<'a>
+pub fn S::search_sorted_by<F, N>(&self, find: F, side_find: N, side: vortex_array::search_sorted::SearchSortedSide) -> core::result::Result<vortex_array::search_sorted::SearchResult, vortex_error::VortexError> where F: core::ops::function::FnMut(usize) -> core::result::Result<core::cmp::Ordering, vortex_error::VortexError>, N: core::ops::function::FnMut(usize) -> core::result::Result<core::cmp::Ordering, vortex_error::VortexError>
 
-pub type vortex_array::scalar::DecimalScalar<'a>::Error = vortex_error::VortexError
+pub mod vortex_array::serde
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::serde::ArrayNodeFlatBuffer<'a>
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::DecimalScalar<'a>
+impl<'a> vortex_array::serde::ArrayNodeFlatBuffer<'a>
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::serde::ArrayNodeFlatBuffer<'a>::try_new(ctx: &'a vortex_array::ArrayContext, session: &'a vortex_session::VortexSession, array: &'a vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-impl<'a> core::hash::Hash for vortex_array::scalar::DecimalScalar<'a>
+pub fn vortex_array::serde::ArrayNodeFlatBuffer<'a>::try_write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<vortex_flatbuffers::array::ArrayNode<'fb>>>
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub struct vortex_array::serde::SerializeOptions
 
-impl<'a> core::marker::Copy for vortex_array::scalar::DecimalScalar<'a>
+pub vortex_array::serde::SerializeOptions::include_padding: bool
 
-pub struct vortex_array::scalar::ExtScalar<'a>
+pub vortex_array::serde::SerializeOptions::offset: usize
 
-impl<'a> vortex_array::scalar::ExtScalar<'a>
+impl core::default::Default for vortex_array::serde::SerializeOptions
 
-pub fn vortex_array::scalar::ExtScalar<'a>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::serde::SerializeOptions::default() -> vortex_array::serde::SerializeOptions
 
-pub fn vortex_array::scalar::ExtScalar<'a>::ext_dtype(&self) -> &'a vortex_array::dtype::extension::ExtDTypeRef
+impl core::fmt::Debug for vortex_array::serde::SerializeOptions
 
-pub fn vortex_array::scalar::ExtScalar<'a>::to_storage_scalar(&self) -> vortex_array::scalar::Scalar
+pub fn vortex_array::serde::SerializeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ExtScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::serde::SerializedArray
 
-impl core::cmp::Eq for vortex_array::scalar::ExtScalar<'_>
+impl vortex_array::serde::SerializedArray
 
-impl core::cmp::PartialEq for vortex_array::scalar::ExtScalar<'_>
+pub fn vortex_array::serde::SerializedArray::buffer(&self, idx: usize) -> vortex_error::VortexResult<vortex_array::buffer::BufferHandle>
 
-pub fn vortex_array::scalar::ExtScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::serde::SerializedArray::buffer_lengths(&self) -> alloc::vec::Vec<usize>
 
-impl core::cmp::PartialOrd for vortex_array::scalar::ExtScalar<'_>
+pub fn vortex_array::serde::SerializedArray::child(&self, idx: usize) -> vortex_array::serde::SerializedArray
 
-pub fn vortex_array::scalar::ExtScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::serde::SerializedArray::decode(&self, dtype: &vortex_array::dtype::DType, len: usize, ctx: &vortex_session::registry::ReadContext, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::fmt::Display for vortex_array::scalar::ExtScalar<'_>
+pub fn vortex_array::serde::SerializedArray::encoding_id(&self) -> u16
 
-pub fn vortex_array::scalar::ExtScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::serde::SerializedArray::from_array_tree(array_tree: impl core::convert::Into<vortex_buffer::ByteBuffer>) -> vortex_error::VortexResult<Self>
 
-impl core::hash::Hash for vortex_array::scalar::ExtScalar<'_>
+pub fn vortex_array::serde::SerializedArray::from_flatbuffer_and_segment(array_tree: vortex_buffer::ByteBuffer, segment: vortex_array::buffer::BufferHandle) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::ExtScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::serde::SerializedArray::from_flatbuffer_and_segment_with_overrides(array_tree: vortex_buffer::ByteBuffer, segment: vortex_array::buffer::BufferHandle, buffer_overrides: &vortex_utils::aliases::hash_map::HashMap<u32, vortex_buffer::ByteBuffer>) -> vortex_error::VortexResult<Self>
 
-impl<'a> core::clone::Clone for vortex_array::scalar::ExtScalar<'a>
+pub fn vortex_array::serde::SerializedArray::from_flatbuffer_with_buffers(array_tree: impl core::convert::Into<vortex_buffer::ByteBuffer>, buffers: alloc::vec::Vec<vortex_array::buffer::BufferHandle>) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::ExtScalar<'a>::clone(&self) -> vortex_array::scalar::ExtScalar<'a>
+pub fn vortex_array::serde::SerializedArray::metadata(&self) -> &[u8]
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ExtScalar<'a>
+pub fn vortex_array::serde::SerializedArray::nbuffers(&self) -> usize
 
-pub type vortex_array::scalar::ExtScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::serde::SerializedArray::nchildren(&self) -> usize
 
-pub fn vortex_array::scalar::ExtScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl core::clone::Clone for vortex_array::serde::SerializedArray
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::ExtScalar<'a>
+pub fn vortex_array::serde::SerializedArray::clone(&self) -> vortex_array::serde::SerializedArray
 
-pub fn vortex_array::scalar::ExtScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::convert::TryFrom<vortex_array::buffer::BufferHandle> for vortex_array::serde::SerializedArray
 
-pub struct vortex_array::scalar::ListScalar<'a>
+pub type vortex_array::serde::SerializedArray::Error = vortex_error::VortexError
 
-impl<'a> vortex_array::scalar::ListScalar<'a>
+pub fn vortex_array::serde::SerializedArray::try_from(value: vortex_array::buffer::BufferHandle) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::scalar::ListScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+impl core::convert::TryFrom<vortex_buffer::buffer::Buffer<u8>> for vortex_array::serde::SerializedArray
 
-pub fn vortex_array::scalar::ListScalar<'a>::element(&self, idx: usize) -> core::option::Option<vortex_array::scalar::Scalar>
+pub type vortex_array::serde::SerializedArray::Error = vortex_error::VortexError
 
-pub fn vortex_array::scalar::ListScalar<'a>::element_dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::serde::SerializedArray::try_from(value: vortex_buffer::ByteBuffer) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::scalar::ListScalar<'a>::elements(&self) -> core::option::Option<alloc::vec::Vec<vortex_array::scalar::Scalar>>
+impl core::fmt::Debug for vortex_array::serde::SerializedArray
 
-pub fn vortex_array::scalar::ListScalar<'a>::is_empty(&self) -> bool
+pub fn vortex_array::serde::SerializedArray::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ListScalar<'a>::is_null(&self) -> bool
+pub trait vortex_array::serde::ArrayChildren
 
-pub fn vortex_array::scalar::ListScalar<'a>::len(&self) -> usize
+pub fn vortex_array::serde::ArrayChildren::get(&self, index: usize, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::ListScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::serde::ArrayChildren::is_empty(&self) -> bool
 
-impl core::cmp::Eq for vortex_array::scalar::ListScalar<'_>
+pub fn vortex_array::serde::ArrayChildren::len(&self) -> usize
 
-impl core::cmp::PartialEq for vortex_array::scalar::ListScalar<'_>
+impl<T: core::convert::AsRef<[vortex_array::ArrayRef]>> vortex_array::serde::ArrayChildren for T
 
-pub fn vortex_array::scalar::ListScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn T::get(&self, index: usize, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl core::cmp::PartialOrd for vortex_array::scalar::ListScalar<'_>
+pub fn T::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar::ListScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn T::len(&self) -> usize
 
-impl core::fmt::Display for vortex_array::scalar::ListScalar<'_>
+pub mod vortex_array::session
 
-pub fn vortex_array::scalar::ListScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::session::ArraySession
 
-impl core::hash::Hash for vortex_array::scalar::ListScalar<'_>
+impl vortex_array::session::ArraySession
 
-pub fn vortex_array::scalar::ListScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::session::ArraySession::empty() -> vortex_array::session::ArraySession
 
-impl<'a> core::clone::Clone for vortex_array::scalar::ListScalar<'a>
+pub fn vortex_array::session::ArraySession::register<P: vortex_array::ArrayPlugin>(&self, plugin: P)
 
-pub fn vortex_array::scalar::ListScalar<'a>::clone(&self) -> vortex_array::scalar::ListScalar<'a>
+pub fn vortex_array::session::ArraySession::registry(&self) -> &vortex_array::session::ArrayRegistry
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ListScalar<'a>
+impl core::default::Default for vortex_array::session::ArraySession
 
-pub type vortex_array::scalar::ListScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::session::ArraySession::default() -> Self
 
-pub fn vortex_array::scalar::ListScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl core::fmt::Debug for vortex_array::session::ArraySession
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::ListScalar<'a>
+pub fn vortex_array::session::ArraySession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::ListScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub trait vortex_array::session::ArraySessionExt: vortex_session::SessionExt
 
-pub struct vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::session::ArraySessionExt::array_serialize(&self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<'a> vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::session::ArraySessionExt::arrays(&self) -> vortex_session::Ref<'_, vortex_array::session::ArraySession>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::as_<T: vortex_array::dtype::FromPrimitiveOrF16>(&self) -> core::option::Option<T>
+impl<S: vortex_session::SessionExt> vortex_array::session::ArraySessionExt for S
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::as_opt<T: vortex_array::dtype::FromPrimitiveOrF16>(&self) -> core::option::Option<core::option::Option<T>>
+pub fn S::array_serialize(&self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+pub fn S::arrays(&self) -> vortex_session::Ref<'_, vortex_array::session::ArraySession>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::is_nan(&self) -> bool
+pub type vortex_array::session::ArrayRegistry = vortex_session::registry::Registry<vortex_array::ArrayPluginRef>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::is_zero(&self) -> core::option::Option<bool>
+pub mod vortex_array::stats
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::ptype(&self) -> vortex_array::dtype::PType
+pub mod vortex_array::stats::flatbuffers
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::pvalue(&self) -> core::option::Option<vortex_array::scalar::PValue>
+pub struct vortex_array::stats::ArrayStats
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+impl vortex_array::stats::ArrayStats
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_typed_value<T: vortex_array::dtype::NativePType>(&self) -> vortex_error::VortexResult<core::option::Option<T>>
+pub fn vortex_array::stats::ArrayStats::clear(&self, stat: vortex_array::expr::stats::Stat)
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::typed_value<T: vortex_array::dtype::NativePType>(&self) -> core::option::Option<T>
+pub fn vortex_array::stats::ArrayStats::retain(&self, stats: &[vortex_array::expr::stats::Stat])
 
-impl<'a> vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::stats::ArrayStats::set(&self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::checked_binary_numeric(&self, other: &vortex_array::scalar::PrimitiveScalar<'a>, op: vortex_array::scalar::NumericOperator) -> core::option::Option<vortex_array::scalar::PrimitiveScalar<'a>>
+pub fn vortex_array::stats::ArrayStats::to_ref<'a>(&'a self, array: &'a vortex_array::ArrayRef) -> vortex_array::stats::StatsSetRef<'a>
 
-impl core::cmp::Eq for vortex_array::scalar::PrimitiveScalar<'_>
+impl core::clone::Clone for vortex_array::stats::ArrayStats
 
-impl core::cmp::PartialEq for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::ArrayStats::clone(&self) -> vortex_array::stats::ArrayStats
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::eq(&self, other: &Self) -> bool
+impl core::convert::From<vortex_array::stats::ArrayStats> for vortex_array::stats::StatsSet
 
-impl core::cmp::PartialOrd for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::StatsSet::from(value: vortex_array::stats::ArrayStats) -> Self
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+impl core::convert::From<vortex_array::stats::StatsSet> for vortex_array::stats::ArrayStats
 
-impl core::convert::From<vortex_array::scalar::PrimitiveScalar<'_>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::ArrayStats::from(value: vortex_array::stats::StatsSet) -> Self
 
-pub fn vortex_array::scalar::Scalar::from(ps: vortex_array::scalar::PrimitiveScalar<'_>) -> Self
+impl core::default::Default for vortex_array::stats::ArrayStats
 
-impl core::fmt::Display for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::ArrayStats::default() -> vortex_array::stats::ArrayStats
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Debug for vortex_array::stats::ArrayStats
 
-impl core::ops::arith::Add for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::ArrayStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::scalar::PrimitiveScalar<'_>::Output = vortex_array::scalar::PrimitiveScalar<'_>
+pub struct vortex_array::stats::MutTypedStatsSetRef<'a, 'b>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::add(self, rhs: Self) -> Self::Output
+pub vortex_array::stats::MutTypedStatsSetRef::dtype: &'b vortex_array::dtype::DType
 
-impl core::ops::arith::Sub for vortex_array::scalar::PrimitiveScalar<'_>
+pub vortex_array::stats::MutTypedStatsSetRef::values: &'a mut vortex_array::stats::StatsSet
 
-pub type vortex_array::scalar::PrimitiveScalar<'_>::Output = vortex_array::scalar::PrimitiveScalar<'_>
+impl vortex_array::stats::MutTypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::sub(self, rhs: Self) -> Self::Output
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::clear(&mut self, stat: vortex_array::expr::stats::Stat)
 
-impl num_traits::ops::checked::CheckedAdd for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::set(&mut self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::checked_add(&self, rhs: &Self) -> core::option::Option<Self>
+impl vortex_array::stats::MutTypedStatsSetRef<'_, '_>
 
-impl num_traits::ops::checked::CheckedSub for vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::combine_sets(&mut self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'_>::checked_sub(&self, rhs: &Self) -> core::option::Option<Self>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::merge_ordered(self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> Self
 
-impl<'a> core::clone::Clone for vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::merge_unordered(self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> Self
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::clone(&self) -> vortex_array::scalar::PrimitiveScalar<'a>
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
 
-pub type vortex_array::scalar::PrimitiveScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::len(&self) -> usize
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::PrimitiveScalar<'a>
+pub struct vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::stats::StatsSet
 
-impl<'a> core::hash::Hash for vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::stats::StatsSet::as_mut_typed_ref<'a, 'b>(&'a mut self, dtype: &'b vortex_array::dtype::DType) -> vortex_array::stats::MutTypedStatsSetRef<'a, 'b>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::stats::StatsSet::as_typed_ref<'a, 'b>(&'a self, dtype: &'b vortex_array::dtype::DType) -> vortex_array::stats::TypedStatsSetRef<'a, 'b>
 
-impl<'a> core::marker::Copy for vortex_array::scalar::PrimitiveScalar<'a>
+pub unsafe fn vortex_array::stats::StatsSet::new_unchecked(values: alloc::vec::Vec<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>) -> Self
 
-pub struct vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSet::of(stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>) -> Self
 
-impl vortex_array::scalar::Scalar
+impl vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::as_binary(&self) -> vortex_array::scalar::BinaryScalar<'_>
+pub fn vortex_array::stats::StatsSet::clear(&mut self, stat: vortex_array::expr::stats::Stat)
 
-pub fn vortex_array::scalar::Scalar::as_binary_opt(&self) -> core::option::Option<vortex_array::scalar::BinaryScalar<'_>>
+pub fn vortex_array::stats::StatsSet::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>>
 
-pub fn vortex_array::scalar::Scalar::as_bool(&self) -> vortex_array::scalar::BoolScalar<'_>
+pub fn vortex_array::stats::StatsSet::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat, dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
 
-pub fn vortex_array::scalar::Scalar::as_bool_opt(&self) -> core::option::Option<vortex_array::scalar::BoolScalar<'_>>
+pub fn vortex_array::stats::StatsSet::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar::Scalar::as_decimal(&self) -> vortex_array::scalar::DecimalScalar<'_>
+pub fn vortex_array::stats::StatsSet::iter(&self) -> impl core::iter::traits::iterator::Iterator<Item = &(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>
 
-pub fn vortex_array::scalar::Scalar::as_decimal_opt(&self) -> core::option::Option<vortex_array::scalar::DecimalScalar<'_>>
+pub fn vortex_array::stats::StatsSet::len(&self) -> usize
 
-pub fn vortex_array::scalar::Scalar::as_extension(&self) -> vortex_array::scalar::ExtScalar<'_>
+pub fn vortex_array::stats::StatsSet::retain_only(&mut self, stats: &[vortex_array::expr::stats::Stat])
 
-pub fn vortex_array::scalar::Scalar::as_extension_opt(&self) -> core::option::Option<vortex_array::scalar::ExtScalar<'_>>
+pub fn vortex_array::stats::StatsSet::set(&mut self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::Scalar::as_list(&self) -> vortex_array::scalar::ListScalar<'_>
+impl vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::as_list_opt(&self) -> core::option::Option<vortex_array::scalar::ListScalar<'_>>
+pub fn vortex_array::stats::StatsSet::combine_sets(&mut self, other: &Self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::Scalar::as_primitive(&self) -> vortex_array::scalar::PrimitiveScalar<'_>
+pub fn vortex_array::stats::StatsSet::merge_ordered(self, other: &Self, dtype: &vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar::Scalar::as_primitive_opt(&self) -> core::option::Option<vortex_array::scalar::PrimitiveScalar<'_>>
+pub fn vortex_array::stats::StatsSet::merge_unordered(self, other: &Self, dtype: &vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar::Scalar::as_struct(&self) -> vortex_array::scalar::StructScalar<'_>
+impl vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::as_struct_opt(&self) -> core::option::Option<vortex_array::scalar::StructScalar<'_>>
+pub fn vortex_array::stats::StatsSet::from_flatbuffer<'a>(fb: &vortex_flatbuffers::array::ArrayStats<'a>, array_dtype: &vortex_array::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::as_utf8(&self) -> vortex_array::scalar::Utf8Scalar<'_>
+impl core::clone::Clone for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::as_utf8_opt(&self) -> core::option::Option<vortex_array::scalar::Utf8Scalar<'_>>
+pub fn vortex_array::stats::StatsSet::clone(&self) -> vortex_array::stats::StatsSet
 
-impl vortex_array::scalar::Scalar
+impl core::convert::From<vortex_array::stats::ArrayStats> for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::binary(buffer: impl core::convert::Into<vortex_buffer::ByteBuffer>, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::stats::StatsSet::from(value: vortex_array::stats::ArrayStats) -> Self
 
-pub fn vortex_array::scalar::Scalar::bool(value: bool, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::convert::From<vortex_array::stats::StatsSet> for vortex_array::stats::ArrayStats
 
-pub fn vortex_array::scalar::Scalar::decimal(value: vortex_array::scalar::DecimalValue, decimal_type: vortex_array::dtype::DecimalDType, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::stats::ArrayStats::from(value: vortex_array::stats::StatsSet) -> Self
 
-pub fn vortex_array::scalar::Scalar::extension<V: vortex_array::dtype::extension::ExtVTable + core::default::Default>(options: <V as vortex_array::dtype::extension::ExtVTable>::Metadata, value: vortex_array::scalar::Scalar) -> Self
+impl core::default::Default for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::extension_ref(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, value: vortex_array::scalar::Scalar) -> Self
+pub fn vortex_array::stats::StatsSet::default() -> vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::fixed_size_list(element_dtype: impl core::convert::Into<alloc::sync::Arc<vortex_array::dtype::DType>>, children: alloc::vec::Vec<vortex_array::scalar::Scalar>, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::fmt::Debug for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::list(element_dtype: impl core::convert::Into<alloc::sync::Arc<vortex_array::dtype::DType>>, children: alloc::vec::Vec<vortex_array::scalar::Scalar>, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::stats::StatsSet::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar::Scalar::list_empty(element_dtype: alloc::sync::Arc<vortex_array::dtype::DType>, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::iter::traits::collect::Extend<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)> for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::primitive<T: vortex_array::dtype::NativePType + core::convert::Into<vortex_array::scalar::PValue>>(value: T, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::stats::StatsSet::extend<T: core::iter::traits::collect::IntoIterator<Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>>(&mut self, iter: T)
 
-pub fn vortex_array::scalar::Scalar::primitive_value(value: vortex_array::scalar::PValue, ptype: vortex_array::dtype::PType, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::iter::traits::collect::FromIterator<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)> for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::try_utf8<B>(str: B, nullability: vortex_array::dtype::Nullability) -> core::result::Result<Self, <B as core::convert::TryInto<vortex_buffer::string::BufferString>>::Error> where B: core::convert::TryInto<vortex_buffer::string::BufferString>
+pub fn vortex_array::stats::StatsSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>>(iter: T) -> Self
 
-pub fn vortex_array::scalar::Scalar::utf8<B>(str: B, nullability: vortex_array::dtype::Nullability) -> Self where B: core::convert::Into<vortex_buffer::string::BufferString>
+impl core::iter::traits::collect::IntoIterator for vortex_array::stats::StatsSet
 
-impl vortex_array::scalar::Scalar
+pub type vortex_array::stats::StatsSet::IntoIter = vortex_array::stats::StatsSetIntoIter
 
-pub fn vortex_array::scalar::Scalar::cast(&self, target_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::stats::StatsSet::Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::Scalar::into_nullable(self) -> vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSet::into_iter(self) -> Self::IntoIter
 
-impl vortex_array::scalar::Scalar
+impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::default_value(dtype: &vortex_array::dtype::DType) -> Self
+pub type vortex_array::stats::StatsSet::Target<'t> = vortex_flatbuffers::array::ArrayStats<'t>
 
-pub fn vortex_array::scalar::Scalar::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::stats::StatsSet::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
 
-pub fn vortex_array::scalar::Scalar::eq_ignore_nullability(&self, other: &Self) -> bool
+pub struct vortex_array::stats::StatsSetIntoIter(_)
 
-pub fn vortex_array::scalar::Scalar::into_parts(self) -> (vortex_array::dtype::DType, core::option::Option<vortex_array::scalar::ScalarValue>)
+impl core::iter::traits::iterator::Iterator for vortex_array::stats::StatsSetIntoIter
 
-pub fn vortex_array::scalar::Scalar::into_value(self) -> core::option::Option<vortex_array::scalar::ScalarValue>
+pub type vortex_array::stats::StatsSetIntoIter::Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::Scalar::is_compatible(dtype: &vortex_array::dtype::DType, value: core::option::Option<&vortex_array::scalar::ScalarValue>) -> bool
+pub fn vortex_array::stats::StatsSetIntoIter::next(&mut self) -> core::option::Option<Self::Item>
 
-pub fn vortex_array::scalar::Scalar::is_null(&self) -> bool
+pub struct vortex_array::stats::StatsSetRef<'a>
 
-pub fn vortex_array::scalar::Scalar::is_valid(&self) -> bool
+impl vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::scalar::Scalar::is_zero(&self) -> core::option::Option<bool>
+pub fn vortex_array::stats::StatsSetRef<'_>::clear(&self, stat: vortex_array::expr::stats::Stat)
 
-pub fn vortex_array::scalar::Scalar::nbytes(&self) -> usize
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_as<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<U>
 
-pub unsafe fn vortex_array::scalar::Scalar::new_unchecked(dtype: vortex_array::dtype::DType, value: core::option::Option<vortex_array::scalar::ScalarValue>) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_constant(&self) -> core::option::Option<bool>
 
-pub fn vortex_array::scalar::Scalar::null(dtype: vortex_array::dtype::DType) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_sorted(&self) -> core::option::Option<bool>
 
-pub fn vortex_array::scalar::Scalar::null_native<T: vortex_array::dtype::NativeDType>() -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_strict_sorted(&self) -> core::option::Option<bool>
 
-pub fn vortex_array::scalar::Scalar::primitive_reinterpret_cast(&self, ptype: vortex_array::dtype::PType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_max<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self) -> core::option::Option<U>
 
-pub fn vortex_array::scalar::Scalar::try_new(dtype: vortex_array::dtype::DType, value: core::option::Option<vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_min<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self) -> core::option::Option<U>
 
-pub fn vortex_array::scalar::Scalar::value(&self) -> core::option::Option<&vortex_array::scalar::ScalarValue>
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_null_count(&self) -> core::option::Option<usize>
 
-pub fn vortex_array::scalar::Scalar::zero_value(dtype: &vortex_array::dtype::DType) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_uncompressed_size_in_bytes(&self) -> core::option::Option<usize>
 
-impl vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::set(&self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
 
-pub fn vortex_array::scalar::Scalar::from_proto(value: &vortex_proto::scalar::Scalar, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
+impl vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::scalar::Scalar::from_proto_value(value: &vortex_proto::scalar::ScalarValue, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_all(&self, stats: &[vortex_array::expr::stats::Stat]) -> vortex_error::VortexResult<vortex_array::stats::StatsSet>
 
-impl vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::compute_stat(&self, stat: vortex_array::expr::stats::Stat) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::Scalar>>
 
-pub fn vortex_array::scalar::Scalar::struct_(dtype: vortex_array::dtype::DType, children: alloc::vec::Vec<vortex_array::scalar::Scalar>) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::inherit<'a>(&self, iter: impl core::iter::traits::iterator::Iterator<Item = &'a (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>)
 
-impl core::clone::Clone for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::inherit_from(&self, stats: vortex_array::stats::StatsSetRef<'_>)
 
-pub fn vortex_array::scalar::Scalar::clone(&self) -> vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::set_iter(&self, iter: vortex_array::stats::StatsSetIntoIter)
 
-impl core::cmp::Eq for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::to_array_stats(&self) -> vortex_array::stats::ArrayStats
 
-impl core::cmp::PartialEq for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::to_owned(&self) -> vortex_array::stats::StatsSet
 
-pub fn vortex_array::scalar::Scalar::eq(&self, other: &Self) -> bool
+pub fn vortex_array::stats::StatsSetRef<'_>::with_iter<F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &'a (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>) -> R, R>(&self, f: F) -> R
 
-impl core::cmp::PartialOrd for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::with_mut_typed_stats_set<U, F: core::ops::function::FnOnce(vortex_array::stats::MutTypedStatsSetRef<'_, '_>) -> U>(&self, apply: F) -> U
 
-pub fn vortex_array::scalar::Scalar::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::stats::StatsSetRef<'_>::with_typed_stats_set<U, F: core::ops::function::FnOnce(vortex_array::stats::TypedStatsSetRef<'_, '_>) -> U>(&self, apply: F) -> U
 
-impl core::convert::From<&[u8]> for vortex_array::scalar::Scalar
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::scalar::Scalar::from(value: &[u8]) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
 
-impl core::convert::From<&str> for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar::Scalar::from(value: &str) -> Self
+pub fn vortex_array::stats::StatsSetRef<'_>::len(&self) -> usize
 
-impl core::convert::From<&vortex_array::scalar::Scalar> for vortex_proto::scalar::Scalar
+impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_proto::scalar::Scalar::from(value: &vortex_array::scalar::Scalar) -> Self
+pub type vortex_array::stats::StatsSetRef<'_>::Target<'t> = vortex_flatbuffers::array::ArrayStats<'t>
 
-impl core::convert::From<alloc::string::String> for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::StatsSetRef<'_>::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
 
-pub fn vortex_array::scalar::Scalar::from(value: alloc::string::String) -> Self
+pub struct vortex_array::stats::TypedStatsSetRef<'a, 'b>
 
-impl core::convert::From<bool> for vortex_array::scalar::Scalar
+pub vortex_array::stats::TypedStatsSetRef::dtype: &'b vortex_array::dtype::DType
 
-pub fn vortex_array::scalar::Scalar::from(value: bool) -> Self
+pub vortex_array::stats::TypedStatsSetRef::values: &'a vortex_array::stats::StatsSet
 
-impl core::convert::From<core::option::Option<&[u8]>> for vortex_array::scalar::Scalar
+impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<&[u8]>) -> Self
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
 
-impl core::convert::From<core::option::Option<&str>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<&str>) -> Self
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::len(&self) -> usize
 
-impl core::convert::From<core::option::Option<alloc::string::String>> for vortex_array::scalar::Scalar
+pub const vortex_array::stats::PRUNING_STATS: &[vortex_array::expr::stats::Stat]
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<alloc::string::String>) -> Self
+pub fn vortex_array::stats::as_stat_bitset_bytes(stats: &[vortex_array::expr::stats::Stat]) -> alloc::vec::Vec<u8>
 
-impl core::convert::From<core::option::Option<bool>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stats::stats_from_bitset_bytes(bytes: &[u8]) -> alloc::vec::Vec<vortex_array::expr::stats::Stat>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<bool>) -> Self
+pub mod vortex_array::stream
 
-impl core::convert::From<core::option::Option<f32>> for vortex_array::scalar::Scalar
+pub struct vortex_array::stream::ArrayStreamAdapter<S>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<f32>) -> Self
+impl<S> vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
 
-impl core::convert::From<core::option::Option<f64>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stream::ArrayStreamAdapter<S>::new(dtype: vortex_array::dtype::DType, inner: S) -> Self
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<f64>) -> Self
+impl<'__pin, S> core::marker::Unpin for vortex_array::stream::ArrayStreamAdapter<S> where pin_project_lite::__private::PinnedFieldsOf<__Origin<'__pin, S>>: core::marker::Unpin
 
-impl core::convert::From<core::option::Option<half::binary16::f16>> for vortex_array::scalar::Scalar
+impl<S> futures_core::stream::Stream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<half::binary16::f16>) -> Self
+pub type vortex_array::stream::ArrayStreamAdapter<S>::Item = core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
 
-impl core::convert::From<core::option::Option<i16>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stream::ArrayStreamAdapter<S>::poll_next(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<core::option::Option<Self::Item>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i16>) -> Self
+pub fn vortex_array::stream::ArrayStreamAdapter<S>::size_hint(&self) -> (usize, core::option::Option<usize>)
 
-impl core::convert::From<core::option::Option<i32>> for vortex_array::scalar::Scalar
+impl<S> vortex_array::stream::ArrayStream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i32>) -> Self
+pub fn vortex_array::stream::ArrayStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::convert::From<core::option::Option<i64>> for vortex_array::scalar::Scalar
+pub trait vortex_array::stream::ArrayStream: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i64>) -> Self
+pub fn vortex_array::stream::ArrayStream::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::convert::From<core::option::Option<i8>> for vortex_array::scalar::Scalar
+impl vortex_array::stream::ArrayStream for vortex_array::stream::SendableArrayStream
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<i8>) -> Self
+pub fn vortex_array::stream::SendableArrayStream::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::convert::From<core::option::Option<u16>> for vortex_array::scalar::Scalar
+impl<S> vortex_array::stream::ArrayStream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u16>) -> Self
+pub fn vortex_array::stream::ArrayStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::convert::From<core::option::Option<u32>> for vortex_array::scalar::Scalar
+pub trait vortex_array::stream::ArrayStreamExt: vortex_array::stream::ArrayStream
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u32>) -> Self
+pub fn vortex_array::stream::ArrayStreamExt::boxed(self) -> vortex_array::stream::SendableArrayStream where Self: core::marker::Sized + core::marker::Send + 'static
 
-impl core::convert::From<core::option::Option<u64>> for vortex_array::scalar::Scalar
+pub fn vortex_array::stream::ArrayStreamExt::read_all(self) -> impl core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::ArrayRef>> where Self: core::marker::Sized
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u64>) -> Self
+impl<S: vortex_array::stream::ArrayStream> vortex_array::stream::ArrayStreamExt for S
 
-impl core::convert::From<core::option::Option<u8>> for vortex_array::scalar::Scalar
+pub fn S::boxed(self) -> vortex_array::stream::SendableArrayStream where Self: core::marker::Sized + core::marker::Send + 'static
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<u8>) -> Self
+pub fn S::read_all(self) -> impl core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::ArrayRef>> where Self: core::marker::Sized
 
-impl core::convert::From<core::option::Option<usize>> for vortex_array::scalar::Scalar
+pub type vortex_array::stream::SendableArrayStream = core::pin::Pin<alloc::boxed::Box<(dyn vortex_array::stream::ArrayStream + core::marker::Send)>>
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<usize>) -> Self
+pub mod vortex_array::validity
 
-impl core::convert::From<core::option::Option<vortex_array::scalar::DecimalValue>> for vortex_array::scalar::Scalar
+pub enum vortex_array::validity::Validity
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_array::scalar::DecimalValue>) -> Self
+pub vortex_array::validity::Validity::AllInvalid
 
-impl core::convert::From<core::option::Option<vortex_buffer::buffer::Buffer<u8>>> for vortex_array::scalar::Scalar
+pub vortex_array::validity::Validity::AllValid
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_buffer::ByteBuffer>) -> Self
+pub vortex_array::validity::Validity::Array(vortex_array::ArrayRef)
 
-impl core::convert::From<core::option::Option<vortex_buffer::string::BufferString>> for vortex_array::scalar::Scalar
+pub vortex_array::validity::Validity::NonNullable
 
-pub fn vortex_array::scalar::Scalar::from(value: core::option::Option<vortex_buffer::string::BufferString>) -> Self
+impl vortex_array::validity::Validity
 
-impl core::convert::From<f32> for vortex_array::scalar::Scalar
+pub const vortex_array::validity::Validity::DTYPE: vortex_array::dtype::DType
 
-pub fn vortex_array::scalar::Scalar::from(value: f32) -> Self
+pub fn vortex_array::validity::Validity::and(self, rhs: vortex_array::validity::Validity) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::convert::From<f64> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::as_array(&self) -> core::option::Option<&vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar::Scalar::from(value: f64) -> Self
+pub fn vortex_array::validity::Validity::cast_nullability(self, nullability: vortex_array::dtype::Nullability, len: usize) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::convert::From<half::binary16::f16> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::copy_from_array(array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::from(value: half::binary16::f16) -> Self
+pub fn vortex_array::validity::Validity::execute_mask(&self, length: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_mask::Mask>
 
-impl core::convert::From<i16> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::filter(&self, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::from(value: i16) -> Self
+pub fn vortex_array::validity::Validity::into_array(self) -> core::option::Option<vortex_array::ArrayRef>
 
-impl core::convert::From<i32> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::into_non_nullable(self, len: usize) -> core::option::Option<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar::Scalar::from(value: i32) -> Self
+pub fn vortex_array::validity::Validity::into_nullable(self) -> vortex_array::validity::Validity
 
-impl core::convert::From<i64> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::is_null(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::scalar::Scalar::from(value: i64) -> Self
+pub fn vortex_array::validity::Validity::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-impl core::convert::From<i8> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::mask_eq(&self, other: &vortex_array::validity::Validity, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::scalar::Scalar::from(value: i8) -> Self
+pub fn vortex_array::validity::Validity::maybe_len(&self) -> core::option::Option<usize>
 
-impl core::convert::From<u16> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::not(&self) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::from(value: u16) -> Self
+pub fn vortex_array::validity::Validity::nullability(&self) -> vortex_array::dtype::Nullability
 
-impl core::convert::From<u32> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::patch(self, len: usize, indices_offset: usize, indices: &vortex_array::ArrayRef, patches: &vortex_array::validity::Validity, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::from(value: u32) -> Self
+pub fn vortex_array::validity::Validity::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<Self>
 
-impl core::convert::From<u64> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::take(&self, indices: &vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar::Scalar::from(value: u64) -> Self
+pub fn vortex_array::validity::Validity::to_array(&self, len: usize) -> vortex_array::ArrayRef
 
-impl core::convert::From<u8> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::to_mask(&self, length: usize) -> vortex_mask::Mask
 
-pub fn vortex_array::scalar::Scalar::from(value: u8) -> Self
+pub fn vortex_array::validity::Validity::uncompressed_size(&self) -> usize
 
-impl core::convert::From<usize> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::union_nullability(self, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::scalar::Scalar::from(value: usize) -> Self
+impl vortex_array::validity::Validity
 
-impl core::convert::From<vortex_array::scalar::DecimalScalar<'_>> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::execute(self, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar::Scalar::from(ds: vortex_array::scalar::DecimalScalar<'_>) -> Self
+impl vortex_array::validity::Validity
 
-impl core::convert::From<vortex_array::scalar::DecimalValue> for vortex_array::scalar::Scalar
+pub fn vortex_array::validity::Validity::from_bit_buffer(buffer: vortex_buffer::bit::buf::BitBuffer, nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::scalar::Scalar::from(value: vortex_array::scalar::DecimalValue) -> Self
+pub fn vortex_array::validity::Validity::from_mask(mask: vortex_mask::Mask, nullability: vortex_array::dtype::Nullability) -> Self
 
-impl core::convert::From<vortex_array::scalar::PrimitiveScalar<'_>> for vortex_array::scalar::Scalar
+impl core::clone::Clone for vortex_array::validity::Validity
 
-pub fn vortex_array::scalar::Scalar::from(ps: vortex_array::scalar::PrimitiveScalar<'_>) -> Self
+pub fn vortex_array::validity::Validity::clone(&self) -> vortex_array::validity::Validity
 
-impl core::convert::From<vortex_array::scalar::Scalar> for vortex_array::compute::Output
+impl core::convert::From<&vortex_array::dtype::Nullability> for vortex_array::validity::Validity
 
-pub fn vortex_array::compute::Output::from(value: vortex_array::scalar::Scalar) -> Self
+pub fn vortex_array::validity::Validity::from(value: &vortex_array::dtype::Nullability) -> Self
 
-impl core::convert::From<vortex_buffer::buffer::Buffer<u8>> for vortex_array::scalar::Scalar
+impl core::convert::From<vortex_array::dtype::Nullability> for vortex_array::validity::Validity
 
-pub fn vortex_array::scalar::Scalar::from(value: vortex_buffer::ByteBuffer) -> Self
+pub fn vortex_array::validity::Validity::from(value: vortex_array::dtype::Nullability) -> Self
 
-impl core::convert::From<vortex_buffer::string::BufferString> for vortex_array::scalar::Scalar
+impl core::convert::From<vortex_buffer::bit::buf::BitBuffer> for vortex_array::validity::Validity
 
-pub fn vortex_array::scalar::Scalar::from(value: vortex_buffer::string::BufferString) -> Self
+pub fn vortex_array::validity::Validity::from(value: vortex_buffer::bit::buf::BitBuffer) -> Self
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for alloc::sync::Arc<dyn arrow_array::scalar::Datum>
+impl core::fmt::Debug for vortex_array::validity::Validity
 
-pub type alloc::sync::Arc<dyn arrow_array::scalar::Datum>::Error = vortex_error::VortexError
+pub fn vortex_array::validity::Validity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn alloc::sync::Arc<dyn arrow_array::scalar::Datum>::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<alloc::sync::Arc<dyn arrow_array::scalar::Datum>, Self::Error>
+impl core::iter::traits::collect::FromIterator<bool> for vortex_array::validity::Validity
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for bool
+pub fn vortex_array::validity::Validity::from_iter<T: core::iter::traits::collect::IntoIterator<Item = bool>>(iter: T) -> Self
 
-pub type bool::Error = vortex_error::VortexError
+impl core::iter::traits::collect::FromIterator<vortex_mask::Mask> for vortex_array::validity::Validity
 
-pub fn bool::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::validity::Validity::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_mask::Mask>>(iter: T) -> Self
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<bool>
+impl vortex_array::ArrayEq for vortex_array::validity::Validity
 
-pub type core::option::Option<bool>::Error = vortex_error::VortexError
+pub fn vortex_array::validity::Validity::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn core::option::Option<bool>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::ArrayHash for vortex_array::validity::Validity
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<f32>
+pub fn vortex_array::validity::Validity::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub type core::option::Option<f32>::Error = vortex_error::VortexError
+pub mod vortex_array::variants
 
-pub fn core::option::Option<f32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::variants::BinaryTyped<'a>(_)
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<f64>
+pub struct vortex_array::variants::BoolTyped<'a>(_)
 
-pub type core::option::Option<f64>::Error = vortex_error::VortexError
+impl vortex_array::variants::BoolTyped<'_>
 
-pub fn core::option::Option<f64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::BoolTyped<'_>::true_count(&self) -> vortex_error::VortexResult<usize>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<half::binary16::f16>
+pub struct vortex_array::variants::DecimalTyped<'a>(_)
 
-pub type core::option::Option<half::binary16::f16>::Error = vortex_error::VortexError
+pub struct vortex_array::variants::ExtensionTyped<'a>(_)
 
-pub fn core::option::Option<half::binary16::f16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::variants::ExtensionTyped<'_>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i16>
+pub fn vortex_array::variants::ExtensionTyped<'_>::ext_dtype(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
 
-pub type core::option::Option<i16>::Error = vortex_error::VortexError
+pub struct vortex_array::variants::ListTyped<'a>(_)
 
-pub fn core::option::Option<i16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::variants::NullTyped<'a>(_)
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i32>
+pub struct vortex_array::variants::PrimitiveTyped<'a>(_)
 
-pub type core::option::Option<i32>::Error = vortex_error::VortexError
+impl vortex_array::variants::PrimitiveTyped<'_>
 
-pub fn core::option::Option<i32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::ptype(&self) -> vortex_array::dtype::PType
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i64>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::value(&self, idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::PValue>>
 
-pub type core::option::Option<i64>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::value_unchecked(&self, idx: usize) -> vortex_error::VortexResult<vortex_array::scalar::PValue>
 
-pub fn core::option::Option<i64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::search_sorted::IndexOrd<core::option::Option<vortex_array::scalar::PValue>> for vortex_array::variants::PrimitiveTyped<'_>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<i8>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &core::option::Option<vortex_array::scalar::PValue>) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-pub type core::option::Option<i8>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<i8>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u16>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<u16>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
 
-pub fn core::option::Option<u16>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u32>
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
 
-pub type core::option::Option<u32>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-pub fn core::option::Option<u32>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u64>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<u64>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn core::option::Option<u64>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<u8>
+pub fn vortex_array::variants::PrimitiveTyped<'_>::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub type core::option::Option<u8>::Error = vortex_error::VortexError
+pub struct vortex_array::variants::StructTyped<'a>(_)
 
-pub fn core::option::Option<u8>::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::variants::StructTyped<'_>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<usize>
+pub fn vortex_array::variants::StructTyped<'_>::dtypes(&self) -> alloc::vec::Vec<vortex_array::dtype::DType>
 
-pub type core::option::Option<usize>::Error = vortex_error::VortexError
+pub fn vortex_array::variants::StructTyped<'_>::names(&self) -> &vortex_array::dtype::FieldNames
 
-pub fn core::option::Option<usize>::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::variants::StructTyped<'_>::nfields(&self) -> usize
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for core::option::Option<vortex_array::scalar::DecimalValue>
+pub struct vortex_array::variants::Utf8Typed<'a>(_)
 
-pub type core::option::Option<vortex_array::scalar::DecimalValue>::Error = vortex_error::VortexError
+pub mod vortex_array::vtable
 
-pub fn core::option::Option<vortex_array::scalar::DecimalValue>::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub struct vortex_array::vtable::EmptyArrayData
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for f32
+impl core::clone::Clone for vortex_array::EmptyArrayData
 
-pub type f32::Error = vortex_error::VortexError
+pub fn vortex_array::EmptyArrayData::clone(&self) -> vortex_array::EmptyArrayData
 
-pub fn f32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl core::default::Default for vortex_array::EmptyArrayData
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for f64
+pub fn vortex_array::EmptyArrayData::default() -> vortex_array::EmptyArrayData
 
-pub type f64::Error = vortex_error::VortexError
+impl core::fmt::Debug for vortex_array::EmptyArrayData
 
-pub fn f64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::EmptyArrayData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for half::binary16::f16
+impl core::fmt::Display for vortex_array::EmptyArrayData
 
-pub type half::binary16::f16::Error = vortex_error::VortexError
+pub fn vortex_array::EmptyArrayData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn half::binary16::f16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::ArrayEq for vortex_array::EmptyArrayData
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i16
+pub fn vortex_array::EmptyArrayData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub type i16::Error = vortex_error::VortexError
+impl vortex_array::ArrayHash for vortex_array::EmptyArrayData
 
-pub fn i16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::EmptyArrayData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i32
+pub struct vortex_array::vtable::NotSupported
 
-pub type i32::Error = vortex_error::VortexError
+impl<V: vortex_array::VTable> vortex_array::OperationsVTable<V> for vortex_array::NotSupported
 
-pub fn i32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::NotSupported::scalar_at(array: vortex_array::ArrayView<'_, V>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i64
+pub struct vortex_array::vtable::ValidityVTableFromChild
 
-pub type i64::Error = vortex_error::VortexError
+impl<V> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChild where V: vortex_array::ValidityChild<V> + vortex_array::VTable
 
-pub fn i64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ValidityVTableFromChild::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for i8
+pub struct vortex_array::vtable::ValidityVTableFromChildSliceHelper
 
-pub type i8::Error = vortex_error::VortexError
+impl<V: vortex_array::VTable> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChildSliceHelper where <V as vortex_array::VTable>::ArrayData: vortex_array::ValidityChildSliceHelper
 
-pub fn i8::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ValidityVTableFromChildSliceHelper::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u16
+pub trait vortex_array::vtable::ArrayPlugin: 'static + core::marker::Send + core::marker::Sync
 
-pub type u16::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayPlugin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn u16::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::vtable::ArrayPlugin::id(&self) -> vortex_array::ArrayId
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u32
+pub fn vortex_array::vtable::ArrayPlugin::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type u32::Error = vortex_error::VortexError
+impl<V: vortex_array::VTable> vortex_array::ArrayPlugin for V
 
-pub fn u32::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn V::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u64
+pub fn V::id(&self) -> arcref::ArcRef<str>
 
-pub type u64::Error = vortex_error::VortexError
+pub fn V::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> core::result::Result<core::option::Option<alloc::vec::Vec<u8>>, vortex_error::VortexError>
 
-pub fn u64::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub trait vortex_array::vtable::ArrayVTable: 'static + core::clone::Clone + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for u8
+pub type vortex_array::vtable::ArrayVTable::ArrayData: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + vortex_array::ArrayHash + vortex_array::ArrayEq
 
-pub type u8::Error = vortex_error::VortexError
+pub type vortex_array::vtable::ArrayVTable::OperationsVTable: vortex_array::OperationsVTable<Self>
 
-pub fn u8::try_from(value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub type vortex_array::vtable::ArrayVTable::ValidityVTable: vortex_array::ValidityVTable<Self>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for usize
+pub fn vortex_array::vtable::ArrayVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type usize::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayVTable::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn usize::try_from(value: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::vtable::ArrayVTable::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::convert::TryFrom<&vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::vtable::ArrayVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar::DecimalValue::try_from(scalar: &vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::vtable::ArrayVTable::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for alloc::string::String
+pub fn vortex_array::vtable::ArrayVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type alloc::string::String::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::string::String::try_from(value: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::vtable::ArrayVTable::id(&self) -> vortex_array::ArrayId
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for bool
+pub fn vortex_array::vtable::ArrayVTable::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type bool::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn bool::try_from(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::vtable::ArrayVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<bool>
+pub fn vortex_array::vtable::ArrayVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type core::option::Option<bool>::Error = vortex_error::VortexError
+pub fn vortex_array::vtable::ArrayVTable::serialize(array: vortex_array::ArrayView<'_, Self>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn core::option::Option<bool>::try_from(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::vtable::ArrayVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_array::scalar::DecimalValue>
+pub fn vortex_array::vtable::ArrayVTable::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type core::option::Option<vortex_array::scalar::DecimalValue>::Error = vortex_error::VortexError
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-pub fn core::option::Option<vortex_array::scalar::DecimalValue>::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::ByteBuffer>
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-pub type core::option::Option<vortex_buffer::ByteBuffer>::Error = vortex_error::VortexError
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-pub fn core::option::Option<vortex_buffer::ByteBuffer>::try_from(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::string::BufferString>
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type core::option::Option<vortex_buffer::string::BufferString>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn core::option::Option<vortex_buffer::string::BufferString>::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalValue
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::scalar::DecimalValue::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar::DecimalValue::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_buffer::ByteBuffer::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_buffer::ByteBuffer::try_from(scalar: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::convert::TryFrom<vortex_array::scalar::Scalar> for vortex_buffer::string::BufferString
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_buffer::string::BufferString::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_buffer::string::BufferString::try_from(scalar: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::Scalar::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::fmt::Display for vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::Scalar::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-impl core::hash::Hash for vortex_array::scalar::Scalar
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::scalar::Scalar::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::Scalar> for (dyn vortex_array::Array + '_)
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-pub fn (dyn vortex_array::Array + '_)::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn (dyn vortex_array::Array + '_)::index_len(&self) -> usize
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<'a, T> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for alloc::vec::Vec<T> where T: for<'b> core::convert::TryFrom<&'b vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type alloc::vec::Vec<T>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn alloc::vec::Vec<T>::try_from(value: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<'a> core::convert::From<&'a vortex_array::scalar::Scalar> for vortex_array::compute::Input<'a>
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::compute::Input<'a>::from(value: &'a vortex_array::scalar::Scalar) -> Self
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for alloc::string::String
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type alloc::string::String::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-pub fn alloc::string::String::try_from(value: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type core::option::Option<vortex_buffer::ByteBuffer>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn core::option::Option<vortex_buffer::ByteBuffer>::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for core::option::Option<vortex_buffer::string::BufferString>
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type core::option::Option<vortex_buffer::string::BufferString>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn core::option::Option<vortex_buffer::string::BufferString>::try_from(scalar: &'a vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BinaryScalar<'a>
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-pub type vortex_array::scalar::BinaryScalar<'a>::Error = vortex_error::VortexError
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::scalar::BinaryScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::BoolScalar<'a>
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub type vortex_array::scalar::BoolScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::BoolScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::DecimalScalar<'a>
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::scalar::DecimalScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar::DecimalScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ExtScalar<'a>
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::scalar::ExtScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar::ExtScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::ListScalar<'a>
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::scalar::ListScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar::ListScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::PrimitiveScalar<'a>
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar::PrimitiveScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::PrimitiveScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::scalar::StructScalar<'a>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::StructScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::Utf8Scalar<'a>
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-pub type vortex_array::scalar::Utf8Scalar<'a>::Error = vortex_error::VortexError
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_buffer::ByteBuffer::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_buffer::ByteBuffer::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_buffer::string::BufferString
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_buffer::string::BufferString::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_buffer::string::BufferString::try_from(scalar: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<T> core::convert::From<alloc::vec::Vec<T>> for vortex_array::scalar::Scalar where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar::Scalar::from(vec: alloc::vec::Vec<T>) -> Self
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<T> core::convert::From<core::option::Option<alloc::vec::Vec<T>>> for vortex_array::scalar::Scalar where T: vortex_array::dtype::NativeDType, vortex_array::scalar::Scalar: core::convert::From<T>
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar::Scalar::from(vec: core::option::Option<alloc::vec::Vec<T>>) -> Self
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<T> core::convert::TryFrom<vortex_array::scalar::Scalar> for alloc::vec::Vec<T> where T: for<'b> core::convert::TryFrom<&'b vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type alloc::vec::Vec<T>::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::vec::Vec<T>::try_from(value: vortex_array::scalar::Scalar) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<'a> vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar::StructScalar<'a>::cast(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::StructScalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-pub fn vortex_array::scalar::StructScalar<'a>::field(&self, name: impl core::convert::AsRef<str>) -> core::option::Option<vortex_array::scalar::Scalar>
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::scalar::StructScalar<'a>::field_by_idx(&self, idx: usize) -> core::option::Option<vortex_array::scalar::Scalar>
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-pub fn vortex_array::scalar::StructScalar<'a>::fields_iter(&self) -> core::option::Option<impl core::iter::traits::exact_size::ExactSizeIterator<Item = vortex_array::scalar::Scalar>>
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::scalar::StructScalar<'a>::is_null(&self) -> bool
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::StructScalar<'a>::names(&self) -> &vortex_array::dtype::FieldNames
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar::StructScalar<'a>::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar::StructScalar<'a>::struct_fields(&self) -> &vortex_array::dtype::StructFields
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::cmp::Eq for vortex_array::scalar::StructScalar<'_>
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::cmp::PartialEq for vortex_array::scalar::StructScalar<'_>
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar::StructScalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::PartialOrd for vortex_array::scalar::StructScalar<'_>
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::StructScalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-impl core::fmt::Display for vortex_array::scalar::StructScalar<'_>
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar::StructScalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::hash::Hash for vortex_array::scalar::StructScalar<'_>
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::StructScalar<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<'a> core::clone::Clone for vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::StructScalar<'a>::clone(&self) -> vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::StructScalar<'a>
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::scalar::StructScalar<'a>::Error = vortex_error::VortexError
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-pub fn vortex_array::scalar::StructScalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::StructScalar<'a>
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-pub fn vortex_array::scalar::StructScalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-pub struct vortex_array::scalar::Utf8Scalar<'a>
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<'a> vortex_array::scalar::Utf8Scalar<'a>
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::dtype(&self) -> &'a vortex_array::dtype::DType
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::is_empty(&self) -> core::option::Option<bool>
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::len(&self) -> core::option::Option<usize>
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::try_new(dtype: &'a vortex_array::dtype::DType, value: core::option::Option<&'a vortex_array::scalar::ScalarValue>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::value(&self) -> core::option::Option<&'a vortex_buffer::string::BufferString>
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::Ord for vortex_array::scalar::Utf8Scalar<'_>
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Utf8Scalar<'_>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-impl core::cmp::PartialEq for vortex_array::scalar::Utf8Scalar<'_>
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar::Utf8Scalar<'_>::eq(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::cmp::PartialOrd for vortex_array::scalar::Utf8Scalar<'_>
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::Utf8Scalar<'_>::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Display for vortex_array::scalar::Utf8Scalar<'_>
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar::Utf8Scalar<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<'a> core::clone::Clone for vortex_array::scalar::Utf8Scalar<'a>
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::clone(&self) -> vortex_array::scalar::Utf8Scalar<'a>
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-impl<'a> core::cmp::Eq for vortex_array::scalar::Utf8Scalar<'a>
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-impl<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar> for vortex_array::scalar::Utf8Scalar<'a>
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub type vortex_array::scalar::Utf8Scalar<'a>::Error = vortex_error::VortexError
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::try_from(value: &'a vortex_array::scalar::Scalar) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<'a> core::fmt::Debug for vortex_array::scalar::Utf8Scalar<'a>
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<'a> core::hash::Hash for vortex_array::scalar::Utf8Scalar<'a>
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar::Utf8Scalar<'a>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::scalar::ScalarTruncation: core::marker::Send + core::marker::Sized
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar::ScalarTruncation::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar::ScalarTruncation::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar::ScalarTruncation::len(&self) -> usize
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar::ScalarTruncation::lower_bound(self, max_length: usize) -> Self
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar::ScalarTruncation::upper_bound(self, max_length: usize) -> core::option::Option<Self>
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar::ScalarTruncation for vortex_buffer::ByteBuffer
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_buffer::ByteBuffer::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_buffer::ByteBuffer::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_buffer::ByteBuffer::len(&self) -> usize
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_buffer::ByteBuffer::lower_bound(self, max_length: usize) -> Self
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_buffer::ByteBuffer::upper_bound(self, max_length: usize) -> core::option::Option<Self>
+impl vortex_array::VTable for vortex_array::arrays::List
 
-impl vortex_array::scalar::ScalarTruncation for vortex_buffer::string::BufferString
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-pub fn vortex_buffer::string::BufferString::from_scalar(value: vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<Self>>
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-pub fn vortex_buffer::string::BufferString::into_scalar(self, nullability: vortex_array::dtype::Nullability) -> vortex_array::scalar::Scalar
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub fn vortex_buffer::string::BufferString::len(&self) -> usize
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_buffer::string::BufferString::lower_bound(self, max_length: usize) -> Self
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_buffer::string::BufferString::upper_bound(self, max_length: usize) -> core::option::Option<Self>
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub trait vortex_array::scalar::StringLike: vortex_array::scalar::typed_view::utf8::private::Sealed + core::marker::Sized
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar::StringLike::increment(self) -> core::result::Result<Self, Self>
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar::StringLike for alloc::string::String
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn alloc::string::String::increment(self) -> core::result::Result<alloc::string::String, alloc::string::String>
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::scalar::StringLike for vortex_buffer::string::BufferString
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_buffer::string::BufferString::increment(self) -> core::result::Result<vortex_buffer::string::BufferString, vortex_buffer::string::BufferString>
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar::lower_bound(value: core::option::Option<impl vortex_array::scalar::ScalarTruncation>, max_length: usize, nullability: vortex_array::dtype::Nullability) -> core::option::Option<(vortex_array::scalar::Scalar, bool)>
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar::upper_bound(value: core::option::Option<impl vortex_array::scalar::ScalarTruncation>, max_length: usize, nullability: vortex_array::dtype::Nullability) -> core::option::Option<(vortex_array::scalar::Scalar, bool)>
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub mod vortex_array::scalar_fn
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::scalar_fn::fns
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::scalar_fn::fns::between
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub enum vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::scalar_fn::fns::between::StrictComparison::NonStrict
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_array::scalar_fn::fns::between::StrictComparison::Strict
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-impl vortex_array::scalar_fn::fns::between::StrictComparison
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::is_strict(&self) -> bool
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::to_compare_operator(&self) -> vortex_array::scalar_fn::fns::operators::CompareOperator
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-pub const fn vortex_array::scalar_fn::fns::between::StrictComparison::to_operator(&self) -> vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::between::StrictComparison::clone(&self) -> vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::between::StrictComparison::eq(&self, other: &vortex_array::scalar_fn::fns::between::StrictComparison) -> bool
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::between::StrictComparison::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::between::StrictComparison::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::marker::Copy for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::between::StrictComparison
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::between::Between
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::between::Between
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::clone(&self) -> vortex_array::scalar_fn::fns::between::Between
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::between::Between
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::scalar_fn::fns::between::Between::Options = vortex_array::scalar_fn::fns::between::BetweenOptions
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub fn vortex_array::scalar_fn::fns::between::Between::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::scalar_fn::fns::between::Between::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::scalar_fn::fns::between::Between::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::scalar_fn::fns::between::Between::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::between::Between::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::between::Between::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::between::Between::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenKernel
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::scalar_fn::fns::between::BetweenOptions
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-pub vortex_array::scalar_fn::fns::between::BetweenOptions::lower_strict: vortex_array::scalar_fn::fns::between::StrictComparison
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub vortex_array::scalar_fn::fns::between::BetweenOptions::upper_strict: vortex_array::scalar_fn::fns::between::StrictComparison
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::clone(&self) -> vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::eq(&self, other: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> bool
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::compute::Options for vortex_array::scalar_fn::fns::between::BetweenOptions
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenOptions::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::between::BetweenReduce
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub type vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::between::Between>
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::between::Between>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::scalar_fn::fns::between::BetweenKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenKernel::between(array: &Self::Array, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::DecimalVTable::between(arr: &vortex_array::arrays::DecimalArray, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar_fn::fns::between::BetweenKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::between(arr: &vortex_array::arrays::PrimitiveArray, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub trait vortex_array::scalar_fn::fns::between::BetweenReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::between::BetweenReduce::between(array: &Self::Array, lower: &dyn vortex_array::Array, upper: &dyn vortex_array::Array, options: &vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-pub mod vortex_array::scalar_fn::fns::binary
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::scalar_fn::fns::binary::Binary
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::binary::Binary
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::clone(&self) -> vortex_array::scalar_fn::fns::binary::Binary
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::binary::Binary
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::scalar_fn::fns::binary::Binary::Options = vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::execute(&self, op: &vortex_array::scalar_fn::fns::operators::Operator, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::fmt_sql(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::is_fallible(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::is_null_sensitive(&self, _operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::return_dtype(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_falsification(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::validity(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::binary::CompareKernel
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::binary::Binary>
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::binary::Binary>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::scalar_fn::fns::binary::CompareKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::binary::CompareKernel::compare(lhs: &Self::Array, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::arrays::DictVTable::compare(lhs: &vortex_array::arrays::DictArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::ExtensionVTable
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::arrays::ExtensionVTable::compare(lhs: &vortex_array::arrays::ExtensionArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::binary::CompareKernel for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinVTable::compare(lhs: &vortex_array::arrays::VarBinArray, rhs: &dyn vortex_array::Array, operator: vortex_array::scalar_fn::fns::operators::CompareOperator, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::binary::and_kleene(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::binary::or_kleene(lhs: &dyn vortex_array::Array, rhs: &dyn vortex_array::Array) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::binary::scalar_cmp(lhs: &vortex_array::scalar::Scalar, rhs: &vortex_array::scalar::Scalar, operator: vortex_array::scalar_fn::fns::operators::CompareOperator) -> vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub mod vortex_array::scalar_fn::fns::cast
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::scalar_fn::fns::cast::Cast
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::cast::Cast
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::clone(&self) -> vortex_array::scalar_fn::fns::cast::Cast
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::cast::Cast
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::scalar_fn::fns::cast::Cast::Options = vortex_array::dtype::DType
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::arity(&self, _options: &vortex_array::dtype::DType) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::child_name(&self, _instance: &vortex_array::dtype::DType, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::execute(&self, target_dtype: &vortex_array::dtype::DType, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::fmt_sql(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::is_null_sensitive(&self, _instance: &vortex_array::dtype::DType) -> bool
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::reduce(&self, target_dtype: &vortex_array::dtype::DType, node: &dyn vortex_array::scalar_fn::ReduceNode, _ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::return_dtype(&self, dtype: &vortex_array::dtype::DType, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::serialize(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_expression(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::validity(&self, dtype: &vortex_array::dtype::DType, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub struct vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastKernel
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: <Self::Parent as vortex_array::matcher::Matcher>::Match, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::cast::CastReduce
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub type vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::cast::Cast>
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-pub fn vortex_array::scalar_fn::fns::cast::CastReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::cast::Cast>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-pub trait vortex_array::scalar_fn::fns::cast::CastKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::cast::CastKernel::cast(array: &Self::Array, dtype: &vortex_array::dtype::DType, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::DecimalVTable::cast(array: &vortex_array::arrays::DecimalArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::PrimitiveVTable::cast(array: &vortex_array::arrays::PrimitiveArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::scalar_fn::fns::cast::CastKernel for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::StructVTable::cast(array: &vortex_array::arrays::StructArray, dtype: &vortex_array::dtype::DType, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::scalar_fn::fns::cast::CastReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::cast::CastReduce::cast(array: &Self::Array, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolVTable::cast(array: &vortex_array::arrays::BoolArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedVTable::cast(array: &vortex_array::arrays::ChunkedArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ConstantVTable::cast(array: &vortex_array::arrays::ConstantArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::DictVTable
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::DictVTable::cast(array: &vortex_array::arrays::DictArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ExtensionVTable
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::ExtensionVTable::cast(array: &vortex_array::arrays::ExtensionArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::cast(array: &vortex_array::arrays::FixedSizeListArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListVTable::cast(array: &vortex_array::arrays::ListArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListViewVTable::cast(array: &vortex_array::arrays::ListViewArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::NullVTable::cast(array: &vortex_array::arrays::NullArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::VarBinVTable::cast(array: &vortex_array::arrays::VarBinArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::cast::CastReduce for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::VarBinViewVTable::cast(array: &vortex_array::arrays::VarBinViewArray, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub mod vortex_array::scalar_fn::fns::dynamic
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::dynamic::DynamicComparison
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::clone(&self) -> vortex_array::scalar_fn::fns::dynamic::DynamicComparison
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-pub type vortex_array::scalar_fn::fns::dynamic::DynamicComparison::Options = vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::execute(&self, data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::fmt_sql(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::return_dtype(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_falsification(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub struct vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::scalar(&self) -> core::option::Option<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::clone(&self) -> vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::eq(&self, other: &Self) -> bool
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub struct vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates::new(expr: &vortex_array::expr::Expression) -> core::option::Option<Self>
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicExprUpdates::version(&self) -> u64
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub mod vortex_array::scalar_fn::fns::fill_null
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::scalar_fn::fns::fill_null::FillNull
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::fill_null::FillNull
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::clone(&self) -> vortex_array::scalar_fn::fns::fill_null::FillNull
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::fill_null::FillNull
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNull::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_fallible(&self, _options: &Self::Options) -> bool
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_null_sensitive(&self, _options: &Self::Options) -> bool
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub struct vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullKernel
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::fill_null::FillNullReduce
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::fill_null::FillNull>
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::fill_null::FillNull>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-pub trait vortex_array::scalar_fn::fns::fill_null::FillNullKernel: vortex_array::vtable::VTable
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullKernel::fill_null(array: &Self::Array, fill_value: &vortex_array::scalar::Scalar, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BoolVTable::fill_null(array: &vortex_array::arrays::BoolArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::DecimalVTable::fill_null(array: &vortex_array::arrays::DecimalArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::DictVTable::fill_null(array: &vortex_array::arrays::DictArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullKernel for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::PrimitiveVTable::fill_null(array: &vortex_array::arrays::PrimitiveArray, fill_value: &vortex_array::scalar::Scalar, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::scalar_fn::fns::fill_null::FillNullReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNullReduce::fill_null(array: &Self::Array, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ChunkedVTable::fill_null(array: &vortex_array::arrays::ChunkedArray, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::fill_null::FillNullReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::fill_null(array: &vortex_array::arrays::ConstantArray, fill_value: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub mod vortex_array::scalar_fn::fns::get_item
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::scalar_fn::fns::get_item::GetItem
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::get_item::GetItem
+pub trait vortex_array::vtable::OperationsVTable<V: vortex_array::VTable>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::clone(&self) -> vortex_array::scalar_fn::fns::get_item::GetItem
+pub fn vortex_array::vtable::OperationsVTable::scalar_at(array: vortex_array::ArrayView<'_, V>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::get_item::GetItem
+impl vortex_array::OperationsVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub type vortex_array::scalar_fn::fns::get_item::GetItem::Options = vortex_array::dtype::FieldName
+pub fn vortex_array::arrays::Bool::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::arity(&self, _field_name: &vortex_array::dtype::FieldName) -> vortex_array::scalar_fn::Arity
+impl vortex_array::OperationsVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Chunked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::execute(&self, field_name: &vortex_array::dtype::FieldName, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::fmt_sql(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::OperationsVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Decimal::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_fallible(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
+impl vortex_array::OperationsVTable<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_null_sensitive(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
+pub fn vortex_array::arrays::Extension::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::reduce(&self, field_name: &vortex_array::dtype::FieldName, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::return_dtype(&self, field_name: &vortex_array::dtype::FieldName, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Filter::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify_untyped(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::FixedSizeList::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_expression(&self, field_name: &vortex_array::dtype::FieldName, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+impl vortex_array::OperationsVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub mod vortex_array::scalar_fn::fns::is_null
+pub fn vortex_array::arrays::List::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub struct vortex_array::scalar_fn::fns::is_null::IsNull
+impl vortex_array::OperationsVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::is_null::IsNull
+pub fn vortex_array::arrays::ListView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::clone(&self) -> vortex_array::scalar_fn::fns::is_null::IsNull
+impl vortex_array::OperationsVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::is_null::IsNull
+pub fn vortex_array::arrays::Masked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::scalar_fn::fns::is_null::IsNull::Options = vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::OperationsVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Primitive::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl vortex_array::OperationsVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Shared::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::execute(&self, _data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Struct::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::VarBin::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::VarBinView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Variant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub mod vortex_array::scalar_fn::fns::like
+impl vortex_array::OperationsVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub struct vortex_array::scalar_fn::fns::like::Like
+pub fn vortex_array::arrays::dict::Dict::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::like::Like
+impl vortex_array::OperationsVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::like::Like::clone(&self) -> vortex_array::scalar_fn::fns::like::Like
+pub fn vortex_array::arrays::null::Null::scalar_at(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::like::Like
+impl vortex_array::OperationsVTable<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-pub type vortex_array::scalar_fn::fns::like::Like::Options = vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::arrays::patched::Patched::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+impl vortex_array::OperationsVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::like::Like::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+impl vortex_array::OperationsVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::fns::like::Like::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::slice::Slice::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V: vortex_array::VTable> vortex_array::OperationsVTable<V> for vortex_array::NotSupported
 
-pub fn vortex_array::scalar_fn::fns::like::Like::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::NotSupported::scalar_at(array: vortex_array::ArrayView<'_, V>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub trait vortex_array::vtable::VTable: 'static + core::clone::Clone + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-pub fn vortex_array::scalar_fn::fns::like::Like::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub type vortex_array::vtable::VTable::ArrayData: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + vortex_array::ArrayHash + vortex_array::ArrayEq
 
-pub fn vortex_array::scalar_fn::fns::like::Like::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::vtable::VTable::OperationsVTable: vortex_array::OperationsVTable<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::stat_falsification(&self, like_opts: &vortex_array::scalar_fn::fns::like::LikeOptions, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub type vortex_array::vtable::VTable::ValidityVTable: vortex_array::ValidityVTable<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::vtable::VTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>(pub V)
+pub fn vortex_array::vtable::VTable::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
+pub fn vortex_array::vtable::VTable::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
+pub fn vortex_array::vtable::VTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>
+pub fn vortex_array::vtable::VTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::vtable::VTable::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeKernel
+pub fn vortex_array::vtable::VTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+pub fn vortex_array::vtable::VTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::vtable::VTable::id(&self) -> vortex_array::ArrayId
 
-pub struct vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::vtable::VTable::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::scalar_fn::fns::like::LikeOptions::case_insensitive: bool
+pub fn vortex_array::vtable::VTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::scalar_fn::fns::like::LikeOptions::negated: bool
+pub fn vortex_array::vtable::VTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::vtable::VTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::clone(&self) -> vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::vtable::VTable::serialize(array: vortex_array::ArrayView<'_, Self>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::vtable::VTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::vtable::VTable::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::eq(&self, other: &vortex_array::scalar_fn::fns::like::LikeOptions) -> bool
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-impl core::default::Default for vortex_array::scalar_fn::fns::like::LikeOptions
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::default() -> vortex_array::scalar_fn::fns::like::LikeOptions
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeOptions
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::like::LikeOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::marker::Copy for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::like::LikeReduce
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::like::Like>
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::like::Like>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::scalar_fn::fns::like::LikeKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::like::LikeKernel::like(array: &Self::Array, pattern: &dyn vortex_array::Array, options: vortex_array::scalar_fn::fns::like::LikeOptions, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-pub trait vortex_array::scalar_fn::fns::like::LikeReduce: vortex_array::vtable::VTable
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::scalar_fn::fns::like::LikeReduce::like(array: &Self::Array, pattern: &dyn vortex_array::Array, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-impl vortex_array::scalar_fn::fns::like::LikeReduce for vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::DictVTable::like(array: &vortex_array::arrays::DictArray, pattern: &dyn vortex_array::Array, options: vortex_array::scalar_fn::fns::like::LikeOptions) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub mod vortex_array::scalar_fn::fns::list_contains
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub struct vortex_array::scalar_fn::fns::list_contains::ListContains
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::list_contains::ListContains
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::clone(&self) -> vortex_array::scalar_fn::fns::list_contains::ListContains
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::list_contains::ListContains
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContains::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-pub struct vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>(pub V)
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub struct vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::list_contains::ListContains>
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::list_contains::ListContains>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub trait vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementKernel::list_contains(list: &dyn vortex_array::Array, element: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce: vortex_array::vtable::VTable
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContainsElementReduce::list_contains(list: &dyn vortex_array::Array, element: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-pub mod vortex_array::scalar_fn::fns::literal
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub struct vortex_array::scalar_fn::fns::literal::Literal
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::literal::Literal
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::clone(&self) -> vortex_array::scalar_fn::fns::literal::Literal
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::literal::Literal
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::scalar_fn::fns::literal::Literal::Options = vortex_array::scalar::Scalar
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::child_name(&self, _instance: &Self::Options, _child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::execute(&self, scalar: &vortex_array::scalar::Scalar, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::fmt_sql(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::return_dtype(&self, options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_expression(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, _catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::validity(&self, scalar: &vortex_array::scalar::Scalar, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub mod vortex_array::scalar_fn::fns::mask
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-pub struct vortex_array::scalar_fn::fns::mask::Mask
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::mask::Mask
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::clone(&self) -> vortex_array::scalar_fn::fns::mask::Mask
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::mask::Mask
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::scalar_fn::fns::mask::Mask::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskKernel
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-pub type vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-pub struct vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::mask::MaskReduce
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::mask::Mask>
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::mask::Mask>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::scalar_fn::fns::mask::MaskKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskKernel::mask(array: &Self::Array, mask: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::mask::MaskKernel for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ChunkedVTable::mask(array: &vortex_array::arrays::ChunkedArray, mask: &vortex_array::ArrayRef, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::scalar_fn::fns::mask::MaskReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::mask::MaskReduce::mask(array: &Self::Array, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::BoolVTable::mask(array: &vortex_array::arrays::BoolArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::DecimalVTable
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::DecimalVTable::mask(array: &vortex_array::arrays::DecimalArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::DictVTable::mask(array: &vortex_array::arrays::DictArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionVTable::mask(array: &vortex_array::arrays::ExtensionArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::mask(array: &vortex_array::arrays::FixedSizeListArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListVTable::mask(array: &vortex_array::arrays::ListArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ListViewVTable::mask(array: &vortex_array::arrays::ListViewArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::MaskedVTable::mask(array: &vortex_array::arrays::MaskedArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::NullVTable::mask(array: &vortex_array::arrays::NullArray, _mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::mask(array: &vortex_array::arrays::PrimitiveArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::StructVTable::mask(array: &vortex_array::arrays::StructArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinVTable
+impl vortex_array::VTable for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::VarBinVTable::mask(array: &vortex_array::arrays::VarBinArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-impl vortex_array::scalar_fn::fns::mask::MaskReduce for vortex_array::arrays::VarBinViewVTable
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-pub fn vortex_array::arrays::VarBinViewVTable::mask(array: &vortex_array::arrays::VarBinViewArray, mask: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub mod vortex_array::scalar_fn::fns::merge
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub enum vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub vortex_array::scalar_fn::fns::merge::DuplicateHandling::Error
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub vortex_array::scalar_fn::fns::merge::DuplicateHandling::RightMost
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::clone(&self) -> vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::eq(&self, other: &vortex_array::scalar_fn::fns::merge::DuplicateHandling) -> bool
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-impl core::default::Default for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::default() -> vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::merge::DuplicateHandling::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-impl core::marker::Copy for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-pub struct vortex_array::scalar_fn::fns::merge::Merge
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::merge::Merge
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::clone(&self) -> vortex_array::scalar_fn::fns::merge::Merge
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::merge::Merge
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::scalar_fn::fns::merge::Merge::Options = vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::is_fallible(&self, instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub mod vortex_array::scalar_fn::fns::not
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub struct vortex_array::scalar_fn::fns::not::Not
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::not::Not
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::scalar_fn::fns::not::Not::clone(&self) -> vortex_array::scalar_fn::fns::not::Not
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::not::Not
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::scalar_fn::fns::not::Not::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::not::Not::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::not::Not::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::not::Not::execute(&self, _data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::not::Not::is_null_sensitive(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::not::Not::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::not::Not::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotKernel
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub type vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::scalar_fn::fns::not::NotExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, _parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub struct vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::not::NotReduce
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::not::Not>
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::not::NotReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, _parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::not::Not>, _child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::scalar_fn::fns::not::NotKernel: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::not::NotKernel::invert(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub trait vortex_array::scalar_fn::fns::not::NotReduce: vortex_array::vtable::VTable
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::not::NotReduce::invert(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::not::NotReduce for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::invert(array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub mod vortex_array::scalar_fn::fns::operators
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub enum vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::Eq
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::Gt
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::Gte
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::Lt
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::Lte
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub vortex_array::scalar_fn::fns::operators::CompareOperator::NotEq
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::inverse(self) -> Self
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::swap(self) -> Self
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::clone(&self) -> vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::eq(&self, other: &vortex_array::scalar_fn::fns::operators::CompareOperator) -> bool
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::cmp::PartialOrd for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::partial_cmp(&self, other: &vortex_array::scalar_fn::fns::operators::CompareOperator) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::scalar_fn::fns::operators::CompareOperator> for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_array::scalar_fn::fns::operators::CompareOperator) -> Self
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::TryFrom<vortex_array::scalar_fn::fns::operators::Operator> for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::scalar_fn::fns::operators::CompareOperator::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::try_from(value: vortex_array::scalar_fn::fns::operators::Operator) -> core::result::Result<Self, Self::Error>
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::marker::Copy for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub enum vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Add
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::And
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Div
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Eq
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Gt
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Gte
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Lt
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Lte
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Mul
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::scalar_fn::fns::operators::Operator::NotEq
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Or
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-pub vortex_array::scalar_fn::fns::operators::Operator::Sub
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-impl vortex_array::scalar_fn::fns::operators::Operator
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::inverse(self) -> core::option::Option<Self>
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::is_arithmetic(&self) -> bool
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::is_comparison(&self) -> bool
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::logical_inverse(self) -> core::option::Option<Self>
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::swap(self) -> core::option::Option<Self>
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::clone(&self) -> vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::eq(&self, other: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-impl core::cmp::PartialOrd for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::partial_cmp(&self, other: &vortex_array::scalar_fn::fns::operators::Operator) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::convert::From<vortex_array::scalar::NumericOperator> for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::from(op: vortex_array::scalar::NumericOperator) -> Self
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::From<vortex_array::scalar_fn::fns::operators::CompareOperator> for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_array::scalar_fn::fns::operators::CompareOperator) -> Self
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::convert::From<vortex_array::scalar_fn::fns::operators::Operator> for i32
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn i32::from(value: vortex_array::scalar_fn::fns::operators::Operator) -> Self
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-impl core::convert::From<vortex_array::scalar_fn::fns::operators::Operator> for vortex_proto::expr::binary_opts::BinaryOp
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_proto::expr::binary_opts::BinaryOp::from(value: vortex_array::scalar_fn::fns::operators::Operator) -> Self
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-impl core::convert::From<vortex_proto::expr::binary_opts::BinaryOp> for vortex_array::scalar_fn::fns::operators::Operator
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::from(value: vortex_proto::expr::binary_opts::BinaryOp) -> Self
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::convert::TryFrom<i32> for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::scalar_fn::fns::operators::Operator::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::try_from(value: i32) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::convert::TryFrom<vortex_array::scalar_fn::fns::operators::Operator> for vortex_array::scalar_fn::fns::operators::CompareOperator
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::scalar_fn::fns::operators::CompareOperator::Error = vortex_error::VortexError
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::operators::CompareOperator::try_from(value: vortex_array::scalar_fn::fns::operators::Operator) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::operators::Operator::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::marker::Copy for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub mod vortex_array::scalar_fn::fns::pack
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::scalar_fn::fns::pack::Pack
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::pack::Pack
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::clone(&self) -> vortex_array::scalar_fn::fns::pack::Pack
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::pack::Pack
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-pub type vortex_array::scalar_fn::fns::pack::Pack::Options = vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::child_name(&self, instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::scalar_fn::fns::pack::PackOptions::names: vortex_array::dtype::FieldNames
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::scalar_fn::fns::pack::PackOptions::nullability: vortex_array::dtype::Nullability
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::pack::PackOptions::clone(&self) -> vortex_array::scalar_fn::fns::pack::PackOptions
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::pack::PackOptions
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::pack::PackOptions
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::scalar_fn::fns::pack::PackOptions::eq(&self, other: &vortex_array::scalar_fn::fns::pack::PackOptions) -> bool
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::pack::PackOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::pack::PackOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::pack::PackOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub mod vortex_array::scalar_fn::fns::root
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::root::Root
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::root::Root
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::root::Root::clone(&self) -> vortex_array::scalar_fn::fns::root::Root
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::root::Root
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::root::Root::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::root::Root::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::execute(&self, _data: &Self::Options, _args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::root::Root::fmt_sql(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::scalar_fn::fns::root::Root::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::root::Root::is_fallible(&self, _options: &Self::Options) -> bool
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::scalar_fn::fns::root::Root::is_null_sensitive(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::root::Root::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::stat_expression(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub mod vortex_array::scalar_fn::fns::select
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub enum vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub vortex_array::scalar_fn::fns::select::FieldSelection::Exclude(vortex_array::dtype::FieldNames)
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub vortex_array::scalar_fn::fns::select::FieldSelection::Include(vortex_array::dtype::FieldNames)
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::exclude(columns: vortex_array::dtype::FieldNames) -> Self
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::field_names(&self) -> &vortex_array::dtype::FieldNames
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::include(columns: vortex_array::dtype::FieldNames) -> Self
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::is_exclude(&self) -> bool
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::is_include(&self) -> bool
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::normalize_to_included_fields(&self, available_fields: &vortex_array::dtype::FieldNames) -> vortex_error::VortexResult<vortex_array::dtype::FieldNames>
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::clone(&self) -> vortex_array::scalar_fn::fns::select::FieldSelection
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-impl core::cmp::Eq for vortex_array::scalar_fn::fns::select::FieldSelection
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::fns::select::FieldSelection
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::eq(&self, other: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-impl core::fmt::Debug for vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::fmt::Display for vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::hash::Hash for vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::select::FieldSelection::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::scalar_fn::fns::select::Select
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::select::Select
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::select::Select::clone(&self) -> vortex_array::scalar_fn::fns::select::Select
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::select::Select
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::scalar_fn::fns::select::Select::Options = vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::arity(&self, _options: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::child_name(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::fns::select::FieldSelection>
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::select::Select::execute(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::fmt_sql(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::select::Select::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::scalar_fn::fns::select::Select::is_fallible(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::select::Select::is_null_sensitive(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::fns::select::Select::return_dtype(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::serialize(&self, instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::select::Select::simplify(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub mod vortex_array::scalar_fn::fns::zip
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub struct vortex_array::scalar_fn::fns::zip::Zip
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::clone::Clone for vortex_array::scalar_fn::fns::zip::Zip
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::clone(&self) -> vortex_array::scalar_fn::fns::zip::Zip
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::zip::Zip
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::scalar_fn::fns::zip::Zip::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::is_null_sensitive(&self, _options: &Self::Options) -> bool
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, _ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-pub struct vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>(pub V)
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::default() -> vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V> vortex_array::kernel::ExecuteParentKernel<V> for vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipKernel
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipExecuteAdaptor<V>::execute_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>(pub V)
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-impl<V: core::default::Default> core::default::Default for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::default() -> vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<V: core::fmt::Debug> core::fmt::Debug for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V> vortex_array::optimizer::rules::ArrayParentReduceRule<V> for vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V> where V: vortex_array::scalar_fn::fns::zip::ZipReduce
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::Parent = vortex_array::arrays::ExactScalarFn<vortex_array::scalar_fn::fns::zip::Zip>
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipReduceAdaptor<V>::reduce_parent(&self, array: &<V as vortex_array::vtable::VTable>::Array, parent: vortex_array::arrays::ScalarFnArrayView<'_, vortex_array::scalar_fn::fns::zip::Zip>, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::scalar_fn::fns::zip::ZipKernel: vortex_array::vtable::VTable
+pub trait vortex_array::vtable::ValidityChild<V: vortex_array::VTable>
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipKernel::zip(array: &Self::Array, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::vtable::ValidityChild::validity_child(array: vortex_array::ArrayView<'_, V>) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::StructVTable
+impl vortex_array::ValidityChild<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::StructVTable::zip(if_true: &vortex_array::arrays::StructArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Extension::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>) -> vortex_array::ArrayRef
 
-impl vortex_array::scalar_fn::fns::zip::ZipKernel for vortex_array::arrays::VarBinViewVTable
+impl vortex_array::ValidityChild<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::VarBinViewVTable::zip(if_true: &vortex_array::arrays::VarBinViewArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::patched::Patched::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>) -> vortex_array::ArrayRef
 
-pub trait vortex_array::scalar_fn::fns::zip::ZipReduce: vortex_array::vtable::VTable
+pub trait vortex_array::vtable::ValidityChildSliceHelper
 
-pub fn vortex_array::scalar_fn::fns::zip::ZipReduce::zip(array: &Self::Array, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::vtable::ValidityChildSliceHelper::sliced_child_array(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::scalar_fn::fns::zip::ZipReduce for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::vtable::ValidityChildSliceHelper::unsliced_child_and_slice(&self) -> (&vortex_array::ArrayRef, usize, usize)
 
-pub fn vortex_array::arrays::ChunkedVTable::zip(if_true: &vortex_array::arrays::ChunkedArray, if_false: &dyn vortex_array::Array, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::vtable::ValidityVTable<V: vortex_array::VTable>
 
-pub mod vortex_array::scalar_fn::session
+pub fn vortex_array::vtable::ValidityVTable::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub struct vortex_array::scalar_fn::session::ScalarFnSession
+impl vortex_array::ValidityVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-impl vortex_array::scalar_fn::session::ScalarFnSession
+pub fn vortex_array::arrays::Bool::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar_fn::session::ScalarFnSession::register<V: vortex_array::scalar_fn::ScalarFnVTable>(&self, vtable: V)
+impl vortex_array::ValidityVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_array::scalar_fn::session::ScalarFnSession::registry(&self) -> &vortex_array::scalar_fn::session::ScalarFnRegistry
+pub fn vortex_array::arrays::Chunked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::default::Default for vortex_array::scalar_fn::session::ScalarFnSession
+impl vortex_array::ValidityVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::scalar_fn::session::ScalarFnSession::default() -> Self
+pub fn vortex_array::arrays::Constant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::session::ScalarFnSession
+impl vortex_array::ValidityVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn vortex_array::scalar_fn::session::ScalarFnSession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Decimal::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub trait vortex_array::scalar_fn::session::ScalarFnSessionExt: vortex_session::SessionExt
+impl vortex_array::ValidityVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub fn vortex_array::scalar_fn::session::ScalarFnSessionExt::scalar_fns(&self) -> vortex_session::Ref<'_, vortex_array::scalar_fn::session::ScalarFnSession>
+pub fn vortex_array::arrays::Filter::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<S: vortex_session::SessionExt> vortex_array::scalar_fn::session::ScalarFnSessionExt for S
+impl vortex_array::ValidityVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-pub type vortex_array::scalar_fn::session::ScalarFnRegistry = vortex_session::registry::Registry<vortex_array::scalar_fn::ScalarFnPlugin>
+pub fn vortex_array::arrays::FixedSizeList::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub enum vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub vortex_array::scalar_fn::Arity::Exact(usize)
+pub fn vortex_array::arrays::List::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::scalar_fn::Arity::Variadic
+impl vortex_array::ValidityVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-pub vortex_array::scalar_fn::Arity::Variadic::max: core::option::Option<usize>
+pub fn vortex_array::arrays::ListView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub vortex_array::scalar_fn::Arity::Variadic::min: usize
+impl vortex_array::ValidityVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-impl vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Masked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar_fn::Arity::matches(&self, arg_count: usize) -> bool
+impl vortex_array::ValidityVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-impl core::clone::Clone for vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Primitive::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar_fn::Arity::clone(&self) -> vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-impl core::cmp::Eq for vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Shared::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-pub fn vortex_array::scalar_fn::Arity::eq(&self, other: &vortex_array::scalar_fn::Arity) -> bool
+pub fn vortex_array::arrays::Struct::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub fn vortex_array::scalar_fn::Arity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBin::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Display for vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::scalar_fn::Arity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::marker::Copy for vortex_array::scalar_fn::Arity
+impl vortex_array::ValidityVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::Arity
+pub fn vortex_array::arrays::Variant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub struct vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::ValidityVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-impl core::clone::Clone for vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::dict::Dict::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar_fn::EmptyOptions::clone(&self) -> vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::ValidityVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-impl core::cmp::Eq for vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::arrays::null::Null::validity(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::ValidityVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::scalar_fn::EmptyOptions::eq(&self, other: &vortex_array::scalar_fn::EmptyOptions) -> bool
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Debug for vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::ValidityVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::scalar_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::slice::Slice::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::fmt::Display for vortex_array::scalar_fn::EmptyOptions
+impl<V: vortex_array::VTable> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChildSliceHelper where <V as vortex_array::VTable>::ArrayData: vortex_array::ValidityChildSliceHelper
 
-pub fn vortex_array::scalar_fn::EmptyOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ValidityVTableFromChildSliceHelper::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::hash::Hash for vortex_array::scalar_fn::EmptyOptions
+impl<V> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChild where V: vortex_array::ValidityChild<V> + vortex_array::VTable
 
-pub fn vortex_array::scalar_fn::EmptyOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_array::ValidityVTableFromChild::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl core::marker::StructuralPartialEq for vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::vtable::child_to_validity(child: &core::option::Option<vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
 
-pub struct vortex_array::scalar_fn::ExecutionArgs<'a>
+pub fn vortex_array::vtable::patches_child(patches: &vortex_array::patches::Patches, idx: usize) -> vortex_array::ArrayRef
 
-pub vortex_array::scalar_fn::ExecutionArgs::ctx: &'a mut vortex_array::ExecutionCtx
+pub fn vortex_array::vtable::patches_child_name(idx: usize) -> &'static str
 
-pub vortex_array::scalar_fn::ExecutionArgs::inputs: alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::vtable::patches_nchildren(patches: &vortex_array::patches::Patches) -> usize
 
-pub vortex_array::scalar_fn::ExecutionArgs::row_count: usize
+pub fn vortex_array::vtable::validity_nchildren(validity: &vortex_array::validity::Validity) -> usize
 
-pub struct vortex_array::scalar_fn::ScalarFn<V: vortex_array::scalar_fn::ScalarFnVTable>(_)
+pub fn vortex_array::vtable::validity_to_child(validity: &vortex_array::validity::Validity, len: usize) -> core::option::Option<vortex_array::ArrayRef>
 
-impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::scalar_fn::ScalarFn<V>
+pub type vortex_array::vtable::ArrayPluginRef = alloc::sync::Arc<dyn vortex_array::ArrayPlugin>
 
-pub fn vortex_array::scalar_fn::ScalarFn<V>::erased(self) -> vortex_array::scalar_fn::ScalarFnRef
+pub macro vortex_array::field_path!
 
-pub fn vortex_array::scalar_fn::ScalarFn<V>::new(vtable: V, options: <V as vortex_array::scalar_fn::ScalarFnVTable>::Options) -> Self
+pub macro vortex_array::match_each_decimal_value!
 
-pub fn vortex_array::scalar_fn::ScalarFn<V>::options(&self) -> &<V as vortex_array::scalar_fn::ScalarFnVTable>::Options
+pub macro vortex_array::match_each_decimal_value_type!
 
-pub fn vortex_array::scalar_fn::ScalarFn<V>::vtable(&self) -> &V
+pub macro vortex_array::match_each_float_ptype!
 
-pub struct vortex_array::scalar_fn::ScalarFnOptions<'a>
+pub macro vortex_array::match_each_integer_ptype!
 
-impl vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub macro vortex_array::match_each_native_ptype!
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub macro vortex_array::match_each_native_simd_ptype!
 
-impl<'a> vortex_array::scalar_fn::ScalarFnOptions<'a>
+pub macro vortex_array::match_each_pvalue!
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'a>::as_any(&self) -> &'a dyn core::any::Any
+pub macro vortex_array::match_each_signed_integer_ptype!
 
-impl core::cmp::Eq for vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub macro vortex_array::match_each_unsigned_integer_ptype!
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub macro vortex_array::match_smallest_offset_type!
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::eq(&self, other: &Self) -> bool
+pub macro vortex_array::require_child!
 
-impl core::fmt::Debug for vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub macro vortex_array::require_opt_child!
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub macro vortex_array::require_patches!
 
-impl core::fmt::Display for vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub macro vortex_array::require_validity!
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub enum vortex_array::Canonical
 
-impl core::hash::Hash for vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub vortex_array::Canonical::Bool(vortex_array::arrays::BoolArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnOptions<'_>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub vortex_array::Canonical::Decimal(vortex_array::arrays::DecimalArray)
 
-pub struct vortex_array::scalar_fn::ScalarFnPlugin(_)
+pub vortex_array::Canonical::Extension(vortex_array::arrays::ExtensionArray)
 
-impl vortex_array::scalar_fn::ScalarFnPlugin
+pub vortex_array::Canonical::FixedSizeList(vortex_array::arrays::FixedSizeListArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::as_any(&self) -> &dyn core::any::Any
+pub vortex_array::Canonical::List(vortex_array::arrays::ListViewArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::deserialize(&self, metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::ScalarFnRef>
+pub vortex_array::Canonical::Null(vortex_array::arrays::null::NullArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub vortex_array::Canonical::Primitive(vortex_array::arrays::PrimitiveArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::is<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> bool
+pub vortex_array::Canonical::Struct(vortex_array::arrays::StructArray)
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::new<V: vortex_array::scalar_fn::ScalarFnVTable>(vtable: V) -> Self
+pub vortex_array::Canonical::VarBinView(vortex_array::arrays::VarBinViewArray)
 
-pub const fn vortex_array::scalar_fn::ScalarFnPlugin::new_static<V: vortex_array::scalar_fn::ScalarFnVTable>(vtable: &'static V) -> Self
+pub vortex_array::Canonical::Variant(vortex_array::arrays::VariantArray)
 
-impl core::clone::Clone for vortex_array::scalar_fn::ScalarFnPlugin
+impl vortex_array::Canonical
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::clone(&self) -> vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_bool(&self) -> &vortex_array::arrays::BoolArray
 
-impl core::cmp::Eq for vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_decimal(&self) -> &vortex_array::arrays::DecimalArray
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_extension(&self) -> &vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::eq(&self, other: &Self) -> bool
+pub fn vortex_array::Canonical::as_fixed_size_list(&self) -> &vortex_array::arrays::FixedSizeListArray
 
-impl core::fmt::Debug for vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_listview(&self) -> &vortex_array::arrays::ListViewArray
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Canonical::as_null(&self) -> &vortex_array::arrays::null::NullArray
 
-impl core::fmt::Display for vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_primitive(&self) -> &vortex_array::arrays::PrimitiveArray
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Canonical::as_struct(&self) -> &vortex_array::arrays::StructArray
 
-impl core::hash::Hash for vortex_array::scalar_fn::ScalarFnPlugin
+pub fn vortex_array::Canonical::as_varbinview(&self) -> &vortex_array::arrays::VarBinViewArray
 
-pub fn vortex_array::scalar_fn::ScalarFnPlugin::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn vortex_array::Canonical::into_bool(self) -> vortex_array::arrays::BoolArray
 
-pub struct vortex_array::scalar_fn::ScalarFnRef(_)
+pub fn vortex_array::Canonical::into_decimal(self) -> vortex_array::arrays::DecimalArray
 
-impl vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::into_extension(self) -> vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::as_<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> &<V as vortex_array::scalar_fn::ScalarFnVTable>::Options
+pub fn vortex_array::Canonical::into_fixed_size_list(self) -> vortex_array::arrays::FixedSizeListArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::as_opt<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> core::option::Option<&<V as vortex_array::scalar_fn::ScalarFnVTable>::Options>
+pub fn vortex_array::Canonical::into_listview(self) -> vortex_array::arrays::ListViewArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::execute(&self, ctx: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Canonical::into_null(self) -> vortex_array::arrays::null::NullArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Canonical::into_primitive(self) -> vortex_array::arrays::PrimitiveArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::is<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> bool
+pub fn vortex_array::Canonical::into_struct(self) -> vortex_array::arrays::StructArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::options(&self) -> vortex_array::scalar_fn::ScalarFnOptions<'_>
+pub fn vortex_array::Canonical::into_varbinview(self) -> vortex_array::arrays::VarBinViewArray
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::reduce(&self, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+impl vortex_array::Canonical
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::return_dtype(&self, arg_types: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Canonical::compact(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::signature(&self) -> vortex_array::scalar_fn::ScalarFnSignature<'_>
+impl vortex_array::Canonical
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::validity(&self, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+pub fn vortex_array::Canonical::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::vtable_ref<V: vortex_array::scalar_fn::ScalarFnVTable>(&self) -> core::option::Option<&V>
+pub fn vortex_array::Canonical::empty(dtype: &vortex_array::dtype::DType) -> vortex_array::Canonical
 
-impl core::clone::Clone for vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::clone(&self) -> vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::len(&self) -> usize
 
-impl core::cmp::Eq for vortex_array::scalar_fn::ScalarFnRef
+impl core::clone::Clone for vortex_array::Canonical
 
-impl core::cmp::PartialEq for vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::clone(&self) -> vortex_array::Canonical
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::eq(&self, other: &Self) -> bool
+impl core::convert::From<vortex_array::Canonical> for vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::ArrayRef::from(value: vortex_array::Canonical) -> Self
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::convert::From<vortex_array::CanonicalView<'_>> for vortex_array::Canonical
 
-impl core::fmt::Display for vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::from(value: vortex_array::CanonicalView<'_>) -> Self
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::fmt::Debug for vortex_array::Canonical
 
-impl core::hash::Hash for vortex_array::scalar_fn::ScalarFnRef
+pub fn vortex_array::Canonical::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar_fn::ScalarFnRef::hash<H: core::hash::Hasher>(&self, state: &mut H)
+impl vortex_array::Executable for vortex_array::Canonical
 
-pub struct vortex_array::scalar_fn::ScalarFnSignature<'a>
+pub fn vortex_array::Canonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::scalar_fn::ScalarFnSignature<'_>
+impl vortex_array::IntoArray for vortex_array::Canonical
 
-pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::arity(&self) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Canonical::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::child_name(&self, index: usize) -> vortex_array::scalar_fn::ChildName
+pub enum vortex_array::CanonicalView<'a>
 
-pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::is_fallible(&self) -> bool
+pub vortex_array::CanonicalView::Bool(vortex_array::ArrayView<'a, vortex_array::arrays::Bool>)
 
-pub fn vortex_array::scalar_fn::ScalarFnSignature<'_>::is_null_sensitive(&self) -> bool
+pub vortex_array::CanonicalView::Decimal(vortex_array::ArrayView<'a, vortex_array::arrays::Decimal>)
 
-pub trait vortex_array::scalar_fn::ReduceCtx
+pub vortex_array::CanonicalView::Extension(vortex_array::ArrayView<'a, vortex_array::arrays::Extension>)
 
-pub fn vortex_array::scalar_fn::ReduceCtx::new_node(&self, scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: &[vortex_array::scalar_fn::ReduceNodeRef]) -> vortex_error::VortexResult<vortex_array::scalar_fn::ReduceNodeRef>
+pub vortex_array::CanonicalView::FixedSizeList(vortex_array::ArrayView<'a, vortex_array::arrays::FixedSizeList>)
 
-pub trait vortex_array::scalar_fn::ReduceNode
+pub vortex_array::CanonicalView::List(vortex_array::ArrayView<'a, vortex_array::arrays::ListView>)
 
-pub fn vortex_array::scalar_fn::ReduceNode::as_any(&self) -> &dyn core::any::Any
+pub vortex_array::CanonicalView::Null(vortex_array::ArrayView<'a, vortex_array::arrays::null::Null>)
 
-pub fn vortex_array::scalar_fn::ReduceNode::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+pub vortex_array::CanonicalView::Primitive(vortex_array::ArrayView<'a, vortex_array::arrays::Primitive>)
 
-pub fn vortex_array::scalar_fn::ReduceNode::child_count(&self) -> usize
+pub vortex_array::CanonicalView::Struct(vortex_array::ArrayView<'a, vortex_array::arrays::Struct>)
 
-pub fn vortex_array::scalar_fn::ReduceNode::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub vortex_array::CanonicalView::VarBinView(vortex_array::ArrayView<'a, vortex_array::arrays::VarBinView>)
 
-pub fn vortex_array::scalar_fn::ReduceNode::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+pub vortex_array::CanonicalView::Variant(vortex_array::ArrayView<'a, vortex_array::arrays::Variant>)
 
-impl vortex_array::scalar_fn::ReduceNode for vortex_array::ArrayRef
+impl vortex_array::CanonicalView<'_>
 
-pub fn vortex_array::ArrayRef::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::CanonicalView<'_>::to_array_ref(&self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayRef::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+impl core::convert::From<vortex_array::CanonicalView<'_>> for vortex_array::Canonical
 
-pub fn vortex_array::ArrayRef::child_count(&self) -> usize
+pub fn vortex_array::Canonical::from(value: vortex_array::CanonicalView<'_>) -> Self
 
-pub fn vortex_array::ArrayRef::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+impl<'a> core::clone::Clone for vortex_array::CanonicalView<'a>
 
-pub fn vortex_array::ArrayRef::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+pub fn vortex_array::CanonicalView<'a>::clone(&self) -> vortex_array::CanonicalView<'a>
 
-impl vortex_array::scalar_fn::ReduceNode for vortex_array::arrays::ScalarFnArray
+impl<'a> core::fmt::Debug for vortex_array::CanonicalView<'a>
 
-pub fn vortex_array::arrays::ScalarFnArray::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::CanonicalView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::arrays::ScalarFnArray::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+impl<'a> core::marker::Copy for vortex_array::CanonicalView<'a>
 
-pub fn vortex_array::arrays::ScalarFnArray::child_count(&self) -> usize
+pub enum vortex_array::Columnar
 
-pub fn vortex_array::arrays::ScalarFnArray::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub vortex_array::Columnar::Canonical(vortex_array::Canonical)
 
-pub fn vortex_array::arrays::ScalarFnArray::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+pub vortex_array::Columnar::Constant(vortex_array::arrays::ConstantArray)
 
-impl<V: vortex_array::vtable::VTable> vortex_array::scalar_fn::ReduceNode for vortex_array::ArrayAdapter<V>
+impl vortex_array::Columnar
 
-pub fn vortex_array::ArrayAdapter<V>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::Columnar::constant<S: core::convert::Into<vortex_array::scalar::Scalar>>(scalar: S, len: usize) -> Self
 
-pub fn vortex_array::ArrayAdapter<V>::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+pub fn vortex_array::Columnar::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::ArrayAdapter<V>::child_count(&self) -> usize
+pub fn vortex_array::Columnar::is_empty(&self) -> bool
 
-pub fn vortex_array::ArrayAdapter<V>::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Columnar::len(&self) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+impl vortex_array::Executable for vortex_array::Columnar
 
-pub trait vortex_array::scalar_fn::ScalarFnVTable: 'static + core::marker::Sized + core::clone::Clone + core::marker::Send + core::marker::Sync
+pub fn vortex_array::Columnar::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::scalar_fn::ScalarFnVTable::Options: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + core::cmp::PartialEq + core::cmp::Eq + core::hash::Hash
+impl vortex_array::IntoArray for vortex_array::Columnar
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Columnar::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::child_name(&self, options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub enum vortex_array::ColumnarView<'a>
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub vortex_array::ColumnarView::Canonical(vortex_array::CanonicalView<'a>)
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub vortex_array::ColumnarView::Constant(vortex_array::ArrayView<'a, vortex_array::arrays::Constant>)
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub enum vortex_array::ExecutionStep
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub vortex_array::ExecutionStep::Done
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::is_fallible(&self, options: &Self::Options) -> bool
+pub vortex_array::ExecutionStep::ExecuteSlot(usize, vortex_array::DonePredicate)
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::is_null_sensitive(&self, options: &Self::Options) -> bool
+impl core::fmt::Debug for vortex_array::ExecutionStep
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub fn vortex_array::ExecutionStep::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub enum vortex_array::Precision
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::serialize(&self, options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub vortex_array::Precision::Ptr
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::simplify(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub vortex_array::Precision::Value
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::simplify_untyped(&self, options: &Self::Options, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl core::clone::Clone for vortex_array::Precision
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::stat_expression(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Precision::clone(&self) -> vortex_array::Precision
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+impl core::fmt::Debug for vortex_array::Precision
 
-pub fn vortex_array::scalar_fn::ScalarFnVTable::validity(&self, options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Precision::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::between::Between
+impl core::marker::Copy for vortex_array::Precision
 
-pub type vortex_array::scalar_fn::fns::between::Between::Options = vortex_array::scalar_fn::fns::between::BetweenOptions
+pub struct vortex_array::AnyCanonical
 
-pub fn vortex_array::scalar_fn::fns::between::Between::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+impl vortex_array::matcher::Matcher for vortex_array::AnyCanonical
 
-pub fn vortex_array::scalar_fn::fns::between::Between::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub type vortex_array::AnyCanonical::Match<'a> = vortex_array::CanonicalView<'a>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::AnyCanonical::matches(array: &vortex_array::ArrayRef) -> bool
 
-pub fn vortex_array::scalar_fn::fns::between::Between::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::AnyCanonical::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<Self::Match>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_array::AnyColumnar
 
-pub fn vortex_array::scalar_fn::fns::between::Between::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl vortex_array::matcher::Matcher for vortex_array::AnyColumnar
 
-pub fn vortex_array::scalar_fn::fns::between::Between::is_fallible(&self, _options: &Self::Options) -> bool
+pub type vortex_array::AnyColumnar::Match<'a> = vortex_array::ColumnarView<'a>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::AnyColumnar::matches(array: &vortex_array::ArrayRef) -> bool
 
-pub fn vortex_array::scalar_fn::fns::between::Between::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::AnyColumnar::try_match<'a>(array: &'a vortex_array::ArrayRef) -> core::option::Option<Self::Match>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub struct vortex_array::Array<V: vortex_array::VTable>
 
-pub fn vortex_array::scalar_fn::fns::between::Between::stat_falsification(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+impl vortex_array::Array<vortex_array::arrays::Bool>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::binary::Binary
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::from_indices<I: core::iter::traits::collect::IntoIterator<Item = usize>>(length: usize, indices: I, validity: vortex_array::validity::Validity) -> Self
 
-pub type vortex_array::scalar_fn::fns::binary::Binary::Options = vortex_array::scalar_fn::fns::operators::Operator
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::into_bit_buffer(self) -> vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::new(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::new_handle(handle: vortex_array::buffer::BufferHandle, offset: usize, len: usize, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Bool>::new_unchecked(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::execute(&self, op: &vortex_array::scalar_fn::fns::operators::Operator, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::try_new(bits: vortex_buffer::bit::buf::BitBuffer, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::fmt_sql(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::try_new_from_handle(bits: vortex_array::buffer::BufferHandle, offset: usize, len: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::validate(bits: &vortex_buffer::bit::buf::BitBuffer, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::is_fallible(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
+impl vortex_array::Array<vortex_array::arrays::Bool>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::is_null_sensitive(&self, _operator: &vortex_array::scalar_fn::fns::operators::Operator) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::Bool>::patch(self, patches: &vortex_array::patches::Patches, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::return_dtype(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+impl vortex_array::Array<vortex_array::arrays::Chunked>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Chunked>::new_unchecked(chunks: alloc::vec::Vec<vortex_array::ArrayRef>, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::stat_falsification(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::Chunked>::rechunk(&self, target_bytesize: u64, target_rowsize: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::binary::Binary::validity(&self, operator: &vortex_array::scalar_fn::fns::operators::Operator, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::Chunked>::try_new(chunks: alloc::vec::Vec<vortex_array::ArrayRef>, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::cast::Cast
+impl vortex_array::Array<vortex_array::arrays::Constant>
 
-pub type vortex_array::scalar_fn::fns::cast::Cast::Options = vortex_array::dtype::DType
+pub fn vortex_array::Array<vortex_array::arrays::Constant>::new<S>(scalar: S, len: usize) -> Self where S: core::convert::Into<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::arity(&self, _options: &vortex_array::dtype::DType) -> vortex_array::scalar_fn::Arity
+impl vortex_array::Array<vortex_array::arrays::Decimal>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::child_name(&self, _instance: &vortex_array::dtype::DType, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::from_iter<T: vortex_array::dtype::NativeDecimalType, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::from_option_iter<T: vortex_array::dtype::NativeDecimalType, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, decimal_dtype: vortex_array::dtype::DecimalDType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::execute(&self, target_dtype: &vortex_array::dtype::DType, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::fmt_sql(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Decimal>::new_unchecked<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::is_null_sensitive(&self, _instance: &vortex_array::dtype::DType) -> bool
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Decimal>::new_unchecked_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::reduce(&self, target_dtype: &vortex_array::dtype::DType, node: &dyn vortex_array::scalar_fn::ReduceNode, _ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::patch(self, patches: &vortex_array::patches::Patches, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::return_dtype(&self, dtype: &vortex_array::dtype::DType, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::try_new<T: vortex_array::dtype::NativeDecimalType>(buffer: vortex_buffer::buffer::Buffer<T>, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::serialize(&self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::try_new_handle(values: vortex_array::buffer::BufferHandle, values_type: vortex_array::dtype::DecimalType, decimal_dtype: vortex_array::dtype::DecimalDType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::stat_expression(&self, dtype: &vortex_array::dtype::DType, expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+impl vortex_array::Array<vortex_array::arrays::Decimal>
 
-pub fn vortex_array::scalar_fn::fns::cast::Cast::validity(&self, dtype: &vortex_array::dtype::DType, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::Decimal>::into_data_parts(self) -> vortex_array::arrays::decimal::DecimalDataParts
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::dynamic::DynamicComparison
+impl vortex_array::Array<vortex_array::arrays::Extension>
 
-pub type vortex_array::scalar_fn::fns::dynamic::DynamicComparison::Options = vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr
+pub fn vortex_array::Array<vortex_array::arrays::Extension>::new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_array: vortex_array::ArrayRef) -> Self
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::Extension>::try_new(ext_dtype: vortex_array::dtype::extension::ExtDTypeRef, storage_array: vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl vortex_array::Array<vortex_array::arrays::Filter>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::execute(&self, data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::Filter>::new(array: vortex_array::ArrayRef, mask: vortex_mask::Mask) -> Self
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::fmt_sql(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Filter>::try_new(array: vortex_array::ArrayRef, mask: vortex_mask::Mask) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl vortex_array::Array<vortex_array::arrays::FixedSizeList>
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::FixedSizeList>::into_data_parts(self) -> vortex_array::arrays::fixed_size_list::FixedSizeListDataParts
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::return_dtype(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::FixedSizeList>::new(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> Self
 
-pub fn vortex_array::scalar_fn::fns::dynamic::DynamicComparison::stat_falsification(&self, dynamic: &vortex_array::scalar_fn::fns::dynamic::DynamicComparisonExpr, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::FixedSizeList>::new_unchecked(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::fill_null::FillNull
+pub fn vortex_array::Array<vortex_array::arrays::FixedSizeList>::try_new(elements: vortex_array::ArrayRef, list_size: u32, validity: vortex_array::validity::Validity, len: usize) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::scalar_fn::fns::fill_null::FillNull::Options = vortex_array::scalar_fn::EmptyOptions
+impl vortex_array::Array<vortex_array::arrays::List>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::List>::into_data_parts(self) -> vortex_array::arrays::list::ListDataParts
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::List>::new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::List>::new_unchecked(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::List>::try_new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::Array<vortex_array::arrays::ListView>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::ListView>::into_data_parts(self) -> vortex_array::arrays::listview::ListViewDataParts
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::ListView>::new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::is_null_sensitive(&self, _options: &Self::Options) -> bool
+pub unsafe fn vortex_array::Array<vortex_array::arrays::ListView>::new_unchecked(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::ListView>::try_new(elements: vortex_array::ArrayRef, offsets: vortex_array::ArrayRef, sizes: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::ListView>::with_zero_copy_to_list(self, is_zctl: bool) -> Self
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl vortex_array::Array<vortex_array::arrays::ListView>
 
-pub fn vortex_array::scalar_fn::fns::fill_null::FillNull::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::ListView>::rebuild(&self, mode: vortex_array::arrays::listview::ListViewRebuildMode) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::get_item::GetItem
+impl vortex_array::Array<vortex_array::arrays::Masked>
 
-pub type vortex_array::scalar_fn::fns::get_item::GetItem::Options = vortex_array::dtype::FieldName
+pub fn vortex_array::Array<vortex_array::arrays::Masked>::try_new(child: vortex_array::ArrayRef, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::arity(&self, _field_name: &vortex_array::dtype::FieldName) -> vortex_array::scalar_fn::Arity
+impl vortex_array::Array<vortex_array::arrays::Primitive>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::empty<T: vortex_array::dtype::NativePType>(nullability: vortex_array::dtype::Nullability) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::from_buffer_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::execute(&self, field_name: &vortex_array::dtype::FieldName, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::from_byte_buffer(buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::fmt_sql(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::from_values_byte_buffer(valid_elems_buffer: vortex_buffer::ByteBuffer, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity, n_rows: usize) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::into_data_parts(self) -> vortex_array::arrays::primitive::PrimitiveDataParts
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_fallible(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::map_each_with_validity<T, R, F>(self, f: F) -> vortex_error::VortexResult<Self> where T: vortex_array::dtype::NativePType, R: vortex_array::dtype::NativePType, F: core::ops::function::FnMut((T, bool)) -> R
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::is_null_sensitive(&self, _field_name: &vortex_array::dtype::FieldName) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::new<T: vortex_array::dtype::NativePType>(buffer: impl core::convert::Into<vortex_buffer::buffer::Buffer<T>>, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::reduce(&self, field_name: &vortex_array::dtype::FieldName, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Primitive>::new_unchecked<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::return_dtype(&self, field_name: &vortex_array::dtype::FieldName, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Primitive>::new_unchecked_from_handle(handle: vortex_array::buffer::BufferHandle, ptype: vortex_array::dtype::PType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::try_new<T: vortex_array::dtype::NativePType>(buffer: vortex_buffer::buffer::Buffer<T>, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::simplify_untyped(&self, field_name: &vortex_array::dtype::FieldName, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::validate<T: vortex_array::dtype::NativePType>(buffer: &vortex_buffer::buffer::Buffer<T>, validity: &vortex_array::validity::Validity) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::get_item::GetItem::stat_expression(&self, field_name: &vortex_array::dtype::FieldName, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+impl vortex_array::Array<vortex_array::arrays::Primitive>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::is_null::IsNull
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::from_option_iter<T: vortex_array::dtype::NativePType, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
 
-pub type vortex_array::scalar_fn::fns::is_null::IsNull::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::into_buffer<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> vortex_buffer::buffer_mut::BufferMut<T>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::to_buffer<T: vortex_array::dtype::NativePType>(&self) -> vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::try_into_buffer_mut<T: vortex_array::dtype::NativePType>(self) -> core::result::Result<vortex_buffer::buffer_mut::BufferMut<T>, vortex_buffer::buffer::Buffer<T>>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::execute(&self, _data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::Array<vortex_array::arrays::Primitive>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::patch(self, patches: &vortex_array::patches::Patches, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl vortex_array::Array<vortex_array::arrays::Primitive>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::Primitive>::top_value(&self) -> vortex_error::VortexResult<core::option::Option<(vortex_array::scalar::PValue, usize)>>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+impl vortex_array::Array<vortex_array::arrays::Shared>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::Shared>::new(source: vortex_array::ArrayRef) -> Self
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::Array<vortex_array::arrays::Struct>
 
-pub fn vortex_array::scalar_fn::fns::is_null::IsNull::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::from_fields<N: core::convert::AsRef<str>>(items: &[(N, vortex_array::ArrayRef)]) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::like::Like
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::into_data_parts(self) -> vortex_array::arrays::struct_::StructDataParts
 
-pub type vortex_array::scalar_fn::fns::like::Like::Options = vortex_array::scalar_fn::fns::like::LikeOptions
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::new(names: vortex_array::dtype::FieldNames, fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, length: usize, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::like::Like::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::new_fieldless_with_len(len: usize) -> Self
 
-pub fn vortex_array::scalar_fn::fns::like::Like::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub unsafe fn vortex_array::Array<vortex_array::arrays::Struct>::new_unchecked(fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, dtype: vortex_array::dtype::StructFields, length: usize, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::like::Like::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::project(&self, projection: &[vortex_array::dtype::FieldName]) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::remove_column(&self, name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> core::option::Option<(Self, vortex_array::ArrayRef)>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::try_from_iter<N: core::convert::AsRef<str>, A: vortex_array::IntoArray, T: core::iter::traits::collect::IntoIterator<Item = (N, A)>>(iter: T) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::try_from_iter_with_validity<N: core::convert::AsRef<str>, A: vortex_array::IntoArray, T: core::iter::traits::collect::IntoIterator<Item = (N, A)>>(iter: T, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::try_new(names: vortex_array::dtype::FieldNames, fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, length: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::try_new_with_dtype(fields: impl core::convert::Into<alloc::sync::Arc<[vortex_array::ArrayRef]>>, dtype: vortex_array::dtype::StructFields, length: usize, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::Array<vortex_array::arrays::Struct>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::stat_falsification(&self, like_opts: &vortex_array::scalar_fn::fns::like::LikeOptions, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::into_record_batch_with_schema(self, schema: impl core::convert::AsRef<arrow_schema::schema::Schema>) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
 
-pub fn vortex_array::scalar_fn::fns::like::Like::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl vortex_array::Array<vortex_array::arrays::Struct>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::list_contains::ListContains
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::remove_column_owned(&self, name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> core::option::Option<(Self, vortex_array::ArrayRef)>
 
-pub type vortex_array::scalar_fn::fns::list_contains::ListContains::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::Array<vortex_array::arrays::Struct>::with_column(&self, name: impl core::convert::Into<vortex_array::dtype::FieldName>, array: vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+impl vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_bytes(value: alloc::vec::Vec<&[u8]>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter_nonnull<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_nullable_bytes(value: alloc::vec::Vec<core::option::Option<&[u8]>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_nullable_strs(value: alloc::vec::Vec<core::option::Option<&str>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_strs(value: alloc::vec::Vec<&str>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_vec<T: core::convert::AsRef<[u8]>>(vec: alloc::vec::Vec<T>, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::into_data_parts(self) -> vortex_array::arrays::varbin::VarBinDataParts
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::list_contains::ListContains::stat_falsification(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::new(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::literal::Literal
+pub unsafe fn vortex_array::Array<vortex_array::arrays::VarBin>::new_unchecked(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub type vortex_array::scalar_fn::fns::literal::Literal::Options = vortex_array::scalar::Scalar
+pub unsafe fn vortex_array::Array<vortex_array::arrays::VarBin>::new_unchecked_from_handle(offsets: vortex_array::ArrayRef, bytes: vortex_array::buffer::BufferHandle, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::try_new(offsets: vortex_array::ArrayRef, bytes: vortex_buffer::ByteBuffer, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::child_name(&self, _instance: &Self::Options, _child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::deserialize(&self, _metadata: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::compact_buffers(&self) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::execute(&self, scalar: &vortex_array::scalar::Scalar, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::compact_with_threshold(&self, buffer_utilization_threshold: f64) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::fmt_sql(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I, dtype: vortex_array::dtype::DType) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter_nullable_bin<T: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::return_dtype(&self, options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter_nullable_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = core::option::Option<T>>>(iter: I) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter_str<T: core::convert::AsRef<str>, I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::stat_expression(&self, scalar: &vortex_array::scalar::Scalar, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, _catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::into_data_parts(self) -> vortex_array::arrays::varbinview::VarBinViewDataParts
 
-pub fn vortex_array::scalar_fn::fns::literal::Literal::validity(&self, scalar: &vortex_array::scalar::Scalar, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::new_handle(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::mask::Mask
+pub unsafe fn vortex_array::Array<vortex_array::arrays::VarBinView>::new_handle_unchecked(views: vortex_array::buffer::BufferHandle, buffers: alloc::sync::Arc<[vortex_array::buffer::BufferHandle]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub type vortex_array::scalar_fn::fns::mask::Mask::Options = vortex_array::scalar_fn::EmptyOptions
+pub unsafe fn vortex_array::Array<vortex_array::arrays::VarBinView>::new_unchecked(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> Self
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::try_new(views: vortex_buffer::buffer::Buffer<vortex_array::arrays::varbinview::BinaryView>, buffers: alloc::sync::Arc<[vortex_buffer::ByteBuffer]>, dtype: vortex_array::dtype::DType, validity: vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl vortex_array::Array<vortex_array::arrays::Variant>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::Variant>::new(child: vortex_array::ArrayRef) -> Self
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::Array<vortex_array::arrays::dict::Dict>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::dict::Dict>::new(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> Self
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub unsafe fn vortex_array::Array<vortex_array::arrays::dict::Dict>::new_unchecked(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> Self
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub unsafe fn vortex_array::Array<vortex_array::arrays::dict::Dict>::set_all_values_referenced(self, all_values_referenced: bool) -> Self
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<vortex_array::arrays::dict::Dict>::try_new(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl vortex_array::Array<vortex_array::arrays::null::Null>
 
-pub fn vortex_array::scalar_fn::fns::mask::Mask::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::null::Null>::new(len: usize) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::merge::Merge
+impl vortex_array::Array<vortex_array::arrays::scalar_fn::ScalarFnVTable>
 
-pub type vortex_array::scalar_fn::fns::merge::Merge::Options = vortex_array::scalar_fn::fns::merge::DuplicateHandling
+pub fn vortex_array::Array<vortex_array::arrays::scalar_fn::ScalarFnVTable>::try_new(scalar_fn: vortex_array::scalar_fn::ScalarFnRef, children: alloc::vec::Vec<vortex_array::ArrayRef>, len: usize) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+impl vortex_array::Array<vortex_array::arrays::slice::Slice>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::slice::Slice>::new(child: vortex_array::ArrayRef, range: core::ops::range::Range<usize>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::slice::Slice>::try_new(child: vortex_array::ArrayRef, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl<V: vortex_array::VTable> vortex_array::Array<V>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<V>::all_invalid(&self) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<V>::all_valid(&self) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::is_fallible(&self, instance: &Self::Options) -> bool
+pub fn vortex_array::Array<V>::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<V>::as_constant(&self) -> core::option::Option<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::reduce(&self, options: &Self::Options, node: &dyn vortex_array::scalar_fn::ReduceNode, ctx: &dyn vortex_array::scalar_fn::ReduceCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar_fn::ReduceNodeRef>>
+pub fn vortex_array::Array<V>::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<V>::invalid_count(&self) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<V>::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::scalar_fn::fns::merge::Merge::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<V>::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::not::Not
+pub fn vortex_array::Array<V>::nbuffers(&self) -> usize
 
-pub type vortex_array::scalar_fn::fns::not::Not::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::Array<V>::nbytes(&self) -> u64
 
-pub fn vortex_array::scalar_fn::fns::not::Not::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<V>::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<V>::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<V>::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::execute(&self, _data: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<V>::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<V>::valid_count(&self) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<V>::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::Array<V>::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::is_null_sensitive(&self, _options: &Self::Options) -> bool
+impl<V: vortex_array::VTable> vortex_array::Array<V>
 
-pub fn vortex_array::scalar_fn::fns::not::Not::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<V>::as_array(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::fns::not::Not::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<V>::as_view(&self) -> vortex_array::ArrayView<'_, V>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::pack::Pack
+pub fn vortex_array::Array<V>::data(&self) -> &<V as vortex_array::VTable>::ArrayData
 
-pub type vortex_array::scalar_fn::fns::pack::Pack::Options = vortex_array::scalar_fn::fns::pack::PackOptions
+pub fn vortex_array::Array<V>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::arity(&self, options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<V>::encoding_id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::child_name(&self, instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<V>::into_data(self) -> <V as vortex_array::VTable>::ArrayData
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<V>::is_empty(&self) -> bool
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::execute(&self, options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<V>::len(&self) -> usize
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::fmt_sql(&self, options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<V>::slots(&self) -> &[core::option::Option<vortex_array::ArrayRef>]
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<V>::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::is_fallible(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<V>::try_from_array_ref(array: vortex_array::ArrayRef) -> core::result::Result<Self, vortex_array::ArrayRef>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::is_null_sensitive(&self, _instance: &Self::Options) -> bool
+pub fn vortex_array::Array<V>::try_from_parts(new: vortex_array::ArrayParts<V>) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::return_dtype(&self, options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<V>::try_into_parts(self) -> core::result::Result<vortex_array::ArrayParts<V>, Self>
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::serialize(&self, instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<V>::with_stats_set(self, stats: vortex_array::stats::StatsSet) -> Self
 
-pub fn vortex_array::scalar_fn::fns::pack::Pack::validity(&self, _options: &Self::Options, _expression: &vortex_array::expr::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl core::convert::From<alloc::vec::Vec<&[u8]>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::root::Root
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<&[u8]>) -> Self
 
-pub type vortex_array::scalar_fn::fns::root::Root::Options = vortex_array::scalar_fn::EmptyOptions
+impl core::convert::From<alloc::vec::Vec<&str>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<&str>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::root::Root::child_name(&self, _instance: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+impl core::convert::From<alloc::vec::Vec<alloc::string::String>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<alloc::string::String>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::root::Root::execute(&self, _data: &Self::Options, _args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::fmt_sql(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::root::Root::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl core::convert::From<alloc::vec::Vec<core::option::Option<&[u8]>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::is_fallible(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<core::option::Option<&[u8]>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::root::Root::is_null_sensitive(&self, _options: &Self::Options) -> bool
+impl core::convert::From<alloc::vec::Vec<core::option::Option<&str>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<core::option::Option<&str>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::root::Root::serialize(&self, _instance: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::convert::From<alloc::vec::Vec<core::option::Option<alloc::string::String>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::root::Root::stat_expression(&self, _options: &Self::Options, _expr: &vortex_array::expr::Expression, stat: vortex_array::expr::stats::Stat, catalog: &dyn vortex_array::expr::pruning::StatsCatalog) -> core::option::Option<vortex_array::expr::Expression>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<core::option::Option<alloc::string::String>>) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::select::Select
+impl core::convert::From<alloc::vec::Vec<core::option::Option<alloc::vec::Vec<u8>>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub type vortex_array::scalar_fn::fns::select::Select::Options = vortex_array::scalar_fn::fns::select::FieldSelection
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from(value: alloc::vec::Vec<core::option::Option<alloc::vec::Vec<u8>>>) -> Self
 
-pub fn vortex_array::scalar_fn::fns::select::Select::arity(&self, _options: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_array::scalar_fn::Arity
+impl core::convert::TryFrom<vortex_array::Array<vortex_array::arrays::Extension>> for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::scalar_fn::fns::select::Select::child_name(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub type vortex_array::arrays::datetime::TemporalData::Error = vortex_error::VortexError
 
-pub fn vortex_array::scalar_fn::fns::select::Select::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::scalar_fn::fns::select::FieldSelection>
+pub fn vortex_array::arrays::datetime::TemporalData::try_from(ext: vortex_array::arrays::ExtensionArray) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::execute(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::string::String>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::fmt_sql(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::string::String>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::select::Select::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::string::String>> for vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::is_fallible(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::string::String>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::select::Select::is_null_sensitive(&self, _instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> bool
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::vec::Vec<u8>>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::return_dtype(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::vec::Vec<u8>>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::select::Select::serialize(&self, instance: &vortex_array::scalar_fn::fns::select::FieldSelection) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl core::iter::traits::collect::FromIterator<core::option::Option<alloc::vec::Vec<u8>>> for vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::select::Select::simplify(&self, selection: &vortex_array::scalar_fn::fns::select::FieldSelection, expr: &vortex_array::expr::Expression, ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<alloc::vec::Vec<u8>>>>(iter: T) -> Self
 
-impl vortex_array::scalar_fn::ScalarFnVTable for vortex_array::scalar_fn::fns::zip::Zip
+impl core::iter::traits::collect::FromIterator<vortex_array::ArrayRef> for vortex_array::Array<vortex_array::arrays::Chunked>
 
-pub type vortex_array::scalar_fn::fns::zip::Zip::Options = vortex_array::scalar_fn::EmptyOptions
+pub fn vortex_array::Array<vortex_array::arrays::Chunked>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::ArrayRef>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::Arity
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a [u8]>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::ChildName
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a [u8]>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::deserialize(&self, _metadata: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Options>
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a [u8]>> for vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::execute(&self, _options: &Self::Options, args: vortex_array::scalar_fn::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a [u8]>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a str>> for vortex_array::Array<vortex_array::arrays::VarBin>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+pub fn vortex_array::Array<vortex_array::arrays::VarBin>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a str>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::is_fallible(&self, _options: &Self::Options) -> bool
+impl<'a> core::iter::traits::collect::FromIterator<core::option::Option<&'a str>> for vortex_array::Array<vortex_array::arrays::VarBinView>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::is_null_sensitive(&self, _options: &Self::Options) -> bool
+pub fn vortex_array::Array<vortex_array::arrays::VarBinView>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = core::option::Option<&'a str>>>(iter: T) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+impl<V: vortex_array::VTable> core::clone::Clone for vortex_array::Array<V>
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::serialize(&self, _options: &Self::Options) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::Array<V>::clone(&self) -> Self
 
-pub fn vortex_array::scalar_fn::fns::zip::Zip::simplify(&self, _options: &Self::Options, expr: &vortex_array::expr::Expression, _ctx: &dyn vortex_array::scalar_fn::SimplifyCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::Expression>>
+impl<V: vortex_array::VTable> core::convert::AsRef<vortex_array::ArrayRef> for vortex_array::Array<V>
 
-pub trait vortex_array::scalar_fn::ScalarFnVTableExt: vortex_array::scalar_fn::ScalarFnVTable
+pub fn vortex_array::Array<V>::as_ref(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::ScalarFnVTableExt::bind(&self, options: Self::Options) -> vortex_array::scalar_fn::ScalarFnRef
+impl<V: vortex_array::VTable> core::convert::From<vortex_array::Array<V>> for vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::ScalarFnVTableExt::new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_array::expr::Expression
+pub fn vortex_array::ArrayRef::from(value: vortex_array::Array<V>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::scalar_fn::ScalarFnVTableExt::try_new_expr(&self, options: Self::Options, children: impl core::iter::traits::collect::IntoIterator<Item = vortex_array::expr::Expression>) -> vortex_error::VortexResult<vortex_array::expr::Expression>
+impl<V: vortex_array::VTable> core::fmt::Debug for vortex_array::Array<V>
 
-impl<V: vortex_array::scalar_fn::ScalarFnVTable> vortex_array::scalar_fn::ScalarFnVTableExt for V
+pub fn vortex_array::Array<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub trait vortex_array::scalar_fn::SimplifyCtx
+impl<V: vortex_array::VTable> core::ops::deref::Deref for vortex_array::Array<V>
 
-pub fn vortex_array::scalar_fn::SimplifyCtx::return_dtype(&self, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub type vortex_array::Array<V>::Target = <V as vortex_array::VTable>::ArrayData
 
-pub type vortex_array::scalar_fn::ChildName = arcref::ArcRef<str>
+pub fn vortex_array::Array<V>::deref(&self) -> &<V as vortex_array::VTable>::ArrayData
 
-pub type vortex_array::scalar_fn::ReduceNodeRef = alloc::sync::Arc<dyn vortex_array::scalar_fn::ReduceNode>
+impl<V: vortex_array::VTable> vortex_array::IntoArray for vortex_array::Array<V>
 
-pub type vortex_array::scalar_fn::ScalarFnId = arcref::ArcRef<str>
+pub fn vortex_array::Array<V>::into_array(self) -> vortex_array::ArrayRef
 
-pub mod vortex_array::search_sorted
+impl<V: vortex_array::VTable> vortex_array::TypedArrayRef<V> for vortex_array::Array<V>
 
-pub enum vortex_array::search_sorted::SearchResult
+pub fn vortex_array::Array<V>::to_owned(&self) -> vortex_array::Array<V>
 
-pub vortex_array::search_sorted::SearchResult::Found(usize)
+pub struct vortex_array::ArrayParts<V: vortex_array::VTable>
 
-pub vortex_array::search_sorted::SearchResult::NotFound(usize)
+pub vortex_array::ArrayParts::data: <V as vortex_array::VTable>::ArrayData
 
-impl vortex_array::search_sorted::SearchResult
+pub vortex_array::ArrayParts::dtype: vortex_array::dtype::DType
 
-pub fn vortex_array::search_sorted::SearchResult::to_ends_index(self, len: usize) -> usize
+pub vortex_array::ArrayParts::len: usize
 
-pub fn vortex_array::search_sorted::SearchResult::to_found(self) -> core::option::Option<usize>
+pub vortex_array::ArrayParts::slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::search_sorted::SearchResult::to_index(self) -> usize
+pub vortex_array::ArrayParts::vtable: V
 
-pub fn vortex_array::search_sorted::SearchResult::to_offsets_index(self, len: usize, side: vortex_array::search_sorted::SearchSortedSide) -> usize
+impl<V: vortex_array::VTable> vortex_array::ArrayParts<V>
 
-impl core::clone::Clone for vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayParts<V>::new(vtable: V, dtype: vortex_array::dtype::DType, len: usize, data: <V as vortex_array::VTable>::ArrayData) -> Self
 
-pub fn vortex_array::search_sorted::SearchResult::clone(&self) -> vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayParts<V>::with_slots(self, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> Self
 
-impl core::cmp::Eq for vortex_array::search_sorted::SearchResult
+pub struct vortex_array::ArrayRef(_)
 
-impl core::cmp::PartialEq for vortex_array::search_sorted::SearchResult
+impl vortex_array::ArrayRef
 
-pub fn vortex_array::search_sorted::SearchResult::eq(&self, other: &vortex_array::search_sorted::SearchResult) -> bool
+pub fn vortex_array::ArrayRef::all_invalid(&self) -> vortex_error::VortexResult<bool>
 
-impl core::fmt::Debug for vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayRef::all_valid(&self) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::search_sorted::SearchResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl core::fmt::Display for vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayRef::as_<M: vortex_array::matcher::Matcher>(&self) -> <M as vortex_array::matcher::Matcher>::Match
 
-pub fn vortex_array::search_sorted::SearchResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::as_constant(&self) -> core::option::Option<vortex_array::scalar::Scalar>
 
-impl core::marker::Copy for vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayRef::as_opt<M: vortex_array::matcher::Matcher>(&self) -> core::option::Option<<M as vortex_array::matcher::Matcher>::Match>
 
-impl core::marker::StructuralPartialEq for vortex_array::search_sorted::SearchResult
+pub fn vortex_array::ArrayRef::as_typed<V: vortex_array::VTable>(&self) -> core::option::Option<vortex_array::ArrayView<'_, V>>
 
-pub enum vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::buffer_handles(&self) -> alloc::vec::Vec<vortex_array::buffer::BufferHandle>
 
-pub vortex_array::search_sorted::SearchSortedSide::Left
+pub fn vortex_array::ArrayRef::buffer_names(&self) -> alloc::vec::Vec<alloc::string::String>
 
-pub vortex_array::search_sorted::SearchSortedSide::Right
+pub fn vortex_array::ArrayRef::buffers(&self) -> alloc::vec::Vec<vortex_buffer::ByteBuffer>
 
-impl core::clone::Clone for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
 
-pub fn vortex_array::search_sorted::SearchSortedSide::clone(&self) -> vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::children_names(&self) -> alloc::vec::Vec<alloc::string::String>
 
-impl core::cmp::Eq for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::depth_first_traversal(&self) -> vortex_array::DepthFirstArrayIterator
 
-impl core::cmp::PartialEq for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::downcast<V: vortex_array::VTable>(self) -> vortex_array::Array<V>
 
-pub fn vortex_array::search_sorted::SearchSortedSide::eq(&self, other: &vortex_array::search_sorted::SearchSortedSide) -> bool
+pub fn vortex_array::ArrayRef::dtype(&self) -> &vortex_array::dtype::DType
 
-impl core::fmt::Debug for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::encoding_id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::search_sorted::SearchSortedSide::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::execute_parent(&self, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Display for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::search_sorted::SearchSortedSide::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::into_canonical(self) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-impl core::marker::Copy for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::invalid_count(&self) -> vortex_error::VortexResult<usize>
 
-impl core::marker::StructuralPartialEq for vortex_array::search_sorted::SearchSortedSide
+pub fn vortex_array::ArrayRef::is<M: vortex_array::matcher::Matcher>(&self) -> bool
 
-pub trait vortex_array::search_sorted::IndexOrd<V>
+pub fn vortex_array::ArrayRef::is_arrow(&self) -> bool
 
-pub fn vortex_array::search_sorted::IndexOrd::index_cmp(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::ArrayRef::is_canonical(&self) -> bool
 
-pub fn vortex_array::search_sorted::IndexOrd::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayRef::is_empty(&self) -> bool
 
-pub fn vortex_array::search_sorted::IndexOrd::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayRef::is_host(&self) -> bool
 
-pub fn vortex_array::search_sorted::IndexOrd::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayRef::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::search_sorted::IndexOrd::index_len(&self) -> usize
+pub fn vortex_array::ArrayRef::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::search_sorted::IndexOrd::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayRef::len(&self) -> usize
 
-impl vortex_array::search_sorted::IndexOrd<core::option::Option<vortex_array::scalar::PValue>> for vortex_array::variants::PrimitiveTyped<'_>
+pub fn vortex_array::ArrayRef::metadata(&self, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &core::option::Option<vortex_array::scalar::PValue>) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::ArrayRef::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+pub fn vortex_array::ArrayRef::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
 
-impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
+pub fn vortex_array::ArrayRef::named_children(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::ArrayRef)>
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::ArrayRef::nbuffers(&self) -> usize
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+pub fn vortex_array::ArrayRef::nbuffers_recursive(&self) -> usize
 
-impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::Scalar> for (dyn vortex_array::Array + '_)
+pub fn vortex_array::ArrayRef::nbytes(&self) -> u64
 
-pub fn (dyn vortex_array::Array + '_)::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::ArrayRef::nchildren(&self) -> usize
 
-pub fn (dyn vortex_array::Array + '_)::index_len(&self) -> usize
+pub fn vortex_array::ArrayRef::nth_child(&self, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
 
-impl<T: core::cmp::PartialOrd> vortex_array::search_sorted::IndexOrd<T> for [T]
+pub fn vortex_array::ArrayRef::reduce(&self) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn [T]::index_cmp(&self, idx: usize, elem: &T) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+pub fn vortex_array::ArrayRef::reduce_parent(&self, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn [T]::index_len(&self) -> usize
+pub fn vortex_array::ArrayRef::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub trait vortex_array::search_sorted::SearchSorted<T>
+pub fn vortex_array::ArrayRef::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::search_sorted::SearchSorted::search_sorted(&self, value: &T, side: vortex_array::search_sorted::SearchSortedSide) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult> where Self: vortex_array::search_sorted::IndexOrd<T>
+pub fn vortex_array::ArrayRef::slot_name(&self, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::search_sorted::SearchSorted::search_sorted_by<F: core::ops::function::FnMut(usize) -> vortex_error::VortexResult<core::cmp::Ordering>, N: core::ops::function::FnMut(usize) -> vortex_error::VortexResult<core::cmp::Ordering>>(&self, find: F, side_find: N, side: vortex_array::search_sorted::SearchSortedSide) -> vortex_error::VortexResult<vortex_array::search_sorted::SearchResult>
+pub fn vortex_array::ArrayRef::slots(&self) -> &[core::option::Option<vortex_array::ArrayRef>]
 
-impl<S, T> vortex_array::search_sorted::SearchSorted<T> for S where S: vortex_array::search_sorted::IndexOrd<T> + ?core::marker::Sized
+pub fn vortex_array::ArrayRef::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
 
-pub fn S::search_sorted_by<F, N>(&self, find: F, side_find: N, side: vortex_array::search_sorted::SearchSortedSide) -> core::result::Result<vortex_array::search_sorted::SearchResult, vortex_error::VortexError> where F: core::ops::function::FnMut(usize) -> core::result::Result<core::cmp::Ordering, vortex_error::VortexError>, N: core::ops::function::FnMut(usize) -> core::result::Result<core::cmp::Ordering, vortex_error::VortexError>
+pub fn vortex_array::ArrayRef::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub mod vortex_array::serde
+pub fn vortex_array::ArrayRef::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
 
-pub struct vortex_array::serde::ArrayNodeFlatBuffer<'a>
+pub fn vortex_array::ArrayRef::try_downcast<V: vortex_array::VTable>(self) -> core::result::Result<vortex_array::Array<V>, vortex_array::ArrayRef>
 
-impl<'a> vortex_array::serde::ArrayNodeFlatBuffer<'a>
+pub fn vortex_array::ArrayRef::valid_count(&self) -> vortex_error::VortexResult<usize>
 
-pub fn vortex_array::serde::ArrayNodeFlatBuffer<'a>::try_new(ctx: &'a vortex_array::ArrayContext, array: &'a dyn vortex_array::Array) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::serde::ArrayNodeFlatBuffer<'a>::try_write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<vortex_flatbuffers::array::ArrayNode<'fb>>>
+pub fn vortex_array::ArrayRef::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
 
-pub struct vortex_array::serde::ArrayParts
+pub fn vortex_array::ArrayRef::with_slot(self, slot_idx: usize, replacement: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::serde::ArrayParts
+pub fn vortex_array::ArrayRef::with_slots(self, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::serde::ArrayParts::buffer(&self, idx: usize) -> vortex_error::VortexResult<vortex_array::buffer::BufferHandle>
+impl vortex_array::ArrayRef
 
-pub fn vortex_array::serde::ArrayParts::buffer_lengths(&self) -> alloc::vec::Vec<usize>
+pub fn vortex_array::ArrayRef::apply(self, expr: &vortex_array::expr::Expression) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::serde::ArrayParts::child(&self, idx: usize) -> vortex_array::serde::ArrayParts
+impl vortex_array::ArrayRef
 
-pub fn vortex_array::serde::ArrayParts::decode(&self, dtype: &vortex_array::dtype::DType, len: usize, ctx: &vortex_array::ArrayContext, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::ArrayRef::as_binary_typed(&self) -> vortex_array::variants::BinaryTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::encoding_id(&self) -> u16
+pub fn vortex_array::ArrayRef::as_bool_typed(&self) -> vortex_array::variants::BoolTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::from_array_tree(array_tree: impl core::convert::Into<vortex_buffer::ByteBuffer>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::as_decimal_typed(&self) -> vortex_array::variants::DecimalTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::from_flatbuffer_and_segment(array_tree: vortex_buffer::ByteBuffer, segment: vortex_array::buffer::BufferHandle) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::as_extension_typed(&self) -> vortex_array::variants::ExtensionTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::from_flatbuffer_and_segment_with_overrides(array_tree: vortex_buffer::ByteBuffer, segment: vortex_array::buffer::BufferHandle, buffer_overrides: &vortex_utils::aliases::hash_map::HashMap<u32, vortex_buffer::ByteBuffer>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::as_list_typed(&self) -> vortex_array::variants::ListTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::from_flatbuffer_with_buffers(array_tree: impl core::convert::Into<vortex_buffer::ByteBuffer>, buffers: alloc::vec::Vec<vortex_array::buffer::BufferHandle>) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayRef::as_null_typed(&self) -> vortex_array::variants::NullTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::metadata(&self) -> &[u8]
+pub fn vortex_array::ArrayRef::as_primitive_typed(&self) -> vortex_array::variants::PrimitiveTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::nbuffers(&self) -> usize
+pub fn vortex_array::ArrayRef::as_struct_typed(&self) -> vortex_array::variants::StructTyped<'_>
 
-pub fn vortex_array::serde::ArrayParts::nchildren(&self) -> usize
+pub fn vortex_array::ArrayRef::as_utf8_typed(&self) -> vortex_array::variants::Utf8Typed<'_>
 
-impl core::clone::Clone for vortex_array::serde::ArrayParts
+pub fn vortex_array::ArrayRef::try_to_mask_fill_null_false(&self, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_mask::Mask>
 
-pub fn vortex_array::serde::ArrayParts::clone(&self) -> vortex_array::serde::ArrayParts
+impl vortex_array::ArrayRef
 
-impl core::convert::TryFrom<vortex_array::buffer::BufferHandle> for vortex_array::serde::ArrayParts
+pub fn vortex_array::ArrayRef::display_as(&self, options: vortex_array::display::DisplayOptions) -> impl core::fmt::Display
 
-pub type vortex_array::serde::ArrayParts::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::display_tree(&self) -> vortex_array::display::TreeDisplay
 
-pub fn vortex_array::serde::ArrayParts::try_from(value: vortex_array::buffer::BufferHandle) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::display_tree_encodings_only(&self) -> vortex_array::display::TreeDisplay
 
-impl core::convert::TryFrom<vortex_buffer::buffer::Buffer<u8>> for vortex_array::serde::ArrayParts
+pub fn vortex_array::ArrayRef::display_values(&self) -> impl core::fmt::Display
 
-pub type vortex_array::serde::ArrayParts::Error = vortex_error::VortexError
+pub fn vortex_array::ArrayRef::tree_display(&self) -> vortex_array::display::TreeDisplay
 
-pub fn vortex_array::serde::ArrayParts::try_from(value: vortex_buffer::ByteBuffer) -> core::result::Result<Self, Self::Error>
+pub fn vortex_array::ArrayRef::tree_display_builder(&self) -> vortex_array::display::TreeDisplay
 
-impl core::fmt::Debug for vortex_array::serde::ArrayParts
+impl vortex_array::ArrayRef
 
-pub fn vortex_array::serde::ArrayParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::execute<E: vortex_array::Executable>(self, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<E>
 
-pub struct vortex_array::serde::SerializeOptions
+pub fn vortex_array::ArrayRef::execute_as<E: vortex_array::Executable>(self, _name: &'static str, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<E>
 
-pub vortex_array::serde::SerializeOptions::include_padding: bool
+pub fn vortex_array::ArrayRef::execute_until<M: vortex_array::matcher::Matcher>(self, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub vortex_array::serde::SerializeOptions::offset: usize
+impl vortex_array::ArrayRef
 
-impl core::default::Default for vortex_array::serde::SerializeOptions
+pub fn vortex_array::ArrayRef::normalize(self, options: &mut vortex_array::normalize::NormalizeOptions<'_>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::serde::SerializeOptions::default() -> vortex_array::serde::SerializeOptions
+impl vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::serde::SerializeOptions
+pub fn vortex_array::ArrayRef::ptr_eq(this: &vortex_array::ArrayRef, other: &vortex_array::ArrayRef) -> bool
 
-pub fn vortex_array::serde::SerializeOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::ArrayRef
 
-pub trait vortex_array::serde::ArrayChildren
+pub fn vortex_array::ArrayRef::serialize(&self, ctx: &vortex_array::ArrayContext, session: &vortex_session::VortexSession, options: &vortex_array::serde::SerializeOptions) -> vortex_error::VortexResult<alloc::vec::Vec<vortex_buffer::ByteBuffer>>
 
-pub fn vortex_array::serde::ArrayChildren::get(&self, index: usize, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::ArrayRef
 
-pub fn vortex_array::serde::ArrayChildren::is_empty(&self) -> bool
+pub fn vortex_array::ArrayRef::to_array_iterator(&self) -> impl vortex_array::iter::ArrayIterator + 'static
 
-pub fn vortex_array::serde::ArrayChildren::len(&self) -> usize
+impl vortex_array::ArrayRef
 
-impl vortex_array::serde::ArrayChildren for &[vortex_array::ArrayRef]
+pub fn vortex_array::ArrayRef::to_array_stream(&self) -> impl vortex_array::stream::ArrayStream + 'static
 
-pub fn &[vortex_array::ArrayRef]::get(&self, index: usize, dtype: &vortex_array::dtype::DType, len: usize) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl core::clone::Clone for vortex_array::ArrayRef
 
-pub fn &[vortex_array::ArrayRef]::len(&self) -> usize
+pub fn vortex_array::ArrayRef::clone(&self) -> vortex_array::ArrayRef
 
-pub mod vortex_array::session
+impl core::convert::From<vortex_array::Canonical> for vortex_array::ArrayRef
 
-pub struct vortex_array::session::ArraySession
+pub fn vortex_array::ArrayRef::from(value: vortex_array::Canonical) -> Self
 
-impl vortex_array::session::ArraySession
+impl core::convert::From<vortex_array::arrays::datetime::TemporalData> for vortex_array::ArrayRef
 
-pub fn vortex_array::session::ArraySession::register(&self, id: impl core::convert::Into<vortex_array::vtable::ArrayId>, encoding: impl core::convert::Into<&'static dyn vortex_array::vtable::DynVTable>)
+pub fn vortex_array::ArrayRef::from(value: vortex_array::arrays::datetime::TemporalData) -> Self
 
-pub fn vortex_array::session::ArraySession::registry(&self) -> &vortex_array::session::ArrayRegistry
+impl core::convert::TryFrom<&vortex_array::ArrayRef> for arrow_array::record_batch::RecordBatch
 
-impl core::default::Default for vortex_array::session::ArraySession
+pub type arrow_array::record_batch::RecordBatch::Error = vortex_error::VortexError
 
-pub fn vortex_array::session::ArraySession::default() -> Self
+pub fn arrow_array::record_batch::RecordBatch::try_from(value: &vortex_array::ArrayRef) -> vortex_error::VortexResult<Self>
 
-impl core::fmt::Debug for vortex_array::session::ArraySession
+impl core::convert::TryFrom<vortex_array::ArrayRef> for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::session::ArraySession::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::datetime::TemporalData::Error = vortex_error::VortexError
 
-pub trait vortex_array::session::ArraySessionExt: vortex_session::SessionExt
+pub fn vortex_array::arrays::datetime::TemporalData::try_from(value: vortex_array::ArrayRef) -> core::result::Result<Self, Self::Error>
 
-pub fn vortex_array::session::ArraySessionExt::arrays(&self) -> vortex_session::Ref<'_, vortex_array::session::ArraySession>
+impl core::fmt::Debug for vortex_array::ArrayRef
 
-impl<S: vortex_session::SessionExt> vortex_array::session::ArraySessionExt for S
+pub fn vortex_array::ArrayRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub type vortex_array::session::ArrayRegistry = vortex_session::registry::Registry<&'static dyn vortex_array::vtable::DynVTable>
+impl core::fmt::Display for vortex_array::ArrayRef
 
-pub mod vortex_array::stats
+pub fn vortex_array::ArrayRef::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub mod vortex_array::stats::flatbuffers
+impl core::iter::traits::collect::FromIterator<vortex_array::ArrayRef> for vortex_array::Array<vortex_array::arrays::Chunked>
 
-pub struct vortex_array::stats::ArrayStats
+pub fn vortex_array::Array<vortex_array::arrays::Chunked>::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_array::ArrayRef>>(iter: T) -> Self
 
-impl vortex_array::stats::ArrayStats
+impl vortex_array::ArrayEq for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::ArrayStats::clear(&self, stat: vortex_array::expr::stats::Stat)
+pub fn vortex_array::ArrayRef::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::stats::ArrayStats::retain(&self, stats: &[vortex_array::expr::stats::Stat])
+impl vortex_array::ArrayHash for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::ArrayStats::set(&self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+pub fn vortex_array::ArrayRef::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::stats::ArrayStats::to_ref<'a>(&'a self, array: &'a dyn vortex_array::Array) -> vortex_array::stats::StatsSetRef<'a>
+impl vortex_array::Executable for vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::ArrayStats::clone(&self) -> vortex_array::stats::ArrayStats
+impl vortex_array::IntoArray for vortex_array::ArrayRef
 
-impl core::convert::From<vortex_array::stats::ArrayStats> for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::from(value: vortex_array::stats::ArrayStats) -> Self
+impl vortex_array::ToCanonical for vortex_array::ArrayRef
 
-impl core::convert::From<vortex_array::stats::StatsSet> for vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::to_bool(&self) -> vortex_array::arrays::BoolArray
 
-pub fn vortex_array::stats::ArrayStats::from(value: vortex_array::stats::StatsSet) -> Self
+pub fn vortex_array::ArrayRef::to_decimal(&self) -> vortex_array::arrays::DecimalArray
 
-impl core::default::Default for vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::to_extension(&self) -> vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::stats::ArrayStats::default() -> vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::to_fixed_size_list(&self) -> vortex_array::arrays::FixedSizeListArray
 
-impl core::fmt::Debug for vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::to_listview(&self) -> vortex_array::arrays::ListViewArray
 
-pub fn vortex_array::stats::ArrayStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::ArrayRef::to_null(&self) -> vortex_array::arrays::null::NullArray
 
-pub struct vortex_array::stats::MutTypedStatsSetRef<'a, 'b>
+pub fn vortex_array::ArrayRef::to_primitive(&self) -> vortex_array::arrays::PrimitiveArray
 
-pub vortex_array::stats::MutTypedStatsSetRef::dtype: &'b vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::to_struct(&self) -> vortex_array::arrays::StructArray
 
-pub vortex_array::stats::MutTypedStatsSetRef::values: &'a mut vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::to_varbinview(&self) -> vortex_array::arrays::VarBinViewArray
 
-impl vortex_array::stats::MutTypedStatsSetRef<'_, '_>
+impl vortex_array::arrow::ArrowArrayExecutor for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::clear(&mut self, stat: vortex_array::expr::stats::Stat)
+pub fn vortex_array::ArrayRef::execute_arrow(self, data_type: core::option::Option<&arrow_schema::datatype::DataType>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::set(&mut self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+pub fn vortex_array::ArrayRef::execute_record_batch(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<arrow_array::record_batch::RecordBatch>
 
-impl vortex_array::stats::MutTypedStatsSetRef<'_, '_>
+pub fn vortex_array::ArrayRef::execute_record_batches(self, schema: &arrow_schema::schema::Schema, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<alloc::vec::Vec<arrow_array::record_batch::RecordBatch>>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::combine_sets(&mut self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> vortex_error::VortexResult<()>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::boolean_array::BooleanArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::merge_ordered(self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::boolean_array::BooleanArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::merge_unordered(self, other: &vortex_array::stats::TypedStatsSetRef<'_, '_>) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::fixed_size_list_array::FixedSizeListArray> for vortex_array::ArrayRef
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::fixed_size_list_array::FixedSizeListArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::map_array::MapArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::len(&self) -> usize
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::map_array::MapArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub struct vortex_array::stats::StatsSet
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::null_array::NullArray> for vortex_array::ArrayRef
 
-impl vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::null_array::NullArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::as_mut_typed_ref<'a, 'b>(&'a mut self, dtype: &'b vortex_array::dtype::DType) -> vortex_array::stats::MutTypedStatsSetRef<'a, 'b>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::as_typed_ref<'a, 'b>(&'a self, dtype: &'b vortex_array::dtype::DType) -> vortex_array::stats::TypedStatsSetRef<'a, 'b>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub unsafe fn vortex_array::stats::StatsSet::new_unchecked(values: alloc::vec::Vec<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::of(stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Date64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::stats::StatsSet
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::clear(&mut self, stat: vortex_array::expr::stats::Stat)
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal128Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat, dtype: &vortex_array::dtype::DType) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal256Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::is_empty(&self) -> bool
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::iter(&self) -> impl core::iter::traits::iterator::Iterator<Item = &(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::len(&self) -> usize
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::retain_only(&mut self, stats: &[vortex_array::expr::stats::Stat])
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Decimal64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::set(&mut self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>> for vortex_array::ArrayRef
 
-impl vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::combine_sets(&mut self, other: &Self, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::merge_ordered(self, other: &Self, dtype: &vortex_array::dtype::DType) -> Self
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::merge_unordered(self, other: &Self, dtype: &vortex_array::dtype::DType) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>> for vortex_array::ArrayRef
 
-impl vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Float64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::from_flatbuffer<'a>(fb: &vortex_flatbuffers::array::ArrayStats<'a>, array_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>> for vortex_array::ArrayRef
 
-impl core::clone::Clone for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::clone(&self) -> vortex_array::stats::StatsSet
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>> for vortex_array::ArrayRef
 
-impl core::convert::From<vortex_array::stats::ArrayStats> for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::from(value: vortex_array::stats::ArrayStats) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>> for vortex_array::ArrayRef
 
-impl core::convert::From<vortex_array::stats::StatsSet> for vortex_array::stats::ArrayStats
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::ArrayStats::from(value: vortex_array::stats::StatsSet) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>> for vortex_array::ArrayRef
 
-impl core::default::Default for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Int8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::default() -> vortex_array::stats::StatsSet
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>> for vortex_array::ArrayRef
 
-impl core::fmt::Debug for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32MillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>> for vortex_array::ArrayRef
 
-impl core::iter::traits::collect::Extend<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)> for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time32SecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::extend<T: core::iter::traits::collect::IntoIterator<Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>>(&mut self, iter: T)
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>> for vortex_array::ArrayRef
 
-impl core::iter::traits::collect::FromIterator<(vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)> for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64MicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::from_iter<T: core::iter::traits::collect::IntoIterator<Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>>(iter: T) -> Self
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>> for vortex_array::ArrayRef
 
-impl core::iter::traits::collect::IntoIterator for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::Time64NanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::stats::StatsSet::IntoIter = vortex_array::stats::StatsSetIntoIter
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>> for vortex_array::ArrayRef
 
-pub type vortex_array::stats::StatsSet::Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMicrosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSet::into_iter(self) -> Self::IntoIter
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>> for vortex_array::ArrayRef
 
-impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampMillisecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::stats::StatsSet::Target<'t> = vortex_flatbuffers::array::ArrayStats<'t>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSet::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampNanosecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub struct vortex_array::stats::StatsSetIntoIter(_)
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>> for vortex_array::ArrayRef
 
-impl core::iter::traits::iterator::Iterator for vortex_array::stats::StatsSetIntoIter
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::TimestampSecondType>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub type vortex_array::stats::StatsSetIntoIter::Item = (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetIntoIter::next(&mut self) -> core::option::Option<Self::Item>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt16Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub struct vortex_array::stats::StatsSetRef<'a>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>> for vortex_array::ArrayRef
 
-impl vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt32Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::clear(&self, stat: vortex_array::expr::stats::Stat)
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_as<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<U>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt64Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_constant(&self) -> core::option::Option<bool>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_sorted(&self) -> core::option::Option<bool>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::primitive_array::PrimitiveArray<arrow_array::types::UInt8Type>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_is_strict_sorted(&self) -> core::option::Option<bool>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::array::struct_array::StructArray> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_max<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self) -> core::option::Option<U>
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::struct_array::StructArray, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_min<U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self) -> core::option::Option<U>
+impl vortex_array::arrow::FromArrowArray<&arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_null_count(&self) -> core::option::Option<usize>
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_uncompressed_size_in_bytes(&self) -> core::option::Option<usize>
+impl vortex_array::arrow::FromArrowArray<&dyn arrow_array::array::Array> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::set(&self, stat: vortex_array::expr::stats::Stat, value: vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)
+pub fn vortex_array::ArrayRef::from_arrow(array: &dyn arrow_array::array::Array, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::arrow::FromArrowArray<arrow_array::record_batch::RecordBatch> for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_all(&self, stats: &[vortex_array::expr::stats::Stat]) -> vortex_error::VortexResult<vortex_array::stats::StatsSet>
+pub fn vortex_array::ArrayRef::from_arrow(array: arrow_array::record_batch::RecordBatch, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::compute_stat(&self, stat: vortex_array::expr::stats::Stat) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::Scalar>>
+impl vortex_array::arrow::IntoArrowArray for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::inherit<'a>(&self, iter: impl core::iter::traits::iterator::Iterator<Item = &'a (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>)
+pub fn vortex_array::ArrayRef::into_arrow(self, data_type: &arrow_schema::datatype::DataType) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::inherit_from(&self, stats: vortex_array::stats::StatsSetRef<'_>)
+pub fn vortex_array::ArrayRef::into_arrow_preferred(self) -> vortex_error::VortexResult<arrow_array::array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::set_iter(&self, iter: vortex_array::stats::StatsSetIntoIter)
+impl vortex_array::builtins::ArrayBuiltins for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::StatsSetRef<'_>::to_owned(&self) -> vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::between(self, lower: vortex_array::ArrayRef, upper: vortex_array::ArrayRef, options: vortex_array::scalar_fn::fns::between::BetweenOptions) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::with_iter<F: for<'a> core::ops::function::FnOnce(&mut dyn core::iter::traits::iterator::Iterator<Item = &'a (vortex_array::expr::stats::Stat, vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>)>) -> R, R>(&self, f: F) -> R
+pub fn vortex_array::ArrayRef::binary(&self, rhs: vortex_array::ArrayRef, op: vortex_array::scalar_fn::fns::operators::Operator) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::with_mut_typed_stats_set<U, F: core::ops::function::FnOnce(vortex_array::stats::MutTypedStatsSetRef<'_, '_>) -> U>(&self, apply: F) -> U
+pub fn vortex_array::ArrayRef::cast(&self, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::with_typed_stats_set<U, F: core::ops::function::FnOnce(vortex_array::stats::TypedStatsSetRef<'_, '_>) -> U>(&self, apply: F) -> U
+pub fn vortex_array::ArrayRef::fill_null(&self, fill_value: impl core::convert::Into<vortex_array::scalar::Scalar>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::ArrayRef::get_item(&self, field_name: impl core::convert::Into<vortex_array::dtype::FieldName>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::ArrayRef::is_null(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::len(&self) -> usize
+pub fn vortex_array::ArrayRef::list_contains(&self, value: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_flatbuffers::WriteFlatBuffer for vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::ArrayRef::mask(self, mask: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub type vortex_array::stats::StatsSetRef<'_>::Target<'t> = vortex_flatbuffers::array::ArrayStats<'t>
+pub fn vortex_array::ArrayRef::not(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::write_flatbuffer<'fb>(&self, fbb: &mut flatbuffers::builder::FlatBufferBuilder<'fb>) -> vortex_error::VortexResult<flatbuffers::primitives::WIPOffset<Self::Target>>
+pub fn vortex_array::ArrayRef::zip(&self, if_true: vortex_array::ArrayRef, if_false: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub struct vortex_array::stats::TypedStatsSetRef<'a, 'b>
+impl vortex_array::optimizer::ArrayOptimizer for vortex_array::ArrayRef
 
-pub vortex_array::stats::TypedStatsSetRef::dtype: &'b vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::optimize(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub vortex_array::stats::TypedStatsSetRef::values: &'a vortex_array::stats::StatsSet
+pub fn vortex_array::ArrayRef::optimize_recursive(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
+impl vortex_array::scalar_fn::ReduceNode for vortex_array::ArrayRef
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, stat: vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::ArrayRef::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::len(&self) -> usize
+pub fn vortex_array::ArrayRef::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
 
-pub const vortex_array::stats::PRUNING_STATS: &[vortex_array::expr::stats::Stat]
+pub fn vortex_array::ArrayRef::child_count(&self) -> usize
 
-pub fn vortex_array::stats::as_stat_bitset_bytes(stats: &[vortex_array::expr::stats::Stat]) -> alloc::vec::Vec<u8>
+pub fn vortex_array::ArrayRef::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
 
-pub fn vortex_array::stats::stats_from_bitset_bytes(bytes: &[u8]) -> alloc::vec::Vec<vortex_array::expr::stats::Stat>
+pub fn vortex_array::ArrayRef::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
 
-pub mod vortex_array::stream
+impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::Scalar> for vortex_array::ArrayRef
 
-pub struct vortex_array::stream::ArrayStreamAdapter<S>
+pub fn vortex_array::ArrayRef::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::Scalar) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
 
-impl<S> vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+pub fn vortex_array::ArrayRef::index_ge(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::stream::ArrayStreamAdapter<S>::new(dtype: vortex_array::dtype::DType, inner: S) -> Self
+pub fn vortex_array::ArrayRef::index_gt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl<'__pin, S> core::marker::Unpin for vortex_array::stream::ArrayStreamAdapter<S> where pin_project_lite::__private::PinnedFieldsOf<__Origin<'__pin, S>>: core::marker::Unpin
+pub fn vortex_array::ArrayRef::index_le(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-impl<S> futures_core::stream::Stream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+pub fn vortex_array::ArrayRef::index_len(&self) -> usize
 
-pub type vortex_array::stream::ArrayStreamAdapter<S>::Item = core::result::Result<alloc::sync::Arc<dyn vortex_array::Array>, vortex_error::VortexError>
+pub fn vortex_array::ArrayRef::index_lt(&self, idx: usize, elem: &V) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_array::stream::ArrayStreamAdapter<S>::poll_next(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<core::option::Option<Self::Item>>
+impl<O: arrow_array::array::list_array::OffsetSizeTrait + vortex_array::dtype::NativePType> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_view_array::GenericListViewArray<O>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stream::ArrayStreamAdapter<S>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn vortex_array::ArrayRef::from_arrow(array: &arrow_array::array::list_view_array::GenericListViewArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl<S> vortex_array::stream::ArrayStream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+impl<O: vortex_array::dtype::IntegerPType + arrow_array::array::list_array::OffsetSizeTrait> vortex_array::arrow::FromArrowArray<&arrow_array::array::list_array::GenericListArray<O>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stream::ArrayStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::list_array::GenericListArray<O>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-pub trait vortex_array::stream::ArrayStream: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+impl<T: arrow_array::types::ByteArrayType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_array::GenericByteArray<T>> for vortex_array::ArrayRef where <T as arrow_array::types::ByteArrayType>::Offset: vortex_array::dtype::IntegerPType
 
-pub fn vortex_array::stream::ArrayStream::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_array::GenericByteArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::stream::ArrayStream for vortex_array::stream::SendableArrayStream
+impl<T: arrow_array::types::ByteViewType> vortex_array::arrow::FromArrowArray<&arrow_array::array::byte_view_array::GenericByteViewArray<T>> for vortex_array::ArrayRef
 
-pub fn vortex_array::stream::SendableArrayStream::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::from_arrow(value: &arrow_array::array::byte_view_array::GenericByteViewArray<T>, nullable: bool) -> vortex_error::VortexResult<Self>
 
-impl<S> vortex_array::stream::ArrayStream for vortex_array::stream::ArrayStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<vortex_array::ArrayRef>>
+impl<V: vortex_array::VTable> core::convert::AsRef<vortex_array::ArrayRef> for vortex_array::Array<V>
 
-pub fn vortex_array::stream::ArrayStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::Array<V>::as_ref(&self) -> &vortex_array::ArrayRef
 
-pub trait vortex_array::stream::ArrayStreamExt: vortex_array::stream::ArrayStream
+impl<V: vortex_array::VTable> core::convert::AsRef<vortex_array::ArrayRef> for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::stream::ArrayStreamExt::boxed(self) -> vortex_array::stream::SendableArrayStream where Self: core::marker::Sized + core::marker::Send + 'static
+pub fn vortex_array::ArrayView<'_, V>::as_ref(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::stream::ArrayStreamExt::read_all(self) -> impl core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::ArrayRef>> where Self: core::marker::Sized
+impl<V: vortex_array::VTable> core::convert::From<vortex_array::Array<V>> for vortex_array::ArrayRef
 
-impl<S: vortex_array::stream::ArrayStream> vortex_array::stream::ArrayStreamExt for S
+pub fn vortex_array::ArrayRef::from(value: vortex_array::Array<V>) -> vortex_array::ArrayRef
 
-pub type vortex_array::stream::SendableArrayStream = core::pin::Pin<alloc::boxed::Box<(dyn vortex_array::stream::ArrayStream + core::marker::Send)>>
+pub struct vortex_array::ArrayView<'a, V: vortex_array::VTable>
 
-pub mod vortex_array::validity
+impl<'a, V: vortex_array::VTable> vortex_array::ArrayView<'a, V>
 
-pub enum vortex_array::validity::Validity
+pub fn vortex_array::ArrayView<'a, V>::array(&self) -> &'a vortex_array::ArrayRef
 
-pub vortex_array::validity::Validity::AllInvalid
+pub fn vortex_array::ArrayView<'a, V>::data(&self) -> &'a <V as vortex_array::VTable>::ArrayData
 
-pub vortex_array::validity::Validity::AllValid
+pub fn vortex_array::ArrayView<'a, V>::dtype(&self) -> &vortex_array::dtype::DType
 
-pub vortex_array::validity::Validity::Array(vortex_array::ArrayRef)
+pub fn vortex_array::ArrayView<'a, V>::encoding_id(&self) -> vortex_array::ArrayId
 
-pub vortex_array::validity::Validity::NonNullable
+pub fn vortex_array::ArrayView<'a, V>::into_owned(self) -> vortex_array::Array<V>
 
-impl vortex_array::validity::Validity
+pub fn vortex_array::ArrayView<'a, V>::is_empty(&self) -> bool
 
-pub const vortex_array::validity::Validity::DTYPE: vortex_array::dtype::DType
+pub fn vortex_array::ArrayView<'a, V>::len(&self) -> usize
 
-pub fn vortex_array::validity::Validity::all_invalid(&self, len: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayView<'a, V>::slots(&self) -> &'a [core::option::Option<vortex_array::ArrayRef>]
 
-pub fn vortex_array::validity::Validity::all_valid(&self, len: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::ArrayView<'a, V>::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::validity::Validity::and(self, rhs: vortex_array::validity::Validity) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::ArrayView<'a, V>::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::validity::Validity::as_array(&self) -> core::option::Option<&vortex_array::ArrayRef>
+impl<V: vortex_array::VTable> core::clone::Clone for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::cast_nullability(self, nullability: vortex_array::dtype::Nullability, len: usize) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::ArrayView<'_, V>::clone(&self) -> Self
 
-pub fn vortex_array::validity::Validity::copy_from_array(array: &dyn vortex_array::Array) -> vortex_error::VortexResult<Self>
+impl<V: vortex_array::VTable> core::convert::AsRef<vortex_array::ArrayRef> for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::filter(&self, mask: &vortex_mask::Mask) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::ArrayView<'_, V>::as_ref(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::validity::Validity::into_array(self) -> core::option::Option<vortex_array::ArrayRef>
+impl<V: vortex_array::VTable> core::fmt::Debug for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::into_non_nullable(self, len: usize) -> core::option::Option<vortex_array::validity::Validity>
+pub fn vortex_array::ArrayView<'_, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::validity::Validity::into_nullable(self) -> vortex_array::validity::Validity
+impl<V: vortex_array::VTable> core::marker::Copy for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::is_null(&self, index: usize) -> vortex_error::VortexResult<bool>
+impl<V: vortex_array::VTable> core::ops::deref::Deref for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub type vortex_array::ArrayView<'_, V>::Target = <V as vortex_array::VTable>::ArrayData
 
-pub fn vortex_array::validity::Validity::maybe_len(&self) -> core::option::Option<usize>
+pub fn vortex_array::ArrayView<'_, V>::deref(&self) -> &<V as vortex_array::VTable>::ArrayData
 
-pub fn vortex_array::validity::Validity::not(&self) -> vortex_error::VortexResult<Self>
+impl<V: vortex_array::VTable> vortex_array::TypedArrayRef<V> for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::validity::Validity::nullability(&self) -> vortex_array::dtype::Nullability
+pub fn vortex_array::ArrayView<'_, V>::to_owned(&self) -> vortex_array::Array<V>
 
-pub fn vortex_array::validity::Validity::patch(self, len: usize, indices_offset: usize, indices: &dyn vortex_array::Array, patches: &vortex_array::validity::Validity) -> vortex_error::VortexResult<Self>
+pub struct vortex_array::CanonicalValidity(pub vortex_array::Canonical)
 
-pub fn vortex_array::validity::Validity::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<Self>
+impl vortex_array::Executable for vortex_array::CanonicalValidity
 
-pub fn vortex_array::validity::Validity::take(&self, indices: &dyn vortex_array::Array) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::CanonicalValidity::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::validity::Validity::to_array(&self, len: usize) -> vortex_array::ArrayRef
+pub struct vortex_array::DepthFirstArrayIterator
 
-pub fn vortex_array::validity::Validity::to_mask(&self, length: usize) -> vortex_mask::Mask
+impl core::iter::traits::iterator::Iterator for vortex_array::DepthFirstArrayIterator
 
-pub fn vortex_array::validity::Validity::uncompressed_size(&self) -> usize
+pub type vortex_array::DepthFirstArrayIterator::Item = vortex_array::ArrayRef
 
-pub fn vortex_array::validity::Validity::union_nullability(self, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::DepthFirstArrayIterator::next(&mut self) -> core::option::Option<Self::Item>
 
-impl vortex_array::validity::Validity
+pub struct vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::execute(self, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl core::clone::Clone for vortex_array::EmptyArrayData
 
-impl vortex_array::validity::Validity
+pub fn vortex_array::EmptyArrayData::clone(&self) -> vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::from_bit_buffer(buffer: vortex_buffer::bit::buf::BitBuffer, nullability: vortex_array::dtype::Nullability) -> Self
+impl core::default::Default for vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::from_mask(mask: vortex_mask::Mask, nullability: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::EmptyArrayData::default() -> vortex_array::EmptyArrayData
 
-impl core::clone::Clone for vortex_array::validity::Validity
+impl core::fmt::Debug for vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::clone(&self) -> vortex_array::validity::Validity
+pub fn vortex_array::EmptyArrayData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialEq for vortex_array::validity::Validity
+impl core::fmt::Display for vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::eq(&self, other: &Self) -> bool
+pub fn vortex_array::EmptyArrayData::fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::convert::From<&vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+impl vortex_array::ArrayEq for vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::from(value: &vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::EmptyArrayData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-impl core::convert::From<vortex_array::dtype::Nullability> for vortex_array::validity::Validity
+impl vortex_array::ArrayHash for vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::from(value: vortex_array::dtype::Nullability) -> Self
+pub fn vortex_array::EmptyArrayData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-impl core::convert::From<vortex_buffer::bit::buf::BitBuffer> for vortex_array::validity::Validity
+pub struct vortex_array::EmptyMetadata
 
-pub fn vortex_array::validity::Validity::from(value: vortex_buffer::bit::buf::BitBuffer) -> Self
+impl core::fmt::Debug for vortex_array::EmptyMetadata
 
-impl core::fmt::Debug for vortex_array::validity::Validity
+pub fn vortex_array::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::validity::Validity::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl vortex_array::DeserializeMetadata for vortex_array::EmptyMetadata
 
-impl core::iter::traits::collect::FromIterator<bool> for vortex_array::validity::Validity
+pub type vortex_array::EmptyMetadata::Output = vortex_array::EmptyMetadata
 
-pub fn vortex_array::validity::Validity::from_iter<T: core::iter::traits::collect::IntoIterator<Item = bool>>(iter: T) -> Self
+pub fn vortex_array::EmptyMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-impl core::iter::traits::collect::FromIterator<vortex_mask::Mask> for vortex_array::validity::Validity
+impl vortex_array::SerializeMetadata for vortex_array::EmptyMetadata
 
-pub fn vortex_array::validity::Validity::from_iter<T: core::iter::traits::collect::IntoIterator<Item = vortex_mask::Mask>>(iter: T) -> Self
+pub fn vortex_array::EmptyMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-impl vortex_array::ArrayEq for vortex_array::validity::Validity
+pub struct vortex_array::ExecutionCtx
 
-pub fn vortex_array::validity::Validity::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+impl vortex_array::ExecutionCtx
 
-impl vortex_array::ArrayHash for vortex_array::validity::Validity
+pub fn vortex_array::ExecutionCtx::allocator(&self) -> vortex_array::memory::HostAllocatorRef
 
-pub fn vortex_array::validity::Validity::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::ExecutionCtx::log(&mut self, msg: core::fmt::Arguments<'_>)
 
-pub mod vortex_array::variants
+pub fn vortex_array::ExecutionCtx::new(session: vortex_session::VortexSession) -> Self
 
-pub struct vortex_array::variants::BinaryTyped<'a>(_)
+pub fn vortex_array::ExecutionCtx::session(&self) -> &vortex_session::VortexSession
 
-pub struct vortex_array::variants::BoolTyped<'a>(_)
+impl core::clone::Clone for vortex_array::ExecutionCtx
 
-impl vortex_array::variants::BoolTyped<'_>
+pub fn vortex_array::ExecutionCtx::clone(&self) -> vortex_array::ExecutionCtx
 
-pub fn vortex_array::variants::BoolTyped<'_>::true_count(&self) -> vortex_error::VortexResult<usize>
+impl core::fmt::Debug for vortex_array::ExecutionCtx
 
-pub struct vortex_array::variants::DecimalTyped<'a>(_)
+pub fn vortex_array::ExecutionCtx::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub struct vortex_array::variants::ExtensionTyped<'a>(_)
+impl core::fmt::Display for vortex_array::ExecutionCtx
 
-impl vortex_array::variants::ExtensionTyped<'_>
+pub fn vortex_array::ExecutionCtx::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::variants::ExtensionTyped<'_>::ext_dtype(&self) -> &vortex_array::dtype::extension::ExtDTypeRef
+impl core::ops::drop::Drop for vortex_array::ExecutionCtx
 
-pub struct vortex_array::variants::ListTyped<'a>(_)
+pub fn vortex_array::ExecutionCtx::drop(&mut self)
 
-pub struct vortex_array::variants::NullTyped<'a>(_)
+pub struct vortex_array::ExecutionResult
 
-pub struct vortex_array::variants::PrimitiveTyped<'a>(_)
+impl vortex_array::ExecutionResult
 
-impl vortex_array::variants::PrimitiveTyped<'_>
+pub fn vortex_array::ExecutionResult::array(&self) -> &vortex_array::ArrayRef
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::ptype(&self) -> vortex_array::dtype::PType
+pub fn vortex_array::ExecutionResult::done(result: impl vortex_array::IntoArray) -> Self
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::value(&self, idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::scalar::PValue>>
+pub fn vortex_array::ExecutionResult::execute_slot<M: vortex_array::matcher::Matcher>(array: impl vortex_array::IntoArray, slot_idx: usize) -> Self
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::value_unchecked(&self, idx: usize) -> vortex_error::VortexResult<vortex_array::scalar::PValue>
+pub fn vortex_array::ExecutionResult::into_parts(self) -> (vortex_array::ArrayRef, vortex_array::ExecutionStep)
 
-impl vortex_array::search_sorted::IndexOrd<core::option::Option<vortex_array::scalar::PValue>> for vortex_array::variants::PrimitiveTyped<'_>
+pub fn vortex_array::ExecutionResult::step(&self) -> &vortex_array::ExecutionStep
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &core::option::Option<vortex_array::scalar::PValue>) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+impl core::fmt::Debug for vortex_array::ExecutionResult
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+pub fn vortex_array::ExecutionResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_array::search_sorted::IndexOrd<vortex_array::scalar::PValue> for vortex_array::variants::PrimitiveTyped<'_>
+pub struct vortex_array::MaskFuture
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_cmp(&self, idx: usize, elem: &vortex_array::scalar::PValue) -> vortex_error::VortexResult<core::option::Option<core::cmp::Ordering>>
+impl vortex_array::MaskFuture
 
-pub fn vortex_array::variants::PrimitiveTyped<'_>::index_len(&self) -> usize
+pub fn vortex_array::MaskFuture::inspect(self, f: impl core::ops::function::FnOnce(&vortex_error::SharedVortexResult<vortex_mask::Mask>) + 'static + core::marker::Send + core::marker::Sync) -> Self
 
-pub struct vortex_array::variants::StructTyped<'a>(_)
+pub fn vortex_array::MaskFuture::is_empty(&self) -> bool
 
-impl vortex_array::variants::StructTyped<'_>
+pub fn vortex_array::MaskFuture::len(&self) -> usize
 
-pub fn vortex_array::variants::StructTyped<'_>::dtypes(&self) -> alloc::vec::Vec<vortex_array::dtype::DType>
+pub fn vortex_array::MaskFuture::new<F>(len: usize, fut: F) -> Self where F: core::future::future::Future<Output = vortex_error::VortexResult<vortex_mask::Mask>> + core::marker::Send + 'static
 
-pub fn vortex_array::variants::StructTyped<'_>::names(&self) -> &vortex_array::dtype::FieldNames
+pub fn vortex_array::MaskFuture::new_true(row_count: usize) -> Self
 
-pub fn vortex_array::variants::StructTyped<'_>::nfields(&self) -> usize
+pub fn vortex_array::MaskFuture::ready(mask: vortex_mask::Mask) -> Self
 
-pub struct vortex_array::variants::Utf8Typed<'a>(_)
+pub fn vortex_array::MaskFuture::slice(&self, range: core::ops::range::Range<usize>) -> Self
 
-pub mod vortex_array::vtable
+impl core::clone::Clone for vortex_array::MaskFuture
 
-pub struct vortex_array::vtable::NotSupported
+pub fn vortex_array::MaskFuture::clone(&self) -> vortex_array::MaskFuture
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::OperationsVTable<V> for vortex_array::vtable::NotSupported
+impl core::future::future::Future for vortex_array::MaskFuture
 
-pub fn vortex_array::vtable::NotSupported::scalar_at(array: &<V as vortex_array::vtable::VTable>::Array, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::MaskFuture::Output = core::result::Result<vortex_mask::Mask, vortex_error::VortexError>
 
-pub struct vortex_array::vtable::ValidityVTableFromChild
+pub fn vortex_array::MaskFuture::poll(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<Self::Output>
 
-impl<V> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromChild where V: vortex_array::vtable::ValidityChild<V> + vortex_array::vtable::VTable
+pub struct vortex_array::NotSupported
 
-pub fn vortex_array::vtable::ValidityVTableFromChild::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl<V: vortex_array::VTable> vortex_array::OperationsVTable<V> for vortex_array::NotSupported
 
-pub struct vortex_array::vtable::ValidityVTableFromChildSliceHelper
+pub fn vortex_array::NotSupported::scalar_at(array: vortex_array::ArrayView<'_, V>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromChildSliceHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValidityChildSliceHelper
+pub struct vortex_array::ProstMetadata<M>(pub M)
 
-pub fn vortex_array::vtable::ValidityVTableFromChildSliceHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl<M: core::fmt::Debug> core::fmt::Debug for vortex_array::ProstMetadata<M>
 
-pub struct vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::ProstMetadata<M>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromValidityHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValidityHelper
+impl<M> core::ops::deref::Deref for vortex_array::ProstMetadata<M>
 
-pub fn vortex_array::vtable::ValidityVTableFromValidityHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::ProstMetadata<M>::Target = M
 
-pub struct vortex_array::vtable::ValidityVTableFromValiditySliceHelper
+pub fn vortex_array::ProstMetadata<M>::deref(&self) -> &Self::Target
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromValiditySliceHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValiditySliceHelper
+impl<M> vortex_array::DeserializeMetadata for vortex_array::ProstMetadata<M> where M: core::fmt::Debug + prost::message::Message + core::default::Default
 
-pub fn vortex_array::vtable::ValidityVTableFromValiditySliceHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::ProstMetadata<M>::Output = M
 
-pub trait vortex_array::vtable::ArrayVTableExt
+pub fn vortex_array::ProstMetadata<M>::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-pub fn vortex_array::vtable::ArrayVTableExt::vtable() -> &'static dyn vortex_array::vtable::DynVTable
+impl<M> vortex_array::SerializeMetadata for vortex_array::ProstMetadata<M> where M: prost::message::Message
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ArrayVTableExt for V
+pub fn vortex_array::ProstMetadata<M>::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn V::vtable() -> &'static dyn vortex_array::vtable::DynVTable
+pub struct vortex_array::RawMetadata(pub alloc::vec::Vec<u8>)
 
-pub trait vortex_array::vtable::BaseArrayVTable<V: vortex_array::vtable::VTable>
+impl core::fmt::Debug for vortex_array::RawMetadata
 
-pub fn vortex_array::vtable::BaseArrayVTable::array_eq(array: &<V as vortex_array::vtable::VTable>::Array, other: &<V as vortex_array::vtable::VTable>::Array, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::RawMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_array::vtable::BaseArrayVTable::array_hash<H: core::hash::Hasher>(array: &<V as vortex_array::vtable::VTable>::Array, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::DeserializeMetadata for vortex_array::RawMetadata
 
-pub fn vortex_array::vtable::BaseArrayVTable::dtype(array: &<V as vortex_array::vtable::VTable>::Array) -> &vortex_array::dtype::DType
+pub type vortex_array::RawMetadata::Output = alloc::vec::Vec<u8>
 
-pub fn vortex_array::vtable::BaseArrayVTable::len(array: &<V as vortex_array::vtable::VTable>::Array) -> usize
+pub fn vortex_array::RawMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-pub fn vortex_array::vtable::BaseArrayVTable::stats(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::SerializeMetadata for vortex_array::RawMetadata
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+pub fn vortex_array::RawMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn vortex_array::arrays::BoolVTable::array_eq(array: &vortex_array::arrays::BoolArray, other: &vortex_array::arrays::BoolArray, precision: vortex_array::Precision) -> bool
+pub struct vortex_array::RecursiveCanonical(pub vortex_array::Canonical)
 
-pub fn vortex_array::arrays::BoolVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::BoolArray, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::Executable for vortex_array::RecursiveCanonical
 
-pub fn vortex_array::arrays::BoolVTable::dtype(array: &vortex_array::arrays::BoolArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::RecursiveCanonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::BoolVTable::len(array: &vortex_array::arrays::BoolArray) -> usize
+pub struct vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::arrays::BoolVTable::stats(array: &vortex_array::arrays::BoolArray) -> vortex_array::stats::StatsSetRef<'_>
+impl<V> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChild where V: vortex_array::ValidityChild<V> + vortex_array::VTable
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::ValidityVTableFromChild::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ChunkedVTable::array_eq(array: &vortex_array::arrays::ChunkedArray, other: &vortex_array::arrays::ChunkedArray, precision: vortex_array::Precision) -> bool
+pub struct vortex_array::ValidityVTableFromChildSliceHelper
 
-pub fn vortex_array::arrays::ChunkedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ChunkedArray, state: &mut H, precision: vortex_array::Precision)
+impl<V: vortex_array::VTable> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChildSliceHelper where <V as vortex_array::VTable>::ArrayData: vortex_array::ValidityChildSliceHelper
 
-pub fn vortex_array::arrays::ChunkedVTable::dtype(array: &vortex_array::arrays::ChunkedArray) -> &vortex_array::dtype::DType
+pub fn vortex_array::ValidityVTableFromChildSliceHelper::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::arrays::ChunkedVTable::len(array: &vortex_array::arrays::ChunkedArray) -> usize
+pub static vortex_array::LEGACY_SESSION: std::sync::lazy_lock::LazyLock<vortex_session::VortexSession>
 
-pub fn vortex_array::arrays::ChunkedVTable::stats(array: &vortex_array::arrays::ChunkedArray) -> vortex_array::stats::StatsSetRef<'_>
+pub trait vortex_array::ArrayEq
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::ArrayEq::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ConstantVTable::array_eq(array: &vortex_array::arrays::ConstantArray, other: &vortex_array::arrays::ConstantArray, _precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ConstantVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ConstantArray, state: &mut H, _precision: vortex_array::Precision)
+pub fn vortex_array::ArrayRef::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ConstantVTable::dtype(array: &vortex_array::arrays::ConstantArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::EmptyArrayData
 
-pub fn vortex_array::arrays::ConstantVTable::len(array: &vortex_array::arrays::ConstantArray) -> usize
+pub fn vortex_array::EmptyArrayData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ConstantVTable::stats(array: &vortex_array::arrays::ConstantArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::bool::BoolData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::bool::BoolData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::array_eq(array: &vortex_array::arrays::DecimalArray, other: &vortex_array::arrays::DecimalArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::DecimalVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::DecimalArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::chunked::ChunkedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::dtype(array: &vortex_array::arrays::DecimalArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::DecimalVTable::len(array: &vortex_array::arrays::DecimalArray) -> usize
+pub fn vortex_array::arrays::constant::ConstantData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::stats(array: &vortex_array::arrays::DecimalArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::decimal::DecimalData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::decimal::DecimalData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DictVTable::array_eq(array: &vortex_array::arrays::DictArray, other: &vortex_array::arrays::DictArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::DictVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::DictArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::dict::DictData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DictVTable::dtype(array: &vortex_array::arrays::DictArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::arrays::DictVTable::len(array: &vortex_array::arrays::DictArray) -> usize
+pub fn vortex_array::arrays::extension::ExtensionData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DictVTable::stats(array: &vortex_array::arrays::DictArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::filter::FilterData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::filter::FilterData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ExtensionVTable::array_eq(array: &vortex_array::arrays::ExtensionArray, other: &vortex_array::arrays::ExtensionArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::ExtensionVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ExtensionArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ExtensionVTable::dtype(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::ExtensionVTable::len(array: &vortex_array::arrays::ExtensionArray) -> usize
+pub fn vortex_array::arrays::list::ListData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ExtensionVTable::stats(array: &vortex_array::arrays::ExtensionArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::listview::ListViewData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::listview::ListViewData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FilterVTable::array_eq(array: &vortex_array::arrays::FilterArray, other: &vortex_array::arrays::FilterArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::arrays::FilterVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::FilterArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::masked::MaskedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FilterVTable::dtype(array: &vortex_array::arrays::FilterArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::FilterVTable::len(array: &vortex_array::arrays::FilterArray) -> usize
+pub fn vortex_array::arrays::patched::PatchedData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FilterVTable::stats(array: &vortex_array::arrays::FilterArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::primitive::PrimitiveData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::primitive::PrimitiveData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FixedSizeListVTable::array_eq(array: &vortex_array::arrays::FixedSizeListArray, other: &vortex_array::arrays::FixedSizeListArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::FixedSizeListArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FixedSizeListVTable::dtype(array: &vortex_array::arrays::FixedSizeListArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::arrays::FixedSizeListVTable::len(array: &vortex_array::arrays::FixedSizeListArray) -> usize
+pub fn vortex_array::arrays::shared::SharedData::array_eq(&self, _other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::FixedSizeListVTable::stats(array: &vortex_array::arrays::FixedSizeListArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::arrays::slice::SliceData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::slice::SliceData::array_eq(&self, other: &Self, _precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListVTable::array_eq(array: &vortex_array::arrays::ListArray, other: &vortex_array::arrays::ListArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::arrays::ListVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ListArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::varbin::VarBinData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListVTable::dtype(array: &vortex_array::arrays::ListArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::arrays::ListVTable::len(array: &vortex_array::arrays::ListArray) -> usize
+pub fn vortex_array::arrays::varbinview::VarBinViewData::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListVTable::stats(array: &vortex_array::arrays::ListArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::buffer::BufferHandle::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListViewVTable::array_eq(array: &vortex_array::arrays::ListViewArray, other: &vortex_array::arrays::ListViewArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_array::patches::Patches
 
-pub fn vortex_array::arrays::ListViewVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ListViewArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::patches::Patches::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListViewVTable::dtype(array: &vortex_array::arrays::ListViewArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayEq for vortex_array::validity::Validity
 
-pub fn vortex_array::arrays::ListViewVTable::len(array: &vortex_array::arrays::ListViewArray) -> usize
+pub fn vortex_array::validity::Validity::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::ListViewVTable::stats(array: &vortex_array::arrays::ListViewArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayEq for vortex_buffer::bit::buf::BitBuffer
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_buffer::bit::buf::BitBuffer::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::MaskedVTable::array_eq(array: &vortex_array::arrays::MaskedArray, other: &vortex_array::arrays::MaskedArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayEq for vortex_mask::Mask
 
-pub fn vortex_array::arrays::MaskedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::MaskedArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_mask::Mask::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::MaskedVTable::dtype(array: &vortex_array::arrays::MaskedArray) -> &vortex_array::dtype::DType
+impl<T: core::cmp::PartialEq> vortex_array::ArrayEq for vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::arrays::MaskedVTable::len(array: &vortex_array::arrays::MaskedArray) -> usize
+pub fn vortex_buffer::buffer::Buffer<T>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::MaskedVTable::stats(array: &vortex_array::arrays::MaskedArray) -> vortex_array::stats::StatsSetRef<'_>
+impl<T: vortex_array::ArrayEq> vortex_array::ArrayEq for core::option::Option<T>
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn core::option::Option<T>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::NullVTable::array_eq(array: &vortex_array::arrays::NullArray, other: &vortex_array::arrays::NullArray, _precision: vortex_array::Precision) -> bool
+pub trait vortex_array::ArrayHash
 
-pub fn vortex_array::arrays::NullVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::NullArray, state: &mut H, _precision: vortex_array::Precision)
+pub fn vortex_array::ArrayHash::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::NullVTable::dtype(_array: &vortex_array::arrays::NullArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NullVTable::len(array: &vortex_array::arrays::NullArray) -> usize
+pub fn vortex_array::ArrayRef::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::NullVTable::stats(array: &vortex_array::arrays::NullArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::EmptyArrayData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::EmptyArrayData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::PrimitiveVTable::array_eq(array: &vortex_array::arrays::PrimitiveArray, other: &vortex_array::arrays::PrimitiveArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::bool::BoolData
 
-pub fn vortex_array::arrays::PrimitiveVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::PrimitiveArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::bool::BoolData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::PrimitiveVTable::dtype(array: &vortex_array::arrays::PrimitiveArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::arrays::PrimitiveVTable::len(array: &vortex_array::arrays::PrimitiveArray) -> usize
+pub fn vortex_array::arrays::chunked::ChunkedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::PrimitiveVTable::stats(array: &vortex_array::arrays::PrimitiveArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::constant::ConstantData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::constant::ConstantData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::ScalarFnVTable::array_eq(array: &vortex_array::arrays::ScalarFnArray, other: &vortex_array::arrays::ScalarFnArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::ScalarFnVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::ScalarFnArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::decimal::DecimalData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::ScalarFnVTable::dtype(array: &vortex_array::arrays::ScalarFnArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::ScalarFnVTable::len(array: &vortex_array::arrays::ScalarFnArray) -> usize
+pub fn vortex_array::arrays::dict::DictData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::ScalarFnVTable::stats(array: &vortex_array::arrays::ScalarFnArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::extension::ExtensionData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::extension::ExtensionData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SharedVTable::array_eq(array: &vortex_array::arrays::SharedArray, other: &vortex_array::arrays::SharedArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::SharedVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::SharedArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::filter::FilterData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SharedVTable::dtype(array: &vortex_array::arrays::SharedArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::SharedVTable::len(array: &vortex_array::arrays::SharedArray) -> usize
+pub fn vortex_array::arrays::fixed_size_list::FixedSizeListData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SharedVTable::stats(array: &vortex_array::arrays::SharedArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::list::ListData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::list::ListData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SliceVTable::array_eq(array: &vortex_array::arrays::SliceArray, other: &vortex_array::arrays::SliceArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::arrays::SliceVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::SliceArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::listview::ListViewData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SliceVTable::dtype(array: &vortex_array::arrays::SliceArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::arrays::SliceVTable::len(array: &vortex_array::arrays::SliceArray) -> usize
+pub fn vortex_array::arrays::masked::MaskedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::SliceVTable::stats(array: &vortex_array::arrays::SliceArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::patched::PatchedData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::patched::PatchedData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::StructVTable::array_eq(array: &vortex_array::arrays::StructArray, other: &vortex_array::arrays::StructArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::StructVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::StructArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::primitive::PrimitiveData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::StructVTable::dtype(array: &vortex_array::arrays::StructArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::arrays::StructVTable::len(array: &vortex_array::arrays::StructArray) -> usize
+pub fn vortex_array::arrays::scalar_fn::ScalarFnData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::StructVTable::stats(array: &vortex_array::arrays::StructArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::shared::SharedData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::shared::SharedData::array_hash<H: core::hash::Hasher>(&self, _state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinVTable::array_eq(array: &vortex_array::arrays::VarBinArray, other: &vortex_array::arrays::VarBinArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrays::VarBinVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::VarBinArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::slice::SliceData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinVTable::dtype(array: &vortex_array::arrays::VarBinArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::arrays::VarBinVTable::len(array: &vortex_array::arrays::VarBinArray) -> usize
+pub fn vortex_array::arrays::varbin::VarBinData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinVTable::stats(array: &vortex_array::arrays::VarBinArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::arrays::varbinview::VarBinViewData
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::varbinview::VarBinViewData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinViewVTable::array_eq(array: &vortex_array::arrays::VarBinViewArray, other: &vortex_array::arrays::VarBinViewArray, precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinViewVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrays::VarBinViewArray, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::buffer::BufferHandle::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinViewVTable::dtype(array: &vortex_array::arrays::VarBinViewArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_array::patches::Patches
 
-pub fn vortex_array::arrays::VarBinViewVTable::len(array: &vortex_array::arrays::VarBinViewArray) -> usize
+pub fn vortex_array::patches::Patches::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::VarBinViewVTable::stats(array: &vortex_array::arrays::VarBinViewArray) -> vortex_array::stats::StatsSetRef<'_>
+impl vortex_array::ArrayHash for vortex_array::validity::Validity
 
-impl vortex_array::vtable::BaseArrayVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::validity::Validity::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrow::ArrowVTable::array_eq(array: &vortex_array::arrow::ArrowArray, other: &vortex_array::arrow::ArrowArray, _precision: vortex_array::Precision) -> bool
+impl vortex_array::ArrayHash for vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::arrow::ArrowVTable::array_hash<H: core::hash::Hasher>(array: &vortex_array::arrow::ArrowArray, state: &mut H, _precision: vortex_array::Precision)
+pub fn vortex_buffer::bit::buf::BitBuffer::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrow::ArrowVTable::dtype(array: &vortex_array::arrow::ArrowArray) -> &vortex_array::dtype::DType
+impl vortex_array::ArrayHash for vortex_mask::Mask
 
-pub fn vortex_array::arrow::ArrowVTable::len(array: &vortex_array::arrow::ArrowArray) -> usize
+pub fn vortex_mask::Mask::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrow::ArrowVTable::stats(array: &vortex_array::arrow::ArrowArray) -> vortex_array::stats::StatsSetRef<'_>
+impl<T: core::hash::Hash> vortex_array::ArrayHash for vortex_buffer::buffer::Buffer<T>
 
-pub trait vortex_array::vtable::DynVTable: 'static + vortex_array::vtable::dyn_::private::Sealed + core::marker::Send + core::marker::Sync + core::fmt::Debug
+pub fn vortex_buffer::buffer::Buffer<T>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::vtable::DynVTable::build(&self, id: vortex_array::vtable::ArrayId, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl<T: vortex_array::ArrayHash> vortex_array::ArrayHash for core::option::Option<T>
 
-pub fn vortex_array::vtable::DynVTable::execute(&self, array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn core::option::Option<T>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
 
-pub fn vortex_array::vtable::DynVTable::execute_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::ArrayPlugin: 'static + core::marker::Send + core::marker::Sync
 
-pub fn vortex_array::vtable::DynVTable::reduce(&self, array: &vortex_array::ArrayRef) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub trait vortex_array::ArrayPlugin: 'static + core::marker::Send + core::marker::Sync
 
-pub fn vortex_array::vtable::DynVTable::reduce_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::ArrayPlugin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::vtable::DynVTable::with_children(&self, array: &dyn vortex_array::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::ArrayPlugin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub trait vortex_array::vtable::OperationsVTable<V: vortex_array::vtable::VTable>
+pub fn vortex_array::ArrayPlugin::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::vtable::OperationsVTable::scalar_at(array: &<V as vortex_array::vtable::VTable>::Array, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayPlugin::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+pub fn vortex_array::ArrayPlugin::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolVTable::scalar_at(array: &vortex_array::arrays::BoolArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayPlugin::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+impl<V: vortex_array::VTable> vortex_array::ArrayPlugin for V
 
-pub fn vortex_array::arrays::ChunkedVTable::scalar_at(array: &vortex_array::arrays::ChunkedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+impl<V: vortex_array::VTable> vortex_array::ArrayPlugin for V
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub fn V::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
 
-pub fn vortex_array::arrays::ConstantVTable::scalar_at(array: &vortex_array::arrays::ConstantArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn V::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> core::result::Result<vortex_array::ArrayRef, vortex_error::VortexError>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub fn V::id(&self) -> arcref::ArcRef<str>
 
-pub fn vortex_array::arrays::DecimalVTable::scalar_at(array: &vortex_array::arrays::DecimalArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn V::id(&self) -> arcref::ArcRef<str>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub fn V::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> core::result::Result<core::option::Option<alloc::vec::Vec<u8>>, vortex_error::VortexError>
 
-pub fn vortex_array::arrays::DictVTable::scalar_at(array: &vortex_array::arrays::DictArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn V::serialize(&self, array: &vortex_array::ArrayRef, session: &vortex_session::VortexSession) -> core::result::Result<core::option::Option<alloc::vec::Vec<u8>>, vortex_error::VortexError>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub trait vortex_array::ArrayVTable: 'static + core::clone::Clone + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-pub fn vortex_array::arrays::ExtensionVTable::scalar_at(array: &vortex_array::arrays::ExtensionArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::ArrayVTable::ArrayData: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + vortex_array::ArrayHash + vortex_array::ArrayEq
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+pub type vortex_array::ArrayVTable::OperationsVTable: vortex_array::OperationsVTable<Self>
 
-pub fn vortex_array::arrays::FilterVTable::scalar_at(array: &vortex_array::arrays::FilterArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::ArrayVTable::ValidityVTable: vortex_array::ValidityVTable<Self>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::ArrayVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::scalar_at(array: &vortex_array::arrays::FixedSizeListArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::ArrayVTable::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListVTable::scalar_at(array: &vortex_array::arrays::ListArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::ArrayVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListViewVTable::scalar_at(array: &vortex_array::arrays::ListViewArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::ArrayVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::MaskedVTable::scalar_at(array: &vortex_array::arrays::MaskedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn vortex_array::ArrayVTable::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::NullVTable::scalar_at(_array: &vortex_array::arrays::NullArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::ArrayVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::PrimitiveVTable::scalar_at(array: &vortex_array::arrays::PrimitiveArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::ArrayVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::scalar_at(array: &vortex_array::arrays::ScalarFnArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::serialize(array: vortex_array::ArrayView<'_, Self>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::ArrayVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::SharedVTable::scalar_at(array: &vortex_array::arrays::SharedArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::ArrayVTable::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::SliceVTable::scalar_at(array: &vortex_array::arrays::SliceArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-pub fn vortex_array::arrays::StructVTable::scalar_at(array: &vortex_array::arrays::StructArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::VarBinVTable::scalar_at(array: &vortex_array::arrays::VarBinArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::VarBinViewVTable::scalar_at(array: &vortex_array::arrays::VarBinViewArray, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::OperationsVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrow::ArrowVTable::scalar_at(_array: &vortex_array::arrow::ArrowArray, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::OperationsVTable<V> for vortex_array::vtable::NotSupported
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::vtable::NotSupported::scalar_at(array: &<V as vortex_array::vtable::VTable>::Array, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::vtable::VTable: 'static + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::vtable::VTable::Array: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::ops::deref::Deref<Target = dyn vortex_array::Array> + vortex_array::IntoArray
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::vtable::VTable::ArrayVTable: vortex_array::vtable::BaseArrayVTable<Self>
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::vtable::VTable::Metadata: core::fmt::Debug
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::vtable::VTable::OperationsVTable: vortex_array::vtable::OperationsVTable<Self>
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::vtable::VTable::ValidityVTable: vortex_array::vtable::ValidityVTable<Self>
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::vtable::VTable::VisitorVTable: vortex_array::vtable::VisitorVTable<Self>
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::vtable::VTable::append_to_builder(array: &Self::Array, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::vtable::VTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-pub fn vortex_array::vtable::VTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub fn vortex_array::vtable::VTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::vtable::VTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-pub fn vortex_array::vtable::VTable::id(array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::vtable::VTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::vtable::VTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::vtable::VTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::vtable::VTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::vtable::VTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::BoolVTable::Array = vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::BoolVTable::ArrayVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::BoolVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::bool::vtable::BoolMetadata>
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::BoolVTable::OperationsVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::BoolVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::BoolVTable::VisitorVTable = vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::BoolVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::BoolArray>
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::BoolVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BoolVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::BoolVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::arrays::BoolVTable::metadata(array: &vortex_array::arrays::BoolArray) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::BoolVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::BoolVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::BoolVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::ChunkedVTable::Array = vortex_array::arrays::ChunkedArray
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::ChunkedVTable::ArrayVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::ChunkedVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::arrays::ChunkedVTable::OperationsVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::ChunkedVTable::ValidityVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ChunkedVTable::VisitorVTable = vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ChunkedVTable::append_to_builder(array: &vortex_array::arrays::ChunkedArray, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ChunkedVTable::build(dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ChunkedArray>
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ChunkedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ChunkedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ChunkedVTable::metadata(_array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ChunkedVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::ChunkedVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::arrays::ChunkedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub fn vortex_array::arrays::ChunkedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ConstantVTable::Array = vortex_array::arrays::ConstantArray
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::ConstantVTable::ArrayVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::ConstantVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::ConstantVTable::OperationsVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::ConstantVTable::ValidityVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::arrays::ConstantVTable::VisitorVTable = vortex_array::arrays::ConstantVTable
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ConstantVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ConstantArray>
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ConstantVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ConstantVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ConstantVTable::metadata(_array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ConstantVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ConstantVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::DecimalVTable::Array = vortex_array::arrays::DecimalArray
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-pub type vortex_array::arrays::DecimalVTable::ArrayVTable = vortex_array::arrays::DecimalVTable
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-pub type vortex_array::arrays::DecimalVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::decimal::vtable::DecimalMetadata>
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-pub type vortex_array::arrays::DecimalVTable::OperationsVTable = vortex_array::arrays::DecimalVTable
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub type vortex_array::arrays::DecimalVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::DecimalVTable::VisitorVTable = vortex_array::arrays::DecimalVTable
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::DecimalVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::DecimalArray>
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::DecimalVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::DecimalVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::DecimalVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::DecimalVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::DecimalVTable::metadata(array: &vortex_array::arrays::DecimalArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::DecimalVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::DecimalVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::DictVTable::Array = vortex_array::arrays::DictArray
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::DictVTable::ArrayVTable = vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::DictVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::DictMetadata>
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::DictVTable::OperationsVTable = vortex_array::arrays::DictVTable
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::DictVTable::ValidityVTable = vortex_array::arrays::DictVTable
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-pub type vortex_array::arrays::DictVTable::VisitorVTable = vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-pub fn vortex_array::arrays::DictVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::DictArray>
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::DictVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::DictVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::DictVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::DictVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::DictVTable::metadata(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::DictVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::DictVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::DictVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ExtensionVTable::Array = vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::ExtensionVTable::ArrayVTable = vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::ExtensionVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::ExtensionVTable::OperationsVTable = vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ExtensionVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromChild
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ExtensionVTable::VisitorVTable = vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ExtensionVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ExtensionArray>
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ExtensionVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ExtensionVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-pub fn vortex_array::arrays::ExtensionVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ExtensionVTable::metadata(_array: &vortex_array::arrays::ExtensionArray) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::arrays::ExtensionVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ExtensionVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::FilterVTable::Array = vortex_array::arrays::FilterArray
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::FilterVTable::ArrayVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::arrays::FilterVTable::Metadata = vortex_array::arrays::filter::vtable::FilterMetadata
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::FilterVTable::OperationsVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::FilterVTable::ValidityVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::FilterVTable::VisitorVTable = vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FilterVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::filter::vtable::FilterMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FilterVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FilterVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::FilterVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::FilterVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FilterVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::List
 
-pub fn vortex_array::arrays::FilterVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-pub fn vortex_array::arrays::FilterVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::FixedSizeListVTable
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub type vortex_array::arrays::FixedSizeListVTable::Array = vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::FixedSizeListVTable::ArrayVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::FixedSizeListVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::FixedSizeListVTable::OperationsVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::FixedSizeListVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::FixedSizeListVTable::VisitorVTable = vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::FixedSizeListArray>
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::FixedSizeListVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FixedSizeListVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::FixedSizeListVTable::metadata(_array: &vortex_array::arrays::FixedSizeListArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ListVTable::Array = vortex_array::arrays::ListArray
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-pub type vortex_array::arrays::ListVTable::ArrayVTable = vortex_array::arrays::ListVTable
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-pub type vortex_array::arrays::ListVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::list::vtable::ListMetadata>
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-pub type vortex_array::arrays::ListVTable::OperationsVTable = vortex_array::arrays::ListVTable
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-pub type vortex_array::arrays::ListVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ListVTable::VisitorVTable = vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ListArray>
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ListVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ListVTable::metadata(array: &vortex_array::arrays::ListArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ListVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ListVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ListVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListViewVTable::Array = vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::ListViewVTable::ArrayVTable = vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::ListViewVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::listview::vtable::ListViewMetadata>
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::ListViewVTable::OperationsVTable = vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ListViewVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub type vortex_array::arrays::ListViewVTable::VisitorVTable = vortex_array::arrays::ListViewVTable
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-pub fn vortex_array::arrays::ListViewVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::ListViewArray>
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::ListViewVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-pub fn vortex_array::arrays::ListViewVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ListViewVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListViewVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ListViewVTable::metadata(array: &vortex_array::arrays::ListViewArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ListViewVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ListViewVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::Array = vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::MaskedVTable::ArrayVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::MaskedVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::MaskedVTable::OperationsVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::MaskedVTable::VisitorVTable = vortex_array::arrays::MaskedVTable
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::MaskedVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::MaskedArray>
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::MaskedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::MaskedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::MaskedVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::arrays::MaskedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::MaskedVTable::metadata(_array: &vortex_array::arrays::MaskedArray) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::arrays::MaskedVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::MaskedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::MaskedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::NullVTable::Array = vortex_array::arrays::NullArray
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::NullVTable::ArrayVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::arrays::NullVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::NullVTable::OperationsVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::NullVTable::ValidityVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::NullVTable::VisitorVTable = vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::NullVTable::build(_dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::NullArray>
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::NullVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::NullVTable::metadata(_array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::NullVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::NullVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub fn vortex_array::arrays::NullVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::PrimitiveVTable
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub type vortex_array::arrays::PrimitiveVTable::Array = vortex_array::arrays::PrimitiveArray
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-pub type vortex_array::arrays::PrimitiveVTable::ArrayVTable = vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::PrimitiveVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::PrimitiveVTable::OperationsVTable = vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::PrimitiveVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::PrimitiveVTable::VisitorVTable = vortex_array::arrays::PrimitiveVTable
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::PrimitiveVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::PrimitiveArray>
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::PrimitiveVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::PrimitiveVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::PrimitiveVTable::metadata(_array: &vortex_array::arrays::PrimitiveArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::PrimitiveVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::PrimitiveVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::ScalarFnVTable::Array = vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::ScalarFnVTable::ArrayVTable = vortex_array::arrays::ScalarFnVTable
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-pub type vortex_array::arrays::ScalarFnVTable::Metadata = vortex_array::arrays::scalar_fn::metadata::ScalarFnMetadata
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub type vortex_array::arrays::ScalarFnVTable::OperationsVTable = vortex_array::arrays::ScalarFnVTable
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-pub type vortex_array::arrays::ScalarFnVTable::ValidityVTable = vortex_array::arrays::ScalarFnVTable
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub type vortex_array::arrays::ScalarFnVTable::VisitorVTable = vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ScalarFnVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::scalar_fn::metadata::ScalarFnMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ScalarFnVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::ScalarFnVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::id(array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::ScalarFnVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::reduce(array: &Self::Array) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::ScalarFnVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::ScalarFnVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::SharedVTable::Array = vortex_array::arrays::SharedArray
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::SharedVTable::ArrayVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::SharedVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::SharedVTable::OperationsVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::SharedVTable::ValidityVTable = vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::SharedVTable::VisitorVTable = vortex_array::arrays::SharedVTable
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-pub fn vortex_array::arrays::SharedVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::SharedArray>
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::arrays::SharedVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::arrays::SharedVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::arrays::SharedVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::SharedVTable::metadata(_array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::SharedVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::SharedVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::SliceVTable::Array = vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub type vortex_array::arrays::SliceVTable::ArrayVTable = vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::arrays::SliceVTable::Metadata = vortex_array::arrays::SliceMetadata
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::SliceVTable::OperationsVTable = vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrays::SliceVTable::ValidityVTable = vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrays::SliceVTable::VisitorVTable = vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::SliceVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &vortex_array::arrays::SliceMetadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SliceVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::SliceVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::SliceVTable::metadata(array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::SliceVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::arrays::SliceVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::arrays::SliceVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::StructVTable
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub type vortex_array::arrays::StructVTable::Array = vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::StructVTable::ArrayVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub type vortex_array::arrays::StructVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub type vortex_array::arrays::StructVTable::OperationsVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::arrays::StructVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::StructVTable::VisitorVTable = vortex_array::arrays::StructVTable
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::StructVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::StructArray>
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::StructVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::StructVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::StructVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::StructVTable::metadata(_array: &vortex_array::arrays::StructArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::StructVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::StructVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::VarBinVTable::Array = vortex_array::arrays::VarBinArray
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-pub type vortex_array::arrays::VarBinVTable::ArrayVTable = vortex_array::arrays::VarBinVTable
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub type vortex_array::arrays::VarBinVTable::Metadata = vortex_array::ProstMetadata<vortex_array::arrays::varbin::vtable::VarBinMetadata>
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-pub type vortex_array::arrays::VarBinVTable::OperationsVTable = vortex_array::arrays::VarBinVTable
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-pub type vortex_array::arrays::VarBinVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::VarBinVTable::VisitorVTable = vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinVTable::build(dtype: &vortex_array::dtype::DType, len: usize, metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::VarBinArray>
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::VarBinVTable::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::VarBinVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::VarBinVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::VarBinVTable::metadata(array: &vortex_array::arrays::VarBinArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::VarBinVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::VarBinVTable::serialize(metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::VarBinVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::VTable for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::VarBinViewVTable::Array = vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrays::VarBinViewVTable::ArrayVTable = vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::arrays::VarBinViewVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::arrays::VarBinViewVTable::OperationsVTable = vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::arrays::VarBinViewVTable::ValidityVTable = vortex_array::vtable::ValidityVTableFromValidityHelper
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub type vortex_array::arrays::VarBinViewVTable::VisitorVTable = vortex_array::arrays::VarBinViewVTable
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-pub fn vortex_array::arrays::VarBinViewVTable::build(dtype: &vortex_array::dtype::DType, len: usize, _metadata: &Self::Metadata, buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<vortex_array::arrays::VarBinViewArray>
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::VarBinViewVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::arrays::VarBinViewVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::VarBinViewVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::VarBinViewVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::VarBinViewVTable::metadata(_array: &vortex_array::arrays::VarBinViewArray) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinViewVTable::reduce_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::VarBinViewVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::VarBinViewVTable::with_children(array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::vtable::VTable for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrow::ArrowVTable::Array = vortex_array::arrow::ArrowArray
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub type vortex_array::arrow::ArrowVTable::ArrayVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrow::ArrowVTable::Metadata = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub type vortex_array::arrow::ArrowVTable::OperationsVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrow::ArrowVTable::ValidityVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::arrow::ArrowVTable::VisitorVTable = vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrow::ArrowVTable::build(_dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &Self::Metadata, _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren) -> vortex_error::VortexResult<Self::Array>
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrow::ArrowVTable::deserialize(_bytes: &[u8], _dtype: &vortex_array::dtype::DType, _len: usize, _buffers: &[vortex_array::buffer::BufferHandle], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self::Metadata>
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrow::ArrowVTable::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrow::ArrowVTable::id(_array: &Self::Array) -> vortex_array::vtable::ArrayId
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::arrow::ArrowVTable::metadata(_array: &Self::Array) -> vortex_error::VortexResult<Self::Metadata>
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrow::ArrowVTable::serialize(_metadata: Self::Metadata) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::arrow::ArrowVTable::with_children(_array: &mut Self::Array, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::vtable::ValidityChild<V: vortex_array::vtable::VTable>
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::vtable::ValidityChild::validity_child(array: &<V as vortex_array::vtable::VTable>::Array) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::vtable::ValidityChild<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ExtensionVTable::validity_child(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::ArrayRef
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub trait vortex_array::vtable::ValidityChildSliceHelper
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::vtable::ValidityChildSliceHelper::sliced_child_array(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::vtable::ValidityChildSliceHelper::unsliced_child_and_slice(&self) -> (&vortex_array::ArrayRef, usize, usize)
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::vtable::ValidityHelper
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::vtable::ValidityHelper::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::DecimalArray
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::FixedSizeListArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::ListArray
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::ListArray::validity(&self) -> &vortex_array::validity::Validity
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::ListViewArray
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-pub fn vortex_array::arrays::ListViewArray::validity(&self) -> &vortex_array::validity::Validity
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::MaskedArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::arrays::PrimitiveArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::arrays::StructArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::arrays::VarBinArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::vtable::ValidityHelper for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::arrays::VarBinViewArray::validity(&self) -> &vortex_array::validity::Validity
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub trait vortex_array::vtable::ValiditySliceHelper
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::vtable::ValiditySliceHelper::sliced_validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::vtable::ValiditySliceHelper::unsliced_validity_and_slice(&self) -> (&vortex_array::validity::Validity, usize, usize)
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::vtable::ValidityVTable<V: vortex_array::vtable::VTable>
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::vtable::ValidityVTable::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ChunkedVTable::validity(array: &vortex_array::arrays::ChunkedArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn vortex_array::arrays::ConstantVTable::validity(array: &vortex_array::arrays::ConstantArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::arrays::DictVTable::validity(array: &vortex_array::arrays::DictArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::FilterVTable::validity(array: &vortex_array::arrays::FilterArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NullVTable::validity(_array: &vortex_array::arrays::NullArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::ScalarFnVTable::validity(array: &vortex_array::arrays::ScalarFnArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::SharedVTable::validity(array: &vortex_array::arrays::SharedArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::SliceVTable::validity(array: &vortex_array::arrays::SliceArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::vtable::ValidityVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrow::ArrowVTable::validity(array: &vortex_array::arrow::ArrowArray) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromChildSliceHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValidityChildSliceHelper
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::vtable::ValidityVTableFromChildSliceHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromValidityHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValidityHelper
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::vtable::ValidityVTableFromValidityHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-impl<V: vortex_array::vtable::VTable> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromValiditySliceHelper where <V as vortex_array::vtable::VTable>::Array: vortex_array::vtable::ValiditySliceHelper
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::vtable::ValidityVTableFromValiditySliceHelper::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-impl<V> vortex_array::vtable::ValidityVTable<V> for vortex_array::vtable::ValidityVTableFromChild where V: vortex_array::vtable::ValidityChild<V> + vortex_array::vtable::VTable
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::vtable::ValidityVTableFromChild::validity(array: &<V as vortex_array::vtable::VTable>::Array) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub trait vortex_array::vtable::VisitorVTable<V: vortex_array::vtable::VTable>
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::vtable::VisitorVTable::buffer_names(array: &<V as vortex_array::vtable::VTable>::Array) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::vtable::VisitorVTable::nbuffers(array: &<V as vortex_array::vtable::VTable>::Array) -> usize
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::vtable::VisitorVTable::nchildren(array: &<V as vortex_array::vtable::VTable>::Array) -> usize
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::vtable::VisitorVTable::nth_child(array: &<V as vortex_array::vtable::VTable>::Array, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::vtable::VisitorVTable::visit_buffers(array: &<V as vortex_array::vtable::VTable>::Array, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::vtable::VisitorVTable::visit_children(array: &<V as vortex_array::vtable::VTable>::Array, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::vtable::VisitorVTable::visit_children_unnamed(array: &<V as vortex_array::vtable::VTable>::Array, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::BoolVTable> for vortex_array::arrays::BoolVTable
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolVTable::nbuffers(_array: &vortex_array::arrays::BoolArray) -> usize
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolVTable::nchildren(array: &vortex_array::arrays::BoolArray) -> usize
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::BoolVTable::nth_child(array: &vortex_array::arrays::BoolArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::BoolVTable::visit_buffers(array: &vortex_array::arrays::BoolArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::BoolVTable::visit_children(array: &vortex_array::arrays::BoolArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ChunkedVTable> for vortex_array::arrays::ChunkedVTable
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ChunkedVTable::nbuffers(_array: &vortex_array::arrays::ChunkedArray) -> usize
+pub trait vortex_array::DeserializeMetadata where Self: core::marker::Sized
 
-pub fn vortex_array::arrays::ChunkedVTable::nchildren(array: &vortex_array::arrays::ChunkedArray) -> usize
+pub type vortex_array::DeserializeMetadata::Output
 
-pub fn vortex_array::arrays::ChunkedVTable::nth_child(array: &vortex_array::arrays::ChunkedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::DeserializeMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_buffers(_array: &vortex_array::arrays::ChunkedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::DeserializeMetadata for vortex_array::EmptyMetadata
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_children(array: &vortex_array::arrays::ChunkedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub type vortex_array::EmptyMetadata::Output = vortex_array::EmptyMetadata
 
-pub fn vortex_array::arrays::ChunkedVTable::visit_children_unnamed(array: &vortex_array::arrays::ChunkedArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+pub fn vortex_array::EmptyMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ConstantVTable> for vortex_array::arrays::ConstantVTable
+impl vortex_array::DeserializeMetadata for vortex_array::RawMetadata
 
-pub fn vortex_array::arrays::ConstantVTable::nbuffers(_array: &vortex_array::arrays::ConstantArray) -> usize
+pub type vortex_array::RawMetadata::Output = alloc::vec::Vec<u8>
 
-pub fn vortex_array::arrays::ConstantVTable::nchildren(_array: &vortex_array::arrays::ConstantArray) -> usize
+pub fn vortex_array::RawMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-pub fn vortex_array::arrays::ConstantVTable::nth_child(_array: &vortex_array::arrays::ConstantArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl<M> vortex_array::DeserializeMetadata for vortex_array::ProstMetadata<M> where M: core::fmt::Debug + prost::message::Message + core::default::Default
 
-pub fn vortex_array::arrays::ConstantVTable::visit_buffers(array: &vortex_array::arrays::ConstantArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub type vortex_array::ProstMetadata<M>::Output = M
 
-pub fn vortex_array::arrays::ConstantVTable::visit_children(_array: &vortex_array::arrays::ConstantArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::ProstMetadata<M>::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::DecimalVTable> for vortex_array::arrays::DecimalVTable
+pub trait vortex_array::DynArrayEq: vortex_array::hash::private::SealedEq
 
-pub fn vortex_array::arrays::DecimalVTable::nbuffers(_array: &vortex_array::arrays::DecimalArray) -> usize
+pub fn vortex_array::DynArrayEq::dyn_array_eq(&self, other: &dyn core::any::Any, precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::nchildren(array: &vortex_array::arrays::DecimalArray) -> usize
+impl<T: vortex_array::ArrayEq + 'static> vortex_array::DynArrayEq for T
 
-pub fn vortex_array::arrays::DecimalVTable::nth_child(array: &vortex_array::arrays::DecimalArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn T::dyn_array_eq(&self, other: &(dyn core::any::Any + 'static), precision: vortex_array::Precision) -> bool
 
-pub fn vortex_array::arrays::DecimalVTable::visit_buffers(array: &vortex_array::arrays::DecimalArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub trait vortex_array::DynArrayHash: vortex_array::hash::private::SealedHash
 
-pub fn vortex_array::arrays::DecimalVTable::visit_children(array: &vortex_array::arrays::DecimalArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::DynArrayHash::dyn_array_hash(&self, state: &mut dyn core::hash::Hasher, precision: vortex_array::Precision)
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::DictVTable> for vortex_array::arrays::DictVTable
+impl<T: vortex_array::ArrayHash + ?core::marker::Sized> vortex_array::DynArrayHash for T
 
-pub fn vortex_array::arrays::DictVTable::nbuffers(_array: &vortex_array::arrays::DictArray) -> usize
+pub fn T::dyn_array_hash(&self, state: &mut dyn core::hash::Hasher, precision: vortex_array::Precision)
 
-pub fn vortex_array::arrays::DictVTable::nchildren(_array: &vortex_array::arrays::DictArray) -> usize
+pub trait vortex_array::Executable: core::marker::Sized
 
-pub fn vortex_array::arrays::DictVTable::nth_child(array: &vortex_array::arrays::DictArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::Executable::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::DictVTable::visit_buffers(_array: &vortex_array::arrays::DictArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::Executable for vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::DictVTable::visit_children(array: &vortex_array::arrays::DictArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::ArrayRef::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ExtensionVTable> for vortex_array::arrays::ExtensionVTable
+impl vortex_array::Executable for vortex_array::Canonical
 
-pub fn vortex_array::arrays::ExtensionVTable::nbuffers(_array: &vortex_array::arrays::ExtensionArray) -> usize
+pub fn vortex_array::Canonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ExtensionVTable::nchildren(_array: &vortex_array::arrays::ExtensionArray) -> usize
+impl vortex_array::Executable for vortex_array::CanonicalValidity
 
-pub fn vortex_array::arrays::ExtensionVTable::nth_child(array: &vortex_array::arrays::ExtensionArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::CanonicalValidity::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ExtensionVTable::visit_buffers(_array: &vortex_array::arrays::ExtensionArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::Executable for vortex_array::Columnar
 
-pub fn vortex_array::arrays::ExtensionVTable::visit_children(array: &vortex_array::arrays::ExtensionArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::Columnar::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::FilterVTable> for vortex_array::arrays::FilterVTable
+impl vortex_array::Executable for vortex_array::RecursiveCanonical
 
-pub fn vortex_array::arrays::FilterVTable::nchildren(_array: &vortex_array::arrays::FilterArray) -> usize
+pub fn vortex_array::RecursiveCanonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FilterVTable::nth_child(array: &vortex_array::arrays::FilterArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::Executable for vortex_array::arrays::BoolArray
 
-pub fn vortex_array::arrays::FilterVTable::visit_buffers(_array: &vortex_array::arrays::FilterArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::BoolArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FilterVTable::visit_children(array: &vortex_array::arrays::FilterArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::Executable for vortex_array::arrays::DecimalArray
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::FixedSizeListVTable> for vortex_array::arrays::FixedSizeListVTable
+pub fn vortex_array::arrays::DecimalArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nbuffers(_array: &vortex_array::arrays::FixedSizeListArray) -> usize
+impl vortex_array::Executable for vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nchildren(array: &vortex_array::arrays::FixedSizeListArray) -> usize
+pub fn vortex_array::arrays::ExtensionArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::nth_child(array: &vortex_array::arrays::FixedSizeListArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::Executable for vortex_array::arrays::FixedSizeListArray
 
-pub fn vortex_array::arrays::FixedSizeListVTable::visit_buffers(_array: &vortex_array::arrays::FixedSizeListArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::FixedSizeListArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::FixedSizeListVTable::visit_children(array: &vortex_array::arrays::FixedSizeListArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::Executable for vortex_array::arrays::ListViewArray
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ListVTable> for vortex_array::arrays::ListVTable
+pub fn vortex_array::arrays::ListViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListVTable::nbuffers(_array: &vortex_array::arrays::ListArray) -> usize
+impl vortex_array::Executable for vortex_array::arrays::PrimitiveArray
 
-pub fn vortex_array::arrays::ListVTable::nchildren(array: &vortex_array::arrays::ListArray) -> usize
+pub fn vortex_array::arrays::PrimitiveArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListVTable::nth_child(array: &vortex_array::arrays::ListArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::Executable for vortex_array::arrays::StructArray
 
-pub fn vortex_array::arrays::ListVTable::visit_buffers(_array: &vortex_array::arrays::ListArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::StructArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListVTable::visit_children(array: &vortex_array::arrays::ListArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::Executable for vortex_array::arrays::VarBinViewArray
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ListViewVTable> for vortex_array::arrays::ListViewVTable
+pub fn vortex_array::arrays::VarBinViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListViewVTable::nbuffers(_array: &vortex_array::arrays::ListViewArray) -> usize
+impl vortex_array::Executable for vortex_array::arrays::null::NullArray
 
-pub fn vortex_array::arrays::ListViewVTable::nchildren(array: &vortex_array::arrays::ListViewArray) -> usize
+pub fn vortex_array::arrays::null::NullArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListViewVTable::nth_child(array: &vortex_array::arrays::ListViewArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::Executable for vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::arrays::ListViewVTable::visit_buffers(_array: &vortex_array::arrays::ListViewArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_buffer::bit::buf::BitBuffer::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::ListViewVTable::visit_children(array: &vortex_array::arrays::ListViewArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::Executable for vortex_mask::Mask
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::MaskedVTable> for vortex_array::arrays::MaskedVTable
+pub fn vortex_mask::Mask::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::MaskedVTable::nchildren(array: &vortex_array::arrays::MaskedArray) -> usize
+impl<T: vortex_array::dtype::NativePType> vortex_array::Executable for vortex_buffer::buffer::Buffer<T>
 
-pub fn vortex_array::arrays::MaskedVTable::nth_child(array: &vortex_array::arrays::MaskedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_buffer::buffer::Buffer<T>::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
 
-pub fn vortex_array::arrays::MaskedVTable::visit_buffers(_array: &vortex_array::arrays::MaskedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub trait vortex_array::IntoArray
 
-pub fn vortex_array::arrays::MaskedVTable::visit_children(array: &vortex_array::arrays::MaskedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::IntoArray::into_array(self) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::NullVTable> for vortex_array::arrays::NullVTable
+impl vortex_array::IntoArray for &vortex_mask::MaskValues
 
-pub fn vortex_array::arrays::NullVTable::nchildren(_array: &vortex_array::arrays::NullArray) -> usize
+pub fn &vortex_mask::MaskValues::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NullVTable::nth_child(_array: &vortex_array::arrays::NullArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::IntoArray for arrow_buffer::buffer::boolean::BooleanBuffer
 
-pub fn vortex_array::arrays::NullVTable::visit_buffers(_array: &vortex_array::arrays::NullArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn arrow_buffer::buffer::boolean::BooleanBuffer::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::NullVTable::visit_children(_array: &vortex_array::arrays::NullArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::IntoArray for arrow_buffer::buffer::immutable::Buffer
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::PrimitiveVTable> for vortex_array::arrays::PrimitiveVTable
+pub fn arrow_buffer::buffer::immutable::Buffer::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::nbuffers(_array: &vortex_array::arrays::PrimitiveArray) -> usize
+impl vortex_array::IntoArray for vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::nchildren(array: &vortex_array::arrays::PrimitiveArray) -> usize
+pub fn vortex_array::ArrayRef::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::nth_child(array: &vortex_array::arrays::PrimitiveArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::IntoArray for vortex_array::Canonical
 
-pub fn vortex_array::arrays::PrimitiveVTable::visit_buffers(array: &vortex_array::arrays::PrimitiveArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::Canonical::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::PrimitiveVTable::visit_children(array: &vortex_array::arrays::PrimitiveArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::IntoArray for vortex_array::Columnar
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::ScalarFnVTable> for vortex_array::arrays::ScalarFnVTable
+pub fn vortex_array::Columnar::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::nbuffers(_array: &vortex_array::arrays::ScalarFnArray) -> usize
+impl vortex_array::IntoArray for vortex_array::arrays::datetime::TemporalData
 
-pub fn vortex_array::arrays::ScalarFnVTable::nchildren(array: &vortex_array::arrays::ScalarFnArray) -> usize
+pub fn vortex_array::arrays::datetime::TemporalData::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::nth_child(array: &vortex_array::arrays::ScalarFnArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::IntoArray for vortex_buffer::bit::buf::BitBuffer
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_buffers(_array: &vortex_array::arrays::ScalarFnArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_buffer::bit::buf::BitBuffer::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_children(array: &vortex_array::arrays::ScalarFnArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::IntoArray for vortex_buffer::bit::buf_mut::BitBufferMut
 
-pub fn vortex_array::arrays::ScalarFnVTable::visit_children_unnamed(array: &vortex_array::arrays::ScalarFnArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+pub fn vortex_buffer::bit::buf_mut::BitBufferMut::into_array(self) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::SharedVTable> for vortex_array::arrays::SharedVTable
+impl vortex_array::IntoArray for vortex_mask::Mask
 
-pub fn vortex_array::arrays::SharedVTable::nchildren(_array: &vortex_array::arrays::SharedArray) -> usize
+pub fn vortex_mask::Mask::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SharedVTable::nth_child(array: &vortex_array::arrays::SharedArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl<O> vortex_array::IntoArray for arrow_buffer::buffer::offset::OffsetBuffer<O> where O: vortex_array::dtype::IntegerPType + arrow_array::array::list_array::OffsetSizeTrait
 
-pub fn vortex_array::arrays::SharedVTable::visit_buffers(_array: &vortex_array::arrays::SharedArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn arrow_buffer::buffer::offset::OffsetBuffer<O>::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SharedVTable::visit_children(array: &vortex_array::arrays::SharedArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl<T: vortex_array::dtype::NativePType> vortex_array::IntoArray for vortex_buffer::buffer::Buffer<T>
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::SliceVTable> for vortex_array::arrays::SliceVTable
+pub fn vortex_buffer::buffer::Buffer<T>::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceVTable::nchildren(_array: &vortex_array::arrays::SliceArray) -> usize
+impl<T: vortex_array::dtype::NativePType> vortex_array::IntoArray for vortex_buffer::buffer_mut::BufferMut<T>
 
-pub fn vortex_array::arrays::SliceVTable::nth_child(array: &vortex_array::arrays::SliceArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_buffer::buffer_mut::BufferMut<T>::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::SliceVTable::visit_buffers(_array: &vortex_array::arrays::SliceArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl<T> vortex_array::IntoArray for arrow_buffer::buffer::scalar::ScalarBuffer<T> where T: arrow_buffer::native::ArrowNativeType + vortex_array::dtype::NativePType
 
-pub fn vortex_array::arrays::SliceVTable::visit_children(array: &vortex_array::arrays::SliceArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn arrow_buffer::buffer::scalar::ScalarBuffer<T>::into_array(self) -> vortex_array::ArrayRef
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::StructVTable> for vortex_array::arrays::StructVTable
+impl<V: vortex_array::VTable> vortex_array::IntoArray for alloc::sync::Arc<vortex_array::Array<V>>
 
-pub fn vortex_array::arrays::StructVTable::nbuffers(_array: &vortex_array::arrays::StructArray) -> usize
+pub fn alloc::sync::Arc<vortex_array::Array<V>>::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructVTable::nchildren(array: &vortex_array::arrays::StructArray) -> usize
+impl<V: vortex_array::VTable> vortex_array::IntoArray for vortex_array::Array<V>
 
-pub fn vortex_array::arrays::StructVTable::nth_child(array: &vortex_array::arrays::StructArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::Array<V>::into_array(self) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructVTable::visit_buffers(_array: &vortex_array::arrays::StructArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub trait vortex_array::OperationsVTable<V: vortex_array::VTable>
 
-pub fn vortex_array::arrays::StructVTable::visit_children(array: &vortex_array::arrays::StructArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::OperationsVTable::scalar_at(array: vortex_array::ArrayView<'_, V>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::StructVTable::visit_children_unnamed(array: &vortex_array::arrays::StructArray, visitor: &mut dyn vortex_array::ArrayChildVisitorUnnamed)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::VarBinVTable> for vortex_array::arrays::VarBinVTable
+pub fn vortex_array::arrays::Bool::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinVTable::nbuffers(_array: &vortex_array::arrays::VarBinArray) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_array::arrays::VarBinVTable::nchildren(array: &vortex_array::arrays::VarBinArray) -> usize
+pub fn vortex_array::arrays::Chunked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinVTable::nth_child(array: &vortex_array::arrays::VarBinArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_array::arrays::VarBinVTable::visit_buffers(array: &vortex_array::arrays::VarBinArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Constant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinVTable::visit_children(array: &vortex_array::arrays::VarBinArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::OperationsVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrays::VarBinViewVTable> for vortex_array::arrays::VarBinViewVTable
+pub fn vortex_array::arrays::Decimal::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinViewVTable::nbuffers(array: &vortex_array::arrays::VarBinViewArray) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-pub fn vortex_array::arrays::VarBinViewVTable::nchildren(array: &vortex_array::arrays::VarBinViewArray) -> usize
+pub fn vortex_array::arrays::Extension::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinViewVTable::nth_child(array: &vortex_array::arrays::VarBinViewArray, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub fn vortex_array::arrays::VarBinViewVTable::visit_buffers(array: &vortex_array::arrays::VarBinViewArray, visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+pub fn vortex_array::arrays::Filter::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrays::VarBinViewVTable::visit_children(array: &vortex_array::arrays::VarBinViewArray, visitor: &mut dyn vortex_array::ArrayChildVisitor)
+impl vortex_array::OperationsVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-impl vortex_array::vtable::VisitorVTable<vortex_array::arrow::ArrowVTable> for vortex_array::arrow::ArrowVTable
+pub fn vortex_array::arrays::FixedSizeList::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrow::ArrowVTable::nchildren(_array: &vortex_array::arrow::ArrowArray) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub fn vortex_array::arrow::ArrowVTable::nth_child(_array: &vortex_array::arrow::ArrowArray, _idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::List::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::arrow::ArrowVTable::visit_buffers(_array: &vortex_array::arrow::ArrowArray, _visitor: &mut dyn vortex_array::ArrayBufferVisitor)
+impl vortex_array::OperationsVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-pub fn vortex_array::arrow::ArrowVTable::visit_children(_array: &vortex_array::arrow::ArrowArray, _visitor: &mut dyn vortex_array::ArrayChildVisitor)
+pub fn vortex_array::arrays::ListView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub fn vortex_array::vtable::validity_nchildren(validity: &vortex_array::validity::Validity) -> usize
+impl vortex_array::OperationsVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::vtable::validity_to_child(validity: &vortex_array::validity::Validity, len: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub type vortex_array::vtable::ArrayId = arcref::ArcRef<str>
+impl vortex_array::OperationsVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub macro vortex_array::field_path!
+pub fn vortex_array::arrays::Primitive::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::match_each_decimal_value!
+impl vortex_array::OperationsVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub macro vortex_array::match_each_decimal_value_type!
+pub fn vortex_array::arrays::Shared::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::match_each_float_ptype!
+impl vortex_array::OperationsVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-pub macro vortex_array::match_each_integer_ptype!
+pub fn vortex_array::arrays::Struct::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::match_each_native_ptype!
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub macro vortex_array::match_each_native_simd_ptype!
+pub fn vortex_array::arrays::VarBin::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::match_each_pvalue!
+impl vortex_array::OperationsVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub macro vortex_array::match_each_signed_integer_ptype!
+pub fn vortex_array::arrays::VarBinView::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::match_each_unsigned_integer_ptype!
+impl vortex_array::OperationsVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub macro vortex_array::match_smallest_offset_type!
+pub fn vortex_array::arrays::Variant::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub macro vortex_array::register_kernel!
+impl vortex_array::OperationsVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub macro vortex_array::vtable!
+pub fn vortex_array::arrays::dict::Dict::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub enum vortex_array::Canonical
+impl vortex_array::OperationsVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub vortex_array::Canonical::Bool(vortex_array::arrays::BoolArray)
+pub fn vortex_array::arrays::null::Null::scalar_at(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_array::Canonical::Decimal(vortex_array::arrays::DecimalArray)
+impl vortex_array::OperationsVTable<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-pub vortex_array::Canonical::Extension(vortex_array::arrays::ExtensionArray)
+pub fn vortex_array::arrays::patched::Patched::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>, index: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_array::Canonical::FixedSizeList(vortex_array::arrays::FixedSizeListArray)
+impl vortex_array::OperationsVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub vortex_array::Canonical::List(vortex_array::arrays::ListViewArray)
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_array::Canonical::Null(vortex_array::arrays::NullArray)
+impl vortex_array::OperationsVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub vortex_array::Canonical::Primitive(vortex_array::arrays::PrimitiveArray)
+pub fn vortex_array::arrays::slice::Slice::scalar_at(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>, index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub vortex_array::Canonical::Struct(vortex_array::arrays::StructArray)
+impl<V: vortex_array::VTable> vortex_array::OperationsVTable<V> for vortex_array::NotSupported
 
-pub vortex_array::Canonical::VarBinView(vortex_array::arrays::VarBinViewArray)
+pub fn vortex_array::NotSupported::scalar_at(array: vortex_array::ArrayView<'_, V>, _index: usize, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-impl vortex_array::Canonical
+pub trait vortex_array::SerializeMetadata
 
-pub fn vortex_array::Canonical::as_bool(&self) -> &vortex_array::arrays::BoolArray
+pub fn vortex_array::SerializeMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn vortex_array::Canonical::as_decimal(&self) -> &vortex_array::arrays::DecimalArray
+impl vortex_array::SerializeMetadata for vortex_array::EmptyMetadata
 
-pub fn vortex_array::Canonical::as_extension(&self) -> &vortex_array::arrays::ExtensionArray
+pub fn vortex_array::EmptyMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn vortex_array::Canonical::as_fixed_size_list(&self) -> &vortex_array::arrays::FixedSizeListArray
+impl vortex_array::SerializeMetadata for vortex_array::RawMetadata
 
-pub fn vortex_array::Canonical::as_listview(&self) -> &vortex_array::arrays::ListViewArray
+pub fn vortex_array::RawMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn vortex_array::Canonical::as_null(&self) -> &vortex_array::arrays::NullArray
+impl<M> vortex_array::SerializeMetadata for vortex_array::ProstMetadata<M> where M: prost::message::Message
 
-pub fn vortex_array::Canonical::as_primitive(&self) -> &vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::ProstMetadata<M>::serialize(self) -> alloc::vec::Vec<u8>
 
-pub fn vortex_array::Canonical::as_struct(&self) -> &vortex_array::arrays::StructArray
+pub trait vortex_array::ToCanonical
 
-pub fn vortex_array::Canonical::as_varbinview(&self) -> &vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::ToCanonical::to_bool(&self) -> vortex_array::arrays::BoolArray
 
-pub fn vortex_array::Canonical::into_bool(self) -> vortex_array::arrays::BoolArray
+pub fn vortex_array::ToCanonical::to_decimal(&self) -> vortex_array::arrays::DecimalArray
 
-pub fn vortex_array::Canonical::into_decimal(self) -> vortex_array::arrays::DecimalArray
+pub fn vortex_array::ToCanonical::to_extension(&self) -> vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::Canonical::into_extension(self) -> vortex_array::arrays::ExtensionArray
+pub fn vortex_array::ToCanonical::to_fixed_size_list(&self) -> vortex_array::arrays::FixedSizeListArray
 
-pub fn vortex_array::Canonical::into_fixed_size_list(self) -> vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::ToCanonical::to_listview(&self) -> vortex_array::arrays::ListViewArray
 
-pub fn vortex_array::Canonical::into_listview(self) -> vortex_array::arrays::ListViewArray
+pub fn vortex_array::ToCanonical::to_null(&self) -> vortex_array::arrays::null::NullArray
 
-pub fn vortex_array::Canonical::into_null(self) -> vortex_array::arrays::NullArray
+pub fn vortex_array::ToCanonical::to_primitive(&self) -> vortex_array::arrays::PrimitiveArray
 
-pub fn vortex_array::Canonical::into_primitive(self) -> vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::ToCanonical::to_struct(&self) -> vortex_array::arrays::StructArray
 
-pub fn vortex_array::Canonical::into_struct(self) -> vortex_array::arrays::StructArray
+pub fn vortex_array::ToCanonical::to_varbinview(&self) -> vortex_array::arrays::VarBinViewArray
 
-pub fn vortex_array::Canonical::into_varbinview(self) -> vortex_array::arrays::VarBinViewArray
+impl vortex_array::ToCanonical for vortex_array::ArrayRef
 
-impl vortex_array::Canonical
+pub fn vortex_array::ArrayRef::to_bool(&self) -> vortex_array::arrays::BoolArray
 
-pub fn vortex_array::Canonical::compact(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::ArrayRef::to_decimal(&self) -> vortex_array::arrays::DecimalArray
 
-impl vortex_array::Canonical
+pub fn vortex_array::ArrayRef::to_extension(&self) -> vortex_array::arrays::ExtensionArray
 
-pub fn vortex_array::Canonical::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::ArrayRef::to_fixed_size_list(&self) -> vortex_array::arrays::FixedSizeListArray
 
-pub fn vortex_array::Canonical::empty(dtype: &vortex_array::dtype::DType) -> vortex_array::Canonical
+pub fn vortex_array::ArrayRef::to_listview(&self) -> vortex_array::arrays::ListViewArray
 
-pub fn vortex_array::Canonical::is_empty(&self) -> bool
+pub fn vortex_array::ArrayRef::to_null(&self) -> vortex_array::arrays::null::NullArray
 
-pub fn vortex_array::Canonical::len(&self) -> usize
+pub fn vortex_array::ArrayRef::to_primitive(&self) -> vortex_array::arrays::PrimitiveArray
 
-impl core::clone::Clone for vortex_array::Canonical
+pub fn vortex_array::ArrayRef::to_struct(&self) -> vortex_array::arrays::StructArray
 
-pub fn vortex_array::Canonical::clone(&self) -> vortex_array::Canonical
+pub fn vortex_array::ArrayRef::to_varbinview(&self) -> vortex_array::arrays::VarBinViewArray
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::Canonical
+pub trait vortex_array::TypedArrayRef<V: vortex_array::VTable>: core::convert::AsRef<vortex_array::ArrayRef> + core::ops::deref::Deref<Target = <V as vortex_array::VTable>::ArrayData>
 
-pub fn vortex_array::Canonical::as_ref(&self) -> &(dyn vortex_array::Array + 'static)
+pub fn vortex_array::TypedArrayRef::to_owned(&self) -> vortex_array::Array<V>
 
-impl core::convert::From<vortex_array::Canonical> for vortex_array::ArrayRef
+impl<V: vortex_array::VTable> vortex_array::TypedArrayRef<V> for vortex_array::Array<V>
 
-pub fn vortex_array::ArrayRef::from(value: vortex_array::Canonical) -> Self
+pub fn vortex_array::Array<V>::to_owned(&self) -> vortex_array::Array<V>
 
-impl core::convert::From<vortex_array::CanonicalView<'_>> for vortex_array::Canonical
+impl<V: vortex_array::VTable> vortex_array::TypedArrayRef<V> for vortex_array::ArrayView<'_, V>
 
-pub fn vortex_array::Canonical::from(value: vortex_array::CanonicalView<'_>) -> Self
+pub fn vortex_array::ArrayView<'_, V>::to_owned(&self) -> vortex_array::Array<V>
 
-impl core::fmt::Debug for vortex_array::Canonical
+pub trait vortex_array::VTable: 'static + core::clone::Clone + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
-pub fn vortex_array::Canonical::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::VTable::ArrayData: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::fmt::Display + vortex_array::ArrayHash + vortex_array::ArrayEq
 
-impl vortex_array::Executable for vortex_array::Canonical
+pub type vortex_array::VTable::OperationsVTable: vortex_array::OperationsVTable<Self>
 
-pub fn vortex_array::Canonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub type vortex_array::VTable::ValidityVTable: vortex_array::ValidityVTable<Self>
 
-impl vortex_array::IntoArray for vortex_array::Canonical
+pub fn vortex_array::VTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::Canonical::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::VTable::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub enum vortex_array::CanonicalView<'a>
+pub fn vortex_array::VTable::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub vortex_array::CanonicalView::Bool(&'a vortex_array::arrays::BoolArray)
+pub fn vortex_array::VTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub vortex_array::CanonicalView::Decimal(&'a vortex_array::arrays::DecimalArray)
+pub fn vortex_array::VTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub vortex_array::CanonicalView::Extension(&'a vortex_array::arrays::ExtensionArray)
+pub fn vortex_array::VTable::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub vortex_array::CanonicalView::FixedSizeList(&'a vortex_array::arrays::FixedSizeListArray)
+pub fn vortex_array::VTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub vortex_array::CanonicalView::List(&'a vortex_array::arrays::ListViewArray)
+pub fn vortex_array::VTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::CanonicalView::Null(&'a vortex_array::arrays::NullArray)
+pub fn vortex_array::VTable::id(&self) -> vortex_array::ArrayId
 
-pub vortex_array::CanonicalView::Primitive(&'a vortex_array::arrays::PrimitiveArray)
+pub fn vortex_array::VTable::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::CanonicalView::Struct(&'a vortex_array::arrays::StructArray)
+pub fn vortex_array::VTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub vortex_array::CanonicalView::VarBinView(&'a vortex_array::arrays::VarBinViewArray)
+pub fn vortex_array::VTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::convert::AsRef<dyn vortex_array::Array> for vortex_array::CanonicalView<'_>
+pub fn vortex_array::VTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::CanonicalView<'_>::as_ref(&self) -> &dyn vortex_array::Array
+pub fn vortex_array::VTable::serialize(array: vortex_array::ArrayView<'_, Self>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-impl core::convert::From<vortex_array::CanonicalView<'_>> for vortex_array::Canonical
+pub fn vortex_array::VTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::Canonical::from(value: vortex_array::CanonicalView<'_>) -> Self
+pub fn vortex_array::VTable::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl<'a> core::clone::Clone for vortex_array::CanonicalView<'a>
+impl vortex_array::VTable for vortex_array::arrays::Bool
 
-pub fn vortex_array::CanonicalView<'a>::clone(&self) -> vortex_array::CanonicalView<'a>
+pub type vortex_array::arrays::Bool::ArrayData = vortex_array::arrays::bool::BoolData
 
-impl<'a> core::fmt::Debug for vortex_array::CanonicalView<'a>
+pub type vortex_array::arrays::Bool::OperationsVTable = vortex_array::arrays::Bool
 
-pub fn vortex_array::CanonicalView<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Bool::ValidityVTable = vortex_array::arrays::Bool
 
-pub enum vortex_array::Columnar
+pub fn vortex_array::arrays::Bool::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub vortex_array::Columnar::Canonical(vortex_array::Canonical)
+pub fn vortex_array::arrays::Bool::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub vortex_array::Columnar::Constant(vortex_array::arrays::ConstantArray)
+pub fn vortex_array::arrays::Bool::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::Columnar
+pub fn vortex_array::arrays::Bool::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::Columnar::constant<S: core::convert::Into<vortex_array::scalar::Scalar>>(scalar: S, len: usize) -> Self
+pub fn vortex_array::arrays::Bool::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::Columnar::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Bool::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::Columnar::is_empty(&self) -> bool
+pub fn vortex_array::arrays::Bool::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::Columnar::len(&self) -> usize
+pub fn vortex_array::arrays::Bool::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::Executable for vortex_array::Columnar
+pub fn vortex_array::arrays::Bool::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::Columnar::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Bool::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::IntoArray for vortex_array::Columnar
+pub fn vortex_array::arrays::Bool::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::Columnar::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub enum vortex_array::ColumnarView<'a>
+pub fn vortex_array::arrays::Bool::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub vortex_array::ColumnarView::Canonical(vortex_array::CanonicalView<'a>)
+pub fn vortex_array::arrays::Bool::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub vortex_array::ColumnarView::Constant(&'a vortex_array::arrays::ConstantArray)
+pub fn vortex_array::arrays::Bool::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<'a> core::convert::AsRef<dyn vortex_array::Array> for vortex_array::ColumnarView<'a>
+pub fn vortex_array::arrays::Bool::validate(&self, data: &vortex_array::arrays::bool::BoolData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ColumnarView<'a>::as_ref(&self) -> &dyn vortex_array::Array
+impl vortex_array::VTable for vortex_array::arrays::Chunked
 
-pub enum vortex_array::Precision
+pub type vortex_array::arrays::Chunked::ArrayData = vortex_array::arrays::chunked::ChunkedData
 
-pub vortex_array::Precision::Ptr
+pub type vortex_array::arrays::Chunked::OperationsVTable = vortex_array::arrays::Chunked
 
-pub vortex_array::Precision::Value
+pub type vortex_array::arrays::Chunked::ValidityVTable = vortex_array::arrays::Chunked
 
-impl core::clone::Clone for vortex_array::Precision
+pub fn vortex_array::arrays::Chunked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::Precision::clone(&self) -> vortex_array::Precision
+pub fn vortex_array::arrays::Chunked::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl core::fmt::Debug for vortex_array::Precision
+pub fn vortex_array::arrays::Chunked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::Precision::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Chunked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl core::marker::Copy for vortex_array::Precision
+pub fn vortex_array::arrays::Chunked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub struct vortex_array::AnyCanonical
+pub fn vortex_array::arrays::Chunked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl vortex_array::matcher::Matcher for vortex_array::AnyCanonical
+pub fn vortex_array::arrays::Chunked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::AnyCanonical::Match<'a> = vortex_array::CanonicalView<'a>
+pub fn vortex_array::arrays::Chunked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::AnyCanonical::matches(array: &dyn vortex_array::Array) -> bool
+pub fn vortex_array::arrays::Chunked::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::AnyCanonical::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub fn vortex_array::arrays::Chunked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::AnyColumnar
+pub fn vortex_array::arrays::Chunked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::matcher::Matcher for vortex_array::AnyColumnar
+pub fn vortex_array::arrays::Chunked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::AnyColumnar::Match<'a> = vortex_array::ColumnarView<'a>
+pub fn vortex_array::arrays::Chunked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::AnyColumnar::try_match<'a>(array: &'a dyn vortex_array::Array) -> core::option::Option<Self::Match>
+pub fn vortex_array::arrays::Chunked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-#[repr(transparent)] pub struct vortex_array::ArrayAdapter<V: vortex_array::vtable::VTable>(_)
+pub fn vortex_array::arrays::Chunked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Chunked::validate(&self, data: &vortex_array::arrays::chunked::ChunkedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::as_inner(&self) -> &<V as vortex_array::vtable::VTable>::Array
+impl vortex_array::VTable for vortex_array::arrays::Constant
 
-impl<V: vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::ArrayAdapter<V>
+pub type vortex_array::arrays::Constant::ArrayData = vortex_array::arrays::constant::ConstantData
 
-pub fn vortex_array::ArrayAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::Constant::OperationsVTable = vortex_array::arrays::Constant
 
-impl<V: vortex_array::vtable::VTable> vortex_array::Array for vortex_array::ArrayAdapter<V>
+pub type vortex_array::arrays::Constant::ValidityVTable = vortex_array::arrays::Constant
 
-pub fn vortex_array::ArrayAdapter<V>::all_invalid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Constant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::all_valid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Constant::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayAdapter<V>::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::Constant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ArrayAdapter<V>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Constant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayAdapter<V>::as_any_arc(self: alloc::sync::Arc<Self>) -> alloc::sync::Arc<(dyn core::any::Any + core::marker::Send + core::marker::Sync)>
+pub fn vortex_array::arrays::Constant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::Constant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, _metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayAdapter<V>::encoding_id(&self) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Constant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::ArrayAdapter<V>::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::invalid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::Constant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ArrayAdapter<V>::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Constant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Constant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::len(&self) -> usize
+pub fn vortex_array::arrays::Constant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Constant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayAdapter<V>::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::Constant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Constant::validate(&self, data: &vortex_array::arrays::constant::ConstantData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::to_array(&self) -> vortex_array::ArrayRef
+impl vortex_array::VTable for vortex_array::arrays::Decimal
 
-pub fn vortex_array::ArrayAdapter<V>::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub type vortex_array::arrays::Decimal::ArrayData = vortex_array::arrays::decimal::DecimalData
 
-pub fn vortex_array::ArrayAdapter<V>::valid_count(&self) -> vortex_error::VortexResult<usize>
+pub type vortex_array::arrays::Decimal::OperationsVTable = vortex_array::arrays::Decimal
 
-pub fn vortex_array::ArrayAdapter<V>::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub type vortex_array::arrays::Decimal::ValidityVTable = vortex_array::arrays::Decimal
 
-pub fn vortex_array::ArrayAdapter<V>::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
+pub fn vortex_array::arrays::Decimal::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::vtable(&self) -> &dyn vortex_array::vtable::DynVTable
+pub fn vortex_array::arrays::Decimal::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayAdapter<V>::with_children(&self, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Decimal::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayEq for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Decimal::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayAdapter<V>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Decimal::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayHash for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Decimal::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayAdapter<V>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::Decimal::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayVisitor for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Decimal::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::buffer_handles(&self) -> alloc::vec::Vec<vortex_array::buffer::BufferHandle>
+pub fn vortex_array::arrays::Decimal::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ArrayAdapter<V>::buffer_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::Decimal::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::buffers(&self) -> alloc::vec::Vec<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::Decimal::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Decimal::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::children_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::Decimal::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::is_host(&self) -> bool
+pub fn vortex_array::arrays::Decimal::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayAdapter<V>::metadata(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Decimal::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Decimal::validate(&self, data: &vortex_array::arrays::decimal::DecimalData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
+impl vortex_array::VTable for vortex_array::arrays::Extension
 
-pub fn vortex_array::ArrayAdapter<V>::named_children(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::ArrayRef)>
+pub type vortex_array::arrays::Extension::ArrayData = vortex_array::arrays::extension::ExtensionData
 
-pub fn vortex_array::ArrayAdapter<V>::nbuffers(&self) -> usize
+pub type vortex_array::arrays::Extension::OperationsVTable = vortex_array::arrays::Extension
 
-pub fn vortex_array::ArrayAdapter<V>::nchildren(&self) -> usize
+pub type vortex_array::arrays::Extension::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::ArrayAdapter<V>::nth_child(&self, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Extension::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::scalar_fn::ReduceNode for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Extension::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayAdapter<V>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::Extension::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ArrayAdapter<V>::child(&self, idx: usize) -> vortex_array::scalar_fn::ReduceNodeRef
+pub fn vortex_array::arrays::Extension::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayAdapter<V>::child_count(&self) -> usize
+pub fn vortex_array::arrays::Extension::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::node_dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_array::arrays::Extension::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayAdapter<V>::scalar_fn(&self) -> core::option::Option<&vortex_array::scalar_fn::ScalarFnRef>
+pub fn vortex_array::arrays::Extension::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::CanonicalValidity(pub vortex_array::Canonical)
+pub fn vortex_array::arrays::Extension::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::Executable for vortex_array::CanonicalValidity
+pub fn vortex_array::arrays::Extension::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::CanonicalValidity::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::Extension::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub struct vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Extension::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl core::fmt::Debug for vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Extension::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::EmptyMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Extension::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::DeserializeMetadata for vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Extension::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub type vortex_array::EmptyMetadata::Output = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::Extension::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::EmptyMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub fn vortex_array::arrays::Extension::validate(&self, data: &vortex_array::arrays::extension::ExtensionData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl vortex_array::SerializeMetadata for vortex_array::EmptyMetadata
+impl vortex_array::VTable for vortex_array::arrays::Filter
 
-pub fn vortex_array::EmptyMetadata::serialize(self) -> alloc::vec::Vec<u8>
+pub type vortex_array::arrays::Filter::ArrayData = vortex_array::arrays::filter::FilterData
 
-pub struct vortex_array::ExecutionCtx
+pub type vortex_array::arrays::Filter::OperationsVTable = vortex_array::arrays::Filter
 
-impl vortex_array::ExecutionCtx
+pub type vortex_array::arrays::Filter::ValidityVTable = vortex_array::arrays::Filter
 
-pub fn vortex_array::ExecutionCtx::log(&mut self, msg: core::fmt::Arguments<'_>)
+pub fn vortex_array::arrays::Filter::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ExecutionCtx::new(session: vortex_session::VortexSession) -> Self
+pub fn vortex_array::arrays::Filter::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ExecutionCtx::session(&self) -> &vortex_session::VortexSession
+pub fn vortex_array::arrays::Filter::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl core::fmt::Display for vortex_array::ExecutionCtx
+pub fn vortex_array::arrays::Filter::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ExecutionCtx::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Filter::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl core::ops::drop::Drop for vortex_array::ExecutionCtx
+pub fn vortex_array::arrays::Filter::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ExecutionCtx::drop(&mut self)
+pub fn vortex_array::arrays::Filter::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub struct vortex_array::MaskFuture
+pub fn vortex_array::arrays::Filter::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::MaskFuture
+pub fn vortex_array::arrays::Filter::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::MaskFuture::inspect(self, f: impl core::ops::function::FnOnce(&vortex_error::SharedVortexResult<vortex_mask::Mask>) + 'static + core::marker::Send + core::marker::Sync) -> Self
+pub fn vortex_array::arrays::Filter::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::MaskFuture::is_empty(&self) -> bool
+pub fn vortex_array::arrays::Filter::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::MaskFuture::len(&self) -> usize
+pub fn vortex_array::arrays::Filter::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::MaskFuture::new<F>(len: usize, fut: F) -> Self where F: core::future::future::Future<Output = vortex_error::VortexResult<vortex_mask::Mask>> + core::marker::Send + 'static
+pub fn vortex_array::arrays::Filter::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::MaskFuture::new_true(row_count: usize) -> Self
+pub fn vortex_array::arrays::Filter::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::MaskFuture::ready(mask: vortex_mask::Mask) -> Self
+pub fn vortex_array::arrays::Filter::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::MaskFuture::slice(&self, range: core::ops::range::Range<usize>) -> Self
+pub fn vortex_array::arrays::Filter::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl core::clone::Clone for vortex_array::MaskFuture
+impl vortex_array::VTable for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::MaskFuture::clone(&self) -> vortex_array::MaskFuture
+pub type vortex_array::arrays::FixedSizeList::ArrayData = vortex_array::arrays::fixed_size_list::FixedSizeListData
 
-impl core::future::future::Future for vortex_array::MaskFuture
+pub type vortex_array::arrays::FixedSizeList::OperationsVTable = vortex_array::arrays::FixedSizeList
 
-pub type vortex_array::MaskFuture::Output = core::result::Result<vortex_mask::Mask, vortex_error::VortexError>
+pub type vortex_array::arrays::FixedSizeList::ValidityVTable = vortex_array::arrays::FixedSizeList
 
-pub fn vortex_array::MaskFuture::poll(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<Self::Output>
+pub fn vortex_array::arrays::FixedSizeList::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub struct vortex_array::ProstMetadata<M>(pub M)
+pub fn vortex_array::arrays::FixedSizeList::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-impl<M: core::fmt::Debug> core::fmt::Debug for vortex_array::ProstMetadata<M>
+pub fn vortex_array::arrays::FixedSizeList::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ProstMetadata<M>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::FixedSizeList::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-impl<M> core::ops::deref::Deref for vortex_array::ProstMetadata<M>
+pub fn vortex_array::arrays::FixedSizeList::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub type vortex_array::ProstMetadata<M>::Target = M
+pub fn vortex_array::arrays::FixedSizeList::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ProstMetadata<M>::deref(&self) -> &Self::Target
+pub fn vortex_array::arrays::FixedSizeList::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<M> vortex_array::DeserializeMetadata for vortex_array::ProstMetadata<M> where M: core::fmt::Debug + prost::message::Message + core::default::Default
+pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub type vortex_array::ProstMetadata<M>::Output = M
+pub fn vortex_array::arrays::FixedSizeList::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ProstMetadata<M>::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub fn vortex_array::arrays::FixedSizeList::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<M> vortex_array::SerializeMetadata for vortex_array::ProstMetadata<M> where M: prost::message::Message
+pub fn vortex_array::arrays::FixedSizeList::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ProstMetadata<M>::serialize(self) -> alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::FixedSizeList::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub struct vortex_array::RawMetadata(pub alloc::vec::Vec<u8>)
+pub fn vortex_array::arrays::FixedSizeList::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl core::fmt::Debug for vortex_array::RawMetadata
+pub fn vortex_array::arrays::FixedSizeList::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::RawMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::FixedSizeList::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::DeserializeMetadata for vortex_array::RawMetadata
+pub fn vortex_array::arrays::FixedSizeList::validate(&self, data: &vortex_array::arrays::fixed_size_list::FixedSizeListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::RawMetadata::Output = alloc::vec::Vec<u8>
+impl vortex_array::VTable for vortex_array::arrays::List
 
-pub fn vortex_array::RawMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub type vortex_array::arrays::List::ArrayData = vortex_array::arrays::list::ListData
 
-impl vortex_array::SerializeMetadata for vortex_array::RawMetadata
+pub type vortex_array::arrays::List::OperationsVTable = vortex_array::arrays::List
 
-pub fn vortex_array::RawMetadata::serialize(self) -> alloc::vec::Vec<u8>
+pub type vortex_array::arrays::List::ValidityVTable = vortex_array::arrays::List
 
-pub struct vortex_array::RecursiveCanonical(pub vortex_array::Canonical)
+pub fn vortex_array::arrays::List::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::Executable for vortex_array::RecursiveCanonical
+pub fn vortex_array::arrays::List::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::RecursiveCanonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::List::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub static vortex_array::LEGACY_SESSION: std::sync::lazy_lock::LazyLock<vortex_session::VortexSession>
+pub fn vortex_array::arrays::List::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub trait vortex_array::Array: 'static + vortex_array::array::private::Sealed + core::marker::Send + core::marker::Sync + core::fmt::Debug + vortex_array::DynArrayEq + vortex_array::DynArrayHash + vortex_array::ArrayVisitor + vortex_array::scalar_fn::ReduceNode
+pub fn vortex_array::arrays::List::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::Array::all_invalid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::List::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::Array::all_valid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::List::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::Array::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::List::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::Array::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::List::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::Array::as_any_arc(self: alloc::sync::Arc<Self>) -> alloc::sync::Arc<(dyn core::any::Any + core::marker::Send + core::marker::Sync)>
+pub fn vortex_array::arrays::List::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::Array::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::List::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::Array::encoding_id(&self) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::List::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::Array::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::List::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::Array::invalid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::List::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::Array::is_empty(&self) -> bool
+pub fn vortex_array::arrays::List::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::Array::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::List::validate(&self, _data: &vortex_array::arrays::list::ListData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::Array::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
+impl vortex_array::VTable for vortex_array::arrays::ListView
 
-pub fn vortex_array::Array::len(&self) -> usize
+pub type vortex_array::arrays::ListView::ArrayData = vortex_array::arrays::listview::ListViewData
 
-pub fn vortex_array::Array::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub type vortex_array::arrays::ListView::OperationsVTable = vortex_array::arrays::ListView
 
-pub fn vortex_array::Array::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::ListView::ValidityVTable = vortex_array::arrays::ListView
 
-pub fn vortex_array::Array::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::ListView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::Array::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::Array::to_array(&self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::ListView::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::Array::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::arrays::ListView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::Array::valid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::ListView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::Array::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::ListView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::Array::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
+pub fn vortex_array::arrays::ListView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::Array::vtable(&self) -> &dyn vortex_array::vtable::DynVTable
+pub fn vortex_array::arrays::ListView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::Array::with_children(&self, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::ListView::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::Array for alloc::sync::Arc<dyn vortex_array::Array>
+pub fn vortex_array::arrays::ListView::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::all_invalid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::ListView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::all_valid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::ListView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+pub fn vortex_array::arrays::ListView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::as_any(&self) -> &dyn core::any::Any
+pub fn vortex_array::arrays::ListView::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::as_any_arc(self: alloc::sync::Arc<Self>) -> alloc::sync::Arc<(dyn core::any::Any + core::marker::Send + core::marker::Sync)>
+pub fn vortex_array::arrays::ListView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::dtype(&self) -> &vortex_array::dtype::DType
+pub fn vortex_array::arrays::ListView::validate(&self, _data: &vortex_array::arrays::listview::ListViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::encoding_id(&self) -> vortex_array::vtable::ArrayId
+impl vortex_array::VTable for vortex_array::arrays::Masked
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub type vortex_array::arrays::Masked::ArrayData = vortex_array::arrays::masked::MaskedData
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::invalid_count(&self) -> vortex_error::VortexResult<usize>
+pub type vortex_array::arrays::Masked::OperationsVTable = vortex_array::arrays::Masked
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub type vortex_array::arrays::Masked::ValidityVTable = vortex_array::arrays::Masked
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Masked::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::len(&self) -> usize
+pub fn vortex_array::arrays::Masked::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Masked::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::Masked::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::to_array(&self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Masked::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::arrays::Masked::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::valid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::Masked::id(&self) -> vortex_array::ArrayId
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::Masked::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
+pub fn vortex_array::arrays::Masked::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::vtable(&self) -> &dyn vortex_array::vtable::DynVTable
+pub fn vortex_array::arrays::Masked::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::with_children(&self, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Masked::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::Array for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Masked::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayAdapter<V>::all_invalid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Masked::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::all_valid(&self) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Masked::validate(&self, _data: &vortex_array::arrays::masked::MaskedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::append_to_builder(&self, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
+impl vortex_array::VTable for vortex_array::arrays::Primitive
 
-pub fn vortex_array::ArrayAdapter<V>::as_any(&self) -> &dyn core::any::Any
+pub type vortex_array::arrays::Primitive::ArrayData = vortex_array::arrays::primitive::PrimitiveData
 
-pub fn vortex_array::ArrayAdapter<V>::as_any_arc(self: alloc::sync::Arc<Self>) -> alloc::sync::Arc<(dyn core::any::Any + core::marker::Send + core::marker::Sync)>
+pub type vortex_array::arrays::Primitive::OperationsVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::ArrayAdapter<V>::dtype(&self) -> &vortex_array::dtype::DType
+pub type vortex_array::arrays::Primitive::ValidityVTable = vortex_array::arrays::Primitive
 
-pub fn vortex_array::ArrayAdapter<V>::encoding_id(&self) -> vortex_array::vtable::ArrayId
+pub fn vortex_array::arrays::Primitive::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::filter(&self, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Primitive::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayAdapter<V>::invalid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::Primitive::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ArrayAdapter<V>::is_invalid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Primitive::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayAdapter<V>::is_valid(&self, index: usize) -> vortex_error::VortexResult<bool>
+pub fn vortex_array::arrays::Primitive::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::len(&self) -> usize
+pub fn vortex_array::arrays::Primitive::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayAdapter<V>::scalar_at(&self, index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+pub fn vortex_array::arrays::Primitive::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::ArrayAdapter<V>::slice(&self, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Primitive::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::statistics(&self) -> vortex_array::stats::StatsSetRef<'_>
+pub fn vortex_array::arrays::Primitive::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ArrayAdapter<V>::take(&self, indices: vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Primitive::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::to_array(&self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Primitive::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::to_canonical(&self) -> vortex_error::VortexResult<vortex_array::Canonical>
+pub fn vortex_array::arrays::Primitive::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::valid_count(&self) -> vortex_error::VortexResult<usize>
+pub fn vortex_array::arrays::Primitive::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::validity(&self) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+pub fn vortex_array::arrays::Primitive::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayAdapter<V>::validity_mask(&self) -> vortex_error::VortexResult<vortex_mask::Mask>
+pub fn vortex_array::arrays::Primitive::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::vtable(&self) -> &dyn vortex_array::vtable::DynVTable
+pub fn vortex_array::arrays::Primitive::validate(&self, data: &vortex_array::arrays::primitive::PrimitiveData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::with_children(&self, children: alloc::vec::Vec<vortex_array::ArrayRef>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+impl vortex_array::VTable for vortex_array::arrays::Shared
 
-pub trait vortex_array::ArrayBufferVisitor
+pub type vortex_array::arrays::Shared::ArrayData = vortex_array::arrays::shared::SharedData
 
-pub fn vortex_array::ArrayBufferVisitor::visit_buffer_handle(&mut self, _name: &str, handle: &vortex_array::buffer::BufferHandle)
+pub type vortex_array::arrays::Shared::OperationsVTable = vortex_array::arrays::Shared
 
-pub trait vortex_array::ArrayChildVisitor
+pub type vortex_array::arrays::Shared::ValidityVTable = vortex_array::arrays::Shared
 
-pub fn vortex_array::ArrayChildVisitor::visit_child(&mut self, _name: &str, _array: &vortex_array::ArrayRef)
+pub fn vortex_array::arrays::Shared::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayChildVisitor::visit_patches(&mut self, patches: &vortex_array::patches::Patches)
+pub fn vortex_array::arrays::Shared::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayChildVisitor::visit_validity(&mut self, validity: &vortex_array::validity::Validity, len: usize)
+pub fn vortex_array::arrays::Shared::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub trait vortex_array::ArrayChildVisitorUnnamed
+pub fn vortex_array::arrays::Shared::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayChildVisitorUnnamed::visit_child(&mut self, array: &vortex_array::ArrayRef)
+pub fn vortex_array::arrays::Shared::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayChildVisitorUnnamed::visit_patches(&mut self, patches: &vortex_array::patches::Patches)
+pub fn vortex_array::arrays::Shared::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayChildVisitorUnnamed::visit_validity(&mut self, validity: &vortex_array::validity::Validity, len: usize)
+pub fn vortex_array::arrays::Shared::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub trait vortex_array::ArrayEq
+pub fn vortex_array::arrays::Shared::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayEq::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Shared::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::ArrayEq for (dyn vortex_array::Array + '_)
+pub fn vortex_array::arrays::Shared::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn (dyn vortex_array::Array + '_)::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Shared::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::ArrayEq for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Shared::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayRef::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Shared::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::ArrayEq for vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::Shared::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::buffer::BufferHandle::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Shared::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::ArrayEq for vortex_array::patches::Patches
+pub fn vortex_array::arrays::Shared::validate(&self, _data: &vortex_array::arrays::shared::SharedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::patches::Patches::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+impl vortex_array::VTable for vortex_array::arrays::Struct
 
-impl vortex_array::ArrayEq for vortex_array::validity::Validity
+pub type vortex_array::arrays::Struct::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::validity::Validity::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub type vortex_array::arrays::Struct::OperationsVTable = vortex_array::arrays::Struct
 
-impl vortex_array::ArrayEq for vortex_buffer::bit::buf::BitBuffer
+pub type vortex_array::arrays::Struct::ValidityVTable = vortex_array::arrays::Struct
 
-pub fn vortex_buffer::bit::buf::BitBuffer::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Struct::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::ArrayEq for vortex_mask::Mask
+pub fn vortex_array::arrays::Struct::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_mask::Mask::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Struct::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl<T: core::cmp::PartialEq> vortex_array::ArrayEq for vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::arrays::Struct::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_buffer::buffer::Buffer<T>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Struct::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<T: vortex_array::ArrayEq> vortex_array::ArrayEq for core::option::Option<T>
+pub fn vortex_array::arrays::Struct::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn core::option::Option<T>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Struct::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayEq for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::Struct::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::array_eq(&self, other: &Self, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::Struct::id(&self) -> vortex_array::ArrayId
 
-pub trait vortex_array::ArrayHash
+pub fn vortex_array::arrays::Struct::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayHash::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::Struct::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::ArrayHash for (dyn vortex_array::Array + '_)
+pub fn vortex_array::arrays::Struct::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn (dyn vortex_array::Array + '_)::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::Struct::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::ArrayHash for vortex_array::ArrayRef
+pub fn vortex_array::arrays::Struct::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayRef::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::Struct::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::ArrayHash for vortex_array::buffer::BufferHandle
+pub fn vortex_array::arrays::Struct::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::buffer::BufferHandle::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+impl vortex_array::VTable for vortex_array::arrays::VarBin
 
-impl vortex_array::ArrayHash for vortex_array::patches::Patches
+pub type vortex_array::arrays::VarBin::ArrayData = vortex_array::arrays::varbin::VarBinData
 
-pub fn vortex_array::patches::Patches::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub type vortex_array::arrays::VarBin::OperationsVTable = vortex_array::arrays::VarBin
 
-impl vortex_array::ArrayHash for vortex_array::validity::Validity
+pub type vortex_array::arrays::VarBin::ValidityVTable = vortex_array::arrays::VarBin
 
-pub fn vortex_array::validity::Validity::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::ArrayHash for vortex_buffer::bit::buf::BitBuffer
+pub fn vortex_array::arrays::VarBin::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_buffer::bit::buf::BitBuffer::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::ArrayHash for vortex_mask::Mask
+pub fn vortex_array::arrays::VarBin::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_mask::Mask::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<T: core::hash::Hash> vortex_array::ArrayHash for vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::arrays::VarBin::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_buffer::buffer::Buffer<T>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl<T: vortex_array::ArrayHash> vortex_array::ArrayHash for core::option::Option<T>
+pub fn vortex_array::arrays::VarBin::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn core::option::Option<T>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::id(&self) -> vortex_array::ArrayId
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayHash for vortex_array::ArrayAdapter<V>
+pub fn vortex_array::arrays::VarBin::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::array_hash<H: core::hash::Hasher>(&self, state: &mut H, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::VarBin::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub trait vortex_array::ArrayVisitor
+pub fn vortex_array::arrays::VarBin::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayVisitor::buffer_handles(&self) -> alloc::vec::Vec<vortex_array::buffer::BufferHandle>
+pub fn vortex_array::arrays::VarBin::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayVisitor::buffer_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::VarBin::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayVisitor::buffers(&self) -> alloc::vec::Vec<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::VarBin::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayVisitor::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBin::validate(&self, _data: &vortex_array::arrays::varbin::VarBinData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayVisitor::children_names(&self) -> alloc::vec::Vec<alloc::string::String>
+impl vortex_array::VTable for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::ArrayVisitor::is_host(&self) -> bool
+pub type vortex_array::arrays::VarBinView::ArrayData = vortex_array::arrays::varbinview::VarBinViewData
 
-pub fn vortex_array::ArrayVisitor::metadata(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub type vortex_array::arrays::VarBinView::OperationsVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::ArrayVisitor::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_array::arrays::VarBinView::ValidityVTable = vortex_array::arrays::VarBinView
 
-pub fn vortex_array::ArrayVisitor::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
+pub fn vortex_array::arrays::VarBinView::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayVisitor::named_children(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::ArrayRef)>
+pub fn vortex_array::arrays::VarBinView::buffer(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayVisitor::nbuffers(&self) -> usize
+pub fn vortex_array::arrays::VarBinView::buffer_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ArrayVisitor::nchildren(&self) -> usize
+pub fn vortex_array::arrays::VarBinView::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayVisitor::nth_child(&self, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBinView::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::ArrayVisitor for alloc::sync::Arc<dyn vortex_array::Array>
+pub fn vortex_array::arrays::VarBinView::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::buffer_handles(&self) -> alloc::vec::Vec<vortex_array::buffer::BufferHandle>
+pub fn vortex_array::arrays::VarBinView::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::buffer_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::VarBinView::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::buffers(&self) -> alloc::vec::Vec<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::VarBinView::id(&self) -> vortex_array::ArrayId
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::VarBinView::nbuffers(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::children_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::VarBinView::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::is_host(&self) -> bool
+pub fn vortex_array::arrays::VarBinView::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::metadata(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::VarBinView::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::VarBinView::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
+pub fn vortex_array::arrays::VarBinView::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::named_children(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::ArrayRef)>
+pub fn vortex_array::arrays::VarBinView::validate(&self, data: &vortex_array::arrays::varbinview::VarBinViewData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::nbuffers(&self) -> usize
+impl vortex_array::VTable for vortex_array::arrays::Variant
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::nchildren(&self) -> usize
+pub type vortex_array::arrays::Variant::ArrayData = vortex_array::EmptyArrayData
 
-pub fn alloc::sync::Arc<dyn vortex_array::Array>::nth_child(&self, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub type vortex_array::arrays::Variant::OperationsVTable = vortex_array::arrays::Variant
 
-impl<V: vortex_array::vtable::VTable> vortex_array::ArrayVisitor for vortex_array::ArrayAdapter<V>
+pub type vortex_array::arrays::Variant::ValidityVTable = vortex_array::arrays::Variant
 
-pub fn vortex_array::ArrayAdapter<V>::buffer_handles(&self) -> alloc::vec::Vec<vortex_array::buffer::BufferHandle>
+pub fn vortex_array::arrays::Variant::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::ArrayAdapter<V>::buffer_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::Variant::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::ArrayAdapter<V>::buffers(&self) -> alloc::vec::Vec<vortex_buffer::ByteBuffer>
+pub fn vortex_array::arrays::Variant::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-pub fn vortex_array::ArrayAdapter<V>::children(&self) -> alloc::vec::Vec<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Variant::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::ArrayAdapter<V>::children_names(&self) -> alloc::vec::Vec<alloc::string::String>
+pub fn vortex_array::arrays::Variant::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayAdapter<V>::is_host(&self) -> bool
+pub fn vortex_array::arrays::Variant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::ArrayAdapter<V>::metadata(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+pub fn vortex_array::arrays::Variant::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub fn vortex_array::ArrayAdapter<V>::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_array::arrays::Variant::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
+pub fn vortex_array::arrays::Variant::id(&self) -> vortex_array::ArrayId
 
-pub fn vortex_array::ArrayAdapter<V>::named_children(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::ArrayRef)>
+pub fn vortex_array::arrays::Variant::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::nbuffers(&self) -> usize
+pub fn vortex_array::arrays::Variant::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::ArrayAdapter<V>::nchildren(&self) -> usize
+pub fn vortex_array::arrays::Variant::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ArrayAdapter<V>::nth_child(&self, idx: usize) -> core::option::Option<vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Variant::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::ArrayVisitorExt: vortex_array::Array
+pub fn vortex_array::arrays::Variant::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::ArrayVisitorExt::depth_first_traversal(&self) -> impl core::iter::traits::iterator::Iterator<Item = vortex_array::ArrayRef>
+pub fn vortex_array::arrays::Variant::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::ArrayVisitorExt::nbuffers_recursive(&self) -> usize
+pub fn vortex_array::arrays::Variant::validate(&self, _data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-impl<A: vortex_array::Array + ?core::marker::Sized> vortex_array::ArrayVisitorExt for A
+impl vortex_array::VTable for vortex_array::arrays::dict::Dict
 
-pub trait vortex_array::DeserializeMetadata where Self: core::marker::Sized
+pub type vortex_array::arrays::dict::Dict::ArrayData = vortex_array::arrays::dict::DictData
 
-pub type vortex_array::DeserializeMetadata::Output
+pub type vortex_array::arrays::dict::Dict::OperationsVTable = vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::DeserializeMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub type vortex_array::arrays::dict::Dict::ValidityVTable = vortex_array::arrays::dict::Dict
 
-impl vortex_array::DeserializeMetadata for vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::dict::Dict::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-pub type vortex_array::EmptyMetadata::Output = vortex_array::EmptyMetadata
+pub fn vortex_array::arrays::dict::Dict::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::EmptyMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub fn vortex_array::arrays::dict::Dict::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::DeserializeMetadata for vortex_array::RawMetadata
+pub fn vortex_array::arrays::dict::Dict::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub type vortex_array::RawMetadata::Output = alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::dict::Dict::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-pub fn vortex_array::RawMetadata::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub fn vortex_array::arrays::dict::Dict::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-impl<M> vortex_array::DeserializeMetadata for vortex_array::ProstMetadata<M> where M: core::fmt::Debug + prost::message::Message + core::default::Default
+pub fn vortex_array::arrays::dict::Dict::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-pub type vortex_array::ProstMetadata<M>::Output = M
+pub fn vortex_array::arrays::dict::Dict::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::ProstMetadata<M>::deserialize(metadata: &[u8]) -> vortex_error::VortexResult<Self::Output>
+pub fn vortex_array::arrays::dict::Dict::id(&self) -> vortex_array::ArrayId
 
-pub trait vortex_array::DynArrayEq: vortex_array::hash::private::SealedEq
+pub fn vortex_array::arrays::dict::Dict::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::DynArrayEq::dyn_array_eq(&self, other: &dyn core::any::Any, precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::dict::Dict::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl<T: vortex_array::ArrayEq + 'static> vortex_array::DynArrayEq for T
+pub fn vortex_array::arrays::dict::Dict::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn T::dyn_array_eq(&self, other: &(dyn core::any::Any + 'static), precision: vortex_array::Precision) -> bool
+pub fn vortex_array::arrays::dict::Dict::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub trait vortex_array::DynArrayHash: vortex_array::hash::private::SealedHash
+pub fn vortex_array::arrays::dict::Dict::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::DynArrayHash::dyn_array_hash(&self, state: &mut dyn core::hash::Hasher, precision: vortex_array::Precision)
+pub fn vortex_array::arrays::dict::Dict::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl<T: vortex_array::ArrayHash + ?core::marker::Sized> vortex_array::DynArrayHash for T
+pub fn vortex_array::arrays::dict::Dict::validate(&self, _data: &vortex_array::arrays::dict::DictData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn T::dyn_array_hash(&self, state: &mut dyn core::hash::Hasher, precision: vortex_array::Precision)
+impl vortex_array::VTable for vortex_array::arrays::null::Null
 
-pub trait vortex_array::Executable: core::marker::Sized
+pub type vortex_array::arrays::null::Null::ArrayData = vortex_array::EmptyArrayData
 
-pub fn vortex_array::Executable::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::null::Null::OperationsVTable = vortex_array::arrays::null::Null
 
-impl vortex_array::Executable for vortex_array::ArrayRef
+pub type vortex_array::arrays::null::Null::ValidityVTable = vortex_array::arrays::null::Null
 
-pub fn vortex_array::ArrayRef::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::Executable for vortex_array::Canonical
+pub fn vortex_array::arrays::null::Null::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::Canonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::Executable for vortex_array::CanonicalValidity
+pub fn vortex_array::arrays::null::Null::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::CanonicalValidity::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::Executable for vortex_array::Columnar
+pub fn vortex_array::arrays::null::Null::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::Columnar::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::Executable for vortex_array::RecursiveCanonical
+pub fn vortex_array::arrays::null::Null::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::RecursiveCanonical::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::Executable for vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::null::Null::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::BoolArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::Executable for vortex_array::arrays::DecimalArray
+pub fn vortex_array::arrays::null::Null::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::Executable for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::null::Null::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::ExtensionArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::null::Null::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::Executable for vortex_array::arrays::FixedSizeListArray
+pub fn vortex_array::arrays::null::Null::validate(&self, _data: &vortex_array::EmptyArrayData, dtype: &vortex_array::dtype::DType, _len: usize, _slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::FixedSizeListArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+impl vortex_array::VTable for vortex_array::arrays::patched::Patched
 
-impl vortex_array::Executable for vortex_array::arrays::ListViewArray
+pub type vortex_array::arrays::patched::Patched::ArrayData = vortex_array::arrays::patched::PatchedData
 
-pub fn vortex_array::arrays::ListViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub type vortex_array::arrays::patched::Patched::OperationsVTable = vortex_array::arrays::patched::Patched
 
-impl vortex_array::Executable for vortex_array::arrays::NullArray
+pub type vortex_array::arrays::patched::Patched::ValidityVTable = vortex_array::ValidityVTableFromChild
 
-pub fn vortex_array::arrays::NullArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::Executable for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::patched::Patched::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::PrimitiveArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::buffer_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::Executable for vortex_array::arrays::StructArray
+pub fn vortex_array::arrays::patched::Patched::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::Executable for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::patched::Patched::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::VarBinViewArray::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::Executable for vortex_mask::Mask
+pub fn vortex_array::arrays::patched::Patched::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_mask::Mask::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::id(&self) -> vortex_array::ArrayId
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::Executable for vortex_buffer::buffer::Buffer<T>
+pub fn vortex_array::arrays::patched::Patched::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_buffer::buffer::Buffer<T>::execute(array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<Self>
+pub fn vortex_array::arrays::patched::Patched::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub trait vortex_array::IntoArray
+pub fn vortex_array::arrays::patched::Patched::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::IntoArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::Patched::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::IntoArray for &vortex_mask::MaskValues
+pub fn vortex_array::arrays::patched::Patched::serialize(array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn &vortex_mask::MaskValues::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::patched::Patched::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for arrow_buffer::buffer::boolean::BooleanBuffer
+pub fn vortex_array::arrays::patched::Patched::validate(&self, data: &vortex_array::arrays::patched::PatchedData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn arrow_buffer::buffer::boolean::BooleanBuffer::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::VTable for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::IntoArray for arrow_buffer::buffer::immutable::Buffer
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ArrayData = vortex_array::arrays::scalar_fn::ScalarFnData
 
-pub fn arrow_buffer::buffer::immutable::Buffer::into_array(self) -> vortex_array::ArrayRef
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::OperationsVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-impl vortex_array::IntoArray for vortex_array::ArrayRef
+pub type vortex_array::arrays::scalar_fn::ScalarFnVTable::ValidityVTable = vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn vortex_array::ArrayRef::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::IntoArray for vortex_array::Canonical
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::Canonical::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::IntoArray for vortex_array::Columnar
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::Columnar::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::BoolArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: vortex_array::Array<Self>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::IntoArray for vortex_array::arrays::ChunkedArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ChunkedArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::IntoArray for vortex_array::arrays::ConstantArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::ConstantArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::IntoArray for vortex_array::arrays::DecimalArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::DecimalArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::IntoArray for vortex_array::arrays::DictArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::DictArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::slot_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validate(&self, data: &vortex_array::arrays::scalar_fn::ScalarFnData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::ExtensionArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::VTable for vortex_array::arrays::slice::Slice
 
-impl vortex_array::IntoArray for vortex_array::arrays::FilterArray
+pub type vortex_array::arrays::slice::Slice::ArrayData = vortex_array::arrays::slice::SliceData
 
-pub fn vortex_array::arrays::FilterArray::into_array(self) -> vortex_array::ArrayRef
+pub type vortex_array::arrays::slice::Slice::OperationsVTable = vortex_array::arrays::slice::Slice
 
-impl vortex_array::IntoArray for vortex_array::arrays::FixedSizeListArray
+pub type vortex_array::arrays::slice::Slice::ValidityVTable = vortex_array::arrays::slice::Slice
 
-pub fn vortex_array::arrays::FixedSizeListArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::append_to_builder(array: vortex_array::ArrayView<'_, Self>, builder: &mut dyn vortex_array::builders::ArrayBuilder, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<()>
 
-impl vortex_array::IntoArray for vortex_array::arrays::ListArray
+pub fn vortex_array::arrays::slice::Slice::buffer(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> vortex_array::buffer::BufferHandle
 
-pub fn vortex_array::arrays::ListArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::buffer_name(_array: vortex_array::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
 
-impl vortex_array::IntoArray for vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::slice::Slice::child(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::ListViewArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::child_name(array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for vortex_array::arrays::MaskedArray
+pub fn vortex_array::arrays::slice::Slice::deserialize(&self, _dtype: &vortex_array::dtype::DType, _len: usize, _metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], _children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayParts<Self>>
 
-pub fn vortex_array::arrays::MaskedArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::execute(array: vortex_array::Array<Self>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
-impl vortex_array::IntoArray for vortex_array::arrays::NullArray
+pub fn vortex_array::arrays::slice::Slice::execute_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::NullArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::id(&self) -> vortex_array::ArrayId
 
-impl vortex_array::IntoArray for vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::slice::Slice::nbuffers(_array: vortex_array::ArrayView<'_, Self>) -> usize
 
-pub fn vortex_array::arrays::PrimitiveArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::nchildren(array: vortex_array::ArrayView<'_, Self>) -> usize
 
-impl vortex_array::IntoArray for vortex_array::arrays::ScalarFnArray
+pub fn vortex_array::arrays::slice::Slice::reduce(array: vortex_array::ArrayView<'_, Self>) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::arrays::ScalarFnArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::reduce_parent(array: vortex_array::ArrayView<'_, Self>, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-impl vortex_array::IntoArray for vortex_array::arrays::SharedArray
+pub fn vortex_array::arrays::slice::Slice::serialize(_array: vortex_array::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_array::arrays::SharedArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::slice::Slice::slot_name(_array: vortex_array::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
 
-impl vortex_array::IntoArray for vortex_array::arrays::SliceArray
+pub fn vortex_array::arrays::slice::Slice::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::ArrayRef>]) -> vortex_error::VortexResult<()>
 
-pub fn vortex_array::arrays::SliceArray::into_array(self) -> vortex_array::ArrayRef
+pub trait vortex_array::ValidityChild<V: vortex_array::VTable>
 
-impl vortex_array::IntoArray for vortex_array::arrays::StructArray
+pub fn vortex_array::ValidityChild::validity_child(array: vortex_array::ArrayView<'_, V>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::StructArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::ValidityChild<vortex_array::arrays::Extension> for vortex_array::arrays::Extension
 
-impl vortex_array::IntoArray for vortex_array::arrays::TemporalArray
+pub fn vortex_array::arrays::Extension::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::Extension>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::TemporalArray::into_array(self) -> vortex_array::ArrayRef
+impl vortex_array::ValidityChild<vortex_array::arrays::patched::Patched> for vortex_array::arrays::patched::Patched
 
-impl vortex_array::IntoArray for vortex_array::arrays::VarBinArray
+pub fn vortex_array::arrays::patched::Patched::validity_child(array: vortex_array::ArrayView<'_, vortex_array::arrays::patched::Patched>) -> vortex_array::ArrayRef
 
-pub fn vortex_array::arrays::VarBinArray::into_array(self) -> vortex_array::ArrayRef
+pub trait vortex_array::ValidityChildSliceHelper
 
-impl vortex_array::IntoArray for vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::ValidityChildSliceHelper::sliced_child_array(&self) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::arrays::VarBinViewArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::ValidityChildSliceHelper::unsliced_child_and_slice(&self) -> (&vortex_array::ArrayRef, usize, usize)
 
-impl vortex_array::IntoArray for vortex_array::arrow::ArrowArray
+pub trait vortex_array::ValidityVTable<V: vortex_array::VTable>
 
-pub fn vortex_array::arrow::ArrowArray::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::ValidityVTable::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::IntoArray for vortex_buffer::bit::buf::BitBuffer
+impl vortex_array::ValidityVTable<vortex_array::arrays::Bool> for vortex_array::arrays::Bool
 
-pub fn vortex_buffer::bit::buf::BitBuffer::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Bool::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Bool>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::IntoArray for vortex_buffer::bit::buf_mut::BitBufferMut
+impl vortex_array::ValidityVTable<vortex_array::arrays::Chunked> for vortex_array::arrays::Chunked
 
-pub fn vortex_buffer::bit::buf_mut::BitBufferMut::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Chunked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Chunked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::IntoArray for vortex_mask::Mask
+impl vortex_array::ValidityVTable<vortex_array::arrays::Constant> for vortex_array::arrays::Constant
 
-pub fn vortex_mask::Mask::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Constant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Constant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<O> vortex_array::IntoArray for arrow_buffer::buffer::offset::OffsetBuffer<O> where O: vortex_array::dtype::IntegerPType + arrow_array::array::list_array::OffsetSizeTrait
+impl vortex_array::ValidityVTable<vortex_array::arrays::Decimal> for vortex_array::arrays::Decimal
 
-pub fn arrow_buffer::buffer::offset::OffsetBuffer<O>::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Decimal::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Decimal>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::IntoArray for vortex_buffer::buffer::Buffer<T>
+impl vortex_array::ValidityVTable<vortex_array::arrays::Filter> for vortex_array::arrays::Filter
 
-pub fn vortex_buffer::buffer::Buffer<T>::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::Filter::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Filter>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<T: vortex_array::dtype::NativePType> vortex_array::IntoArray for vortex_buffer::buffer_mut::BufferMut<T>
+impl vortex_array::ValidityVTable<vortex_array::arrays::FixedSizeList> for vortex_array::arrays::FixedSizeList
 
-pub fn vortex_buffer::buffer_mut::BufferMut<T>::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::FixedSizeList::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::FixedSizeList>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<T> vortex_array::IntoArray for arrow_buffer::buffer::scalar::ScalarBuffer<T> where T: arrow_buffer::native::ArrowNativeType + vortex_array::dtype::NativePType
+impl vortex_array::ValidityVTable<vortex_array::arrays::List> for vortex_array::arrays::List
 
-pub fn arrow_buffer::buffer::scalar::ScalarBuffer<T>::into_array(self) -> vortex_array::ArrayRef
+pub fn vortex_array::arrays::List::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::List>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub trait vortex_array::SerializeMetadata
+impl vortex_array::ValidityVTable<vortex_array::arrays::ListView> for vortex_array::arrays::ListView
 
-pub fn vortex_array::SerializeMetadata::serialize(self) -> alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::ListView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::ListView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::SerializeMetadata for vortex_array::EmptyMetadata
+impl vortex_array::ValidityVTable<vortex_array::arrays::Masked> for vortex_array::arrays::Masked
 
-pub fn vortex_array::EmptyMetadata::serialize(self) -> alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::Masked::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Masked>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl vortex_array::SerializeMetadata for vortex_array::RawMetadata
+impl vortex_array::ValidityVTable<vortex_array::arrays::Primitive> for vortex_array::arrays::Primitive
 
-pub fn vortex_array::RawMetadata::serialize(self) -> alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::Primitive::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Primitive>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<M> vortex_array::SerializeMetadata for vortex_array::ProstMetadata<M> where M: prost::message::Message
+impl vortex_array::ValidityVTable<vortex_array::arrays::Shared> for vortex_array::arrays::Shared
 
-pub fn vortex_array::ProstMetadata<M>::serialize(self) -> alloc::vec::Vec<u8>
+pub fn vortex_array::arrays::Shared::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Shared>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub trait vortex_array::ToCanonical
+impl vortex_array::ValidityVTable<vortex_array::arrays::Struct> for vortex_array::arrays::Struct
 
-pub fn vortex_array::ToCanonical::to_bool(&self) -> vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::Struct::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Struct>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ToCanonical::to_decimal(&self) -> vortex_array::arrays::DecimalArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBin> for vortex_array::arrays::VarBin
 
-pub fn vortex_array::ToCanonical::to_extension(&self) -> vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::VarBin::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBin>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ToCanonical::to_fixed_size_list(&self) -> vortex_array::arrays::FixedSizeListArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::VarBinView> for vortex_array::arrays::VarBinView
 
-pub fn vortex_array::ToCanonical::to_listview(&self) -> vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::VarBinView::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::VarBinView>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ToCanonical::to_null(&self) -> vortex_array::arrays::NullArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::Variant> for vortex_array::arrays::Variant
 
-pub fn vortex_array::ToCanonical::to_primitive(&self) -> vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::arrays::Variant::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::Variant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn vortex_array::ToCanonical::to_struct(&self) -> vortex_array::arrays::StructArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::dict::Dict> for vortex_array::arrays::dict::Dict
 
-pub fn vortex_array::ToCanonical::to_varbinview(&self) -> vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::arrays::dict::Dict::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::dict::Dict>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-impl<A: vortex_array::Array + ?core::marker::Sized> vortex_array::ToCanonical for A
+impl vortex_array::ValidityVTable<vortex_array::arrays::null::Null> for vortex_array::arrays::null::Null
 
-pub fn A::to_bool(&self) -> vortex_array::arrays::BoolArray
+pub fn vortex_array::arrays::null::Null::validity(_array: vortex_array::ArrayView<'_, vortex_array::arrays::null::Null>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn A::to_decimal(&self) -> vortex_array::arrays::DecimalArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::scalar_fn::ScalarFnVTable> for vortex_array::arrays::scalar_fn::ScalarFnVTable
 
-pub fn A::to_extension(&self) -> vortex_array::arrays::ExtensionArray
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::scalar_fn::ScalarFnVTable>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn A::to_fixed_size_list(&self) -> vortex_array::arrays::FixedSizeListArray
+impl vortex_array::ValidityVTable<vortex_array::arrays::slice::Slice> for vortex_array::arrays::slice::Slice
 
-pub fn A::to_listview(&self) -> vortex_array::arrays::ListViewArray
+pub fn vortex_array::arrays::slice::Slice::validity(array: vortex_array::ArrayView<'_, vortex_array::arrays::slice::Slice>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn A::to_null(&self) -> vortex_array::arrays::NullArray
+impl<V: vortex_array::VTable> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChildSliceHelper where <V as vortex_array::VTable>::ArrayData: vortex_array::ValidityChildSliceHelper
 
-pub fn A::to_primitive(&self) -> vortex_array::arrays::PrimitiveArray
+pub fn vortex_array::ValidityVTableFromChildSliceHelper::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
-pub fn A::to_struct(&self) -> vortex_array::arrays::StructArray
+impl<V> vortex_array::ValidityVTable<V> for vortex_array::ValidityVTableFromChild where V: vortex_array::ValidityChild<V> + vortex_array::VTable
 
-pub fn A::to_varbinview(&self) -> vortex_array::arrays::VarBinViewArray
+pub fn vortex_array::ValidityVTableFromChild::validity(array: vortex_array::ArrayView<'_, V>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
 
 pub trait vortex_array::VortexSessionExecute
 
@@ -18244,6 +25208,24 @@ impl vortex_array::VortexSessionExecute for vortex_session::VortexSession
 
 pub fn vortex_session::VortexSession::create_execution_ctx(&self) -> vortex_array::ExecutionCtx
 
-pub type vortex_array::ArrayContext = vortex_session::registry::Context<&'static dyn vortex_array::vtable::DynVTable>
+pub fn vortex_array::child_to_validity(child: &core::option::Option<vortex_array::ArrayRef>, nullability: vortex_array::dtype::Nullability) -> vortex_array::validity::Validity
+
+pub fn vortex_array::patches_child(patches: &vortex_array::patches::Patches, idx: usize) -> vortex_array::ArrayRef
+
+pub fn vortex_array::patches_child_name(idx: usize) -> &'static str
+
+pub fn vortex_array::patches_nchildren(patches: &vortex_array::patches::Patches) -> usize
+
+pub fn vortex_array::validity_nchildren(validity: &vortex_array::validity::Validity) -> usize
+
+pub fn vortex_array::validity_to_child(validity: &vortex_array::validity::Validity, len: usize) -> core::option::Option<vortex_array::ArrayRef>
+
+pub type vortex_array::ArrayContext = vortex_session::registry::Context<vortex_array::ArrayPluginRef>
+
+pub type vortex_array::ArrayId = arcref::ArcRef<str>
+
+pub type vortex_array::ArrayPluginRef = alloc::sync::Arc<dyn vortex_array::ArrayPlugin>
+
+pub type vortex_array::ArrayPluginRef = alloc::sync::Arc<dyn vortex_array::ArrayPlugin>
 
-pub type vortex_array::ArrayRef = alloc::sync::Arc<dyn vortex_array::Array>
+pub type vortex_array::DonePredicate = fn(&vortex_array::ArrayRef) -> bool
diff --git a/vortex-array/src/accessor.rs b/vortex-array/src/accessor.rs
index d0bcb1243c4..6460f879cb3 100644
--- a/vortex-array/src/accessor.rs
+++ b/vortex-array/src/accessor.rs
@@ -5,8 +5,8 @@
 pub trait ArrayAccessor<Item: ?Sized> {
     /// Iterate over each element of the array, in-order.
     ///
-    /// The function `f` will be passed an [`Iterator`], it can call [`next`][Iterator::next] on the
-    /// iterator [`len`][crate::Array::len] times. Iterator elements are `Option` types,
+    /// The function `f` will be passed an [`Iterator`], it can call [`Iterator::next`] on the
+    /// iterator `len` times. Iterator elements are `Option` types,
     /// regardless of the nullability of the underlying array data.
     fn with_iterator<F, R>(&self, f: F) -> R
     where
diff --git a/vortex-array/src/aggregate_fn/accumulator.rs b/vortex-array/src/aggregate_fn/accumulator.rs
new file mode 100644
index 00000000000..00c80b38221
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/accumulator.rs
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+use crate::AnyCanonical;
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFn;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::session::AggregateFnSessionExt;
+use crate::dtype::DType;
+use crate::executor::MAX_ITERATIONS;
+use crate::scalar::Scalar;
+
+/// Reference-counted type-erased accumulator.
+pub type AccumulatorRef = Box<dyn DynAccumulator>;
+
+/// An accumulator used for computing aggregates over an entire stream of arrays.
+pub struct Accumulator<V: AggregateFnVTable> {
+    /// The vtable of the aggregate function.
+    vtable: V,
+    /// Type-erased aggregate function used for kernel dispatch.
+    aggregate_fn: AggregateFnRef,
+    /// The DType of the input.
+    dtype: DType,
+    /// The DType of the aggregate.
+    return_dtype: DType,
+    /// The DType of the accumulator state.
+    partial_dtype: DType,
+    /// The partial state of the accumulator, updated after each accumulate/merge call.
+    partial: V::Partial,
+}
+
+impl<V: AggregateFnVTable> Accumulator<V> {
+    pub fn try_new(vtable: V, options: V::Options, dtype: DType) -> VortexResult<Self> {
+        let return_dtype = vtable.return_dtype(&options, &dtype).ok_or_else(|| {
+            vortex_err!(
+                "Aggregate function {} cannot be applied to dtype {}",
+                vtable.id(),
+                dtype
+            )
+        })?;
+        let partial_dtype = vtable.partial_dtype(&options, &dtype).ok_or_else(|| {
+            vortex_err!(
+                "Aggregate function {} cannot be applied to dtype {}",
+                vtable.id(),
+                dtype
+            )
+        })?;
+        let partial = vtable.empty_partial(&options, &dtype)?;
+        let aggregate_fn = AggregateFn::new(vtable.clone(), options).erased();
+
+        Ok(Self {
+            vtable,
+            aggregate_fn,
+            dtype,
+            return_dtype,
+            partial_dtype,
+            partial,
+        })
+    }
+}
+
+/// A trait object for type-erased accumulators, used for dynamic dispatch when the aggregate
+/// function is not known at compile time.
+pub trait DynAccumulator: 'static + Send {
+    /// Accumulate a new array into the accumulator's state.
+    fn accumulate(&mut self, batch: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<()>;
+
+    /// Whether the accumulator's result is fully determined.
+    fn is_saturated(&self) -> bool;
+
+    /// Flush the accumulation state and return the partial aggregate result as a scalar.
+    ///
+    /// Resets the accumulator state back to the initial state.
+    fn flush(&mut self) -> VortexResult<Scalar>;
+
+    /// Finish the accumulation and return the final aggregate result as a scalar.
+    ///
+    /// Resets the accumulator state back to the initial state.
+    fn finish(&mut self) -> VortexResult<Scalar>;
+}
+
+impl<V: AggregateFnVTable> DynAccumulator for Accumulator<V> {
+    fn accumulate(&mut self, batch: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<()> {
+        if self.is_saturated() {
+            return Ok(());
+        }
+
+        vortex_ensure!(
+            batch.dtype() == &self.dtype,
+            "Input DType mismatch: expected {}, got {}",
+            self.dtype,
+            batch.dtype()
+        );
+
+        // Allow the vtable to short-circuit on the raw array before decompression.
+        if self.vtable.try_accumulate(&mut self.partial, batch, ctx)? {
+            return Ok(());
+        }
+
+        let session = ctx.session().clone();
+        let kernels = &session.aggregate_fns().kernels;
+
+        let mut batch = batch.clone();
+        for _ in 0..*MAX_ITERATIONS {
+            if batch.is::<AnyCanonical>() {
+                break;
+            }
+
+            let kernels_r = kernels.read();
+            let batch_id = batch.encoding_id();
+            if let Some(result) = kernels_r
+                .get(&(batch_id.clone(), Some(self.aggregate_fn.id())))
+                .or_else(|| kernels_r.get(&(batch_id, None)))
+                .and_then(|kernel| {
+                    kernel
+                        .aggregate(&self.aggregate_fn, &batch, ctx)
+                        .transpose()
+                })
+                .transpose()?
+            {
+                vortex_ensure!(
+                    result.dtype() == &self.partial_dtype,
+                    "Aggregate kernel returned {}, expected {}",
+                    result.dtype(),
+                    self.partial_dtype,
+                );
+                self.vtable.combine_partials(&mut self.partial, result)?;
+                return Ok(());
+            }
+
+            // Execute one step and try again
+            batch = batch.execute(ctx)?;
+        }
+
+        // Otherwise, execute the batch until it is columnar and accumulate it into the state.
+        let columnar = batch.execute::<Columnar>(ctx)?;
+
+        self.vtable.accumulate(&mut self.partial, &columnar, ctx)
+    }
+
+    fn is_saturated(&self) -> bool {
+        self.vtable.is_saturated(&self.partial)
+    }
+
+    fn flush(&mut self) -> VortexResult<Scalar> {
+        let partial = self.vtable.to_scalar(&self.partial)?;
+        self.vtable.reset(&mut self.partial);
+
+        #[cfg(debug_assertions)]
+        {
+            vortex_ensure!(
+                partial.dtype() == &self.partial_dtype,
+                "Aggregate kernel returned incorrect DType on flush: expected {}, got {}",
+                self.partial_dtype,
+                partial.dtype(),
+            );
+        }
+
+        Ok(partial)
+    }
+
+    fn finish(&mut self) -> VortexResult<Scalar> {
+        let result = self.vtable.finalize_scalar(&self.partial)?;
+        self.vtable.reset(&mut self.partial);
+
+        vortex_ensure!(
+            result.dtype() == &self.return_dtype,
+            "Aggregate kernel returned incorrect DType on finalize: expected {}, got {}",
+            self.return_dtype,
+            result.dtype(),
+        );
+
+        Ok(result)
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/accumulator_grouped.rs b/vortex-array/src/aggregate_fn/accumulator_grouped.rs
new file mode 100644
index 00000000000..24f8f0157ec
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/accumulator_grouped.rs
@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use arrow_buffer::ArrowNativeType;
+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_error::vortex_panic;
+use vortex_mask::Mask;
+
+use crate::AnyCanonical;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFn;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::session::AggregateFnSessionExt;
+use crate::arrays::ChunkedArray;
+use crate::arrays::FixedSizeListArray;
+use crate::arrays::ListViewArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::builders::builder_with_capacity;
+use crate::builtins::ArrayBuiltins;
+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>;
+
+/// An accumulator used for computing grouped aggregates.
+///
+/// Note that the groups must be processed in order, and the accumulator does not support random
+/// access to groups.
+pub struct GroupedAccumulator<V: AggregateFnVTable> {
+    /// The vtable of the aggregate function.
+    vtable: V,
+    /// The options of the aggregate function.
+    options: V::Options,
+    /// Type-erased aggregate function used for kernel dispatch.
+    aggregate_fn: AggregateFnRef,
+    /// The DType of the input.
+    dtype: DType,
+    /// The DType of the aggregate.
+    return_dtype: DType,
+    /// The DType of the partial accumulator state.
+    partial_dtype: DType,
+    /// The accumulated state for prior batches of groups.
+    partials: Vec<ArrayRef>,
+}
+
+impl<V: AggregateFnVTable> GroupedAccumulator<V> {
+    pub fn try_new(vtable: V, options: V::Options, dtype: DType) -> VortexResult<Self> {
+        let aggregate_fn = AggregateFn::new(vtable.clone(), options.clone()).erased();
+        let return_dtype = vtable.return_dtype(&options, &dtype).ok_or_else(|| {
+            vortex_err!(
+                "Aggregate function {} cannot be applied to dtype {}",
+                vtable.id(),
+                dtype
+            )
+        })?;
+        let partial_dtype = vtable.partial_dtype(&options, &dtype).ok_or_else(|| {
+            vortex_err!(
+                "Aggregate function {} cannot be applied to dtype {}",
+                vtable.id(),
+                dtype
+            )
+        })?;
+
+        Ok(Self {
+            vtable,
+            options,
+            aggregate_fn,
+            dtype,
+            return_dtype,
+            partial_dtype,
+            partials: vec![],
+        })
+    }
+}
+
+/// A trait object for type-erased grouped accumulators, used for dynamic dispatch when the aggregate
+/// function is not known at compile time.
+pub trait DynGroupedAccumulator: 'static + Send {
+    /// Accumulate a list of groups into the accumulator.
+    fn accumulate_list(&mut self, groups: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<()>;
+
+    /// Finish the accumulation and return the partial aggregate results for all groups.
+    /// Resets the accumulator state for the next round of accumulation.
+    fn flush(&mut self) -> VortexResult<ArrayRef>;
+
+    /// Finish the accumulation and return the final aggregate results for all groups.
+    /// Resets the accumulator state for the next round of accumulation.
+    fn finish(&mut self) -> VortexResult<ArrayRef>;
+}
+
+impl<V: AggregateFnVTable> DynGroupedAccumulator for GroupedAccumulator<V> {
+    fn accumulate_list(&mut self, groups: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<()> {
+        let elements_dtype = match groups.dtype() {
+            DType::List(elem, _) => elem,
+            DType::FixedSizeList(elem, ..) => elem,
+            _ => vortex_bail!(
+                "Input DType mismatch: expected List or FixedSizeList, got {}",
+                groups.dtype()
+            ),
+        };
+        vortex_ensure!(
+            elements_dtype.as_ref() == &self.dtype,
+            "Input DType mismatch: expected {}, got {}",
+            self.dtype,
+            elements_dtype
+        );
+
+        // We first execute the groups until it is a ListView or FixedSizeList, since we only
+        // dispatch the aggregate kernel over the elements of these arrays.
+        let canonical = match groups.clone().execute::<Columnar>(ctx)? {
+            Columnar::Canonical(c) => c,
+            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),
+            _ => vortex_panic!("We checked the DType above, so this should never happen"),
+        }
+    }
+
+    fn flush(&mut self) -> VortexResult<ArrayRef> {
+        let states = std::mem::take(&mut self.partials);
+        Ok(ChunkedArray::try_new(states, self.partial_dtype.clone())?.into_array())
+    }
+
+    fn finish(&mut self) -> VortexResult<ArrayRef> {
+        let states = self.flush()?;
+        let results = self.vtable.finalize(states)?;
+
+        vortex_ensure!(
+            results.dtype() == &self.return_dtype,
+            "Return DType mismatch: expected {}, got {}",
+            self.return_dtype,
+            results.dtype()
+        );
+
+        Ok(results)
+    }
+}
+
+impl<V: AggregateFnVTable> GroupedAccumulator<V> {
+    fn accumulate_list_view(
+        &mut self,
+        groups: &ListViewArray,
+        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;
+            }
+
+            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()?
+            {
+                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 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()
+            }
+        }
+
+        self.push_result(states.finish())
+    }
+
+    fn accumulate_fixed_size_list(
+        &mut self,
+        groups: &FixedSizeListArray,
+        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 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)?;
+                accumulator.accumulate(&group, ctx)?;
+                states.append_scalar(&accumulator.finish()?)?;
+            } else {
+                states.append_null()
+            }
+            offset += size;
+        }
+
+        self.push_result(states.finish())
+    }
+
+    fn push_result(&mut self, state: ArrayRef) -> VortexResult<()> {
+        vortex_ensure!(
+            state.dtype() == &self.partial_dtype,
+            "State DType mismatch: expected {}, got {}",
+            self.partial_dtype,
+            state.dtype()
+        );
+        self.partials.push(state);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/erased.rs b/vortex-array/src/aggregate_fn/erased.rs
new file mode 100644
index 00000000000..750a7c24f77
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/erased.rs
@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Type-erased aggregate function ([`AggregateFnRef`]).
+
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_utils::debug_with::DebugWith;
+
+use crate::aggregate_fn::AccumulatorRef;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::GroupedAccumulatorRef;
+use crate::aggregate_fn::options::AggregateFnOptions;
+use crate::aggregate_fn::typed::AggregateFnInner;
+use crate::aggregate_fn::typed::DynAggregateFn;
+use crate::dtype::DType;
+
+/// A type-erased aggregate function, pairing a vtable with bound options behind a trait object.
+///
+/// This stores an [`AggregateFnVTable`] and its options behind an `Arc<dyn DynAggregateFn>`,
+/// allowing heterogeneous storage and dispatch.
+///
+/// Use [`super::AggregateFn::new()`] to construct, and [`super::AggregateFn::erased()`] to
+/// obtain an [`AggregateFnRef`].
+#[derive(Clone)]
+pub struct AggregateFnRef(pub(super) Arc<dyn DynAggregateFn>);
+
+impl AggregateFnRef {
+    /// Returns the ID of this aggregate function.
+    pub fn id(&self) -> AggregateFnId {
+        self.0.id()
+    }
+
+    /// Returns whether the aggregate function is of the given vtable type.
+    pub fn is<V: AggregateFnVTable>(&self) -> bool {
+        self.0.as_any().is::<AggregateFnInner<V>>()
+    }
+
+    /// Returns the typed options for this aggregate function if it matches the given vtable type.
+    pub fn as_opt<V: AggregateFnVTable>(&self) -> Option<&V::Options> {
+        self.downcast_inner::<V>().map(|inner| &inner.options)
+    }
+
+    /// Returns a reference to the typed vtable if it matches the given vtable type.
+    pub fn vtable_ref<V: AggregateFnVTable>(&self) -> Option<&V> {
+        self.downcast_inner::<V>().map(|inner| &inner.vtable)
+    }
+
+    /// Downcast the inner to the concrete `AggregateFnInner<V>`.
+    fn downcast_inner<V: AggregateFnVTable>(&self) -> Option<&AggregateFnInner<V>> {
+        self.0.as_any().downcast_ref::<AggregateFnInner<V>>()
+    }
+
+    /// Returns the typed options for this aggregate function if it matches the given vtable type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the vtable type does not match.
+    pub fn as_<V: AggregateFnVTable>(&self) -> &V::Options {
+        self.as_opt::<V>()
+            .vortex_expect("Aggregate function options type mismatch")
+    }
+
+    /// The type-erased options for this aggregate function.
+    pub fn options(&self) -> AggregateFnOptions<'_> {
+        AggregateFnOptions { inner: &*self.0 }
+    }
+
+    /// Coerce the input type for this aggregate function.
+    pub fn coerce_args(&self, input_dtype: &DType) -> VortexResult<DType> {
+        self.0.coerce_args(input_dtype)
+    }
+
+    /// Compute the return [`DType`] per group given the input element type.
+    ///
+    /// Returns `None` if the input dtype is not supported by the aggregate function.
+    pub fn return_dtype(&self, input_dtype: &DType) -> Option<DType> {
+        self.0.return_dtype(input_dtype)
+    }
+
+    /// DType of the intermediate accumulator state.
+    ///
+    /// Returns `None` if the input dtype is not supported by the aggregate function.
+    pub fn state_dtype(&self, input_dtype: &DType) -> Option<DType> {
+        self.0.state_dtype(input_dtype)
+    }
+
+    /// Create an accumulator for streaming aggregation.
+    pub fn accumulator(&self, input_dtype: &DType) -> VortexResult<AccumulatorRef> {
+        self.0.accumulator(input_dtype)
+    }
+
+    /// Create a grouped accumulator for grouped streaming aggregation.
+    pub fn accumulator_grouped(&self, input_dtype: &DType) -> VortexResult<GroupedAccumulatorRef> {
+        self.0.accumulator_grouped(input_dtype)
+    }
+}
+
+impl Debug for AggregateFnRef {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AggregateFnRef")
+            .field("vtable", &self.0.id())
+            .field("options", &DebugWith(|fmt| self.0.options_debug(fmt)))
+            .finish()
+    }
+}
+
+impl Display for AggregateFnRef {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}(", self.0.id())?;
+        self.0.options_display(f)?;
+        write!(f, ")")
+    }
+}
+
+impl PartialEq for AggregateFnRef {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.id() == other.0.id() && self.0.options_eq(other.0.options_any())
+    }
+}
+impl Eq for AggregateFnRef {}
+
+impl Hash for AggregateFnRef {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.id().hash(state);
+        self.0.options_hash(state);
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/count/mod.rs b/vortex-array/src/aggregate_fn/fns/count/mod.rs
new file mode 100644
index 00000000000..f0617e96bfe
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/count/mod.rs
@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::scalar::Scalar;
+
+/// Count the number of non-null elements in an array.
+///
+/// Applies to all types. Returns a `u64` count.
+/// The identity value is zero.
+#[derive(Clone, Debug)]
+pub struct Count;
+
+impl AggregateFnVTable for Count {
+    type Options = EmptyOptions;
+    type Partial = u64;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.count")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("Count is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _input_dtype: &DType) -> Option<DType> {
+        Some(DType::Primitive(PType::U64, Nullability::NonNullable))
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        _input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(0u64)
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        let val = other
+            .as_primitive()
+            .typed_value::<u64>()
+            .vortex_expect("count partial should not be null");
+        *partial += val;
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        Ok(Scalar::primitive(*partial, Nullability::NonNullable))
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        *partial = 0;
+    }
+
+    #[inline]
+    fn is_saturated(&self, _partial: &Self::Partial) -> bool {
+        false
+    }
+
+    fn try_accumulate(
+        &self,
+        state: &mut Self::Partial,
+        batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<bool> {
+        *state += batch.valid_count()? as u64;
+        Ok(true)
+    }
+
+    fn accumulate(
+        &self,
+        _partial: &mut Self::Partial,
+        _batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        unreachable!("Count::try_accumulate handles all arrays")
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::count::Count;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    pub fn count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<usize> {
+        let mut acc = Accumulator::try_new(Count, EmptyOptions, array.dtype().clone())?;
+        acc.accumulate(array, ctx)?;
+        let result = acc.finish()?;
+
+        Ok(usize::try_from(
+            result
+                .as_primitive()
+                .typed_value::<u64>()
+                .vortex_expect("count result should not be null"),
+        )?)
+    }
+
+    #[test]
+    fn count_all_valid() -> VortexResult<()> {
+        let array =
+            PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5], Validity::NonNullable).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&array, &mut ctx)?, 5);
+        Ok(())
+    }
+
+    #[test]
+    fn count_with_nulls() -> VortexResult<()> {
+        let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)])
+            .into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&array, &mut ctx)?, 3);
+        Ok(())
+    }
+
+    #[test]
+    fn count_all_null() -> VortexResult<()> {
+        let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&array, &mut ctx)?, 0);
+        Ok(())
+    }
+
+    #[test]
+    fn count_empty() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Count, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn count_multi_batch() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
+        let mut acc = Accumulator::try_new(Count, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+
+        let batch2 = PrimitiveArray::from_option_iter([None, Some(5i32)]).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
+        Ok(())
+    }
+
+    #[test]
+    fn count_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
+        let mut acc = Accumulator::try_new(Count, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::from_option_iter([Some(1i32), None]).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        let result1 = acc.finish()?;
+        assert_eq!(result1.as_primitive().typed_value::<u64>(), Some(1));
+
+        let batch2 = PrimitiveArray::from_option_iter([Some(2i32), Some(3), None]).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        let result2 = acc.finish()?;
+        assert_eq!(result2.as_primitive().typed_value::<u64>(), Some(2));
+        Ok(())
+    }
+
+    #[test]
+    fn count_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut state = Count.empty_partial(&EmptyOptions, &dtype)?;
+
+        let scalar1 = Scalar::primitive(5u64, Nullability::NonNullable);
+        Count.combine_partials(&mut state, scalar1)?;
+
+        let scalar2 = Scalar::primitive(3u64, Nullability::NonNullable);
+        Count.combine_partials(&mut state, scalar2)?;
+
+        let result = Count.to_scalar(&state)?;
+        Count.reset(&mut state);
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(8));
+        Ok(())
+    }
+
+    #[test]
+    fn count_constant_non_null() -> VortexResult<()> {
+        let array = ConstantArray::new(42i32, 10);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&array.into_array(), &mut ctx)?, 10);
+        Ok(())
+    }
+
+    #[test]
+    fn count_constant_null() -> VortexResult<()> {
+        let array = ConstantArray::new(
+            Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)),
+            10,
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&array.into_array(), &mut ctx)?, 0);
+        Ok(())
+    }
+
+    #[test]
+    fn count_chunked() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]);
+        let chunk2 = PrimitiveArray::from_option_iter([None, Some(5i32), None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(count(&chunked.into_array(), &mut ctx)?, 3);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/first/mod.rs b/vortex-array/src/aggregate_fn/fns/first/mod.rs
new file mode 100644
index 00000000000..38e55607279
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/first/mod.rs
@@ -0,0 +1,288 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::scalar::Scalar;
+
+/// Return the first non-null value of an array.
+///
+/// See [`First`] for details.
+pub fn first(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Scalar> {
+    let mut acc = Accumulator::try_new(First, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    acc.finish()
+}
+
+/// Return the first non-null value seen across all batches.
+#[derive(Clone, Debug)]
+pub struct First;
+
+/// Partial accumulator state for the [`First`] aggregate.
+pub struct FirstPartial {
+    /// The nullable version of the input dtype, used for the result and for empty/all-null inputs.
+    return_dtype: DType,
+    /// The first non-null value seen so far, or `None` if no non-null value has been observed.
+    value: Option<Scalar>,
+}
+
+impl AggregateFnVTable for First {
+    type Options = EmptyOptions;
+    type Partial = FirstPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.first")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("First is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        Some(input_dtype.as_nullable())
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(FirstPartial {
+            return_dtype: input_dtype.as_nullable(),
+            value: None,
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        // Only the first non-null partial wins; later ones are ignored.
+        if partial.value.is_none() && !other.is_null() {
+            partial.value = Some(other);
+        }
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        Ok(match &partial.value {
+            Some(v) => v.clone(),
+            None => Scalar::null(partial.return_dtype.clone()),
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.value = None;
+    }
+
+    #[inline]
+    fn is_saturated(&self, partial: &Self::Partial) -> bool {
+        partial.value.is_some()
+    }
+
+    fn try_accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<bool> {
+        if partial.value.is_some() {
+            return Ok(true);
+        }
+        if let Some(idx) = batch.validity_mask()?.first() {
+            let scalar = batch.scalar_at(idx)?;
+            partial.value = Some(scalar.into_nullable());
+        }
+        Ok(true)
+    }
+
+    fn accumulate(
+        &self,
+        _partial: &mut Self::Partial,
+        _batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        unreachable!("First::try_accumulate handles all arrays")
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::first::First;
+    use crate::aggregate_fn::fns::first::first;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::VarBinArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    #[test]
+    fn first_non_null() -> VortexResult<()> {
+        let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(10i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_skips_leading_nulls() -> VortexResult<()> {
+        let array =
+            PrimitiveArray::from_option_iter([None, None, Some(7i32), Some(8)]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(7i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_all_null() -> VortexResult<()> {
+        let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype));
+        Ok(())
+    }
+
+    #[test]
+    fn first_empty() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result, Scalar::null(DType::Primitive(PType::I32, Nullable)));
+        Ok(())
+    }
+
+    #[test]
+    fn first_constant() -> VortexResult<()> {
+        let array = ConstantArray::new(42i32, 10).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_constant_null() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype));
+        Ok(())
+    }
+
+    #[test]
+    fn first_varbin() -> VortexResult<()> {
+        let array = VarBinArray::from_iter(
+            vec![None, Some("hello"), Some("world")],
+            DType::Utf8(Nullable),
+        )
+        .into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(first(&array, &mut ctx)?, Scalar::utf8("hello", Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_multi_batch_picks_earliest_non_null() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?;
+
+        // First batch is all null - should not saturate.
+        let batch1 = PrimitiveArray::from_option_iter::<i32, _>([None, None]).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        assert!(!acc.is_saturated());
+
+        // Second batch contains the first non-null value.
+        let batch2 = PrimitiveArray::from_option_iter([None, Some(99i32), Some(100)]).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        assert!(acc.is_saturated());
+
+        // Third batch must be ignored - First is already saturated.
+        let batch3 = PrimitiveArray::from_option_iter([Some(1i32)]).into_array();
+        acc.accumulate(&batch3, &mut ctx)?;
+
+        let result = acc.finish()?;
+        assert_eq!(result, Scalar::primitive(99i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        assert_eq!(acc.finish()?, Scalar::primitive(10i32, Nullable));
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 6, 9], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        assert_eq!(acc.finish()?, Scalar::primitive(3i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut state = First.empty_partial(&EmptyOptions, &dtype)?;
+
+        // A null partial means the sub-accumulator saw nothing valid - should be ignored.
+        First.combine_partials(&mut state, Scalar::null(dtype.as_nullable()))?;
+        assert!(!First.is_saturated(&state));
+
+        First.combine_partials(&mut state, Scalar::primitive(5i32, Nullable))?;
+        assert!(First.is_saturated(&state));
+
+        // Subsequent valid partials are dropped.
+        First.combine_partials(&mut state, Scalar::primitive(7i32, Nullable))?;
+        assert_eq!(First.to_scalar(&state)?, Scalar::primitive(5i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn first_chunked() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter::<i32, _>([None, None]);
+        let chunk2 = PrimitiveArray::from_option_iter([None, Some(42i32), Some(100)]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(
+            first(&chunked.into_array(), &mut ctx)?,
+            Scalar::primitive(42i32, Nullable)
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs b/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs
new file mode 100644
index 00000000000..c63025ccd7c
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+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();
+    true_count == array.len() || true_count == 0
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/decimal.rs b/vortex-array/src/aggregate_fn/fns/is_constant/decimal.rs
new file mode 100644
index 00000000000..4a226f403f3
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/decimal.rs
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+
+use crate::arrays::DecimalArray;
+use crate::match_each_decimal_value_type;
+
+pub(super) fn check_decimal_constant(array: &DecimalArray) -> bool {
+    match_each_decimal_value_type!(array.values_type(), |S| {
+        array.buffer::<S>().iter().all_equal()
+    })
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/extension.rs b/vortex-array/src/aggregate_fn/fns/is_constant/extension.rs
new file mode 100644
index 00000000000..fa9393ede64
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/extension.rs
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::is_constant;
+use crate::ExecutionCtx;
+use crate::arrays::ExtensionArray;
+use crate::arrays::extension::ExtensionArrayExt;
+
+/// Check if an extension array is constant by delegating to its storage array.
+pub(super) fn check_extension_constant(
+    e: &ExtensionArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<bool> {
+    is_constant(e.storage_array(), ctx)
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/fixed_size_list.rs b/vortex-array/src/aggregate_fn/fns/is_constant/fixed_size_list.rs
new file mode 100644
index 00000000000..19ca54def21
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/fixed_size_list.rs
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::arrays_value_equal;
+use crate::ExecutionCtx;
+use crate::arrays::FixedSizeListArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+
+/// Check if a fixed-size list array is constant by comparing each list's elements.
+///
+/// Uses `binary(Operator::Eq)` for element-wise value comparison with null-safe equality.
+pub(super) fn check_fixed_size_list_constant(
+    f: &FixedSizeListArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<bool> {
+    if f.len() <= 1 {
+        return Ok(true);
+    }
+
+    let first_elements = f.fixed_size_list_elements_at(0)?;
+    for i in 1..f.len() {
+        let current_elements = f.fixed_size_list_elements_at(i)?;
+        if !arrays_value_equal(&first_elements, &current_elements, ctx)? {
+            return Ok(false);
+        }
+    }
+
+    Ok(true)
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/list.rs b/vortex-array/src/aggregate_fn/fns/is_constant/list.rs
new file mode 100644
index 00000000000..533ffa6edf8
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/list.rs
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::arrays_value_equal;
+use crate::ExecutionCtx;
+use crate::arrays::ListViewArray;
+use crate::arrays::listview::ListViewArrayExt;
+
+/// Check if a list view array is constant by comparing each list's elements.
+///
+/// A list view array is constant if all lists have the same size and the same elements.
+/// Uses `binary(Operator::Eq)` for element-wise value comparison with null-safe equality.
+pub(super) fn check_listview_constant(
+    l: &ListViewArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<bool> {
+    if l.len() <= 1 {
+        return Ok(true);
+    }
+
+    let first_size = l.size_at(0);
+    let first_elements = l.list_elements_at(0)?;
+
+    for i in 1..l.len() {
+        if l.size_at(i) != first_size {
+            return Ok(false);
+        }
+        if first_size == 0 {
+            continue;
+        }
+        let current_elements = l.list_elements_at(i)?;
+        if !arrays_value_equal(&first_elements, &current_elements, ctx)? {
+            return Ok(false);
+        }
+    }
+
+    Ok(true)
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs
new file mode 100644
index 00000000000..4df47b770de
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs
@@ -0,0 +1,676 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod bool;
+mod decimal;
+mod extension;
+mod fixed_size_list;
+mod list;
+pub mod primitive;
+mod struct_;
+mod varbin;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_mask::Mask;
+
+use self::bool::check_bool_constant;
+use self::decimal::check_decimal_constant;
+use self::extension::check_extension_constant;
+use self::fixed_size_list::check_fixed_size_list_constant;
+use self::list::check_listview_constant;
+use self::primitive::check_primitive_constant;
+use self::struct_::check_struct_constant;
+use self::varbin::check_varbinview_constant;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::arrays::Constant;
+use crate::arrays::Null;
+use crate::builtins::ArrayBuiltins;
+use crate::dtype::DType;
+use crate::dtype::FieldNames;
+use crate::dtype::Nullability;
+use crate::dtype::StructFields;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+use crate::expr::stats::StatsProviderExt;
+use crate::scalar::Scalar;
+use crate::scalar_fn::fns::operators::Operator;
+
+/// Check if two arrays of the same length have equal values at every position (null-safe).
+///
+/// Two positions are considered equal if they are both null, or both non-null with the same value.
+///
+// TODO(ngates): move this function out when we have any/all aggregate functions.
+fn arrays_value_equal(a: &ArrayRef, b: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    debug_assert_eq!(a.len(), b.len());
+    if a.is_empty() {
+        return Ok(true);
+    }
+
+    // Check validity masks match (null positions must be identical).
+    let a_mask = a.validity_mask()?;
+    let b_mask = b.validity_mask()?;
+    if a_mask != b_mask {
+        return Ok(false);
+    }
+
+    let valid_count = a_mask.true_count();
+    if valid_count == 0 {
+        // Both all-null → equal.
+        return Ok(true);
+    }
+
+    // Compare values element-wise. Result is null where both inputs are null,
+    // true/false where both are valid.
+    let eq_result = a.binary(b.clone(), Operator::Eq)?;
+    let eq_result = eq_result.execute::<Mask>(ctx)?;
+
+    Ok(eq_result.true_count() == valid_count)
+}
+
+/// Compute whether an array has constant values.
+///
+/// An array is constant IFF at least one of the following conditions apply:
+/// 1. It has at least one element (**Note** - an empty array isn't constant).
+/// 2. It's encoded as a [`ConstantArray`](crate::arrays::ConstantArray) or [`NullArray`](crate::arrays::NullArray)
+/// 3. Has an exact statistic attached to it, saying its constant.
+/// 4. Is all invalid.
+/// 5. Is all valid AND has minimum and maximum statistics that are equal.
+pub fn is_constant(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    // Short-circuit using cached array statistics.
+    if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(Stat::IsConstant) {
+        return Ok(value);
+    }
+
+    // Empty arrays are not constant.
+    if array.is_empty() {
+        return Ok(false);
+    }
+
+    // Array of length 1 is always constant.
+    if array.len() == 1 {
+        array
+            .statistics()
+            .set(Stat::IsConstant, Precision::Exact(true.into()));
+        return Ok(true);
+    }
+
+    // Constant and null arrays are always constant.
+    if array.is::<Constant>() || array.is::<Null>() {
+        array
+            .statistics()
+            .set(Stat::IsConstant, Precision::Exact(true.into()));
+        return Ok(true);
+    }
+
+    let all_invalid = array.all_invalid()?;
+    if all_invalid {
+        array
+            .statistics()
+            .set(Stat::IsConstant, Precision::Exact(true.into()));
+        return Ok(true);
+    }
+
+    let all_valid = array.all_valid()?;
+
+    // If we have some nulls but not all nulls, array can't be constant.
+    if !all_valid && !all_invalid {
+        array
+            .statistics()
+            .set(Stat::IsConstant, Precision::Exact(false.into()));
+        return Ok(false);
+    }
+
+    // We already know here that the array is all valid, so we check for min/max stats.
+    let min = array.statistics().get(Stat::Min);
+    let max = array.statistics().get(Stat::Max);
+
+    if let Some((min, max)) = min.zip(max)
+        && min.is_exact()
+        && min == max
+        && (Stat::NaNCount.dtype(array.dtype()).is_none()
+            || array.statistics().get_as::<u64>(Stat::NaNCount) == Some(Precision::exact(0u64)))
+    {
+        array
+            .statistics()
+            .set(Stat::IsConstant, Precision::Exact(true.into()));
+        return Ok(true);
+    }
+
+    // Short-circuit for unsupported dtypes.
+    if IsConstant
+        .return_dtype(&EmptyOptions, array.dtype())
+        .is_none()
+    {
+        // Null dtype - vacuously false for empty
+        return Ok(false);
+    }
+
+    // Compute using Accumulator<IsConstant>.
+    let mut acc = Accumulator::try_new(IsConstant, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    let result_scalar = acc.finish()?;
+
+    let result = result_scalar.as_bool().value().unwrap_or(false);
+
+    // Cache the computed is_constant as a statistic.
+    array
+        .statistics()
+        .set(Stat::IsConstant, Precision::Exact(result.into()));
+
+    Ok(result)
+}
+
+/// Compute whether an array is constant.
+///
+/// Returns a `Bool(NonNullable)` scalar.
+/// The partial state is a nullable struct `{is_constant: Bool(NN), value: input_dtype?}`.
+/// A null struct means the accumulator has seen no data yet (empty).
+#[derive(Clone, Debug)]
+pub struct IsConstant;
+
+impl IsConstant {
+    /// Build a partial scalar from a kernel's `is_constant` result.
+    ///
+    /// Kernels that compute `is_constant` by delegating to child arrays can call this
+    /// to package the boolean result into the partial struct format expected by the
+    /// accumulator, avoiding duplicated boilerplate.
+    pub fn make_partial(batch: &ArrayRef, is_constant: bool) -> VortexResult<Scalar> {
+        let partial_dtype = make_is_constant_partial_dtype(batch.dtype());
+        if is_constant {
+            if batch.is_empty() {
+                return Ok(Scalar::null(partial_dtype));
+            }
+            let first_value = batch.scalar_at(0)?.into_nullable();
+            Ok(Scalar::struct_(
+                partial_dtype,
+                vec![Scalar::bool(true, Nullability::NonNullable), first_value],
+            ))
+        } else {
+            Ok(Scalar::struct_(
+                partial_dtype,
+                vec![
+                    Scalar::bool(false, Nullability::NonNullable),
+                    Scalar::null(batch.dtype().as_nullable()),
+                ],
+            ))
+        }
+    }
+}
+
+/// Partial accumulator state for is_constant.
+pub struct IsConstantPartial {
+    is_constant: bool,
+    /// None = empty (no values seen), Some(null) = all nulls, Some(v) = first value seen.
+    first_value: Option<Scalar>,
+    element_dtype: DType,
+}
+
+impl IsConstantPartial {
+    fn check_value(&mut self, value: Scalar) {
+        if !self.is_constant {
+            return;
+        }
+        match &self.first_value {
+            None => {
+                self.first_value = Some(value);
+            }
+            Some(first) => {
+                if *first != value {
+                    self.is_constant = false;
+                }
+            }
+        }
+    }
+}
+
+static NAMES: std::sync::LazyLock<FieldNames> =
+    std::sync::LazyLock::new(|| FieldNames::from(["is_constant", "value"]));
+
+pub fn make_is_constant_partial_dtype(element_dtype: &DType) -> DType {
+    DType::Struct(
+        StructFields::new(
+            NAMES.clone(),
+            vec![
+                DType::Bool(Nullability::NonNullable),
+                element_dtype.as_nullable(),
+            ],
+        ),
+        Nullability::Nullable,
+    )
+}
+
+impl AggregateFnVTable for IsConstant {
+    type Options = EmptyOptions;
+    type Partial = IsConstantPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.is_constant")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("IsConstant is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        match input_dtype {
+            DType::Null | DType::Variant(..) => None,
+            _ => Some(DType::Bool(Nullability::NonNullable)),
+        }
+    }
+
+    fn partial_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        match input_dtype {
+            DType::Null | DType::Variant(..) => None,
+            _ => Some(make_is_constant_partial_dtype(input_dtype)),
+        }
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(IsConstantPartial {
+            is_constant: true,
+            first_value: None,
+            element_dtype: input_dtype.clone(),
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        if !partial.is_constant {
+            return Ok(());
+        }
+
+        // Null struct means the other accumulator was empty, skip it.
+        if other.is_null() {
+            return Ok(());
+        }
+
+        let other_is_constant = other
+            .as_struct()
+            .field_by_idx(0)
+            .map(|s| s.as_bool().value().unwrap_or(false))
+            .unwrap_or(false);
+
+        if !other_is_constant {
+            partial.is_constant = false;
+            return Ok(());
+        }
+
+        let other_value = other.as_struct().field_by_idx(1);
+
+        if let Some(other_val) = other_value {
+            partial.check_value(other_val);
+        }
+
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        let dtype = make_is_constant_partial_dtype(&partial.element_dtype);
+        Ok(match &partial.first_value {
+            None => {
+                // Empty accumulator — return null struct.
+                Scalar::null(dtype)
+            }
+            Some(first_value) => Scalar::struct_(
+                dtype,
+                vec![
+                    Scalar::bool(partial.is_constant, Nullability::NonNullable),
+                    first_value
+                        .clone()
+                        .cast(&partial.element_dtype.as_nullable())?,
+                ],
+            ),
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.is_constant = true;
+        partial.first_value = None;
+    }
+
+    #[inline]
+    fn is_saturated(&self, partial: &Self::Partial) -> bool {
+        !partial.is_constant
+    }
+
+    fn accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &Columnar,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        if !partial.is_constant {
+            return Ok(());
+        }
+
+        match batch {
+            Columnar::Constant(c) => {
+                partial.check_value(c.scalar().clone().into_nullable());
+                Ok(())
+            }
+            Columnar::Canonical(c) => {
+                if c.is_empty() {
+                    return Ok(());
+                }
+
+                // Convert to ArrayRef for DynArray methods.
+                let array_ref = c.clone().into_array();
+
+                let all_invalid = array_ref.all_invalid()?;
+                if all_invalid {
+                    partial.check_value(Scalar::null(partial.element_dtype.as_nullable()));
+                    return Ok(());
+                }
+
+                let all_valid = array_ref.all_valid()?;
+                // Mixed nulls → not constant.
+                if !all_valid && !all_invalid {
+                    partial.is_constant = false;
+                    return Ok(());
+                }
+
+                // All valid from here. Check batch-level constancy.
+                if c.len() == 1 {
+                    partial.check_value(array_ref.scalar_at(0)?.into_nullable());
+                    return Ok(());
+                }
+
+                let batch_is_constant = match c {
+                    Canonical::Primitive(p) => check_primitive_constant(p),
+                    Canonical::Bool(b) => check_bool_constant(b),
+                    Canonical::VarBinView(v) => check_varbinview_constant(v),
+                    Canonical::Decimal(d) => check_decimal_constant(d),
+                    Canonical::Struct(s) => check_struct_constant(s, ctx)?,
+                    Canonical::Extension(e) => check_extension_constant(e, ctx)?,
+                    Canonical::List(l) => check_listview_constant(l, ctx)?,
+                    Canonical::FixedSizeList(f) => check_fixed_size_list_constant(f, ctx)?,
+                    Canonical::Null(_) => true,
+                    Canonical::Variant(_) => {
+                        vortex_bail!("Variant arrays don't support IsConstant")
+                    }
+                };
+
+                if !batch_is_constant {
+                    partial.is_constant = false;
+                    return Ok(());
+                }
+
+                partial.check_value(array_ref.scalar_at(0)?.into_nullable());
+                Ok(())
+            }
+        }
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        partials.get_item(NAMES.get(0).vortex_expect("out of bounds").clone())
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        if partial.first_value.is_none() {
+            // Empty accumulator → return false.
+            return Ok(Scalar::bool(false, Nullability::NonNullable));
+        }
+        Ok(Scalar::bool(partial.is_constant, Nullability::NonNullable))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray as _;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::is_constant::is_constant;
+    use crate::arrays::BoolArray;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::DecimalArray;
+    use crate::arrays::ListArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::StructArray;
+    use crate::dtype::DType;
+    use crate::dtype::DecimalDType;
+    use crate::dtype::FieldNames;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::expr::stats::Stat;
+    use crate::validity::Validity;
+
+    // Tests migrated from compute/is_constant.rs
+    #[test]
+    fn is_constant_min_max_no_nan() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let arr = buffer![0, 1].into_array();
+        arr.statistics().compute_all(&[Stat::Min, Stat::Max])?;
+        assert!(!is_constant(&arr, &mut ctx)?);
+
+        let arr = buffer![0, 0].into_array();
+        arr.statistics().compute_all(&[Stat::Min, Stat::Max])?;
+        assert!(is_constant(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::from_option_iter([Some(0), Some(0)]).into_array();
+        assert!(is_constant(&arr, &mut ctx)?);
+        Ok(())
+    }
+
+    #[test]
+    fn is_constant_min_max_with_nan() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let arr = PrimitiveArray::from_iter([0.0, 0.0, f32::NAN]).into_array();
+        arr.statistics().compute_all(&[Stat::Min, Stat::Max])?;
+        assert!(!is_constant(&arr, &mut ctx)?);
+
+        let arr =
+            PrimitiveArray::from_option_iter([Some(f32::NEG_INFINITY), Some(f32::NEG_INFINITY)])
+                .into_array();
+        arr.statistics().compute_all(&[Stat::Min, Stat::Max])?;
+        assert!(is_constant(&arr, &mut ctx)?);
+        Ok(())
+    }
+
+    // Tests migrated from arrays/bool/compute/is_constant.rs
+    #[rstest]
+    #[case(vec![true], true)]
+    #[case(vec![false; 65], true)]
+    #[case({
+        let mut v = vec![true; 64];
+        v.push(false);
+        v
+    }, false)]
+    fn test_bool_is_constant(#[case] input: Vec<bool>, #[case] expected: bool) -> VortexResult<()> {
+        let array = BoolArray::from_iter(input);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(is_constant(&array.into_array(), &mut ctx)?, expected);
+        Ok(())
+    }
+
+    // Tests migrated from arrays/chunked/compute/is_constant.rs
+    #[test]
+    fn empty_chunk_is_constant() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                Buffer::<u8>::empty().into_array(),
+                Buffer::<u8>::empty().into_array(),
+                buffer![255u8, 255].into_array(),
+                Buffer::<u8>::empty().into_array(),
+                buffer![255u8, 255].into_array(),
+            ],
+            DType::Primitive(PType::U8, Nullability::NonNullable),
+        )?
+        .into_array();
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(is_constant(&chunked, &mut ctx)?);
+        Ok(())
+    }
+
+    // Tests migrated from arrays/decimal/compute/is_constant.rs
+    #[test]
+    fn test_decimal_is_constant() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let array = DecimalArray::new(
+            buffer![0i128, 1i128, 2i128],
+            DecimalDType::new(19, 0),
+            Validity::NonNullable,
+        );
+        assert!(!is_constant(&array.into_array(), &mut ctx)?);
+
+        let array = DecimalArray::new(
+            buffer![100i128, 100i128, 100i128],
+            DecimalDType::new(19, 0),
+            Validity::NonNullable,
+        );
+        assert!(is_constant(&array.into_array(), &mut ctx)?);
+        Ok(())
+    }
+
+    // Tests migrated from arrays/list/compute/is_constant.rs
+    #[test]
+    fn test_is_constant_nested_list() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let xs = ListArray::try_new(
+            buffer![0i32, 1, 0, 1].into_array(),
+            buffer![0u32, 2, 4].into_array(),
+            Validity::NonNullable,
+        )?;
+
+        let struct_of_lists = StructArray::try_new(
+            FieldNames::from(["xs"]),
+            vec![xs.into_array()],
+            2,
+            Validity::NonNullable,
+        )?;
+        assert!(is_constant(
+            &struct_of_lists.clone().into_array(),
+            &mut ctx
+        )?);
+        assert!(is_constant(&struct_of_lists.into_array(), &mut ctx)?);
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(
+        // [1,2], [1, 2], [1, 2]
+        vec![1i32, 2, 1, 2, 1, 2],
+        vec![0u32, 2, 4, 6],
+        true
+    )]
+    #[case(
+        // [1, 2], [3], [4, 5]
+        vec![1i32, 2, 3, 4, 5],
+        vec![0u32, 2, 3, 5],
+        false
+    )]
+    #[case(
+        // [1, 2], [3, 4]
+        vec![1i32, 2, 3, 4],
+        vec![0u32, 2, 4],
+        false
+    )]
+    #[case(
+        // [], [], []
+        vec![],
+        vec![0u32, 0, 0, 0],
+        true
+    )]
+    fn test_list_is_constant(
+        #[case] elements: Vec<i32>,
+        #[case] offsets: Vec<u32>,
+        #[case] expected: bool,
+    ) -> VortexResult<()> {
+        let list_array = ListArray::try_new(
+            PrimitiveArray::from_iter(elements).into_array(),
+            PrimitiveArray::from_iter(offsets).into_array(),
+            Validity::NonNullable,
+        )?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_list_is_constant_nested_lists() -> VortexResult<()> {
+        let inner_elements = buffer![1i32, 2, 1, 2].into_array();
+        let inner_offsets = buffer![0u32, 1, 2, 3, 4].into_array();
+        let inner_lists = ListArray::try_new(inner_elements, inner_offsets, Validity::NonNullable)?;
+
+        let outer_offsets = buffer![0u32, 2, 4].into_array();
+        let outer_list = ListArray::try_new(
+            inner_lists.into_array(),
+            outer_offsets,
+            Validity::NonNullable,
+        )?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        // Both outer lists contain [[1], [2]], so should be constant
+        assert!(is_constant(&outer_list.into_array(), &mut ctx)?);
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(
+        // 100 identical [1, 2] lists
+        [1i32, 2].repeat(100),
+        (0..101).map(|i| (i * 2) as u32).collect(),
+        true
+    )]
+    #[case(
+        // Difference after threshold: 64 identical [1, 2] + one [3, 4]
+        {
+            let mut elements = [1i32, 2].repeat(64);
+            elements.extend_from_slice(&[3, 4]);
+            elements
+        },
+        (0..66).map(|i| (i * 2) as u32).collect(),
+        false
+    )]
+    #[case(
+        // Difference in first 64: first 63 identical [1, 2] + one [3, 4] + rest identical [1, 2]
+        {
+            let mut elements = [1i32, 2].repeat(63);
+            elements.extend_from_slice(&[3, 4]);
+            elements.extend([1i32, 2].repeat(37));
+            elements
+        },
+        (0..101).map(|i| (i * 2) as u32).collect(),
+        false
+    )]
+    fn test_list_is_constant_with_threshold(
+        #[case] elements: Vec<i32>,
+        #[case] offsets: Vec<u32>,
+        #[case] expected: bool,
+    ) -> VortexResult<()> {
+        let list_array = ListArray::try_new(
+            PrimitiveArray::from_iter(elements).into_array(),
+            PrimitiveArray::from_iter(offsets).into_array(),
+            Validity::NonNullable,
+        )?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/primitive/compute/is_constant.rs b/vortex-array/src/aggregate_fn/fns/is_constant/primitive.rs
similarity index 58%
rename from vortex-array/src/arrays/primitive/compute/is_constant.rs
rename to vortex-array/src/aggregate_fn/fns/is_constant/primitive.rs
index fb1474939b9..510306237ad 100644
--- a/vortex-array/src/arrays/primitive/compute/is_constant.rs
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/primitive.rs
@@ -1,17 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_error::VortexResult;
-
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
 use crate::dtype::NativePType;
 use crate::dtype::half::f16;
 use crate::match_each_native_ptype;
-use crate::register_kernel;
 
 cfg_if::cfg_if! {
     if #[cfg(target_feature = "avx2")] {
@@ -21,28 +14,6 @@ cfg_if::cfg_if! {
     }
 }
 
-impl IsConstantKernel for PrimitiveVTable {
-    fn is_constant(
-        &self,
-        array: &PrimitiveArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        if opts.is_negligible_cost() {
-            return Ok(None);
-        }
-
-        let is_constant = match_each_native_ptype!(array.ptype(), integral: |P| {
-            compute_is_constant::<_, {IS_CONST_LANE_WIDTH / size_of::<P>()}>(array.as_slice::<P>())
-        }, floating: |P| {
-            compute_is_constant::<_, {IS_CONST_LANE_WIDTH / size_of::<P>()}>(unsafe { std::mem::transmute::<&[P], &[<P as EqFloat>::IntType]>(array.as_slice::<P>()) })
-        });
-
-        Ok(Some(is_constant))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(PrimitiveVTable).lift());
-
 /// Assumes any floating point has been cast into its bit representation for which != and !is_eq are the same
 /// Assumes there's at least 1 value in the slice, which is an invariant of the entry level function.
 pub fn compute_is_constant<T: NativePType, const WIDTH: usize>(values: &[T]) -> bool {
@@ -79,3 +50,11 @@ impl EqFloat for f32 {
 impl EqFloat for f64 {
     type IntType = u64;
 }
+
+pub(super) fn check_primitive_constant(array: &PrimitiveArray) -> bool {
+    match_each_native_ptype!(array.ptype(), integral: |P| {
+        compute_is_constant::<_, {IS_CONST_LANE_WIDTH / size_of::<P>()}>(array.as_slice::<P>())
+    }, floating: |P| {
+        compute_is_constant::<_, {IS_CONST_LANE_WIDTH / size_of::<P>()}>(unsafe { std::mem::transmute::<&[P], &[<P as EqFloat>::IntType]>(array.as_slice::<P>()) })
+    })
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/struct_.rs b/vortex-array/src/aggregate_fn/fns/is_constant/struct_.rs
new file mode 100644
index 00000000000..9376115521f
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/struct_.rs
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::is_constant;
+use crate::ExecutionCtx;
+use crate::arrays::StructArray;
+use crate::arrays::struct_::StructArrayExt;
+
+/// Check if a struct array is constant by checking each field independently.
+pub(super) fn check_struct_constant(s: &StructArray, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    for field in s.unmasked_fields().iter() {
+        if !is_constant(field, ctx)? {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/varbin.rs b/vortex-array/src/aggregate_fn/fns/is_constant/varbin.rs
new file mode 100644
index 00000000000..aff91f0fffa
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/varbin.rs
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexExpect;
+
+use crate::arrays::VarBinViewArray;
+use crate::arrays::varbinview::Ref;
+
+pub(super) fn check_varbinview_constant(array: &VarBinViewArray) -> bool {
+    let mut views_iter = array.views().iter();
+    let first_value = views_iter
+        .next()
+        .vortex_expect("Must have at least one value");
+
+    if first_value.is_inlined() {
+        let first_value = first_value.as_inlined();
+
+        for view in views_iter {
+            if !view.is_inlined() || view.as_inlined() != first_value {
+                return false;
+            }
+        }
+    } else {
+        let ref_bytes = |view_ref: &Ref| {
+            &array.buffer(view_ref.buffer_index as usize).as_slice()[view_ref.as_range()]
+        };
+
+        let first_view_ref = first_value.as_view();
+        let first_value_bytes = ref_bytes(first_view_ref);
+
+        for view in views_iter {
+            if view.is_inlined() || view.len() != first_value.len() {
+                return false;
+            }
+
+            let view_ref = view.as_view();
+            let value = ref_bytes(view_ref);
+            if value != first_value_bytes {
+                return false;
+            }
+        }
+    }
+
+    true
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs
new file mode 100644
index 00000000000..c1efdc91563
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::IsSortedIteratorExt;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
+
+pub(super) fn check_bool_sorted(array: &BoolArray, strict: bool) -> VortexResult<bool> {
+    match array.validity_mask()? {
+        Mask::AllFalse(_) => Ok(!strict),
+        Mask::AllTrue(_) => {
+            let values = array.to_bit_buffer();
+            Ok(if strict {
+                values.iter().is_strict_sorted()
+            } else {
+                values.iter().is_sorted()
+            })
+        }
+        Mask::Values(mask_values) => {
+            if strict {
+                let validity_buffer = mask_values.bit_buffer();
+                let values = array.to_bit_buffer();
+                Ok(validity_buffer
+                    .iter()
+                    .zip(values.iter())
+                    .map(|(is_valid, value)| is_valid.then_some(value))
+                    .is_strict_sorted())
+            } else {
+                let set_indices = mask_values.bit_buffer().set_indices();
+                let values = array.to_bit_buffer();
+                let values_iter = set_indices.map(|idx|
+                    // Safety:
+                    // All idxs are in-bounds for the array.
+                    unsafe {
+                        values.value_unchecked(idx)
+                    });
+                Ok(values_iter.is_sorted())
+            }
+        }
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/decimal.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/decimal.rs
new file mode 100644
index 00000000000..e56858fd015
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/decimal.rs
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::IsSortedIteratorExt;
+use crate::arrays::DecimalArray;
+use crate::dtype::NativeDecimalType;
+use crate::match_each_decimal_value_type;
+
+pub(super) fn check_decimal_sorted(array: &DecimalArray, strict: bool) -> VortexResult<bool> {
+    match_each_decimal_value_type!(array.values_type(), |S| {
+        compute_is_sorted::<S>(array, strict)
+    })
+}
+
+fn compute_is_sorted<T: NativeDecimalType>(array: &DecimalArray, strict: bool) -> VortexResult<bool>
+where
+    dyn Iterator<Item = T>: IsSortedIteratorExt,
+{
+    match array.validity_mask()? {
+        Mask::AllFalse(_) => Ok(!strict),
+        Mask::AllTrue(_) => {
+            let buf = array.buffer::<T>();
+            let iter = buf.iter().copied();
+
+            Ok(if strict {
+                IsSortedIteratorExt::is_strict_sorted(iter)
+            } else {
+                iter.is_sorted()
+            })
+        }
+        Mask::Values(mask_values) => {
+            let values = array.buffer::<T>();
+            let iter = mask_values
+                .bit_buffer()
+                .iter()
+                .zip_eq(values)
+                .map(|(is_valid, v)| is_valid.then_some(v));
+
+            Ok(if strict {
+                IsSortedIteratorExt::is_strict_sorted(iter)
+            } else {
+                iter.is_sorted()
+            })
+        }
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/extension.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/extension.rs
new file mode 100644
index 00000000000..dc69b7c8bf9
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/extension.rs
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ExecutionCtx;
+use crate::aggregate_fn::fns::is_sorted::is_sorted;
+use crate::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use crate::arrays::ExtensionArray;
+use crate::arrays::extension::ExtensionArrayExt;
+
+pub(super) fn check_extension_sorted(
+    array: &ExtensionArray,
+    strict: bool,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<bool> {
+    if strict {
+        is_strict_sorted(array.storage_array(), ctx)
+    } else {
+        is_sorted(array.storage_array(), ctx)
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs
new file mode 100644
index 00000000000..780fc492baa
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs
@@ -0,0 +1,701 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod bool;
+mod decimal;
+mod extension;
+mod primitive;
+mod varbin;
+
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use self::bool::check_bool_sorted;
+use self::decimal::check_decimal_sorted;
+use self::extension::check_extension_sorted;
+use self::primitive::check_primitive_sorted;
+use self::varbin::check_varbinview_sorted;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::arrays::Constant;
+use crate::arrays::Null;
+use crate::builtins::ArrayBuiltins;
+use crate::dtype::DType;
+use crate::dtype::FieldNames;
+use crate::dtype::Nullability;
+use crate::dtype::StructFields;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProviderExt;
+use crate::scalar::Scalar;
+
+/// Options for the `is_sorted` aggregate function.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct IsSortedOptions {
+    /// If true, check for strictly ascending order (no duplicates).
+    pub strict: bool,
+}
+
+impl Display for IsSortedOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "strict={}", self.strict)
+    }
+}
+
+/// Compute whether an array is sorted in non-decreasing order.
+///
+/// Returns `true` for empty arrays and arrays of length 1.
+/// Returns `false` for struct, list, and fixed-size list arrays.
+pub fn is_sorted(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    is_sorted_impl(array, false, ctx)
+}
+
+/// Compute whether an array is strictly sorted in increasing order (no duplicates).
+///
+/// Returns `true` for empty arrays and arrays of length 1.
+/// Returns `false` for struct, list, and fixed-size list arrays.
+pub fn is_strict_sorted(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    is_sorted_impl(array, true, ctx)
+}
+
+fn is_sorted_impl(array: &ArrayRef, strict: bool, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    let stat = if strict {
+        Stat::IsStrictSorted
+    } else {
+        Stat::IsSorted
+    };
+
+    // Short-circuit using cached array statistics.
+    if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(stat) {
+        return Ok(value);
+    }
+
+    // Arrays with 0 or 1 elements are (strict) sorted.
+    if array.len() <= 1 {
+        return Ok(true);
+    }
+
+    // Constant and null arrays are always sorted, but not strict sorted.
+    if array.is::<Constant>() || array.is::<Null>() {
+        let result = !strict;
+        cache_is_sorted(array, strict, result);
+        return Ok(result);
+    }
+
+    // We don't support sorting struct arrays.
+    if array.dtype().is_struct() {
+        return Ok(false);
+    }
+
+    // Short-circuit for unsupported dtypes.
+    if IsSorted
+        .return_dtype(&IsSortedOptions { strict }, array.dtype())
+        .is_none()
+    {
+        return Ok(false);
+    }
+
+    // Enforce strictness before we even try to check if the array is sorted.
+    if strict {
+        let invalid_count = array.invalid_count()?;
+        match invalid_count {
+            // We can keep going
+            0 => {}
+            // If we have a potential null value - it has to be the first one.
+            1 => {
+                if !array.is_invalid(0)? {
+                    cache_is_sorted(array, strict, false);
+                    return Ok(false);
+                }
+            }
+            _ => {
+                cache_is_sorted(array, strict, false);
+                return Ok(false);
+            }
+        }
+    }
+
+    // Compute using Accumulator<IsSorted>.
+    let mut acc =
+        Accumulator::try_new(IsSorted, IsSortedOptions { strict }, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    let result_scalar = acc.finish()?;
+
+    let result = result_scalar.as_bool().value().unwrap_or(false);
+
+    // Cache the computed result as statistics.
+    cache_is_sorted(array, strict, result);
+
+    Ok(result)
+}
+
+fn cache_is_sorted(array: &ArrayRef, strict: bool, result: bool) {
+    let array_stats = array.statistics();
+    if strict {
+        if result {
+            array_stats.set(Stat::IsSorted, Precision::Exact(true.into()));
+            array_stats.set(Stat::IsStrictSorted, Precision::Exact(true.into()));
+        } else {
+            array_stats.set(Stat::IsStrictSorted, Precision::Exact(false.into()));
+        }
+    } else if result {
+        array_stats.set(Stat::IsSorted, Precision::Exact(true.into()));
+    } else {
+        array_stats.set(Stat::IsSorted, Precision::Exact(false.into()));
+        array_stats.set(Stat::IsStrictSorted, Precision::Exact(false.into()));
+    }
+}
+
+/// Aggregate function vtable for `is_sorted`.
+///
+/// Returns `Bool(NonNullable)` scalar.
+/// The partial state is a nullable struct `{is_sorted: Bool(NN), first_value: T?, last_value: T?}`.
+/// A null struct means the accumulator has seen no data yet (empty).
+#[derive(Clone, Debug)]
+pub struct IsSorted;
+
+impl IsSorted {
+    /// Build a partial scalar from a kernel's `is_sorted` result.
+    ///
+    /// Kernels that compute `is_sorted` by delegating to child arrays can call this
+    /// to package the boolean result into the partial struct format expected by the
+    /// accumulator, avoiding duplicated boilerplate.
+    pub fn make_partial(batch: &ArrayRef, is_sorted: bool, strict: bool) -> VortexResult<Scalar> {
+        let partial_dtype = make_is_sorted_partial_dtype(batch.dtype());
+        if batch.is_empty() {
+            return Ok(Scalar::null(partial_dtype));
+        }
+        let first_value = batch.scalar_at(0)?.into_nullable();
+        let last_value = batch.scalar_at(batch.len() - 1)?.into_nullable();
+        // SAFETY: We constructed partial_dtype and the children match its field dtypes exactly.
+        Ok(unsafe {
+            Scalar::struct_unchecked(
+                partial_dtype,
+                [
+                    Scalar::bool(is_sorted, Nullability::NonNullable),
+                    Scalar::bool(strict, Nullability::NonNullable),
+                    first_value,
+                    last_value,
+                ],
+            )
+        })
+    }
+}
+
+/// Partial accumulator state for is_sorted.
+pub struct IsSortedPartial {
+    is_sorted: bool,
+    strict: bool,
+    /// None = empty (no values seen).
+    first_value: Option<Scalar>,
+    last_value: Option<Scalar>,
+    element_dtype: DType,
+}
+
+static NAMES: std::sync::LazyLock<FieldNames> = std::sync::LazyLock::new(|| {
+    FieldNames::from(["is_sorted", "strict", "first_value", "last_value"])
+});
+
+pub fn make_is_sorted_partial_dtype(element_dtype: &DType) -> DType {
+    DType::Struct(
+        StructFields::new(
+            NAMES.clone(),
+            vec![
+                DType::Bool(Nullability::NonNullable),
+                DType::Bool(Nullability::NonNullable),
+                element_dtype.as_nullable(),
+                element_dtype.as_nullable(),
+            ],
+        ),
+        Nullability::Nullable,
+    )
+}
+
+impl AggregateFnVTable for IsSorted {
+    type Options = IsSortedOptions;
+    type Partial = IsSortedPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.is_sorted")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("IsSorted is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        match input_dtype {
+            DType::Null
+            | DType::Struct(..)
+            | DType::List(..)
+            | DType::FixedSizeList(..)
+            | DType::Variant(..) => None,
+            _ => Some(DType::Bool(Nullability::NonNullable)),
+        }
+    }
+
+    fn partial_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        match input_dtype {
+            DType::Null
+            | DType::Struct(..)
+            | DType::List(..)
+            | DType::FixedSizeList(..)
+            | DType::Variant(..) => None,
+            _ => Some(make_is_sorted_partial_dtype(input_dtype)),
+        }
+    }
+
+    fn empty_partial(
+        &self,
+        options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(IsSortedPartial {
+            is_sorted: true,
+            strict: options.strict,
+            first_value: None,
+            last_value: None,
+            element_dtype: input_dtype.clone(),
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        if !partial.is_sorted {
+            return Ok(());
+        }
+
+        // Null struct means the other accumulator was empty, skip it.
+        if other.is_null() {
+            return Ok(());
+        }
+
+        let other_is_sorted = other
+            .as_struct()
+            .field_by_idx(0)
+            .map(|s| s.as_bool().value().unwrap_or(false))
+            .unwrap_or(false);
+
+        let other_first = other.as_struct().field_by_idx(2);
+        let other_last = other.as_struct().field_by_idx(3);
+
+        if !other_is_sorted {
+            partial.is_sorted = false;
+            // Still update last_value for correctness if needed, but we're done.
+            if let Some(last) = other_last {
+                partial.last_value = Some(last);
+            }
+            return Ok(());
+        }
+
+        // Check boundary: self.last_value vs other.first_value
+        if let Some(ref self_last) = partial.last_value
+            && let Some(ref other_first_val) = other_first
+        {
+            if !self_last.is_null() && !other_first_val.is_null() {
+                let boundary_ok = if partial.strict {
+                    *self_last < *other_first_val
+                } else {
+                    *self_last <= *other_first_val
+                };
+                if !boundary_ok {
+                    partial.is_sorted = false;
+                }
+            } else if !self_last.is_null() && other_first_val.is_null() {
+                // non-null before null violates sort order
+                partial.is_sorted = false;
+            } else if self_last.is_null() && other_first_val.is_null() && partial.strict {
+                // both null with strict: violates strict sort
+                partial.is_sorted = false;
+            }
+        }
+
+        // Update first_value if this is the first non-empty chunk.
+        if partial.first_value.is_none() {
+            partial.first_value = other_first;
+        }
+        if let Some(last) = other_last {
+            partial.last_value = Some(last);
+        }
+
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        let dtype = make_is_sorted_partial_dtype(&partial.element_dtype);
+        Ok(match (&partial.first_value, &partial.last_value) {
+            (None, _) => {
+                // Empty accumulator — return null struct.
+                Scalar::null(dtype)
+            }
+            (Some(first_value), Some(last_value)) => {
+                // SAFETY: We constructed partial_dtype and the children match its field dtypes.
+                unsafe {
+                    Scalar::struct_unchecked(
+                        dtype,
+                        [
+                            Scalar::bool(partial.is_sorted, Nullability::NonNullable),
+                            Scalar::bool(partial.strict, Nullability::NonNullable),
+                            first_value.clone(),
+                            last_value.clone(),
+                        ],
+                    )
+                }
+            }
+            (Some(first_value), None) => {
+                // SAFETY: We constructed partial_dtype and the children match its field dtypes.
+                unsafe {
+                    Scalar::struct_unchecked(
+                        dtype,
+                        [
+                            Scalar::bool(partial.is_sorted, Nullability::NonNullable),
+                            Scalar::bool(partial.strict, Nullability::NonNullable),
+                            first_value.clone(),
+                            first_value.clone(),
+                        ],
+                    )
+                }
+            }
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.is_sorted = true;
+        partial.first_value = None;
+        partial.last_value = None;
+    }
+
+    #[inline]
+    fn is_saturated(&self, partial: &Self::Partial) -> bool {
+        !partial.is_sorted
+    }
+
+    fn accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &Columnar,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        if !partial.is_sorted {
+            return Ok(());
+        }
+
+        match batch {
+            Columnar::Constant(c) => {
+                // Constant arrays are sorted but not strict sorted (if len > 1).
+                let value = c.scalar().clone().into_nullable();
+                if partial.strict && c.len() > 1 {
+                    partial.is_sorted = false;
+                }
+
+                // Check boundary with previous chunk.
+                if let Some(ref self_last) = partial.last_value {
+                    if !self_last.is_null() && !value.is_null() {
+                        let boundary_ok = if partial.strict {
+                            *self_last < value
+                        } else {
+                            *self_last <= value
+                        };
+                        if !boundary_ok {
+                            partial.is_sorted = false;
+                        }
+                    } else if (!self_last.is_null() && value.is_null())
+                        || (self_last.is_null() && value.is_null() && partial.strict)
+                    {
+                        partial.is_sorted = false;
+                    }
+                }
+
+                if partial.first_value.is_none() {
+                    partial.first_value = Some(value.clone());
+                }
+                partial.last_value = Some(value);
+                Ok(())
+            }
+            Columnar::Canonical(c) => {
+                if c.is_empty() {
+                    return Ok(());
+                }
+
+                let array_ref = c.clone().into_array();
+
+                // Check boundary with previous chunk.
+                let first_value = array_ref.scalar_at(0)?.into_nullable();
+                if let Some(ref self_last) = partial.last_value {
+                    if !self_last.is_null() && !first_value.is_null() {
+                        let boundary_ok = if partial.strict {
+                            *self_last < first_value
+                        } else {
+                            *self_last <= first_value
+                        };
+                        if !boundary_ok {
+                            partial.is_sorted = false;
+                            partial.last_value =
+                                Some(array_ref.scalar_at(array_ref.len() - 1)?.into_nullable());
+                            if partial.first_value.is_none() {
+                                partial.first_value = Some(first_value);
+                            }
+                            return Ok(());
+                        }
+                    } else if (!self_last.is_null() && first_value.is_null())
+                        || (self_last.is_null() && first_value.is_null() && partial.strict)
+                    {
+                        partial.is_sorted = false;
+                        partial.last_value =
+                            Some(array_ref.scalar_at(array_ref.len() - 1)?.into_nullable());
+                        if partial.first_value.is_none() {
+                            partial.first_value = Some(first_value);
+                        }
+                        return Ok(());
+                    }
+                }
+
+                // Check within-batch sortedness.
+                let batch_is_sorted = match c {
+                    Canonical::Primitive(p) => check_primitive_sorted(p, partial.strict)?,
+                    Canonical::Bool(b) => check_bool_sorted(b, partial.strict)?,
+                    Canonical::VarBinView(v) => check_varbinview_sorted(v, partial.strict)?,
+                    Canonical::Decimal(d) => check_decimal_sorted(d, partial.strict)?,
+                    Canonical::Extension(e) => check_extension_sorted(e, partial.strict, ctx)?,
+                    Canonical::Null(_) => !partial.strict,
+                    // Struct, List, FixedSizeList should have been filtered out by return_dtype
+                    _ => unreachable!(),
+                };
+
+                if !batch_is_sorted {
+                    partial.is_sorted = false;
+                }
+
+                if partial.first_value.is_none() {
+                    partial.first_value = Some(first_value);
+                }
+                partial.last_value =
+                    Some(array_ref.scalar_at(array_ref.len() - 1)?.into_nullable());
+                Ok(())
+            }
+        }
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        partials.get_item(NAMES.get(0).vortex_expect("out of bounds").clone())
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        if partial.first_value.is_none() {
+            // Empty accumulator → vacuously sorted.
+            return Ok(Scalar::bool(true, Nullability::NonNullable));
+        }
+        Ok(Scalar::bool(partial.is_sorted, Nullability::NonNullable))
+    }
+}
+
+#[expect(
+    clippy::wrong_self_convention,
+    reason = "is_* naming follows Iterator::is_sorted convention"
+)]
+/// Helper methods to check sortedness with strictness.
+pub trait IsSortedIteratorExt: Iterator
+where
+    <Self as Iterator>::Item: PartialOrd,
+{
+    fn is_strict_sorted(self) -> bool
+    where
+        Self: Sized,
+        Self::Item: PartialOrd,
+    {
+        self.is_sorted_by(|a, b| a < b)
+    }
+}
+
+impl<T> IsSortedIteratorExt for T
+where
+    T: Iterator + ?Sized,
+    T::Item: PartialOrd,
+{
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::is_sorted::is_sorted;
+    use crate::aggregate_fn::fns::is_sorted::is_strict_sorted;
+    use crate::arrays::BoolArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::validity::Validity;
+
+    // Tests migrated from compute/is_sorted.rs
+    #[test]
+    fn test_is_sorted() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array();
+        assert!(is_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 2, 3),
+            Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(is_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 2, 3),
+            Validity::Array(BoolArray::from_iter([true, false, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(!is_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(buffer!(0, 1, 3, 2), Validity::AllValid).into_array();
+        assert!(!is_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 3, 2),
+            Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(!is_sorted(&arr, &mut ctx)?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_is_strict_sorted() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array();
+        assert!(is_strict_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 2, 3),
+            Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(is_strict_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 2, 3),
+            Validity::Array(BoolArray::from_iter([true, false, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(!is_strict_sorted(&arr, &mut ctx)?);
+
+        let arr = PrimitiveArray::new(
+            buffer!(0, 1, 3, 2),
+            Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
+        )
+        .into_array();
+        assert!(!is_strict_sorted(&arr, &mut ctx)?);
+
+        Ok(())
+    }
+
+    // Tests migrated from arrays/primitive/compute/is_sorted.rs
+    #[rstest]
+    #[case(PrimitiveArray::from_iter([1, 2, 3, 4, 5]), true)]
+    #[case(PrimitiveArray::from_iter([1, 1, 2, 3, 4, 5]), true)]
+    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(2)]), true)]
+    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1)]), true)]
+    #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
+    fn test_primitive_is_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(
+            is_sorted(&array.into_array(), &mut ctx)
+                .vortex_expect("operation should succeed in test"),
+            expected
+        );
+    }
+
+    #[rstest]
+    #[case(PrimitiveArray::from_iter([1, 2, 3, 4, 5]), true)]
+    #[case(PrimitiveArray::from_iter([1, 1, 2, 3, 4, 5]), false)]
+    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(2), None]), false)]
+    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1), None]), false)]
+    #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
+    fn test_primitive_is_strict_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(
+            is_strict_sorted(&array.into_array(), &mut ctx)
+                .vortex_expect("operation should succeed in test"),
+            expected
+        );
+    }
+
+    // Tests migrated from arrays/decimal/compute/is_sorted.rs
+    #[test]
+    fn test_decimal_is_sorted() -> VortexResult<()> {
+        use arrow_array::types::Decimal128Type;
+        use arrow_cast::parse::parse_decimal;
+
+        use crate::arrays::DecimalArray;
+        use crate::dtype::DecimalDType;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DecimalDType::new(19, 2);
+        let i100 =
+            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
+        let i200 =
+            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();
+
+        let sorted = buffer![i100, i200, i200];
+        let unsorted = buffer![i200, i100, i200];
+
+        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);
+        let unsorted_array = DecimalArray::new(unsorted, dtype, Validity::NonNullable);
+
+        assert!(is_sorted(&sorted_array.into_array(), &mut ctx)?);
+        assert!(!is_sorted(&unsorted_array.into_array(), &mut ctx)?);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_decimal_is_strict_sorted() -> VortexResult<()> {
+        use arrow_array::types::Decimal128Type;
+        use arrow_cast::parse::parse_decimal;
+
+        use crate::arrays::DecimalArray;
+        use crate::dtype::DecimalDType;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DecimalDType::new(19, 2);
+        let i100 =
+            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
+        let i200 =
+            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();
+        let i300 =
+            parse_decimal::<Decimal128Type>("300.00", dtype.precision(), dtype.scale()).unwrap();
+
+        let strict_sorted = buffer![i100, i200, i300];
+        let sorted = buffer![i100, i200, i200];
+
+        let dtype = DecimalDType::new(19, 2);
+
+        let strict_sorted_array = DecimalArray::new(strict_sorted, dtype, Validity::NonNullable);
+        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);
+
+        assert!(is_strict_sorted(
+            &strict_sorted_array.into_array(),
+            &mut ctx
+        )?);
+        assert!(!is_strict_sorted(&sorted_array.into_array(), &mut ctx)?);
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/primitive.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/primitive.rs
new file mode 100644
index 00000000000..21c80e7bd45
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/primitive.rs
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::IsSortedIteratorExt;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::primitive::NativeValue;
+use crate::dtype::NativePType;
+use crate::match_each_native_ptype;
+
+pub(super) fn check_primitive_sorted(array: &PrimitiveArray, strict: bool) -> VortexResult<bool> {
+    match_each_native_ptype!(array.ptype(), |P| { compute_is_sorted::<P>(array, strict) })
+}
+
+fn compute_is_sorted<T: NativePType>(array: &PrimitiveArray, strict: bool) -> VortexResult<bool> {
+    match array.validity_mask()? {
+        Mask::AllFalse(_) => Ok(!strict),
+        Mask::AllTrue(_) => {
+            let slice = array.as_slice::<T>();
+            let iter = slice.iter().copied().map(NativeValue);
+
+            Ok(if strict {
+                iter.is_strict_sorted()
+            } else {
+                iter.is_sorted()
+            })
+        }
+        Mask::Values(mask_values) => {
+            let iter = mask_values
+                .bit_buffer()
+                .iter()
+                .zip_eq(array.as_slice::<T>())
+                .map(|(is_valid, value)| is_valid.then_some(NativeValue(*value)));
+
+            Ok(if strict {
+                iter.is_strict_sorted()
+            } else {
+                iter.is_sorted()
+            })
+        }
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/varbin.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/varbin.rs
new file mode 100644
index 00000000000..84529ef16c7
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/varbin.rs
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::IsSortedIteratorExt;
+use crate::accessor::ArrayAccessor;
+use crate::arrays::VarBinViewArray;
+
+pub(super) fn check_varbinview_sorted(array: &VarBinViewArray, strict: bool) -> VortexResult<bool> {
+    Ok(if strict {
+        array.with_iterator(|bytes_iter| bytes_iter.is_strict_sorted())
+    } else {
+        array.with_iterator(|bytes_iter| bytes_iter.is_sorted())
+    })
+}
diff --git a/vortex-array/src/aggregate_fn/fns/last/mod.rs b/vortex-array/src/aggregate_fn/fns/last/mod.rs
new file mode 100644
index 00000000000..009b487ad2d
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/last/mod.rs
@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::scalar::Scalar;
+
+/// Return the last non-null value of an array.
+///
+/// See [`Last`] for details.
+pub fn last(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Scalar> {
+    let mut acc = Accumulator::try_new(Last, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    acc.finish()
+}
+
+/// Return the last non-null value seen across all batches.
+#[derive(Clone, Debug)]
+pub struct Last;
+
+/// Partial accumulator state for the [`Last`] aggregate.
+pub struct LastPartial {
+    /// The nullable version of the input dtype, used for the result and for empty/all-null inputs.
+    return_dtype: DType,
+    /// The last non-null value seen so far, or `None` if no non-null value has been observed.
+    value: Option<Scalar>,
+}
+
+impl AggregateFnVTable for Last {
+    type Options = EmptyOptions;
+    type Partial = LastPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.last")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("Last is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        Some(input_dtype.as_nullable())
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(LastPartial {
+            return_dtype: input_dtype.as_nullable(),
+            value: None,
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        // Each new non-null partial replaces the previous one; nulls are ignored.
+        if !other.is_null() {
+            partial.value = Some(other);
+        }
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        Ok(match &partial.value {
+            Some(v) => v.clone(),
+            None => Scalar::null(partial.return_dtype.clone()),
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.value = None;
+    }
+
+    #[inline]
+    fn is_saturated(&self, _partial: &Self::Partial) -> bool {
+        // Last can never short-circuit: a later batch can always supersede the current value.
+        false
+    }
+
+    fn try_accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<bool> {
+        if let Some(idx) = batch.validity_mask()?.last() {
+            let scalar = batch.scalar_at(idx)?;
+            partial.value = Some(scalar.into_nullable());
+        }
+        Ok(true)
+    }
+
+    fn accumulate(
+        &self,
+        _partial: &mut Self::Partial,
+        _batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        unreachable!("Last::try_accumulate handles all arrays")
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::last::Last;
+    use crate::aggregate_fn::fns::last::last;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::VarBinArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    #[test]
+    fn last_non_null() -> VortexResult<()> {
+        let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(30i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_skips_trailing_nulls() -> VortexResult<()> {
+        let array =
+            PrimitiveArray::from_option_iter([Some(7i32), Some(8), None, None]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(8i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_all_null() -> VortexResult<()> {
+        let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype));
+        Ok(())
+    }
+
+    #[test]
+    fn last_empty() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result, Scalar::null(DType::Primitive(PType::I32, Nullable)));
+        Ok(())
+    }
+
+    #[test]
+    fn last_constant() -> VortexResult<()> {
+        let array = ConstantArray::new(42i32, 10).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_constant_null() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype));
+        Ok(())
+    }
+
+    #[test]
+    fn last_varbin() -> VortexResult<()> {
+        let array = VarBinArray::from_iter(
+            vec![Some("hello"), Some("world"), None],
+            DType::Utf8(Nullable),
+        )
+        .into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(last(&array, &mut ctx)?, Scalar::utf8("world", Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_multi_batch_picks_latest_non_null() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullable);
+        let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::from_option_iter([Some(1i32), Some(2)]).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+
+        // All-null batch must not clobber the previously-stored value.
+        let batch2 = PrimitiveArray::from_option_iter::<i32, _>([None, None]).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+
+        let batch3 = PrimitiveArray::from_option_iter([Some(99i32), None]).into_array();
+        acc.accumulate(&batch3, &mut ctx)?;
+
+        // Last is never saturated; later batches keep updating it.
+        assert!(!acc.is_saturated());
+
+        let result = acc.finish()?;
+        assert_eq!(result, Scalar::primitive(99i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        assert_eq!(acc.finish()?, Scalar::primitive(20i32, Nullable));
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 6, 9], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        assert_eq!(acc.finish()?, Scalar::primitive(9i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut state = Last.empty_partial(&EmptyOptions, &dtype)?;
+
+        Last.combine_partials(&mut state, Scalar::primitive(5i32, Nullable))?;
+        assert_eq!(Last.to_scalar(&state)?, Scalar::primitive(5i32, Nullable));
+
+        // A later non-null partial replaces the prior value.
+        Last.combine_partials(&mut state, Scalar::primitive(7i32, Nullable))?;
+        assert_eq!(Last.to_scalar(&state)?, Scalar::primitive(7i32, Nullable));
+
+        // A null partial must not clobber the stored value.
+        Last.combine_partials(&mut state, Scalar::null(dtype.as_nullable()))?;
+        assert_eq!(Last.to_scalar(&state)?, Scalar::primitive(7i32, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn last_chunked() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter([Some(42i32), Some(100)]);
+        let chunk2 = PrimitiveArray::from_option_iter::<i32, _>([None, None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(
+            last(&chunked.into_array(), &mut ctx)?,
+            Scalar::primitive(100i32, Nullable)
+        );
+        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
new file mode 100644
index 00000000000..557598489e6
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/min_max/bool.rs
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::BitAnd;
+
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::MinMaxPartial;
+use super::MinMaxResult;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::dtype::Nullability::NonNullable;
+use crate::scalar::Scalar;
+
+pub(super) fn accumulate_bool(partial: &mut MinMaxPartial, array: &BoolArray) -> VortexResult<()> {
+    if array.is_empty() {
+        return Ok(());
+    }
+
+    let mask = array.validity_mask()?;
+    let true_non_null = match &mask {
+        Mask::AllTrue(_) => array.to_bit_buffer(),
+        Mask::AllFalse(_) => return Ok(()),
+        Mask::Values(v) => array.to_bit_buffer().bitand(v.bit_buffer()),
+    };
+
+    let mut true_slices = true_non_null.set_slices();
+
+    let Some(slice) = true_slices.next() else {
+        // all false
+        partial.merge(Some(MinMaxResult {
+            min: Scalar::bool(false, NonNullable),
+            max: Scalar::bool(false, NonNullable),
+        }));
+        return Ok(());
+    };
+
+    if slice.0 == 0 && slice.1 == array.len() {
+        // all true
+        partial.merge(Some(MinMaxResult {
+            min: Scalar::bool(true, NonNullable),
+            max: Scalar::bool(true, NonNullable),
+        }));
+        return Ok(());
+    }
+
+    // Check for valid false values when we have a partial validity mask
+    match &mask {
+        Mask::AllTrue(_) | Mask::AllFalse(_) => {}
+        Mask::Values(v) => {
+            let false_non_null = (!array.to_bit_buffer()).bitand(v.bit_buffer());
+            let mut false_slices = false_non_null.set_slices();
+
+            if false_slices.next().is_none() {
+                // No false values, so all valid values are true
+                partial.merge(Some(MinMaxResult {
+                    min: Scalar::bool(true, NonNullable),
+                    max: Scalar::bool(true, NonNullable),
+                }));
+                return Ok(());
+            }
+        }
+    }
+
+    partial.merge(Some(MinMaxResult {
+        min: Scalar::bool(false, NonNullable),
+        max: Scalar::bool(true, NonNullable),
+    }));
+    Ok(())
+}
diff --git a/vortex-array/src/arrays/decimal/compute/min_max.rs b/vortex-array/src/aggregate_fn/fns/min_max/decimal.rs
similarity index 52%
rename from vortex-array/src/arrays/decimal/compute/min_max.rs
rename to vortex-array/src/aggregate_fn/fns/min_max/decimal.rs
index ca0ba190e43..93400f37275 100644
--- a/vortex-array/src/arrays/decimal/compute/min_max.rs
+++ b/vortex-array/src/aggregate_fn/fns/min_max/decimal.rs
@@ -5,30 +5,27 @@ use itertools::Itertools;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use super::MinMaxPartial;
+use super::MinMaxResult;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
 use crate::dtype::DecimalDType;
 use crate::dtype::NativeDecimalType;
 use crate::dtype::Nullability::NonNullable;
 use crate::match_each_decimal_value_type;
-use crate::register_kernel;
 use crate::scalar::DecimalValue;
 use crate::scalar::Scalar;
 
-impl MinMaxKernel for DecimalVTable {
-    fn min_max(&self, array: &DecimalArray) -> VortexResult<Option<MinMaxResult>> {
-        match_each_decimal_value_type!(array.values_type(), |T| {
-            compute_min_max_with_validity::<T>(array)
-        })
-    }
+pub(super) fn accumulate_decimal(
+    partial: &mut MinMaxPartial,
+    array: &DecimalArray,
+) -> VortexResult<()> {
+    match_each_decimal_value_type!(array.values_type(), |T| {
+        let local = compute_min_max_with_validity::<T>(array)?;
+        partial.merge(local);
+        Ok(())
+    })
 }
 
-register_kernel!(MinMaxKernelAdapter(DecimalVTable).lift());
-
-#[inline]
 fn compute_min_max_with_validity<D>(array: &DecimalArray) -> VortexResult<Option<MinMaxResult>>
 where
     D: Into<DecimalValue> + NativeDecimalType,
@@ -69,44 +66,3 @@ where
         }),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::arrays::DecimalArray;
-    use crate::compute::MinMaxResult;
-    use crate::compute::min_max;
-    use crate::dtype::DecimalDType;
-    use crate::scalar::DecimalValue;
-    use crate::scalar::Scalar;
-    use crate::scalar::ScalarValue;
-    use crate::validity::Validity;
-
-    #[test]
-    fn min_max_test() {
-        let decimal = DecimalArray::new(
-            buffer![100i32, 2000i32, 200i32],
-            DecimalDType::new(4, 2),
-            Validity::from_iter([true, false, true]),
-        );
-
-        let min_max = min_max(decimal.as_ref()).unwrap();
-
-        let non_nullable_dtype = decimal.dtype().as_nonnullable();
-        let expected = MinMaxResult {
-            min: Scalar::try_new(
-                non_nullable_dtype.clone(),
-                Some(ScalarValue::from(DecimalValue::from(100i32))),
-            )
-            .unwrap(),
-            max: Scalar::try_new(
-                non_nullable_dtype,
-                Some(ScalarValue::from(DecimalValue::from(200i32))),
-            )
-            .unwrap(),
-        };
-
-        assert_eq!(Some(expected), min_max)
-    }
-}
diff --git a/vortex-array/src/aggregate_fn/fns/min_max/extension.rs b/vortex-array/src/aggregate_fn/fns/min_max/extension.rs
new file mode 100644
index 00000000000..60962dd008e
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/min_max/extension.rs
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use super::MinMaxPartial;
+use super::MinMaxResult;
+use super::min_max;
+use crate::ExecutionCtx;
+use crate::arrays::ExtensionArray;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::dtype::Nullability;
+use crate::scalar::Scalar;
+
+pub(super) fn accumulate_extension(
+    partial: &mut MinMaxPartial,
+    array: &ExtensionArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let non_nullable_ext_dtype = array.ext_dtype().with_nullability(Nullability::NonNullable);
+    let local =
+        min_max(array.storage_array(), ctx)?.map(|MinMaxResult { min, max }| MinMaxResult {
+            min: Scalar::extension_ref(non_nullable_ext_dtype.clone(), min),
+            max: Scalar::extension_ref(non_nullable_ext_dtype, max),
+        });
+    partial.merge(local);
+    Ok(())
+}
diff --git a/vortex-array/src/aggregate_fn/fns/min_max/mod.rs b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs
new file mode 100644
index 00000000000..91d178a4814
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs
@@ -0,0 +1,652 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod bool;
+mod decimal;
+mod extension;
+mod primitive;
+mod varbin;
+
+use std::sync::LazyLock;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use self::bool::accumulate_bool;
+use self::decimal::accumulate_decimal;
+use self::extension::accumulate_extension;
+use self::primitive::accumulate_primitive;
+use self::varbin::accumulate_varbinview;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::dtype::FieldNames;
+use crate::dtype::Nullability;
+use crate::dtype::StructFields;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+use crate::partial_ord::partial_max;
+use crate::partial_ord::partial_min;
+use crate::scalar::Scalar;
+
+static NAMES: LazyLock<FieldNames> = LazyLock::new(|| FieldNames::from(["min", "max"]));
+
+/// The minimum and maximum non-null values of an array, or `None` if there are no non-null values.
+///
+/// The result scalars have the non-nullable version of the array dtype.
+/// This will update the stats set of the array as a side effect.
+pub fn min_max(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Option<MinMaxResult>> {
+    // Short-circuit using cached array statistics.
+    let cached_min = array
+        .statistics()
+        .get(Stat::Min)
+        .and_then(Precision::as_exact);
+    let cached_max = array
+        .statistics()
+        .get(Stat::Max)
+        .and_then(Precision::as_exact);
+    if let Some((min, max)) = cached_min.zip(cached_max) {
+        let non_nullable_dtype = array.dtype().as_nonnullable();
+        return Ok(Some(MinMaxResult {
+            min: min.cast(&non_nullable_dtype)?,
+            max: max.cast(&non_nullable_dtype)?,
+        }));
+    }
+
+    // Short-circuit for empty arrays or all-null arrays.
+    if array.is_empty() || array.valid_count()? == 0 {
+        return Ok(None);
+    }
+
+    // Short-circuit for unsupported dtypes.
+    if MinMax.return_dtype(&EmptyOptions, array.dtype()).is_none() {
+        return Ok(None);
+    }
+
+    // Compute using Accumulator<MinMax>.
+    let mut acc = Accumulator::try_new(MinMax, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    let result_scalar = acc.finish()?;
+    let result = MinMaxResult::from_scalar(result_scalar)?;
+
+    // Cache the computed min/max as statistics.
+    if let Some(ref r) = result {
+        if let Some(min_value) = r.min.value() {
+            array
+                .statistics()
+                .set(Stat::Min, Precision::Exact(min_value.clone()));
+        }
+        if let Some(max_value) = r.max.value() {
+            array
+                .statistics()
+                .set(Stat::Max, Precision::Exact(max_value.clone()));
+        }
+    }
+
+    Ok(result)
+}
+
+/// The minimum and maximum non-null values of an array.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MinMaxResult {
+    pub min: Scalar,
+    pub max: Scalar,
+}
+
+impl MinMaxResult {
+    /// Extract a `MinMaxResult` from a struct scalar with `{min, max}` fields.
+    pub fn from_scalar(scalar: Scalar) -> VortexResult<Option<Self>> {
+        if scalar.is_null() {
+            Ok(None)
+        } else {
+            let min = scalar
+                .as_struct()
+                .field_by_idx(0)
+                .vortex_expect("missing min field");
+            let max = scalar
+                .as_struct()
+                .field_by_idx(1)
+                .vortex_expect("missing max field");
+            Ok(Some(MinMaxResult { min, max }))
+        }
+    }
+}
+
+/// Compute the min and max of an array.
+///
+/// Returns a nullable struct scalar `{min: T, max: T}` where `T` is the non-nullable input dtype.
+/// The struct is null when the array is empty or all-null.
+#[derive(Clone, Debug)]
+pub struct MinMax;
+
+/// Partial accumulator state for min/max.
+pub struct MinMaxPartial {
+    min: Option<Scalar>,
+    max: Option<Scalar>,
+    element_dtype: DType,
+}
+
+impl MinMaxPartial {
+    /// Merge a local `MinMaxResult` into this partial state.
+    fn merge(&mut self, local: Option<MinMaxResult>) {
+        let Some(MinMaxResult { min, max }) = local else {
+            return;
+        };
+
+        self.min = Some(match self.min.take() {
+            Some(current) => partial_min(min, current).vortex_expect("incomparable min scalars"),
+            None => min,
+        });
+
+        self.max = Some(match self.max.take() {
+            Some(current) => partial_max(max, current).vortex_expect("incomparable max scalars"),
+            None => max,
+        });
+    }
+}
+
+/// Creates the struct dtype `{min: T, max: T}` (nullable) used for min/max aggregate results.
+pub fn make_minmax_dtype(element_dtype: &DType) -> DType {
+    DType::Struct(
+        StructFields::new(
+            NAMES.clone(),
+            vec![
+                element_dtype.as_nonnullable(),
+                element_dtype.as_nonnullable(),
+            ],
+        ),
+        Nullability::Nullable,
+    )
+}
+
+impl AggregateFnVTable for MinMax {
+    type Options = EmptyOptions;
+    type Partial = MinMaxPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.min_max")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("MinMax is not yet serializable");
+    }
+
+    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,
+        }
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(MinMaxPartial {
+            min: None,
+            max: None,
+            element_dtype: input_dtype.clone(),
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        let local = MinMaxResult::from_scalar(other)?;
+        partial.merge(local);
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        let dtype = make_minmax_dtype(&partial.element_dtype);
+        Ok(match (&partial.min, &partial.max) {
+            (Some(min), Some(max)) => Scalar::struct_(dtype, vec![min.clone(), max.clone()]),
+            _ => Scalar::null(dtype),
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.min = None;
+        partial.max = None;
+    }
+
+    #[inline]
+    fn is_saturated(&self, _partial: &Self::Partial) -> bool {
+        false
+    }
+
+    fn accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &Columnar,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        match batch {
+            Columnar::Constant(c) => {
+                let scalar = c.scalar();
+                if scalar.is_null() {
+                    return Ok(());
+                }
+                // Skip NaN float constants
+                if scalar.as_primitive_opt().is_some_and(|p| p.is_nan()) {
+                    return Ok(());
+                }
+                let non_nullable_dtype = scalar.dtype().as_nonnullable();
+                let cast = scalar.cast(&non_nullable_dtype)?;
+                partial.merge(Some(MinMaxResult {
+                    min: cast.clone(),
+                    max: cast,
+                }));
+                Ok(())
+            }
+            Columnar::Canonical(c) => match c {
+                Canonical::Primitive(p) => accumulate_primitive(partial, p),
+                Canonical::Bool(b) => accumulate_bool(partial, b),
+                Canonical::VarBinView(v) => accumulate_varbinview(partial, v),
+                Canonical::Decimal(d) => accumulate_decimal(partial, d),
+                Canonical::Extension(e) => accumulate_extension(partial, e, ctx),
+                Canonical::Null(_) => Ok(()),
+                Canonical::Struct(_)
+                | Canonical::List(_)
+                | Canonical::FixedSizeList(_)
+                | Canonical::Variant(_) => {
+                    vortex_bail!("Unsupported canonical type for min_max: {}", batch.dtype())
+                }
+            },
+        }
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::BitBuffer;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray as _;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::min_max::MinMax;
+    use crate::aggregate_fn::fns::min_max::MinMaxResult;
+    use crate::aggregate_fn::fns::min_max::min_max;
+    use crate::arrays::BoolArray;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::DecimalArray;
+    use crate::arrays::NullArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::VarBinArray;
+    use crate::dtype::DType;
+    use crate::dtype::DecimalDType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::scalar::DecimalValue;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+    use crate::validity::Validity;
+
+    #[test]
+    fn test_prim_min_max() -> VortexResult<()> {
+        let p = PrimitiveArray::new(buffer![1, 2, 3], Validity::NonNullable).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(
+            min_max(&p, &mut ctx)?,
+            Some(MinMaxResult {
+                min: 1.into(),
+                max: 3.into()
+            })
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_bool_min_max() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let all_true = BoolArray::new(
+            BitBuffer::from([true, true, true].as_slice()),
+            Validity::NonNullable,
+        )
+        .into_array();
+        assert_eq!(
+            min_max(&all_true, &mut ctx)?,
+            Some(MinMaxResult {
+                min: true.into(),
+                max: true.into()
+            })
+        );
+
+        let all_false = BoolArray::new(
+            BitBuffer::from([false, false, false].as_slice()),
+            Validity::NonNullable,
+        )
+        .into_array();
+        assert_eq!(
+            min_max(&all_false, &mut ctx)?,
+            Some(MinMaxResult {
+                min: false.into(),
+                max: false.into()
+            })
+        );
+
+        let mixed = BoolArray::new(
+            BitBuffer::from([false, true, false].as_slice()),
+            Validity::NonNullable,
+        )
+        .into_array();
+        assert_eq!(
+            min_max(&mixed, &mut ctx)?,
+            Some(MinMaxResult {
+                min: false.into(),
+                max: true.into()
+            })
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_null_array() -> VortexResult<()> {
+        let p = NullArray::new(1).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(min_max(&p, &mut ctx)?, None);
+        Ok(())
+    }
+
+    #[test]
+    fn test_prim_nan() -> VortexResult<()> {
+        let array = PrimitiveArray::new(
+            buffer![f32::NAN, -f32::NAN, -1.0, 1.0],
+            Validity::NonNullable,
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = min_max(&array.into_array(), &mut ctx)?.vortex_expect("should have result");
+        assert_eq!(f32::try_from(&result.min)?, -1.0);
+        assert_eq!(f32::try_from(&result.max)?, 1.0);
+        Ok(())
+    }
+
+    #[test]
+    fn test_prim_inf() -> VortexResult<()> {
+        let array = PrimitiveArray::new(
+            buffer![f32::INFINITY, f32::NEG_INFINITY, -1.0, 1.0],
+            Validity::NonNullable,
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = min_max(&array.into_array(), &mut ctx)?.vortex_expect("should have result");
+        assert_eq!(f32::try_from(&result.min)?, f32::NEG_INFINITY);
+        assert_eq!(f32::try_from(&result.max)?, f32::INFINITY);
+        Ok(())
+    }
+
+    #[test]
+    fn test_multi_batch() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(MinMax, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20, 5], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 25], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+
+        let result = MinMaxResult::from_scalar(acc.finish()?)?.vortex_expect("should have result");
+        assert_eq!(result.min, Scalar::from(3i32));
+        assert_eq!(result.max, Scalar::from(25i32));
+        Ok(())
+    }
+
+    #[test]
+    fn test_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(MinMax, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        let result1 = MinMaxResult::from_scalar(acc.finish()?)?.vortex_expect("should have result");
+        assert_eq!(result1.min, Scalar::from(10i32));
+        assert_eq!(result1.max, Scalar::from(20i32));
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 6, 9], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        let result2 = MinMaxResult::from_scalar(acc.finish()?)?.vortex_expect("should have result");
+        assert_eq!(result2.min, Scalar::from(3i32));
+        assert_eq!(result2.max, Scalar::from(9i32));
+        Ok(())
+    }
+
+    #[test]
+    fn test_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut state = MinMax.empty_partial(&EmptyOptions, &dtype)?;
+
+        let struct_dtype = crate::aggregate_fn::fns::min_max::make_minmax_dtype(&dtype);
+        let scalar1 = Scalar::struct_(
+            struct_dtype.clone(),
+            vec![Scalar::from(5i32), Scalar::from(15i32)],
+        );
+        MinMax.combine_partials(&mut state, scalar1)?;
+
+        let scalar2 = Scalar::struct_(struct_dtype, vec![Scalar::from(2i32), Scalar::from(10i32)]);
+        MinMax.combine_partials(&mut state, scalar2)?;
+
+        let result = MinMaxResult::from_scalar(MinMax.to_scalar(&state)?)?
+            .vortex_expect("should have result");
+        assert_eq!(result.min, Scalar::from(2i32));
+        assert_eq!(result.max, Scalar::from(15i32));
+        Ok(())
+    }
+
+    #[test]
+    fn test_constant_nan() -> VortexResult<()> {
+        let scalar = Scalar::primitive(f16::NAN, Nullability::NonNullable);
+        let array = ConstantArray::new(scalar, 2).into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(min_max(&array, &mut ctx)?, None);
+        Ok(())
+    }
+
+    #[test]
+    fn test_chunked() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter([Some(5i32), None, Some(1)]);
+        let chunk2 = PrimitiveArray::from_option_iter([Some(10i32), Some(3), None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = min_max(&chunked.into_array(), &mut ctx)?.vortex_expect("should have result");
+        assert_eq!(result.min, Scalar::from(1i32));
+        assert_eq!(result.max, Scalar::from(10i32));
+        Ok(())
+    }
+
+    #[test]
+    fn test_all_null() -> VortexResult<()> {
+        let p = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(min_max(&p.into_array(), &mut ctx)?, None);
+        Ok(())
+    }
+
+    #[test]
+    fn test_varbin() -> VortexResult<()> {
+        let array = VarBinArray::from_iter(
+            vec![
+                Some("hello world"),
+                None,
+                Some("hello world this is a long string"),
+                None,
+            ],
+            DType::Utf8(Nullability::Nullable),
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = min_max(&array.into_array(), &mut ctx)?.vortex_expect("should have result");
+        assert_eq!(
+            result.min,
+            Scalar::utf8("hello world", Nullability::NonNullable)
+        );
+        assert_eq!(
+            result.max,
+            Scalar::utf8(
+                "hello world this is a long string",
+                Nullability::NonNullable
+            )
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_decimal() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![100i32, 2000i32, 200i32],
+            DecimalDType::new(4, 2),
+            Validity::from_iter([true, false, true]),
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = min_max(&decimal.into_array(), &mut ctx)?.vortex_expect("should have result");
+
+        let non_nullable_dtype = DType::Decimal(DecimalDType::new(4, 2), Nullability::NonNullable);
+        let expected_min = Scalar::try_new(
+            non_nullable_dtype.clone(),
+            Some(ScalarValue::from(DecimalValue::from(100i32))),
+        )?;
+        let expected_max = Scalar::try_new(
+            non_nullable_dtype,
+            Some(ScalarValue::from(DecimalValue::from(200i32))),
+        )?;
+        assert_eq!(result.min, expected_min);
+        assert_eq!(result.max, expected_max);
+        Ok(())
+    }
+
+    use crate::dtype::half::f16;
+
+    #[test]
+    fn test_bool_with_nulls() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let result = min_max(
+            &BoolArray::from_iter(vec![Some(true), Some(true), None, None]).into_array(),
+            &mut ctx,
+        )?;
+        assert_eq!(
+            result,
+            Some(MinMaxResult {
+                min: Scalar::bool(true, Nullability::NonNullable),
+                max: Scalar::bool(true, Nullability::NonNullable),
+            })
+        );
+
+        let result = min_max(
+            &BoolArray::from_iter(vec![None, Some(true), Some(true)]).into_array(),
+            &mut ctx,
+        )?;
+        assert_eq!(
+            result,
+            Some(MinMaxResult {
+                min: Scalar::bool(true, Nullability::NonNullable),
+                max: Scalar::bool(true, Nullability::NonNullable),
+            })
+        );
+
+        let result = min_max(
+            &BoolArray::from_iter(vec![None, Some(true), Some(true), None]).into_array(),
+            &mut ctx,
+        )?;
+        assert_eq!(
+            result,
+            Some(MinMaxResult {
+                min: Scalar::bool(true, Nullability::NonNullable),
+                max: Scalar::bool(true, Nullability::NonNullable),
+            })
+        );
+
+        let result = min_max(
+            &BoolArray::from_iter(vec![Some(false), Some(false), None, None]).into_array(),
+            &mut ctx,
+        )?;
+        assert_eq!(
+            result,
+            Some(MinMaxResult {
+                min: Scalar::bool(false, Nullability::NonNullable),
+                max: Scalar::bool(false, Nullability::NonNullable),
+            })
+        );
+        Ok(())
+    }
+
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/7074>.
+    ///
+    /// A chunked all-true bool array with an empty first chunk returned min=false because
+    /// `accumulate_bool` on the empty chunk incorrectly merged min=false,max=false into the
+    /// partial state.
+    #[test]
+    fn test_bool_chunked_with_empty_chunk() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let empty = BoolArray::new(BitBuffer::from([].as_slice()), Validity::NonNullable);
+        let chunk1 = BoolArray::new(
+            BitBuffer::from([true, true].as_slice()),
+            Validity::NonNullable,
+        );
+        let chunk2 = BoolArray::new(
+            BitBuffer::from([true, true, true].as_slice()),
+            Validity::NonNullable,
+        );
+        let chunked = ChunkedArray::try_new(
+            vec![empty.into_array(), chunk1.into_array(), chunk2.into_array()],
+            DType::Bool(Nullability::NonNullable),
+        )?;
+
+        let result = min_max(&chunked.into_array(), &mut ctx)?;
+        assert_eq!(
+            result,
+            Some(MinMaxResult {
+                min: Scalar::bool(true, Nullability::NonNullable),
+                max: Scalar::bool(true, Nullability::NonNullable),
+            })
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_varbin_all_nulls() -> VortexResult<()> {
+        let array = VarBinArray::from_iter(
+            vec![Option::<&str>::None, None, None],
+            DType::Utf8(Nullability::Nullable),
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(min_max(&array.into_array(), &mut ctx)?, None);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/primitive/compute/min_max.rs b/vortex-array/src/aggregate_fn/fns/min_max/primitive.rs
similarity index 50%
rename from vortex-array/src/arrays/primitive/compute/min_max.rs
rename to vortex-array/src/aggregate_fn/fns/min_max/primitive.rs
index 387756d5588..1332fa7dd88 100644
--- a/vortex-array/src/arrays/primitive/compute/min_max.rs
+++ b/vortex-array/src/aggregate_fn/fns/min_max/primitive.rs
@@ -5,29 +5,26 @@ use itertools::Itertools;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use super::MinMaxPartial;
+use super::MinMaxResult;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability::NonNullable;
 use crate::match_each_native_ptype;
-use crate::register_kernel;
 use crate::scalar::PValue;
 use crate::scalar::Scalar;
 
-impl MinMaxKernel for PrimitiveVTable {
-    fn min_max(&self, array: &PrimitiveArray) -> VortexResult<Option<MinMaxResult>> {
-        match_each_native_ptype!(array.ptype(), |T| {
-            compute_min_max_with_validity::<T>(array)
-        })
-    }
+pub(super) fn accumulate_primitive(
+    partial: &mut MinMaxPartial,
+    p: &PrimitiveArray,
+) -> VortexResult<()> {
+    match_each_native_ptype!(p.ptype(), |T| {
+        let local = compute_min_max_with_validity::<T>(p)?;
+        partial.merge(local);
+        Ok(())
+    })
 }
 
-register_kernel!(MinMaxKernelAdapter(PrimitiveVTable).lift());
-
-#[inline]
 fn compute_min_max_with_validity<T>(array: &PrimitiveArray) -> VortexResult<Option<MinMaxResult>>
 where
     T: NativePType,
@@ -51,8 +48,6 @@ where
     T: NativePType,
     PValue: From<T>,
 {
-    // `total_compare` function provides a total ordering (even for NaN values).
-    // However, we exclude NaNs from min max as they're not useful for any purpose where min/max would be used
     match iter
         .filter(|v| !v.is_nan())
         .minmax_by(|a, b| a.total_compare(**b))
@@ -71,34 +66,3 @@ where
         }),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::min_max;
-    use crate::validity::Validity;
-
-    #[test]
-    fn min_max_nan() {
-        let array = PrimitiveArray::new(
-            buffer![f32::NAN, -f32::NAN, -1.0, 1.0],
-            Validity::NonNullable,
-        );
-        let min_max = min_max(array.as_ref()).unwrap().unwrap();
-        assert_eq!(f32::try_from(&min_max.min).unwrap(), -1.0);
-        assert_eq!(f32::try_from(&min_max.max).unwrap(), 1.0);
-    }
-
-    #[test]
-    fn min_max_inf() {
-        let array = PrimitiveArray::new(
-            buffer![f32::INFINITY, f32::NEG_INFINITY, -1.0, 1.0],
-            Validity::NonNullable,
-        );
-        let min_max = min_max(array.as_ref()).unwrap().unwrap();
-        assert_eq!(f32::try_from(&min_max.min).unwrap(), f32::NEG_INFINITY);
-        assert_eq!(f32::try_from(&min_max.max).unwrap(), f32::INFINITY);
-    }
-}
diff --git a/vortex-array/src/aggregate_fn/fns/min_max/varbin.rs b/vortex-array/src/aggregate_fn/fns/min_max/varbin.rs
new file mode 100644
index 00000000000..a64cf80a240
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/min_max/varbin.rs
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+
+use super::MinMaxPartial;
+use super::MinMaxResult;
+use crate::accessor::ArrayAccessor;
+use crate::arrays::VarBinViewArray;
+use crate::dtype::DType;
+use crate::dtype::Nullability::NonNullable;
+use crate::scalar::Scalar;
+
+pub(super) fn accumulate_varbinview(
+    partial: &mut MinMaxPartial,
+    array: &VarBinViewArray,
+) -> VortexResult<()> {
+    partial.merge(varbin_compute_min_max(array, array.dtype()));
+    Ok(())
+}
+
+fn varbin_compute_min_max<T: ArrayAccessor<[u8]>>(
+    array: &T,
+    dtype: &DType,
+) -> Option<MinMaxResult> {
+    array.with_iterator(|iter| match iter.flatten().minmax() {
+        itertools::MinMaxResult::NoElements => None,
+        itertools::MinMaxResult::OneElement(value) => {
+            let scalar = make_scalar(dtype, value);
+            Some(MinMaxResult {
+                min: scalar.clone(),
+                max: scalar,
+            })
+        }
+        itertools::MinMaxResult::MinMax(min, max) => Some(MinMaxResult {
+            min: make_scalar(dtype, min),
+            max: make_scalar(dtype, max),
+        }),
+    })
+}
+
+fn make_scalar(dtype: &DType, value: &[u8]) -> Scalar {
+    match dtype {
+        DType::Binary(_) => Scalar::binary(value.to_vec(), NonNullable),
+        DType::Utf8(_) => {
+            // SAFETY: VarBin arrays always validate their data against their dtype.
+            let value = unsafe { str::from_utf8_unchecked(value) };
+            Scalar::utf8(value, NonNullable)
+        }
+        _ => vortex_panic!("cannot make Scalar from bytes with dtype {dtype}"),
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/mod.rs b/vortex-array/src/aggregate_fn/fns/mod.rs
new file mode 100644
index 00000000000..38d5340cd1f
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/mod.rs
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+pub mod count;
+pub mod first;
+pub mod is_constant;
+pub mod is_sorted;
+pub mod last;
+pub mod min_max;
+pub mod nan_count;
+pub mod sum;
diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs
new file mode 100644
index 00000000000..9a1a8e4793b
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs
@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod primitive;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+
+use self::primitive::accumulate_primitive;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::dtype::Nullability::NonNullable;
+use crate::dtype::PType;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+use crate::scalar::Scalar;
+use crate::scalar::ScalarValue;
+
+/// Return the number of NaN values in an array.
+///
+/// See [`NanCount`] for details.
+pub fn nan_count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<usize> {
+    // Short-circuit using cached array statistics.
+    if let Some(Precision::Exact(nan_count_scalar)) = array.statistics().get(Stat::NaNCount) {
+        return usize::try_from(&nan_count_scalar)
+            .map_err(|e| vortex_err!("Failed to convert NaN count stat to usize: {e}"));
+    }
+
+    // Short-circuit for non-float types.
+    if NanCount
+        .return_dtype(&EmptyOptions, array.dtype())
+        .is_none()
+    {
+        return Ok(0);
+    }
+
+    // Short-circuit for empty arrays or all-null arrays.
+    if array.is_empty() || array.valid_count()? == 0 {
+        return Ok(0);
+    }
+
+    // Compute using Accumulator<NanCount>.
+    let mut acc = Accumulator::try_new(NanCount, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    let result = acc.finish()?;
+
+    let count = result
+        .as_primitive()
+        .typed_value::<u64>()
+        .vortex_expect("nan_count result should not be null");
+    let count_usize = usize::try_from(count).vortex_expect("Cannot be more nans than usize::MAX");
+
+    // Cache the computed NaN count as a statistic.
+    array
+        .statistics()
+        .set(Stat::NaNCount, Precision::Exact(ScalarValue::from(count)));
+
+    Ok(count_usize)
+}
+
+/// Count the number of NaN values in an array.
+///
+/// Only applies to floating-point primitive types. Returns a `u64` count.
+/// If the array is all-invalid, the NaN count is zero.
+#[derive(Clone, Debug)]
+pub struct NanCount;
+
+impl AggregateFnVTable for NanCount {
+    type Options = EmptyOptions;
+    type Partial = u64;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.nan_count")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("NanCount is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        if let DType::Primitive(ptype, ..) = input_dtype
+            && ptype.is_float()
+        {
+            Some(DType::Primitive(PType::U64, NonNullable))
+        } else {
+            None
+        }
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        _input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        Ok(0u64)
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        let val = other
+            .as_primitive()
+            .typed_value::<u64>()
+            .vortex_expect("nan_count partial should not be null");
+        *partial += val;
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        Ok(Scalar::primitive(*partial, NonNullable))
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        *partial = 0;
+    }
+
+    #[inline]
+    fn is_saturated(&self, _partial: &Self::Partial) -> bool {
+        false
+    }
+
+    fn accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        match batch {
+            Columnar::Constant(c) => {
+                if c.scalar().is_null() {
+                    // Null values are not NaN.
+                    return Ok(());
+                }
+                if c.scalar().as_primitive().is_nan() {
+                    *partial += c.len() as u64;
+                }
+                Ok(())
+            }
+            Columnar::Canonical(c) => match c {
+                Canonical::Primitive(p) => accumulate_primitive(partial, p),
+                _ => vortex_bail!(
+                    "Unsupported canonical type for nan_count: {}",
+                    batch.dtype()
+                ),
+            },
+        }
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::nan_count::NanCount;
+    use crate::aggregate_fn::fns::nan_count::nan_count;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    #[test]
+    fn nan_count_multi_batch() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?;
+
+        let batch1 =
+            PrimitiveArray::new(buffer![f64::NAN, 1.0f64, f64::NAN], Validity::NonNullable)
+                .into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+
+        let batch2 =
+            PrimitiveArray::new(buffer![2.0f64, f64::NAN], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?;
+
+        let batch1 =
+            PrimitiveArray::new(buffer![f64::NAN, 1.0f64], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        let result1 = acc.finish()?;
+        assert_eq!(result1.as_primitive().typed_value::<u64>(), Some(1));
+
+        let batch2 = PrimitiveArray::new(buffer![f64::NAN, f64::NAN, 2.0], Validity::NonNullable)
+            .into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        let result2 = acc.finish()?;
+        assert_eq!(result2.as_primitive().typed_value::<u64>(), Some(2));
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+        let mut state = NanCount.empty_partial(&EmptyOptions, &dtype)?;
+
+        let scalar1 = Scalar::primitive(5u64, Nullability::NonNullable);
+        NanCount.combine_partials(&mut state, scalar1)?;
+
+        let scalar2 = Scalar::primitive(3u64, Nullability::NonNullable);
+        NanCount.combine_partials(&mut state, scalar2)?;
+
+        let result = NanCount.to_scalar(&state)?;
+        NanCount.reset(&mut state);
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(8));
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_constant_nan() -> VortexResult<()> {
+        let array = ConstantArray::new(f64::NAN, 10);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 10);
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_constant_non_nan() -> VortexResult<()> {
+        let array = ConstantArray::new(1.0f64, 10);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 0);
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_empty() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_chunked() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter([Some(f64::NAN), None, Some(1.0)]);
+        let chunk2 = PrimitiveArray::from_option_iter([Some(f64::NAN), Some(f64::NAN), None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&chunked.into_array(), &mut ctx)?, 3);
+        Ok(())
+    }
+
+    #[test]
+    fn nan_count_all_null() -> VortexResult<()> {
+        let p = PrimitiveArray::from_option_iter::<f64, _>([None, None, None]);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs
new file mode 100644
index 00000000000..34781bafbd7
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use crate::arrays::PrimitiveArray;
+use crate::dtype::NativePType;
+use crate::match_each_float_ptype;
+
+pub(super) fn accumulate_primitive(count: &mut u64, p: &PrimitiveArray) -> VortexResult<()> {
+    match_each_float_ptype!(p.ptype(), |F| {
+        *count += compute_nan_count_with_validity(p.as_slice::<F>(), p.validity_mask()?) as u64;
+    });
+    Ok(())
+}
+
+fn compute_nan_count_with_validity<T: NativePType>(values: &[T], validity: Mask) -> usize {
+    match validity {
+        Mask::AllTrue(_) => values.iter().filter(|v| v.is_nan()).count(),
+        Mask::AllFalse(_) => 0,
+        Mask::Values(v) => values
+            .iter()
+            .zip(v.bit_buffer().iter())
+            .filter_map(|(v, m)| m.then_some(v))
+            .filter(|v| v.is_nan())
+            .count(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::nan_count::nan_count;
+    use crate::arrays::PrimitiveArray;
+    use crate::validity::Validity;
+
+    #[test]
+    fn primitive_nan_count() -> VortexResult<()> {
+        let p = PrimitiveArray::new(
+            buffer![
+                -f32::NAN,
+                f32::NAN,
+                0.1,
+                1.1,
+                -0.0,
+                f32::INFINITY,
+                f32::NEG_INFINITY
+            ],
+            Validity::NonNullable,
+        );
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2);
+        Ok(())
+    }
+
+    #[test]
+    fn primitive_nan_count_with_nulls() -> VortexResult<()> {
+        let p = PrimitiveArray::from_option_iter([Some(f64::NAN), None, Some(f64::NAN), Some(1.0)]);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2);
+        Ok(())
+    }
+
+    #[test]
+    fn primitive_nan_count_all_valid_no_nans() -> VortexResult<()> {
+        let p = PrimitiveArray::new(buffer![1.0f64, 2.0, 3.0], Validity::NonNullable);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/bool.rs b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
new file mode 100644
index 00000000000..f80023e0b57
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::BitAnd;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_mask::AllOr;
+
+use super::SumState;
+use super::checked_add_u64;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
+
+pub(super) fn accumulate_bool(inner: &mut SumState, b: &BoolArray) -> VortexResult<bool> {
+    let SumState::Unsigned(acc) = inner else {
+        vortex_panic!("expected unsigned sum state for bool input");
+    };
+
+    let mask = b.validity_mask()?;
+    let true_count = match mask.bit_buffer() {
+        AllOr::None => return Ok(false),
+        AllOr::All => b.to_bit_buffer().true_count() as u64,
+        AllOr::Some(validity) => b.to_bit_buffer().bitand(validity).true_count() as u64,
+    };
+
+    Ok(checked_add_u64(acc, true_count))
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::sum::Sum;
+    use crate::aggregate_fn::fns::sum::sum;
+    use crate::arrays::BoolArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::executor::VortexSessionExecute;
+
+    #[test]
+    fn sum_bool_all_true() -> VortexResult<()> {
+        let arr: BoolArray = [true, true, true].into_iter().collect();
+        let result = sum(
+            &arr.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_mixed() -> VortexResult<()> {
+        let arr: BoolArray = [true, false, true, false, true].into_iter().collect();
+        let result = sum(
+            &arr.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_all_false() -> VortexResult<()> {
+        let arr: BoolArray = [false, false, false].into_iter().collect();
+        let result = sum(
+            &arr.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_with_nulls() -> VortexResult<()> {
+        let arr = BoolArray::from_iter([Some(true), None, Some(true), Some(false)]);
+        let result = sum(
+            &arr.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(2));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_all_null() -> VortexResult<()> {
+        let arr = BoolArray::from_iter([None::<bool>, None, None]);
+        let result = sum(
+            &arr.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_empty_produces_zero() -> VortexResult<()> {
+        let dtype = DType::Bool(Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Bool(Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+
+        let batch1: BoolArray = [true, true, false].into_iter().collect();
+        acc.accumulate(&batch1.into_array(), &mut ctx)?;
+        let result1 = acc.finish()?;
+        assert_eq!(result1.as_primitive().typed_value::<u64>(), Some(2));
+
+        let batch2: BoolArray = [false, true].into_iter().collect();
+        acc.accumulate(&batch2.into_array(), &mut ctx)?;
+        let result2 = acc.finish()?;
+        assert_eq!(result2.as_primitive().typed_value::<u64>(), Some(1));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_bool_return_dtype() -> VortexResult<()> {
+        let dtype = Sum
+            .return_dtype(&EmptyOptions, &DType::Bool(Nullability::NonNullable))
+            .unwrap();
+        assert_eq!(dtype, DType::Primitive(PType::U64, Nullability::Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_boolean_from_iter() -> VortexResult<()> {
+        let arr = BoolArray::from_iter([true, false, false, true]).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().as_::<i32>(), Some(2));
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/constant.rs b/vortex-array/src/aggregate_fn/fns/sum/constant.rs
new file mode 100644
index 00000000000..c55b66a71cc
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/constant.rs
@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::scalar::DecimalValue;
+use crate::scalar::Scalar;
+
+/// Compute `scalar * len` for a constant array, returning the product as a sum-typed scalar.
+///
+/// Returns `Ok(None)` if the scalar is null (no contribution to the sum).
+/// Returns a null scalar on overflow (saturation).
+pub(super) fn multiply_constant(
+    scalar: &Scalar,
+    len: usize,
+    return_dtype: &DType,
+) -> VortexResult<Option<Scalar>> {
+    if scalar.is_null() || len == 0 {
+        return Ok(None);
+    }
+
+    let product = match scalar.dtype() {
+        DType::Bool(_) => {
+            let val = scalar
+                .as_bool()
+                .value()
+                .ok_or_else(|| vortex_err!("Expected non-null bool scalar for sum"))?;
+            if !val {
+                return Ok(None);
+            }
+            Scalar::primitive(len as u64, Nullability::Nullable)
+        }
+        DType::Primitive(..) => {
+            let pvalue = scalar
+                .as_primitive()
+                .pvalue()
+                .ok_or_else(|| vortex_err!("Expected non-null primitive scalar for sum"))?;
+            match return_dtype {
+                DType::Primitive(PType::U64, _) => {
+                    let val = pvalue.cast::<u64>()?;
+                    match val.checked_mul(len as u64) {
+                        Some(product) => Scalar::primitive(product, Nullability::Nullable),
+                        None => Scalar::null(return_dtype.as_nullable()),
+                    }
+                }
+                DType::Primitive(PType::I64, _) => {
+                    let val = pvalue.cast::<i64>()?;
+                    match i64::try_from(len).ok().and_then(|l| val.checked_mul(l)) {
+                        Some(product) => Scalar::primitive(product, Nullability::Nullable),
+                        None => Scalar::null(return_dtype.as_nullable()),
+                    }
+                }
+                DType::Primitive(PType::F64, _) => {
+                    let val = pvalue.cast::<f64>()?;
+                    Scalar::primitive(val * len as f64, Nullability::Nullable)
+                }
+                _ => vortex_bail!(
+                    "Unexpected return dtype for primitive sum: {}",
+                    return_dtype
+                ),
+            }
+        }
+        DType::Decimal(..) => {
+            let val = scalar
+                .as_decimal()
+                .decimal_value()
+                .ok_or_else(|| vortex_err!("Expected non-null decimal scalar for sum"))?;
+            let len_decimal = DecimalValue::from(len as i128);
+            match val.checked_mul(&len_decimal) {
+                Some(product) => {
+                    let ret_decimal = *return_dtype
+                        .as_decimal_opt()
+                        .ok_or_else(|| vortex_err!("Expected decimal return dtype"))?;
+                    Scalar::decimal(product, ret_decimal, Nullability::Nullable)
+                }
+                None => Scalar::null(return_dtype.as_nullable()),
+            }
+        }
+        _ => vortex_bail!("Unsupported constant type for sum: {}", scalar.dtype()),
+    };
+
+    Ok(Some(product))
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::sum::sum;
+    use crate::arrays::ConstantArray;
+    use crate::dtype::DType;
+    use crate::dtype::DecimalDType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::dtype::i256;
+    use crate::expr::stats::Stat;
+    use crate::scalar::DecimalValue;
+    use crate::scalar::Scalar;
+
+    #[test]
+    fn sum_constant_unsigned() -> VortexResult<()> {
+        let array = ConstantArray::new(5u64, 10).into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, 50u64.into());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_signed() -> VortexResult<()> {
+        let array = ConstantArray::new(-5i64, 10).into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, (-50i64).into());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_nullable_value() -> VortexResult<()> {
+        let array = ConstantArray::new(Scalar::null(DType::Primitive(PType::U32, Nullable)), 10)
+            .into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, Scalar::primitive(0u64, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_bool_false() -> VortexResult<()> {
+        let array = ConstantArray::new(false, 10).into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, 0u64.into());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_bool_true() -> VortexResult<()> {
+        let array = ConstantArray::new(true, 10).into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, 10u64.into());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_bool_null() -> VortexResult<()> {
+        let array = ConstantArray::new(Scalar::null(DType::Bool(Nullable)), 10).into_array();
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, Scalar::primitive(0u64, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_decimal() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let array = ConstantArray::new(
+            Scalar::decimal(
+                DecimalValue::I64(100),
+                decimal_dtype,
+                Nullability::NonNullable,
+            ),
+            5,
+        )
+        .into_array();
+
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+
+        assert_eq!(
+            result.as_decimal().decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(500)))
+        );
+        assert_eq!(result.dtype(), &Stat::Sum.dtype(array.dtype()).unwrap());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_decimal_null() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let array = ConstantArray::new(Scalar::null(DType::Decimal(decimal_dtype, Nullable)), 10)
+            .into_array();
+
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(
+            result,
+            Scalar::decimal(
+                DecimalValue::I256(i256::ZERO),
+                DecimalDType::new(20, 2),
+                Nullable
+            )
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_constant_decimal_large_value() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let array = ConstantArray::new(
+            Scalar::decimal(
+                DecimalValue::I64(999_999_999),
+                decimal_dtype,
+                Nullability::NonNullable,
+            ),
+            100,
+        )
+        .into_array();
+
+        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(
+            result.as_decimal().decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(99_999_999_900)))
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/decimal.rs b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs
new file mode 100644
index 00000000000..91fd48e73ea
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs
@@ -0,0 +1,465 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use num_traits::AsPrimitive;
+use num_traits::CheckedAdd;
+use num_traits::NumOps;
+use vortex_buffer::BitBuffer;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_mask::Mask;
+
+use super::SumState;
+use crate::arrays::DecimalArray;
+use crate::dtype::DecimalDType;
+use crate::dtype::DecimalType;
+use crate::dtype::NativeDecimalType;
+use crate::match_each_decimal_value_type;
+use crate::scalar::DecimalValue;
+
+/// Accumulate a decimal array into the sum state.
+/// Returns Ok(true) if saturated (overflow), Ok(false) if not.
+pub(super) fn accumulate_decimal(inner: &mut SumState, d: &DecimalArray) -> VortexResult<bool> {
+    let mask = d.validity_mask()?;
+    let validity = match &mask {
+        Mask::AllTrue(_) => None,
+        Mask::Values(mask_values) => Some(mask_values.bit_buffer()),
+        Mask::AllFalse(_) => {
+            return Ok(false);
+        }
+    };
+
+    let SumState::Decimal { value, dtype } = inner else {
+        vortex_panic!("expected decimal sum state for decimal input");
+    };
+
+    let values_type = DecimalType::smallest_decimal_value_type(dtype);
+    match_each_decimal_value_type!(d.values_type(), |T| {
+        match_each_decimal_value_type!(values_type, |I| {
+            let initial: I = value
+                .cast()
+                .vortex_expect("cannot fail to cast initial value");
+            match sum_decimal_value(initial, d.buffer::<T>(), validity, *dtype) {
+                Some(v) => *value = v,
+                None => return Ok(true),
+            }
+            Ok(false)
+        })
+    })
+}
+
+fn sum_decimal_value<T, I>(
+    initial: I,
+    values: Buffer<T>,
+    validity: Option<&BitBuffer>,
+    output_dtype: DecimalDType,
+) -> Option<DecimalValue>
+where
+    T: AsPrimitive<I>,
+    I: NumOps + CheckedAdd + Copy + NativeDecimalType + 'static,
+    bool: AsPrimitive<I>,
+    DecimalValue: From<I>,
+{
+    let sum = match validity {
+        Some(v) => sum_decimal_with_validity(values, v, initial),
+        None => sum_decimal(values, initial),
+    };
+
+    sum.map(DecimalValue::from)
+        // We have to make sure that the decimal value fits the precision of the decimal dtype.
+        .filter(|v| v.fits_in_precision(output_dtype))
+}
+
+fn sum_decimal<T: AsPrimitive<I>, I: Copy + CheckedAdd + 'static>(
+    values: Buffer<T>,
+    initial: I,
+) -> Option<I> {
+    let mut sum = initial;
+    for v in values.iter() {
+        let v: I = v.as_();
+        sum = CheckedAdd::checked_add(&sum, &v)?;
+    }
+    Some(sum)
+}
+
+fn sum_decimal_with_validity<T, I>(values: Buffer<T>, validity: &BitBuffer, initial: I) -> Option<I>
+where
+    T: AsPrimitive<I>,
+    I: NumOps + CheckedAdd + Copy + 'static,
+    bool: AsPrimitive<I>,
+{
+    let mut sum = initial;
+    for (v, valid) in values.iter().zip_eq(validity) {
+        let v: I = v.as_() * valid.as_();
+
+        sum = CheckedAdd::checked_add(&sum, &v)?;
+    }
+    Some(sum)
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::sum::Sum;
+    use crate::aggregate_fn::fns::sum::sum;
+    use crate::arrays::DecimalArray;
+    use crate::dtype::DType;
+    use crate::dtype::DecimalDType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::i256;
+    use crate::scalar::DecimalValue;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+    use crate::validity::Validity;
+
+    #[test]
+    fn sum_decimal_basic() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![100i32, 200i32, 300i32],
+            DecimalDType::new(4, 2),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(600i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_with_nulls() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![100i32, 200i32, 300i32, 400i32],
+            DecimalDType::new(4, 2),
+            Validity::from_iter([true, false, true, true]),
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(14, 2), Nullable),
+            Some(ScalarValue::from(DecimalValue::from(800i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_negative_values() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![100i32, -200i32, 300i32, -50i32],
+            DecimalDType::new(4, 2),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(150i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_near_i32_max() -> VortexResult<()> {
+        let near_max = i32::MAX - 1000;
+        let decimal = DecimalArray::new(
+            buffer![near_max, 500i32, 400i32],
+            DecimalDType::new(10, 2),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected_sum = near_max as i64 + 500 + 400;
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(20, 2), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_large_i64_values() -> VortexResult<()> {
+        let large_val = i64::MAX / 4;
+        let decimal = DecimalArray::new(
+            buffer![large_val, large_val, large_val, large_val + 1],
+            DecimalDType::new(19, 0),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected_sum = (large_val as i128) * 4 + 1;
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(29, 0), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_preserves_scale() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![12345i32, 67890i32, 11111i32],
+            DecimalDType::new(6, 4),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(16, 4), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(91346i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_single_value() -> VortexResult<()> {
+        let decimal =
+            DecimalArray::new(buffer![42i32], DecimalDType::new(3, 1), Validity::AllValid);
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(13, 1), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(42i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_all_nulls_except_one() -> VortexResult<()> {
+        let decimal = DecimalArray::new(
+            buffer![100i32, 200i32, 300i32, 400i32],
+            DecimalDType::new(4, 2),
+            Validity::from_iter([false, false, true, false]),
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(14, 2), Nullable),
+            Some(ScalarValue::from(DecimalValue::from(300i32))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_overflow_detection() -> VortexResult<()> {
+        let max_val = i128::MAX / 2;
+        let decimal = DecimalArray::new(
+            buffer![max_val, max_val, max_val],
+            DecimalDType::new(38, 0),
+            Validity::AllValid,
+        );
+
+        let result = sum(
+            &decimal.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+
+        let expected_sum =
+            i256::from_i128(max_val) + i256::from_i128(max_val) + i256::from_i128(max_val);
+        let expected = Scalar::try_new(
+            DType::Decimal(DecimalDType::new(48, 0), Nullability::NonNullable),
+            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
+        )?;
+
+        assert_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_i256_overflow() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(76, 0);
+        let decimal = DecimalArray::new(
+            buffer![i256::MAX, i256::MAX, i256::MAX],
+            decimal_dtype,
+            Validity::AllValid,
+        );
+
+        assert_eq!(
+            sum(
+                &decimal.into_array(),
+                &mut LEGACY_SESSION.create_execution_ctx()
+            )
+            .vortex_expect("operation should succeed in test"),
+            Scalar::null(DType::Decimal(decimal_dtype, Nullable))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_near_precision_boundary() -> VortexResult<()> {
+        // Input precision 4 → return precision min(76, 4+10) = 14.
+        // Native type for precision 14 is I64 (max precision 18), so 14 < 18.
+        // Use combine_partials to push state near (but under) 10^14.
+        let input_dtype = DType::Decimal(DecimalDType::new(4, 0), Nullability::NonNullable);
+        let mut state = Sum.empty_partial(&EmptyOptions, &input_dtype)?;
+
+        let near_limit = Scalar::decimal(
+            DecimalValue::from(99_999_999_999_990i64),
+            DecimalDType::new(14, 0),
+            Nullable,
+        );
+        Sum.combine_partials(&mut state, near_limit)?;
+
+        // Add a small value that keeps us just under 10^14.
+        let small = Scalar::decimal(DecimalValue::from(9i64), DecimalDType::new(14, 0), Nullable);
+        Sum.combine_partials(&mut state, small)?;
+
+        let result = Sum.to_scalar(&state)?;
+        assert!(!result.is_null());
+        assert_eq!(
+            result.as_decimal().decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(99_999_999_999_999)))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_precision_overflow_within_i256() -> VortexResult<()> {
+        // Input precision 4 → return precision 14. Native I64 (max 18).
+        // The max representable value for precision 14 is 10^14 - 1.
+        // When the sum reaches exactly 10^14, fits_in_precision fails even though
+        // i256 arithmetic does not overflow. This tests the precision-based
+        // saturation path in combine_partials.
+        let input_dtype = DType::Decimal(DecimalDType::new(4, 0), Nullability::NonNullable);
+        let mut state = Sum.empty_partial(&EmptyOptions, &input_dtype)?;
+
+        let near_limit = Scalar::decimal(
+            DecimalValue::from(99_999_999_999_999i64),
+            DecimalDType::new(14, 0),
+            Nullable,
+        );
+        Sum.combine_partials(&mut state, near_limit)?;
+
+        // Push the sum to exactly 10^14, exceeding precision 14.
+        let one_more =
+            Scalar::decimal(DecimalValue::from(1i64), DecimalDType::new(14, 0), Nullable);
+        Sum.combine_partials(&mut state, one_more)?;
+
+        let result = Sum.to_scalar(&state)?;
+        assert!(result.is_null());
+        assert_eq!(
+            result.dtype(),
+            &DType::Decimal(DecimalDType::new(14, 0), Nullable)
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_precision_overflow_negative() -> VortexResult<()> {
+        // Same setup but with negative values: sum reaches -10^14.
+        let input_dtype = DType::Decimal(DecimalDType::new(4, 0), Nullability::NonNullable);
+        let mut state = Sum.empty_partial(&EmptyOptions, &input_dtype)?;
+
+        let near_limit = Scalar::decimal(
+            DecimalValue::from(-99_999_999_999_999i64),
+            DecimalDType::new(14, 0),
+            Nullable,
+        );
+        Sum.combine_partials(&mut state, near_limit)?;
+
+        let one_more = Scalar::decimal(
+            DecimalValue::from(-1i64),
+            DecimalDType::new(14, 0),
+            Nullable,
+        );
+        Sum.combine_partials(&mut state, one_more)?;
+
+        let result = Sum.to_scalar(&state)?;
+        assert!(result.is_null());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_decimal_accumulate_precision_overflow() -> VortexResult<()> {
+        // Test precision overflow via the accumulate_decimal path (not combine_partials).
+        // Input precision 28 (I128 storage) → return precision min(76, 38) = 38.
+        // Native for precision 38 is I128 (max 38), so 38 = 38.
+        // Use precision 27 → return 37. Native for 37 is I128 (max 38), so 37 < 38.
+        //
+        // We use combine_partials to get the state close to 10^37, then accumulate
+        // a real array that pushes it over.
+        let input_dtype = DType::Decimal(DecimalDType::new(27, 0), Nullability::NonNullable);
+        let return_dtype = DecimalDType::new(37, 0);
+        let mut state = Sum.empty_partial(&EmptyOptions, &input_dtype)?;
+
+        // Set state to 10^37 - 1 via combine_partials.
+        let near_limit_val: i128 = 10i128.pow(37) - 1;
+        let near_limit =
+            Scalar::decimal(DecimalValue::from(near_limit_val), return_dtype, Nullable);
+        Sum.combine_partials(&mut state, near_limit)?;
+
+        // Now accumulate a real i128 array with a single element = 1 to overflow precision.
+        let decimal =
+            DecimalArray::new(buffer![1i128], DecimalDType::new(27, 0), Validity::AllValid);
+
+        // Drive accumulate through the vtable directly.
+        let columnar = crate::Columnar::Canonical(crate::Canonical::Decimal(decimal));
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        Sum.accumulate(&mut state, &columnar, &mut ctx)?;
+
+        let result = Sum.to_scalar(&state)?;
+        assert!(result.is_null());
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/mod.rs b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
new file mode 100644
index 00000000000..4d09eac4d5b
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
@@ -0,0 +1,806 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod bool;
+mod constant;
+mod decimal;
+mod primitive;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
+
+use self::bool::accumulate_bool;
+use self::constant::multiply_constant;
+use self::decimal::accumulate_decimal;
+use self::primitive::accumulate_primitive;
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::DynAccumulator;
+use crate::aggregate_fn::EmptyOptions;
+use crate::dtype::DType;
+use crate::dtype::DecimalDType;
+use crate::dtype::MAX_PRECISION;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+use crate::scalar::DecimalValue;
+use crate::scalar::Scalar;
+
+/// Return the sum of an array.
+///
+/// See [`Sum`] for details.
+pub fn sum(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Scalar> {
+    // Short-circuit using cached array statistics.
+    if let Some(Precision::Exact(sum_scalar)) = array.statistics().get(Stat::Sum) {
+        return Ok(sum_scalar);
+    }
+
+    // Compute using Accumulator<Sum>.
+    // TODO(ngates): we may want to wrap this three-step dance up into an extension crate maybe.
+    let mut acc = Accumulator::try_new(Sum, EmptyOptions, array.dtype().clone())?;
+    acc.accumulate(array, ctx)?;
+    let result = acc.finish()?;
+
+    // Cache the computed sum as a statistic (only if non-null, i.e. no overflow).
+    if let Some(val) = result.value().cloned() {
+        array.statistics().set(Stat::Sum, Precision::Exact(val));
+    }
+
+    Ok(result)
+}
+
+/// Sum an array, starting from zero.
+///
+/// If the sum overflows, a null scalar will be returned.
+/// If the array is all-invalid, the sum will be zero.
+#[derive(Clone, Debug)]
+pub struct Sum;
+
+impl AggregateFnVTable for Sum {
+    type Options = EmptyOptions;
+    type Partial = SumPartial;
+
+    fn id(&self) -> AggregateFnId {
+        AggregateFnId::new_ref("vortex.sum")
+    }
+
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        unimplemented!("Sum is not yet serializable");
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        // When a sum overflows, we return a sum _value_ of null. Therefore, we all return dtypes
+        // are nullable.
+        use Nullability::Nullable;
+
+        Some(match input_dtype {
+            DType::Bool(_) => DType::Primitive(PType::U64, Nullable),
+            DType::Primitive(ptype, _) => match ptype {
+                PType::U8 | PType::U16 | PType::U32 | PType::U64 => {
+                    DType::Primitive(PType::U64, Nullable)
+                }
+                PType::I8 | PType::I16 | PType::I32 | PType::I64 => {
+                    DType::Primitive(PType::I64, Nullable)
+                }
+                PType::F16 | PType::F32 | PType::F64 => {
+                    // Float sums cannot overflow, but all null floats still end up as null
+                    DType::Primitive(PType::F64, Nullable)
+                }
+            },
+            DType::Decimal(decimal_dtype, _) => {
+                // Both Spark and DataFusion use this heuristic.
+                // - https://github.com/apache/spark/blob/fcf636d9eb8d645c24be3db2d599aba2d7e2955a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Sum.scala#L66
+                // - https://github.com/apache/datafusion/blob/4153adf2c0f6e317ef476febfdc834208bd46622/datafusion/functions-aggregate/src/sum.rs#L188
+                let precision = u8::min(MAX_PRECISION, decimal_dtype.precision() + 10);
+                DType::Decimal(
+                    DecimalDType::new(precision, decimal_dtype.scale()),
+                    Nullable,
+                )
+            }
+            // Unsupported types
+            _ => return None,
+        })
+    }
+
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+        self.return_dtype(options, input_dtype)
+    }
+
+    fn empty_partial(
+        &self,
+        options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        let return_dtype = self
+            .return_dtype(options, input_dtype)
+            .ok_or_else(|| vortex_err!("Unsupported sum dtype: {}", input_dtype))?;
+        let initial = make_zero_state(&return_dtype);
+
+        Ok(SumPartial {
+            return_dtype,
+            current: Some(initial),
+        })
+    }
+
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()> {
+        if other.is_null() {
+            // A null partial means the sub-accumulator saturated (overflow).
+            partial.current = None;
+            return Ok(());
+        }
+        let Some(ref mut inner) = partial.current else {
+            return Ok(());
+        };
+        let saturated = match inner {
+            SumState::Unsigned(acc) => {
+                let val = other
+                    .as_primitive()
+                    .typed_value::<u64>()
+                    .vortex_expect("checked non-null");
+                checked_add_u64(acc, val)
+            }
+            SumState::Signed(acc) => {
+                let val = other
+                    .as_primitive()
+                    .typed_value::<i64>()
+                    .vortex_expect("checked non-null");
+                checked_add_i64(acc, val)
+            }
+            SumState::Float(acc) => {
+                let val = other
+                    .as_primitive()
+                    .typed_value::<f64>()
+                    .vortex_expect("checked non-null");
+                *acc += val;
+                false
+            }
+            SumState::Decimal { value, dtype } => {
+                let val = other
+                    .as_decimal()
+                    .decimal_value()
+                    .vortex_expect("checked non-null");
+                match value.checked_add(&val) {
+                    Some(r) => {
+                        *value = r;
+                        !value.fits_in_precision(*dtype)
+                    }
+                    None => true,
+                }
+            }
+        };
+        if saturated {
+            partial.current = None;
+        }
+        Ok(())
+    }
+
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        Ok(match &partial.current {
+            None => Scalar::null(partial.return_dtype.as_nullable()),
+            Some(SumState::Unsigned(v)) => Scalar::primitive(*v, Nullability::Nullable),
+            Some(SumState::Signed(v)) => Scalar::primitive(*v, Nullability::Nullable),
+            Some(SumState::Float(v)) => Scalar::primitive(*v, Nullability::Nullable),
+            Some(SumState::Decimal { value, .. }) => {
+                let decimal_dtype = *partial
+                    .return_dtype
+                    .as_decimal_opt()
+                    .vortex_expect("return dtype must be decimal");
+                Scalar::decimal(*value, decimal_dtype, Nullability::Nullable)
+            }
+        })
+    }
+
+    fn reset(&self, partial: &mut Self::Partial) {
+        partial.current = Some(make_zero_state(&partial.return_dtype));
+    }
+
+    #[inline]
+    fn is_saturated(&self, partial: &Self::Partial) -> bool {
+        match partial.current.as_ref() {
+            None => true,
+            Some(SumState::Float(v)) => v.is_nan(),
+            Some(_) => false,
+        }
+    }
+
+    fn accumulate(
+        &self,
+        partial: &mut Self::Partial,
+        batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        // Constants compute scalar * len and combine via combine_partials.
+        if let Columnar::Constant(c) = batch {
+            if let Some(product) = multiply_constant(c.scalar(), c.len(), &partial.return_dtype)? {
+                self.combine_partials(partial, product)?;
+            }
+            return Ok(());
+        }
+
+        let mut inner = match partial.current.take() {
+            Some(inner) => inner,
+            None => return Ok(()),
+        };
+
+        let result = match batch {
+            Columnar::Canonical(c) => match c {
+                Canonical::Primitive(p) => accumulate_primitive(&mut inner, p),
+                Canonical::Bool(b) => accumulate_bool(&mut inner, b),
+                Canonical::Decimal(d) => accumulate_decimal(&mut inner, d),
+                _ => vortex_bail!("Unsupported canonical type for sum: {}", batch.dtype()),
+            },
+            Columnar::Constant(_) => unreachable!(),
+        };
+
+        match result {
+            Ok(false) => partial.current = Some(inner),
+            Ok(true) => {} // saturated: current stays None
+            Err(e) => {
+                partial.current = Some(inner);
+                return Err(e);
+            }
+        }
+        Ok(())
+    }
+
+    fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+        Ok(partials)
+    }
+
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        self.to_scalar(partial)
+    }
+}
+
+/// The group state for a sum aggregate, containing the accumulated value and configuration
+/// needed for reset/result without external context.
+pub struct SumPartial {
+    return_dtype: DType,
+    /// The current accumulated state, or `None` if saturated (checked overflow).
+    current: Option<SumState>,
+}
+
+/// The accumulated sum value.
+///
+// TODO(ngates): instead of an enum, we should use a Box<dyn State> to avoid dispatcher over the
+//  input type every time? Perhaps?
+pub enum SumState {
+    Unsigned(u64),
+    Signed(i64),
+    Float(f64),
+    Decimal {
+        value: DecimalValue,
+        dtype: DecimalDType,
+    },
+}
+
+fn make_zero_state(return_dtype: &DType) -> SumState {
+    match return_dtype {
+        DType::Primitive(ptype, _) => match ptype {
+            PType::U8 | PType::U16 | PType::U32 | PType::U64 => SumState::Unsigned(0),
+            PType::I8 | PType::I16 | PType::I32 | PType::I64 => SumState::Signed(0),
+            PType::F16 | PType::F32 | PType::F64 => SumState::Float(0.0),
+        },
+        DType::Decimal(decimal, _) => SumState::Decimal {
+            value: DecimalValue::zero(decimal),
+            dtype: *decimal,
+        },
+        _ => vortex_panic!("Unsupported sum type"),
+    }
+}
+
+/// Checked add for u64, returning true if overflow occurred.
+#[inline(always)]
+fn checked_add_u64(acc: &mut u64, val: u64) -> bool {
+    match acc.checked_add(val) {
+        Some(r) => {
+            *acc = r;
+            false
+        }
+        None => true,
+    }
+}
+
+/// Checked add for i64, returning true if overflow occurred.
+#[inline(always)]
+fn checked_add_i64(acc: &mut i64, val: i64) -> bool {
+    match acc.checked_add(val) {
+        Some(r) => {
+            *acc = r;
+            false
+        }
+        None => true,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use num_traits::CheckedAdd;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::DynAccumulator;
+    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::BoolArray;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::DecimalArray;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::dtype::DType;
+    use crate::dtype::DecimalDType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::dtype::i256;
+    use crate::expr::stats::Precision;
+    use crate::expr::stats::Stat;
+    use crate::expr::stats::StatsProvider;
+    use crate::scalar::DecimalValue;
+    use crate::scalar::NumericOperator;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    /// Sum an array with an initial value (test-only helper).
+    fn sum_with_accumulator(array: &ArrayRef, accumulator: &Scalar) -> VortexResult<Scalar> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        if accumulator.is_null() {
+            return Ok(accumulator.clone());
+        }
+        if accumulator.is_zero() == Some(true) {
+            return sum(array, &mut ctx);
+        }
+
+        let sum_dtype = Stat::Sum.dtype(array.dtype()).ok_or_else(|| {
+            vortex_error::vortex_err!("Sum not supported for dtype: {}", array.dtype())
+        })?;
+
+        // For non-float types, try statistics short-circuit with accumulator.
+        if !matches!(&sum_dtype, DType::Primitive(p, _) if p.is_float())
+            && let Some(Precision::Exact(sum_scalar)) = array.statistics().get(Stat::Sum)
+        {
+            return add_scalars(&sum_dtype, &sum_scalar, accumulator);
+        }
+
+        // Compute array sum from zero (also caches stats).
+        let array_sum = sum(array, &mut ctx)?;
+
+        // Combine with the accumulator.
+        add_scalars(&sum_dtype, &array_sum, accumulator)
+    }
+
+    /// Add two sum scalars with overflow checking.
+    fn add_scalars(sum_dtype: &DType, lhs: &Scalar, rhs: &Scalar) -> VortexResult<Scalar> {
+        if lhs.is_null() || rhs.is_null() {
+            return Ok(Scalar::null(sum_dtype.as_nullable()));
+        }
+
+        Ok(match sum_dtype {
+            DType::Primitive(ptype, _) if ptype.is_float() => {
+                let lhs_val = f64::try_from(lhs)?;
+                let rhs_val = f64::try_from(rhs)?;
+                Scalar::primitive(lhs_val + rhs_val, Nullable)
+            }
+            DType::Primitive(..) => lhs
+                .as_primitive()
+                .checked_add(&rhs.as_primitive())
+                .map(Scalar::from)
+                .unwrap_or_else(|| Scalar::null(sum_dtype.as_nullable())),
+            DType::Decimal(..) => lhs
+                .as_decimal()
+                .checked_binary_numeric(&rhs.as_decimal(), NumericOperator::Add)
+                .map(Scalar::from)
+                .unwrap_or_else(|| Scalar::null(sum_dtype.as_nullable())),
+            _ => unreachable!("Sum will always be a decimal or a primitive dtype"),
+        })
+    }
+
+    // Multi-batch and reset tests
+
+    #[test]
+    fn sum_multi_batch() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 6, 9], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(48));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_finish_resets_state() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+
+        let batch1 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        acc.accumulate(&batch1, &mut ctx)?;
+        let result1 = acc.finish()?;
+        assert_eq!(result1.as_primitive().typed_value::<i64>(), Some(30));
+
+        let batch2 = PrimitiveArray::new(buffer![3i32, 6, 9], Validity::NonNullable).into_array();
+        acc.accumulate(&batch2, &mut ctx)?;
+        let result2 = acc.finish()?;
+        assert_eq!(result2.as_primitive().typed_value::<i64>(), Some(18));
+        Ok(())
+    }
+
+    // State merge tests (vtable-level)
+
+    #[test]
+    fn sum_state_merge() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut state = Sum.empty_partial(&EmptyOptions, &dtype)?;
+
+        let scalar1 = Scalar::primitive(100i64, Nullable);
+        Sum.combine_partials(&mut state, scalar1)?;
+
+        let scalar2 = Scalar::primitive(50i64, Nullable);
+        Sum.combine_partials(&mut state, scalar2)?;
+
+        let result = Sum.to_scalar(&state)?;
+        Sum.reset(&mut state);
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(150));
+        Ok(())
+    }
+
+    // Stats caching test
+
+    #[test]
+    fn sum_stats() -> VortexResult<()> {
+        let array = ChunkedArray::try_new(
+            vec![
+                PrimitiveArray::from_iter([1, 1, 1]).into_array(),
+                PrimitiveArray::from_iter([2, 2, 2]).into_array(),
+            ],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )
+        .vortex_expect("operation should succeed in test");
+        let array = array.into_array();
+        // compute sum with accumulator to populate stats
+        sum_with_accumulator(&array, &Scalar::primitive(2i64, Nullable))?;
+
+        let sum_without_acc = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(sum_without_acc, Scalar::primitive(9i64, Nullable));
+        Ok(())
+    }
+
+    // Constant float non-multiply test
+
+    #[test]
+    fn sum_constant_float_non_multiply() -> VortexResult<()> {
+        let acc = -2048669276050936500000000000f64;
+        let array = ConstantArray::new(6.1811675e16f64, 25);
+        let result = sum_with_accumulator(&array.into_array(), &Scalar::primitive(acc, Nullable))
+            .vortex_expect("operation should succeed in test");
+        assert_eq!(
+            f64::try_from(&result).vortex_expect("operation should succeed in test"),
+            -2048669274505644600000000000f64
+        );
+        Ok(())
+    }
+
+    // Grouped sum tests
+
+    fn run_grouped_sum(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()
+    }
+
+    #[test]
+    fn grouped_sum_fixed_size_list() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array();
+        let groups = FixedSizeListArray::try_new(elements, 3, Validity::NonNullable, 2)?;
+
+        let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result = run_grouped_sum(&groups.into_array(), &elem_dtype)?;
+
+        let expected = PrimitiveArray::from_option_iter([Some(6i64), Some(15i64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn grouped_sum_with_null_elements() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5), Some(6)])
+                .into_array();
+        let groups = FixedSizeListArray::try_new(elements, 3, Validity::NonNullable, 2)?;
+
+        let elem_dtype = DType::Primitive(PType::I32, Nullable);
+        let result = run_grouped_sum(&groups.into_array(), &elem_dtype)?;
+
+        let expected = PrimitiveArray::from_option_iter([Some(4i64), Some(11i64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn grouped_sum_with_null_group() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9], Validity::NonNullable)
+                .into_array();
+        let validity = Validity::from_iter([true, false, true]);
+        let groups = FixedSizeListArray::try_new(elements, 3, validity, 3)?;
+
+        let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result = run_grouped_sum(&groups.into_array(), &elem_dtype)?;
+
+        let expected =
+            PrimitiveArray::from_option_iter([Some(6i64), None, Some(24i64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn grouped_sum_all_null_elements_in_group() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::from_option_iter([None::<i32>, None, Some(3), Some(4)]).into_array();
+        let groups = FixedSizeListArray::try_new(elements, 2, Validity::NonNullable, 2)?;
+
+        let elem_dtype = DType::Primitive(PType::I32, Nullable);
+        let result = run_grouped_sum(&groups.into_array(), &elem_dtype)?;
+
+        let expected = PrimitiveArray::from_option_iter([Some(0i64), Some(7i64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn grouped_sum_bool() -> VortexResult<()> {
+        let elements: BoolArray = [true, false, true, true, true, true].into_iter().collect();
+        let groups =
+            FixedSizeListArray::try_new(elements.into_array(), 3, Validity::NonNullable, 2)?;
+
+        let elem_dtype = DType::Bool(Nullability::NonNullable);
+        let result = run_grouped_sum(&groups.into_array(), &elem_dtype)?;
+
+        let expected = PrimitiveArray::from_option_iter([Some(2u64), Some(3u64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn grouped_sum_finish_resets() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = GroupedAccumulator::try_new(Sum, EmptyOptions, elem_dtype)?;
+
+        let elements1 =
+            PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array();
+        let groups1 = FixedSizeListArray::try_new(elements1, 2, Validity::NonNullable, 2)?;
+        acc.accumulate_list(&groups1.into_array(), &mut ctx)?;
+        let result1 = acc.finish()?;
+
+        let expected1 = PrimitiveArray::from_option_iter([Some(3i64), Some(7i64)]).into_array();
+        assert_arrays_eq!(&result1, &expected1);
+
+        let elements2 = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
+        let groups2 = FixedSizeListArray::try_new(elements2, 2, Validity::NonNullable, 1)?;
+        acc.accumulate_list(&groups2.into_array(), &mut ctx)?;
+        let result2 = acc.finish()?;
+
+        let expected2 = PrimitiveArray::from_option_iter([Some(30i64)]).into_array();
+        assert_arrays_eq!(&result2, &expected2);
+        Ok(())
+    }
+
+    // Chunked array tests
+
+    #[test]
+    fn sum_chunked_floats_with_nulls() -> VortexResult<()> {
+        let chunk1 =
+            PrimitiveArray::from_option_iter(vec![Some(1.5f64), None, Some(3.2), Some(4.8)]);
+        let chunk2 = PrimitiveArray::from_option_iter(vec![Some(2.1f64), Some(5.7), None]);
+        let chunk3 = PrimitiveArray::from_option_iter(vec![None, Some(1.0f64), Some(2.5), None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(
+            vec![
+                chunk1.into_array(),
+                chunk2.into_array(),
+                chunk3.into_array(),
+            ],
+            dtype,
+        )?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().as_::<f64>(), Some(20.8));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_floats_all_nulls_is_zero() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter::<f32, _>(vec![None, None, None]);
+        let chunk2 = PrimitiveArray::from_option_iter::<f32, _>(vec![None, None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result, Scalar::primitive(0f64, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_floats_empty_chunks() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter(vec![Some(10.5f64), Some(20.3)]);
+        let chunk2 = ConstantArray::new(Scalar::primitive(0f64, Nullable), 0);
+        let chunk3 = PrimitiveArray::from_option_iter(vec![Some(5.2f64)]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(
+            vec![
+                chunk1.into_array(),
+                chunk2.into_array(),
+                chunk3.into_array(),
+            ],
+            dtype,
+        )?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().as_::<f64>(), Some(36.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_int_almost_all_null() -> VortexResult<()> {
+        let chunk1 = PrimitiveArray::from_option_iter::<u32, _>(vec![Some(1)]);
+        let chunk2 = PrimitiveArray::from_option_iter::<u32, _>(vec![None]);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        assert_eq!(result.as_primitive().as_::<u64>(), Some(1));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_decimals() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let chunk1 = DecimalArray::new(
+            buffer![100i32, 100i32, 100i32, 100i32, 100i32],
+            decimal_dtype,
+            Validity::AllValid,
+        );
+        let chunk2 = DecimalArray::new(
+            buffer![200i32, 200i32, 200i32],
+            decimal_dtype,
+            Validity::AllValid,
+        );
+        let chunk3 = DecimalArray::new(buffer![300i32, 300i32], decimal_dtype, Validity::AllValid);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(
+            vec![
+                chunk1.into_array(),
+                chunk2.into_array(),
+                chunk3.into_array(),
+            ],
+            dtype,
+        )?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        let decimal_result = result.as_decimal();
+        assert_eq!(
+            decimal_result.decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(1700)))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_decimals_with_nulls() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let chunk1 = DecimalArray::new(
+            buffer![100i32, 100i32, 100i32],
+            decimal_dtype,
+            Validity::AllValid,
+        );
+        let chunk2 = DecimalArray::new(
+            buffer![0i32, 0i32],
+            decimal_dtype,
+            Validity::from_iter([false, false]),
+        );
+        let chunk3 = DecimalArray::new(buffer![200i32, 200i32], decimal_dtype, Validity::AllValid);
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(
+            vec![
+                chunk1.into_array(),
+                chunk2.into_array(),
+                chunk3.into_array(),
+            ],
+            dtype,
+        )?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        let decimal_result = result.as_decimal();
+        assert_eq!(
+            decimal_result.decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(700)))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_decimals_large() -> VortexResult<()> {
+        let decimal_dtype = DecimalDType::new(3, 0);
+        let chunk1 = ConstantArray::new(
+            Scalar::decimal(
+                DecimalValue::I16(500),
+                decimal_dtype,
+                Nullability::NonNullable,
+            ),
+            1,
+        );
+        let chunk2 = ConstantArray::new(
+            Scalar::decimal(
+                DecimalValue::I16(600),
+                decimal_dtype,
+                Nullability::NonNullable,
+            ),
+            1,
+        );
+        let dtype = chunk1.dtype().clone();
+        let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
+
+        let result = sum(
+            &chunked.into_array(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )?;
+        let decimal_result = result.as_decimal();
+        assert_eq!(
+            decimal_result.decimal_value(),
+            Some(DecimalValue::I256(i256::from_i128(1100)))
+        );
+        assert_eq!(
+            result.dtype(),
+            &DType::Decimal(DecimalDType::new(13, 0), Nullable)
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
new file mode 100644
index 00000000000..ed8ecd17a6a
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
@@ -0,0 +1,302 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use itertools::Itertools;
+use num_traits::ToPrimitive;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_mask::AllOr;
+
+use super::SumState;
+use super::checked_add_i64;
+use super::checked_add_u64;
+use crate::arrays::PrimitiveArray;
+use crate::match_each_native_ptype;
+
+pub(super) fn accumulate_primitive(inner: &mut SumState, p: &PrimitiveArray) -> VortexResult<bool> {
+    let mask = p.validity_mask()?;
+    match mask.bit_buffer() {
+        AllOr::None => Ok(false),
+        AllOr::All => accumulate_primitive_all(inner, p),
+        AllOr::Some(validity) => accumulate_primitive_valid(inner, p, validity),
+    }
+}
+
+fn accumulate_primitive_all(inner: &mut SumState, p: &PrimitiveArray) -> VortexResult<bool> {
+    match inner {
+        SumState::Unsigned(acc) => match_each_native_ptype!(p.ptype(),
+            unsigned: |T| {
+                for &v in p.as_slice::<T>() {
+                    if checked_add_u64(acc, v.to_u64().vortex_expect("unsigned to u64")) {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            },
+            signed: |_T| { vortex_panic!("unsigned sum state with signed input") },
+            floating: |_T| { vortex_panic!("unsigned sum state with float input") }
+        ),
+        SumState::Signed(acc) => match_each_native_ptype!(p.ptype(),
+            unsigned: |_T| { vortex_panic!("signed sum state with unsigned input") },
+            signed: |T| {
+                for &v in p.as_slice::<T>() {
+                    if checked_add_i64(acc, v.to_i64().vortex_expect("signed to i64")) {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            },
+            floating: |_T| { vortex_panic!("signed sum state with float input") }
+        ),
+        SumState::Float(acc) => match_each_native_ptype!(p.ptype(),
+            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");
+                    }
+                }
+                Ok(false)
+            }
+        ),
+        SumState::Decimal { .. } => vortex_panic!("decimal sum state with primitive input"),
+    }
+}
+
+fn accumulate_primitive_valid(
+    inner: &mut SumState,
+    p: &PrimitiveArray,
+    validity: &vortex_buffer::BitBuffer,
+) -> VortexResult<bool> {
+    match inner {
+        SumState::Unsigned(acc) => match_each_native_ptype!(p.ptype(),
+            unsigned: |T| {
+                for (&v, valid) in p.as_slice::<T>().iter().zip_eq(validity.iter()) {
+                    if valid && checked_add_u64(acc, v.to_u64().vortex_expect("unsigned to u64")) {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            },
+            signed: |_T| { vortex_panic!("unsigned sum state with signed input") },
+            floating: |_T| { vortex_panic!("unsigned sum state with float input") }
+        ),
+        SumState::Signed(acc) => match_each_native_ptype!(p.ptype(),
+            unsigned: |_T| { vortex_panic!("signed sum state with unsigned input") },
+            signed: |T| {
+                for (&v, valid) in p.as_slice::<T>().iter().zip_eq(validity.iter()) {
+                    if valid && checked_add_i64(acc, v.to_i64().vortex_expect("signed to i64")) {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            },
+            floating: |_T| { vortex_panic!("signed sum state with float input") }
+        ),
+        SumState::Float(acc) => match_each_native_ptype!(p.ptype(),
+            unsigned: |_T| { vortex_panic!("float sum state with unsigned input") },
+            signed: |_T| { vortex_panic!("float sum state with signed input") },
+            floating: |T| {
+                for (&v, valid) in p.as_slice::<T>().iter().zip_eq(validity.iter()) {
+                    if valid && !v.is_nan() {
+                        *acc += ToPrimitive::to_f64(&v).vortex_expect("float to f64");
+                    }
+                }
+                Ok(false)
+            }
+        ),
+        SumState::Decimal { .. } => vortex_panic!("decimal sum state with primitive input"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::sum::Sum;
+    use crate::aggregate_fn::fns::sum::sum;
+    use crate::arrays::PrimitiveArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+    use crate::validity::Validity;
+
+    #[test]
+    fn sum_i32() -> VortexResult<()> {
+        let arr = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(10));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_u8() -> VortexResult<()> {
+        let arr = PrimitiveArray::new(buffer![10u8, 20, 30], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(60));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_f64() -> VortexResult<()> {
+        let arr =
+            PrimitiveArray::new(buffer![1.5f64, 2.5, 3.0], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(7.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_with_nulls() -> VortexResult<()> {
+        let arr = PrimitiveArray::from_option_iter([Some(2i32), None, Some(4)]).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(6));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_all_null() -> VortexResult<()> {
+        let arr = PrimitiveArray::from_option_iter([None::<i32>, None, None]).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_all_invalid_float() -> VortexResult<()> {
+        let arr = PrimitiveArray::from_option_iter::<f32, _>([None, None, None]).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result, Scalar::primitive(0f64, Nullable));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_buffer_i32() -> VortexResult<()> {
+        let arr = buffer![1, 1, 1, 1].into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().as_::<i32>(), Some(4));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_buffer_f64() -> VortexResult<()> {
+        let arr = buffer![1., 1., 1., 1.].into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().as_::<f32>(), Some(4.));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_empty_produces_zero() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_empty_f64_produces_zero() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+        let result = acc.finish()?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(0.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_f64_with_nan() -> VortexResult<()> {
+        let arr = PrimitiveArray::new(
+            buffer![1.0f64, f64::NAN, 2.0, f64::NAN, 3.0],
+            Validity::NonNullable,
+        )
+        .into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(6.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_f32_with_nan() -> VortexResult<()> {
+        let arr =
+            PrimitiveArray::new(buffer![1.0f32, f32::NAN, 4.0], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(5.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_f64_with_nan_and_nulls() -> VortexResult<()> {
+        let arr = PrimitiveArray::from_option_iter([Some(1.0f64), None, Some(f64::NAN), Some(3.0)])
+            .into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(4.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_all_nan() -> VortexResult<()> {
+        let arr =
+            PrimitiveArray::new(buffer![f64::NAN, f64::NAN], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(0.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_f64_with_infinity() -> VortexResult<()> {
+        let batch = PrimitiveArray::new(
+            buffer![1.0f64, f64::INFINITY, f64::NEG_INFINITY, 2.0],
+            Validity::NonNullable,
+        )
+        .into_array();
+        let acc = sum(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        // INFINITY + NEG_INFINITY = NaN, which is treated as saturated
+        assert!(acc.as_primitive().typed_value::<f64>().unwrap().is_nan());
+
+        let mut acc = Accumulator::try_new(
+            Sum,
+            EmptyOptions,
+            DType::Primitive(PType::F64, Nullability::NonNullable),
+        )?;
+        acc.accumulate(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert!(acc.is_saturated());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_checked_overflow() -> VortexResult<()> {
+        let arr = PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array();
+        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert!(result.is_null());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_checked_overflow_is_saturated() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I64, Nullability::NonNullable);
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, dtype)?;
+        assert!(!acc.is_saturated());
+
+        let batch =
+            PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array();
+        acc.accumulate(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        assert!(acc.is_saturated());
+
+        // finish resets state, clearing saturation
+        drop(acc.finish()?);
+        assert!(!acc.is_saturated());
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/foreign.rs b/vortex-array/src/aggregate_fn/foreign.rs
new file mode 100644
index 00000000000..e79d2456493
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/foreign.rs
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFn;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::dtype::DType;
+use crate::scalar::Scalar;
+
+/// Options payload for a foreign aggregate function.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ForeignAggregateFnOptions {
+    metadata: Vec<u8>,
+}
+
+impl ForeignAggregateFnOptions {
+    pub fn new(metadata: Vec<u8>) -> Self {
+        Self { metadata }
+    }
+}
+
+impl Display for ForeignAggregateFnOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "foreign(metadata={}B)", self.metadata.len())
+    }
+}
+
+/// Aggregate-function placeholder used when deserializing an unknown aggregate function ID.
+#[derive(Clone, Debug)]
+pub struct ForeignAggregateFnVTable {
+    id: AggregateFnId,
+}
+
+impl ForeignAggregateFnVTable {
+    pub fn new(id: AggregateFnId) -> Self {
+        Self { id }
+    }
+}
+
+impl AggregateFnVTable for ForeignAggregateFnVTable {
+    type Options = ForeignAggregateFnOptions;
+    type Partial = ();
+
+    fn id(&self) -> AggregateFnId {
+        self.id.clone()
+    }
+
+    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(options.metadata.clone()))
+    }
+
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        Ok(ForeignAggregateFnOptions::new(metadata.to_vec()))
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _input_dtype: &DType) -> Option<DType> {
+        None
+    }
+
+    fn partial_dtype(&self, _options: &Self::Options, _input_dtype: &DType) -> Option<DType> {
+        None
+    }
+
+    fn empty_partial(
+        &self,
+        _options: &Self::Options,
+        _input_dtype: &DType,
+    ) -> VortexResult<Self::Partial> {
+        vortex_bail!("Cannot execute unknown aggregate function '{}'", self.id)
+    }
+
+    fn combine_partials(&self, _partial: &mut Self::Partial, _other: Scalar) -> VortexResult<()> {
+        vortex_bail!("Cannot execute unknown aggregate function '{}'", self.id)
+    }
+
+    fn to_scalar(&self, _partial: &Self::Partial) -> VortexResult<Scalar> {
+        vortex_bail!("Cannot execute unknown aggregate function '{}'", self.id)
+    }
+
+    fn reset(&self, _partial: &mut Self::Partial) {}
+
+    fn is_saturated(&self, _state: &Self::Partial) -> bool {
+        false
+    }
+
+    fn accumulate(
+        &self,
+        _state: &mut Self::Partial,
+        _batch: &Columnar,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        vortex_bail!("Cannot execute unknown aggregate function '{}'", self.id)
+    }
+
+    fn finalize(&self, _states: ArrayRef) -> VortexResult<ArrayRef> {
+        vortex_bail!("Cannot execute unknown aggregate function '{}'", self.id)
+    }
+}
+
+pub fn new_foreign_aggregate_fn(id: AggregateFnId, metadata: Vec<u8>) -> AggregateFnRef {
+    AggregateFn::new(
+        ForeignAggregateFnVTable::new(id),
+        ForeignAggregateFnOptions::new(metadata),
+    )
+    .erased()
+}
diff --git a/vortex-array/src/aggregate_fn/kernels.rs b/vortex-array/src/aggregate_fn/kernels.rs
new file mode 100644
index 00000000000..d806b18d84d
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/kernels.rs
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Pluggable aggregate function kernels used to provide encoding-specific implementations of
+//! aggregate functions.
+
+use std::fmt::Debug;
+
+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::scalar::Scalar;
+
+/// A pluggable kernel for an aggregate function.
+///
+/// The provided array should be aggregated into a single scalar representing the partial state
+/// of a single group.
+pub trait DynAggregateKernel: 'static + Send + Sync + Debug {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>>;
+}
+
+/// 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.
+///
+/// Each element of the list 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.
+    fn grouped_aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        groups: &ListViewArray,
+    ) -> 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/mod.rs b/vortex-array/src/aggregate_fn/mod.rs
new file mode 100644
index 00000000000..a22006cb981
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/mod.rs
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Aggregate function vtable machinery.
+//!
+//! This module contains the [`AggregateFnVTable`] trait, the [`Accumulator`] trait, and the
+//! type-erasure infrastructure for aggregate functions.
+
+use arcref::ArcRef;
+
+mod accumulator;
+pub use accumulator::*;
+
+mod accumulator_grouped;
+pub use accumulator_grouped::*;
+
+mod vtable;
+pub use vtable::*;
+
+mod plugin;
+pub use plugin::*;
+
+mod foreign;
+pub(crate) use foreign::*;
+
+mod typed;
+pub use typed::*;
+
+mod erased;
+pub use erased::*;
+
+mod options;
+pub use options::*;
+
+pub mod fns;
+pub mod kernels;
+pub mod proto;
+pub mod session;
+
+/// A unique identifier for an aggregate function.
+pub type AggregateFnId = ArcRef<str>;
+
+/// Private module to seal [`typed::DynAggregateFn`].
+mod sealed {
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::typed::AggregateFnInner;
+
+    /// Marker trait to prevent external implementations of [`super::typed::DynAggregateFn`].
+    pub(crate) trait Sealed {}
+
+    /// This can be the **only** implementor for [`super::typed::DynAggregateFn`].
+    impl<V: AggregateFnVTable> Sealed for AggregateFnInner<V> {}
+}
diff --git a/vortex-array/src/aggregate_fn/options.rs b/vortex-array/src/aggregate_fn/options.rs
new file mode 100644
index 00000000000..792e2924ea9
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/options.rs
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::any::Any;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_error::VortexResult;
+
+use crate::aggregate_fn::typed::DynAggregateFn;
+
+/// An opaque handle to aggregate function options.
+pub struct AggregateFnOptions<'a> {
+    pub(super) inner: &'a dyn DynAggregateFn,
+}
+
+impl Display for AggregateFnOptions<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.options_display(f)
+    }
+}
+
+impl Debug for AggregateFnOptions<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.options_debug(f)
+    }
+}
+
+impl PartialEq for AggregateFnOptions<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.id() == other.inner.id() && self.inner.options_eq(other.inner.options_any())
+    }
+}
+impl Eq for AggregateFnOptions<'_> {}
+
+impl Hash for AggregateFnOptions<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.inner.id().hash(state);
+        self.inner.options_hash(state);
+    }
+}
+
+impl AggregateFnOptions<'_> {
+    /// Serialize the options to a byte vector.
+    pub fn serialize(&self) -> VortexResult<Option<Vec<u8>>> {
+        self.inner.options_serialize()
+    }
+}
+
+impl<'a> AggregateFnOptions<'a> {
+    /// Return the underlying `Any` reference.
+    pub fn as_any(&self) -> &'a dyn Any {
+        self.inner.options_any()
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/plugin.rs b/vortex-array/src/aggregate_fn/plugin.rs
new file mode 100644
index 00000000000..b7ff8b893ac
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/plugin.rs
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use crate::aggregate_fn::AggregateFn;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnVTable;
+
+/// Reference-counted pointer to an aggregate function plugin.
+pub type AggregateFnPluginRef = Arc<dyn AggregateFnPlugin>;
+
+/// Registry trait for ID-based deserialization of aggregate functions.
+///
+/// Plugins are registered in the session by their [`AggregateFnId`]. When a serialized aggregate
+/// function is encountered, the session resolves the ID to the plugin and calls [`deserialize`]
+/// to reconstruct the value as an [`AggregateFnRef`].
+///
+/// [`deserialize`]: AggregateFnPlugin::deserialize
+pub trait AggregateFnPlugin: 'static + Send + Sync {
+    /// Returns the ID for this aggregate function.
+    fn id(&self) -> AggregateFnId;
+
+    /// Deserialize an aggregate function from serialized metadata.
+    fn deserialize(&self, metadata: &[u8], session: &VortexSession)
+    -> VortexResult<AggregateFnRef>;
+}
+
+impl std::fmt::Debug for dyn AggregateFnPlugin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("AggregateFnPlugin")
+            .field(&self.id())
+            .finish()
+    }
+}
+
+impl<V: AggregateFnVTable> AggregateFnPlugin for V {
+    fn id(&self) -> AggregateFnId {
+        AggregateFnVTable::id(self)
+    }
+
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        session: &VortexSession,
+    ) -> VortexResult<AggregateFnRef> {
+        let options = AggregateFnVTable::deserialize(self, metadata, session)?;
+        Ok(AggregateFn::new(self.clone(), options).erased())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/proto.rs b/vortex-array/src/aggregate_fn/proto.rs
new file mode 100644
index 00000000000..dfb86ad0ed9
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/proto.rs
@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use arcref::ArcRef;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+use vortex_proto::expr as pb;
+use vortex_session::VortexSession;
+
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::new_foreign_aggregate_fn;
+use crate::aggregate_fn::session::AggregateFnSessionExt;
+
+impl AggregateFnRef {
+    /// Serialize this aggregate function to its protobuf representation.
+    ///
+    /// Note: the serialization format is not stable and may change between versions.
+    pub fn serialize_proto(&self) -> VortexResult<pb::AggregateFn> {
+        let metadata = self
+            .options()
+            .serialize()?
+            .ok_or_else(|| vortex_err!("Aggregate function '{}' is not serializable", self.id()))?;
+
+        Ok(pb::AggregateFn {
+            id: self.id().to_string(),
+            metadata: Some(metadata),
+        })
+    }
+
+    /// Deserialize an aggregate function from its protobuf representation.
+    ///
+    /// Looks up the aggregate function plugin by ID in the session's registry
+    /// and delegates deserialization to it.
+    ///
+    /// 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 = ArcRef::new_arc(Arc::from(proto.id.as_str()));
+        let agg_fn = if let Some(plugin) = session.aggregate_fns().registry().find(&agg_fn_id) {
+            plugin.deserialize(proto.metadata(), session)?
+        } else if session.allows_unknown() {
+            new_foreign_aggregate_fn(agg_fn_id.clone(), proto.metadata().to_vec())
+        } else {
+            return Err(vortex_err!("unknown aggregate function id: {}", proto.id));
+        };
+
+        if agg_fn.id() != agg_fn_id {
+            vortex_bail!(
+                "Aggregate function ID mismatch: expected {}, got {}",
+                agg_fn_id,
+                agg_fn.id()
+            );
+        }
+
+        Ok(agg_fn)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prost::Message;
+    use vortex_error::VortexResult;
+    use vortex_error::vortex_panic;
+    use vortex_proto::expr as pb;
+    use vortex_session::VortexSession;
+
+    use crate::ArrayRef;
+    use crate::Columnar;
+    use crate::ExecutionCtx;
+    use crate::aggregate_fn::AggregateFnId;
+    use crate::aggregate_fn::AggregateFnRef;
+    use crate::aggregate_fn::AggregateFnVTable;
+    use crate::aggregate_fn::AggregateFnVTableExt;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::session::AggregateFnSession;
+    use crate::aggregate_fn::session::AggregateFnSessionExt;
+    use crate::dtype::DType;
+    use crate::scalar::Scalar;
+
+    /// A minimal serializable aggregate function used solely to exercise the serde round-trip.
+    #[derive(Clone, Debug)]
+    struct TestAgg;
+
+    impl AggregateFnVTable for TestAgg {
+        type Options = EmptyOptions;
+        type Partial = ();
+
+        fn id(&self) -> AggregateFnId {
+            AggregateFnId::new_ref("vortex.test.proto")
+        }
+
+        fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+            Ok(Some(vec![]))
+        }
+
+        fn deserialize(
+            &self,
+            _metadata: &[u8],
+            _session: &VortexSession,
+        ) -> VortexResult<Self::Options> {
+            Ok(EmptyOptions)
+        }
+
+        fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+            Some(input_dtype.clone())
+        }
+
+        fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
+            self.return_dtype(options, input_dtype)
+        }
+
+        fn empty_partial(
+            &self,
+            _options: &Self::Options,
+            _input_dtype: &DType,
+        ) -> VortexResult<Self::Partial> {
+            Ok(())
+        }
+
+        fn combine_partials(
+            &self,
+            _partial: &mut Self::Partial,
+            _other: Scalar,
+        ) -> VortexResult<()> {
+            Ok(())
+        }
+
+        fn to_scalar(&self, _partial: &Self::Partial) -> VortexResult<Scalar> {
+            vortex_panic!("TestAgg is for serde tests only");
+        }
+
+        fn reset(&self, _partial: &mut Self::Partial) {}
+
+        fn is_saturated(&self, _partial: &Self::Partial) -> bool {
+            true
+        }
+
+        fn accumulate(
+            &self,
+            _state: &mut Self::Partial,
+            _batch: &Columnar,
+            _ctx: &mut ExecutionCtx,
+        ) -> VortexResult<()> {
+            Ok(())
+        }
+
+        fn finalize(&self, partials: ArrayRef) -> VortexResult<ArrayRef> {
+            Ok(partials)
+        }
+    }
+
+    #[test]
+    fn aggregate_fn_serde() {
+        let session = VortexSession::empty().with::<AggregateFnSession>();
+        session.aggregate_fns().register(TestAgg);
+
+        let agg_fn = TestAgg.bind(EmptyOptions);
+
+        let serialized = agg_fn.serialize_proto().unwrap();
+        let buf = serialized.encode_to_vec();
+        let deserialized_proto = pb::AggregateFn::decode(buf.as_slice()).unwrap();
+        let deserialized = AggregateFnRef::from_proto(&deserialized_proto, &session).unwrap();
+
+        assert_eq!(deserialized, agg_fn);
+    }
+
+    #[test]
+    fn unknown_aggregate_fn_id_allow_unknown() {
+        let session = VortexSession::empty()
+            .with::<AggregateFnSession>()
+            .allow_unknown();
+
+        let proto = pb::AggregateFn {
+            id: "vortex.test.foreign_aggregate".to_string(),
+            metadata: Some(vec![7, 8, 9]),
+        };
+
+        let agg_fn = AggregateFnRef::from_proto(&proto, &session).unwrap();
+        assert_eq!(agg_fn.id().as_ref(), "vortex.test.foreign_aggregate");
+
+        let roundtrip = agg_fn.serialize_proto().unwrap();
+        assert_eq!(roundtrip.id, proto.id);
+        assert_eq!(roundtrip.metadata(), proto.metadata());
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/session.rs b/vortex-array/src/aggregate_fn/session.rs
new file mode 100644
index 00000000000..64e66195358
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/session.rs
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use parking_lot::RwLock;
+use vortex_session::Ref;
+use vortex_session::SessionExt;
+use vortex_session::registry::Registry;
+use vortex_utils::aliases::hash_map::HashMap;
+
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnPluginRef;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::fns::first::First;
+use crate::aggregate_fn::fns::is_constant::IsConstant;
+use crate::aggregate_fn::fns::is_sorted::IsSorted;
+use crate::aggregate_fn::fns::last::Last;
+use crate::aggregate_fn::fns::min_max::MinMax;
+use crate::aggregate_fn::fns::nan_count::NanCount;
+use crate::aggregate_fn::fns::sum::Sum;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::aggregate_fn::kernels::DynGroupedAggregateKernel;
+use crate::array::ArrayId;
+use crate::arrays::Chunked;
+use crate::arrays::Dict;
+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.
+#[derive(Debug)]
+pub struct AggregateFnSession {
+    registry: AggregateFnRegistry,
+
+    pub(super) kernels: RwLock<HashMap<KernelKey, &'static dyn DynAggregateKernel>>,
+    pub(super) grouped_kernels: RwLock<HashMap<KernelKey, &'static dyn DynGroupedAggregateKernel>>,
+}
+
+type KernelKey = (ArrayId, Option<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()),
+        };
+
+        // Register the built-in aggregate functions
+        this.register(First);
+        this.register(IsConstant);
+        this.register(IsSorted);
+        this.register(Last);
+        this.register(MinMax);
+        this.register(NanCount);
+        this.register(Sum);
+
+        // Register the built-in aggregate kernels.
+        this.register_aggregate_kernel(Chunked::ID, None, &ChunkedArrayAggregate);
+        this.register_aggregate_kernel(Dict::ID, Some(MinMax.id()), &DictMinMaxKernel);
+        this.register_aggregate_kernel(Dict::ID, Some(IsConstant.id()), &DictIsConstantKernel);
+        this.register_aggregate_kernel(Dict::ID, Some(IsSorted.id()), &DictIsSortedKernel);
+
+        this
+    }
+}
+
+impl AggregateFnSession {
+    /// Returns the aggregate function registry.
+    pub fn registry(&self) -> &AggregateFnRegistry {
+        &self.registry
+    }
+
+    /// 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);
+    }
+
+    /// Register an aggregate function kernel for a specific aggregate function and array type.
+    pub fn register_aggregate_kernel(
+        &self,
+        array_id: ArrayId,
+        agg_fn_id: Option<AggregateFnId>,
+        kernel: &'static dyn DynAggregateKernel,
+    ) {
+        self.kernels.write().insert((array_id, agg_fn_id), kernel);
+    }
+}
+
+/// Extension trait for accessing aggregate function session data.
+pub trait AggregateFnSessionExt: SessionExt {
+    /// Returns the aggregate function vtable registry.
+    fn aggregate_fns(&self) -> Ref<'_, AggregateFnSession> {
+        self.get::<AggregateFnSession>()
+    }
+}
+impl<S: SessionExt> AggregateFnSessionExt for S {}
diff --git a/vortex-array/src/aggregate_fn/typed.rs b/vortex-array/src/aggregate_fn/typed.rs
new file mode 100644
index 00000000000..3d1d4a8d15a
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/typed.rs
@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Typed and inner representations of aggregate functions.
+//!
+//! - [`AggregateFn<V>`]: The public typed wrapper, parameterized by a concrete
+//!   [`AggregateFnVTable`].
+//! - [`AggregateFnInner<V>`]: The private inner struct that holds the vtable + options.
+//! - [`DynAggregateFn`]: The private sealed trait for type-erased dispatch (bound, options in
+//!   self).
+
+use std::any::Any;
+use std::fmt;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use vortex_error::VortexResult;
+
+use crate::aggregate_fn::Accumulator;
+use crate::aggregate_fn::AccumulatorRef;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::GroupedAccumulator;
+use crate::aggregate_fn::GroupedAccumulatorRef;
+use crate::dtype::DType;
+
+/// An object-safe, sealed trait for bound aggregate function dispatch.
+///
+/// Options are stored inside the implementing [`AggregateFnInner<V>`], not passed externally.
+/// This is the sole trait behind [`AggregateFnRef`]'s `Arc<dyn DynAggregateFn>`.
+pub(super) trait DynAggregateFn: 'static + Send + Sync + super::sealed::Sealed {
+    fn as_any(&self) -> &dyn Any;
+    fn id(&self) -> AggregateFnId;
+    fn options_any(&self) -> &dyn Any;
+
+    fn coerce_args(&self, input_dtype: &DType) -> VortexResult<DType>;
+    fn return_dtype(&self, input_dtype: &DType) -> Option<DType>;
+    fn state_dtype(&self, input_dtype: &DType) -> Option<DType>;
+    fn accumulator(&self, input_dtype: &DType) -> VortexResult<AccumulatorRef>;
+    fn accumulator_grouped(&self, input_dtype: &DType) -> VortexResult<GroupedAccumulatorRef>;
+
+    fn options_serialize(&self) -> VortexResult<Option<Vec<u8>>>;
+    fn options_eq(&self, other_options: &dyn Any) -> bool;
+    fn options_hash(&self, hasher: &mut dyn Hasher);
+    fn options_display(&self, f: &mut Formatter<'_>) -> fmt::Result;
+    fn options_debug(&self, f: &mut Formatter<'_>) -> fmt::Result;
+}
+
+/// The private inner representation of a bound aggregate function, pairing a vtable with its
+/// options.
+///
+/// This is the sole implementor of [`DynAggregateFn`], enabling [`AggregateFnRef`] to safely
+/// downcast back to the concrete vtable type via [`Any`].
+pub(super) struct AggregateFnInner<V: AggregateFnVTable> {
+    pub(super) vtable: V,
+    pub(super) options: V::Options,
+}
+
+impl<V: AggregateFnVTable> DynAggregateFn for AggregateFnInner<V> {
+    #[inline(always)]
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline(always)]
+    fn id(&self) -> AggregateFnId {
+        V::id(&self.vtable)
+    }
+
+    fn options_any(&self) -> &dyn Any {
+        &self.options
+    }
+
+    fn coerce_args(&self, input_dtype: &DType) -> VortexResult<DType> {
+        V::coerce_args(&self.vtable, &self.options, input_dtype)
+    }
+
+    fn return_dtype(&self, input_dtype: &DType) -> Option<DType> {
+        V::return_dtype(&self.vtable, &self.options, input_dtype)
+    }
+
+    fn state_dtype(&self, input_dtype: &DType) -> Option<DType> {
+        V::partial_dtype(&self.vtable, &self.options, input_dtype)
+    }
+
+    fn accumulator(&self, input_dtype: &DType) -> VortexResult<AccumulatorRef> {
+        Ok(Box::new(Accumulator::try_new(
+            self.vtable.clone(),
+            self.options.clone(),
+            input_dtype.clone(),
+        )?))
+    }
+
+    fn accumulator_grouped(&self, input_dtype: &DType) -> VortexResult<GroupedAccumulatorRef> {
+        Ok(Box::new(GroupedAccumulator::try_new(
+            self.vtable.clone(),
+            self.options.clone(),
+            input_dtype.clone(),
+        )?))
+    }
+
+    fn options_serialize(&self) -> VortexResult<Option<Vec<u8>>> {
+        V::serialize(&self.vtable, &self.options)
+    }
+
+    fn options_eq(&self, other_options: &dyn Any) -> bool {
+        other_options
+            .downcast_ref::<V::Options>()
+            .is_some_and(|o| self.options == *o)
+    }
+
+    fn options_hash(&self, mut hasher: &mut dyn Hasher) {
+        self.options.hash(&mut hasher);
+    }
+
+    fn options_display(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.options, f)
+    }
+
+    fn options_debug(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Debug::fmt(&self.options, f)
+    }
+}
+
+/// A typed aggregate function instance, parameterized by a concrete [`AggregateFnVTable`].
+///
+/// You can construct one via [`new()`], and erase the type with [`erased()`] to obtain an
+/// [`AggregateFnRef`].
+///
+/// [`new()`]: AggregateFn::new
+/// [`erased()`]: AggregateFn::erased
+pub struct AggregateFn<V: AggregateFnVTable>(pub(super) Arc<AggregateFnInner<V>>);
+
+impl<V: AggregateFnVTable> AggregateFn<V> {
+    /// Create a new typed aggregate function instance.
+    pub fn new(vtable: V, options: V::Options) -> Self {
+        Self(Arc::new(AggregateFnInner { vtable, options }))
+    }
+
+    /// Returns a reference to the vtable.
+    pub fn vtable(&self) -> &V {
+        &self.0.vtable
+    }
+
+    /// Returns a reference to the options.
+    pub fn options(&self) -> &V::Options {
+        &self.0.options
+    }
+
+    /// Erase the concrete type information, returning a type-erased [`AggregateFnRef`].
+    pub fn erased(self) -> AggregateFnRef {
+        AggregateFnRef(self.0)
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/vtable.rs b/vortex-array/src/aggregate_fn/vtable.rs
new file mode 100644
index 00000000000..73dd2604700
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/vtable.rs
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hash;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::Columnar;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::AggregateFn;
+use crate::aggregate_fn::AggregateFnId;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::arrays::ConstantArray;
+use crate::dtype::DType;
+use crate::scalar::Scalar;
+
+/// Defines the interface for aggregate function vtables.
+///
+/// This trait is non-object-safe and allows the implementer to make use of associated types
+/// for improved type safety, while allowing Vortex to enforce runtime checks on the inputs and
+/// outputs of each function.
+///
+/// The [`AggregateFnVTable`] trait should be implemented for a struct that holds global data across
+/// all instances of the aggregate. In almost all cases, this struct will be an empty unit
+/// struct, since most aggregates do not require any global state.
+pub trait AggregateFnVTable: 'static + Sized + Clone + Send + Sync {
+    /// Options for this aggregate function.
+    type Options: 'static + Send + Sync + Clone + Debug + Display + PartialEq + Eq + Hash;
+
+    /// The partial accumulator state for a single group.
+    type Partial: 'static + Send;
+
+    /// Returns the ID of the aggregate function vtable.
+    fn id(&self) -> AggregateFnId;
+
+    /// Serialize the options for this aggregate function.
+    ///
+    /// Should return `Ok(None)` if the function is not serializable, and `Ok(vec![])` if it is
+    /// serializable but has no metadata.
+    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        _ = options;
+        Ok(None)
+    }
+
+    /// Deserialize the options of this aggregate function.
+    fn deserialize(
+        &self,
+        _metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        vortex_bail!("Aggregate function {} is not deserializable", self.id());
+    }
+
+    /// Coerce the input type for this aggregate function.
+    ///
+    /// This is optionally used by Vortex users when performing type coercion over a Vortex
+    /// expression. The default implementation returns the input type unchanged.
+    fn coerce_args(&self, options: &Self::Options, input_dtype: &DType) -> VortexResult<DType> {
+        let _ = options;
+        Ok(input_dtype.clone())
+    }
+
+    /// The return [`DType`] of the aggregate.
+    ///
+    /// Returns `None` if the aggregate function cannot be applied to the input dtype.
+    fn return_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType>;
+
+    /// DType of the intermediate partial accumulator state.
+    ///
+    /// Use a struct dtype when multiple fields are needed
+    /// (e.g., Mean: `Struct { sum: f64, count: u64 }`).
+    ///
+    /// Returns `None` if the aggregate function cannot be applied to the input dtype.
+    fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType>;
+
+    /// Return the partial accumulator state for an empty group.
+    fn empty_partial(
+        &self,
+        options: &Self::Options,
+        input_dtype: &DType,
+    ) -> VortexResult<Self::Partial>;
+
+    /// Combine partial scalar state into the accumulator.
+    fn combine_partials(&self, partial: &mut Self::Partial, other: Scalar) -> VortexResult<()>;
+
+    /// Convert the partial state into a partial scalar.
+    ///
+    /// The returned scalar must have the same DType as specified by `partial_dtype` for the
+    /// options and input dtype used to construct the state.
+    fn to_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar>;
+
+    /// Reset the state of the accumulator to an empty group.
+    fn reset(&self, partial: &mut Self::Partial);
+
+    /// Is the partial accumulator state is "saturated", i.e. has it reached a state where the
+    /// final result is fully determined.
+    fn is_saturated(&self, state: &Self::Partial) -> bool;
+
+    /// Try to accumulate the raw array before decompression.
+    ///
+    /// Returns `true` if the array was handled, `false` to fall through to
+    /// the default kernel dispatch and canonicalization path.
+    ///
+    /// This is useful for aggregates that only depend on array metadata (e.g., validity)
+    /// rather than the encoded data, avoiding unnecessary decompression.
+    fn try_accumulate(
+        &self,
+        _state: &mut Self::Partial,
+        _batch: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<bool> {
+        Ok(false)
+    }
+
+    /// Accumulate a new canonical array into the accumulator state.
+    fn accumulate(
+        &self,
+        state: &mut Self::Partial,
+        batch: &Columnar,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()>;
+
+    /// Finalize an array of accumulator states into an array of aggregate results.
+    ///
+    /// The provides `states` array has dtype as specified by `state_dtype`, the result array
+    /// must have dtype as specified by `return_dtype`.
+    fn finalize(&self, states: ArrayRef) -> VortexResult<ArrayRef>;
+
+    /// Finalize a scalar accumulator state into an aggregate result.
+    ///
+    /// The provided `state` has dtype as specified by `state_dtype`, the result scalar must have
+    /// dtype as specified by `return_dtype`.
+    fn finalize_scalar(&self, partial: &Self::Partial) -> VortexResult<Scalar> {
+        let scalar = self.to_scalar(partial)?;
+        let array = ConstantArray::new(scalar, 1).into_array();
+        let result = self.finalize(array)?;
+        result.scalar_at(0)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EmptyOptions;
+impl Display for EmptyOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "")
+    }
+}
+
+/// Factory functions for aggregate vtables.
+pub trait AggregateFnVTableExt: AggregateFnVTable {
+    /// Bind this vtable with the given options into an [`AggregateFnRef`].
+    fn bind(&self, options: Self::Options) -> AggregateFnRef {
+        AggregateFn::new(self.clone(), options).erased()
+    }
+}
+impl<V: AggregateFnVTable> AggregateFnVTableExt for V {}
diff --git a/vortex-array/src/aliases/mod.rs b/vortex-array/src/aliases/mod.rs
index de68213a51f..d001e0402e2 100644
--- a/vortex-array/src/aliases/mod.rs
+++ b/vortex-array/src/aliases/mod.rs
@@ -11,3 +11,8 @@ pub mod paste {
 
 // Re-export of [`inventory`](https://docs.rs/inventory/latest/inventory/).
 pub use inventory;
+
+pub mod vortex_error {
+    //! Re-export of [`vortex_error`](https://docs.rs/vortex-error/latest/vortex_error/).
+    pub use vortex_error::VortexExpect;
+}
diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs
new file mode 100644
index 00000000000..c2fea73dd73
--- /dev/null
+++ b/vortex-array/src/array/erased.rs
@@ -0,0 +1,623 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::any::type_name;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::hash::Hasher;
+use std::ops::Range;
+use std::sync::Arc;
+
+use vortex_buffer::ByteBuffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
+use vortex_mask::Mask;
+use vortex_session::VortexSession;
+
+use crate::AnyCanonical;
+use crate::Array;
+use crate::ArrayEq;
+use crate::ArrayHash;
+use crate::ArrayView;
+use crate::Canonical;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::LEGACY_SESSION;
+use crate::ToCanonical;
+use crate::VTable;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::sum::sum;
+use crate::array::ArrayId;
+use crate::array::ArrayInner;
+use crate::array::DynArray;
+use crate::arrays::Bool;
+use crate::arrays::Constant;
+use crate::arrays::DictArray;
+use crate::arrays::FilterArray;
+use crate::arrays::Null;
+use crate::arrays::Primitive;
+use crate::arrays::SliceArray;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinView;
+use crate::arrays::bool::BoolArrayExt;
+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::stats::StatsSetRef;
+use crate::validity::Validity;
+
+/// A depth-first pre-order iterator over an Array.
+pub struct DepthFirstArrayIterator {
+    stack: Vec<ArrayRef>,
+}
+
+impl Iterator for DepthFirstArrayIterator {
+    type Item = ArrayRef;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = self.stack.pop()?;
+        for child in next.children().into_iter().rev() {
+            self.stack.push(child);
+        }
+        Some(next)
+    }
+}
+
+/// A reference-counted pointer to a type-erased array.
+#[derive(Clone)]
+pub struct ArrayRef(Arc<dyn DynArray>);
+
+impl ArrayRef {
+    /// Create from an `Arc<dyn DynArray>`.
+    pub(crate) fn from_inner(inner: Arc<dyn DynArray>) -> Self {
+        Self(inner)
+    }
+
+    /// Returns the Arc::as_ptr().addr() of the underlying array.
+    /// This function is used in a couple of places, and we should migrate them to using array_eq.
+    #[doc(hidden)]
+    pub fn addr(&self) -> usize {
+        Arc::as_ptr(&self.0).addr()
+    }
+
+    /// Returns a reference to the inner Arc.
+    #[inline(always)]
+    pub(crate) fn inner(&self) -> &Arc<dyn DynArray> {
+        &self.0
+    }
+
+    /// Consumes the array reference, returning the owned backing allocation.
+    #[inline(always)]
+    pub(crate) fn into_inner(self) -> Arc<dyn DynArray> {
+        self.0
+    }
+
+    /// Returns true if the two ArrayRefs point to the same allocation.
+    pub fn ptr_eq(this: &ArrayRef, other: &ArrayRef) -> bool {
+        Arc::ptr_eq(&this.0, &other.0)
+    }
+}
+
+impl Debug for ArrayRef {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(&*self.0, f)
+    }
+}
+
+impl ArrayHash for ArrayRef {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: crate::Precision) {
+        self.0.dyn_array_hash(state as &mut dyn Hasher, precision);
+    }
+}
+
+impl ArrayEq for ArrayRef {
+    fn array_eq(&self, other: &Self, precision: crate::Precision) -> bool {
+        self.0.dyn_array_eq(other, precision)
+    }
+}
+
+#[allow(clippy::same_name_method)]
+impl ArrayRef {
+    /// Returns the length of the array.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns whether the array is empty (has zero rows).
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0.len() == 0
+    }
+
+    /// Returns the logical Vortex [`DType`] of the array.
+    #[inline]
+    pub fn dtype(&self) -> &DType {
+        self.0.dtype()
+    }
+
+    /// Returns the encoding ID of the array.
+    #[inline]
+    pub fn encoding_id(&self) -> ArrayId {
+        self.0.encoding_id()
+    }
+
+    /// Performs a constant-time slice of the array.
+    pub fn slice(&self, range: Range<usize>) -> VortexResult<ArrayRef> {
+        let len = self.len();
+        let start = range.start;
+        let stop = range.end;
+
+        if start == 0 && stop == len {
+            return Ok(self.clone());
+        }
+
+        vortex_ensure!(start <= len, "OutOfBounds: start {start} > length {}", len);
+        vortex_ensure!(stop <= len, "OutOfBounds: stop {stop} > length {}", len);
+
+        vortex_ensure!(start <= stop, "start ({start}) must be <= stop ({stop})");
+
+        if start == stop {
+            return Ok(Canonical::empty(self.dtype()).into_array());
+        }
+
+        let sliced = SliceArray::try_new(self.clone(), range)?
+            .into_array()
+            .optimize()?;
+
+        // Propagate some stats from the original array to the sliced array.
+        if !sliced.is::<Constant>() {
+            self.statistics().with_iter(|iter| {
+                sliced.statistics().inherit(iter.filter(|(stat, value)| {
+                    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()
+                    })
+                }));
+            });
+        }
+
+        Ok(sliced)
+    }
+
+    /// Wraps the array in a [`FilterArray`] such that it is logically filtered by the given mask.
+    pub fn filter(&self, mask: Mask) -> VortexResult<ArrayRef> {
+        FilterArray::try_new(self.clone(), mask)?
+            .into_array()
+            .optimize()
+    }
+
+    /// Wraps the array in a [`DictArray`] such that it is logically taken by the given indices.
+    pub fn take(&self, indices: ArrayRef) -> VortexResult<ArrayRef> {
+        DictArray::try_new(indices, self.clone())?
+            .into_array()
+            .optimize()
+    }
+
+    /// Fetch the scalar at the given index.
+    pub fn scalar_at(&self, index: usize) -> VortexResult<Scalar> {
+        vortex_ensure!(index < self.len(), OutOfBounds: index, 0, self.len());
+        if self.is_invalid(index)? {
+            return Ok(Scalar::null(self.dtype().clone()));
+        }
+        let scalar = self.0.scalar_at(self, index)?;
+        vortex_ensure!(self.dtype() == scalar.dtype(), "Scalar dtype mismatch");
+        Ok(scalar)
+    }
+
+    /// Returns whether the item at `index` is valid.
+    pub fn is_valid(&self, index: usize) -> VortexResult<bool> {
+        vortex_ensure!(index < self.len(), OutOfBounds: index, 0, self.len());
+        match self.validity()? {
+            Validity::NonNullable | Validity::AllValid => Ok(true),
+            Validity::AllInvalid => Ok(false),
+            Validity::Array(a) => a
+                .scalar_at(index)?
+                .as_bool()
+                .value()
+                .ok_or_else(|| vortex_err!("validity value at index {} is null", index)),
+        }
+    }
+
+    /// Returns whether the item at `index` is invalid.
+    pub fn is_invalid(&self, index: usize) -> VortexResult<bool> {
+        Ok(!self.is_valid(index)?)
+    }
+
+    /// Returns whether all items in the array are valid.
+    pub fn all_valid(&self) -> VortexResult<bool> {
+        match self.validity()? {
+            Validity::NonNullable | Validity::AllValid => Ok(true),
+            Validity::AllInvalid => Ok(false),
+            Validity::Array(a) => Ok(a.statistics().compute_min::<bool>().unwrap_or(false)),
+        }
+    }
+
+    /// Returns whether the array is all invalid.
+    pub fn all_invalid(&self) -> VortexResult<bool> {
+        match self.validity()? {
+            Validity::NonNullable | Validity::AllValid => Ok(false),
+            Validity::AllInvalid => Ok(true),
+            Validity::Array(a) => Ok(!a.statistics().compute_max::<bool>().unwrap_or(true)),
+        }
+    }
+
+    /// Returns the number of valid elements in the array.
+    pub fn valid_count(&self) -> VortexResult<usize> {
+        let len = self.len();
+        if let Some(Precision::Exact(invalid_count)) =
+            self.statistics().get_as::<usize>(Stat::NullCount)
+        {
+            return Ok(len - invalid_count);
+        }
+
+        let count = match self.validity()? {
+            Validity::NonNullable | Validity::AllValid => len,
+            Validity::AllInvalid => 0,
+            Validity::Array(a) => {
+                let mut ctx = LEGACY_SESSION.create_execution_ctx();
+                let array_sum = sum(&a, &mut ctx)?;
+                array_sum
+                    .as_primitive()
+                    .as_::<usize>()
+                    .ok_or_else(|| vortex_err!("sum of validity array is null"))?
+            }
+        };
+        vortex_ensure!(count <= len, "Valid count exceeds array length");
+
+        self.statistics()
+            .set(Stat::NullCount, Precision::exact(len - count));
+
+        Ok(count)
+    }
+
+    /// Returns the number of invalid elements in the array.
+    pub fn invalid_count(&self) -> VortexResult<usize> {
+        Ok(self.len() - self.valid_count()?)
+    }
+
+    /// Returns the [`Validity`] of the array.
+    pub fn validity(&self) -> VortexResult<Validity> {
+        self.0.validity(self)
+    }
+
+    /// Returns the canonical validity mask for the array.
+    pub fn validity_mask(&self) -> VortexResult<Mask> {
+        match self.validity()? {
+            Validity::NonNullable | Validity::AllValid => Ok(Mask::new_true(self.len())),
+            Validity::AllInvalid => Ok(Mask::new_false(self.len())),
+            Validity::Array(a) => Ok(a.to_bool().to_mask()),
+        }
+    }
+
+    /// Returns the canonical representation of the array.
+    pub fn into_canonical(self) -> VortexResult<Canonical> {
+        self.execute(&mut LEGACY_SESSION.create_execution_ctx())
+    }
+
+    /// Returns the canonical representation of the array.
+    pub fn to_canonical(&self) -> VortexResult<Canonical> {
+        self.clone().into_canonical()
+    }
+
+    /// Writes the array into the canonical builder.
+    pub fn append_to_builder(
+        &self,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        self.0.append_to_builder(self, builder, ctx)
+    }
+
+    /// Returns the statistics of the array.
+    pub fn statistics(&self) -> StatsSetRef<'_> {
+        self.0.statistics().to_ref(self)
+    }
+
+    /// Does the array match the given matcher.
+    pub fn is<M: Matcher>(&self) -> bool {
+        M::matches(self)
+    }
+
+    /// Returns the array downcast by the given matcher.
+    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.
+    pub fn as_opt<M: Matcher>(&self) -> Option<M::Match<'_>> {
+        M::try_match(self)
+    }
+
+    /// Returns the array downcast to the given `Array<V>` as an owned typed handle.
+    pub fn try_downcast<V: VTable>(self) -> Result<Array<V>, ArrayRef> {
+        Array::<V>::try_from_array_ref(self)
+    }
+
+    /// Returns the array downcast to the given `Array<V>` as an owned typed handle.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the array is not of the given type.
+    pub fn downcast<V: VTable>(self) -> Array<V> {
+        Self::try_downcast(self)
+            .unwrap_or_else(|_| vortex_panic!("Failed to downcast to {}", type_name::<V>()))
+    }
+
+    /// Returns a reference to the typed `ArrayInner<V>` if this array matches the given vtable type.
+    pub fn as_typed<V: VTable>(&self) -> Option<ArrayView<'_, V>> {
+        let inner = self.0.as_any().downcast_ref::<ArrayInner<V>>()?;
+        Some(unsafe { ArrayView::new_unchecked(self, &inner.data) })
+    }
+
+    /// Returns the constant scalar if this is a constant array.
+    pub fn as_constant(&self) -> Option<Scalar> {
+        self.as_opt::<Constant>().map(|a| a.scalar().clone())
+    }
+
+    /// Total size of the array in bytes, including all children and buffers.
+    pub fn nbytes(&self) -> u64 {
+        let mut nbytes = 0;
+        for array in self.depth_first_traversal() {
+            for buffer in array.buffers() {
+                nbytes += buffer.len() as u64;
+            }
+        }
+        nbytes
+    }
+
+    /// Returns whether this array is an arrow encoding.
+    pub fn is_arrow(&self) -> bool {
+        self.is::<Null>()
+            || self.is::<Bool>()
+            || self.is::<Primitive>()
+            || self.is::<VarBin>()
+            || self.is::<VarBinView>()
+    }
+
+    /// Whether the array is of a canonical encoding.
+    pub fn is_canonical(&self) -> bool {
+        self.is::<AnyCanonical>()
+    }
+
+    /// Returns a new array with the slot at `slot_idx` replaced by `replacement`.
+    ///
+    /// This is only valid for physical rewrites: the replacement must have the same logical
+    /// `DType` and `len` as the existing slot.
+    ///
+    /// Takes ownership to allow in-place mutation when the refcount is 1.
+    pub fn with_slot(self, slot_idx: usize, replacement: ArrayRef) -> VortexResult<ArrayRef> {
+        let slots = self.slots().to_vec();
+        let nslots = slots.len();
+        vortex_ensure!(
+            slot_idx < nslots,
+            "slot index {} out of bounds for array with {} slots",
+            slot_idx,
+            nslots
+        );
+        let existing = slots[slot_idx]
+            .as_ref()
+            .vortex_expect("with_slot cannot replace an absent slot");
+        vortex_ensure!(
+            existing.dtype() == replacement.dtype(),
+            "slot {} dtype changed from {} to {} during physical rewrite",
+            slot_idx,
+            existing.dtype(),
+            replacement.dtype()
+        );
+        vortex_ensure!(
+            existing.len() == replacement.len(),
+            "slot {} len changed from {} to {} during physical rewrite",
+            slot_idx,
+            existing.len(),
+            replacement.len()
+        );
+        let mut slots = slots;
+        slots[slot_idx] = Some(replacement);
+        self.with_slots(slots)
+    }
+
+    /// Returns a new array with the provided slots.
+    ///
+    /// This is only valid for physical rewrites: slot count, presence, logical `DType`, and
+    /// logical `len` must remain unchanged.
+    pub fn with_slots(self, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef> {
+        let old_slots = self.slots();
+        vortex_ensure!(
+            old_slots.len() == slots.len(),
+            "slot count changed from {} to {} during physical rewrite",
+            old_slots.len(),
+            slots.len()
+        );
+        for (idx, (old_slot, new_slot)) in old_slots.iter().zip(slots.iter()).enumerate() {
+            vortex_ensure!(
+                old_slot.is_some() == new_slot.is_some(),
+                "slot {} presence changed during physical rewrite",
+                idx
+            );
+            if let (Some(old_slot), Some(new_slot)) = (old_slot.as_ref(), new_slot.as_ref()) {
+                vortex_ensure!(
+                    old_slot.dtype() == new_slot.dtype(),
+                    "slot {} dtype changed from {} to {} during physical rewrite",
+                    idx,
+                    old_slot.dtype(),
+                    new_slot.dtype()
+                );
+                vortex_ensure!(
+                    old_slot.len() == new_slot.len(),
+                    "slot {} len changed from {} to {} during physical rewrite",
+                    idx,
+                    old_slot.len(),
+                    new_slot.len()
+                );
+            }
+        }
+        let inner = Arc::clone(&self.0);
+        inner.with_slots(self, slots)
+    }
+
+    pub fn reduce(&self) -> VortexResult<Option<ArrayRef>> {
+        self.0.reduce(self)
+    }
+
+    pub fn reduce_parent(
+        &self,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        self.0.reduce_parent(self, parent, child_idx)
+    }
+
+    pub(crate) fn execute_encoding(
+        self,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<crate::ExecutionResult> {
+        let inner = Arc::clone(&self.0);
+        inner.execute(self, ctx)
+    }
+
+    pub fn execute_parent(
+        &self,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        self.0.execute_parent(self, parent, child_idx, ctx)
+    }
+
+    // ArrayVisitor delegation methods
+
+    /// Returns the children of the array.
+    pub fn children(&self) -> Vec<ArrayRef> {
+        self.0.children(self)
+    }
+
+    /// Returns the number of children of the array.
+    pub fn nchildren(&self) -> usize {
+        self.0.nchildren(self)
+    }
+
+    /// Returns the nth child of the array without allocating a Vec.
+    pub fn nth_child(&self, idx: usize) -> Option<ArrayRef> {
+        self.0.nth_child(self, idx)
+    }
+
+    /// Returns the names of the children of the array.
+    pub fn children_names(&self) -> Vec<String> {
+        self.0.children_names(self)
+    }
+
+    /// Returns the array's children with their names.
+    pub fn named_children(&self) -> Vec<(String, ArrayRef)> {
+        self.0.named_children(self)
+    }
+
+    /// Returns the data buffers of the array.
+    pub fn buffers(&self) -> Vec<ByteBuffer> {
+        self.0.buffers(self)
+    }
+
+    /// Returns the buffer handles of the array.
+    pub fn buffer_handles(&self) -> Vec<BufferHandle> {
+        self.0.buffer_handles(self)
+    }
+
+    /// Returns the names of the buffers of the array.
+    pub fn buffer_names(&self) -> Vec<String> {
+        self.0.buffer_names(self)
+    }
+
+    /// Returns the array's buffers with their names.
+    pub fn named_buffers(&self) -> Vec<(String, BufferHandle)> {
+        self.0.named_buffers(self)
+    }
+
+    /// Returns the number of data buffers of the array.
+    pub fn nbuffers(&self) -> usize {
+        self.0.nbuffers(self)
+    }
+
+    /// Returns the slots of the array.
+    pub fn slots(&self) -> &[Option<ArrayRef>] {
+        self.0.slots()
+    }
+
+    /// Returns the name of the slot at the given index.
+    pub fn slot_name(&self, idx: usize) -> String {
+        self.0.slot_name(self, idx)
+    }
+
+    /// Returns the serialized metadata of the array.
+    pub fn metadata(&self, session: &VortexSession) -> VortexResult<Option<Vec<u8>>> {
+        self.0.metadata(self, session)
+    }
+
+    /// Formats a human-readable metadata description.
+    pub fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.0.metadata_fmt(f)
+    }
+
+    /// Returns whether all buffers are host-resident.
+    pub fn is_host(&self) -> bool {
+        for array in self.depth_first_traversal() {
+            if !array.buffer_handles().iter().all(BufferHandle::is_on_host) {
+                return false;
+            }
+        }
+        true
+    }
+
+    // ArrayVisitorExt delegation methods
+
+    /// Count the number of buffers encoded by self and all child arrays.
+    pub fn nbuffers_recursive(&self) -> usize {
+        self.children()
+            .iter()
+            .map(|c| c.nbuffers_recursive())
+            .sum::<usize>()
+            + self.nbuffers()
+    }
+
+    /// Depth-first traversal of the array and its children.
+    pub fn depth_first_traversal(&self) -> DepthFirstArrayIterator {
+        DepthFirstArrayIterator {
+            stack: vec![self.clone()],
+        }
+    }
+}
+
+impl IntoArray for ArrayRef {
+    #[inline(always)]
+    fn into_array(self) -> ArrayRef {
+        self
+    }
+}
+
+impl<V: VTable> Matcher for V {
+    type Match<'a> = ArrayView<'a, V>;
+
+    fn matches(array: &ArrayRef) -> bool {
+        array.0.as_any().is::<ArrayInner<V>>()
+    }
+
+    fn try_match<'a>(array: &'a ArrayRef) -> Option<ArrayView<'a, V>> {
+        let inner = array.0.as_any().downcast_ref::<ArrayInner<V>>()?;
+        Some(unsafe { ArrayView::new_unchecked(array, &inner.data) })
+    }
+}
diff --git a/vortex-array/src/array/foreign.rs b/vortex-array/src/array/foreign.rs
new file mode 100644
index 00000000000..b29d76ba2b8
--- /dev/null
+++ b/vortex-array/src/array/foreign.rs
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::Array;
+use crate::ArrayRef;
+use crate::ExecutionResult;
+use crate::IntoArray;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::array::vtable::NotSupported;
+use crate::array::vtable::ValidityVTable;
+use crate::buffer::BufferHandle;
+use crate::dtype::DType;
+use crate::executor::ExecutionCtx;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
+use crate::serde::ArrayChildren;
+use crate::validity::Validity;
+
+#[derive(Clone, Debug)]
+pub struct ForeignArrayData {
+    metadata: Vec<u8>,
+    buffers: Vec<BufferHandle>,
+}
+
+impl ForeignArrayData {
+    pub fn new(metadata: Vec<u8>, buffers: Vec<BufferHandle>) -> Self {
+        Self { metadata, buffers }
+    }
+}
+
+impl Display for ForeignArrayData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "ForeignArrayData({}B)", self.metadata.len())
+    }
+}
+
+impl ArrayHash for ForeignArrayData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: crate::Precision) {
+        self.metadata.hash(state);
+        self.buffers.len().hash(state);
+        for buffer in &self.buffers {
+            buffer.array_hash(state, precision);
+        }
+    }
+}
+
+impl ArrayEq for ForeignArrayData {
+    fn array_eq(&self, other: &Self, precision: crate::Precision) -> 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))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ForeignArray {
+    id: ArrayId,
+}
+
+impl ForeignArray {
+    pub fn new(id: ArrayId) -> Self {
+        Self { id }
+    }
+}
+
+pub struct ForeignValidityVTable;
+
+impl ValidityVTable<ForeignArray> for ForeignValidityVTable {
+    fn validity(array: ArrayView<'_, ForeignArray>) -> VortexResult<Validity> {
+        Ok(Validity::from(array.dtype().nullability()))
+    }
+}
+
+impl VTable for ForeignArray {
+    type ArrayData = ForeignArrayData;
+    type OperationsVTable = NotSupported;
+    type ValidityVTable = ForeignValidityVTable;
+
+    fn id(&self) -> ArrayId {
+        self.id.clone()
+    }
+
+    fn validate(
+        &self,
+        _data: &Self::ArrayData,
+        _dtype: &DType,
+        _len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        Ok(())
+    }
+
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize {
+        array.buffers.len()
+    }
+
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        array.buffers[idx].clone()
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        Some(format!("buffer[{idx}]"))
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(array.metadata.clone()))
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let child_arrays = (0..children.len())
+            .map(|idx| children.get(idx, dtype, len))
+            .collect::<VortexResult<Vec<_>>>()?;
+
+        Ok(ArrayParts::new(
+            self.clone(),
+            dtype.clone(),
+            len,
+            ForeignArrayData::new(metadata.to_vec(), buffers.to_vec()),
+        )
+        .with_slots(child_arrays.into_iter().map(Some).collect()))
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        format!("child[{idx}]")
+    }
+
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        vortex_bail!(
+            "Cannot execute unknown array encoding '{}'",
+            array.encoding_id()
+        )
+    }
+}
+
+pub fn new_foreign_array(
+    id: ArrayId,
+    dtype: DType,
+    len: usize,
+    metadata: Vec<u8>,
+    buffers: Vec<BufferHandle>,
+    children: Vec<ArrayRef>,
+) -> VortexResult<ArrayRef> {
+    Ok(Array::<ForeignArray>::try_from_parts(
+        ArrayParts::new(
+            ForeignArray::new(id),
+            dtype,
+            len,
+            ForeignArrayData::new(metadata, buffers),
+        )
+        .with_slots(children.into_iter().map(Some).collect()),
+    )?
+    .into_array())
+}
diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs
index 54326bc622c..9ef3e57cab2 100644
--- a/vortex-array/src/array/mod.rs
+++ b/vortex-array/src/array/mod.rs
@@ -1,359 +1,175 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-mod visitor;
-
 use std::any::Any;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::hash::Hash;
 use std::hash::Hasher;
-use std::ops::Deref;
-use std::ops::Range;
-use std::sync::Arc;
 
-pub use visitor::*;
+use arcref::ArcRef;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
-use vortex_mask::Mask;
-
-use crate::AnyCanonical;
-use crate::ArrayEq;
-use crate::ArrayHash;
-use crate::Canonical;
-use crate::DynArrayEq;
-use crate::DynArrayHash;
+use vortex_session::VortexSession;
+
 use crate::ExecutionCtx;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
-use crate::arrays::BoolVTable;
-use crate::arrays::ConstantVTable;
-use crate::arrays::DictArray;
-use crate::arrays::FilterArray;
-use crate::arrays::NullVTable;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::ScalarFnVTable;
-use crate::arrays::SliceArray;
-use crate::arrays::VarBinVTable;
-use crate::arrays::VarBinViewVTable;
 use crate::buffer::BufferHandle;
 use crate::builders::ArrayBuilder;
-use crate::compute;
 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::hash;
-use crate::matcher::Matcher;
-use crate::optimizer::ArrayOptimizer;
+use crate::executor::ExecutionResult;
+use crate::executor::ExecutionStep;
 use crate::scalar::Scalar;
-use crate::scalar_fn::ReduceNode;
-use crate::scalar_fn::ReduceNodeRef;
-use crate::scalar_fn::ScalarFnRef;
-use crate::stats::StatsSetRef;
+use crate::stats::ArrayStats;
 use crate::validity::Validity;
-use crate::vtable::ArrayId;
-use crate::vtable::ArrayVTableExt;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::DynVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
+
+mod erased;
+pub use erased::*;
+
+mod plugin;
+pub use plugin::*;
+
+mod foreign;
+pub(crate) use foreign::*;
+
+mod typed;
+pub use typed::*;
+
+pub mod vtable;
+pub use vtable::*;
+
+mod view;
+pub use view::*;
+
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
 
 /// The public API trait for all Vortex arrays.
-pub trait Array:
-    'static
-    + private::Sealed
-    + Send
-    + Sync
-    + Debug
-    + DynArrayEq
-    + DynArrayHash
-    + ArrayVisitor
-    + ReduceNode
-{
+///
+/// This trait is sealed and cannot be implemented outside of `vortex-array`.
+/// Use [`ArrayRef`] as the primary handle for working with arrays.
+#[doc(hidden)]
+pub(crate) trait DynArray: 'static + private::Sealed + Send + Sync + Debug {
     /// Returns the array as a reference to a generic [`Any`] trait object.
     fn as_any(&self) -> &dyn Any;
 
-    /// Returns the array as an `Arc<dyn Any + Send + Sync>`.
-    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any + Send + Sync>;
-
-    /// Returns the array as an [`ArrayRef`].
-    fn to_array(&self) -> ArrayRef;
+    /// Converts an owned array allocation into an owned [`Any`] allocation for downcasting.
+    fn into_any_arc(self: std::sync::Arc<Self>) -> std::sync::Arc<dyn Any + Send + Sync>;
 
     /// Returns the length of the array.
     fn len(&self) -> usize;
 
-    /// Returns whether the array is empty (has zero rows).
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
     /// Returns the logical Vortex [`DType`] of the array.
     fn dtype(&self) -> &DType;
 
-    /// Returns the vtable of the array.
-    fn vtable(&self) -> &dyn DynVTable;
+    /// Returns the slots of the array.
+    fn slots(&self) -> &[Option<ArrayRef>];
 
     /// Returns the encoding ID of the array.
     fn encoding_id(&self) -> ArrayId;
 
-    /// Performs a constant-time slice of the array.
-    fn slice(&self, range: Range<usize>) -> VortexResult<ArrayRef>;
-
-    /// Wraps the array in a [`FilterArray`] such that it is logically filtered by the given mask.
-    fn filter(&self, mask: Mask) -> VortexResult<ArrayRef>;
-
-    /// Wraps the array in a [`DictArray`] such that it is logically taken by the given indices.
-    fn take(&self, indices: ArrayRef) -> VortexResult<ArrayRef>;
-
     /// Fetch the scalar at the given index.
     ///
     /// This method panics if the index is out of bounds for the array.
-    fn scalar_at(&self, index: usize) -> VortexResult<Scalar>;
-
-    /// Returns whether the item at `index` is valid.
-    fn is_valid(&self, index: usize) -> VortexResult<bool>;
-
-    /// Returns whether the item at `index` is invalid.
-    fn is_invalid(&self, index: usize) -> VortexResult<bool>;
-
-    /// Returns whether all items in the array are valid.
-    ///
-    /// This is usually cheaper than computing a precise `valid_count`, but may return false
-    /// negatives.
-    fn all_valid(&self) -> VortexResult<bool>;
-
-    /// Returns whether the array is all invalid.
-    ///
-    /// This is usually cheaper than computing a precise `invalid_count`, but may return false
-    /// negatives.
-    fn all_invalid(&self) -> VortexResult<bool>;
-
-    /// Returns the number of valid elements in the array.
-    fn valid_count(&self) -> VortexResult<usize>;
-
-    /// Returns the number of invalid elements in the array.
-    fn invalid_count(&self) -> VortexResult<usize>;
+    fn scalar_at(&self, this: &ArrayRef, index: usize) -> VortexResult<Scalar>;
 
     /// Returns the [`Validity`] of the array.
-    fn validity(&self) -> VortexResult<Validity>;
-
-    /// Returns the canonical validity mask for the array.
-    fn validity_mask(&self) -> VortexResult<Mask>;
-
-    /// Returns the canonical representation of the array.
-    fn to_canonical(&self) -> VortexResult<Canonical>;
+    fn validity(&self, this: &ArrayRef) -> VortexResult<Validity>;
 
     /// Writes the array into the canonical builder.
     ///
     /// The [`DType`] of the builder must match that of the array.
     fn append_to_builder(
         &self,
+        this: &ArrayRef,
         builder: &mut dyn ArrayBuilder,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()>;
 
     /// Returns the statistics of the array.
-    // TODO(ngates): change how this works. It's weird.
-    fn statistics(&self) -> StatsSetRef<'_>;
-
-    /// Replaces the children of the array with the given array references.
-    fn with_children(&self, children: Vec<ArrayRef>) -> VortexResult<ArrayRef>;
-}
+    fn statistics(&self) -> &ArrayStats;
 
-impl Array for Arc<dyn Array> {
-    #[inline]
-    fn as_any(&self) -> &dyn Any {
-        Array::as_any(self.as_ref())
-    }
+    // --- Visitor methods (formerly in ArrayVisitor) ---
 
-    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
-        self
-    }
+    /// Returns the children of the array.
+    fn children(&self, this: &ArrayRef) -> Vec<ArrayRef>;
 
-    #[inline]
-    fn to_array(&self) -> ArrayRef {
-        self.clone()
-    }
+    /// Returns the number of children of the array.
+    fn nchildren(&self, this: &ArrayRef) -> usize;
 
-    #[inline]
-    fn len(&self) -> usize {
-        self.as_ref().len()
-    }
+    /// Returns the nth child of the array without allocating a Vec.
+    ///
+    /// Returns `None` if the index is out of bounds.
+    fn nth_child(&self, this: &ArrayRef, idx: usize) -> Option<ArrayRef>;
 
-    #[inline]
-    fn dtype(&self) -> &DType {
-        self.as_ref().dtype()
-    }
+    /// Returns the names of the children of the array.
+    fn children_names(&self, this: &ArrayRef) -> Vec<String>;
 
-    fn vtable(&self) -> &dyn DynVTable {
-        self.as_ref().vtable()
-    }
+    /// Returns the array's children with their names.
+    fn named_children(&self, this: &ArrayRef) -> Vec<(String, ArrayRef)>;
 
-    #[inline]
-    fn encoding_id(&self) -> ArrayId {
-        self.as_ref().encoding_id()
-    }
+    /// Returns the buffers of the array.
+    fn buffers(&self, this: &ArrayRef) -> Vec<ByteBuffer>;
 
-    #[inline]
-    fn slice(&self, range: Range<usize>) -> VortexResult<ArrayRef> {
-        self.as_ref().slice(range)
-    }
+    /// Returns the buffer handles of the array.
+    fn buffer_handles(&self, this: &ArrayRef) -> Vec<BufferHandle>;
 
-    fn filter(&self, mask: Mask) -> VortexResult<ArrayRef> {
-        self.as_ref().filter(mask)
-    }
+    /// Returns the names of the buffers of the array.
+    fn buffer_names(&self, this: &ArrayRef) -> Vec<String>;
 
-    fn take(&self, indices: ArrayRef) -> VortexResult<ArrayRef> {
-        self.as_ref().take(indices)
-    }
+    /// Returns the array's buffers with their names.
+    fn named_buffers(&self, this: &ArrayRef) -> Vec<(String, BufferHandle)>;
 
-    #[inline]
-    fn scalar_at(&self, index: usize) -> VortexResult<Scalar> {
-        self.as_ref().scalar_at(index)
-    }
+    /// Returns the number of buffers of the array.
+    fn nbuffers(&self, this: &ArrayRef) -> usize;
 
-    #[inline]
-    fn is_valid(&self, index: usize) -> VortexResult<bool> {
-        self.as_ref().is_valid(index)
-    }
+    /// Returns the name of the slot at the given index.
+    fn slot_name(&self, this: &ArrayRef, idx: usize) -> String;
 
-    #[inline]
-    fn is_invalid(&self, index: usize) -> VortexResult<bool> {
-        self.as_ref().is_invalid(index)
-    }
+    /// Returns the serialized metadata of the array, or `None` if the array does not
+    /// support serialization.
+    fn metadata(&self, this: &ArrayRef, session: &VortexSession) -> VortexResult<Option<Vec<u8>>>;
 
-    #[inline]
-    fn all_valid(&self) -> VortexResult<bool> {
-        self.as_ref().all_valid()
-    }
+    /// Formats a human-readable metadata description.
+    fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
 
-    #[inline]
-    fn all_invalid(&self) -> VortexResult<bool> {
-        self.as_ref().all_invalid()
-    }
+    /// Hashes the array contents including len, dtype, and encoding id.
+    fn dyn_array_hash(&self, state: &mut dyn Hasher, precision: crate::Precision);
 
-    #[inline]
-    fn valid_count(&self) -> VortexResult<usize> {
-        self.as_ref().valid_count()
-    }
+    /// Compares two arrays of the same concrete type for equality.
+    fn dyn_array_eq(&self, other: &ArrayRef, precision: crate::Precision) -> bool;
 
-    #[inline]
-    fn invalid_count(&self) -> VortexResult<usize> {
-        self.as_ref().invalid_count()
-    }
+    /// Returns a new array with the given slots.
+    fn with_slots(&self, this: ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef>;
 
-    #[inline]
-    fn validity(&self) -> VortexResult<Validity> {
-        self.as_ref().validity()
-    }
+    /// Attempt to reduce the array to a simpler representation.
+    fn reduce(&self, this: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
 
-    #[inline]
-    fn validity_mask(&self) -> VortexResult<Mask> {
-        self.as_ref().validity_mask()
-    }
+    /// Attempt to reduce the parent of this array.
+    fn reduce_parent(
+        &self,
+        this: &ArrayRef,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>>;
 
-    fn to_canonical(&self) -> VortexResult<Canonical> {
-        self.as_ref().to_canonical()
-    }
+    /// Execute the array by taking a single encoding-specific execution step.
+    fn execute(&self, this: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult>;
 
-    fn append_to_builder(
+    /// Attempt to execute the parent of this array.
+    fn execute_parent(
         &self,
-        builder: &mut dyn ArrayBuilder,
+        this: &ArrayRef,
+        parent: &ArrayRef,
+        child_idx: usize,
         ctx: &mut ExecutionCtx,
-    ) -> VortexResult<()> {
-        self.as_ref().append_to_builder(builder, ctx)
-    }
-
-    fn statistics(&self) -> StatsSetRef<'_> {
-        self.as_ref().statistics()
-    }
-
-    fn with_children(&self, children: Vec<ArrayRef>) -> VortexResult<ArrayRef> {
-        self.as_ref().with_children(children)
-    }
-}
-
-/// A reference counted pointer to a dynamic [`Array`] trait object.
-pub type ArrayRef = Arc<dyn Array>;
-
-impl ToOwned for dyn Array {
-    type Owned = ArrayRef;
-
-    fn to_owned(&self) -> Self::Owned {
-        self.to_array()
-    }
-}
-
-impl dyn Array + '_ {
-    /// Does the array match the given matcher.
-    pub fn is<M: Matcher>(&self) -> bool {
-        M::matches(self)
-    }
-
-    /// Returns the array downcast by the given matcher.
-    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.
-    pub fn as_opt<M: Matcher>(&self) -> Option<M::Match<'_>> {
-        M::try_match(self)
-    }
-
-    /// Returns the array downcast to the given `A` as an owned object.
-    pub fn try_into<V: VTable>(self: Arc<Self>) -> Result<V::Array, Arc<Self>> {
-        match self.is::<V>() {
-            true => {
-                let arc = self
-                    .as_any_arc()
-                    .downcast::<ArrayAdapter<V>>()
-                    .map_err(|_| vortex_err!("failed to downcast"))
-                    .vortex_expect("Failed to downcast");
-                Ok(match Arc::try_unwrap(arc) {
-                    Ok(array) => array.0,
-                    Err(arc) => arc.deref().0.clone(),
-                })
-            }
-            false => Err(self),
-        }
-    }
-
-    pub fn as_constant(&self) -> Option<Scalar> {
-        self.as_opt::<ConstantVTable>().map(|a| a.scalar().clone())
-    }
-
-    /// Total size of the array in bytes, including all children and buffers.
-    pub fn nbytes(&self) -> u64 {
-        let mut nbytes = 0;
-        for array in self.depth_first_traversal() {
-            for buffer in array.buffers() {
-                nbytes += buffer.len() as u64;
-            }
-        }
-        nbytes
-    }
-
-    /// Returns whether this array is an arrow encoding.
-    pub fn is_arrow(&self) -> bool {
-        self.is::<NullVTable>()
-            || self.is::<BoolVTable>()
-            || self.is::<PrimitiveVTable>()
-            || self.is::<VarBinVTable>()
-            || self.is::<VarBinViewVTable>()
-    }
-
-    /// Whether the array is of a canonical encoding.
-    pub fn is_canonical(&self) -> bool {
-        self.is::<AnyCanonical>()
-    }
+    ) -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Trait for converting a type into a Vortex [`ArrayRef`].
@@ -361,238 +177,66 @@ pub trait IntoArray {
     fn into_array(self) -> ArrayRef;
 }
 
-impl IntoArray for ArrayRef {
-    fn into_array(self) -> ArrayRef {
-        self
-    }
-}
-
 mod private {
     use super::*;
 
     pub trait Sealed {}
 
-    impl<V: VTable> Sealed for ArrayAdapter<V> {}
-    impl Sealed for Arc<dyn Array> {}
-}
-
-/// Adapter struct used to lift the [`VTable`] trait into an object-safe [`Array`]
-/// implementation.
-///
-/// Since this is a unit struct with `repr(transparent)`, we are able to turn un-adapted array
-/// structs into [`dyn Array`] using some cheeky casting inside [`std::ops::Deref`] and
-/// [`AsRef`]. See the `vtable!` macro for more details.
-#[repr(transparent)]
-pub struct ArrayAdapter<V: VTable>(V::Array);
-
-impl<V: VTable> ArrayAdapter<V> {
-    /// Provide a reference to the underlying array held within the adapter.
-    pub fn as_inner(&self) -> &V::Array {
-        &self.0
-    }
+    impl<V: VTable> Sealed for ArrayInner<V> {}
 }
 
-impl<V: VTable> Debug for ArrayAdapter<V> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl<V: VTable> ReduceNode for ArrayAdapter<V> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn node_dtype(&self) -> VortexResult<DType> {
-        Ok(<V::ArrayVTable as BaseArrayVTable<V>>::dtype(&self.0).clone())
-    }
-
-    fn scalar_fn(&self) -> Option<&ScalarFnRef> {
-        self.0.as_opt::<ScalarFnVTable>().map(|a| a.scalar_fn())
-    }
-
-    fn child(&self, idx: usize) -> ReduceNodeRef {
-        self.nth_child(idx)
-            .unwrap_or_else(|| vortex_panic!("Child index out of bounds: {}", idx))
-    }
-
-    fn child_count(&self) -> usize {
-        self.nchildren()
-    }
-}
+// =============================================================================
+// New path: DynArray and supporting trait impls for ArrayInner<V>
+// =============================================================================
 
-impl<V: VTable> Array for ArrayAdapter<V> {
+/// DynArray implementation for [`ArrayInner<V>`].
+///
+/// This is self-contained: identity methods use `ArrayInner<V>`'s own fields (dtype, len, stats),
+/// while data-access methods delegate to VTable methods on the inner `V::ArrayData`.
+impl<V: VTable> DynArray for ArrayInner<V> {
     fn as_any(&self) -> &dyn Any {
         self
     }
 
-    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
+    fn into_any_arc(self: std::sync::Arc<Self>) -> std::sync::Arc<dyn Any + Send + Sync> {
         self
     }
 
-    fn to_array(&self) -> ArrayRef {
-        Arc::new(ArrayAdapter::<V>(self.0.clone()))
-    }
-
     fn len(&self) -> usize {
-        <V::ArrayVTable as BaseArrayVTable<V>>::len(&self.0)
+        self.len
     }
 
     fn dtype(&self) -> &DType {
-        <V::ArrayVTable as BaseArrayVTable<V>>::dtype(&self.0)
+        &self.dtype
     }
 
-    fn vtable(&self) -> &dyn DynVTable {
-        V::vtable()
+    fn slots(&self) -> &[Option<ArrayRef>] {
+        &self.slots
     }
 
     fn encoding_id(&self) -> ArrayId {
-        V::id(&self.0)
-    }
-
-    fn slice(&self, range: Range<usize>) -> VortexResult<ArrayRef> {
-        let start = range.start;
-        let stop = range.end;
-
-        if start == 0 && stop == self.len() {
-            return Ok(self.to_array());
-        }
-
-        vortex_ensure!(
-            start <= self.len(),
-            "OutOfBounds: start {start} > length {}",
-            self.len()
-        );
-        vortex_ensure!(
-            stop <= self.len(),
-            "OutOfBounds: stop {stop} > length {}",
-            self.len()
-        );
-
-        vortex_ensure!(start <= stop, "start ({start}) must be <= stop ({stop})");
-
-        if start == stop {
-            return Ok(Canonical::empty(self.dtype()).into_array());
-        }
-
-        let sliced = SliceArray::try_new(self.to_array(), range)?
-            .into_array()
-            .optimize()?;
-
-        // Propagate some stats from the original array to the sliced array.
-        if !sliced.is::<ConstantVTable>() {
-            self.statistics().with_iter(|iter| {
-                sliced.statistics().inherit(iter.filter(|(stat, value)| {
-                    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()
-                    })
-                }));
-            });
-        }
-
-        Ok(sliced)
-    }
-
-    fn filter(&self, mask: Mask) -> VortexResult<ArrayRef> {
-        FilterArray::try_new(self.to_array(), mask)?
-            .into_array()
-            .optimize()
-    }
-
-    fn take(&self, indices: ArrayRef) -> VortexResult<ArrayRef> {
-        DictArray::try_new(indices, self.to_array())?
-            .into_array()
-            .optimize()
-    }
-
-    fn scalar_at(&self, index: usize) -> VortexResult<Scalar> {
-        vortex_ensure!(index < self.len(), OutOfBounds: index, 0, self.len());
-        if self.is_invalid(index)? {
-            return Ok(Scalar::null(self.dtype().clone()));
-        }
-        let scalar = <V::OperationsVTable as OperationsVTable<V>>::scalar_at(&self.0, index)?;
-        vortex_ensure!(self.dtype() == scalar.dtype(), "Scalar dtype mismatch");
-        Ok(scalar)
-    }
-
-    fn is_valid(&self, index: usize) -> VortexResult<bool> {
-        vortex_ensure!(index < self.len(), OutOfBounds: index, 0, self.len());
-        match self.validity()? {
-            Validity::NonNullable | Validity::AllValid => Ok(true),
-            Validity::AllInvalid => Ok(false),
-            Validity::Array(a) => a
-                .scalar_at(index)?
-                .as_bool()
-                .value()
-                .ok_or_else(|| vortex_err!("validity value at index {} is null", index)),
-        }
+        self.vtable.id()
     }
 
-    fn is_invalid(&self, index: usize) -> VortexResult<bool> {
-        Ok(!self.is_valid(index)?)
+    fn scalar_at(&self, this: &ArrayRef, index: usize) -> VortexResult<Scalar> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        <V::OperationsVTable as OperationsVTable<V>>::scalar_at(
+            view,
+            index,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
     }
 
-    fn all_valid(&self) -> VortexResult<bool> {
-        match self.validity()? {
-            Validity::NonNullable | Validity::AllValid => Ok(true),
-            Validity::AllInvalid => Ok(false),
-            Validity::Array(a) => Ok(a.statistics().compute_min::<bool>().unwrap_or(false)),
-        }
-    }
-
-    fn all_invalid(&self) -> VortexResult<bool> {
-        match self.validity()? {
-            Validity::NonNullable | Validity::AllValid => Ok(false),
-            Validity::AllInvalid => Ok(true),
-            Validity::Array(a) => Ok(!a.statistics().compute_max::<bool>().unwrap_or(true)),
-        }
-    }
-
-    fn valid_count(&self) -> VortexResult<usize> {
-        if let Some(Precision::Exact(invalid_count)) =
-            self.statistics().get_as::<usize>(Stat::NullCount)
-        {
-            return Ok(self.len() - invalid_count);
-        }
-
-        let count = match self.validity()? {
-            Validity::NonNullable | Validity::AllValid => self.len(),
-            Validity::AllInvalid => 0,
-            Validity::Array(a) => {
-                let sum = compute::sum(&a)?;
-                sum.as_primitive()
-                    .as_::<usize>()
-                    .ok_or_else(|| vortex_err!("sum of validity array is null"))?
-            }
-        };
-        vortex_ensure!(count <= self.len(), "Valid count exceeds array length");
-
-        self.statistics()
-            .set(Stat::NullCount, Precision::exact(self.len() - count));
-
-        Ok(count)
-    }
-
-    fn invalid_count(&self) -> VortexResult<usize> {
-        Ok(self.len() - self.valid_count()?)
-    }
-
-    fn validity(&self) -> VortexResult<Validity> {
-        if self.dtype().is_nullable() {
-            let validity = <V::ValidityVTable as ValidityVTable<V>>::validity(&self.0)?;
+    fn validity(&self, this: &ArrayRef) -> VortexResult<Validity> {
+        if self.dtype.is_nullable() {
+            let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+            let validity = <V::ValidityVTable as ValidityVTable<V>>::validity(view)?;
             if let Validity::Array(array) = &validity {
-                vortex_ensure!(array.len() == self.len(), "Validity array length mismatch");
+                vortex_ensure!(array.len() == self.len, "Validity array length mismatch");
                 vortex_ensure!(
                     matches!(array.dtype(), DType::Bool(Nullability::NonNullable)),
                     "Validity array is not non-nullable boolean: {}",
-                    self.encoding_id(),
+                    self.vtable.id(),
                 );
             }
             Ok(validity)
@@ -601,225 +245,269 @@ impl<V: VTable> Array for ArrayAdapter<V> {
         }
     }
 
-    fn validity_mask(&self) -> VortexResult<Mask> {
-        match self.validity()? {
-            Validity::NonNullable | Validity::AllValid => Ok(Mask::new_true(self.len())),
-            Validity::AllInvalid => Ok(Mask::new_false(self.len())),
-            Validity::Array(a) => a.try_to_mask_fill_null_false(),
-        }
-    }
-
-    fn to_canonical(&self) -> VortexResult<Canonical> {
-        self.to_array()
-            .execute(&mut LEGACY_SESSION.create_execution_ctx())
-    }
-
     fn append_to_builder(
         &self,
+        this: &ArrayRef,
         builder: &mut dyn ArrayBuilder,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
-        if builder.dtype() != self.dtype() {
+        if builder.dtype() != &self.dtype {
             vortex_panic!(
                 "Builder dtype mismatch: expected {}, got {}",
-                self.dtype(),
+                self.dtype,
                 builder.dtype(),
             );
         }
         let len = builder.len();
 
-        V::append_to_builder(&self.0, builder, ctx)?;
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        V::append_to_builder(view, builder, ctx)?;
 
         assert_eq!(
-            len + self.len(),
+            len + self.len,
             builder.len(),
             "Builder length mismatch after writing array for encoding {}",
-            self.encoding_id(),
+            self.vtable.id(),
         );
         Ok(())
     }
 
-    fn statistics(&self) -> StatsSetRef<'_> {
-        <V::ArrayVTable as BaseArrayVTable<V>>::stats(&self.0)
+    fn statistics(&self) -> &ArrayStats {
+        &self.stats
     }
 
-    fn with_children(&self, children: Vec<ArrayRef>) -> VortexResult<ArrayRef> {
-        let mut this = self.0.clone();
-        V::with_children(&mut this, children)?;
-        Ok(this.into_array())
+    fn children(&self, this: &ArrayRef) -> Vec<ArrayRef> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nchildren(view)).map(|i| V::child(view, i)).collect()
     }
-}
 
-impl<V: VTable> ArrayHash for ArrayAdapter<V> {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: hash::Precision) {
-        self.0.encoding_id().hash(state);
-        <V::ArrayVTable as BaseArrayVTable<V>>::array_hash(&self.0, state, precision);
+    fn nchildren(&self, this: &ArrayRef) -> usize {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        V::nchildren(view)
     }
-}
 
-impl<V: VTable> ArrayEq for ArrayAdapter<V> {
-    fn array_eq(&self, other: &Self, precision: hash::Precision) -> bool {
-        <V::ArrayVTable as BaseArrayVTable<V>>::array_eq(&self.0, &other.0, precision)
+    fn nth_child(&self, this: &ArrayRef, idx: usize) -> Option<ArrayRef> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (idx < V::nchildren(view)).then(|| V::child(view, idx))
     }
-}
 
-impl<V: VTable> ArrayVisitor for ArrayAdapter<V> {
-    fn children(&self) -> Vec<ArrayRef> {
-        struct ChildrenCollector {
-            children: Vec<ArrayRef>,
-        }
-
-        impl ArrayChildVisitorUnnamed for ChildrenCollector {
-            fn visit_child(&mut self, array: &ArrayRef) {
-                self.children.push(array.clone());
-            }
-        }
-
-        let mut collector = ChildrenCollector {
-            children: Vec::new(),
-        };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(&self.0, &mut collector);
-        collector.children
+    fn children_names(&self, this: &ArrayRef) -> Vec<String> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nchildren(view))
+            .map(|i| V::child_name(view, i))
+            .collect()
     }
 
-    fn nchildren(&self) -> usize {
-        <V::VisitorVTable as VisitorVTable<V>>::nchildren(&self.0)
+    fn named_children(&self, this: &ArrayRef) -> Vec<(String, ArrayRef)> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nchildren(view))
+            .map(|i| (V::child_name(view, i), V::child(view, i)))
+            .collect()
     }
 
-    fn nth_child(&self, idx: usize) -> Option<ArrayRef> {
-        <V::VisitorVTable as VisitorVTable<V>>::nth_child(&self.0, idx)
+    fn buffers(&self, this: &ArrayRef) -> Vec<ByteBuffer> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nbuffers(view))
+            .map(|i| V::buffer(view, i).to_host_sync())
+            .collect()
     }
 
-    fn children_names(&self) -> Vec<String> {
-        struct ChildNameCollector {
-            names: Vec<String>,
-        }
-
-        impl ArrayChildVisitor for ChildNameCollector {
-            fn visit_child(&mut self, name: &str, _array: &ArrayRef) {
-                self.names.push(name.to_string());
-            }
-        }
+    fn buffer_handles(&self, this: &ArrayRef) -> Vec<BufferHandle> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nbuffers(view)).map(|i| V::buffer(view, i)).collect()
+    }
 
-        let mut collector = ChildNameCollector { names: Vec::new() };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(&self.0, &mut collector);
-        collector.names
+    fn buffer_names(&self, this: &ArrayRef) -> Vec<String> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nbuffers(view))
+            .filter_map(|i| V::buffer_name(view, i))
+            .collect()
     }
 
-    fn named_children(&self) -> Vec<(String, ArrayRef)> {
-        struct NamedChildrenCollector {
-            children: Vec<(String, ArrayRef)>,
-        }
+    fn named_buffers(&self, this: &ArrayRef) -> Vec<(String, BufferHandle)> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        (0..V::nbuffers(view))
+            .filter_map(|i| V::buffer_name(view, i).map(|name| (name, V::buffer(view, i))))
+            .collect()
+    }
 
-        impl ArrayChildVisitor for NamedChildrenCollector {
-            fn visit_child(&mut self, name: &str, array: &ArrayRef) {
-                self.children.push((name.to_string(), array.to_array()));
-            }
-        }
+    fn nbuffers(&self, this: &ArrayRef) -> usize {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        V::nbuffers(view)
+    }
 
-        let mut collector = NamedChildrenCollector {
-            children: Vec::new(),
-        };
+    fn slot_name(&self, this: &ArrayRef, idx: usize) -> String {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        V::slot_name(view, idx)
+    }
 
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(&self.0, &mut collector);
-        collector.children
+    fn metadata(&self, this: &ArrayRef, session: &VortexSession) -> VortexResult<Option<Vec<u8>>> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        V::serialize(view, session)
     }
 
-    fn buffers(&self) -> Vec<ByteBuffer> {
-        struct BufferCollector {
-            buffers: Vec<ByteBuffer>,
-        }
+    fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.data, f)
+    }
 
-        impl ArrayBufferVisitor for BufferCollector {
-            fn visit_buffer_handle(&mut self, _name: &str, handle: &BufferHandle) {
-                self.buffers.push(handle.to_host_sync());
-            }
+    fn dyn_array_hash(&self, state: &mut dyn Hasher, precision: crate::Precision) {
+        let mut wrapper = HasherWrapper(state);
+        self.len.hash(&mut wrapper);
+        self.dtype.hash(&mut wrapper);
+        self.vtable.id().hash(&mut wrapper);
+        self.slots.len().hash(&mut wrapper);
+        for slot in &self.slots {
+            slot.array_hash(&mut wrapper, precision);
         }
-
-        let mut collector = BufferCollector {
-            buffers: Vec::new(),
+        self.data.array_hash(&mut wrapper, precision);
+    }
+
+    fn dyn_array_eq(&self, other: &ArrayRef, precision: crate::Precision) -> bool {
+        other
+            .inner()
+            .as_any()
+            .downcast_ref::<Self>()
+            .is_some_and(|other_inner| {
+                self.len == other.len()
+                    && self.dtype == *other.dtype()
+                    && self.vtable.id() == other.encoding_id()
+                    && self.slots.len() == other_inner.slots.len()
+                    && self
+                        .slots
+                        .iter()
+                        .zip(other_inner.slots.iter())
+                        .all(|(slot, other_slot)| slot.array_eq(other_slot, precision))
+                    && self.data.array_eq(&other_inner.data, precision)
+            })
+    }
+
+    fn with_slots(&self, this: ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef> {
+        let data = self.data.clone();
+        let stats = this.statistics().to_owned();
+        Ok(Array::<V>::try_from_parts(
+            ArrayParts::new(self.vtable.clone(), this.dtype().clone(), this.len(), data)
+                .with_slots(slots),
+        )?
+        .with_stats_set(stats)
+        .into_array())
+    }
+
+    fn reduce(&self, this: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        let Some(reduced) = V::reduce(view)? else {
+            return Ok(None);
         };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_buffers(&self.0, &mut collector);
-        collector.buffers
+        vortex_ensure!(
+            reduced.len() == this.len(),
+            "Reduced array length mismatch from {} to {}",
+            this.encoding_id(),
+            reduced.encoding_id()
+        );
+        vortex_ensure!(
+            reduced.dtype() == this.dtype(),
+            "Reduced array dtype mismatch from {} to {}",
+            this.encoding_id(),
+            reduced.encoding_id()
+        );
+        Ok(Some(reduced))
     }
 
-    fn buffer_handles(&self) -> Vec<BufferHandle> {
-        struct BufferHandleCollector {
-            handles: Vec<BufferHandle>,
-        }
+    fn reduce_parent(
+        &self,
+        this: &ArrayRef,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        let Some(reduced) = V::reduce_parent(view, parent, child_idx)? else {
+            return Ok(None);
+        };
 
-        impl ArrayBufferVisitor for BufferHandleCollector {
-            fn visit_buffer_handle(&mut self, _name: &str, handle: &BufferHandle) {
-                self.handles.push(handle.clone());
-            }
-        }
+        vortex_ensure!(
+            reduced.len() == parent.len(),
+            "Reduced array length mismatch from {} to {}",
+            parent.encoding_id(),
+            reduced.encoding_id()
+        );
+        vortex_ensure!(
+            reduced.dtype() == parent.dtype(),
+            "Reduced array dtype mismatch from {} to {}",
+            parent.encoding_id(),
+            reduced.encoding_id()
+        );
 
-        let mut collector = BufferHandleCollector {
-            handles: Vec::new(),
-        };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_buffers(&self.0, &mut collector);
-        collector.handles
+        Ok(Some(reduced))
     }
 
-    fn buffer_names(&self) -> Vec<String> {
-        <V::VisitorVTable as VisitorVTable<V>>::buffer_names(&self.0)
-    }
+    fn execute(&self, this: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let len = this.len();
+        let dtype = this.dtype().clone();
+        let stats = this.statistics().to_owned();
 
-    fn named_buffers(&self) -> Vec<(String, BufferHandle)> {
-        struct NamedBufferCollector {
-            buffers: Vec<(String, BufferHandle)>,
-        }
+        let typed = Array::<V>::try_from_array_ref(this)
+            .map_err(|_| vortex_err!("Failed to downcast array for execute"))
+            .vortex_expect("Failed to downcast array for execute");
+        let result = V::execute(typed, ctx)?;
 
-        impl ArrayBufferVisitor for NamedBufferCollector {
-            fn visit_buffer_handle(&mut self, name: &str, handle: &BufferHandle) {
-                self.buffers.push((name.to_string(), handle.clone()));
+        if matches!(result.step(), ExecutionStep::Done) {
+            if cfg!(debug_assertions) {
+                vortex_ensure!(
+                    result.array().len() == len,
+                    "Result length mismatch for {:?}",
+                    self.vtable
+                );
+                vortex_ensure!(
+                    result.array().dtype() == &dtype,
+                    "Executed canonical dtype mismatch for {:?}",
+                    self.vtable
+                );
             }
-        }
 
-        let mut collector = NamedBufferCollector {
-            buffers: Vec::new(),
-        };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_buffers(&self.0, &mut collector);
-        collector.buffers
-    }
-
-    fn nbuffers(&self) -> usize {
-        <V::VisitorVTable as VisitorVTable<V>>::nbuffers(&self.0)
-    }
+            result.array().statistics().set_iter(stats.into_iter());
+        }
 
-    fn metadata(&self) -> VortexResult<Option<Vec<u8>>> {
-        V::serialize(V::metadata(&self.0)?)
+        Ok(result)
     }
 
-    fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match V::metadata(&self.0) {
-            Err(e) => write!(f, "<serde error: {e}>"),
-            Ok(metadata) => Debug::fmt(&metadata, f),
-        }
-    }
+    fn execute_parent(
+        &self,
+        this: &ArrayRef,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
+        let Some(result) = V::execute_parent(view, parent, child_idx, ctx)? else {
+            return Ok(None);
+        };
 
-    fn is_host(&self) -> bool {
-        for array in self.depth_first_traversal() {
-            if !array.buffer_handles().iter().all(BufferHandle::is_on_host) {
-                return false;
-            }
+        if cfg!(debug_assertions) {
+            vortex_ensure!(
+                result.len() == parent.len(),
+                "Executed parent canonical length mismatch"
+            );
+            vortex_ensure!(
+                result.dtype() == parent.dtype(),
+                "Executed parent canonical dtype mismatch"
+            );
         }
 
-        true
+        Ok(Some(result))
     }
 }
 
-/// Implement a matcher for a specific VTable type
-impl<V: VTable> Matcher for V {
-    type Match<'a> = &'a V::Array;
+/// Wrapper around `&mut dyn Hasher` that implements `Hasher` (and is `Sized`).
+struct HasherWrapper<'a>(&'a mut dyn Hasher);
 
-    fn matches(array: &dyn Array) -> bool {
-        Array::as_any(array).is::<ArrayAdapter<V>>()
+impl Hasher for HasherWrapper<'_> {
+    fn finish(&self) -> u64 {
+        self.0.finish()
     }
 
-    fn try_match<'a>(array: &'a dyn Array) -> Option<Self::Match<'a>> {
-        Array::as_any(array)
-            .downcast_ref::<ArrayAdapter<V>>()
-            .map(|array_adapter| &array_adapter.0)
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.write(bytes);
     }
 }
+
+/// ArrayId is a globally unique name for the array's vtable.
+pub type ArrayId = ArcRef<str>;
diff --git a/vortex-array/src/array/plugin.rs b/vortex-array/src/array/plugin.rs
new file mode 100644
index 00000000000..bff76a30c59
--- /dev/null
+++ b/vortex-array/src/array/plugin.rs
@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::VTable;
+use crate::buffer::BufferHandle;
+use crate::dtype::DType;
+use crate::serde::ArrayChildren;
+
+/// Reference-counted array plugin.
+pub type ArrayPluginRef = Arc<dyn ArrayPlugin>;
+
+/// Registry trait for ID-based deserialization of arrays.
+///
+/// Plugins are registered in the session by their [`ArrayId`]. When a serialized array is
+/// encountered, the session resolves the ID to the plugin and calls [`deserialize`] to reconstruct
+/// the value as an [`ArrayRef`].
+///
+/// [`deserialize`]: ArrayPlugin::deserialize
+pub trait ArrayPlugin: 'static + Send + Sync {
+    /// Returns the ID for this array encoding.
+    fn id(&self) -> ArrayId;
+
+    /// Serialize the array metadata.
+    ///
+    /// This function will only be called for arrays where the encoding ID matches that of this
+    /// plugin.
+    fn serialize(&self, array: &ArrayRef, session: &VortexSession)
+    -> VortexResult<Option<Vec<u8>>>;
+
+    /// Deserialize an array from serialized components.
+    ///
+    /// The returned array doesn't necessary have to match this plugin's encoding ID. This is
+    /// useful for implementing back-compat logic and deserializing arrays into the new version.
+    #[allow(clippy::too_many_arguments)]
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayRef>;
+}
+
+impl std::fmt::Debug for dyn ArrayPlugin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("ArrayPlugin").field(&self.id()).finish()
+    }
+}
+
+impl<V: VTable> ArrayPlugin for V {
+    fn id(&self) -> ArrayId {
+        VTable::id(self)
+    }
+
+    fn serialize(
+        &self,
+        array: &ArrayRef,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        assert_eq!(
+            self.id(),
+            array.encoding_id(),
+            "Invoked for incorrect array ID"
+        );
+        V::serialize(array.as_::<V>(), session)
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<ArrayRef> {
+        Ok(Array::<V>::try_from_parts(V::deserialize(
+            self, dtype, len, metadata, buffers, children, session,
+        )?)?
+        .into_array())
+    }
+}
diff --git a/vortex-array/src/array/typed.rs b/vortex-array/src/array/typed.rs
new file mode 100644
index 00000000000..0d8239af589
--- /dev/null
+++ b/vortex-array/src/array/typed.rs
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Typed array wrappers: [`ArrayInner<V>`] (heap-allocated), [`Array<V>`] (typed handle),
+//! and [`ArrayView<V>`] (lightweight borrow).
+
+use std::any::Any;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::ops::DerefMut;
+use std::sync::Arc;
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::dtype::DType;
+use crate::stats::ArrayStats;
+use crate::stats::StatsSet;
+use crate::stats::StatsSetRef;
+use crate::validity::Validity;
+
+/// Construction parameters for typed arrays.
+pub struct ArrayParts<V: VTable> {
+    pub vtable: V,
+    pub dtype: DType,
+    pub len: usize,
+    pub data: V::ArrayData,
+    pub slots: Vec<Option<ArrayRef>>,
+}
+
+impl<V: VTable> ArrayParts<V> {
+    pub fn new(vtable: V, dtype: DType, len: usize, data: V::ArrayData) -> Self {
+        Self {
+            vtable,
+            dtype,
+            len,
+            data,
+            slots: Vec::new(),
+        }
+    }
+
+    pub fn with_slots(mut self, slots: Vec<Option<ArrayRef>>) -> Self {
+        self.slots = slots;
+        self
+    }
+}
+
+/// Shared bound for helpers that should work over both owned [`Array<V>`] and borrowed
+/// [`ArrayView<V>`].
+///
+/// Extension traits use this to share typed array logic while still exposing the backing
+/// [`ArrayRef`] and the encoding-specific [`VTable::ArrayData`].
+pub trait TypedArrayRef<V: VTable>: AsRef<ArrayRef> + Deref<Target = V::ArrayData> {
+    /// Returns an owned [`Array<V>`] from the reference.
+    fn to_owned(&self) -> Array<V> {
+        self.as_ref().clone().downcast()
+    }
+}
+
+impl<V: VTable> TypedArrayRef<V> for Array<V> {}
+
+impl<V: VTable> TypedArrayRef<V> for ArrayView<'_, V> {}
+// =============================================================================
+// ArrayInner<V> — the concrete type stored inside Arc<dyn DynArray>
+// =============================================================================
+
+/// The concrete array type that lives inside an `Arc` behind [`ArrayRef`].
+///
+/// Prefer using [`Array<V>`] (owned typed handle) for constructing arrays
+/// and converting between typed and untyped representations.
+/// This type is returned by reference from [`Matcher`] downcasts.
+#[doc(hidden)]
+pub(crate) struct ArrayInner<V: VTable> {
+    pub(crate) vtable: V,
+    pub(crate) dtype: DType,
+    pub(crate) len: usize,
+    pub(crate) data: V::ArrayData,
+    pub(crate) slots: Vec<Option<ArrayRef>>,
+    pub(crate) stats: ArrayStats,
+}
+
+impl<V: VTable> ArrayInner<V> {
+    /// Create a new inner array from explicit construction parameters.
+    #[doc(hidden)]
+    pub fn try_new(new: ArrayParts<V>) -> VortexResult<Self> {
+        new.vtable
+            .validate(&new.data, &new.dtype, new.len, &new.slots)?;
+        Ok(unsafe {
+            Self::from_data_unchecked(
+                new.vtable,
+                new.dtype,
+                new.len,
+                new.data,
+                new.slots,
+                ArrayStats::default(),
+            )
+        })
+    }
+
+    /// Create without validation.
+    ///
+    /// # Safety
+    /// Caller must ensure dtype and len match the data.
+    pub(crate) unsafe fn from_data_unchecked(
+        vtable: V,
+        dtype: DType,
+        len: usize,
+        data: V::ArrayData,
+        slots: Vec<Option<ArrayRef>>,
+        stats: ArrayStats,
+    ) -> Self {
+        Self {
+            vtable,
+            dtype,
+            len,
+            data,
+            slots,
+            stats,
+        }
+    }
+}
+
+impl<V: VTable> Deref for ArrayInner<V> {
+    type Target = V::ArrayData;
+    fn deref(&self) -> &V::ArrayData {
+        &self.data
+    }
+}
+
+impl<V: VTable> DerefMut for ArrayInner<V> {
+    fn deref_mut(&mut self) -> &mut V::ArrayData {
+        &mut self.data
+    }
+}
+
+impl<V: VTable> Clone for ArrayInner<V> {
+    fn clone(&self) -> Self {
+        Self {
+            vtable: self.vtable.clone(),
+            dtype: self.dtype.clone(),
+            len: self.len,
+            data: self.data.clone(),
+            slots: self.slots.clone(),
+            stats: self.stats.clone(),
+        }
+    }
+}
+
+impl<V: VTable> Debug for ArrayInner<V> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ArrayInner")
+            .field("encoding", &self.vtable.id())
+            .field("dtype", &self.dtype)
+            .field("len", &self.len)
+            .field("inner", &self.data)
+            .field("slots", &self.slots)
+            .finish()
+    }
+}
+
+impl<V: VTable> IntoArray for ArrayInner<V> {
+    fn into_array(self) -> ArrayRef {
+        ArrayRef::from_inner(Arc::new(self))
+    }
+}
+
+impl<V: VTable> From<ArrayInner<V>> for ArrayRef {
+    fn from(value: ArrayInner<V>) -> ArrayRef {
+        ArrayRef::from_inner(Arc::new(value))
+    }
+}
+
+// =============================================================================
+// Array<V> — typed owned handle wrapping an ArrayRef
+// =============================================================================
+
+/// A typed owned handle to an array.
+///
+/// `Array<V>` holds an [`ArrayRef`] (shared, heap-allocated) and provides typed access
+/// to the encoding-specific data via [`Deref`] to `V::ArrayData`.
+///
+/// This is the primary type for working with typed arrays. Convert to [`ArrayRef`]
+/// via [`into_array()`](IntoArray::into_array) or [`AsRef<ArrayRef>`].
+pub struct Array<V: VTable> {
+    inner: ArrayRef,
+    _phantom: PhantomData<V>,
+}
+
+#[allow(clippy::same_name_method)]
+impl<V: VTable> Array<V> {
+    /// Create a typed array from explicit construction parameters.
+    pub fn try_from_parts(new: ArrayParts<V>) -> VortexResult<Self> {
+        let inner = ArrayRef::from_inner(Arc::new(ArrayInner::<V>::try_new(new)?));
+        Ok(Self {
+            inner,
+            _phantom: PhantomData,
+        })
+    }
+
+    /// Create a typed array from explicit construction parameters without validation.
+    ///
+    /// # Safety
+    /// Caller must ensure the provided parts are logically consistent.
+    #[doc(hidden)]
+    pub unsafe fn from_parts_unchecked(new: ArrayParts<V>) -> Self {
+        let inner = ArrayRef::from_inner(Arc::new(unsafe {
+            ArrayInner::<V>::from_data_unchecked(
+                new.vtable,
+                new.dtype,
+                new.len,
+                new.data,
+                new.slots,
+                ArrayStats::default(),
+            )
+        }));
+        Self {
+            inner,
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Create from an existing `ArrayRef`, trusting that it contains `ArrayInner<V>`.
+    ///
+    /// # Safety
+    /// Caller must ensure the `ArrayRef` contains an `ArrayInner<V>`.
+    #[allow(dead_code)]
+    pub(crate) unsafe fn from_array_ref_unchecked(array: ArrayRef) -> Self {
+        Self {
+            inner: array,
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Try to create from an `ArrayRef`, returning `Err` if the type doesn't match.
+    pub fn try_from_array_ref(array: ArrayRef) -> Result<Self, ArrayRef> {
+        if array.is::<V>() {
+            Ok(Self {
+                inner: array,
+                _phantom: PhantomData,
+            })
+        } else {
+            Err(array)
+        }
+    }
+
+    /// Returns the dtype.
+    pub fn dtype(&self) -> &DType {
+        self.inner.dtype()
+    }
+
+    /// Returns the length.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns whether this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.len() == 0
+    }
+
+    /// Returns the encoding ID.
+    pub fn encoding_id(&self) -> ArrayId {
+        self.inner.encoding_id()
+    }
+
+    /// Returns the statistics.
+    pub fn statistics(&self) -> StatsSetRef<'_> {
+        self.inner.statistics()
+    }
+
+    /// Returns a reference to the encoding-specific data.
+    pub fn data(&self) -> &V::ArrayData {
+        &self.downcast_inner().data
+    }
+
+    /// Returns the full typed array construction parts if this handle owns the allocation.
+    pub fn try_into_parts(self) -> Result<ArrayParts<V>, Self> {
+        let Self { inner, _phantom } = self;
+        let any = inner.into_inner().into_any_arc();
+        let inner = Arc::downcast::<ArrayInner<V>>(any)
+            .unwrap_or_else(|_| unreachable!("typed array must contain ArrayInner for its vtable"));
+
+        match Arc::try_unwrap(inner) {
+            Ok(inner) => Ok(ArrayParts {
+                vtable: inner.vtable,
+                dtype: inner.dtype,
+                len: inner.len,
+                data: inner.data,
+                slots: inner.slots,
+            }),
+            Err(inner) => Err(Self {
+                inner: ArrayRef::from_inner(inner),
+                _phantom: PhantomData,
+            }),
+        }
+    }
+
+    pub fn with_stats_set(self, stats: StatsSet) -> Self {
+        self.statistics().replace(stats);
+        self
+    }
+
+    /// Returns a clone of the inner encoding-specific data.
+    pub fn into_data(self) -> V::ArrayData {
+        self.downcast_inner().data.clone()
+    }
+
+    /// Returns the array slots.
+    pub fn slots(&self) -> &[Option<ArrayRef>] {
+        &self.downcast_inner().slots
+    }
+
+    /// Returns the internal [`ArrayRef`].
+    #[inline(always)]
+    pub fn as_array(&self) -> &ArrayRef {
+        &self.inner
+    }
+
+    /// Returns an [`ArrayView`] borrowing this array's data.
+    pub fn as_view(&self) -> ArrayView<'_, V> {
+        let inner = self.downcast_inner();
+        // SAFETY: `inner.data` is the `V::ArrayData` stored inside `self.inner`.
+        unsafe { ArrayView::new_unchecked(&self.inner, &inner.data) }
+    }
+
+    /// Downcast the inner `ArrayRef` to `&ArrayInner<V>`.
+    #[inline(always)]
+    fn downcast_inner(&self) -> &ArrayInner<V> {
+        let any = self.inner.inner().as_any();
+        // NOTE(ngates): use downcast_unchecked when it becomes stable
+        debug_assert!(any.is::<ArrayInner<V>>());
+        // SAFETY: caller guarantees that T is the correct type
+        unsafe { &*(any as *const dyn Any as *const ArrayInner<V>) }
+    }
+}
+
+/// Public API methods that shadow `DynArray` / `ArrayRef` methods.
+impl<V: VTable> Array<V> {
+    #[allow(clippy::same_name_method)]
+    pub fn slice(&self, range: std::ops::Range<usize>) -> VortexResult<ArrayRef> {
+        self.inner.slice(range)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn scalar_at(&self, index: usize) -> VortexResult<crate::scalar::Scalar> {
+        self.inner.scalar_at(index)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn filter(&self, mask: vortex_mask::Mask) -> VortexResult<ArrayRef> {
+        self.inner.filter(mask)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn take(&self, indices: ArrayRef) -> VortexResult<ArrayRef> {
+        self.inner.take(indices)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn validity(&self) -> VortexResult<Validity> {
+        self.inner.validity()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn is_valid(&self, index: usize) -> VortexResult<bool> {
+        self.inner.is_valid(index)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn is_invalid(&self, index: usize) -> VortexResult<bool> {
+        self.inner.is_invalid(index)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn all_valid(&self) -> VortexResult<bool> {
+        self.inner.all_valid()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn all_invalid(&self) -> VortexResult<bool> {
+        self.inner.all_invalid()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn to_canonical(&self) -> VortexResult<crate::Canonical> {
+        self.inner.to_canonical()
+    }
+
+    pub fn nbytes(&self) -> u64 {
+        self.inner.nbytes()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn nbuffers(&self) -> usize {
+        self.inner.nbuffers()
+    }
+
+    pub fn as_constant(&self) -> Option<crate::scalar::Scalar> {
+        self.inner.as_constant()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn valid_count(&self) -> VortexResult<usize> {
+        self.inner.valid_count()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn invalid_count(&self) -> VortexResult<usize> {
+        self.inner.invalid_count()
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn append_to_builder(
+        &self,
+        builder: &mut dyn crate::builders::ArrayBuilder,
+        ctx: &mut crate::ExecutionCtx,
+    ) -> VortexResult<()> {
+        self.inner.append_to_builder(builder, ctx)
+    }
+
+    #[allow(clippy::same_name_method)]
+    pub fn validity_mask(&self) -> VortexResult<vortex_mask::Mask> {
+        self.inner.validity_mask()
+    }
+}
+
+impl<V: VTable> Deref for Array<V> {
+    type Target = V::ArrayData;
+
+    fn deref(&self) -> &V::ArrayData {
+        self.data()
+    }
+}
+
+impl<V: VTable> Clone for Array<V> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<V: VTable> Debug for Array<V> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Array")
+            .field("encoding", &self.inner.encoding_id())
+            .field("dtype", self.inner.dtype())
+            .field("len", &self.inner.len())
+            .finish()
+    }
+}
+
+impl<V: VTable> AsRef<ArrayRef> for Array<V> {
+    fn as_ref(&self) -> &ArrayRef {
+        &self.inner
+    }
+}
+
+impl<V: VTable> IntoArray for Array<V> {
+    #[inline(always)]
+    fn into_array(self) -> ArrayRef {
+        self.inner
+    }
+}
+
+impl<V: VTable> IntoArray for Arc<Array<V>> {
+    fn into_array(self) -> ArrayRef {
+        match Arc::try_unwrap(self) {
+            Ok(array) => array.inner,
+            Err(arc) => arc.inner.clone(),
+        }
+    }
+}
+
+impl<V: VTable> From<Array<V>> for ArrayRef {
+    fn from(value: Array<V>) -> ArrayRef {
+        value.inner
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+
+    use super::Array;
+    use crate::arrays::Primitive;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::validity::Validity;
+
+    #[test]
+    fn typed_array_into_parts_roundtrips() {
+        let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable);
+        let expected = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable);
+
+        let parts = array.try_into_parts().unwrap();
+        let rebuilt = Array::<Primitive>::try_from_parts(parts).unwrap();
+
+        assert_arrays_eq!(rebuilt, expected);
+    }
+
+    #[test]
+    fn typed_array_try_into_parts_requires_unique_owner() {
+        let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable);
+        let alias = array.clone();
+
+        let array = match array.try_into_parts() {
+            Ok(_) => panic!("aliased arrays should not move out their backing parts"),
+            Err(array) => array,
+        };
+
+        assert_arrays_eq!(array, alias);
+    }
+}
diff --git a/vortex-array/src/array/view.rs b/vortex-array/src/array/view.rs
new file mode 100644
index 00000000000..c751429abf8
--- /dev/null
+++ b/vortex-array/src/array/view.rs
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::ops::Deref;
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::VTable;
+use crate::dtype::DType;
+use crate::stats::StatsSetRef;
+use crate::validity::Validity;
+
+/// A lightweight, `Copy`-able typed view into an [`ArrayRef`].
+pub struct ArrayView<'a, V: VTable> {
+    array: &'a ArrayRef,
+    data: &'a V::ArrayData,
+}
+
+impl<V: VTable> Copy for ArrayView<'_, V> {}
+
+impl<V: VTable> Clone for ArrayView<'_, V> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, V: VTable> ArrayView<'a, V> {
+    /// # Safety
+    /// Caller must ensure `data` is the `V::ArrayData` stored inside `array`.
+    pub(crate) unsafe fn new_unchecked(array: &'a ArrayRef, data: &'a V::ArrayData) -> Self {
+        debug_assert!(array.is::<V>());
+        Self { array, data }
+    }
+
+    pub fn array(&self) -> &'a ArrayRef {
+        self.array
+    }
+
+    pub fn data(&self) -> &'a V::ArrayData {
+        self.data
+    }
+
+    pub fn slots(&self) -> &'a [Option<ArrayRef>] {
+        self.array.slots()
+    }
+
+    pub fn dtype(&self) -> &DType {
+        self.array.dtype()
+    }
+
+    pub fn len(&self) -> usize {
+        self.array.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.array.len() == 0
+    }
+
+    pub fn encoding_id(&self) -> ArrayId {
+        self.array.encoding_id()
+    }
+
+    pub fn statistics(&self) -> StatsSetRef<'_> {
+        self.array.statistics()
+    }
+
+    pub fn validity(&self) -> VortexResult<Validity> {
+        self.array.validity()
+    }
+
+    pub fn into_owned(self) -> Array<V> {
+        // SAFETY: we are ourselves type checked as 'V'
+        unsafe { Array::<V>::from_array_ref_unchecked(self.array.clone()) }
+    }
+}
+
+impl<V: VTable> AsRef<ArrayRef> for ArrayView<'_, V> {
+    fn as_ref(&self) -> &ArrayRef {
+        self.array
+    }
+}
+
+impl<V: VTable> Deref for ArrayView<'_, V> {
+    type Target = V::ArrayData;
+
+    fn deref(&self) -> &V::ArrayData {
+        self.data
+    }
+}
+
+impl<V: VTable> Debug for ArrayView<'_, V> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ArrayView")
+            .field("encoding", &self.array.encoding_id())
+            .field("dtype", self.array.dtype())
+            .field("len", &self.array.len())
+            .finish()
+    }
+}
diff --git a/vortex-array/src/array/visitor.rs b/vortex-array/src/array/visitor.rs
deleted file mode 100644
index 8067fafc3f4..00000000000
--- a/vortex-array/src/array/visitor.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Formatter;
-use std::sync::Arc;
-
-use vortex_buffer::ByteBuffer;
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::arrays::ConstantArray;
-use crate::buffer::BufferHandle;
-use crate::patches::Patches;
-use crate::validity::Validity;
-
-pub trait ArrayVisitor {
-    /// Returns the children of the array.
-    fn children(&self) -> Vec<ArrayRef>;
-
-    /// Returns the number of children of the array.
-    fn nchildren(&self) -> usize;
-
-    /// Returns the nth child of the array without allocating a Vec.
-    ///
-    /// Returns `None` if the index is out of bounds.
-    fn nth_child(&self, idx: usize) -> Option<ArrayRef>;
-
-    /// Returns the names of the children of the array.
-    fn children_names(&self) -> Vec<String>;
-
-    /// Returns the array's children with their names.
-    fn named_children(&self) -> Vec<(String, ArrayRef)>;
-
-    /// Returns the buffers of the array.
-    fn buffers(&self) -> Vec<ByteBuffer>;
-
-    /// Returns the buffer handles of the array.
-    fn buffer_handles(&self) -> Vec<BufferHandle>;
-
-    /// Returns the names of the buffers of the array.
-    fn buffer_names(&self) -> Vec<String>;
-
-    /// Returns the array's buffers with their names.
-    fn named_buffers(&self) -> Vec<(String, BufferHandle)>;
-
-    /// Returns the number of buffers of the array.
-    fn nbuffers(&self) -> usize;
-
-    /// Returns the serialized metadata of the array, or `None` if the array does not
-    /// support serialization.
-    fn metadata(&self) -> VortexResult<Option<Vec<u8>>>;
-
-    /// Formats a human-readable metadata description.
-    fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
-
-    /// Checks if all buffers in the array tree are host-resident.
-    ///
-    /// This will fail if any buffers of self or child arrays are GPU-resident.
-    fn is_host(&self) -> bool;
-}
-
-impl ArrayVisitor for Arc<dyn Array> {
-    fn children(&self) -> Vec<ArrayRef> {
-        self.as_ref().children()
-    }
-
-    fn nchildren(&self) -> usize {
-        self.as_ref().nchildren()
-    }
-
-    fn nth_child(&self, idx: usize) -> Option<ArrayRef> {
-        self.as_ref().nth_child(idx)
-    }
-
-    fn children_names(&self) -> Vec<String> {
-        self.as_ref().children_names()
-    }
-
-    fn named_children(&self) -> Vec<(String, ArrayRef)> {
-        self.as_ref().named_children()
-    }
-
-    fn buffers(&self) -> Vec<ByteBuffer> {
-        self.as_ref().buffers()
-    }
-
-    fn buffer_handles(&self) -> Vec<BufferHandle> {
-        self.as_ref().buffer_handles()
-    }
-
-    fn buffer_names(&self) -> Vec<String> {
-        self.as_ref().buffer_names()
-    }
-
-    fn named_buffers(&self) -> Vec<(String, BufferHandle)> {
-        self.as_ref().named_buffers()
-    }
-
-    fn nbuffers(&self) -> usize {
-        self.as_ref().nbuffers()
-    }
-
-    fn metadata(&self) -> VortexResult<Option<Vec<u8>>> {
-        self.as_ref().metadata()
-    }
-
-    fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.as_ref().metadata_fmt(f)
-    }
-
-    fn is_host(&self) -> bool {
-        self.as_ref().is_host()
-    }
-}
-
-pub trait ArrayVisitorExt: Array {
-    /// Count the number of buffers encoded by self and all child arrays.
-    fn nbuffers_recursive(&self) -> usize {
-        self.children()
-            .iter()
-            .map(ArrayVisitorExt::nbuffers_recursive)
-            .sum::<usize>()
-            + self.nbuffers()
-    }
-
-    /// Depth-first traversal of the array and its children.
-    fn depth_first_traversal(&self) -> impl Iterator<Item = ArrayRef> {
-        /// A depth-first pre-order iterator over an Array.
-        struct ArrayChildrenIterator {
-            stack: Vec<ArrayRef>,
-        }
-
-        impl Iterator for ArrayChildrenIterator {
-            type Item = ArrayRef;
-
-            fn next(&mut self) -> Option<Self::Item> {
-                let next = self.stack.pop()?;
-                for child in next.children().into_iter().rev() {
-                    self.stack.push(child);
-                }
-                Some(next)
-            }
-        }
-
-        ArrayChildrenIterator {
-            stack: vec![self.to_array()],
-        }
-    }
-}
-
-impl<A: Array + ?Sized> ArrayVisitorExt for A {}
-
-pub trait ArrayBufferVisitor {
-    fn visit_buffer_handle(&mut self, _name: &str, handle: &BufferHandle);
-}
-
-/// A visitor for array children that does not require names.
-///
-/// This is more efficient than [`ArrayChildVisitor`] when you only need to
-/// iterate over children without accessing their names (e.g., for counting
-/// or accessing by index).
-pub trait ArrayChildVisitorUnnamed {
-    /// Visit a child of this array.
-    fn visit_child(&mut self, array: &ArrayRef);
-
-    /// Utility for visiting Array validity.
-    fn visit_validity(&mut self, validity: &Validity, len: usize) {
-        if let Some(vlen) = validity.maybe_len() {
-            assert_eq!(vlen, len, "Validity length mismatch");
-        }
-
-        match validity {
-            Validity::NonNullable | Validity::AllValid => {}
-            Validity::AllInvalid => self.visit_child(&ConstantArray::new(false, len).into_array()),
-            Validity::Array(array) => {
-                self.visit_child(array);
-            }
-        }
-    }
-
-    /// Utility for visiting Array patches.
-    fn visit_patches(&mut self, patches: &Patches) {
-        self.visit_child(patches.indices());
-        self.visit_child(patches.values());
-        if let Some(chunk_offsets) = patches.chunk_offsets() {
-            self.visit_child(chunk_offsets);
-        }
-    }
-}
-
-pub trait ArrayChildVisitor {
-    /// Visit a child of this array.
-    fn visit_child(&mut self, _name: &str, _array: &ArrayRef);
-
-    /// Utility for visiting Array validity.
-    fn visit_validity(&mut self, validity: &Validity, len: usize) {
-        if let Some(vlen) = validity.maybe_len() {
-            assert_eq!(vlen, len, "Validity length mismatch");
-        }
-
-        match validity {
-            Validity::NonNullable | Validity::AllValid => {}
-            Validity::AllInvalid => {
-                // To avoid storing metadata about validity, we store all invalid as a
-                // constant array of false values.
-                // This gives:
-                //  * is_nullable & has_validity => Validity::Array (or Validity::AllInvalid)
-                //  * is_nullable & !has_validity => Validity::AllValid
-                //  * !is_nullable => Validity::NonNullable
-                self.visit_child("validity", &ConstantArray::new(false, len).into_array())
-            }
-            Validity::Array(array) => {
-                self.visit_child("validity", array);
-            }
-        }
-    }
-
-    /// Utility for visiting Array patches.
-    fn visit_patches(&mut self, patches: &Patches) {
-        self.visit_child("patch_indices", patches.indices());
-        self.visit_child("patch_values", patches.values());
-        if let Some(chunk_offsets) = patches.chunk_offsets() {
-            self.visit_child("patch_chunk_offsets", chunk_offsets);
-        }
-    }
-}
diff --git a/vortex-array/src/array/vtable/mod.rs b/vortex-array/src/array/vtable/mod.rs
new file mode 100644
index 00000000000..2b65853bb88
--- /dev/null
+++ b/vortex-array/src/array/vtable/mod.rs
@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! This module contains the VTable definitions for a Vortex encoding.
+
+mod operations;
+mod validity;
+
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
+
+pub use operations::*;
+pub use validity::*;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
+
+use crate::Array;
+use crate::ArrayRef;
+use crate::ArrayView;
+use crate::Canonical;
+use crate::ExecutionResult;
+use crate::IntoArray;
+use crate::Precision;
+pub use crate::array::plugin::*;
+use crate::arrays::ConstantArray;
+use crate::arrays::constant::Constant;
+use crate::buffer::BufferHandle;
+use crate::builders::ArrayBuilder;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::executor::ExecutionCtx;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
+use crate::patches::Patches;
+use crate::scalar::ScalarValue;
+use crate::serde::ArrayChildren;
+use crate::validity::Validity;
+
+/// The array [`VTable`] encapsulates logic for an Array type within Vortex.
+///
+/// The logic is split across several "VTable" traits to enable easier code organization than
+/// simply lumping everything into a single trait.
+///
+/// From this [`VTable`] trait, we derive implementations for the sealed `DynArray` trait and the
+/// public [`ArrayPlugin`] registry trait.
+///
+/// The functions defined in these vtable traits will typically document their pre- and
+/// post-conditions. The pre-conditions are validated inside the `DynArray` and [`ArrayRef`]
+/// implementations so do not need to be checked in the vtable implementations (for example, index
+/// out of bounds). Post-conditions are validated after invocation of the vtable function and will
+/// panic if violated.
+pub trait VTable: 'static + Clone + Sized + Send + Sync + Debug {
+    type ArrayData: 'static + Send + Sync + Clone + Debug + Display + ArrayHash + ArrayEq;
+
+    type OperationsVTable: OperationsVTable<Self>;
+    type ValidityVTable: ValidityVTable<Self>;
+
+    /// Returns the ID of the array.
+    fn id(&self) -> ArrayId;
+
+    /// Validates that externally supplied logical metadata matches the array data.
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()>;
+
+    /// Returns the number of buffers in the array.
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize;
+
+    /// Returns the buffer at the given index.
+    ///
+    /// # Panics
+    /// Panics if `idx >= nbuffers(array)`.
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle;
+
+    /// Returns the name of the buffer at the given index, or `None` if unnamed.
+    fn buffer_name(array: ArrayView<'_, Self>, idx: usize) -> Option<String>;
+
+    /// Returns the number of children in the array.
+    ///
+    /// The default counts non-None slots.
+    fn nchildren(array: ArrayView<'_, Self>) -> usize {
+        array.slots().iter().filter(|s| s.is_some()).count()
+    }
+
+    /// Returns the child at the given index.
+    ///
+    /// The default returns the `idx`-th non-None slot.
+    ///
+    /// # Panics
+    /// Panics if `idx >= nchildren(array)`.
+    fn child(array: ArrayView<'_, Self>, idx: usize) -> ArrayRef {
+        array
+            .slots()
+            .iter()
+            .filter_map(|s| s.clone())
+            .nth(idx)
+            .vortex_expect("child index out of bounds")
+    }
+
+    /// Returns the name of the child at the given index.
+    ///
+    /// The default returns the slot name of the `idx`-th non-None slot.
+    ///
+    /// # Panics
+    /// Panics if `idx >= nchildren(array)`.
+    fn child_name(array: ArrayView<'_, Self>, idx: usize) -> String {
+        array
+            .slots()
+            .iter()
+            .enumerate()
+            .filter(|(_, s)| s.is_some())
+            .nth(idx)
+            .map(|(slot_idx, _)| Self::slot_name(array, slot_idx))
+            .vortex_expect("child_name index out of bounds")
+    }
+
+    /// Serialize metadata into a byte buffer for IPC or file storage.
+    /// Return `None` if the array cannot be serialized.
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>>;
+
+    /// Deserialize an array from serialized components.
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>>;
+
+    /// Writes the array into a canonical builder.
+    fn append_to_builder(
+        array: ArrayView<'_, Self>,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        let canonical = array
+            .array()
+            .clone()
+            .execute::<Canonical>(ctx)?
+            .into_array();
+        builder.extend_from_array(&canonical);
+        Ok(())
+    }
+
+    /// Returns the name of the slot at the given index.
+    ///
+    /// # Panics
+    /// Panics if `idx >= slots(array).len()`.
+    fn slot_name(array: ArrayView<'_, Self>, idx: usize) -> String;
+
+    /// Execute this array by returning an [`ExecutionResult`].
+    ///
+    /// Execution is **iterative**, not recursive. Instead of recursively executing children,
+    /// implementations should return [`ExecutionResult::execute_slot`] to request that the
+    /// scheduler execute a slot first, or [`ExecutionResult::done`] when the encoding can
+    /// produce a result directly.
+    ///
+    /// For good examples of this pattern, see:
+    /// - [`Dict::execute`](crate::arrays::dict::vtable::Dict::execute) — demonstrates
+    ///   requiring children via `require_child!` and producing a result once they are canonical.
+    /// - `BitPacked::execute` (in `vortex-fastlanes`) — demonstrates requiring patches and
+    ///   validity via `require_patches!`/`require_validity!`.
+    ///
+    /// Array execution is designed such that repeated execution of an array will eventually
+    /// converge to a canonical representation. Implementations of this function should therefore
+    /// ensure they make progress towards that goal.
+    ///
+    /// The returned array (in `Done`) must be logically equivalent to the input array. In other
+    /// words, the recursively canonicalized forms of both arrays must be equal.
+    ///
+    /// Debug builds will panic if the returned array is of the wrong type, wrong length, or
+    /// incorrectly contains null values.
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult>;
+
+    /// Attempt to execute the parent of this array.
+    fn execute_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        _ = (array, parent, child_idx, ctx);
+        Ok(None)
+    }
+
+    /// Attempt to reduce the array to a simpler representation.
+    fn reduce(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>> {
+        _ = array;
+        Ok(None)
+    }
+
+    /// Attempt to perform a reduction of the parent of this array.
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        _ = (array, parent, child_idx);
+        Ok(None)
+    }
+}
+
+/// Alias for migration — downstream code can start using `ArrayVTable`.
+pub use VTable as ArrayVTable;
+
+use crate::array::ArrayId;
+
+/// Empty array metadata struct for encodings with no per-array metadata.
+#[derive(Clone, Debug, Default)]
+pub struct EmptyArrayData;
+
+impl ArrayEq for EmptyArrayData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+impl ArrayHash for EmptyArrayData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
+
+impl Display for EmptyArrayData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+/// Placeholder type used to indicate when a particular vtable is not supported by the encoding.
+pub struct NotSupported;
+
+/// Returns the validity as a child array if it produces one.
+#[inline]
+pub fn validity_to_child(validity: &Validity, len: usize) -> Option<ArrayRef> {
+    match validity {
+        Validity::NonNullable | Validity::AllValid => None,
+        Validity::AllInvalid => Some(ConstantArray::new(false, len).into_array()),
+        Validity::Array(array) => Some(array.clone()),
+    }
+}
+
+/// Reconstruct a [`Validity`] from an optional child array and nullability.
+///
+/// This is the inverse of [`validity_to_child`].
+#[inline]
+pub fn child_to_validity(child: &Option<ArrayRef>, nullability: Nullability) -> Validity {
+    match child {
+        Some(arr) => {
+            // Detect constant bool arrays created by validity_to_child.
+            // Use direct ScalarValue matching to avoid expensive scalar conversion.
+            if let Some(c) = arr.as_opt::<Constant>()
+                && let Some(ScalarValue::Bool(val)) = c.scalar().value()
+            {
+                return if *val {
+                    Validity::AllValid
+                } else {
+                    Validity::AllInvalid
+                };
+            }
+            Validity::Array(arr.clone())
+        }
+        None => Validity::from(nullability),
+    }
+}
+
+/// Returns 1 if validity produces a child, 0 otherwise.
+#[inline]
+pub fn validity_nchildren(validity: &Validity) -> usize {
+    match validity {
+        Validity::NonNullable | Validity::AllValid => 0,
+        Validity::AllInvalid | Validity::Array(_) => 1,
+    }
+}
+
+/// Returns the number of children produced by patches.
+#[inline]
+pub fn patches_nchildren(patches: &Patches) -> usize {
+    2 + patches.chunk_offsets().is_some() as usize
+}
+
+/// Returns the child at the given index within a patches component.
+#[inline]
+pub fn patches_child(patches: &Patches, idx: usize) -> ArrayRef {
+    match idx {
+        0 => patches.indices().clone(),
+        1 => patches.values().clone(),
+        2 => patches
+            .chunk_offsets()
+            .as_ref()
+            .vortex_expect("patch_chunk_offsets child out of bounds")
+            .clone(),
+        _ => vortex_panic!("patches child index {idx} out of bounds"),
+    }
+}
+
+/// Returns the name of the child at the given index within a patches component.
+#[inline]
+pub fn patches_child_name(idx: usize) -> &'static str {
+    match idx {
+        0 => "patch_indices",
+        1 => "patch_values",
+        2 => "patch_chunk_offsets",
+        _ => vortex_panic!("patches child name index {idx} out of bounds"),
+    }
+}
diff --git a/vortex-array/src/vtable/operations.rs b/vortex-array/src/array/vtable/operations.rs
similarity index 66%
rename from vortex-array/src/vtable/operations.rs
rename to vortex-array/src/array/vtable/operations.rs
index 3189651e423..a002bc488fa 100644
--- a/vortex-array/src/vtable/operations.rs
+++ b/vortex-array/src/array/vtable/operations.rs
@@ -4,9 +4,11 @@
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::scalar::Scalar;
 use crate::vtable::NotSupported;
-use crate::vtable::VTable;
 
 pub trait OperationsVTable<V: VTable> {
     /// Fetch the scalar at the given index.
@@ -15,11 +17,19 @@ pub trait OperationsVTable<V: VTable> {
     ///
     /// Bounds-checking has already been performed by the time this function is called,
     /// and the index is guaranteed to be non-null.
-    fn scalar_at(array: &V::Array, index: usize) -> VortexResult<Scalar>;
+    fn scalar_at(
+        array: ArrayView<'_, V>,
+        index: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar>;
 }
 
 impl<V: VTable> OperationsVTable<V> for NotSupported {
-    fn scalar_at(array: &V::Array, _index: usize) -> VortexResult<Scalar> {
+    fn scalar_at(
+        array: ArrayView<'_, V>,
+        _index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         vortex_bail!(
             "Legacy scalar_at operation is not supported for {} arrays",
             array.encoding_id()
diff --git a/vortex-array/src/array/vtable/validity.rs b/vortex-array/src/array/vtable/validity.rs
new file mode 100644
index 00000000000..9f2b2989e52
--- /dev/null
+++ b/vortex-array/src/array/vtable/validity.rs
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::validity::Validity;
+
+pub trait ValidityVTable<V: VTable> {
+    /// Returns the [`Validity`] of the array.
+    ///
+    /// ## Pre-conditions
+    ///
+    /// - The array DType is nullable.
+    fn validity(array: ArrayView<'_, V>) -> VortexResult<Validity>;
+}
+
+/// An implementation of the [`ValidityVTable`] for arrays that delegate validity entirely
+/// to a child array.
+pub struct ValidityVTableFromChild;
+
+pub trait ValidityChild<V: VTable> {
+    fn validity_child(array: ArrayView<'_, V>) -> ArrayRef;
+}
+
+impl<V: VTable> ValidityVTable<V> for ValidityVTableFromChild
+where
+    V: ValidityChild<V>,
+{
+    fn validity(array: ArrayView<'_, V>) -> VortexResult<Validity> {
+        V::validity_child(array).validity()
+    }
+}
+
+/// An implementation of the [`ValidityVTable`] for arrays that hold an unsliced validity
+/// and a slice into it.
+pub struct ValidityVTableFromChildSliceHelper;
+
+pub trait ValidityChildSliceHelper {
+    fn unsliced_child_and_slice(&self) -> (&ArrayRef, usize, usize);
+
+    fn sliced_child_array(&self) -> VortexResult<ArrayRef> {
+        let (unsliced_validity, start, stop) = self.unsliced_child_and_slice();
+        unsliced_validity.slice(start..stop)
+    }
+}
+
+impl<V: VTable> ValidityVTable<V> for ValidityVTableFromChildSliceHelper
+where
+    V::ArrayData: ValidityChildSliceHelper,
+{
+    fn validity(array: ArrayView<'_, V>) -> VortexResult<Validity> {
+        array.data().sliced_child_array()?.validity()
+    }
+}
diff --git a/vortex-array/src/arrays/arbitrary.rs b/vortex-array/src/arrays/arbitrary.rs
index 05ad2193308..16099d5c2c1 100644
--- a/vortex-array/src/arrays/arbitrary.rs
+++ b/vortex-array/src/arrays/arbitrary.rs
@@ -11,17 +11,17 @@ use vortex_buffer::BitBuffer;
 use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 
-use super::BoolArray;
-use super::ChunkedArray;
-use super::NullArray;
-use super::PrimitiveArray;
-use super::StructArray;
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
+use crate::arrays::BoolArray;
+use crate::arrays::ChunkedArray;
+use crate::arrays::NullArray;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::StructArray;
 use crate::arrays::VarBinArray;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DecimalBuilder;
 use crate::builders::FixedSizeListBuilder;
@@ -162,7 +162,10 @@ fn random_array_chunk(
             random_fixed_size_list(u, elem_dtype, *list_size, *null, chunk_len)
         }
         DType::Extension(..) => {
-            todo!("Extension arrays are not implemented")
+            unimplemented!("Extension arrays are not implemented")
+        }
+        DType::Variant(_) => {
+            unimplemented!("Variant arrays are not implemented")
         }
     }
 }
@@ -180,7 +183,7 @@ fn random_fixed_size_list(
     let array_length = chunk_len.unwrap_or(u.int_in_range(0..=20)?);
 
     let mut builder =
-        FixedSizeListBuilder::with_capacity(elem_dtype.clone(), list_size, null, array_length);
+        FixedSizeListBuilder::with_capacity(Arc::clone(elem_dtype), list_size, null, array_length);
 
     for _ in 0..array_length {
         if null == Nullability::Nullable && u.arbitrary::<bool>()? {
@@ -226,7 +229,7 @@ fn random_list_with_offset_type<O: IntegerPType>(
 ) -> Result<ArrayRef> {
     let array_length = chunk_len.unwrap_or(u.int_in_range(0..=20)?);
 
-    let mut builder = ListViewBuilder::<O, O>::with_capacity(elem_dtype.clone(), null, 20, 10);
+    let mut builder = ListViewBuilder::<O, O>::with_capacity(Arc::clone(elem_dtype), null, 20, 10);
 
     for _ in 0..array_length {
         if null == Nullability::Nullable && u.arbitrary::<bool>()? {
@@ -252,7 +255,7 @@ fn random_list_scalar(
     let elems = (0..list_size)
         .map(|_| random_scalar(u, elem_dtype))
         .collect::<Result<Vec<_>>>()?;
-    Ok(Scalar::list(elem_dtype.clone(), elems, null))
+    Ok(Scalar::list(Arc::clone(elem_dtype), elems, null))
 }
 
 fn random_string(
diff --git a/vortex-array/src/arrays/assertions.rs b/vortex-array/src/arrays/assertions.rs
index 07fe481d02c..990dde4b37d 100644
--- a/vortex-array/src/arrays/assertions.rs
+++ b/vortex-array/src/arrays/assertions.rs
@@ -4,11 +4,37 @@
 use std::fmt::Display;
 
 use itertools::Itertools;
+use vortex_error::VortexExpect;
 
-pub fn format_indices<I: IntoIterator<Item = usize>>(indices: I) -> impl Display {
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::LEGACY_SESSION;
+use crate::RecursiveCanonical;
+use crate::VortexSessionExecute;
+
+fn format_indices<I: IntoIterator<Item = usize>>(indices: I) -> impl Display {
     indices.into_iter().format(",")
 }
 
+/// Executes an array to recursive canonical form with the given execution context.
+fn execute_to_canonical(array: ArrayRef, ctx: &mut ExecutionCtx) -> ArrayRef {
+    array
+        .execute::<RecursiveCanonical>(ctx)
+        .vortex_expect("failed to execute array to recursive canonical form")
+        .0
+        .into_array()
+}
+
+/// Finds indices where two arrays differ based on `scalar_at` comparison.
+#[expect(clippy::unwrap_used)]
+fn find_mismatched_indices(left: &ArrayRef, right: &ArrayRef) -> Vec<usize> {
+    assert_eq!(left.len(), right.len());
+    (0..left.len())
+        .filter(|i| left.scalar_at(*i).unwrap() != right.scalar_at(*i).unwrap())
+        .collect()
+}
+
 /// Asserts that the scalar at position `$n` in array `$arr` equals `$expected`.
 ///
 /// This is a convenience macro for testing that avoids verbose scalar comparison code.
@@ -21,9 +47,14 @@ pub fn format_indices<I: IntoIterator<Item = usize>>(indices: I) -> impl Display
 /// ```
 #[macro_export]
 macro_rules! assert_nth_scalar {
-    ($arr:expr, $n:expr, $expected:expr) => {
-        assert_eq!($arr.scalar_at($n).unwrap(), $expected.try_into().unwrap());
-    };
+    ($arr:expr, $n:expr, $expected:expr) => {{
+        use $crate::IntoArray as _;
+        let arr_ref: $crate::ArrayRef = $crate::IntoArray::into_array($arr.clone());
+        assert_eq!(
+            arr_ref.scalar_at($n).unwrap(),
+            $expected.try_into().unwrap()
+        );
+    }};
 }
 
 /// Asserts that the scalar at position `$n` in array `$arr` is null.
@@ -36,22 +67,25 @@ macro_rules! assert_nth_scalar {
 /// ```
 #[macro_export]
 macro_rules! assert_nth_scalar_is_null {
-    ($arr:expr, $n:expr) => {
+    ($arr:expr, $n:expr) => {{
+        let arr_ref: $crate::ArrayRef = $crate::IntoArray::into_array($arr.clone());
         assert!(
-            $arr.scalar_at($n).unwrap().is_null(),
+            arr_ref.scalar_at($n).unwrap().is_null(),
             "expected scalar at index {} to be null, but was {:?}",
             $n,
-            $arr.scalar_at($n).unwrap()
+            arr_ref.scalar_at($n).unwrap()
         );
-    };
+    }};
 }
 
 #[macro_export]
 macro_rules! assert_arrays_eq {
     ($left:expr, $right:expr) => {{
-       let left = $left.clone();
-       let right = $right.clone();
-       if left.dtype() != right.dtype() {
+
+
+        let left: $crate::ArrayRef = $crate::IntoArray::into_array($left.clone());
+        let right: $crate::ArrayRef = $crate::IntoArray::into_array($right.clone());
+        if left.dtype() != right.dtype() {
             panic!(
                 "assertion left == right failed: arrays differ in type: {} != {}.\n  left: {}\n right: {}",
                 left.dtype(),
@@ -61,26 +95,54 @@ macro_rules! assert_arrays_eq {
             )
         }
 
-        if left.len() != right.len() {
-            panic!(
-                "assertion left == right failed: arrays differ in length: {} != {}.\n  left: {}\n right: {}",
-                left.len(),
-                right.len(),
-                left.display_values(),
-                right.display_values()
-            )
+        assert_eq!(
+            left.len(),
+            right.len(),
+            "assertion left == right failed: arrays differ in length: {} != {}.\n  left: {}\n right: {}",
+            left.len(),
+            right.len(),
+            left.display_values(),
+            right.display_values()
+        );
+
+        #[allow(deprecated)]
+        let left = left.clone();
+        #[allow(deprecated)]
+        let right = right.clone();
+        $crate::arrays::assert_arrays_eq_impl(&left, &right);
+    }};
+}
+
+/// Implementation of `assert_arrays_eq!` — called by the macro after converting inputs to
+/// `ArrayRef`.
+#[track_caller]
+#[allow(clippy::panic)]
+pub fn assert_arrays_eq_impl(left: &ArrayRef, right: &ArrayRef) {
+    let executed = execute_to_canonical(left.clone(), &mut LEGACY_SESSION.create_execution_ctx());
+
+    let left_right = find_mismatched_indices(left, right);
+    let executed_right = find_mismatched_indices(&executed, right);
+
+    if !left_right.is_empty() || !executed_right.is_empty() {
+        let mut msg = String::new();
+        if !left_right.is_empty() {
+            msg.push_str(&format!(
+                "\n  left != right at indices: {}",
+                format_indices(left_right)
+            ));
         }
-        let n = left.len();
-        let mismatched_indices = (0..n)
-            .filter(|i| left.scalar_at(*i).unwrap() != right.scalar_at(*i).unwrap())
-            .collect::<Vec<_>>();
-        if mismatched_indices.len() != 0 {
-            panic!(
-                "assertion left == right failed: arrays do not match at indices: {}.\n  left: {}\n right: {}",
-                $crate::arrays::format_indices(mismatched_indices),
-                left.display_values(),
-                right.display_values()
-            )
+        if !executed_right.is_empty() {
+            msg.push_str(&format!(
+                "\n  executed != right at indices: {}",
+                format_indices(executed_right)
+            ));
         }
-    }};
+        panic!(
+            "assertion failed: arrays do not match:{}\n     left: {}\n    right: {}\n executed: {}",
+            msg,
+            left.display_values(),
+            right.display_values(),
+            executed.display_values()
+        )
+    }
 }
diff --git a/vortex-array/src/arrays/bool/array.rs b/vortex-array/src/arrays/bool/array.rs
index 67109e2e47e..8a7eed44037 100644
--- a/vortex-array/src/arrays/bool/array.rs
+++ b/vortex-array/src/arrays/bool/array.rs
@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use arrow_array::BooleanArray;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BitBufferMut;
@@ -11,13 +14,23 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::bool;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::Bool;
+use crate::arrays::BoolArray;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
-/// A boolean array that stores true/false values in a compact bit-packed format.
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
+
+/// Inner data for a boolean array that stores true/false values in a compact bit-packed format.
 ///
 /// This mirrors the Apache Arrow Boolean array encoding, where each boolean value
 /// is stored as a single bit rather than a full byte.
@@ -50,23 +63,90 @@ use crate::validity::Validity;
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct BoolArray {
-    pub(super) dtype: DType,
+pub struct BoolData {
     pub(super) bits: BufferHandle,
     pub(super) offset: usize,
-    pub(super) len: usize,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
 }
 
-pub struct BoolArrayParts {
+impl Display for BoolData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "offset: {}", self.offset)
+    }
+}
+
+pub struct BoolDataParts {
     pub bits: BufferHandle,
     pub offset: usize,
     pub len: usize,
-    pub validity: Validity,
 }
 
-impl BoolArray {
+pub trait BoolArrayExt: TypedArrayRef<Bool> {
+    fn nullability(&self) -> crate::dtype::Nullability {
+        match self.as_ref().dtype() {
+            DType::Bool(nullability) => *nullability,
+            _ => unreachable!("BoolArrayExt requires a bool dtype"),
+        }
+    }
+
+    fn validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn bool_validity_mask(&self) -> Mask {
+        self.validity().to_mask(self.as_ref().len())
+    }
+
+    fn to_bit_buffer(&self) -> BitBuffer {
+        let buffer = self.bits.as_host().clone();
+        BitBuffer::new_with_offset(buffer, self.as_ref().len(), self.offset)
+    }
+
+    fn maybe_to_mask(&self) -> VortexResult<Option<Mask>> {
+        let all_valid = match &self.validity() {
+            Validity::NonNullable | Validity::AllValid => true,
+            Validity::AllInvalid => false,
+            Validity::Array(a) => a.statistics().compute_min::<bool>().unwrap_or(false),
+        };
+        Ok(all_valid.then(|| Mask::from_buffer(self.to_bit_buffer())))
+    }
+
+    fn to_mask(&self) -> Mask {
+        self.maybe_to_mask()
+            .vortex_expect("failed to check validity")
+            .vortex_expect("cannot convert nullable boolean array to mask")
+    }
+
+    fn to_mask_fill_null_false(&self) -> Mask {
+        let validity_mask = self.bool_validity_mask();
+        let buffer = match validity_mask {
+            Mask::AllTrue(_) => self.to_bit_buffer(),
+            Mask::AllFalse(_) => return Mask::new_false(self.as_ref().len()),
+            Mask::Values(validity) => validity.bit_buffer() & self.to_bit_buffer(),
+        };
+        Mask::from_buffer(buffer)
+    }
+}
+impl<T: TypedArrayRef<Bool>> BoolArrayExt for T {}
+
+/// Field accessors and non-consuming methods on the inner bool data.
+impl BoolData {
+    /// Splits into owned parts
+    #[inline]
+    pub fn into_parts(self, len: usize) -> BoolDataParts {
+        BoolDataParts {
+            bits: self.bits,
+            offset: self.offset,
+            len,
+        }
+    }
+
+    pub(crate) fn make_slots(validity: &Validity, len: usize) -> Vec<Option<ArrayRef>> {
+        vec![validity_to_child(validity, len)]
+    }
+}
+
+/// Constructors and consuming methods for `BoolArray` (`Array<Bool>`).
+impl Array<Bool> {
     /// Constructs a new `BoolArray`.
     ///
     /// # Panics
@@ -88,35 +168,93 @@ impl BoolArray {
 
     /// Constructs a new `BoolArray`.
     ///
-    /// See [`BoolArray::new_unchecked`] for more information.
-    ///
     /// # Errors
     ///
-    /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`BoolArray::new_unchecked`].
+    /// Returns an error if the provided components do not satisfy the invariants.
     pub fn try_new(bits: BitBuffer, validity: Validity) -> VortexResult<Self> {
+        let dtype = DType::Bool(validity.nullability());
+        let len = bits.len();
+        let slots = BoolData::make_slots(&validity, len);
+        let data = BoolData::try_new(bits, validity)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Bool, dtype, len, data).with_slots(slots))
+        })
+    }
+
+    /// Build a new bool array from a `BufferHandle`, returning an error if the offset is
+    /// too large or the buffer is not large enough to hold the values.
+    pub fn try_new_from_handle(
+        bits: BufferHandle,
+        offset: usize,
+        len: usize,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let dtype = DType::Bool(validity.nullability());
+        let slots = BoolData::make_slots(&validity, len);
+        let data = BoolData::try_new_from_handle(bits, offset, len, validity)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Bool, dtype, len, data).with_slots(slots))
+        })
+    }
+
+    /// Creates a new [`BoolArray`] without validation.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the validity length is equal to the bit buffer length.
+    pub unsafe fn new_unchecked(bits: BitBuffer, validity: Validity) -> Self {
+        let dtype = DType::Bool(validity.nullability());
+        let len = bits.len();
+        let slots = BoolData::make_slots(&validity, len);
+        // SAFETY: caller guarantees validity length equals bit buffer length.
+        let data = unsafe { BoolData::new_unchecked(bits, validity) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Bool, dtype, len, data).with_slots(slots))
+        }
+    }
+
+    /// Validates the components that would be used to create a [`BoolArray`].
+    pub fn validate(bits: &BitBuffer, validity: &Validity) -> VortexResult<()> {
+        BoolData::validate(bits, validity)
+    }
+
+    /// Create a new BoolArray from a set of indices and a length.
+    ///
+    /// All indices must be less than the length.
+    pub fn from_indices<I: IntoIterator<Item = usize>>(
+        length: usize,
+        indices: I,
+        validity: Validity,
+    ) -> Self {
+        let mut buffer = BitBufferMut::new_unset(length);
+        indices.into_iter().for_each(|idx| buffer.set(idx));
+        Self::new(buffer.freeze(), validity)
+    }
+
+    /// Returns the underlying [`BitBuffer`] of the array, consuming self.
+    pub fn into_bit_buffer(self) -> BitBuffer {
+        let len = self.len();
+        let data = self.into_data();
+        let buffer = data.bits.unwrap_host();
+        BitBuffer::new_with_offset(buffer, len, data.offset)
+    }
+}
+
+/// Internal constructors on BoolData (used by Array<Bool> 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 {
-            dtype: DType::Bool(validity.nullability()),
             bits: BufferHandle::new_host(buffer),
             offset,
-            len,
-            validity,
-            stats_set: ArrayStats::default(),
         })
     }
 
-    /// Build a new bool array from a `BufferHandle`, returning an error if the offset is
-    /// too large or the buffer is not large enough to hold the values.
-    ///
-    /// # Error
-    ///
-    /// Error if the inputs fail validation. See also `try_new`.
-    pub fn try_new_from_handle(
+    pub(super) fn try_new_from_handle(
         bits: BufferHandle,
         offset: usize,
         len: usize,
@@ -137,49 +275,29 @@ impl BoolArray {
             bits.len() * 8,
         );
 
-        Ok(Self {
-            dtype: DType::Bool(validity.nullability()),
-            bits,
-            offset,
-            len,
-            validity,
-            stats_set: ArrayStats::default(),
-        })
+        Ok(Self { bits, offset })
     }
 
-    /// Creates a new [`BoolArray`] without validation from these components:
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the validity length is equal to the bit buffer length.
-    pub unsafe fn new_unchecked(bits: BitBuffer, validity: Validity) -> Self {
+    pub(super) unsafe fn new_unchecked(bits: BitBuffer, validity: Validity) -> Self {
         if cfg!(debug_assertions) {
-            Self::new(bits, validity)
+            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 {
-                dtype: DType::Bool(validity.nullability()),
                 bits: BufferHandle::new_host(buffer),
                 offset,
-                len,
-                validity,
-                stats_set: ArrayStats::default(),
             }
         }
     }
 
-    /// Validates the components that would be used to create a [`BoolArray`].
-    ///
-    /// This function checks all the invariants required by [`BoolArray::new_unchecked`].
-    pub fn validate(bits: &BitBuffer, validity: &Validity) -> VortexResult<()> {
+    pub(super) fn validate(bits: &BitBuffer, validity: &Validity) -> VortexResult<()> {
         vortex_ensure!(
             bits.offset() < 8,
             "BitBuffer offset must be <8, got {}",
             bits.offset()
         );
 
-        // Validate validity
         if let Some(validity_len) = validity.maybe_len() {
             vortex_ensure!(
                 validity_len == bits.len(),
@@ -190,86 +308,17 @@ impl BoolArray {
 
         Ok(())
     }
-
-    /// Splits into owned parts
-    #[inline]
-    pub fn into_parts(self) -> BoolArrayParts {
-        BoolArrayParts {
-            bits: self.bits,
-            offset: self.offset,
-            len: self.len,
-            validity: self.validity,
-        }
-    }
-
-    /// Create a new BoolArray from a set of indices and a length.
-    ///
-    /// All indices must be less than the length.
-    pub fn from_indices<I: IntoIterator<Item = usize>>(
-        length: usize,
-        indices: I,
-        validity: Validity,
-    ) -> Self {
-        let mut buffer = BitBufferMut::new_unset(length);
-        indices.into_iter().for_each(|idx| buffer.set(idx));
-        Self::new(buffer.freeze(), validity)
-    }
-
-    /// Returns the underlying [`BitBuffer`] of the array.
-    pub fn to_bit_buffer(&self) -> BitBuffer {
-        let buffer = self.bits.as_host().clone();
-
-        BitBuffer::new_with_offset(buffer, self.len, self.offset)
-    }
-
-    /// Returns the underlying [`BitBuffer`] of the array
-    pub fn into_bit_buffer(self) -> BitBuffer {
-        self.to_bit_buffer()
-    }
-
-    pub fn to_mask(&self) -> Mask {
-        self.maybe_to_mask()
-            .vortex_expect("failed to check validity")
-            .vortex_expect("cannot convert nullable boolean array to mask")
-    }
-
-    pub fn maybe_to_mask(&self) -> VortexResult<Option<Mask>> {
-        Ok(self
-            .all_valid()?
-            .then(|| Mask::from_buffer(self.to_bit_buffer())))
-    }
-
-    pub fn to_mask_fill_null_false(&self) -> Mask {
-        if let Some(constant) = self.as_constant() {
-            let bool_constant = constant.as_bool();
-            if bool_constant.value().unwrap_or(false) {
-                return Mask::new_true(self.len());
-            } else {
-                return Mask::new_false(self.len());
-            }
-        }
-        // Extract a boolean buffer, treating null values to false
-        let buffer = match self
-            .validity_mask()
-            .unwrap_or_else(|_| Mask::new_true(self.len()))
-        {
-            Mask::AllTrue(_) => self.to_bit_buffer(),
-            Mask::AllFalse(_) => return Mask::new_false(self.len()),
-            Mask::Values(validity) => validity.bit_buffer() & self.to_bit_buffer(),
-        };
-        Mask::from_buffer(buffer)
-    }
 }
 
 impl From<BitBuffer> for BoolArray {
     fn from(value: BitBuffer) -> Self {
-        Self::new(value, Validity::NonNullable)
+        BoolArray::new(value, Validity::NonNullable)
     }
 }
 
 impl FromIterator<bool> for BoolArray {
     fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
-        Self::from(BitBuffer::from_iter(iter))
+        BoolArray::from(BitBuffer::from_iter(iter))
     }
 }
 
@@ -277,7 +326,7 @@ impl FromIterator<Option<bool>> for BoolArray {
     fn from_iter<I: IntoIterator<Item = Option<bool>>>(iter: I) -> Self {
         let (buffer, nulls) = BooleanArray::from_iter(iter).into_parts();
 
-        Self::new(
+        BoolArray::new(
             BitBuffer::from(buffer),
             nulls
                 .map(|n| Validity::from(BitBuffer::from(n.into_inner())))
@@ -307,14 +356,15 @@ mod tests {
     use vortex_buffer::BitBufferMut;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::assert_arrays_eq;
     use crate::patches::Patches;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn bool_array() {
@@ -327,7 +377,7 @@ mod tests {
     fn test_all_some_iter() {
         let arr = BoolArray::from_iter([Some(true), Some(false)]);
 
-        assert!(matches!(arr.validity(), Validity::AllValid));
+        assert!(matches!(arr.validity(), Ok(Validity::AllValid)));
 
         let scalar = bool::try_from(&arr.scalar_at(0).unwrap()).unwrap();
         assert!(scalar);
@@ -379,7 +429,9 @@ mod tests {
             None,
         )
         .unwrap();
-        let arr = arr.patch(&patches).unwrap();
+        let arr = arr
+            .patch(&patches, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         // After patching index 4 to false: indices 1-3 and 5-11 are true, index 0 and 4 are false
         let expected_patched: Vec<bool> = (0..12).map(|i| (1..12).contains(&i) && i != 4).collect();
         assert_arrays_eq!(arr, BoolArray::from_iter(expected_patched));
@@ -408,7 +460,9 @@ mod tests {
             None,
         )
         .unwrap();
-        let arr = arr.patch(&patches).unwrap();
+        let arr = arr
+            .patch(&patches, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         // Verify buffer was reused in place
         assert_eq!(arr.to_bit_buffer().inner().as_ptr(), buf_ptr);
 
diff --git a/vortex-array/src/arrays/bool/compute/cast.rs b/vortex-array/src/arrays/bool/compute/cast.rs
index 622a60a46a1..3b5fbea7607 100644
--- a/vortex-array/src/arrays/bool/compute/cast.rs
+++ b/vortex-array/src/arrays/bool/compute/cast.rs
@@ -3,26 +3,27 @@
 
 use vortex_error::VortexResult;
 
-use crate::array::ArrayRef;
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
+use crate::arrays::bool::BoolArrayExt;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for BoolVTable {
-    fn cast(array: &BoolArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for Bool {
+    fn cast(array: ArrayView<'_, Bool>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !matches!(dtype, DType::Bool(_)) {
             return Ok(None);
         }
 
         let new_nullability = dtype.nullability();
         let new_validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(new_nullability, array.len())?;
         Ok(Some(
-            BoolArray::new(array.to_bit_buffer(), new_validity).to_array(),
+            BoolArray::new(array.to_bit_buffer(), new_validity).into_array(),
         ))
     }
 }
@@ -31,6 +32,7 @@ impl CastReduce for BoolVTable {
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -41,7 +43,9 @@ mod tests {
     fn try_cast_bool_success() {
         let bool = BoolArray::from_iter(vec![Some(true), Some(false), Some(true)]);
 
-        let res = bool.to_array().cast(DType::Bool(Nullability::NonNullable));
+        let res = bool
+            .into_array()
+            .cast(DType::Bool(Nullability::NonNullable));
         assert!(res.is_ok());
         assert_eq!(res.unwrap().dtype(), &DType::Bool(Nullability::NonNullable));
     }
@@ -50,7 +54,7 @@ mod tests {
     #[should_panic]
     fn try_cast_bool_fail() {
         let bool = BoolArray::from_iter(vec![Some(true), Some(false), None]);
-        bool.to_array()
+        bool.into_array()
             .cast(DType::Bool(Nullability::NonNullable))
             .unwrap();
     }
@@ -61,6 +65,6 @@ mod tests {
     #[case(BoolArray::from_iter(vec![true]))]
     #[case(BoolArray::from_iter(vec![false, false]))]
     fn test_cast_bool_conformance(#[case] array: BoolArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/fill_null.rs b/vortex-array/src/arrays/bool/compute/fill_null.rs
index 245f2c397dd..f2489f9d073 100644
--- a/vortex-array/src/arrays/bool/compute/fill_null.rs
+++ b/vortex-array/src/arrays/bool/compute/fill_null.rs
@@ -7,31 +7,32 @@ use vortex_error::vortex_err;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
+use crate::arrays::bool::BoolArrayExt;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNullKernel;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl FillNullKernel for BoolVTable {
+impl FillNullKernel for Bool {
     fn fill_null(
-        array: &BoolArray,
+        array: ArrayView<'_, Bool>,
         fill_value: &Scalar,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let fill = fill_value
             .as_bool()
             .value()
             .ok_or_else(|| vortex_err!("Fill value must be non null"))?;
 
-        Ok(Some(match array.validity() {
+        Ok(Some(match array.validity()? {
             Validity::Array(v) => {
+                let v_bool = v.execute::<BoolArray>(ctx)?;
                 let bool_buffer = if fill {
-                    array.to_bit_buffer() | &!v.to_bool().to_bit_buffer()
+                    array.to_bit_buffer() | &!v_bool.to_bit_buffer()
                 } else {
-                    array.to_bit_buffer() & v.to_bool().to_bit_buffer()
+                    array.to_bit_buffer() & v_bool.to_bit_buffer()
                 };
                 BoolArray::new(bool_buffer, fill_value.dtype().nullability().into()).into_array()
             }
@@ -46,7 +47,9 @@ mod tests {
     use vortex_buffer::BitBuffer;
     use vortex_buffer::bitbuffer;
 
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::builtins::ArrayBuiltins;
     use crate::canonical::ToCanonical;
     use crate::dtype::DType;
@@ -63,7 +66,7 @@ mod tests {
             Validity::from_iter([true, false, true, false]),
         );
         let non_null_array = bool_array
-            .to_array()
+            .into_array()
             .fill_null(Scalar::from(fill_value))
             .unwrap()
             .to_bool();
diff --git a/vortex-array/src/arrays/bool/compute/filter.rs b/vortex-array/src/arrays/bool/compute/filter.rs
index 82887d8799d..c7b45498957 100644
--- a/vortex-array/src/arrays/bool/compute/filter.rs
+++ b/vortex-array/src/arrays/bool/compute/filter.rs
@@ -10,34 +10,26 @@ use vortex_mask::Mask;
 use vortex_mask::MaskIter;
 
 use crate::ArrayRef;
-use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::arrays::filter::FilterKernel;
-use crate::vtable::ValidityHelper;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::filter::FilterReduce;
 
 /// If the filter density is above 80%, we use slices to filter the array instead of indices.
 const FILTER_SLICES_DENSITY_THRESHOLD: f64 = 0.8;
 
-impl FilterKernel for BoolVTable {
-    fn filter(
-        array: &BoolArray,
-        mask: &Mask,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        let validity = array.validity().filter(mask)?;
+impl FilterReduce for Bool {
+    fn filter(array: ArrayView<'_, Bool>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+        let validity = array.validity()?.filter(mask)?;
 
         let mask_values = mask
             .values()
             .vortex_expect("AllTrue and AllFalse are handled by filter fn");
 
         let buffer = match mask_values.threshold_iter(FILTER_SLICES_DENSITY_THRESHOLD) {
-            MaskIter::Indices(indices) => filter_indices(
-                &array.to_bit_buffer(),
-                mask.true_count(),
-                indices.iter().copied(),
-            ),
+            MaskIter::Indices(indices) => filter_indices(&array.to_bit_buffer(), indices),
             MaskIter::Slices(slices) => filter_slices(
                 &array.to_bit_buffer(),
                 mask.true_count(),
@@ -49,24 +41,18 @@ impl FilterKernel for BoolVTable {
     }
 }
 
-/// Select indices from a boolean buffer.
-/// NOTE: it was benchmarked to be faster using collect_bool to index into a slice than to
-///  pass the indices as an iterator of usize. So we keep this alternate implementation.
-pub fn filter_indices(
-    bools: &BitBuffer,
-    indices_len: usize,
-    mut indices: impl Iterator<Item = usize>,
-) -> BitBuffer {
+fn filter_indices(bools: &BitBuffer, indices: &[usize]) -> BitBuffer {
     let buffer = bools.inner().as_ref();
-    BitBuffer::collect_bool(indices_len, |_idx| {
-        let idx = indices
-            .next()
-            .vortex_expect("iterator is guaranteed to be within the length of the array.");
-        get_bit(buffer, bools.offset() + idx)
+    let offset = bools.offset();
+    BitBuffer::collect_bool(indices.len(), |idx| {
+        // Safety:
+        // We iterate over the slice's length.
+        let idx = unsafe { indices.get_unchecked(idx) } + offset;
+        get_bit(buffer, idx)
     })
 }
 
-pub fn filter_slices(
+fn filter_slices(
     buffer: &BitBuffer,
     indices_len: usize,
     slices: impl Iterator<Item = (usize, usize)>,
@@ -81,12 +67,13 @@ pub fn filter_slices(
 
 #[cfg(test)]
 mod test {
+
     use itertools::Itertools;
     use vortex_mask::Mask;
 
+    use super::*;
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
-    use crate::arrays::bool::compute::filter::filter_indices;
-    use crate::arrays::bool::compute::filter::filter_slices;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::filter::test_filter_conformance;
 
@@ -111,7 +98,7 @@ mod test {
     fn filter_bool_by_index_test() {
         let arr = BoolArray::from_iter([true, true, false]);
 
-        let filtered = filter_indices(&arr.to_bit_buffer(), 2, [0, 2].into_iter());
+        let filtered = filter_indices(&arr.to_bit_buffer(), &[0, 2]);
         assert_eq!(vec![true, false], filtered.iter().collect_vec())
     }
 
@@ -125,6 +112,6 @@ mod test {
     #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))]
     #[case(BoolArray::from_iter((0..1024).map(|i| i % 3 != 0)))]
     fn test_filter_bool_conformance(#[case] array: BoolArray) {
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/is_constant.rs b/vortex-array/src/arrays/bool/compute/is_constant.rs
deleted file mode 100644
index 53ce5483b07..00000000000
--- a/vortex-array/src/arrays/bool/compute/is_constant.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::register_kernel;
-
-impl IsConstantKernel for BoolVTable {
-    fn is_constant(&self, array: &BoolArray, opts: &IsConstantOpts) -> VortexResult<Option<bool>> {
-        // If the array is small, then it is a constant time operation.
-        if opts.is_negligible_cost() && array.len() > 64 {
-            return Ok(None);
-        }
-
-        let true_count = array.to_bit_buffer().true_count();
-        Ok(Some(true_count == array.len() || true_count == 0))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(BoolVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-
-    use super::*;
-    use crate::compute::is_constant;
-
-    #[rstest]
-    #[case(vec![true], true)]
-    #[case(vec![false; 65], true)]
-    #[case({
-        let mut v = vec![true; 64];
-        v.push(false);
-        v
-    }, false)]
-    fn test_is_constant(#[case] input: Vec<bool>, #[case] expected: bool) {
-        let array = BoolArray::from_iter(input);
-        assert_eq!(is_constant(array.as_ref()).unwrap(), Some(expected));
-    }
-}
diff --git a/vortex-array/src/arrays/bool/compute/is_sorted.rs b/vortex-array/src/arrays/bool/compute/is_sorted.rs
deleted file mode 100644
index 68413afad1a..00000000000
--- a/vortex-array/src/arrays/bool/compute/is_sorted.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::compute::IsSortedIteratorExt;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-impl IsSortedKernel for BoolVTable {
-    fn is_sorted(&self, array: &BoolArray) -> VortexResult<Option<bool>> {
-        match array.validity_mask()? {
-            Mask::AllFalse(_) => Ok(Some(true)),
-            Mask::AllTrue(_) => Ok(Some(array.to_bit_buffer().iter().is_sorted())),
-            Mask::Values(mask_values) => {
-                let set_indices = mask_values.bit_buffer().set_indices();
-                let values = array.to_bit_buffer();
-                let values_iter = set_indices.map(|idx|
-                    // Safety:
-                    // All idxs are in-bounds for the array.
-                    unsafe {
-                        values.value_unchecked(idx)
-                    });
-
-                Ok(Some(values_iter.is_sorted()))
-            }
-        }
-    }
-
-    fn is_strict_sorted(&self, array: &BoolArray) -> VortexResult<Option<bool>> {
-        match array.validity_mask()? {
-            Mask::AllFalse(_) => Ok(Some(false)),
-            Mask::AllTrue(_) => Ok(Some(array.to_bit_buffer().iter().is_strict_sorted())),
-            Mask::Values(mask_values) => {
-                let validity_buffer = mask_values.bit_buffer();
-                let values = array.to_bit_buffer();
-
-                Ok(Some(
-                    validity_buffer
-                        .iter()
-                        .zip(values.iter())
-                        .map(|(is_valid, value)| is_valid.then_some(value))
-                        .is_strict_sorted(),
-                ))
-            }
-        }
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(BoolVTable).lift());
diff --git a/vortex-array/src/arrays/bool/compute/mask.rs b/vortex-array/src/arrays/bool/compute/mask.rs
index 710beb9b212..6fd278f2d3d 100644
--- a/vortex-array/src/arrays/bool/compute/mask.rs
+++ b/vortex-array/src/arrays/bool/compute/mask.rs
@@ -5,21 +5,19 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
+use crate::arrays::bool::BoolArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for BoolVTable {
-    fn mask(array: &BoolArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Bool {
+    fn mask(array: ArrayView<'_, Bool>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             BoolArray::new(
                 array.to_bit_buffer(),
-                array
-                    .validity()
-                    .clone()
-                    .and(Validity::Array(mask.clone()))?,
+                array.validity()?.and(Validity::Array(mask.clone()))?,
             )
             .into_array(),
         ))
@@ -30,6 +28,7 @@ impl MaskReduce for BoolVTable {
 mod test {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::compute::conformance::mask::test_mask_conformance;
 
@@ -40,6 +39,6 @@ mod test {
     #[case(BoolArray::from_iter([false, false]))]
     #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))]
     fn test_mask_bool_conformance(#[case] array: BoolArray) {
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/min_max.rs b/vortex-array/src/arrays/bool/compute/min_max.rs
deleted file mode 100644
index 52d38e6792a..00000000000
--- a/vortex-array/src/arrays/bool/compute/min_max.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::ops::BitAnd;
-
-use Nullability::NonNullable;
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::dtype::Nullability;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl MinMaxKernel for BoolVTable {
-    fn min_max(&self, array: &BoolArray) -> VortexResult<Option<MinMaxResult>> {
-        let mask = array.validity_mask()?;
-        let true_non_null = match &mask {
-            Mask::AllTrue(_) => array.to_bit_buffer(),
-            Mask::AllFalse(_) => return Ok(None),
-            Mask::Values(v) => array.to_bit_buffer().bitand(v.bit_buffer()),
-        };
-
-        // TODO(ngates): we should be able to bail out earlier as soon as we have one true and
-        //  one false value.
-        let mut true_slices = true_non_null.set_slices();
-        // If there are no slices, then all values are false
-        // if there is a single slice that covers the entire array, then all values are true
-        // otherwise, we have a mix of true and false values
-
-        let Some(slice) = true_slices.next() else {
-            // all false
-            return Ok(Some(MinMaxResult {
-                min: Scalar::bool(false, NonNullable),
-                max: Scalar::bool(false, NonNullable),
-            }));
-        };
-        if slice.0 == 0 && slice.1 == array.len() {
-            // all true
-            return Ok(Some(MinMaxResult {
-                min: Scalar::bool(true, NonNullable),
-                max: Scalar::bool(true, NonNullable),
-            }));
-        };
-
-        // If the non null true slice doesn't cover the whole array we need to check for valid false values
-        match &mask {
-            // if the mask is all true or all false we don't need to look for false values
-            Mask::AllTrue(_) | Mask::AllFalse(_) => {}
-            Mask::Values(v) => {
-                let false_non_null = (!array.to_bit_buffer()).bitand(v.bit_buffer());
-                let mut false_slices = false_non_null.set_slices();
-
-                let Some(_) = false_slices.next() else {
-                    // In this case we don't have any false values which means we are all true and null
-                    return Ok(Some(MinMaxResult {
-                        min: Scalar::bool(true, NonNullable),
-                        max: Scalar::bool(true, NonNullable),
-                    }));
-                };
-            }
-        }
-
-        Ok(Some(MinMaxResult {
-            min: Scalar::bool(false, NonNullable),
-            max: Scalar::bool(true, NonNullable),
-        }))
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(BoolVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use Nullability::NonNullable;
-
-    use crate::arrays::BoolArray;
-    use crate::compute::MinMaxResult;
-    use crate::compute::min_max;
-    use crate::dtype::Nullability;
-    use crate::scalar::Scalar;
-
-    #[test]
-    fn test_min_max_nulls() {
-        assert_eq!(
-            min_max(BoolArray::from_iter(vec![Some(true), Some(true), None, None]).as_ref())
-                .unwrap(),
-            Some(MinMaxResult {
-                min: Scalar::bool(true, NonNullable),
-                max: Scalar::bool(true, NonNullable),
-            })
-        );
-
-        assert_eq!(
-            min_max(BoolArray::from_iter(vec![None, Some(true), Some(true)]).as_ref()).unwrap(),
-            Some(MinMaxResult {
-                min: Scalar::bool(true, NonNullable),
-                max: Scalar::bool(true, NonNullable),
-            })
-        );
-
-        assert_eq!(
-            min_max(BoolArray::from_iter(vec![None, Some(true), Some(true), None]).as_ref())
-                .unwrap(),
-            Some(MinMaxResult {
-                min: Scalar::bool(true, NonNullable),
-                max: Scalar::bool(true, NonNullable),
-            })
-        );
-
-        assert_eq!(
-            min_max(BoolArray::from_iter(vec![Some(false), Some(false), None, None]).as_ref())
-                .unwrap(),
-            Some(MinMaxResult {
-                min: Scalar::bool(false, NonNullable),
-                max: Scalar::bool(false, NonNullable),
-            })
-        );
-    }
-}
diff --git a/vortex-array/src/arrays/bool/compute/mod.rs b/vortex-array/src/arrays/bool/compute/mod.rs
index 0a91991182d..9649bd31d6c 100644
--- a/vortex-array/src/arrays/bool/compute/mod.rs
+++ b/vortex-array/src/arrays/bool/compute/mod.rs
@@ -4,19 +4,16 @@
 mod cast;
 mod fill_null;
 pub(crate) mod filter;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub mod rules;
 mod slice;
-mod sum;
 mod take;
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::compute::conformance::consistency::test_array_consistency;
 
@@ -42,6 +39,6 @@ mod tests {
         None, None, Some(true), None, None, None, Some(false), None, None
     ]))]
     fn test_bool_consistency(#[case] array: BoolArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/rules.rs b/vortex-array/src/arrays/bool/compute/rules.rs
index 8c065d3dba0..ed2e7a4dc28 100644
--- a/vortex-array/src/arrays/bool/compute/rules.rs
+++ b/vortex-array/src/arrays/bool/compute/rules.rs
@@ -5,22 +5,24 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Masked;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
-use crate::vtable::ValidityHelper;
 
-pub(crate) const RULES: ParentRuleSet<BoolVTable> = ParentRuleSet::new(&[
+pub(crate) const RULES: ParentRuleSet<Bool> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&BoolMaskedValidityRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(BoolVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(BoolVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(BoolVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Bool)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Bool)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Bool)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(Bool)),
 ]);
 
 /// Rule to push down validity masking from MaskedArray parent into BoolArray child.
@@ -30,13 +32,13 @@ pub(crate) const RULES: ParentRuleSet<BoolVTable> = ParentRuleSet::new(&[
 #[derive(Default, Debug)]
 pub struct BoolMaskedValidityRule;
 
-impl ArrayParentReduceRule<BoolVTable> for BoolMaskedValidityRule {
-    type Parent = MaskedVTable;
+impl ArrayParentReduceRule<Bool> for BoolMaskedValidityRule {
+    type Parent = Masked;
 
     fn reduce_parent(
         &self,
-        array: &BoolArray,
-        parent: &MaskedArray,
+        array: ArrayView<'_, Bool>,
+        parent: ArrayView<'_, Masked>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         if child_idx > 0 {
@@ -48,7 +50,7 @@ impl ArrayParentReduceRule<BoolVTable> for BoolMaskedValidityRule {
         Ok(Some(
             BoolArray::new(
                 array.to_bit_buffer(),
-                array.validity().clone().and(parent.validity().clone())?,
+                array.validity()?.and(parent.validity()?)?,
             )
             .into_array(),
         ))
diff --git a/vortex-array/src/arrays/bool/compute/slice.rs b/vortex-array/src/arrays/bool/compute/slice.rs
index f65fa7651bd..0ef11bb3085 100644
--- a/vortex-array/src/arrays/bool/compute/slice.rs
+++ b/vortex-array/src/arrays/bool/compute/slice.rs
@@ -7,17 +7,18 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::arrays::SliceReduce;
-use crate::vtable::ValidityHelper;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for BoolVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+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)?,
+                array.validity()?.slice(range)?,
             )
             .into_array(),
         ))
diff --git a/vortex-array/src/arrays/bool/compute/sum.rs b/vortex-array/src/arrays/bool/compute/sum.rs
deleted file mode 100644
index e5c036f190d..00000000000
--- a/vortex-array/src/arrays/bool/compute/sum.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::ops::BitAnd;
-
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_mask::AllOr;
-
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::dtype::Nullability;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl SumKernel for BoolVTable {
-    fn sum(&self, array: &BoolArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        let true_count: Option<u64> = match array.validity_mask()?.bit_buffer() {
-            AllOr::All => {
-                // All-valid
-                Some(array.to_bit_buffer().true_count() as u64)
-            }
-            AllOr::None => {
-                // All-invalid
-                unreachable!("All-invalid boolean array should have been handled by entry-point")
-            }
-            AllOr::Some(validity_mask) => {
-                Some(array.to_bit_buffer().bitand(validity_mask).true_count() as u64)
-            }
-        };
-
-        let acc_value = accumulator
-            .as_primitive()
-            .as_::<u64>()
-            .vortex_expect("cannot be null");
-        let result = true_count.and_then(|tc| acc_value.checked_add(tc));
-        Ok(match result {
-            Some(v) => Scalar::primitive(v, Nullability::Nullable),
-            None => Scalar::null_native::<u64>(),
-        })
-    }
-}
-
-register_kernel!(SumKernelAdapter(BoolVTable).lift());
diff --git a/vortex-array/src/arrays/bool/compute/take.rs b/vortex-array/src/arrays/bool/compute/take.rs
index 207ed653658..19b1508fd84 100644
--- a/vortex-array/src/arrays/bool/compute/take.rs
+++ b/vortex-array/src/arrays/bool/compute/take.rs
@@ -8,28 +8,28 @@ use vortex_buffer::get_bit;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
 use crate::arrays::ConstantArray;
-use crate::arrays::TakeExecute;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::dict::TakeExecute;
 use crate::builtins::ArrayBuiltins;
 use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
 use crate::scalar::Scalar;
-use crate::vtable::ValidityHelper;
 
-impl TakeExecute for BoolVTable {
+impl TakeExecute for Bool {
     fn take(
-        array: &BoolArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Bool>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let indices_nulls_zeroed = match indices.validity_mask()? {
-            Mask::AllTrue(_) => indices.to_array(),
+            Mask::AllTrue(_) => indices.clone(),
             Mask::AllFalse(_) => {
                 return Ok(Some(
                     ConstantArray::new(Scalar::null(array.dtype().as_nullable()), indices.len())
@@ -37,16 +37,16 @@ impl TakeExecute for BoolVTable {
                 ));
             }
             Mask::Values(_) => indices
-                .to_array()
+                .clone()
                 .fill_null(Scalar::from(0).cast(indices.dtype())?)?,
         };
-        let indices_nulls_zeroed = indices_nulls_zeroed.to_primitive();
+        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>())
         });
 
         Ok(Some(
-            BoolArray::new(buffer, array.validity().take(indices)?).to_array(),
+            BoolArray::new(buffer, array.validity()?.take(indices)?).into_array(),
         ))
     }
 }
@@ -83,11 +83,11 @@ mod test {
     use rstest::rstest;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray as _;
     use crate::ToCanonical;
     use crate::arrays::BoolArray;
-    use crate::arrays::primitive::PrimitiveArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::validity::Validity;
@@ -112,7 +112,7 @@ mod test {
         );
 
         let all_invalid_indices = PrimitiveArray::from_option_iter([None::<i32>, None, None]);
-        let b = reference.take(all_invalid_indices.to_array()).unwrap();
+        let b = reference.take(all_invalid_indices.into_array()).unwrap();
         assert_arrays_eq!(b, BoolArray::from_iter([None, None, None]));
     }
 
@@ -121,9 +121,9 @@ mod test {
         let values = BoolArray::from_iter(vec![Some(false), Some(true), None, None, Some(false)]);
         let indices = PrimitiveArray::new(
             buffer![0, 3, 100],
-            Validity::Array(BoolArray::from_iter([true, true, false]).to_array()),
+            Validity::Array(BoolArray::from_iter([true, true, false]).into_array()),
         );
-        let actual = values.take(indices.to_array()).unwrap();
+        let actual = values.take(indices.into_array()).unwrap();
 
         // position 3 is null, the third index is null
         assert_arrays_eq!(actual, BoolArray::from_iter([Some(false), None, None]));
@@ -134,9 +134,9 @@ mod test {
         let values = BoolArray::from_iter(vec![false, true, false, true, false]);
         let indices = PrimitiveArray::new(
             buffer![0, 3, 100],
-            Validity::Array(BoolArray::from_iter([true, true, false]).to_array()),
+            Validity::Array(BoolArray::from_iter([true, true, false]).into_array()),
         );
-        let actual = values.take(indices.to_array()).unwrap();
+        let actual = values.take(indices.into_array()).unwrap();
         // the third index is null
         assert_arrays_eq!(
             actual,
@@ -149,9 +149,9 @@ mod test {
         let values = BoolArray::from_iter(vec![Some(false), Some(true), None, None, Some(false)]);
         let indices = PrimitiveArray::new(
             buffer![0, 3, 100],
-            Validity::Array(BoolArray::from_iter([false, false, false]).to_array()),
+            Validity::Array(BoolArray::from_iter([false, false, false]).into_array()),
         );
-        let actual = values.take(indices.to_array()).unwrap();
+        let actual = values.take(indices.into_array()).unwrap();
         assert_arrays_eq!(actual, BoolArray::from_iter([None, None, None]));
     }
 
@@ -160,9 +160,9 @@ mod test {
         let values = BoolArray::from_iter(vec![false, true, false, true, false]);
         let indices = PrimitiveArray::new(
             buffer![0, 3, 100],
-            Validity::Array(BoolArray::from_iter([false, false, false]).to_array()),
+            Validity::Array(BoolArray::from_iter([false, false, false]).into_array()),
         );
-        let actual = values.take(indices.to_array()).unwrap();
+        let actual = values.take(indices.into_array()).unwrap();
         assert_arrays_eq!(actual, BoolArray::from_iter([None, None, None]));
     }
 
@@ -172,6 +172,6 @@ mod test {
     #[case(BoolArray::from_iter([true, false]))]
     #[case(BoolArray::from_iter([true]))]
     fn test_take_bool_conformance(#[case] array: BoolArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/bool/mod.rs b/vortex-array/src/arrays/bool/mod.rs
index cc80b6150f2..a4aee2c4faa 100644
--- a/vortex-array/src/arrays/bool/mod.rs
+++ b/vortex-array/src/arrays/bool/mod.rs
@@ -4,14 +4,16 @@
 mod array;
 mod patch;
 
-pub use array::BoolArray;
-pub use array::BoolArrayParts;
+pub use array::BoolArrayExt;
+pub use array::BoolData;
+pub use array::BoolDataParts;
 
 pub(crate) mod compute;
 
 mod vtable;
 pub use compute::rules::BoolMaskedValidityRule;
-pub use vtable::BoolVTable;
+pub use vtable::Bool;
+pub use vtable::BoolArray;
 
 #[cfg(feature = "_test-harness")]
 mod test_harness;
diff --git a/vortex-array/src/arrays/bool/patch.rs b/vortex-array/src/arrays/bool/patch.rs
index 91103dfad54..fef03bc30fb 100644
--- a/vortex-array/src/arrays/bool/patch.rs
+++ b/vortex-array/src/arrays/bool/patch.rs
@@ -2,27 +2,31 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use itertools::Itertools;
+use vortex_buffer::BitBufferMut;
 use vortex_error::VortexResult;
 
-use crate::ToCanonical;
+use crate::ExecutionCtx;
 use crate::arrays::BoolArray;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::match_each_unsigned_integer_ptype;
 use crate::patches::Patches;
-use crate::vtable::ValidityHelper;
 
 impl BoolArray {
-    pub fn patch(self, patches: &Patches) -> VortexResult<Self> {
+    pub fn patch(self, patches: &Patches, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
         let len = self.len();
         let offset = patches.offset();
-        let indices = patches.indices().to_primitive();
-        let values = patches.values().to_bool();
+        let indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
+        let values = patches.values().clone().execute::<BoolArray>(ctx)?;
 
         let patched_validity =
-            self.validity()
-                .clone()
-                .patch(len, offset, indices.as_ref(), values.validity())?;
+            self.validity()?
+                .patch(len, offset, patches.indices(), &values.validity()?, ctx)?;
 
-        let mut own_values = self.into_bit_buffer().into_mut();
+        let bit_buffer = self.into_bit_buffer();
+        let mut own_values = bit_buffer
+            .try_into_mut()
+            .unwrap_or_else(|bb| BitBufferMut::copy_from(&bb));
         match_each_unsigned_integer_ptype!(indices.ptype(), |I| {
             for (idx, value) in indices
                 .as_slice::<I>()
@@ -42,13 +46,14 @@ impl BoolArray {
 mod tests {
     use vortex_buffer::BitBuffer;
 
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::assert_arrays_eq;
 
     #[test]
     fn patch_sliced_bools() {
         let arr = BoolArray::from(BitBuffer::new_set(12));
-        let sliced = arr.slice(4..12).unwrap();
+        let sliced = arr.into_array().slice(4..12).unwrap();
         let expected = BoolArray::from_iter([true; 8]);
         assert_arrays_eq!(sliced, expected);
     }
@@ -56,7 +61,7 @@ mod tests {
     #[test]
     fn patch_sliced_bools_offset() {
         let arr = BoolArray::from(BitBuffer::new_set(15));
-        let sliced = arr.slice(4..15).unwrap();
+        let sliced = arr.into_array().slice(4..15).unwrap();
         let expected = BoolArray::from_iter([true; 11]);
         assert_arrays_eq!(sliced, expected);
     }
diff --git a/vortex-array/src/arrays/bool/test_harness.rs b/vortex-array/src/arrays/bool/test_harness.rs
index 286c0f98110..52cffafdbd9 100644
--- a/vortex-array/src/arrays/bool/test_harness.rs
+++ b/vortex-array/src/arrays/bool/test_harness.rs
@@ -5,11 +5,12 @@ use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
 
 use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 
 impl BoolArray {
     pub fn opt_bool_vec(&self) -> Vec<Option<bool>> {
         self.validity_mask()
-            .vortex_expect("Failed to get validity mask")
+            .vortex_expect("validity_mask")
             .to_bit_buffer()
             .iter()
             .zip(self.to_bit_buffer().iter())
@@ -19,7 +20,7 @@ impl BoolArray {
 
     pub fn bool_vec(&self) -> Vec<bool> {
         self.validity_mask()
-            .vortex_expect("Failed to get validity mask")
+            .vortex_expect("validity_mask")
             .to_bit_buffer()
             .iter()
             .zip(self.to_bit_buffer().iter())
diff --git a/vortex-array/src/arrays/bool/vtable/array.rs b/vortex-array/src/arrays/bool/vtable/array.rs
deleted file mode 100644
index e0cc247c222..00000000000
--- a/vortex-array/src/arrays/bool/vtable/array.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<BoolVTable> for BoolVTable {
-    fn len(array: &BoolArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &BoolArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &BoolArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &BoolArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.to_bit_buffer().array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &BoolArray, other: &BoolArray, precision: Precision) -> bool {
-        if array.dtype != other.dtype {
-            return false;
-        }
-        array
-            .to_bit_buffer()
-            .array_eq(&other.to_bit_buffer(), precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/bool/vtable/kernel.rs b/vortex-array/src/arrays/bool/vtable/kernel.rs
index 004ffe79fbb..e8fa5f30e9c 100644
--- a/vortex-array/src/arrays/bool/vtable/kernel.rs
+++ b/vortex-array/src/arrays/bool/vtable/kernel.rs
@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::BoolVTable;
-use crate::arrays::TakeExecuteAdaptor;
-use crate::arrays::filter::FilterExecuteAdaptor;
+use crate::arrays::Bool;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::fill_null::FillNullExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<BoolVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(BoolVTable)),
-    ParentKernelSet::lift(&FillNullExecuteAdaptor(BoolVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(BoolVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<Bool> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FillNullExecuteAdaptor(Bool)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Bool)),
 ]);
diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs
index d6d42412339..d02a8da22cf 100644
--- a/vortex-array/src/arrays/bool/vtable/mod.rs
+++ b/vortex-array/src/arrays/bool/vtable/mod.rs
@@ -1,38 +1,43 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hash;
+use std::hash::Hasher;
+
 use kernel::PARENT_KERNELS;
+use prost::Message;
 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 crate::ArrayRef;
-use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ProstMetadata;
-use crate::SerializeMetadata;
-use crate::arrays::BoolArray;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::bool::BoolData;
+use crate::arrays::bool::array::SLOT_NAMES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod canonical;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
 
+use crate::Precision;
+use crate::array::ArrayId;
 use crate::arrays::bool::compute::rules::RULES;
-use crate::vtable::ArrayId;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
 
-vtable!(Bool);
+/// A [`Bool`]-encoded Vortex array.
+pub type BoolArray = Array<Bool>;
 
 #[derive(prost::Message)]
 pub struct BoolMetadata {
@@ -41,49 +46,102 @@ pub struct BoolMetadata {
     pub offset: u32,
 }
 
-impl VTable for BoolVTable {
-    type Array = BoolArray;
+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);
+    }
+}
+
+impl ArrayEq for BoolData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.offset == other.offset && self.bits.array_eq(&other.bits, precision)
+    }
+}
 
-    type Metadata = ProstMetadata<BoolMetadata>;
+impl VTable for Bool {
+    type ArrayData = BoolData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &BoolArray) -> VortexResult<Self::Metadata> {
-        assert!(array.offset < 8, "Offset must be <8, got {}", array.offset);
-        Ok(ProstMetadata(BoolMetadata {
-            offset: u32::try_from(array.offset).vortex_expect("checked"),
-        }))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.bits.clone(),
+            _ => vortex_panic!("BoolArray buffer index {idx} out of bounds"),
+        }
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("bits".to_string()),
+            _ => None,
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let metadata = <Self::Metadata as DeserializeMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(metadata))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        assert!(array.offset < 8, "Offset must be <8, got {}", array.offset);
+        Ok(Some(
+            BoolMetadata {
+                offset: u32::try_from(array.offset).vortex_expect("checked"),
+            }
+            .encode_to_vec(),
+        ))
+    }
+
+    fn validate(
+        &self,
+        data: &BoolData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let DType::Bool(nullability) = dtype else {
+            vortex_bail!("Expected bool dtype, got {dtype:?}");
+        };
+        vortex_ensure!(
+            data.bits.len() * 8 >= data.offset + len,
+            "BoolArray buffer with offset {} cannot back outer length {} (buffer bits = {})",
+            data.offset,
+            len,
+            data.bits.len() * 8
+        );
+
+        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure!(
+                validity_len == len,
+                "BoolArray validity len {} does not match outer length {}",
+                validity_len,
+                len
+            );
+        }
+
+        Ok(())
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<BoolArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = BoolMetadata::decode(metadata)?;
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
@@ -98,51 +156,84 @@ impl VTable for BoolVTable {
         };
 
         let buffer = buffers[0].clone();
-
-        BoolArray::try_new_from_handle(buffer, metadata.offset as usize, len, validity)
+        let slots = BoolData::make_slots(&validity, len);
+        let data = BoolData::try_new_from_handle(buffer, metadata.offset as usize, len, validity)?;
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "BoolArray can have at most 1 child (validity), got {}",
-            children.len()
-        );
-
-        array.validity = if children.is_empty() {
-            Validity::from(array.dtype().nullability())
-        } else {
-            Validity::Array(children.into_iter().next().vortex_expect("checked"))
-        };
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
-    fn reduce_parent(
-        array: &Self::Array,
+    fn execute_parent(
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        RULES.evaluate(array, parent, child_idx)
+        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute_parent(
-        array: &Self::Array,
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
-        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
+        RULES.evaluate(array, parent, child_idx)
     }
 }
 
-#[derive(Debug)]
-pub struct BoolVTable;
+#[derive(Clone, Debug)]
+pub struct Bool;
 
-impl BoolVTable {
+impl Bool {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.bool");
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::ByteBufferMut;
+    use vortex_session::registry::ReadContext;
+
+    use crate::ArrayContext;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::BoolArray;
+    use crate::assert_arrays_eq;
+    use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
+
+    #[test]
+    fn test_nullable_bool_serde_roundtrip() {
+        let array = BoolArray::from_iter([Some(true), None, Some(false), None]);
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+        let parts = SerializedArray::try_from(concat.freeze()).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
+
+        assert_arrays_eq!(decoded, array);
+    }
+}
diff --git a/vortex-array/src/arrays/bool/vtable/operations.rs b/vortex-array/src/arrays/bool/vtable/operations.rs
index e44f7d0509e..ece00b038ea 100644
--- a/vortex-array/src/arrays/bool/vtable/operations.rs
+++ b/vortex-array/src/arrays/bool/vtable/operations.rs
@@ -3,13 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Bool;
+use crate::arrays::bool::BoolArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<BoolVTable> for BoolVTable {
-    fn scalar_at(array: &BoolArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Bool> for Bool {
+    fn scalar_at(
+        array: ArrayView<'_, Bool>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(Scalar::bool(
             array.to_bit_buffer().value(index),
             array.dtype().nullability(),
@@ -21,14 +27,16 @@ impl OperationsVTable<BoolVTable> for BoolVTable {
 mod tests {
     use std::iter;
 
-    use super::*;
+    use crate::IntoArray;
     use crate::ToCanonical;
+    use crate::arrays::BoolArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::assert_arrays_eq;
 
     #[test]
     fn test_slice_hundred_elements() {
         let arr = BoolArray::from_iter(iter::repeat_n(Some(true), 100));
-        let sliced_arr = arr.slice(8..16).unwrap().to_bool();
+        let sliced_arr = arr.into_array().slice(8..16).unwrap().to_bool();
         assert_eq!(sliced_arr.len(), 8);
         assert_eq!(sliced_arr.to_bit_buffer().len(), 8);
         assert_eq!(sliced_arr.to_bit_buffer().offset(), 0);
@@ -37,7 +45,7 @@ mod tests {
     #[test]
     fn test_slice() {
         let arr = BoolArray::from_iter([Some(true), Some(true), None, Some(false), None]);
-        let sliced_arr = arr.slice(1..4).unwrap().to_bool();
+        let sliced_arr = arr.into_array().slice(1..4).unwrap().to_bool();
 
         assert_arrays_eq!(
             sliced_arr,
diff --git a/vortex-array/src/arrays/bool/vtable/validity.rs b/vortex-array/src/arrays/bool/vtable/validity.rs
index 5aec7fbddb5..6d5a9a506bc 100644
--- a/vortex-array/src/arrays/bool/vtable/validity.rs
+++ b/vortex-array/src/arrays/bool/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::BoolArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::bool::vtable::Bool;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for BoolArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<Bool> for Bool {
+    fn validity(array: ArrayView<'_, Bool>) -> VortexResult<Validity> {
+        Ok(BoolArrayExt::validity(&array))
     }
 }
diff --git a/vortex-array/src/arrays/bool/vtable/visitor.rs b/vortex-array/src/arrays/bool/vtable/visitor.rs
deleted file mode 100644
index f1780d73174..00000000000
--- a/vortex-array/src/arrays/bool/vtable/visitor.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<BoolVTable> for BoolVTable {
-    fn visit_buffers(array: &BoolArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle("bits", &array.bits);
-    }
-
-    fn nbuffers(_array: &BoolArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &BoolArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(&array.validity, array.len());
-    }
-
-    fn nchildren(array: &BoolArray) -> usize {
-        validity_nchildren(&array.validity)
-    }
-
-    fn nth_child(array: &BoolArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => validity_to_child(&array.validity, array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/chunked/array.rs b/vortex-array/src/arrays/chunked/array.rs
index 73ee89fd9be..4537b685fa0 100644
--- a/vortex-array/src/arrays/chunked/array.rs
+++ b/vortex-array/src/arrays/chunked/array.rs
@@ -6,155 +6,177 @@
 //! Vortex is a chunked array library that's able to
 
 use std::fmt::Debug;
+use std::fmt::Display;
+use std::fmt::Formatter;
 
 use futures::stream;
-use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect as _;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Chunked;
 use crate::arrays::PrimitiveArray;
 use crate::dtype::DType;
 use crate::iter::ArrayIterator;
 use crate::iter::ArrayIteratorAdapter;
 use crate::search_sorted::SearchSorted;
 use crate::search_sorted::SearchSortedSide;
-use crate::stats::ArrayStats;
 use crate::stream::ArrayStream;
 use crate::stream::ArrayStreamAdapter;
 use crate::validity::Validity;
 
+pub(super) const CHUNK_OFFSETS_SLOT: usize = 0;
+pub(super) const CHUNKS_OFFSET: usize = 1;
+
 #[derive(Clone, Debug)]
-pub struct ChunkedArray {
-    pub(super) dtype: DType,
-    pub(super) len: usize,
-    pub(super) chunk_offsets: PrimitiveArray,
-    pub(super) chunks: Vec<ArrayRef>,
-    pub(super) stats_set: ArrayStats,
+pub struct ChunkedData {
+    pub(super) chunk_offsets: Vec<usize>,
 }
 
-impl ChunkedArray {
-    /// Constructs a new `ChunkedArray`.
-    ///
-    /// See [`ChunkedArray::new_unchecked`] for more information.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`ChunkedArray::new_unchecked`].
-    pub fn try_new(chunks: Vec<ArrayRef>, dtype: DType) -> VortexResult<Self> {
-        Self::validate(&chunks, &dtype)?;
-
-        // SAFETY: validation done above.
-        unsafe { Ok(Self::new_unchecked(chunks, dtype)) }
+impl Display for ChunkedData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "nchunks: {}", self.chunk_offsets.len().saturating_sub(1))
     }
+}
 
-    /// Creates a new [`ChunkedArray`] without validation from these components:
-    ///
-    /// * `chunks` is a vector of arrays to be concatenated logically.
-    /// * `dtype` is the common data type of all chunks.
-    ///
-    /// # Safety
-    ///
-    /// All chunks must have exactly the same [`DType`] as the provided `dtype`.
-    pub unsafe fn new_unchecked(chunks: Vec<ArrayRef>, dtype: DType) -> Self {
-        #[cfg(debug_assertions)]
-        Self::validate(&chunks, &dtype)
-            .vortex_expect("[Debug Assertion]: Invalid `ChunkedArray` parameters");
-
-        let nchunks = chunks.len();
-
-        let mut chunk_offsets_buf = BufferMut::<u64>::with_capacity(nchunks + 1);
-        // SAFETY: nchunks + 1
-        unsafe { chunk_offsets_buf.push_unchecked(0) }
-        let mut curr_offset = 0;
-        for c in &chunks {
-            curr_offset += c.len() as u64;
-            // SAFETY: nchunks + 1
-            unsafe { chunk_offsets_buf.push_unchecked(curr_offset) }
-        }
-
-        let chunk_offsets = PrimitiveArray::new(chunk_offsets_buf.freeze(), Validity::NonNullable);
-
-        Self {
-            dtype,
-            len: curr_offset
-                .try_into()
-                .vortex_expect("chunk offset must fit in usize"),
-            chunk_offsets,
-            chunks,
-            stats_set: Default::default(),
-        }
+pub trait ChunkedArrayExt: TypedArrayRef<Chunked> {
+    fn chunk_offsets_array(&self) -> &ArrayRef {
+        self.as_ref().slots()[CHUNK_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("validated chunk offsets slot")
     }
 
-    /// Validates the components that would be used to create a [`ChunkedArray`].
-    ///
-    /// This function checks all the invariants required by [`ChunkedArray::new_unchecked`].
-    pub fn validate(chunks: &[ArrayRef], dtype: &DType) -> VortexResult<()> {
-        for chunk in chunks {
-            if chunk.dtype() != dtype {
-                vortex_bail!(MismatchedTypes: dtype, chunk.dtype());
-            }
-        }
-
-        Ok(())
+    fn nchunks(&self) -> usize {
+        self.as_ref().slots().len().saturating_sub(CHUNKS_OFFSET)
     }
 
-    #[inline]
-    pub fn chunk(&self, idx: usize) -> &ArrayRef {
-        assert!(idx < self.nchunks(), "chunk index {idx} out of bounds");
+    fn chunk(&self, idx: usize) -> &ArrayRef {
+        self.as_ref().slots()[CHUNKS_OFFSET + idx]
+            .as_ref()
+            .vortex_expect("validated chunk slot")
+    }
 
-        &self.chunks[idx]
+    fn iter_chunks<'a>(&'a self) -> Box<dyn Iterator<Item = &'a ArrayRef> + 'a> {
+        Box::new(
+            self.as_ref().slots()[CHUNKS_OFFSET..]
+                .iter()
+                .map(|slot| slot.as_ref().vortex_expect("validated chunk slot")),
+        )
     }
 
-    pub fn nchunks(&self) -> usize {
-        self.chunks.len()
+    fn chunks(&self) -> Vec<ArrayRef> {
+        self.iter_chunks().cloned().collect()
     }
 
-    #[inline]
-    pub fn chunk_offsets(&self) -> Buffer<u64> {
-        self.chunk_offsets.to_buffer()
+    fn non_empty_chunks<'a>(&'a self) -> Box<dyn Iterator<Item = &'a ArrayRef> + 'a> {
+        Box::new(self.iter_chunks().filter(|chunk| !chunk.is_empty()))
     }
 
-    pub(crate) fn find_chunk_idx(&self, index: usize) -> VortexResult<(usize, usize)> {
-        assert!(index <= self.len(), "Index out of bounds of the array");
-        let index = index as u64;
+    fn chunk_offsets(&self) -> &[usize] {
+        &self.chunk_offsets
+    }
 
-        // Since there might be duplicate values in offsets because of empty chunks we want to search from right
-        // and take the last chunk (we subtract 1 since there's a leading 0)
-        let index_chunk = self
-            .chunk_offsets()
+    fn find_chunk_idx(&self, index: usize) -> VortexResult<(usize, usize)> {
+        assert!(
+            index <= self.as_ref().len(),
+            "Index out of bounds of the array"
+        );
+        let chunk_offsets = self.chunk_offsets();
+        let index_chunk = chunk_offsets
             .search_sorted(&index, SearchSortedSide::Right)?
             .to_ends_index(self.nchunks() + 1)
             .saturating_sub(1);
-        let chunk_start = self.chunk_offsets()[index_chunk];
-
-        let index_in_chunk =
-            usize::try_from(index - chunk_start).vortex_expect("Index is too large for usize");
+        let chunk_start = chunk_offsets[index_chunk];
+        let index_in_chunk = index - chunk_start;
         Ok((index_chunk, index_in_chunk))
     }
 
-    pub fn chunks(&self) -> &[ArrayRef] {
-        &self.chunks
+    fn array_iterator(&self) -> impl ArrayIterator + '_ {
+        ArrayIteratorAdapter::new(
+            self.as_ref().dtype().clone(),
+            self.iter_chunks().map(|chunk| Ok(chunk.clone())),
+        )
+    }
+
+    fn array_stream(&self) -> impl ArrayStream + '_ {
+        ArrayStreamAdapter::new(
+            self.as_ref().dtype().clone(),
+            stream::iter(self.iter_chunks().map(|chunk| Ok(chunk.clone()))),
+        )
+    }
+}
+impl<T: TypedArrayRef<Chunked>> ChunkedArrayExt for T {}
+
+impl ChunkedData {
+    pub(super) fn compute_chunk_offsets(chunks: &[ArrayRef]) -> Vec<usize> {
+        let mut chunk_offsets = Vec::with_capacity(chunks.len() + 1);
+        chunk_offsets.push(0);
+        let mut curr_offset = 0;
+        for chunk in chunks {
+            curr_offset += chunk.len();
+            chunk_offsets.push(curr_offset);
+        }
+        chunk_offsets
     }
 
-    pub fn non_empty_chunks(&self) -> impl Iterator<Item = &ArrayRef> + '_ {
-        self.chunks().iter().filter(|c| !c.is_empty())
+    pub(super) fn make_slots(
+        chunk_offsets: &[usize],
+        chunks: &[ArrayRef],
+    ) -> Vec<Option<ArrayRef>> {
+        let mut chunk_offsets_buf = BufferMut::<u64>::with_capacity(chunk_offsets.len());
+        for &offset in chunk_offsets {
+            let offset = u64::try_from(offset)
+                .vortex_expect("chunk offset must fit in u64 for serialization");
+            unsafe { chunk_offsets_buf.push_unchecked(offset) }
+        }
+
+        let mut slots = Vec::with_capacity(1 + chunks.len());
+        slots.push(Some(
+            PrimitiveArray::new(chunk_offsets_buf.freeze(), Validity::NonNullable).into_array(),
+        ));
+        slots.extend(chunks.iter().map(|c| Some(c.clone())));
+        slots
     }
 
-    pub fn array_iterator(&self) -> impl ArrayIterator + '_ {
-        ArrayIteratorAdapter::new(self.dtype().clone(), self.chunks().iter().cloned().map(Ok))
+    /// Validates the components that would be used to create a `ChunkedArray`.
+    ///
+    /// This function checks all the invariants required by `ChunkedArray::new_unchecked`.
+    pub fn validate(chunks: &[ArrayRef], dtype: &DType) -> VortexResult<()> {
+        for chunk in chunks {
+            if chunk.dtype() != dtype {
+                vortex_bail!(MismatchedTypes: dtype, chunk.dtype());
+            }
+        }
+
+        Ok(())
     }
+}
 
-    pub fn array_stream(&self) -> impl ArrayStream + '_ {
-        ArrayStreamAdapter::new(
-            self.dtype().clone(),
-            stream::iter(self.chunks().iter().cloned().map(Ok)),
-        )
+impl Array<Chunked> {
+    /// Constructs a new `ChunkedArray`.
+    pub fn try_new(chunks: Vec<ArrayRef>, dtype: DType) -> VortexResult<Self> {
+        ChunkedData::validate(&chunks, &dtype)?;
+        let len = chunks.iter().map(|chunk| chunk.len()).sum();
+        let chunk_offsets = ChunkedData::compute_chunk_offsets(&chunks);
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(
+                    Chunked,
+                    dtype,
+                    len,
+                    ChunkedData {
+                        chunk_offsets: chunk_offsets.clone(),
+                    },
+                )
+                .with_slots(ChunkedData::make_slots(&chunk_offsets, &chunks)),
+            )
+        })
     }
 
     pub fn rechunk(&self, target_bytesize: u64, target_rowsize: usize) -> VortexResult<Self> {
@@ -162,7 +184,7 @@ impl ChunkedArray {
         let mut chunks_to_combine = Vec::new();
         let mut new_chunk_n_bytes = 0;
         let mut new_chunk_n_elements = 0;
-        for chunk in self.chunks() {
+        for chunk in self.iter_chunks() {
             let n_bytes = chunk.nbytes();
             let n_elements = chunk.len();
 
@@ -171,13 +193,12 @@ impl ChunkedArray {
                 && !chunks_to_combine.is_empty()
             {
                 new_chunks.push(
-                    // SAFETY: chunks_to_combine contains valid chunks of the same dtype as self.
-                    // All chunks are guaranteed to be valid arrays matching self.dtype().
                     unsafe {
-                        ChunkedArray::new_unchecked(chunks_to_combine, self.dtype().clone())
-                            .to_canonical()?
-                            .into_array()
-                    },
+                        Array::<Chunked>::new_unchecked(chunks_to_combine, self.dtype().clone())
+                    }
+                    .into_array()
+                    .to_canonical()?
+                    .into_array(),
                 );
 
                 new_chunk_n_bytes = 0;
@@ -195,29 +216,50 @@ impl ChunkedArray {
         }
 
         if !chunks_to_combine.is_empty() {
-            new_chunks.push(unsafe {
-                // SAFETY: chunks_to_combine contains valid chunks of the same dtype as self.
-                // All chunks are guaranteed to be valid arrays matching self.dtype().
-                ChunkedArray::new_unchecked(chunks_to_combine, self.dtype().clone())
-                    .to_canonical()?
+            new_chunks.push(
+                unsafe { Array::<Chunked>::new_unchecked(chunks_to_combine, self.dtype().clone()) }
                     .into_array()
-            });
+                    .to_canonical()?
+                    .into_array(),
+            );
         }
 
-        // SAFETY: new_chunks contains valid arrays of the same dtype as self.
-        // All chunks were either taken from self or created from self's chunks.
         unsafe { Ok(Self::new_unchecked(new_chunks, self.dtype().clone())) }
     }
+
+    /// Creates a new `ChunkedArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// All chunks must have exactly the same [`DType`] as the provided `dtype`.
+    pub unsafe fn new_unchecked(chunks: Vec<ArrayRef>, dtype: DType) -> Self {
+        let len = chunks.iter().map(|chunk| chunk.len()).sum();
+        let chunk_offsets = ChunkedData::compute_chunk_offsets(&chunks);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(
+                    Chunked,
+                    dtype,
+                    len,
+                    ChunkedData {
+                        chunk_offsets: chunk_offsets.clone(),
+                    },
+                )
+                .with_slots(ChunkedData::make_slots(&chunk_offsets, &chunks)),
+            )
+        }
+    }
 }
 
-impl FromIterator<ArrayRef> for ChunkedArray {
+impl FromIterator<ArrayRef> for Array<Chunked> {
     fn from_iter<T: IntoIterator<Item = ArrayRef>>(iter: T) -> Self {
         let chunks: Vec<ArrayRef> = iter.into_iter().collect();
         let dtype = chunks
             .first()
             .map(|c| c.dtype().clone())
             .vortex_expect("Cannot infer DType from an empty iterator");
-        Self::try_new(chunks, dtype).vortex_expect("Failed to create chunked array from iterator")
+        Array::<Chunked>::try_new(chunks, dtype)
+            .vortex_expect("Failed to create chunked array from iterator")
     }
 }
 
@@ -227,9 +269,9 @@ mod test {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::array::Array;
+    use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::chunked::ChunkedArray;
+    use crate::arrays::chunked::ChunkedArrayExt;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -277,7 +319,7 @@ mod test {
         let rechunked = chunked.rechunk(1 << 16, 5).unwrap();
 
         assert_eq!(rechunked.nchunks(), 2);
-        assert!(rechunked.chunks().iter().all(|c| c.len() < 5));
+        assert!(rechunked.iter_chunks().all(|c| c.len() < 5));
         assert_arrays_eq!(chunked, rechunked);
     }
 
@@ -317,7 +359,7 @@ mod test {
 
         // Should be all_valid since all non-empty chunks are all_valid
         assert!(chunked.all_valid().unwrap());
-        assert!(!chunked.all_invalid().unwrap());
+        assert!(!chunked.into_array().all_invalid().unwrap());
 
         Ok(())
     }
@@ -337,7 +379,7 @@ mod test {
 
         // Should be all_invalid since all non-empty chunks are all_invalid
         assert!(!chunked.all_valid().unwrap());
-        assert!(chunked.all_invalid().unwrap());
+        assert!(chunked.into_array().all_invalid().unwrap());
 
         Ok(())
     }
@@ -357,7 +399,7 @@ mod test {
 
         // Should be neither all_valid nor all_invalid
         assert!(!chunked.all_valid().unwrap());
-        assert!(!chunked.all_invalid().unwrap());
+        assert!(!chunked.into_array().all_invalid().unwrap());
 
         Ok(())
     }
diff --git a/vortex-array/src/arrays/chunked/compute/aggregate.rs b/vortex-array/src/arrays/chunked/compute/aggregate.rs
new file mode 100644
index 00000000000..474c6943ea6
--- /dev/null
+++ b/vortex-array/src/arrays/chunked/compute/aggregate.rs
@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::arrays::Chunked;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::scalar::Scalar;
+
+#[derive(Debug)]
+pub struct ChunkedArrayAggregate;
+
+impl DynAggregateKernel for ChunkedArrayAggregate {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let Some(chunked) = batch.as_opt::<Chunked>() else {
+            return Ok(None);
+        };
+
+        let mut acc = aggregate_fn.accumulator(chunked.dtype())?;
+        for chunk in chunked.iter_chunks() {
+            acc.accumulate(chunk, ctx)?;
+        }
+        // Return the partial (not finalized) result, since the outer accumulator
+        // will call combine_partials() on this value.
+        Ok(Some(acc.flush()?))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::Accumulator;
+    use crate::aggregate_fn::DynAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::fns::sum::Sum;
+    use crate::arrays::BoolArray;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::scalar::Scalar;
+
+    fn run_sum(batch: &crate::ArrayRef) -> VortexResult<Scalar> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut acc = Accumulator::try_new(Sum, EmptyOptions, batch.dtype().clone())?;
+        acc.accumulate(batch, &mut ctx)?;
+        acc.finish()
+    }
+
+    #[test]
+    fn sum_chunked_i32() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                buffer![1i32, 2, 3].into_array(),
+                buffer![4i32, 5, 6].into_array(),
+            ],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(21));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_f64() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                buffer![1.5f64, 2.5].into_array(),
+                buffer![3.0f64].into_array(),
+            ],
+            DType::Primitive(PType::F64, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<f64>(), Some(7.0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_with_nulls() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array(),
+                PrimitiveArray::from_option_iter([None, Some(5)]).into_array(),
+            ],
+            DType::Primitive(PType::I32, Nullability::Nullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(9));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_all_null() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                PrimitiveArray::from_option_iter([None::<i32>, None]).into_array(),
+                PrimitiveArray::from_option_iter([None::<i32>]).into_array(),
+            ],
+            DType::Primitive(PType::I32, Nullability::Nullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_single_chunk() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![buffer![10i32, 20, 30].into_array()],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(60));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_empty_chunks() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let chunked = ChunkedArray::try_new(
+            vec![
+                Buffer::<i32>::empty().into_array(),
+                buffer![1i32, 2, 3].into_array(),
+                Buffer::<i32>::empty().into_array(),
+                buffer![4i32, 5].into_array(),
+                Buffer::<i32>::empty().into_array(),
+            ],
+            dtype,
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(15));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_all_empty() -> VortexResult<()> {
+        let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let chunked = ChunkedArray::try_new(vec![], dtype)?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(0));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_many_small_chunks() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                buffer![1i32].into_array(),
+                buffer![2i32].into_array(),
+                buffer![3i32].into_array(),
+                buffer![4i32].into_array(),
+                buffer![5i32].into_array(),
+            ],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(15));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_u64() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![
+                buffer![100u64, 200].into_array(),
+                buffer![300u64].into_array(),
+            ],
+            DType::Primitive(PType::U64, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(600));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_bool() -> VortexResult<()> {
+        let b1: BoolArray = [true, false, true].into_iter().collect();
+        let b2: BoolArray = [true, true].into_iter().collect();
+        let chunked = ChunkedArray::try_new(
+            vec![b1.into_array(), b2.into_array()],
+            DType::Bool(Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(4));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_bool_with_nulls() -> VortexResult<()> {
+        let b1 = BoolArray::from_iter([Some(true), None, Some(true)]);
+        let b2 = BoolArray::from_iter([Some(false), None]);
+        let chunked = ChunkedArray::try_new(
+            vec![b1.into_array(), b2.into_array()],
+            DType::Bool(Nullability::Nullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<u64>(), Some(2));
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_checked_overflow() -> VortexResult<()> {
+        let chunked = ChunkedArray::try_new(
+            vec![buffer![i64::MAX].into_array(), buffer![1i64].into_array()],
+            DType::Primitive(PType::I64, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&chunked.into_array())?;
+        assert!(result.is_null());
+        Ok(())
+    }
+
+    #[test]
+    fn sum_chunked_nested() -> VortexResult<()> {
+        let inner = ChunkedArray::try_new(
+            vec![buffer![1i32, 2].into_array(), buffer![3i32].into_array()],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?;
+        let outer = ChunkedArray::try_new(
+            vec![inner.into_array(), buffer![4i32, 5, 6].into_array()],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?;
+        let result = run_sum(&outer.into_array())?;
+        assert_eq!(result.as_primitive().typed_value::<i64>(), Some(21));
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/chunked/compute/cast.rs b/vortex-array/src/arrays/chunked/compute/cast.rs
index 0727b181859..9eed54d4300 100644
--- a/vortex-array/src/arrays/chunked/compute/cast.rs
+++ b/vortex-array/src/arrays/chunked/compute/cast.rs
@@ -5,16 +5,18 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
 
-impl CastReduce for ChunkedVTable {
-    fn cast(array: &ChunkedArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for Chunked {
+    fn cast(array: ArrayView<'_, Chunked>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         let mut cast_chunks = Vec::new();
-        for chunk in array.chunks() {
+        for chunk in array.iter_chunks() {
             cast_chunks.push(chunk.cast(dtype.clone())?);
         }
 
@@ -33,8 +35,8 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::chunked::ChunkedArray;
     use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -92,6 +94,6 @@ mod test {
         DType::Primitive(PType::U8, Nullability::NonNullable)
     ).unwrap().into_array())]
     fn test_cast_chunked_conformance(#[case] array: crate::ArrayRef) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/fill_null.rs b/vortex-array/src/arrays/chunked/compute/fill_null.rs
index a4d6a52cd0c..b207a152ee0 100644
--- a/vortex-array/src/arrays/chunked/compute/fill_null.rs
+++ b/vortex-array/src/arrays/chunked/compute/fill_null.rs
@@ -5,17 +5,21 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNullReduce;
 
-impl FillNullReduce for ChunkedVTable {
-    fn fill_null(array: &ChunkedArray, fill_value: &Scalar) -> VortexResult<Option<ArrayRef>> {
+impl FillNullReduce for Chunked {
+    fn fill_null(
+        array: ArrayView<'_, Chunked>,
+        fill_value: &Scalar,
+    ) -> VortexResult<Option<ArrayRef>> {
         let new_chunks = array
-            .chunks()
-            .iter()
+            .iter_chunks()
             .map(|c| c.fill_null(fill_value.clone()))
             .collect::<VortexResult<Vec<_>>>()?;
 
@@ -31,7 +35,7 @@ impl FillNullReduce for ChunkedVTable {
 mod tests {
     use vortex_buffer::BitBuffer;
 
-    use crate::array::Array;
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
     use crate::builtins::ArrayBuiltins;
@@ -44,14 +48,14 @@ mod tests {
     fn fill_null_chunks() {
         let chunked = ChunkedArray::try_new(
             vec![
-                BoolArray::new(BitBuffer::new_set(5), Validity::AllInvalid).to_array(),
-                BoolArray::new(BitBuffer::new_set(5), Validity::AllValid).to_array(),
+                BoolArray::new(BitBuffer::new_set(5), Validity::AllInvalid).into_array(),
+                BoolArray::new(BitBuffer::new_set(5), Validity::AllValid).into_array(),
             ],
             DType::Bool(Nullability::Nullable),
         )
         .unwrap();
 
-        let filled = chunked.to_array().fill_null(Scalar::from(false)).unwrap();
+        let filled = chunked.into_array().fill_null(Scalar::from(false)).unwrap();
         assert_eq!(*filled.dtype(), DType::Bool(Nullability::NonNullable));
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/filter.rs b/vortex-array/src/arrays/chunked/compute/filter.rs
index 2e2328f77a6..0e32543761d 100644
--- a/vortex-array/src/arrays/chunked/compute/filter.rs
+++ b/vortex-array/src/arrays/chunked/compute/filter.rs
@@ -7,13 +7,14 @@ use vortex_error::VortexResult;
 use vortex_mask::Mask;
 use vortex_mask::MaskIter;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::arrays::filter::FilterKernel;
 use crate::search_sorted::SearchSorted;
 use crate::search_sorted::SearchSortedSide;
@@ -22,9 +23,9 @@ use crate::validity::Validity;
 // This is modeled after the constant with the equivalent name in arrow-rs.
 pub(crate) const FILTER_SLICES_SELECTIVITY_THRESHOLD: f64 = 0.8;
 
-impl FilterKernel for ChunkedVTable {
+impl FilterKernel for Chunked {
     fn filter(
-        array: &ChunkedArray,
+        array: ArrayView<'_, Chunked>,
         mask: &Mask,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -62,7 +63,7 @@ pub(crate) enum ChunkFilter {
 
 /// Filter the chunks using slice ranges.
 fn filter_slices(
-    array: &ChunkedArray,
+    array: ArrayView<'_, Chunked>,
     slices: impl Iterator<Item = (usize, usize)>,
 ) -> VortexResult<Vec<ArrayRef>> {
     let mut result = Vec::with_capacity(array.nchunks());
@@ -70,7 +71,7 @@ fn filter_slices(
     let chunk_filters = chunk_filters(array, slices)?;
 
     // Now, apply the chunk filter to every slice.
-    for (chunk, chunk_filter) in array.chunks().iter().zip(chunk_filters.into_iter()) {
+    for (chunk, chunk_filter) in array.iter_chunks().zip(chunk_filters.into_iter()) {
         match chunk_filter {
             // All => preserve the entire chunk unfiltered.
             ChunkFilter::All => result.push(chunk.clone()),
@@ -87,7 +88,7 @@ fn filter_slices(
 }
 
 pub(crate) fn chunk_filters(
-    array: &ChunkedArray,
+    array: ArrayView<'_, Chunked>,
     slices: impl Iterator<Item = (usize, usize)>,
 ) -> VortexResult<Vec<ChunkFilter>> {
     let chunk_offsets = array.chunk_offsets();
@@ -95,10 +96,10 @@ pub(crate) fn chunk_filters(
     let mut chunk_filters = vec![ChunkFilter::None; array.nchunks()];
 
     for (slice_start, slice_end) in slices {
-        let (start_chunk, start_idx) = find_chunk_idx(slice_start, &chunk_offsets)?;
+        let (start_chunk, start_idx) = find_chunk_idx(slice_start, chunk_offsets)?;
         // NOTE: we adjust slice end back by one, in case it ends on a chunk boundary, we do not
         // want to index into the unused chunk.
-        let (end_chunk, end_idx) = find_chunk_idx(slice_end - 1, &chunk_offsets)?;
+        let (end_chunk, end_idx) = find_chunk_idx(slice_end - 1, chunk_offsets)?;
         // Adjust back to an exclusive range
         let end_idx = end_idx + 1;
 
@@ -117,8 +118,7 @@ pub(crate) fn chunk_filters(
             // start chunk: append a slice from (start_idx, start_chunk_end), i.e. whole chunk.
             // end chunk: append a slice from (0, end_idx).
             // chunks between start and end: append ChunkFilter::All.
-            let start_chunk_len: usize =
-                (chunk_offsets[start_chunk + 1] - chunk_offsets[start_chunk]).try_into()?;
+            let start_chunk_len = chunk_offsets[start_chunk + 1] - chunk_offsets[start_chunk];
             let start_slice = (start_idx, start_chunk_len);
             match &mut chunk_filters[start_chunk] {
                 f @ (ChunkFilter::All | ChunkFilter::None) => {
@@ -146,7 +146,7 @@ pub(crate) fn chunk_filters(
 
 /// Filter the chunks using indices.
 fn filter_indices(
-    array: &ChunkedArray,
+    array: ArrayView<'_, Chunked>,
     indices: impl Iterator<Item = usize>,
 ) -> VortexResult<Vec<ArrayRef>> {
     let mut result = Vec::with_capacity(array.nchunks());
@@ -156,15 +156,14 @@ fn filter_indices(
     let chunk_offsets = array.chunk_offsets();
 
     for set_index in indices {
-        let (chunk_id, index) = find_chunk_idx(set_index, &chunk_offsets)?;
+        let (chunk_id, index) = find_chunk_idx(set_index, chunk_offsets)?;
         if chunk_id != current_chunk_id {
             // Push the chunk we've accumulated.
             if !chunk_indices.is_empty() {
                 let chunk = array.chunk(current_chunk_id);
                 let indices =
                     PrimitiveArray::new(chunk_indices.clone().freeze(), Validity::NonNullable);
-                let filtered_chunk = chunk.take(indices.to_array())?.to_canonical()?.into_array();
-                result.push(filtered_chunk);
+                result.push(chunk.take(indices.into_array())?);
             }
 
             // Advance the chunk forward, reset the chunk indices buffer.
@@ -178,7 +177,7 @@ fn filter_indices(
     if !chunk_indices.is_empty() {
         let chunk = array.chunk(current_chunk_id);
         let indices = PrimitiveArray::new(chunk_indices.clone().freeze(), Validity::NonNullable);
-        let filtered_chunk = chunk.take(indices.to_array())?.to_canonical()?.into_array();
+        let filtered_chunk = chunk.take(indices.into_array())?;
         result.push(filtered_chunk);
     }
 
@@ -187,14 +186,12 @@ fn filter_indices(
 
 /// Mirrors the find_chunk_idx method on ChunkedArray, but avoids all of the overhead
 /// from scalars, dtypes, and metadata cloning.
-pub(crate) fn find_chunk_idx(idx: usize, chunk_ends: &[u64]) -> VortexResult<(usize, usize)> {
+pub(crate) fn find_chunk_idx(idx: usize, chunk_ends: &[usize]) -> VortexResult<(usize, usize)> {
     let chunk_id = chunk_ends
-        .search_sorted(&(idx as u64), SearchSortedSide::Right)?
+        .search_sorted(&idx, SearchSortedSide::Right)?
         .to_ends_index(chunk_ends.len())
         .saturating_sub(1);
-    let chunk_begin: usize = chunk_ends[chunk_id]
-        .try_into()
-        .vortex_expect("chunk end must fit in usize");
+    let chunk_begin = chunk_ends[chunk_id];
     let chunk_offset = idx - chunk_begin;
 
     Ok((chunk_id, chunk_offset))
@@ -206,7 +203,6 @@ mod test {
     use vortex_mask::Mask;
 
     use crate::IntoArray;
-    use crate::array::Array;
     use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
     use crate::compute::conformance::filter::test_filter_conformance;
@@ -254,17 +250,17 @@ mod test {
         vec![
             buffer![0u64, 1].into_array(),
             buffer![2_u64].into_array(),
-            PrimitiveArray::empty::<u64>(Nullability::NonNullable).to_array(),
+            PrimitiveArray::empty::<u64>(Nullability::NonNullable).into_array(),
             buffer![3_u64, 4].into_array(),
         ],
         DType::Primitive(PType::U64, Nullability::NonNullable),
     ).unwrap())]
     #[case(ChunkedArray::try_new(
         vec![
-            PrimitiveArray::from_option_iter([Some(0u64), None]).to_array(),
-            PrimitiveArray::from_option_iter([Some(2u64)]).to_array(),
-            PrimitiveArray::empty::<u64>(Nullability::Nullable).to_array(),
-            PrimitiveArray::from_option_iter([None, Some(4u64)]).to_array(),
+            PrimitiveArray::from_option_iter([Some(0u64), None]).into_array(),
+            PrimitiveArray::from_option_iter([Some(2u64)]).into_array(),
+            PrimitiveArray::empty::<u64>(Nullability::Nullable).into_array(),
+            PrimitiveArray::from_option_iter([None, Some(4u64)]).into_array(),
         ],
         DType::Primitive(PType::U64, Nullability::Nullable),
     ).unwrap())]
@@ -279,6 +275,6 @@ mod test {
         DType::Primitive(PType::I64, Nullability::NonNullable),
     ).unwrap())]
     fn test_filter_chunked_conformance(#[case] chunked: ChunkedArray) {
-        test_filter_conformance(chunked.as_ref());
+        test_filter_conformance(&chunked.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/is_constant.rs b/vortex-array/src/arrays/chunked/compute/is_constant.rs
deleted file mode 100644
index 9d913c18fd2..00000000000
--- a/vortex-array/src/arrays/chunked/compute/is_constant.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::is_constant_opts;
-use crate::register_kernel;
-
-impl IsConstantKernel for ChunkedVTable {
-    fn is_constant(
-        &self,
-        array: &ChunkedArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        let mut chunks = array.non_empty_chunks();
-
-        let first_chunk = chunks
-            .next()
-            .vortex_expect("Must have at least one non-empty chunk");
-
-        match is_constant_opts(first_chunk, opts)? {
-            // Un-determined
-            None => return Ok(None),
-            Some(false) => return Ok(Some(false)),
-            Some(true) => {}
-        }
-
-        let first_value = first_chunk.scalar_at(0)?.into_nullable();
-
-        for chunk in chunks {
-            match is_constant_opts(chunk, opts)? {
-                // Un-determined
-                None => return Ok(None),
-                Some(false) => return Ok(Some(false)),
-                Some(true) => {}
-            }
-
-            if first_value != chunk.scalar_at(0)?.into_nullable() {
-                return Ok(Some(false));
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(ChunkedVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::Buffer;
-    use vortex_buffer::buffer;
-
-    use crate::Array;
-    use crate::IntoArray;
-    use crate::arrays::ChunkedArray;
-    use crate::dtype::DType;
-    use crate::dtype::Nullability;
-    use crate::dtype::PType;
-
-    #[test]
-    fn empty_chunk_is_constant() {
-        let chunked = ChunkedArray::try_new(
-            vec![
-                Buffer::<u8>::empty().into_array(),
-                Buffer::<u8>::empty().into_array(),
-                buffer![255u8, 255].into_array(),
-                Buffer::<u8>::empty().into_array(),
-                buffer![255u8, 255].into_array(),
-            ],
-            DType::Primitive(PType::U8, Nullability::NonNullable),
-        )
-        .unwrap()
-        .into_array();
-
-        assert!(chunked.statistics().compute_is_constant().unwrap());
-    }
-}
diff --git a/vortex-array/src/arrays/chunked/compute/is_sorted.rs b/vortex-array/src/arrays/chunked/compute/is_sorted.rs
deleted file mode 100644
index 76577946cc0..00000000000
--- a/vortex-array/src/arrays/chunked/compute/is_sorted.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::compute::is_sorted;
-use crate::compute::is_strict_sorted;
-use crate::register_kernel;
-
-impl IsSortedKernel for ChunkedVTable {
-    fn is_sorted(&self, array: &ChunkedArray) -> VortexResult<Option<bool>> {
-        is_sorted_impl(array, false, is_sorted)
-    }
-
-    fn is_strict_sorted(&self, array: &ChunkedArray) -> VortexResult<Option<bool>> {
-        is_sorted_impl(array, true, is_strict_sorted)
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(ChunkedVTable).lift());
-
-fn is_sorted_impl(
-    array: &ChunkedArray,
-    strict: bool,
-    reentry_fn: impl Fn(&dyn Array) -> VortexResult<Option<bool>>,
-) -> VortexResult<Option<bool>> {
-    let mut first_last = Vec::default();
-
-    for chunk in array.chunks() {
-        if chunk.is_empty() {
-            continue;
-        }
-
-        let first = chunk.scalar_at(0)?;
-        let last = chunk.scalar_at(chunk.len() - 1)?;
-
-        first_last.push((first, last));
-    }
-
-    let chunk_sorted = first_last
-        .iter()
-        .is_sorted_by(|a, b| if strict { a.1 < b.0 } else { a.1 <= b.0 });
-
-    if !chunk_sorted {
-        return Ok(Some(false));
-    }
-
-    for chunk in array.chunks() {
-        match reentry_fn(chunk)? {
-            None => {
-                return Ok(None);
-            }
-            Some(v) => {
-                if !v {
-                    return Ok(Some(false));
-                }
-            }
-        }
-    }
-
-    Ok(Some(true))
-}
diff --git a/vortex-array/src/arrays/chunked/compute/kernel.rs b/vortex-array/src/arrays/chunked/compute/kernel.rs
index 97b982e09e2..502c1fe8337 100644
--- a/vortex-array/src/arrays/chunked/compute/kernel.rs
+++ b/vortex-array/src/arrays/chunked/compute/kernel.rs
@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::ChunkedVTable;
-use crate::arrays::FilterExecuteAdaptor;
-use crate::arrays::SliceExecuteAdaptor;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Chunked;
+use crate::arrays::dict::TakeExecuteAdaptor;
+use crate::arrays::filter::FilterExecuteAdaptor;
+use crate::arrays::slice::SliceExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::mask::MaskExecuteAdaptor;
+use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
-pub(crate) static PARENT_KERNELS: ParentKernelSet<ChunkedVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ChunkedVTable)),
-    ParentKernelSet::lift(&MaskExecuteAdaptor(ChunkedVTable)),
-    ParentKernelSet::lift(&SliceExecuteAdaptor(ChunkedVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ChunkedVTable)),
+pub(crate) static PARENT_KERNELS: ParentKernelSet<Chunked> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FilterExecuteAdaptor(Chunked)),
+    ParentKernelSet::lift(&MaskExecuteAdaptor(Chunked)),
+    ParentKernelSet::lift(&SliceExecuteAdaptor(Chunked)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Chunked)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(Chunked)),
 ]);
diff --git a/vortex-array/src/arrays/chunked/compute/mask.rs b/vortex-array/src/arrays/chunked/compute/mask.rs
index 86a2ed6e820..bec7b5e83d0 100644
--- a/vortex-array/src/arrays/chunked/compute/mask.rs
+++ b/vortex-array/src/arrays/chunked/compute/mask.rs
@@ -6,27 +6,28 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::scalar_fn::EmptyOptions;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
 use crate::scalar_fn::fns::mask::MaskKernel;
 
-impl MaskKernel for ChunkedVTable {
+impl MaskKernel for Chunked {
     fn mask(
-        array: &ChunkedArray,
+        array: ArrayView<'_, Chunked>,
         mask: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let chunk_offsets = array.chunk_offsets();
         let new_chunks: Vec<ArrayRef> = array
-            .chunks()
-            .iter()
+            .iter_chunks()
             .enumerate()
             .map(|(i, chunk)| {
-                let start: usize = chunk_offsets[i].try_into()?;
-                let end: usize = chunk_offsets[i + 1].try_into()?;
+                let start = chunk_offsets[i];
+                let end = chunk_offsets[i + 1];
                 let chunk_mask = mask.slice(start..end)?;
                 MaskExpr.try_new_array(chunk.len(), EmptyOptions, [chunk.clone(), chunk_mask])
             })
@@ -56,15 +57,15 @@ mod test {
         vec![
             buffer![0u64, 1].into_array(),
             buffer![2_u64].into_array(),
-            PrimitiveArray::empty::<u64>(Nullability::NonNullable).to_array(),
+            PrimitiveArray::empty::<u64>(Nullability::NonNullable).into_array(),
             buffer![3_u64, 4].into_array(),
         ],
         DType::Primitive(PType::U64, Nullability::NonNullable),
     ).unwrap())]
     #[case(ChunkedArray::try_new(
         vec![
-            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).to_array(),
-            PrimitiveArray::from_option_iter([Some(4i32), Some(5)]).to_array(),
+            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]).into_array(),
+            PrimitiveArray::from_option_iter([Some(4i32), Some(5)]).into_array(),
         ],
         DType::Primitive(PType::I32, Nullability::Nullable),
     ).unwrap())]
@@ -79,6 +80,6 @@ mod test {
         DType::Primitive(PType::F32, Nullability::NonNullable),
     ).unwrap())]
     fn test_mask_chunked_conformance(#[case] chunked: ChunkedArray) {
-        test_mask_conformance(chunked.as_ref());
+        test_mask_conformance(&chunked.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/min_max.rs b/vortex-array/src/arrays/chunked/compute/min_max.rs
deleted file mode 100644
index d1130649386..00000000000
--- a/vortex-array/src/arrays/chunked/compute/min_max.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::compute::min_max;
-use crate::partial_ord::partial_max;
-use crate::partial_ord::partial_min;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl MinMaxKernel for ChunkedVTable {
-    fn min_max(&self, array: &ChunkedArray) -> VortexResult<Option<MinMaxResult>> {
-        let mut min_max_all_null = true;
-        let res = array
-            .array_iterator()
-            .map(|chunk| {
-                let chunk = chunk?;
-                if let Some(min_max) = min_max(&chunk)? {
-                    min_max_all_null = false;
-                    Ok((Some(min_max.min), Some(min_max.max)))
-                } else {
-                    Ok((None, None))
-                }
-            })
-            .collect::<VortexResult<Vec<_>>>()?;
-
-        // There are no chunks that have min/max stats, so return early
-        if min_max_all_null {
-            return Ok(None);
-        }
-
-        let (min_values, max_values): (Vec<Option<Scalar>>, Vec<Option<Scalar>>) =
-            res.into_iter().unzip();
-
-        Ok(Some(MinMaxResult {
-            min: min_values
-                .into_iter()
-                .flatten()
-                // This is None iff all the values `None` (refuted above) or partial_min returns None
-                .fold(None, |acc, x| {
-                    if let Some(acc) = acc {
-                        partial_min(x, acc)
-                    } else {
-                        Some(x)
-                    }
-                })
-                .ok_or_else(|| {
-                    vortex_err!("Incomparable scalars (from partial_min), this is likely a bug",)
-                })?,
-            max: max_values
-                .into_iter()
-                .flatten()
-                .fold(None, |acc, x| {
-                    if let Some(acc) = acc {
-                        partial_max(x, acc)
-                    } else {
-                        Some(x)
-                    }
-                })
-                .ok_or_else(|| vortex_err!("Incomparable scalars, this is likely a bug"))?,
-        }))
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(ChunkedVTable).lift());
diff --git a/vortex-array/src/arrays/chunked/compute/mod.rs b/vortex-array/src/arrays/chunked/compute/mod.rs
index 2e972cc1f23..bbc9029657a 100644
--- a/vortex-array/src/arrays/chunked/compute/mod.rs
+++ b/vortex-array/src/arrays/chunked/compute/mod.rs
@@ -1,17 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+pub(crate) mod aggregate;
 mod cast;
 mod fill_null;
 mod filter;
-mod is_constant;
-mod is_sorted;
 pub(crate) mod kernel;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
-mod sum;
 mod take;
 mod zip;
 
@@ -82,7 +79,7 @@ mod tests {
     ).unwrap())]
 
     fn test_chunked_consistency(#[case] array: ChunkedArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
diff --git a/vortex-array/src/arrays/chunked/compute/rules.rs b/vortex-array/src/arrays/chunked/compute/rules.rs
index fc34af04dc2..8ef63a188c3 100644
--- a/vortex-array/src/arrays/chunked/compute/rules.rs
+++ b/vortex-array/src/arrays/chunked/compute/rules.rs
@@ -6,46 +6,47 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::AnyScalarFn;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrays::ScalarFnArray;
+use crate::arrays::ScalarFnVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::scalar_fn::AnyScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::optimizer::ArrayOptimizer;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullReduceAdaptor;
-use crate::scalar_fn::fns::zip::ZipReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<ChunkedVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ChunkedVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<Chunked> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(Chunked)),
     ParentRuleSet::lift(&ChunkedUnaryScalarFnPushDownRule),
     ParentRuleSet::lift(&ChunkedConstantScalarFnPushDownRule),
-    ParentRuleSet::lift(&FillNullReduceAdaptor(ChunkedVTable)),
-    ParentRuleSet::lift(&ZipReduceAdaptor(ChunkedVTable)),
+    ParentRuleSet::lift(&FillNullReduceAdaptor(Chunked)),
 ]);
 
 /// Push down any unary scalar function through chunked arrays.
 #[derive(Debug)]
 struct ChunkedUnaryScalarFnPushDownRule;
-impl ArrayParentReduceRule<ChunkedVTable> for ChunkedUnaryScalarFnPushDownRule {
+impl ArrayParentReduceRule<Chunked> for ChunkedUnaryScalarFnPushDownRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        array: &ChunkedArray,
-        parent: &ScalarFnArray,
+        array: ArrayView<'_, Chunked>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
-        if parent.children().len() != 1 {
+        if parent.nchildren() != 1 {
             return Ok(None);
         }
 
         let new_chunks: Vec<_> = array
-            .chunks
-            .iter()
+            .iter_chunks()
             .map(|chunk| {
                 ScalarFnArray::try_new(
                     parent.scalar_fn().clone(),
@@ -66,38 +67,36 @@ impl ArrayParentReduceRule<ChunkedVTable> for ChunkedUnaryScalarFnPushDownRule {
 /// Push down non-unary scalar functions through chunked arrays where other siblings are constant.
 #[derive(Debug)]
 struct ChunkedConstantScalarFnPushDownRule;
-impl ArrayParentReduceRule<ChunkedVTable> for ChunkedConstantScalarFnPushDownRule {
+impl ArrayParentReduceRule<Chunked> for ChunkedConstantScalarFnPushDownRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        array: &ChunkedArray,
-        parent: &ScalarFnArray,
+        array: ArrayView<'_, Chunked>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
-        for (idx, child) in parent.children().iter().enumerate() {
+        for (idx, child) in parent.iter_children().enumerate() {
             if idx == child_idx {
                 continue;
             }
-            if !child.is::<ConstantVTable>() {
+            if !child.is::<Constant>() {
                 return Ok(None);
             }
         }
 
         let new_chunks: Vec<_> = array
-            .chunks
-            .iter()
+            .iter_chunks()
             .map(|chunk| {
                 let new_children: Vec<_> = parent
-                    .children()
-                    .iter()
+                    .iter_children()
                     .enumerate()
                     .map(|(idx, child)| {
                         if idx == child_idx {
                             chunk.clone()
                         } else {
                             ConstantArray::new(
-                                child.as_::<ConstantVTable>().scalar().clone(),
+                                child.as_::<Constant>().scalar().clone(),
                                 chunk.len(),
                             )
                             .into_array()
diff --git a/vortex-array/src/arrays/chunked/compute/slice.rs b/vortex-array/src/arrays/chunked/compute/slice.rs
index b8633663d08..14919301bd1 100644
--- a/vortex-array/src/arrays/chunked/compute/slice.rs
+++ b/vortex-array/src/arrays/chunked/compute/slice.rs
@@ -9,13 +9,15 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::arrays::SliceKernel;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::slice::SliceKernel;
 
-impl SliceKernel for ChunkedVTable {
+impl SliceKernel for Chunked {
     fn slice(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
diff --git a/vortex-array/src/arrays/chunked/compute/sum.rs b/vortex-array/src/arrays/chunked/compute/sum.rs
deleted file mode 100644
index 3a54fa72290..00000000000
--- a/vortex-array/src/arrays/chunked/compute/sum.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::compute::sum_with_accumulator;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl SumKernel for ChunkedVTable {
-    fn sum(&self, array: &ChunkedArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        array
-            .chunks
-            .iter()
-            .try_fold(accumulator.clone(), |result, chunk| {
-                sum_with_accumulator(chunk, &result)
-            })
-    }
-}
-
-register_kernel!(SumKernelAdapter(ChunkedVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::array::IntoArray;
-    use crate::arrays::ChunkedArray;
-    use crate::arrays::ConstantArray;
-    use crate::arrays::DecimalArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::sum;
-    use crate::dtype::DType;
-    use crate::dtype::DecimalDType;
-    use crate::dtype::Nullability;
-    use crate::dtype::i256;
-    use crate::scalar::DecimalValue;
-    use crate::scalar::Scalar;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_sum_chunked_floats_with_nulls() {
-        // Create chunks with floats including nulls
-        let chunk1 =
-            PrimitiveArray::from_option_iter(vec![Some(1.5f64), None, Some(3.2), Some(4.8)]);
-
-        let chunk2 = PrimitiveArray::from_option_iter(vec![Some(2.1f64), Some(5.7), None]);
-
-        let chunk3 = PrimitiveArray::from_option_iter(vec![None, Some(1.0f64), Some(2.5), None]);
-
-        // Create chunked array from the chunks
-        let dtype = chunk1.dtype().clone();
-        let chunked = ChunkedArray::try_new(
-            vec![
-                chunk1.into_array(),
-                chunk2.into_array(),
-                chunk3.into_array(),
-            ],
-            dtype,
-        )
-        .unwrap();
-
-        // Compute sum
-        let result = sum(chunked.as_ref()).unwrap();
-
-        // Expected sum: 1.5 + 3.2 + 4.8 + 2.1 + 5.7 + 1.0 + 2.5 = 20.8
-        assert_eq!(result.as_primitive().as_::<f64>(), Some(20.8));
-    }
-
-    #[test]
-    fn test_sum_chunked_floats_all_nulls_is_zero() {
-        // Create chunks with all nulls
-        let chunk1 = PrimitiveArray::from_option_iter::<f32, _>(vec![None, None, None]);
-        let chunk2 = PrimitiveArray::from_option_iter::<f32, _>(vec![None, None]);
-
-        let dtype = chunk1.dtype().clone();
-        let chunked =
-            ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype).unwrap();
-        // Compute sum - should return null for all nulls
-        let result = sum(chunked.as_ref()).unwrap();
-        assert_eq!(result, Scalar::primitive(0f64, Nullability::Nullable));
-    }
-
-    #[test]
-    fn test_sum_chunked_floats_empty_chunks() {
-        // Test with some empty chunks mixed with non-empty
-        let chunk1 = PrimitiveArray::from_option_iter(vec![Some(10.5f64), Some(20.3)]);
-        let chunk2 = ConstantArray::new(Scalar::primitive(0f64, Nullability::Nullable), 0);
-        let chunk3 = PrimitiveArray::from_option_iter(vec![Some(5.2f64)]);
-
-        let dtype = chunk1.dtype().clone();
-        let chunked = ChunkedArray::try_new(
-            vec![
-                chunk1.into_array(),
-                chunk2.into_array(),
-                chunk3.into_array(),
-            ],
-            dtype,
-        )
-        .unwrap();
-
-        // Compute sum: 10.5 + 20.3 + 5.2 = 36.0
-        let result = sum(chunked.as_ref()).unwrap();
-        assert_eq!(result.as_primitive().as_::<f64>(), Some(36.0));
-    }
-
-    #[test]
-    fn test_sum_chunked_int_almost_all_null_chunks() {
-        let chunk1 = PrimitiveArray::from_option_iter::<u32, _>(vec![Some(1)]);
-        let chunk2 = PrimitiveArray::from_option_iter::<u32, _>(vec![None]);
-
-        let dtype = chunk1.dtype().clone();
-        let chunked =
-            ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype).unwrap();
-
-        let result = sum(chunked.as_ref()).unwrap();
-        assert_eq!(result.as_primitive().as_::<u64>(), Some(1));
-    }
-
-    #[test]
-    fn test_sum_chunked_decimals() {
-        // Create decimal chunks with precision=10, scale=2
-        let decimal_dtype = DecimalDType::new(10, 2);
-        let chunk1 = DecimalArray::new(
-            buffer![100i32, 100i32, 100i32, 100i32, 100i32],
-            decimal_dtype,
-            Validity::AllValid,
-        );
-        let chunk2 = DecimalArray::new(
-            buffer![200i32, 200i32, 200i32],
-            decimal_dtype,
-            Validity::AllValid,
-        );
-        let chunk3 = DecimalArray::new(buffer![300i32, 300i32], decimal_dtype, Validity::AllValid);
-
-        let dtype = chunk1.dtype().clone();
-        let chunked = ChunkedArray::try_new(
-            vec![
-                chunk1.into_array(),
-                chunk2.into_array(),
-                chunk3.into_array(),
-            ],
-            dtype,
-        )
-        .unwrap();
-
-        // Compute sum: 5*100 + 3*200 + 2*300 = 500 + 600 + 600 = 1700 (represents 17.00)
-        let result = sum(chunked.as_ref()).unwrap();
-        let decimal_result = result.as_decimal();
-        assert_eq!(
-            decimal_result.decimal_value(),
-            Some(DecimalValue::I256(i256::from_i128(1700)))
-        );
-    }
-
-    #[test]
-    fn test_sum_chunked_decimals_with_nulls() {
-        let decimal_dtype = DecimalDType::new(10, 2);
-
-        // Create chunks with some nulls - all must have same nullability
-        let chunk1 = DecimalArray::new(
-            buffer![100i32, 100i32, 100i32],
-            decimal_dtype,
-            Validity::AllValid,
-        );
-        let chunk2 = DecimalArray::new(
-            buffer![0i32, 0i32],
-            decimal_dtype,
-            Validity::from_iter([false, false]),
-        );
-        let chunk3 = DecimalArray::new(buffer![200i32, 200i32], decimal_dtype, Validity::AllValid);
-
-        let dtype = chunk1.dtype().clone();
-        let chunked = ChunkedArray::try_new(
-            vec![
-                chunk1.into_array(),
-                chunk2.into_array(),
-                chunk3.into_array(),
-            ],
-            dtype,
-        )
-        .unwrap();
-
-        // Compute sum: 3*100 + 2*200 = 300 + 400 = 700 (nulls ignored)
-        let result = sum(chunked.as_ref()).unwrap();
-        let decimal_result = result.as_decimal();
-        assert_eq!(
-            decimal_result.decimal_value(),
-            Some(DecimalValue::I256(i256::from_i128(700)))
-        );
-    }
-
-    #[test]
-    fn test_sum_chunked_decimals_large() {
-        // Create decimals with precision 3 (max value 999)
-        // Sum will be 500 + 600 = 1100, which fits in result precision 13 (3+10)
-        let decimal_dtype = DecimalDType::new(3, 0);
-        let chunk1 = ConstantArray::new(
-            Scalar::decimal(
-                DecimalValue::I16(500),
-                decimal_dtype,
-                Nullability::NonNullable,
-            ),
-            1,
-        );
-        let chunk2 = ConstantArray::new(
-            Scalar::decimal(
-                DecimalValue::I16(600),
-                decimal_dtype,
-                Nullability::NonNullable,
-            ),
-            1,
-        );
-
-        let dtype = chunk1.dtype().clone();
-        let chunked =
-            ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype).unwrap();
-
-        // Compute sum: 500 + 600 = 1100
-        // Result should have precision 13 (3+10), scale 0
-        let result = sum(chunked.as_ref()).unwrap();
-        let decimal_result = result.as_decimal();
-        assert_eq!(
-            decimal_result.decimal_value(),
-            Some(DecimalValue::I256(i256::from_i128(1100)))
-        );
-        assert_eq!(
-            result.dtype(),
-            &DType::Decimal(DecimalDType::new(13, 0), Nullability::Nullable)
-        );
-    }
-}
diff --git a/vortex-array/src/arrays/chunked/compute/take.rs b/vortex-array/src/arrays/chunked/compute/take.rs
index 0b1da3602e5..1cd48c57319 100644
--- a/vortex-array/src/arrays/chunked/compute/take.rs
+++ b/vortex-array/src/arrays/chunked/compute/take.rs
@@ -5,16 +5,16 @@ use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
-use crate::arrays::ChunkedVTable;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
+use crate::arrays::ChunkedArray;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::TakeExecute;
-use crate::arrays::chunked::ChunkedArray;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::dict::TakeExecute;
 use crate::builtins::ArrayBuiltins;
-use crate::canonical::ToCanonical;
 use crate::dtype::DType;
 use crate::dtype::PType;
 use crate::executor::ExecutionCtx;
@@ -23,14 +23,13 @@ use crate::validity::Validity;
 // TODO(joe): this is pretty unoptimized but better than before. We want canonical using a builder
 // we also want to return a chunked array ideally.
 fn take_chunked(
-    array: &ChunkedArray,
-    indices: &dyn Array,
+    array: ArrayView<'_, Chunked>,
+    indices: &ArrayRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let indices = indices
-        .to_array()
         .cast(DType::Primitive(PType::U64, indices.dtype().nullability()))?
-        .to_primitive();
+        .execute::<PrimitiveArray>(ctx)?;
 
     let indices_mask = indices.validity_mask()?;
     let indices_values = indices.as_slice::<u64>();
@@ -61,9 +60,10 @@ fn take_chunked(
     for chunk_idx in 0..nchunks {
         let chunk_start = chunk_offsets[chunk_idx];
         let chunk_end = chunk_offsets[chunk_idx + 1];
-        let chunk_len = usize::try_from(chunk_end - chunk_start)?;
+        let chunk_len = chunk_end - chunk_start;
+        let chunk_end_u64 = u64::try_from(chunk_end)?;
 
-        let range_end = cursor + pairs[cursor..].partition_point(|&(v, _)| v < chunk_end);
+        let range_end = cursor + pairs[cursor..].partition_point(|&(v, _)| v < chunk_end_u64);
         let chunk_pairs = &pairs[cursor..range_end];
 
         if !chunk_pairs.is_empty() {
@@ -72,7 +72,7 @@ fn take_chunked(
                 if cursor + i > 0 && val != pairs[cursor + i - 1].0 {
                     dedup_idx += 1;
                 }
-                let local = usize::try_from(val - chunk_start)?;
+                let local = usize::try_from(val)? - chunk_start;
                 if local_indices.last() != Some(&local) {
                     local_indices.push(local);
                 }
@@ -96,14 +96,15 @@ fn take_chunked(
 
     // 4. Single take to restore original order and expand duplicates.
     //    Carry the original index validity so null indices produce null outputs.
-    let take_validity = Validity::from_mask(indices_mask, indices.dtype().nullability());
+    let take_validity =
+        Validity::from_mask(indices.validity_mask()?, indices.dtype().nullability());
     flat.take(PrimitiveArray::new(final_take.freeze(), take_validity).into_array())
 }
 
-impl TakeExecute for ChunkedVTable {
+impl TakeExecute for Chunked {
     fn take(
-        array: &ChunkedArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Chunked>,
+        indices: &ArrayRef,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         take_chunked(array, indices, ctx).map(Some)
@@ -118,11 +119,11 @@ mod test {
 
     use crate::IntoArray;
     use crate::ToCanonical;
-    use crate::array::Array;
     use crate::arrays::BoolArray;
+    use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
-    use crate::arrays::chunked::ChunkedArray;
+    use crate::arrays::chunked::ChunkedArrayExt;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::dtype::FieldNames;
@@ -138,7 +139,7 @@ mod test {
         assert_eq!(arr.len(), 9);
         let indices = buffer![0u64, 0, 6, 4].into_array();
 
-        let result = arr.take(indices.to_array()).unwrap();
+        let result = arr.take(indices).unwrap();
         assert_arrays_eq!(result, PrimitiveArray::from_iter([1i32, 1, 1, 2]));
     }
 
@@ -151,7 +152,7 @@ mod test {
         assert_eq!(arr.len(), 9);
         let indices = PrimitiveArray::new(buffer![0u64, 0, 6, 4], Validity::NonNullable);
 
-        let result = arr.take(indices.to_array()).unwrap();
+        let result = arr.take(indices.into_array()).unwrap();
         assert_arrays_eq!(
             result,
             PrimitiveArray::from_option_iter([1i32, 1, 1, 2].map(Some))
@@ -170,7 +171,7 @@ mod test {
             Validity::Array(bitbuffer![1 0 0 1].into_array()),
         );
 
-        let result = arr.take(indices.to_array()).unwrap();
+        let result = arr.take(indices.into_array()).unwrap();
         assert_arrays_eq!(
             result,
             PrimitiveArray::from_option_iter([Some(1i32), None, None, Some(2)])
@@ -183,17 +184,20 @@ mod test {
             StructArray::try_new(FieldNames::default(), vec![], 100, Validity::NonNullable)
                 .unwrap();
 
-        let arr = ChunkedArray::from_iter(vec![struct_array.to_array(), struct_array.to_array()]);
+        let arr = ChunkedArray::from_iter(vec![
+            struct_array.clone().into_array(),
+            struct_array.into_array(),
+        ]);
 
         let result = arr
-            .take(PrimitiveArray::from_option_iter(vec![Some(0), None, Some(101)]).to_array())
+            .take(PrimitiveArray::from_option_iter(vec![Some(0), None, Some(101)]).into_array())
             .unwrap();
 
         let expect = StructArray::try_new(
             FieldNames::default(),
             vec![],
             3,
-            Validity::Array(BoolArray::from_iter(vec![true, false, true]).to_array()),
+            Validity::Array(BoolArray::from_iter(vec![true, false, true]).into_array()),
         )
         .unwrap();
         assert_arrays_eq!(result, expect);
@@ -208,7 +212,7 @@ mod test {
         assert_eq!(arr.len(), 9);
 
         let indices = PrimitiveArray::empty::<u64>(Nullability::NonNullable);
-        let result = arr.take(indices.to_array()).unwrap();
+        let result = arr.take(indices.into_array()).unwrap();
 
         assert!(result.is_empty());
         assert_eq!(result.dtype(), arr.dtype());
@@ -232,7 +236,7 @@ mod test {
 
         // Fully shuffled indices that cross every chunk boundary.
         let indices = buffer![8u64, 0, 5, 3, 2, 7, 1, 6, 4].into_array();
-        let result = arr.take(indices.to_array())?;
+        let result = arr.take(indices)?;
 
         assert_arrays_eq!(
             result,
@@ -269,7 +273,7 @@ mod test {
             vortex_buffer::Buffer::from(indices.clone()),
             Validity::NonNullable,
         );
-        let result = arr.take(indices_arr.to_array())?;
+        let result = arr.take(indices_arr.into_array())?;
 
         // Verify every element.
         let result = result.to_primitive();
@@ -298,7 +302,7 @@ mod test {
         // Indices with nulls scattered across chunk boundaries.
         let indices =
             PrimitiveArray::from_option_iter([Some(5u64), None, Some(0), Some(3), None, Some(2)]);
-        let result = arr.take(indices.to_array())?;
+        let result = arr.take(indices.into_array())?;
 
         assert_arrays_eq!(
             result,
@@ -325,14 +329,14 @@ mod test {
                 .clone(),
         )
         .unwrap();
-        test_take_conformance(arr.as_ref());
+        test_take_conformance(&arr.into_array());
 
         // Test with nullable chunked array
         let a = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]);
         let b = PrimitiveArray::from_option_iter([Some(4i32), Some(5)]);
         let dtype = a.dtype().clone();
         let arr = ChunkedArray::try_new(vec![a.into_array(), b.into_array()], dtype).unwrap();
-        test_take_conformance(arr.as_ref());
+        test_take_conformance(&arr.into_array());
 
         // Test with multiple identical chunks
         let chunk = buffer![10i32, 20, 30, 40, 50].into_array();
@@ -341,6 +345,6 @@ mod test {
             chunk.dtype().clone(),
         )
         .unwrap();
-        test_take_conformance(arr.as_ref());
+        test_take_conformance(&arr.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/zip.rs b/vortex-array/src/arrays/chunked/compute/zip.rs
index fbc2ac9d06b..0979cb15031 100644
--- a/vortex-array/src/arrays/chunked/compute/zip.rs
+++ b/vortex-array/src/arrays/chunked/compute/zip.rs
@@ -2,26 +2,29 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::chunked::paired_chunks::PairedChunksExt;
 use crate::builtins::ArrayBuiltins;
-use crate::scalar_fn::fns::zip::ZipReduce;
+use crate::scalar_fn::fns::zip::ZipKernel;
 
 // Push down the zip call to the chunks. Without this rule
 // the default implementation canonicalises the chunked array
 // then zips once.
-impl ZipReduce for ChunkedVTable {
+impl ZipKernel for Chunked {
     fn zip(
-        if_true: &ChunkedArray,
-        if_false: &dyn Array,
-        mask: &Mask,
+        if_true: ArrayView<'_, Chunked>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let Some(if_false) = if_false.as_opt::<ChunkedVTable>() else {
+        let Some(if_false) = if_false.as_opt::<Chunked>() else {
             return Ok(None);
         };
         let dtype = if_true
@@ -29,44 +32,15 @@ impl ZipReduce for ChunkedVTable {
             .union_nullability(if_false.dtype().nullability());
         let mut out_chunks = Vec::with_capacity(if_true.nchunks() + if_false.nchunks());
 
-        let mut lhs_idx = 0;
-        let mut rhs_idx = 0;
-        let mut lhs_offset = 0;
-        let mut rhs_offset = 0;
-        let mut pos = 0;
-        let total_len = if_true.len();
-
-        while pos < total_len {
-            let lhs_chunk = if_true.chunk(lhs_idx);
-            let rhs_chunk = if_false.chunk(rhs_idx);
-
-            let lhs_rem = lhs_chunk.len() - lhs_offset;
-            let rhs_rem = rhs_chunk.len() - rhs_offset;
-            let take_until = lhs_rem.min(rhs_rem);
-
-            let mask_slice = mask.slice(pos..pos + take_until);
-            let lhs_slice = lhs_chunk.slice(lhs_offset..lhs_offset + take_until)?;
-            let rhs_slice = rhs_chunk.slice(rhs_offset..rhs_offset + take_until)?;
-
-            out_chunks.push(lhs_slice.zip(rhs_slice, mask_slice.into_array())?);
-
-            pos += take_until;
-            lhs_offset += take_until;
-            rhs_offset += take_until;
-
-            if lhs_offset == lhs_chunk.len() {
-                lhs_idx += 1;
-                lhs_offset = 0;
-            }
-            if rhs_offset == rhs_chunk.len() {
-                rhs_idx += 1;
-                rhs_offset = 0;
-            }
+        for pair in if_true.paired_chunks(&if_false) {
+            let pair = pair?;
+            let mask_slice = mask.slice(pair.pos)?;
+            out_chunks.push(mask_slice.zip(pair.left, pair.right)?);
         }
 
         // SAFETY: chunks originate from zipping slices of inputs that share dtype/nullability.
         let chunked = unsafe { ChunkedArray::new_unchecked(out_chunks, dtype) };
-        Ok(Some(chunked.to_array()))
+        Ok(Some(chunked.into_array()))
     }
 }
 
@@ -75,12 +49,15 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
+    use crate::ArrayRef;
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
     use crate::ToCanonical;
+    use crate::VortexSessionExecute;
+    use crate::arrays::Chunked;
     use crate::arrays::ChunkedArray;
-    use crate::arrays::ChunkedVTable;
-    #[expect(deprecated)]
-    use crate::compute::zip;
+    use crate::arrays::chunked::ChunkedArrayExt;
+    use crate::builtins::ArrayBuiltins;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -109,10 +86,17 @@ mod tests {
 
         let mask = Mask::from_iter([true, false, true, false, true]);
 
-        #[expect(deprecated)]
-        let zipped = zip(if_true.as_ref(), if_false.as_ref(), &mask).unwrap();
+        let zipped = &mask
+            .into_array()
+            .zip(if_true.into_array(), if_false.into_array())
+            .unwrap();
+        // One step of execution will push down the zip.
+        let zipped = zipped
+            .clone()
+            .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         let zipped = zipped
-            .as_opt::<ChunkedVTable>()
+            .as_opt::<Chunked>()
             .expect("zip should keep chunked encoding");
 
         assert_eq!(zipped.nchunks(), 4);
diff --git a/vortex-array/src/arrays/chunked/mod.rs b/vortex-array/src/arrays/chunked/mod.rs
index 4ef5ed10cf2..766d9f6575c 100644
--- a/vortex-array/src/arrays/chunked/mod.rs
+++ b/vortex-array/src/arrays/chunked/mod.rs
@@ -2,12 +2,15 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::ChunkedArray;
+pub use array::ChunkedArrayExt;
+pub use array::ChunkedData;
+pub use vtable::ChunkedArray;
 
-mod compute;
+pub(crate) mod compute;
+pub(crate) mod paired_chunks;
 
 mod vtable;
-pub use vtable::ChunkedVTable;
+pub use vtable::Chunked;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/arrays/chunked/paired_chunks.rs b/vortex-array/src/arrays/chunked/paired_chunks.rs
new file mode 100644
index 00000000000..f786d62b9fb
--- /dev/null
+++ b/vortex-array/src/arrays/chunked/paired_chunks.rs
@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::Range;
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::arrays::chunked::ChunkedArrayExt;
+
+pub(crate) struct AlignedPair {
+    pub left: ArrayRef,
+    pub right: ArrayRef,
+    pub pos: Range<usize>,
+}
+
+/// Cursor over a chunk list that maintains the invariant: `idx` always
+/// points at a non-empty chunk or is past the end.
+struct ChunkCursor {
+    chunks: Vec<ArrayRef>,
+    idx: usize,
+    offset: usize,
+}
+
+impl ChunkCursor {
+    fn new(chunks: Vec<ArrayRef>) -> Self {
+        let mut cursor = Self {
+            chunks,
+            idx: 0,
+            offset: 0,
+        };
+        cursor.skip_empty();
+        cursor
+    }
+
+    fn skip_empty(&mut self) {
+        while self.idx < self.chunks.len() && self.chunks[self.idx].is_empty() {
+            self.idx += 1;
+        }
+    }
+
+    fn is_exhausted(&self) -> bool {
+        self.idx >= self.chunks.len()
+    }
+
+    fn remaining(&self) -> usize {
+        self.chunks[self.idx].len() - self.offset
+    }
+
+    fn take(&mut self, n: usize) -> VortexResult<ArrayRef> {
+        let chunk = &self.chunks[self.idx];
+        let slice = chunk.slice(self.offset..self.offset + n)?;
+        self.offset += n;
+        if self.offset == chunk.len() {
+            self.idx += 1;
+            self.offset = 0;
+            self.skip_empty();
+        }
+        Ok(slice)
+    }
+}
+
+pub(crate) struct PairedChunks {
+    left: ChunkCursor,
+    right: ChunkCursor,
+    pos: usize,
+    total_len: usize,
+}
+
+pub(crate) trait PairedChunksExt: ChunkedArrayExt {
+    fn paired_chunks<T: ChunkedArrayExt>(&self, other: &T) -> PairedChunks {
+        assert_eq!(
+            self.as_ref().len(),
+            other.as_ref().len(),
+            "paired_chunks requires arrays of equal length"
+        );
+        PairedChunks {
+            left: ChunkCursor::new(self.chunks()),
+            right: ChunkCursor::new(other.chunks()),
+            pos: 0,
+            total_len: self.as_ref().len(),
+        }
+    }
+}
+
+impl<T: ChunkedArrayExt> PairedChunksExt for T {}
+
+impl Iterator for PairedChunks {
+    type Item = VortexResult<AlignedPair>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos >= self.total_len || self.left.is_exhausted() || self.right.is_exhausted() {
+            return None;
+        }
+
+        let take = self.left.remaining().min(self.right.remaining());
+
+        let (lhs_slice, rhs_slice) = match self
+            .left
+            .take(take)
+            .and_then(|l| self.right.take(take).map(|r| (l, r)))
+        {
+            Ok(pair) => pair,
+            Err(e) => return Some(Err(e)),
+        };
+
+        let start = self.pos;
+        self.pos += take;
+
+        Some(Ok(AlignedPair {
+            left: lhs_slice,
+            right: rhs_slice,
+            pos: start..self.pos,
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::IntoArray;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::chunked::paired_chunks::PairedChunksExt;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+
+    fn i32_dtype() -> DType {
+        DType::Primitive(PType::I32, Nullability::NonNullable)
+    }
+
+    #[allow(clippy::type_complexity)]
+    fn collect_pairs(
+        left: &ChunkedArray,
+        right: &ChunkedArray,
+    ) -> VortexResult<Vec<(Vec<i32>, Vec<i32>, std::ops::Range<usize>)>> {
+        use crate::ToCanonical;
+        let mut result = Vec::new();
+        for pair in left.paired_chunks(right) {
+            let pair = pair?;
+            let l: Vec<i32> = pair.left.to_primitive().as_slice::<i32>().to_vec();
+            let r: Vec<i32> = pair.right.to_primitive().as_slice::<i32>().to_vec();
+            result.push((l, r, pair.pos));
+        }
+        Ok(result)
+    }
+
+    #[test]
+    fn test_aligned_chunks() -> VortexResult<()> {
+        let left = ChunkedArray::try_new(
+            vec![buffer![1i32, 2].into_array(), buffer![3i32, 4].into_array()],
+            i32_dtype(),
+        )?;
+        let right = ChunkedArray::try_new(
+            vec![
+                buffer![10i32, 20].into_array(),
+                buffer![30i32, 40].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+
+        let pairs = collect_pairs(&left, &right)?;
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(pairs[0], (vec![1, 2], vec![10, 20], 0..2));
+        assert_eq!(pairs[1], (vec![3, 4], vec![30, 40], 2..4));
+        Ok(())
+    }
+
+    #[test]
+    fn test_misaligned_chunks() -> VortexResult<()> {
+        let left = ChunkedArray::try_new(
+            vec![
+                buffer![1i32, 2].into_array(),
+                buffer![3i32].into_array(),
+                buffer![4i32, 5].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+        let right = ChunkedArray::try_new(
+            vec![
+                buffer![10i32].into_array(),
+                buffer![20i32, 30].into_array(),
+                buffer![40i32, 50].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+
+        let pairs = collect_pairs(&left, &right)?;
+        assert_eq!(pairs.len(), 4);
+        assert_eq!(pairs[0], (vec![1], vec![10], 0..1));
+        assert_eq!(pairs[1], (vec![2], vec![20], 1..2));
+        assert_eq!(pairs[2], (vec![3], vec![30], 2..3));
+        assert_eq!(pairs[3], (vec![4, 5], vec![40, 50], 3..5));
+        Ok(())
+    }
+
+    #[test]
+    fn test_empty_chunks() -> VortexResult<()> {
+        let left = ChunkedArray::try_new(
+            vec![
+                buffer![0i32; 0].into_array(),
+                buffer![1i32, 2, 3].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+        let right = ChunkedArray::try_new(
+            vec![
+                buffer![10i32, 20, 30].into_array(),
+                buffer![0i32; 0].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+
+        let pairs = collect_pairs(&left, &right)?;
+        assert_eq!(pairs.len(), 1);
+        assert_eq!(pairs[0], (vec![1, 2, 3], vec![10, 20, 30], 0..3));
+        Ok(())
+    }
+
+    #[test]
+    fn test_single_element_chunks() -> VortexResult<()> {
+        let left = ChunkedArray::try_new(
+            vec![
+                buffer![1i32].into_array(),
+                buffer![2i32].into_array(),
+                buffer![3i32].into_array(),
+            ],
+            i32_dtype(),
+        )?;
+        let right = ChunkedArray::try_new(vec![buffer![10i32, 20, 30].into_array()], i32_dtype())?;
+
+        let pairs = collect_pairs(&left, &right)?;
+        assert_eq!(pairs.len(), 3);
+        assert_eq!(pairs[0], (vec![1], vec![10], 0..1));
+        assert_eq!(pairs[1], (vec![2], vec![20], 1..2));
+        assert_eq!(pairs[2], (vec![3], vec![30], 2..3));
+        Ok(())
+    }
+
+    #[test]
+    fn test_both_empty() -> VortexResult<()> {
+        let left = ChunkedArray::try_new(vec![], i32_dtype())?;
+        let right = ChunkedArray::try_new(vec![], i32_dtype())?;
+
+        let pairs = collect_pairs(&left, &right)?;
+        assert!(pairs.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    #[should_panic(expected = "paired_chunks requires arrays of equal length")]
+    fn test_length_mismatch_panics() {
+        let left = ChunkedArray::try_new(vec![buffer![1i32, 2].into_array()], i32_dtype()).unwrap();
+        let right =
+            ChunkedArray::try_new(vec![buffer![10i32, 20, 30].into_array()], i32_dtype()).unwrap();
+
+        left.paired_chunks(&right).for_each(drop);
+    }
+}
diff --git a/vortex-array/src/arrays/chunked/tests.rs b/vortex-array/src/arrays/chunked/tests.rs
index 80d11e4bc52..a20e775cf5c 100644
--- a/vortex-array/src/arrays/chunked/tests.rs
+++ b/vortex-array/src/arrays/chunked/tests.rs
@@ -8,11 +8,14 @@ use vortex_buffer::buffer;
 
 use crate::IntoArray;
 use crate::accessor::ArrayAccessor;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
 use crate::arrays::ListArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::struct_::StructArrayExt;
 use crate::assert_arrays_eq;
 use crate::canonical::ToCanonical;
 use crate::dtype::DType;
@@ -33,6 +36,36 @@ fn chunked_array() -> ChunkedArray {
     .unwrap()
 }
 
+#[test]
+fn with_slot_rewrites_chunk_and_offsets() {
+    let array = chunked_array().into_array();
+
+    let replacement = buffer![10u64, 11, 12].into_array();
+    let array = array.with_slot(1, replacement).unwrap();
+    let array = array.as_::<Chunked>();
+
+    assert_eq!(array.nchunks(), 3);
+    assert_eq!(array.chunk_offsets(), [0, 3, 6, 9]);
+    assert_arrays_eq!(
+        array.chunk(0).clone(),
+        PrimitiveArray::from_iter([10u64, 11, 12])
+    );
+    assert_arrays_eq!(
+        array.array().clone(),
+        PrimitiveArray::from_iter([10u64, 11, 12, 4, 5, 6, 7, 8, 9])
+    );
+}
+
+#[test]
+fn with_slot_rejects_len_mismatch() {
+    let err = chunked_array()
+        .into_array()
+        .with_slot(1, buffer![10u64, 11].into_array())
+        .unwrap_err();
+
+    assert!(err.to_string().contains("physical rewrite"));
+}
+
 #[test]
 fn slice_middle() {
     assert_arrays_eq!(
@@ -147,7 +180,7 @@ pub fn pack_nested_structs() {
     let dtype = struct_array.dtype().clone();
     let chunked = ChunkedArray::try_new(
         vec![
-            ChunkedArray::try_new(vec![struct_array.to_array()], dtype.clone())
+            ChunkedArray::try_new(vec![struct_array.clone().into_array()], dtype.clone())
                 .unwrap()
                 .into_array(),
         ],
@@ -189,7 +222,7 @@ pub fn pack_nested_lists() {
         ),
     );
 
-    let canon_values = chunked_list.unwrap().to_listview();
+    let canon_values = chunked_list.unwrap().as_array().to_listview();
 
     assert_eq!(l1.scalar_at(0).unwrap(), canon_values.scalar_at(0).unwrap());
     assert_eq!(l2.scalar_at(0).unwrap(), canon_values.scalar_at(1).unwrap());
diff --git a/vortex-array/src/arrays/chunked/vtable/array.rs b/vortex-array/src/arrays/chunked/vtable/array.rs
deleted file mode 100644
index 3dd35b0884c..00000000000
--- a/vortex-array/src/arrays/chunked/vtable/array.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ChunkedVTable> for ChunkedVTable {
-    fn len(array: &ChunkedArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &ChunkedArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ChunkedArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &ChunkedArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.len.hash(state);
-        array.chunk_offsets.as_ref().array_hash(state, precision);
-        for chunk in &array.chunks {
-            chunk.array_hash(state, precision);
-        }
-    }
-
-    fn array_eq(array: &ChunkedArray, other: &ChunkedArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.len == other.len
-            && array
-                .chunk_offsets
-                .as_ref()
-                .array_eq(other.chunk_offsets.as_ref(), precision)
-            && array.chunks.len() == other.chunks.len()
-            && array
-                .chunks
-                .iter()
-                .zip(&other.chunks)
-                .all(|(a, b)| a.array_eq(b, precision))
-    }
-}
diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs
index c66ce3a7dfd..63bb4132eca 100644
--- a/vortex-array/src/arrays/chunked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs
@@ -1,64 +1,70 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_buffer::BufferMut;
+use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewRebuildMode;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
-use crate::builders::builder_with_capacity;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewRebuildMode;
+use crate::arrays::struct_::StructArrayExt;
+use crate::builders::builder_with_capacity_in;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::dtype::StructFields;
+use crate::memory::HostAllocatorExt;
 use crate::validity::Validity;
 
 pub(super) fn _canonicalize(
-    array: &ChunkedArray,
+    array: ArrayView<'_, Chunked>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Canonical> {
     if array.nchunks() == 0 {
         return Ok(Canonical::empty(array.dtype()));
     }
     if array.nchunks() == 1 {
-        return array.chunks()[0].clone().execute::<Canonical>(ctx);
+        return array.chunk(0).clone().execute::<Canonical>(ctx);
     }
 
+    let owned_chunks: Vec<ArrayRef> = array.iter_chunks().cloned().collect();
     Ok(match array.dtype() {
         DType::Struct(struct_dtype, _) => {
             let struct_array = pack_struct_chunks(
-                array.chunks(),
-                Validity::copy_from_array(array.as_ref())?,
+                &owned_chunks,
+                Validity::copy_from_array(array.array())?,
                 struct_dtype,
                 ctx,
             )?;
             Canonical::Struct(struct_array)
         }
         DType::List(elem_dtype, _) => Canonical::List(swizzle_list_chunks(
-            array.chunks(),
-            Validity::copy_from_array(array.as_ref())?,
+            &owned_chunks,
+            Validity::copy_from_array(array.array())?,
             elem_dtype,
             ctx,
         )?),
         _ => {
-            let mut builder = builder_with_capacity(array.dtype(), array.len());
-            array.append_to_builder(builder.as_mut(), ctx)?;
+            let mut builder = builder_with_capacity_in(ctx.allocator(), array.dtype(), array.len());
+            array.array().append_to_builder(builder.as_mut(), ctx)?;
             builder.finish_into_canonical()
         }
     })
 }
 
-/// Packs many [`StructArray`]s to instead be a single [`StructArray`], where the [`Array`] for each
+/// Packs many [`StructArray`]s to instead be a single [`StructArray`], where the [`DynArray`] for each
 /// field is a [`ChunkedArray`].
 ///
 /// The caller guarantees there are at least 2 chunks.
@@ -79,11 +85,7 @@ fn pack_struct_chunks(
     for (field_idx, field_dtype) in struct_dtype.fields().enumerate() {
         let mut field_chunks = Vec::with_capacity(chunks.len());
         for struct_array in &executed_chunks {
-            let field = struct_array
-                .unmasked_fields()
-                .get(field_idx)
-                .vortex_expect("Invalid field index")
-                .to_array();
+            let field = struct_array.unmasked_field(field_idx).clone();
             field_chunks.push(field);
         }
 
@@ -130,8 +132,12 @@ fn swizzle_list_chunks(
     // this much more complicated.
     // We (somewhat arbitrarily) choose `u64` for our offsets and sizes here. These can always be
     // narrowed later by the compressor.
-    let mut offsets = BufferMut::<u64>::with_capacity(len);
-    let mut sizes = BufferMut::<u64>::with_capacity(len);
+    let allocator = ctx.allocator();
+    let mut offsets = allocator.allocate_typed::<u64>(len)?;
+    let mut sizes = allocator.allocate_typed::<u64>(len)?;
+    let offsets_out: &mut [u64] = offsets.as_mut_slice_typed::<u64>()?;
+    let sizes_slice_out: &mut [u64] = sizes.as_mut_slice_typed::<u64>()?;
+    let mut next_list = 0usize;
 
     for chunk in chunks {
         let chunk_array = chunk.clone().execute::<ListViewArray>(ctx)?;
@@ -145,14 +151,14 @@ fn swizzle_list_chunks(
         // Cast offsets and sizes to `u64`.
         let offsets_arr = chunk_array
             .offsets()
-            .to_array()
+            .clone()
             .cast(DType::Primitive(PType::U64, Nullability::NonNullable))
             .vortex_expect("Must be able to fit array offsets in u64")
             .execute::<PrimitiveArray>(ctx)?;
 
         let sizes_arr = chunk_array
             .sizes()
-            .to_array()
+            .clone()
             .cast(DType::Primitive(PType::U64, Nullability::NonNullable))
             .vortex_expect("Must be able to fit array offsets in u64")
             .execute::<PrimitiveArray>(ctx)?;
@@ -161,19 +167,31 @@ fn swizzle_list_chunks(
         let sizes_slice = sizes_arr.as_slice::<u64>();
 
         // Append offsets and sizes, adjusting offsets to point into the combined array.
-        offsets.extend(offsets_slice.iter().map(|o| o + num_elements));
-        sizes.extend(sizes_slice);
+        for (&offset, &size) in offsets_slice.iter().zip(sizes_slice.iter()) {
+            offsets_out[next_list] = offset + num_elements;
+            sizes_slice_out[next_list] = size;
+            next_list += 1;
+        }
 
         num_elements += chunk_array.elements().len() as u64;
     }
+    debug_assert_eq!(next_list, len);
 
     // SAFETY: elements are sliced from valid `ListViewArray`s (from `to_listview()`).
     let chunked_elements =
         unsafe { ChunkedArray::new_unchecked(list_elements_chunks, elem_dtype.clone()) }
             .into_array();
 
-    let offsets = PrimitiveArray::new(offsets.freeze(), Validity::NonNullable).into_array();
-    let sizes = PrimitiveArray::new(sizes.freeze(), Validity::NonNullable).into_array();
+    let offsets = PrimitiveArray::new(
+        Buffer::<u64>::from_byte_buffer(offsets.freeze()),
+        Validity::NonNullable,
+    )
+    .into_array();
+    let sizes = PrimitiveArray::new(
+        Buffer::<u64>::from_byte_buffer(sizes.freeze()),
+        Validity::NonNullable,
+    )
+    .into_array();
 
     // SAFETY:
     // - `offsets` and `sizes` are non-nullable u64 arrays of the same length
@@ -191,9 +209,15 @@ fn swizzle_list_chunks(
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
 
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
+    use crate::Canonical;
+    use crate::ExecutionCtx;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::accessor::ArrayAccessor;
@@ -201,12 +225,33 @@ mod tests {
     use crate::arrays::ListArray;
     use crate::arrays::StructArray;
     use crate::arrays::VarBinViewArray;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::dtype::DType::List;
     use crate::dtype::DType::Primitive;
     use crate::dtype::Nullability::NonNullable;
     use crate::dtype::PType::I32;
+    use crate::memory::DefaultHostAllocator;
+    use crate::memory::HostAllocator;
+    use crate::memory::MemorySessionExt;
+    use crate::memory::WritableHostBuffer;
     use crate::validity::Validity;
 
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl HostAllocator for CountingAllocator {
+        fn allocate(
+            &self,
+            len: usize,
+            alignment: vortex_buffer::Alignment,
+        ) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultHostAllocator.allocate(len, alignment)
+        }
+    }
+
     #[test]
     pub fn pack_nested_structs() {
         let struct_array = StructArray::try_new(
@@ -219,7 +264,7 @@ mod tests {
         let dtype = struct_array.dtype().clone();
         let chunked = ChunkedArray::try_new(
             vec![
-                ChunkedArray::try_new(vec![struct_array.to_array()], dtype.clone())
+                ChunkedArray::try_new(vec![struct_array.clone().into_array()], dtype.clone())
                     .unwrap()
                     .into_array(),
             ],
@@ -228,8 +273,8 @@ mod tests {
         .unwrap()
         .into_array();
         let canonical_struct = chunked.to_struct();
-        let canonical_varbin = canonical_struct.unmasked_fields()[0].to_varbinview();
-        let original_varbin = struct_array.unmasked_fields()[0].to_varbinview();
+        let canonical_varbin = canonical_struct.unmasked_field(0).to_varbinview();
+        let original_varbin = struct_array.unmasked_field(0).to_varbinview();
         let orig_values = original_varbin
             .with_iterator(|it| it.map(|a| a.map(|v| v.to_vec())).collect::<Vec<_>>());
         let canon_values = canonical_varbin
@@ -258,9 +303,47 @@ mod tests {
             List(Arc::new(Primitive(I32, NonNullable)), NonNullable),
         );
 
-        let canon_values = chunked_list.unwrap().to_listview();
+        let canon_values = chunked_list.unwrap().as_array().to_listview();
 
         assert_eq!(l1.scalar_at(0).unwrap(), canon_values.scalar_at(0).unwrap());
         assert_eq!(l2.scalar_at(0).unwrap(), canon_values.scalar_at(1).unwrap());
     }
+
+    #[test]
+    fn list_canonicalize_uses_memory_session_allocator() {
+        let allocations = Arc::new(AtomicUsize::new(0));
+        let session = VortexSession::empty();
+        session
+            .memory_mut()
+            .set_allocator(Arc::new(CountingAllocator {
+                allocations: Arc::clone(&allocations),
+            }));
+        let mut ctx = ExecutionCtx::new(session);
+
+        let l1 = ListArray::try_new(
+            buffer![1, 2, 3, 4].into_array(),
+            buffer![0, 3].into_array(),
+            Validity::NonNullable,
+        )
+        .unwrap();
+        let l2 = ListArray::try_new(
+            buffer![5, 6].into_array(),
+            buffer![0, 2].into_array(),
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let chunked_list = ChunkedArray::try_new(
+            vec![l1.into_array(), l2.into_array()],
+            List(Arc::new(Primitive(I32, NonNullable)), NonNullable),
+        )
+        .unwrap()
+        .into_array();
+
+        drop(chunked_list.execute::<Canonical>(&mut ctx).unwrap());
+        assert!(
+            allocations.load(Ordering::Relaxed) >= 2,
+            "expected offset+size allocations through MemorySession"
+        );
+    }
 }
diff --git a/vortex-array/src/arrays/chunked/vtable/mod.rs b/vortex-array/src/arrays/chunked/vtable/mod.rs
index 093333f232a..29e4b397d35 100644
--- a/vortex-array/src/arrays/chunked/vtable/mod.rs
+++ b/vortex-array/src/arrays/chunked/vtable/mod.rs
@@ -1,21 +1,35 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
+
 use itertools::Itertools;
+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_error::vortex_panic;
 use vortex_session::VortexSession;
 
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
+use crate::ExecutionResult;
 use crate::IntoArray;
+use crate::Precision;
 use crate::ToCanonical;
-use crate::arrays::ChunkedArray;
-use crate::arrays::PrimitiveArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::chunked::ChunkedData;
+use crate::arrays::chunked::array::CHUNK_OFFSETS_SLOT;
+use crate::arrays::chunked::array::CHUNKS_OFFSET;
 use crate::arrays::chunked::compute::kernel::PARENT_KERNELS;
 use crate::arrays::chunked::compute::rules::PARENT_RULES;
 use crate::arrays::chunked::vtable::canonical::_canonicalize;
@@ -25,181 +39,232 @@ use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::serde::ArrayChildren;
-use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-
-mod array;
 mod canonical;
 mod operations;
 mod validity;
-mod visitor;
-
-vtable!(Chunked);
+/// A [`Chunked`]-encoded Vortex array.
+pub type ChunkedArray = Array<Chunked>;
 
-#[derive(Debug)]
-pub struct ChunkedVTable;
+#[derive(Clone, Debug)]
+pub struct Chunked;
 
-impl ChunkedVTable {
+impl Chunked {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.chunked");
 }
 
-impl VTable for ChunkedVTable {
-    type Array = ChunkedArray;
+impl ArrayHash for ChunkedData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {
+        // Chunk offsets are cached derived data. Slot 0 already stores the logical offsets array,
+        // and ArrayInner hashing includes every slot before ArrayData.
+    }
+}
+
+impl ArrayEq for ChunkedData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        // Chunk offsets are cached derived data. Slot 0 already stores the logical offsets array,
+        // and ArrayInner equality compares every slot before ArrayData.
+        true
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl VTable for Chunked {
+    type ArrayData = ChunkedData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &ChunkedArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        data: &ChunkedData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            !slots.is_empty(),
+            "ChunkedArray must have at least a chunk offsets slot"
+        );
+        let chunk_offsets = slots[CHUNK_OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("validated chunk offsets slot");
+        vortex_ensure!(
+            chunk_offsets.dtype() == &DType::Primitive(PType::U64, Nullability::NonNullable),
+            "ChunkedArray chunk offsets must be non-nullable u64, found {}",
+            chunk_offsets.dtype()
+        );
+        vortex_ensure!(
+            chunk_offsets.len() == data.chunk_offsets.len(),
+            "ChunkedArray chunk offsets slot length {} does not match cached offsets length {}",
+            chunk_offsets.len(),
+            data.chunk_offsets.len()
+        );
+        vortex_ensure!(
+            data.chunk_offsets.len() == slots.len() - CHUNKS_OFFSET + 1,
+            "ChunkedArray chunk offsets length {} does not match {} chunks",
+            data.chunk_offsets.len(),
+            slots.len() - CHUNKS_OFFSET
+        );
+        vortex_ensure!(
+            data.chunk_offsets
+                .last()
+                .copied()
+                .vortex_expect("chunked arrays always have a leading 0 offset")
+                == len,
+            "ChunkedArray length {} does not match outer length {}",
+            data.chunk_offsets.last().copied().unwrap_or_default(),
+            len
+        );
+        for (idx, (start, end)) in data
+            .chunk_offsets
+            .iter()
+            .copied()
+            .tuple_windows()
+            .enumerate()
+        {
+            let chunk = slots[CHUNKS_OFFSET + idx]
+                .as_ref()
+                .vortex_expect("validated chunk slot");
+            vortex_ensure!(
+                chunk.dtype() == dtype,
+                "ChunkedArray chunk dtype {} does not match outer dtype {}",
+                chunk.dtype(),
+                dtype
+            );
+            vortex_ensure!(
+                chunk.len() == end - start,
+                "ChunkedArray chunk {} len {} does not match offsets span {}",
+                idx,
+                chunk.len(),
+                end - start
+            );
+        }
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ChunkedArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("ChunkedArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
-        _len: usize,
-        _metadata: &Self::Metadata,
+        len: usize,
+        metadata: &[u8],
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ChunkedArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "ChunkedArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         if children.is_empty() {
             vortex_bail!("Chunked array needs at least one child");
         }
 
         let nchunks = children.len() - 1;
-
-        // The first child contains the row offsets of the chunks
-        let chunk_offsets_array = children
-            .get(
-                0,
-                &DType::Primitive(PType::U64, Nullability::NonNullable),
-                // 1 extra offset for the end of the last chunk
-                nchunks + 1,
-            )?
-            .to_primitive();
-
-        let chunk_offsets_buf = chunk_offsets_array.to_buffer::<u64>();
-
-        // The remaining children contain the actual data of the chunks
-        let chunks = chunk_offsets_buf
+        let chunk_offsets = children.get(
+            CHUNK_OFFSETS_SLOT,
+            &DType::Primitive(PType::U64, Nullability::NonNullable),
+            nchunks + 1,
+        )?;
+        let chunk_offsets_buf = chunk_offsets.to_primitive().to_buffer::<u64>();
+        let chunk_offsets_usize = chunk_offsets_buf
             .iter()
+            .copied()
+            .map(|offset| {
+                usize::try_from(offset)
+                    .map_err(|_| vortex_err!("chunk offset {offset} exceeds usize range"))
+            })
+            .collect::<VortexResult<Vec<_>>>()?;
+        let mut slots = Vec::with_capacity(children.len());
+        slots.push(Some(chunk_offsets));
+        for (idx, (start, end)) in chunk_offsets_usize
+            .iter()
+            .copied()
             .tuple_windows()
             .enumerate()
-            .map(|(idx, (start, end))| {
-                let chunk_len = usize::try_from(end - start)
-                    .map_err(|_| vortex_err!("chunk_len {} exceeds usize range", end - start))?;
-                children.get(idx + 1, dtype, chunk_len)
-            })
-            .try_collect()?;
-
-        let chunk_offsets = PrimitiveArray::new(chunk_offsets_buf.clone(), Validity::NonNullable);
-
-        let total_len = chunk_offsets_buf
-            .last()
-            .ok_or_else(|| vortex_err!("chunk_offsets must not be empty"))?;
-        let len = usize::try_from(*total_len)
-            .map_err(|_| vortex_err!("total length {} exceeds usize range", total_len))?;
+        {
+            let chunk_len = end - start;
+            slots.push(Some(children.get(idx + CHUNKS_OFFSET, dtype, chunk_len)?));
+        }
 
-        // Construct directly using the struct fields to avoid recomputing chunk_offsets
-        Ok(ChunkedArray {
-            dtype: dtype.clone(),
+        Ok(ArrayParts::new(
+            self.clone(),
+            dtype.clone(),
             len,
-            chunk_offsets,
-            chunks,
-            stats_set: Default::default(),
-        })
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        // Children: chunk_offsets, then chunks...
-        vortex_ensure!(
-            !children.is_empty(),
-            "Chunked array needs at least one child"
-        );
-
-        let nchunks = children.len() - 1;
-        let chunk_offsets_array = children[0].to_primitive();
-        let chunk_offsets_buf = chunk_offsets_array.to_buffer::<u64>();
-
-        vortex_ensure!(
-            chunk_offsets_buf.len() == nchunks + 1,
-            "Expected {} chunk offsets, found {}",
-            nchunks + 1,
-            chunk_offsets_buf.len()
-        );
-
-        let chunks = children.into_iter().skip(1).collect();
-        array.chunk_offsets = PrimitiveArray::new(chunk_offsets_buf.clone(), Validity::NonNullable);
-        array.chunks = chunks;
-
-        let total_len = chunk_offsets_buf
-            .last()
-            .ok_or_else(|| vortex_err!("chunk_offsets must not be empty"))?;
-        array.len = usize::try_from(*total_len)
-            .map_err(|_| vortex_err!("total length {} exceeds usize range", total_len))?;
-
-        Ok(())
+            ChunkedData {
+                chunk_offsets: chunk_offsets_usize,
+            },
+        )
+        .with_slots(slots))
     }
 
     fn append_to_builder(
-        array: &ChunkedArray,
+        array: ArrayView<'_, Self>,
         builder: &mut dyn ArrayBuilder,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
-        for chunk in array.chunks() {
+        for chunk in array.iter_chunks() {
             chunk.append_to_builder(builder, ctx)?;
         }
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(_canonicalize(array, ctx)?.into_array())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        match idx {
+            CHUNK_OFFSETS_SLOT => "chunk_offsets".to_string(),
+            n => format!("chunks[{}]", n - CHUNKS_OFFSET),
+        }
     }
 
-    fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
-        Ok(match array.chunks.len() {
-            0 => Some(Canonical::empty(array.dtype()).into_array()),
-            1 => Some(array.chunks[0].clone()),
-            _ => None,
-        })
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(_canonicalize(array.as_view(), ctx)?))
     }
 
-    fn reduce_parent(
-        array: &Self::Array,
+    fn execute_parent(
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        PARENT_RULES.evaluate(array, parent, child_idx)
+        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute_parent(
-        array: &Self::Array,
+    fn reduce(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>> {
+        Ok(match array.nchunks() {
+            0 => Some(Canonical::empty(array.dtype()).into_array()),
+            1 => Some(array.chunk(0).clone()),
+            _ => None,
+        })
+    }
+
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
-        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
+        PARENT_RULES.evaluate(array, parent, child_idx)
     }
 }
diff --git a/vortex-array/src/arrays/chunked/vtable/operations.rs b/vortex-array/src/arrays/chunked/vtable/operations.rs
index e2bfd9d7e78..7c7095a05c7 100644
--- a/vortex-array/src/arrays/chunked/vtable/operations.rs
+++ b/vortex-array/src/arrays/chunked/vtable/operations.rs
@@ -3,14 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Chunked;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<ChunkedVTable> for ChunkedVTable {
-    fn scalar_at(array: &ChunkedArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Chunked> for Chunked {
+    fn scalar_at(
+        array: ArrayView<'_, Chunked>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let (chunk_index, chunk_offset) = array.find_chunk_idx(index)?;
         array.chunk(chunk_index).scalar_at(chunk_offset)
     }
diff --git a/vortex-array/src/arrays/chunked/vtable/validity.rs b/vortex-array/src/arrays/chunked/vtable/validity.rs
index f3d12224838..5f5c11c7832 100644
--- a/vortex-array/src/arrays/chunked/vtable/validity.rs
+++ b/vortex-array/src/arrays/chunked/vtable/validity.rs
@@ -4,17 +4,18 @@
 use itertools::Itertools;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::validity::Validity;
-use crate::vtable::ValidityVTable;
 
-impl ValidityVTable<ChunkedVTable> for ChunkedVTable {
-    fn validity(array: &ChunkedArray) -> VortexResult<Validity> {
+impl ValidityVTable<Chunked> for Chunked {
+    fn validity(array: ArrayView<'_, Chunked>) -> VortexResult<Validity> {
         let validities: Vec<Validity> =
             array.chunks().iter().map(|c| c.validity()).try_collect()?;
 
@@ -42,7 +43,7 @@ impl ValidityVTable<ChunkedVTable> for ChunkedVTable {
                 ChunkedArray::new_unchecked(
                     validities
                         .into_iter()
-                        .zip(array.chunks())
+                        .zip(array.iter_chunks())
                         .map(|(v, chunk)| v.to_array(chunk.len()))
                         .collect(),
                     DType::Bool(Nullability::NonNullable),
diff --git a/vortex-array/src/arrays/chunked/vtable/visitor.rs b/vortex-array/src/arrays/chunked/vtable/visitor.rs
deleted file mode 100644
index 785b7ae7083..00000000000
--- a/vortex-array/src/arrays/chunked/vtable/visitor.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayChildVisitorUnnamed;
-use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
-use crate::vtable::VisitorVTable;
-
-impl VisitorVTable<ChunkedVTable> for ChunkedVTable {
-    fn visit_buffers(_array: &ChunkedArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &ChunkedArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ChunkedArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("chunk_offsets", &array.chunk_offsets.to_array());
-
-        for (idx, chunk) in array.chunks().iter().enumerate() {
-            visitor.visit_child(format!("chunks[{idx}]").as_str(), chunk);
-        }
-    }
-
-    fn visit_children_unnamed(array: &ChunkedArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
-        visitor.visit_child(&array.chunk_offsets.to_array());
-
-        for chunk in array.chunks().iter() {
-            visitor.visit_child(chunk);
-        }
-    }
-
-    fn nchildren(array: &ChunkedArray) -> usize {
-        1 + array.chunks().len()
-    }
-
-    fn nth_child(array: &ChunkedArray, idx: usize) -> Option<crate::ArrayRef> {
-        match idx {
-            0 => Some(array.chunk_offsets.to_array()),
-            n => array.chunks().get(n - 1).cloned(),
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/constant/array.rs b/vortex-array/src/arrays/constant/array.rs
index e8bcb7d88c6..c6b47cd0a17 100644
--- a/vortex-array/src/arrays/constant/array.rs
+++ b/vortex-array/src/arrays/constant/array.rs
@@ -1,27 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::arrays::Constant;
 use crate::scalar::Scalar;
-use crate::stats::ArrayStats;
 
 #[derive(Clone, Debug)]
-pub struct ConstantArray {
+pub struct ConstantData {
     pub(super) scalar: Scalar,
-    pub(super) len: usize,
-    pub(super) stats_set: ArrayStats,
 }
 
-impl ConstantArray {
-    pub fn new<S>(scalar: S, len: usize) -> Self
+impl Display for ConstantData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "scalar: {}", self.scalar)
+    }
+}
+
+impl ConstantData {
+    pub fn new<S>(scalar: S) -> Self
     where
         S: Into<Scalar>,
     {
         let scalar = scalar.into();
-        Self {
-            scalar,
-            len,
-            stats_set: Default::default(),
-        }
+        Self { scalar }
     }
 
     /// Returns the [`Scalar`] value of this constant array.
@@ -33,3 +38,15 @@ impl ConstantArray {
         self.scalar
     }
 }
+
+impl Array<Constant> {
+    pub fn new<S>(scalar: S, len: usize) -> Self
+    where
+        S: Into<Scalar>,
+    {
+        let scalar = scalar.into();
+        let dtype = scalar.dtype().clone();
+        let data = ConstantData::new(scalar);
+        unsafe { Array::from_parts_unchecked(ArrayParts::new(Constant, dtype, len, data)) }
+    }
+}
diff --git a/vortex-array/src/arrays/constant/compute/between.rs b/vortex-array/src/arrays/constant/compute/between.rs
new file mode 100644
index 00000000000..00794569d72
--- /dev/null
+++ b/vortex-array/src/arrays/constant/compute/between.rs
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
+use crate::arrays::ConstantArray;
+use crate::scalar::Scalar;
+use crate::scalar_fn::fns::between::BetweenOptions;
+use crate::scalar_fn::fns::between::BetweenReduce;
+
+impl BetweenReduce for Constant {
+    fn between(
+        array: ArrayView<'_, Constant>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
+        options: &BetweenOptions,
+    ) -> VortexResult<Option<ArrayRef>> {
+        // Can reduce if everything is constant
+        if let Some(((constant, lower), upper)) = Some(array.scalar().clone())
+            .zip(lower.as_constant())
+            .zip(upper.as_constant())
+        {
+            let BetweenOptions {
+                lower_strict,
+                upper_strict,
+            } = options;
+
+            let lower_result = if lower_strict.is_strict() {
+                lower < constant
+            } else {
+                lower <= constant
+            };
+
+            let upper_result = if upper_strict.is_strict() {
+                constant < upper
+            } else {
+                constant <= upper
+            };
+
+            let result = lower_result && upper_result;
+
+            let scalar = Scalar::bool(
+                result,
+                lower.dtype().nullability() | upper.dtype().nullability(),
+            );
+            return Ok(Some(ConstantArray::new(scalar, array.len()).into_array()));
+        }
+
+        Ok(None)
+    }
+}
diff --git a/vortex-array/src/arrays/constant/compute/cast.rs b/vortex-array/src/arrays/constant/compute/cast.rs
index 7a21966cedd..68c6dbeb758 100644
--- a/vortex-array/src/arrays/constant/compute/cast.rs
+++ b/vortex-array/src/arrays/constant/compute/cast.rs
@@ -5,13 +5,14 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
 
-impl CastReduce for ConstantVTable {
-    fn cast(array: &ConstantArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for Constant {
+    fn cast(array: ArrayView<'_, Constant>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         match array.scalar().cast(dtype) {
             Ok(scalar) => Ok(Some(ConstantArray::new(scalar, array.len()).into_array())),
             Err(_e) => Ok(None),
@@ -36,6 +37,6 @@ mod tests {
     #[case(ConstantArray::new(Scalar::null_native::<i32>(), 4).into_array())]
     #[case(ConstantArray::new(Scalar::from(255u8), 1).into_array())]
     fn test_cast_constant_conformance(#[case] array: crate::ArrayRef) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 }
diff --git a/vortex-array/src/arrays/constant/compute/fill_null.rs b/vortex-array/src/arrays/constant/compute/fill_null.rs
index 5353a481cd2..22fe70c246d 100644
--- a/vortex-array/src/arrays/constant/compute/fill_null.rs
+++ b/vortex-array/src/arrays/constant/compute/fill_null.rs
@@ -4,14 +4,17 @@
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNullReduce;
 use crate::scalar_fn::fns::fill_null::fill_null_constant;
 
-impl FillNullReduce for ConstantVTable {
-    fn fill_null(array: &ConstantArray, fill_value: &Scalar) -> VortexResult<Option<ArrayRef>> {
+impl FillNullReduce for Constant {
+    fn fill_null(
+        array: ArrayView<'_, Constant>,
+        fill_value: &Scalar,
+    ) -> VortexResult<Option<ArrayRef>> {
         fill_null_constant(array, fill_value).map(Some)
     }
 }
@@ -22,6 +25,9 @@ mod test {
     use crate::arrays::ConstantArray;
     use crate::arrow::IntoArrowArray as _;
     use crate::builtins::ArrayBuiltins;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
     use crate::scalar::Scalar;
 
     #[test]
@@ -70,7 +76,10 @@ mod test {
     fn test_non_nullable_with_nullable() {
         let actual = ConstantArray::new(Scalar::from(1), 3)
             .into_array()
-            .fill_null(Scalar::from(Some(1)))
+            .fill_null(Scalar::new(
+                DType::Primitive(PType::I32, Nullability::Nullable),
+                Some(1.into()),
+            ))
             .unwrap();
         let expected = ConstantArray::new(Scalar::from(1), 3).into_array();
 
diff --git a/vortex-array/src/arrays/constant/compute/filter.rs b/vortex-array/src/arrays/constant/compute/filter.rs
index 3e397aebed9..e078d2a585c 100644
--- a/vortex-array/src/arrays/constant/compute/filter.rs
+++ b/vortex-array/src/arrays/constant/compute/filter.rs
@@ -6,12 +6,13 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrays::filter::FilterReduce;
 
-impl FilterReduce for ConstantVTable {
-    fn filter(array: &ConstantArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for Constant {
+    fn filter(array: ArrayView<'_, Constant>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             ConstantArray::new(array.scalar().clone(), mask.true_count()).into_array(),
         ))
diff --git a/vortex-array/src/arrays/constant/compute/min_max.rs b/vortex-array/src/arrays/constant/compute/min_max.rs
deleted file mode 100644
index 744fb61216e..00000000000
--- a/vortex-array/src/arrays/constant/compute/min_max.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for ConstantVTable {
-    fn min_max(&self, array: &ConstantArray) -> VortexResult<Option<MinMaxResult>> {
-        let scalar = array.scalar();
-        if scalar.is_null() || scalar.as_primitive_opt().is_some_and(|p| p.is_nan()) {
-            return Ok(None);
-        }
-        let non_nullable_dtype = scalar.dtype().as_nonnullable();
-        Ok(Some(MinMaxResult {
-            min: scalar.cast(&non_nullable_dtype)?,
-            max: scalar.cast(&non_nullable_dtype)?,
-        }))
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(ConstantVTable).lift());
-
-#[cfg(test)]
-mod test {
-    use crate::arrays::ConstantArray;
-    use crate::compute::min_max;
-    use crate::dtype::Nullability;
-    use crate::dtype::half::f16;
-    use crate::scalar::Scalar;
-
-    #[test]
-    fn test_min_max_nan() {
-        let scalar = Scalar::primitive(f16::NAN, Nullability::NonNullable);
-        let array = ConstantArray::new(scalar, 2).to_array();
-        let result = min_max(&array).unwrap();
-        assert_eq!(result, None);
-    }
-}
diff --git a/vortex-array/src/arrays/constant/compute/mod.rs b/vortex-array/src/arrays/constant/compute/mod.rs
index 9bc531bc3cc..eec35ac0cbf 100644
--- a/vortex-array/src/arrays/constant/compute/mod.rs
+++ b/vortex-array/src/arrays/constant/compute/mod.rs
@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+mod between;
 mod cast;
 mod fill_null;
 mod filter;
-mod min_max;
 mod not;
 pub(crate) mod rules;
 mod slice;
-mod sum;
 mod take;
 
 #[cfg(test)]
@@ -60,6 +59,6 @@ mod test {
     #[case::constant_single(ConstantArray::new(Scalar::from(99u64), 1))]
     #[case::constant_large(ConstantArray::new(Scalar::from("hello"), 1000))]
     fn test_constant_consistency(#[case] array: ConstantArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/constant/compute/not.rs b/vortex-array/src/arrays/constant/compute/not.rs
index 61eec1dcbb3..1eb912d0a91 100644
--- a/vortex-array/src/arrays/constant/compute/not.rs
+++ b/vortex-array/src/arrays/constant/compute/not.rs
@@ -5,13 +5,14 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::not::NotReduce;
 
-impl NotReduce for ConstantVTable {
-    fn invert(array: &ConstantArray) -> VortexResult<Option<ArrayRef>> {
+impl NotReduce for Constant {
+    fn invert(array: ArrayView<'_, Constant>) -> VortexResult<Option<ArrayRef>> {
         let value = match array.scalar().as_bool().value() {
             Some(b) => Scalar::bool(!b, array.dtype().nullability()),
             None => Scalar::null(array.dtype().clone()),
diff --git a/vortex-array/src/arrays/constant/compute/rules.rs b/vortex-array/src/arrays/constant/compute/rules.rs
index bd280857238..f97e6c596c7 100644
--- a/vortex-array/src/arrays/constant/compute/rules.rs
+++ b/vortex-array/src/arrays/constant/compute/rules.rs
@@ -5,39 +5,41 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterReduceAdaptor;
-use crate::arrays::FilterVTable;
-use crate::arrays::SliceReduceAdaptor;
-use crate::arrays::TakeReduceAdaptor;
+use crate::arrays::Filter;
+use crate::arrays::dict::TakeReduceAdaptor;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
+use crate::scalar_fn::fns::between::BetweenReduceAdaptor;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullReduceAdaptor;
 use crate::scalar_fn::fns::not::NotReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<ConstantVTable> = ParentRuleSet::new(&[
+pub(crate) const PARENT_RULES: ParentRuleSet<Constant> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&BetweenReduceAdaptor(Constant)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Constant)),
     ParentRuleSet::lift(&ConstantFilterRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(ConstantVTable)),
-    ParentRuleSet::lift(&NotReduceAdaptor(ConstantVTable)),
-    ParentRuleSet::lift(&FillNullReduceAdaptor(ConstantVTable)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(ConstantVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ConstantVTable)),
-    ParentRuleSet::lift(&TakeReduceAdaptor(ConstantVTable)),
+    ParentRuleSet::lift(&FillNullReduceAdaptor(Constant)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(Constant)),
+    ParentRuleSet::lift(&NotReduceAdaptor(Constant)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Constant)),
+    ParentRuleSet::lift(&TakeReduceAdaptor(Constant)),
 ]);
 
 #[derive(Debug)]
 struct ConstantFilterRule;
 
-impl ArrayParentReduceRule<ConstantVTable> for ConstantFilterRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<Constant> for ConstantFilterRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &ConstantArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, Constant>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
diff --git a/vortex-array/src/arrays/constant/compute/slice.rs b/vortex-array/src/arrays/constant/compute/slice.rs
index e39e9604c75..c5f25672076 100644
--- a/vortex-array/src/arrays/constant/compute/slice.rs
+++ b/vortex-array/src/arrays/constant/compute/slice.rs
@@ -7,12 +7,13 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for ConstantVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Constant {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             ConstantArray::new(array.scalar.clone(), range.len()).into_array(),
         ))
diff --git a/vortex-array/src/arrays/constant/compute/sum.rs b/vortex-array/src/arrays/constant/compute/sum.rs
deleted file mode 100644
index b4c7eea247f..00000000000
--- a/vortex-array/src/arrays/constant/compute/sum.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use num_traits::AsPrimitive;
-use num_traits::CheckedAdd;
-use num_traits::CheckedMul;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::dtype::DType;
-use crate::dtype::DecimalDType;
-use crate::dtype::NativePType;
-use crate::dtype::Nullability;
-use crate::dtype::i256;
-use crate::expr::stats::Stat;
-use crate::match_each_native_ptype;
-use crate::register_kernel;
-use crate::scalar::DecimalScalar;
-use crate::scalar::DecimalValue;
-use crate::scalar::PrimitiveScalar;
-use crate::scalar::Scalar;
-use crate::scalar::ScalarValue;
-
-impl SumKernel for ConstantVTable {
-    fn sum(&self, array: &ConstantArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        // Compute the expected dtype of the sum.
-        let sum_dtype = Stat::Sum
-            .dtype(array.dtype())
-            .ok_or_else(|| vortex_err!("Sum not supported for dtype {}", array.dtype()))?;
-
-        let sum_value = sum_scalar(array.scalar(), array.len(), accumulator)?;
-        Scalar::try_new(sum_dtype, sum_value)
-    }
-}
-
-fn sum_scalar(
-    scalar: &Scalar,
-    len: usize,
-    accumulator: &Scalar,
-) -> VortexResult<Option<ScalarValue>> {
-    match scalar.dtype() {
-        DType::Bool(_) => {
-            let count = match scalar.as_bool().value() {
-                None => unreachable!("Handled before reaching this point"),
-                Some(false) => 0u64,
-                Some(true) => len as u64,
-            };
-            let accumulator = accumulator
-                .as_primitive()
-                .as_::<u64>()
-                .vortex_expect("cannot be null");
-            Ok(accumulator
-                .checked_add(count)
-                .map(|v| ScalarValue::Primitive(v.into())))
-        }
-        DType::Primitive(ptype, _) => {
-            #[expect(dead_code, reason = "TODO(connor): good question")]
-            let result = match_each_native_ptype!(
-                ptype,
-                unsigned: |T| { sum_integral::<u64>(scalar.as_primitive(), len, accumulator)?.map(|v| ScalarValue::Primitive(v.into())) },
-                signed: |T| { sum_integral::<i64>(scalar.as_primitive(), len, accumulator)?.map(|v| ScalarValue::Primitive(v.into())) },
-                floating: |T| { sum_float(scalar.as_primitive(), len, accumulator)?.map(|v| ScalarValue::Primitive(v.into())) }
-            );
-            Ok(result)
-        }
-        DType::Decimal(decimal_dtype, _) => {
-            sum_decimal(scalar.as_decimal(), len, *decimal_dtype, accumulator)
-        }
-        DType::Extension(_) => {
-            sum_scalar(&scalar.as_extension().to_storage_scalar(), len, accumulator)
-        }
-        dtype => vortex_bail!("Unsupported dtype for sum: {}", dtype),
-    }
-}
-
-fn sum_decimal(
-    decimal_scalar: DecimalScalar,
-    array_len: usize,
-    decimal_dtype: DecimalDType,
-    accumulator: &Scalar,
-) -> VortexResult<Option<ScalarValue>> {
-    let result_dtype = Stat::Sum
-        .dtype(&DType::Decimal(decimal_dtype, Nullability::Nullable))
-        .vortex_expect("decimal supports sum");
-    let result_decimal_type = result_dtype
-        .as_decimal_opt()
-        .vortex_expect("must be decimal");
-
-    let Some(value) = decimal_scalar.decimal_value() else {
-        // Null value: return null
-        return Ok(None);
-    };
-
-    // Convert array_len to DecimalValue for multiplication.
-    let len_value = DecimalValue::I256(i256::from_i128(array_len as i128));
-
-    let Some(array_sum) = value
-        .checked_mul(&len_value)
-        .filter(|d| d.fits_in_precision(*result_decimal_type))
-    else {
-        return Ok(None);
-    };
-
-    // Add accumulator to array_sum.
-    let initial_decimal = accumulator.as_decimal();
-    let initial_dec_value = initial_decimal
-        .decimal_value()
-        .unwrap_or(DecimalValue::I256(i256::ZERO));
-
-    let total = array_sum
-        .checked_add(&initial_dec_value)
-        .and_then(|result| {
-            result
-                .fits_in_precision(*result_decimal_type)
-                .then_some(result)
-        });
-    match total {
-        Some(result_value) => Ok(Some(ScalarValue::from(result_value))),
-        None => Ok(None), // Overflow
-    }
-}
-
-fn sum_integral<T>(
-    primitive_scalar: PrimitiveScalar<'_>,
-    array_len: usize,
-    accumulator: &Scalar,
-) -> VortexResult<Option<T>>
-where
-    T: NativePType + CheckedMul + CheckedAdd,
-{
-    let v = primitive_scalar.as_::<T>();
-    let array_len =
-        T::from(array_len).ok_or_else(|| vortex_err!("array_len must fit the sum type"))?;
-    let Some(array_sum) = v.and_then(|v| v.checked_mul(&array_len)) else {
-        return Ok(None);
-    };
-
-    let initial = accumulator
-        .as_primitive()
-        .as_::<T>()
-        .vortex_expect("cannot be null");
-    Ok(initial.checked_add(&array_sum))
-}
-
-fn sum_float(
-    primitive_scalar: PrimitiveScalar<'_>,
-    array_len: usize,
-    accumulator: &Scalar,
-) -> VortexResult<Option<f64>> {
-    let initial = accumulator
-        .as_primitive()
-        .as_::<f64>()
-        .vortex_expect("cannot be null");
-    let v = primitive_scalar
-        .as_::<f64>()
-        .vortex_expect("cannot be null");
-    let len_f64: f64 = array_len.as_();
-
-    Ok(Some(initial + v * len_f64))
-}
-
-register_kernel!(SumKernelAdapter(ConstantVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use vortex_error::VortexExpect;
-
-    use crate::Array;
-    use crate::IntoArray;
-    use crate::arrays::ConstantArray;
-    use crate::compute::sum;
-    use crate::compute::sum_with_accumulator;
-    use crate::dtype::DType;
-    use crate::dtype::DecimalDType;
-    use crate::dtype::Nullability;
-    use crate::dtype::Nullability::Nullable;
-    use crate::dtype::PType;
-    use crate::dtype::i256;
-    use crate::expr::stats::Stat;
-    use crate::scalar::DecimalValue;
-    use crate::scalar::Scalar;
-
-    #[test]
-    fn test_sum_unsigned() {
-        let array = ConstantArray::new(5u64, 10).into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, 50u64.into());
-    }
-
-    #[test]
-    fn test_sum_signed() {
-        let array = ConstantArray::new(-5i64, 10).into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, (-50i64).into());
-    }
-
-    #[test]
-    fn test_sum_nullable_value() {
-        let array = ConstantArray::new(Scalar::null(DType::Primitive(PType::U32, Nullable)), 10)
-            .into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, Scalar::primitive(0u64, Nullable));
-    }
-
-    #[test]
-    fn test_sum_bool_false() {
-        let array = ConstantArray::new(false, 10).into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, 0u64.into());
-    }
-
-    #[test]
-    fn test_sum_bool_true() {
-        let array = ConstantArray::new(true, 10).into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, 10u64.into());
-    }
-
-    #[test]
-    fn test_sum_bool_null() {
-        let array = ConstantArray::new(Scalar::null(DType::Bool(Nullable)), 10).into_array();
-        let result = sum(&array).unwrap();
-        assert_eq!(result, Scalar::primitive(0u64, Nullable));
-    }
-
-    #[test]
-    fn test_sum_decimal() {
-        let decimal_dtype = DecimalDType::new(10, 2);
-        let array = ConstantArray::new(
-            Scalar::decimal(
-                DecimalValue::I64(100),
-                decimal_dtype,
-                Nullability::NonNullable,
-            ),
-            5,
-        )
-        .into_array();
-
-        let result = sum(&array).unwrap();
-
-        assert_eq!(
-            result.as_decimal().decimal_value(),
-            Some(DecimalValue::I256(i256::from_i128(500)))
-        );
-        assert_eq!(result.dtype(), &Stat::Sum.dtype(array.dtype()).unwrap());
-    }
-
-    #[test]
-    fn test_sum_decimal_null() {
-        let decimal_dtype = DecimalDType::new(10, 2);
-        let array = ConstantArray::new(Scalar::null(DType::Decimal(decimal_dtype, Nullable)), 10)
-            .into_array();
-
-        let result = sum(&array).unwrap();
-        assert_eq!(
-            result,
-            Scalar::decimal(
-                DecimalValue::I256(i256::ZERO),
-                DecimalDType::new(20, 2),
-                Nullable
-            )
-        );
-    }
-
-    #[test]
-    fn test_sum_decimal_large_value() {
-        let decimal_dtype = DecimalDType::new(10, 2);
-        let array = ConstantArray::new(
-            Scalar::decimal(
-                DecimalValue::I64(999_999_999),
-                decimal_dtype,
-                Nullability::NonNullable,
-            ),
-            100,
-        )
-        .into_array();
-
-        let result = sum(&array).unwrap();
-        assert_eq!(
-            result.as_decimal().decimal_value(),
-            Some(DecimalValue::I256(i256::from_i128(99_999_999_900)))
-        );
-    }
-
-    #[test]
-    fn test_sum_float_non_multiply() {
-        let acc = -2048669276050936500000000000f64;
-        let array = ConstantArray::new(6.1811675e16f64, 25);
-        let sum = sum_with_accumulator(array.as_ref(), &Scalar::primitive(acc, Nullable))
-            .vortex_expect("operation should succeed in test");
-        assert_eq!(
-            f64::try_from(&sum).vortex_expect("operation should succeed in test"),
-            -2048669274505644600000000000f64
-        );
-    }
-}
diff --git a/vortex-array/src/arrays/constant/compute/take.rs b/vortex-array/src/arrays/constant/compute/take.rs
index 5b3dd8db387..96aa71fd9ac 100644
--- a/vortex-array/src/arrays/constant/compute/take.rs
+++ b/vortex-array/src/arrays/constant/compute/take.rs
@@ -4,20 +4,20 @@
 use vortex_error::VortexResult;
 use vortex_mask::AllOr;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrays::MaskedArray;
-use crate::arrays::TakeReduce;
-use crate::arrays::TakeReduceAdaptor;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::dict::TakeReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar::Scalar;
 use crate::validity::Validity;
 
-impl TakeReduce for ConstantVTable {
-    fn take(array: &ConstantArray, indices: &dyn Array) -> VortexResult<Option<ArrayRef>> {
+impl TakeReduce for Constant {
+    fn take(array: ArrayView<'_, Constant>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let result = match indices.validity_mask()?.bit_buffer() {
             AllOr::All => {
                 let scalar = Scalar::try_new(
@@ -52,7 +52,7 @@ impl TakeReduce for ConstantVTable {
     }
 }
 
-impl ConstantVTable {
+impl Constant {
     pub const TAKE_RULES: ParentRuleSet<Self> =
         ParentRuleSet::new(&[ParentRuleSet::lift(&TakeReduceAdaptor::<Self>(Self))]);
 }
@@ -63,7 +63,6 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_mask::AllOr;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::ConstantArray;
@@ -76,7 +75,7 @@ mod tests {
 
     #[test]
     fn take_nullable_indices() {
-        let array = ConstantArray::new(42, 10).to_array();
+        let array = ConstantArray::new(42, 10).into_array();
         let taken = array
             .take(
                 PrimitiveArray::new(
@@ -106,7 +105,7 @@ mod tests {
 
     #[test]
     fn take_all_valid_indices() {
-        let array = ConstantArray::new(42, 10).to_array();
+        let array = ConstantArray::new(42, 10).into_array();
         let taken = array
             .take(PrimitiveArray::new(buffer![0, 5, 7], Validity::AllValid).into_array())
             .unwrap();
@@ -128,6 +127,6 @@ mod tests {
     #[case(ConstantArray::new(Scalar::null_native::<i64>(), 5))]
     #[case(ConstantArray::new(true, 1))]
     fn test_take_constant_conformance(#[case] array: ConstantArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/constant/mod.rs b/vortex-array/src/arrays/constant/mod.rs
index bb5bb519401..36df554d4c3 100644
--- a/vortex-array/src/arrays/constant/mod.rs
+++ b/vortex-array/src/arrays/constant/mod.rs
@@ -7,11 +7,11 @@ mod arbitrary;
 pub use arbitrary::ArbitraryConstantArray;
 
 mod array;
-pub use array::ConstantArray;
-pub(crate) use vtable::canonical::constant_canonicalize;
+pub use array::ConstantData;
+pub use vtable::ConstantArray;
 
 pub(crate) mod compute;
 
 mod vtable;
 
-pub use vtable::ConstantVTable;
+pub use vtable::Constant;
diff --git a/vortex-array/src/arrays/constant/vtable/array.rs b/vortex-array/src/arrays/constant/vtable/array.rs
deleted file mode 100644
index 0a9c212abfd..00000000000
--- a/vortex-array/src/arrays/constant/vtable/array.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::dtype::DType;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ConstantVTable> for ConstantVTable {
-    fn len(array: &ConstantArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &ConstantArray) -> &DType {
-        array.scalar.dtype()
-    }
-
-    fn stats(array: &ConstantArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &ConstantArray,
-        state: &mut H,
-        _precision: Precision,
-    ) {
-        array.scalar.hash(state);
-        array.len.hash(state);
-    }
-
-    fn array_eq(array: &ConstantArray, other: &ConstantArray, _precision: Precision) -> bool {
-        array.scalar == other.scalar && array.len == other.len
-    }
-}
diff --git a/vortex-array/src/arrays/constant/vtable/canonical.rs b/vortex-array/src/arrays/constant/vtable/canonical.rs
index 71a1a5cb582..137f48fd8eb 100644
--- a/vortex-array/src/arrays/constant/vtable/canonical.rs
+++ b/vortex-array/src/arrays/constant/vtable/canonical.rs
@@ -11,17 +11,19 @@ use vortex_error::VortexResult;
 
 use crate::Canonical;
 use crate::IntoArray;
-use crate::arrays::BinaryView;
+use crate::array::ArrayView;
 use crate::arrays::BoolArray;
+use crate::arrays::Constant;
+use crate::arrays::ConstantArray;
 use crate::arrays::DecimalArray;
 use crate::arrays::ExtensionArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::NullArray;
+use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::constant::ConstantArray;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::arrays::varbinview::BinaryView;
 use crate::builders::builder_with_capacity;
 use crate::dtype::DType;
 use crate::dtype::DecimalType;
@@ -34,7 +36,7 @@ use crate::scalar::Scalar;
 use crate::validity::Validity;
 
 /// Shared implementation for both `canonicalize` and `execute` methods.
-pub(crate) fn constant_canonicalize(array: &ConstantArray) -> VortexResult<Canonical> {
+pub(crate) fn constant_canonicalize(array: ArrayView<'_, Constant>) -> VortexResult<Canonical> {
     let scalar = array.scalar();
 
     let validity = match array.dtype().nullability() {
@@ -126,7 +128,7 @@ pub(crate) fn constant_canonicalize(array: &ConstantArray) -> VortexResult<Canon
                     .map(|s| ConstantArray::new(s, array.len()).into_array())
                     .collect(),
                 None => {
-                    assert!(validity.all_invalid(array.len())?);
+                    assert!(matches!(validity, Validity::AllInvalid));
                     // The struct is entirely null, so fields just need placeholder values with the
                     // correct dtype. We use `default_value` which returns a zero for non-nullable
                     // dtypes and null for nullable dtypes, preserving each field's nullability.
@@ -164,6 +166,11 @@ pub(crate) fn constant_canonicalize(array: &ConstantArray) -> VortexResult<Canon
             let storage_self = ConstantArray::new(storage_scalar, array.len()).into_array();
             Canonical::Extension(ExtensionArray::new(ext_dtype.clone(), storage_self))
         }
+        DType::Variant(_) => {
+            unimplemented!(
+                "TODO(variant): canonicalization will use the child-array design in a follow-up"
+            )
+        }
     })
 }
 
@@ -312,14 +319,17 @@ mod tests {
 
     use enum_iterator::all;
     use itertools::Itertools;
+    use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::arrays::ConstantArray;
-    use crate::arrays::ListViewRebuildMode;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinArray;
+    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;
     use crate::canonical::ToCanonical;
     use crate::dtype::DType;
@@ -330,12 +340,11 @@ mod tests {
     use crate::expr::stats::StatsProvider;
     use crate::scalar::Scalar;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_canonicalize_null() {
         let const_null = ConstantArray::new(Scalar::null(DType::Null), 42);
-        let actual = const_null.to_null();
+        let actual = const_null.as_array().to_null();
         assert_eq!(actual.len(), 42);
         assert_eq!(actual.scalar_at(33).unwrap(), Scalar::null(DType::Null));
     }
@@ -356,13 +365,13 @@ mod tests {
             .statistics()
             .compute_all(&all::<Stat>().collect_vec())
             .unwrap();
-        let canonical = const_array.to_canonical()?;
-        let canonical_stats = canonical.as_ref().statistics();
+        let canonical = const_array.to_canonical()?.into_array();
+        let canonical_stats = canonical.statistics();
 
-        let stats_ref = stats.as_typed_ref(canonical.as_ref().dtype());
+        let stats_ref = stats.as_typed_ref(canonical.dtype());
 
         for stat in all::<Stat>() {
-            if stat.dtype(canonical.as_ref().dtype()).is_none() {
+            if stat.dtype(canonical.dtype()).is_none() {
                 continue;
             }
             assert_eq!(
@@ -464,7 +473,7 @@ mod tests {
             3,
         );
 
-        let struct_array = array.to_struct();
+        let struct_array = array.as_array().to_struct();
         assert_eq!(struct_array.len(), 3);
         assert_eq!(struct_array.valid_count().unwrap(), 0);
 
@@ -496,7 +505,7 @@ mod tests {
 
         assert_eq!(canonical.len(), 4);
         assert_eq!(canonical.list_size(), 3);
-        assert_eq!(canonical.validity(), &Validity::NonNullable);
+        assert!(matches!(canonical.validity(), Ok(Validity::NonNullable)));
 
         // Check that each list is [10, 20, 30].
         for i in 0..4 {
@@ -523,7 +532,7 @@ mod tests {
 
         assert_eq!(canonical.len(), 3);
         assert_eq!(canonical.list_size(), 2);
-        assert_eq!(canonical.validity(), &Validity::AllValid);
+        assert!(matches!(canonical.validity(), Ok(Validity::AllValid)));
 
         // Check elements.
         let elements = canonical.elements().to_primitive();
@@ -547,7 +556,7 @@ mod tests {
 
         assert_eq!(canonical.len(), 5);
         assert_eq!(canonical.list_size(), 4);
-        assert_eq!(canonical.validity(), &Validity::AllInvalid);
+        assert!(matches!(canonical.validity(), Ok(Validity::AllInvalid)));
 
         // Elements should be defaults (zeros).
         let elements = canonical.elements().to_primitive();
@@ -569,7 +578,7 @@ mod tests {
 
         assert_eq!(canonical.len(), 10);
         assert_eq!(canonical.list_size(), 0);
-        assert_eq!(canonical.validity(), &Validity::NonNullable);
+        assert!(matches!(canonical.validity(), Ok(Validity::NonNullable)));
 
         // Elements array should be empty.
         assert!(canonical.elements().is_empty());
@@ -635,7 +644,7 @@ mod tests {
 
         assert_eq!(canonical.len(), 3);
         assert_eq!(canonical.list_size(), 3);
-        assert_eq!(canonical.validity(), &Validity::NonNullable);
+        assert!(matches!(canonical.validity(), Ok(Validity::NonNullable)));
 
         // Check elements including nulls.
         let elements = canonical.elements().to_primitive();
@@ -647,7 +656,9 @@ mod tests {
         assert_eq!(elements.scalar_at(2).unwrap(), Scalar::from(200i32));
 
         // Check element validity.
-        let element_validity = elements.validity();
+        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());
diff --git a/vortex-array/src/arrays/constant/vtable/mod.rs b/vortex-array/src/arrays/constant/vtable/mod.rs
index 08d4fe9f094..d6f1c6ab2d3 100644
--- a/vortex-array/src/arrays/constant/vtable/mod.rs
+++ b/vortex-array/src/arrays/constant/vtable/mod.rs
@@ -2,81 +2,138 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::hash::Hash;
+use std::hash::Hasher;
 
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
+use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::arrays::ConstantArray;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::constant::ConstantData;
 use crate::arrays::constant::compute::rules::PARENT_RULES;
 use crate::arrays::constant::vtable::canonical::constant_canonicalize;
 use crate::buffer::BufferHandle;
+use crate::builders::ArrayBuilder;
+use crate::builders::BoolBuilder;
+use crate::builders::DecimalBuilder;
+use crate::builders::NullBuilder;
+use crate::builders::PrimitiveBuilder;
+use crate::builders::VarBinViewBuilder;
+use crate::canonical::Canonical;
 use crate::dtype::DType;
+use crate::match_each_decimal_value;
+use crate::match_each_native_ptype;
+use crate::scalar::DecimalValue;
 use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 use crate::serde::ArrayChildren;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-
-mod array;
 pub(crate) mod canonical;
 mod operations;
 mod validity;
-mod visitor;
 
-vtable!(Constant);
+/// A [`Constant`]-encoded Vortex array.
+pub type ConstantArray = Array<Constant>;
 
-#[derive(Debug)]
-pub struct ConstantVTable;
+#[derive(Clone, Debug)]
+pub struct Constant;
 
-impl ConstantVTable {
+impl Constant {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.constant");
 }
 
-impl VTable for ConstantVTable {
-    type Array = ConstantArray;
+impl ArrayHash for ConstantData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.scalar.hash(state);
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl ArrayEq for ConstantData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.scalar == other.scalar
+    }
+}
+
+impl VTable for Constant {
+    type ArrayData = ConstantData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &ConstantArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        data: &ConstantData,
+        dtype: &DType,
+        _len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            data.scalar.dtype() == dtype,
+            "ConstantArray scalar dtype does not match outer dtype"
+        );
+        Ok(())
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(Vec::new()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => BufferHandle::new_host(
+                ScalarValue::to_proto_bytes::<ByteBufferMut>(array.scalar.value()).freeze(),
+            ),
+            _ => vortex_panic!("ConstantArray buffer index {idx} out of bounds"),
+        }
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("scalar".to_string()),
+            _ => None,
+        }
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        vortex_panic!("ConstantArray slot_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        // HACK: Because the scalar is stored in the buffers, we do not need to serialize the
+        // metadata at all.
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        _metadata: &[u8],
+
         buffers: &[BufferHandle],
         _children: &dyn ArrayChildren,
-    ) -> VortexResult<ConstantArray> {
+        session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
         vortex_ensure!(
             buffers.len() == 1,
             "Expected 1 buffer, got {}",
@@ -86,30 +143,271 @@ impl VTable for ConstantVTable {
         let buffer = buffers[0].clone().try_to_host_sync()?;
         let bytes: &[u8] = buffer.as_ref();
 
-        let scalar_value = ScalarValue::from_proto_bytes(bytes, dtype)?;
+        let scalar_value = ScalarValue::from_proto_bytes(bytes, dtype, session)?;
         let scalar = Scalar::try_new(dtype.clone(), scalar_value)?;
 
-        Ok(ConstantArray::new(scalar, len))
-    }
-
-    fn with_children(_array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.is_empty(),
-            "ConstantArray has no children, got {}",
-            children.len()
-        );
-        Ok(())
+        Ok(crate::array::ArrayParts::new(
+            self.clone(),
+            dtype.clone(),
+            len,
+            ConstantData::new(scalar),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(constant_canonicalize(array)?.into_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(constant_canonicalize(
+            array.as_view(),
+        )?))
+    }
+
+    fn append_to_builder(
+        array: ArrayView<'_, Self>,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        let n = array.len();
+        let scalar = array.scalar();
+
+        match array.dtype() {
+            DType::Null => append_value_or_nulls::<NullBuilder>(builder, true, n, |_| {}),
+            DType::Bool(_) => {
+                append_value_or_nulls::<BoolBuilder>(builder, scalar.is_null(), n, |b| {
+                    b.append_values(
+                        scalar
+                            .as_bool()
+                            .value()
+                            .vortex_expect("non-null bool scalar must have a value"),
+                        n,
+                    );
+                })
+            }
+            DType::Primitive(ptype, _) => {
+                match_each_native_ptype!(ptype, |P| {
+                    append_value_or_nulls::<PrimitiveBuilder<P>>(
+                        builder,
+                        scalar.is_null(),
+                        n,
+                        |b| {
+                            let value = P::try_from(scalar)
+                                .vortex_expect("Couldn't unwrap constant scalar to primitive");
+                            b.append_n_values(value, n);
+                        },
+                    );
+                });
+            }
+            DType::Decimal(..) => {
+                append_value_or_nulls::<DecimalBuilder>(builder, scalar.is_null(), n, |b| {
+                    let value = scalar
+                        .as_decimal()
+                        .decimal_value()
+                        .vortex_expect("non-null decimal scalar must have a value");
+                    match_each_decimal_value!(value, |v| { b.append_n_values(v, n) });
+                });
+            }
+            DType::Utf8(_) => {
+                append_value_or_nulls::<VarBinViewBuilder>(builder, scalar.is_null(), n, |b| {
+                    let typed = scalar.as_utf8();
+                    let value = typed
+                        .value()
+                        .vortex_expect("non-null utf8 scalar must have a value");
+                    b.append_n_values(value.as_bytes(), n);
+                });
+            }
+            DType::Binary(_) => {
+                append_value_or_nulls::<VarBinViewBuilder>(builder, scalar.is_null(), n, |b| {
+                    let typed = scalar.as_binary();
+                    let value = typed
+                        .value()
+                        .vortex_expect("non-null binary scalar must have a value");
+                    b.append_n_values(value, n);
+                });
+            }
+            // TODO: add fast paths for DType::Struct, DType::List, DType::FixedSizeList, DType::Extension.
+            _ => {
+                let canonical = array
+                    .array()
+                    .clone()
+                    .execute::<Canonical>(ctx)?
+                    .into_array();
+                builder.extend_from_array(&canonical);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Downcasts `builder` to `B`, then either appends `n` nulls or calls `fill` with the typed
+/// builder depending on `is_null`.
+///
+/// `is_null` must only be `true` when the builder is nullable.
+fn append_value_or_nulls<B: ArrayBuilder + 'static>(
+    builder: &mut dyn ArrayBuilder,
+    is_null: bool,
+    n: usize,
+    fill: impl FnOnce(&mut B),
+) {
+    let b = builder
+        .as_any_mut()
+        .downcast_mut::<B>()
+        .vortex_expect("builder dtype must match array dtype");
+    if is_null {
+        // SAFETY: is_null=true only when the scalar (and thus the builder) is nullable.
+        unsafe { b.append_nulls_unchecked(n) };
+    } else {
+        fill(b);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_session::VortexSession;
+
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::constant::vtable::canonical::constant_canonicalize;
+    use crate::assert_arrays_eq;
+    use crate::builders::builder_with_capacity;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::dtype::StructFields;
+    use crate::scalar::Scalar;
+
+    fn ctx() -> ExecutionCtx {
+        ExecutionCtx::new(VortexSession::empty())
+    }
+
+    /// Appends `array` into a fresh builder and asserts the result matches `constant_canonicalize`.
+    fn assert_append_matches_canonical(array: ConstantArray) -> vortex_error::VortexResult<()> {
+        let expected = constant_canonicalize(array.as_view())?.into_array();
+        let mut builder = builder_with_capacity(array.dtype(), array.len());
+        array
+            .into_array()
+            .append_to_builder(builder.as_mut(), &mut ctx())?;
+        let result = builder.finish();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_null_constant_append() -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(Scalar::null(DType::Null), 5))
+    }
+
+    #[rstest]
+    #[case::bool_true(true, 5)]
+    #[case::bool_false(false, 3)]
+    fn test_bool_constant_append(
+        #[case] value: bool,
+        #[case] n: usize,
+    ) -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::bool(value, Nullability::NonNullable),
+            n,
+        ))
+    }
+
+    #[test]
+    fn test_bool_null_constant_append() -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::null(DType::Bool(Nullability::Nullable)),
+            4,
+        ))
+    }
+
+    #[rstest]
+    #[case::i32(Scalar::primitive(42i32, Nullability::NonNullable), 5)]
+    #[case::u8(Scalar::primitive(7u8, Nullability::NonNullable), 3)]
+    #[case::f64(Scalar::primitive(1.5f64, Nullability::NonNullable), 4)]
+    #[case::i32_null(Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)), 3)]
+    fn test_primitive_constant_append(
+        #[case] scalar: Scalar,
+        #[case] n: usize,
+    ) -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(scalar, n))
+    }
+
+    #[rstest]
+    #[case::utf8_inline("hi", 5)] // ≤12 bytes: inlined in BinaryView
+    #[case::utf8_noninline("hello world!!", 5)] // >12 bytes: requires buffer block
+    #[case::utf8_empty("", 3)]
+    #[case::utf8_n_zero("hello world!!", 0)] // n=0 with non-inline: must not write orphaned bytes
+    fn test_utf8_constant_append(
+        #[case] value: &str,
+        #[case] n: usize,
+    ) -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::utf8(value, Nullability::NonNullable),
+            n,
+        ))
+    }
+
+    #[test]
+    fn test_utf8_null_constant_append() -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::null(DType::Utf8(Nullability::Nullable)),
+            4,
+        ))
+    }
+
+    #[rstest]
+    #[case::binary_inline(vec![1u8, 2, 3], 5)] // ≤12 bytes: inlined
+    #[case::binary_noninline(vec![0u8; 13], 5)] // >12 bytes: buffer block
+    fn test_binary_constant_append(
+        #[case] value: Vec<u8>,
+        #[case] n: usize,
+    ) -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::binary(value, Nullability::NonNullable),
+            n,
+        ))
+    }
+
+    #[test]
+    fn test_binary_null_constant_append() -> vortex_error::VortexResult<()> {
+        assert_append_matches_canonical(ConstantArray::new(
+            Scalar::null(DType::Binary(Nullability::Nullable)),
+            4,
+        ))
+    }
+
+    #[test]
+    fn test_struct_constant_append() -> vortex_error::VortexResult<()> {
+        let fields = StructFields::new(
+            ["x", "y"].into(),
+            vec![
+                DType::Primitive(PType::I32, Nullability::NonNullable),
+                DType::Utf8(Nullability::NonNullable),
+            ],
+        );
+        let scalar = Scalar::struct_(
+            DType::Struct(fields, Nullability::NonNullable),
+            [
+                Scalar::primitive(42i32, Nullability::NonNullable),
+                Scalar::utf8("hi", Nullability::NonNullable),
+            ],
+        );
+        assert_append_matches_canonical(ConstantArray::new(scalar, 3))
+    }
+
+    #[test]
+    fn test_null_struct_constant_append() -> vortex_error::VortexResult<()> {
+        let fields = StructFields::new(
+            ["x"].into(),
+            vec![DType::Primitive(PType::I32, Nullability::Nullable)],
+        );
+        let dtype = DType::Struct(fields, Nullability::Nullable);
+        assert_append_matches_canonical(ConstantArray::new(Scalar::null(dtype), 4))
     }
 }
diff --git a/vortex-array/src/arrays/constant/vtable/operations.rs b/vortex-array/src/arrays/constant/vtable/operations.rs
index f223ba63888..fdd2dd67345 100644
--- a/vortex-array/src/arrays/constant/vtable/operations.rs
+++ b/vortex-array/src/arrays/constant/vtable/operations.rs
@@ -3,13 +3,18 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Constant;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<ConstantVTable> for ConstantVTable {
-    fn scalar_at(array: &ConstantArray, _index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Constant> for Constant {
+    fn scalar_at(
+        array: ArrayView<'_, Constant>,
+        _index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(array.scalar.clone())
     }
 }
diff --git a/vortex-array/src/arrays/constant/vtable/validity.rs b/vortex-array/src/arrays/constant/vtable/validity.rs
index fbe1afbd749..bff15b1d95e 100644
--- a/vortex-array/src/arrays/constant/vtable/validity.rs
+++ b/vortex-array/src/arrays/constant/vtable/validity.rs
@@ -3,13 +3,13 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::Constant;
 use crate::validity::Validity;
-use crate::vtable::ValidityVTable;
 
-impl ValidityVTable<ConstantVTable> for ConstantVTable {
-    fn validity(array: &ConstantArray) -> VortexResult<Validity> {
+impl ValidityVTable<Constant> for Constant {
+    fn validity(array: ArrayView<'_, Constant>) -> VortexResult<Validity> {
         debug_assert!(array.dtype().is_nullable());
         Ok(if array.scalar().is_null() {
             Validity::AllInvalid
diff --git a/vortex-array/src/arrays/constant/vtable/visitor.rs b/vortex-array/src/arrays/constant/vtable/visitor.rs
deleted file mode 100644
index 41dcda607ff..00000000000
--- a/vortex-array/src/arrays/constant/vtable/visitor.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_buffer::ByteBufferMut;
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::buffer::BufferHandle;
-use crate::scalar::ScalarValue;
-use crate::vtable::VisitorVTable;
-
-impl VisitorVTable<ConstantVTable> for ConstantVTable {
-    fn visit_buffers(array: &ConstantArray, visitor: &mut dyn ArrayBufferVisitor) {
-        let buffer = ScalarValue::to_proto_bytes::<ByteBufferMut>(array.scalar.value()).freeze();
-        visitor.visit_buffer_handle("scalar", &BufferHandle::new_host(buffer));
-    }
-
-    fn nbuffers(_array: &ConstantArray) -> usize {
-        1
-    }
-
-    fn visit_children(_array: &ConstantArray, _visitor: &mut dyn ArrayChildVisitor) {}
-
-    fn nchildren(_array: &ConstantArray) -> usize {
-        0
-    }
-
-    fn nth_child(_array: &ConstantArray, _idx: usize) -> Option<ArrayRef> {
-        None
-    }
-}
diff --git a/vortex-array/src/arrays/datetime/mod.rs b/vortex-array/src/arrays/datetime/mod.rs
index 606cc9a9c79..25913deb8b2 100644
--- a/vortex-array/src/arrays/datetime/mod.rs
+++ b/vortex-array/src/arrays/datetime/mod.rs
@@ -10,11 +10,11 @@ use vortex_error::VortexError;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::dtype::DType;
 use crate::dtype::extension::ExtDTypeRef;
 use crate::extension::datetime::AnyTemporal;
@@ -31,23 +31,26 @@ use crate::extension::datetime::Timestamp;
 ///
 /// ## Arrow compatibility
 ///
-/// TemporalArray can be created from Arrow arrays containing the following datatypes:
+/// TemporalData can be created from Arrow arrays containing the following datatypes:
 /// * `Time32`
 /// * `Time64`
 /// * `Timestamp`
 /// * `Date32`
 /// * `Date64`
 ///
-/// Anything that can be constructed and held in a `TemporalArray` can also be zero-copy converted
+/// Anything that can be constructed and held in a `TemporalData` can also be zero-copy converted
 /// back to the relevant Arrow datatype.
 #[derive(Clone, Debug)]
-pub struct TemporalArray {
+pub struct TemporalData {
     /// The underlying Vortex extension array holding all the numeric values.
     ext: ExtensionArray,
 }
 
-impl TemporalArray {
-    /// Create a new `TemporalArray` holding either i32 day offsets, or i64 millisecond offsets
+/// Type alias for backward compatibility.
+pub type TemporalArray = TemporalData;
+
+impl TemporalData {
+    /// Create a new `TemporalData` holding either i32 day offsets, or i64 millisecond offsets
     /// that are evenly divisible by the number of 86,400,000.
     ///
     /// This is equivalent to the data described by either of the `Date32` or `Date64` data types
@@ -69,7 +72,7 @@ impl TemporalArray {
         }
     }
 
-    /// Create a new `TemporalArray` holding one of the following values:
+    /// Create a new `TemporalData` holding one of the following values:
     ///
     /// * `i32` values representing seconds since midnight
     /// * `i32` values representing milliseconds since midnight
@@ -97,7 +100,7 @@ impl TemporalArray {
         }
     }
 
-    /// Create a new `TemporalArray` holding Arrow spec compliant Timestamp data, with an
+    /// Create a new `TemporalData` holding Arrow spec compliant Timestamp data, with an
     /// optional timezone.
     ///
     /// # Panics
@@ -119,13 +122,13 @@ impl TemporalArray {
     }
 }
 
-impl TemporalArray {
+impl TemporalData {
     /// Access the underlying temporal values in the underlying ExtensionArray storage.
     ///
     /// These values are to be interpreted based on the time unit and optional time-zone stored
     /// in the TemporalMetadata.
     pub fn temporal_values(&self) -> &ArrayRef {
-        self.ext.storage()
+        self.ext.storage_array()
     }
 
     /// Retrieve the temporal metadata.
@@ -147,28 +150,22 @@ impl TemporalArray {
     }
 }
 
-impl AsRef<dyn Array> for TemporalArray {
-    fn as_ref(&self) -> &dyn Array {
-        self.ext.as_ref()
-    }
-}
-
-impl From<TemporalArray> for ArrayRef {
-    fn from(value: TemporalArray) -> Self {
+impl From<TemporalData> for ArrayRef {
+    fn from(value: TemporalData) -> Self {
         value.ext.into_array()
     }
 }
 
-impl IntoArray for TemporalArray {
+impl IntoArray for TemporalData {
     fn into_array(self) -> ArrayRef {
         self.into()
     }
 }
 
-impl TryFrom<ArrayRef> for TemporalArray {
+impl TryFrom<ArrayRef> for TemporalData {
     type Error = VortexError;
 
-    /// Try to specialize a generic Vortex array as a TemporalArray.
+    /// Try to specialize a generic Vortex array as a TemporalData.
     ///
     /// # Errors
     ///
@@ -178,7 +175,7 @@ impl TryFrom<ArrayRef> for TemporalArray {
     /// `TemporalMetadata` variants, an error is returned.
     fn try_from(value: ArrayRef) -> Result<Self, Self::Error> {
         let ext = value
-            .as_opt::<ExtensionVTable>()
+            .as_opt::<Extension>()
             .ok_or_else(|| vortex_err!("array must be an ExtensionArray"))?;
         if !ext.ext_dtype().is::<AnyTemporal>() {
             vortex_bail!(
@@ -186,24 +183,26 @@ impl TryFrom<ArrayRef> for TemporalArray {
                 ext.ext_dtype()
             );
         }
-        Ok(Self { ext: ext.clone() })
+        Ok(Self {
+            ext: ext.into_owned(),
+        })
     }
 }
 
 // Conversions to/from ExtensionArray
-impl From<&TemporalArray> for ExtensionArray {
-    fn from(value: &TemporalArray) -> Self {
+impl From<&TemporalData> for ExtensionArray {
+    fn from(value: &TemporalData) -> Self {
         value.ext.clone()
     }
 }
 
-impl From<TemporalArray> for ExtensionArray {
-    fn from(value: TemporalArray) -> Self {
+impl From<TemporalData> for ExtensionArray {
+    fn from(value: TemporalData) -> Self {
         value.ext
     }
 }
 
-impl TryFrom<ExtensionArray> for TemporalArray {
+impl TryFrom<ExtensionArray> for TemporalData {
     type Error = VortexError;
 
     fn try_from(ext: ExtensionArray) -> Result<Self, Self::Error> {
diff --git a/vortex-array/src/arrays/datetime/test.rs b/vortex-array/src/arrays/datetime/test.rs
index 69d7d4c7793..3d270ec7053 100644
--- a/vortex-array/src/arrays/datetime/test.rs
+++ b/vortex-array/src/arrays/datetime/test.rs
@@ -3,13 +3,14 @@
 
 use rstest::rstest;
 use vortex_buffer::buffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::IntoArray;
+use crate::Precision;
 use crate::ToCanonical;
-use crate::array::Array;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::TemporalArray;
+use crate::arrays::datetime::TemporalData;
 use crate::assert_arrays_eq;
 use crate::expr::gt;
 use crate::expr::lit;
@@ -18,14 +19,14 @@ use crate::extension::datetime::TemporalMetadata;
 use crate::extension::datetime::TimeUnit;
 use crate::extension::datetime::Timestamp;
 use crate::extension::datetime::TimestampOptions;
+use crate::hash::ArrayEq;
 use crate::scalar::Scalar;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 macro_rules! test_temporal_roundtrip {
     ($prim:ty, $constructor:expr, $unit:expr) => {{
         let array = buffer![100 as $prim].into_array();
-        let temporal: TemporalArray = $constructor(array, $unit);
+        let temporal: TemporalData = $constructor(array, $unit);
 
         assert_arrays_eq!(
             temporal.temporal_values(),
@@ -58,25 +59,25 @@ macro_rules! test_fail_case {
 test_success_case!(
     test_roundtrip_time32_second,
     i32,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Seconds
 );
 test_success_case!(
     test_roundtrip_time32_millisecond,
     i32,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Milliseconds
 );
 test_fail_case!(
     test_fail_time32_micro,
     i32,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Microseconds
 );
 test_fail_case!(
     test_fail_time32_nano,
     i32,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Nanoseconds
 );
 
@@ -84,31 +85,31 @@ test_fail_case!(
 test_success_case!(
     test_roundtrip_time64_us,
     i64,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Microseconds
 );
 test_success_case!(
     test_roundtrip_time64_ns,
     i64,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Nanoseconds
 );
 test_fail_case!(
     test_fail_time64_ms,
     i64,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Milliseconds
 );
 test_fail_case!(
     test_fail_time64_s,
     i64,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Seconds
 );
 test_fail_case!(
     test_fail_time64_i32,
     i32,
-    TemporalArray::new_time,
+    TemporalData::new_time,
     TimeUnit::Nanoseconds
 );
 
@@ -116,13 +117,13 @@ test_fail_case!(
 test_success_case!(
     test_roundtrip_date32,
     i32,
-    TemporalArray::new_date,
+    TemporalData::new_date,
     TimeUnit::Days
 );
 test_fail_case!(
     test_fail_date32,
     i64,
-    TemporalArray::new_date,
+    TemporalData::new_date,
     TimeUnit::Days
 );
 
@@ -130,13 +131,13 @@ test_fail_case!(
 test_success_case!(
     test_roundtrip_date64,
     i64,
-    TemporalArray::new_date,
+    TemporalData::new_date,
     TimeUnit::Milliseconds
 );
 test_fail_case!(
     test_fail_date64,
     i32,
-    TemporalArray::new_date,
+    TemporalData::new_date,
     TimeUnit::Milliseconds
 );
 
@@ -153,8 +154,7 @@ fn test_timestamp() {
         TimeUnit::Nanoseconds,
     ] {
         for tz in [Some("UTC".into()), None] {
-            let temporal_array =
-                TemporalArray::new_timestamp(ts_array.to_array(), unit, tz.clone());
+            let temporal_array = TemporalData::new_timestamp(ts_array.clone(), unit, tz.clone());
 
             assert_arrays_eq!(
                 temporal_array.temporal_values(),
@@ -174,7 +174,7 @@ fn test_timestamp_fails_i32() {
     let ts = buffer![100i32].into_array();
     let ts_array = ts.into_array();
 
-    TemporalArray::new_timestamp(ts_array, TimeUnit::Seconds, None);
+    TemporalData::new_timestamp(ts_array, TimeUnit::Seconds, None);
 }
 
 #[rstest]
@@ -193,10 +193,15 @@ fn test_validity_preservation(#[case] validity: Validity) {
     )
     .into_array();
     let temporal_array =
-        TemporalArray::new_timestamp(milliseconds, TimeUnit::Milliseconds, Some("UTC".into()));
-    assert_eq!(
-        temporal_array.temporal_values().to_primitive().validity(),
-        &validity
+        TemporalData::new_timestamp(milliseconds, TimeUnit::Milliseconds, Some("UTC".into()));
+
+    assert!(
+        temporal_array
+            .temporal_values()
+            .to_primitive()
+            .validity()
+            .vortex_expect("temporal validity should be derivable")
+            .array_eq(&validity, Precision::Ptr)
     );
 }
 
@@ -205,7 +210,7 @@ fn test222() -> VortexResult<()> {
     // Write file with MILLISECONDS timestamps
     let ts_array = PrimitiveArray::from_iter(vec![1704067200000i64, 1704153600000, 1704240000000])
         .into_array();
-    let temporal = TemporalArray::new_timestamp(ts_array, TimeUnit::Milliseconds, None);
+    let temporal = TemporalData::new_timestamp(ts_array, TimeUnit::Milliseconds, None);
 
     // Read with SECONDS filter scalar
     let filter_expr = gt(
@@ -219,7 +224,7 @@ fn test222() -> VortexResult<()> {
         )),
     );
 
-    let _result = temporal.as_ref().apply(&filter_expr);
+    let _result = temporal.into_array().apply(&filter_expr);
 
     // let err = result.is_err().unwrap();
     // println!("Expected error: {}", err);
diff --git a/vortex-array/src/arrays/decimal/array.rs b/vortex-array/src/arrays/decimal/array.rs
index 93d2cb20d72..7bddbb8afb2 100644
--- a/vortex-array/src/arrays/decimal/array.rs
+++ b/vortex-array/src/arrays/decimal/array.rs
@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use itertools::Itertools;
+use vortex_buffer::Alignment;
 use vortex_buffer::BitBufferMut;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
@@ -11,7 +15,17 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 
-use crate::ToCanonical;
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::Decimal;
+use crate::arrays::DecimalArray;
+use crate::arrays::PrimitiveArray;
 use crate::buffer::BufferHandle;
 use crate::dtype::BigCast;
 use crate::dtype::DType;
@@ -19,12 +33,16 @@ use crate::dtype::DecimalDType;
 use crate::dtype::DecimalType;
 use crate::dtype::IntegerPType;
 use crate::dtype::NativeDecimalType;
+use crate::dtype::Nullability;
 use crate::match_each_decimal_value_type;
 use crate::match_each_integer_ptype;
 use crate::patches::Patches;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
+
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
 
 /// A decimal array that stores fixed-precision decimal numbers with configurable scale.
 ///
@@ -84,35 +102,88 @@ use crate::vtable::ValidityHelper;
 /// assert_eq!(array.len(), 3);
 /// ```
 #[derive(Clone, Debug)]
-pub struct DecimalArray {
-    pub(super) dtype: DType,
+pub struct DecimalData {
+    pub(super) decimal_dtype: DecimalDType,
     pub(super) values: BufferHandle,
     pub(super) values_type: DecimalType,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
 }
 
-pub struct DecimalArrayParts {
+impl Display for DecimalData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "decimal_dtype: {}, values_type: {}",
+            self.decimal_dtype, self.values_type
+        )
+    }
+}
+
+pub struct DecimalDataParts {
     pub decimal_dtype: DecimalDType,
     pub values: BufferHandle,
     pub values_type: DecimalType,
     pub validity: Validity,
 }
 
-impl DecimalArray {
+pub trait DecimalArrayExt: TypedArrayRef<Decimal> {
+    fn decimal_dtype(&self) -> DecimalDType {
+        match self.as_ref().dtype() {
+            DType::Decimal(decimal_dtype, _) => *decimal_dtype,
+            _ => unreachable!("DecimalArrayExt requires a decimal dtype"),
+        }
+    }
+
+    fn nullability(&self) -> Nullability {
+        match self.as_ref().dtype() {
+            DType::Decimal(_, nullability) => *nullability,
+            _ => unreachable!("DecimalArrayExt requires a decimal dtype"),
+        }
+    }
+
+    fn validity_child(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[VALIDITY_SLOT].as_ref()
+    }
+
+    fn validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn values_type(&self) -> DecimalType {
+        self.values_type
+    }
+
+    fn precision(&self) -> u8 {
+        self.decimal_dtype().precision()
+    }
+
+    fn scale(&self) -> i8 {
+        self.decimal_dtype().scale()
+    }
+
+    fn buffer_handle(&self) -> &BufferHandle {
+        &self.values
+    }
+
+    fn buffer<T: NativeDecimalType>(&self) -> Buffer<T> {
+        DecimalData::buffer::<T>(self)
+    }
+}
+impl<T: TypedArrayRef<Decimal>> DecimalArrayExt for T {}
+
+impl DecimalData {
+    /// Build the slots vector for this array.
+    pub(super) fn make_slots(validity: &Validity, len: usize) -> Vec<Option<ArrayRef>> {
+        vec![validity_to_child(validity, len)]
+    }
+
     /// Creates a new [`DecimalArray`] using a host-native buffer.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented in
     /// [`DecimalArray::new_unchecked`].
-    pub fn new<T: NativeDecimalType>(
-        buffer: Buffer<T>,
-        decimal_dtype: DecimalDType,
-        validity: Validity,
-    ) -> Self {
-        Self::try_new(buffer, decimal_dtype, validity)
-            .vortex_expect("DecimalArray construction failed")
+    pub fn new<T: NativeDecimalType>(buffer: Buffer<T>, decimal_dtype: DecimalDType) -> Self {
+        Self::try_new(buffer, decimal_dtype).vortex_expect("DecimalArray construction failed")
     }
 
     /// Creates a new [`DecimalArray`] from a [`BufferHandle`] of values that may live in
@@ -126,9 +197,8 @@ impl DecimalArray {
         values: BufferHandle,
         values_type: DecimalType,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> Self {
-        Self::try_new_handle(values, values_type, decimal_dtype, validity)
+        Self::try_new_handle(values, values_type, decimal_dtype)
             .vortex_expect("DecimalArray construction failed")
     }
 
@@ -143,12 +213,11 @@ impl DecimalArray {
     pub fn try_new<T: NativeDecimalType>(
         buffer: Buffer<T>,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> VortexResult<Self> {
         let values = BufferHandle::new_host(buffer.into_byte_buffer());
         let values_type = T::DECIMAL_TYPE;
 
-        Self::try_new_handle(values, values_type, decimal_dtype, validity)
+        Self::try_new_handle(values, values_type, decimal_dtype)
     }
 
     /// Constructs a new `DecimalArray` with validation from a [`BufferHandle`].
@@ -162,12 +231,11 @@ impl DecimalArray {
         values: BufferHandle,
         values_type: DecimalType,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> VortexResult<Self> {
-        Self::validate(&values, values_type, &validity)?;
+        Self::validate(&values, values_type)?;
 
         // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked_handle(values, values_type, decimal_dtype, validity) })
+        Ok(unsafe { Self::new_unchecked_handle(values, values_type, decimal_dtype) })
     }
 
     /// Creates a new [`DecimalArray`] without validation from these components:
@@ -186,7 +254,6 @@ impl DecimalArray {
     pub unsafe fn new_unchecked<T: NativeDecimalType>(
         buffer: Buffer<T>,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> Self {
         // SAFETY: new_unchecked_handle inherits the safety guarantees of new_unchecked
         unsafe {
@@ -194,7 +261,6 @@ impl DecimalArray {
                 BufferHandle::new_host(buffer.into_byte_buffer()),
                 T::DECIMAL_TYPE,
                 decimal_dtype,
-                validity,
             )
         }
     }
@@ -212,41 +278,34 @@ impl DecimalArray {
         values: BufferHandle,
         values_type: DecimalType,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> Self {
-        #[cfg(debug_assertions)]
-        {
-            Self::validate(&values, values_type, &validity)
-                .vortex_expect("[Debug Assertion]: Invalid `DecimalArray` parameters");
-        }
-
         Self {
+            decimal_dtype,
             values,
             values_type,
-            dtype: DType::Decimal(decimal_dtype, validity.nullability()),
-            validity,
-            stats_set: Default::default(),
         }
     }
 
     /// Validates the components that would be used to create a [`DecimalArray`] from a byte buffer.
     ///
     /// This function checks all the invariants required by [`DecimalArray::new_unchecked`].
-    fn validate(
-        buffer: &BufferHandle,
-        values_type: DecimalType,
-        validity: &Validity,
-    ) -> VortexResult<()> {
-        if let Some(validity_len) = validity.maybe_len() {
-            let expected_len = values_type.byte_width() * validity_len;
+    fn validate(buffer: &BufferHandle, values_type: DecimalType) -> VortexResult<()> {
+        let byte_width = values_type.byte_width();
+        vortex_ensure!(
+            buffer.len().is_multiple_of(byte_width),
+            InvalidArgument: "decimal buffer size {} is not divisible by element width {}",
+            buffer.len(),
+            byte_width,
+        );
+        match_each_decimal_value_type!(values_type, |D| {
             vortex_ensure!(
-                buffer.len() == expected_len,
-                InvalidArgument: "expected buffer of size {} bytes, was {} bytes",
-                expected_len,
-                buffer.len(),
+                buffer.is_aligned_to(Alignment::of::<D>()),
+                InvalidArgument: "decimal buffer alignment {:?} is invalid for values type {:?}",
+                buffer.alignment(),
+                D::DECIMAL_TYPE,
             );
-        }
-
+            Ok::<(), vortex_error::VortexError>(())
+        })?;
         Ok(())
     }
 
@@ -263,7 +322,6 @@ impl DecimalArray {
         byte_buffer: ByteBuffer,
         values_type: DecimalType,
         decimal_dtype: DecimalDType,
-        validity: Validity,
     ) -> Self {
         // SAFETY: inherits the same safety contract as `new_unchecked_from_byte_buffer`
         unsafe {
@@ -271,20 +329,18 @@ impl DecimalArray {
                 BufferHandle::new_host(byte_buffer),
                 values_type,
                 decimal_dtype,
-                validity,
             )
         }
     }
 
-    pub fn into_parts(self) -> DecimalArrayParts {
-        let decimal_dtype = self.dtype.into_decimal_opt().vortex_expect("cannot fail");
+    /// Returns the length of this array.
+    pub fn len(&self) -> usize {
+        self.values.len() / self.values_type.byte_width()
+    }
 
-        DecimalArrayParts {
-            decimal_dtype,
-            values: self.values,
-            values_type: self.values_type,
-            validity: self.validity,
-        }
+    /// Returns `true` if this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     /// Returns the underlying [`ByteBuffer`] of the array.
@@ -303,34 +359,93 @@ impl DecimalArray {
         Buffer::<T>::from_byte_buffer(self.values.as_host().clone())
     }
 
-    /// Returns the decimal type information
-    pub fn decimal_dtype(&self) -> DecimalDType {
-        if let DType::Decimal(decimal_dtype, _) = self.dtype {
-            decimal_dtype
-        } else {
-            vortex_panic!("Expected Decimal dtype, got {:?}", self.dtype)
-        }
-    }
-
     /// Return the `DecimalType` used to represent the values in the array.
     pub fn values_type(&self) -> DecimalType {
         self.values_type
     }
 
+    /// Returns the decimal type information.
+    pub fn decimal_dtype(&self) -> DecimalDType {
+        self.decimal_dtype
+    }
+
     pub fn precision(&self) -> u8 {
-        self.decimal_dtype().precision()
+        self.decimal_dtype.precision()
     }
 
     pub fn scale(&self) -> i8 {
-        self.decimal_dtype().scale()
+        self.decimal_dtype.scale()
     }
+}
+
+impl Array<Decimal> {
+    pub fn into_data_parts(self) -> DecimalDataParts {
+        let validity = DecimalArrayExt::validity(&self);
+        let decimal_dtype = DecimalArrayExt::decimal_dtype(&self);
+        let data = self.into_data();
+        DecimalDataParts {
+            decimal_dtype,
+            values: data.values,
+            values_type: data.values_type,
+            validity,
+        }
+    }
+}
 
+impl Array<Decimal> {
+    /// Creates a new [`DecimalArray`] using a host-native buffer.
+    pub fn new<T: NativeDecimalType>(
+        buffer: Buffer<T>,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> Self {
+        Self::try_new(buffer, decimal_dtype, validity)
+            .vortex_expect("DecimalArray construction failed")
+    }
+
+    /// Creates a new [`DecimalArray`] without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`DecimalData::new_unchecked`].
+    pub unsafe fn new_unchecked<T: NativeDecimalType>(
+        buffer: Buffer<T>,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> Self {
+        let dtype = DType::Decimal(decimal_dtype, validity.nullability());
+        let len = buffer.len();
+        let slots = DecimalData::make_slots(&validity, len);
+        let data = unsafe { DecimalData::new_unchecked(buffer, decimal_dtype) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Decimal, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Creates a new [`DecimalArray`] from a host-native buffer with validation.
+    pub fn try_new<T: NativeDecimalType>(
+        buffer: Buffer<T>,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let dtype = DType::Decimal(decimal_dtype, validity.nullability());
+        let len = buffer.len();
+        let slots = DecimalData::make_slots(&validity, len);
+        let data = DecimalData::try_new(buffer, decimal_dtype)?;
+        Array::try_from_parts(ArrayParts::new(Decimal, dtype, len, data).with_slots(slots))
+    }
+
+    /// Creates a new [`DecimalArray`] from an iterator of values.
+    #[expect(
+        clippy::same_name_method,
+        reason = "intentionally named from_iter like Iterator::from_iter"
+    )]
     pub fn from_iter<T: NativeDecimalType, I: IntoIterator<Item = T>>(
         iter: I,
         decimal_dtype: DecimalDType,
     ) -> Self {
-        let iter = iter.into_iter();
-
         Self::new(
             BufferMut::from_iter(iter).freeze(),
             decimal_dtype,
@@ -338,6 +453,7 @@ impl DecimalArray {
         )
     }
 
+    /// Creates a new [`DecimalArray`] from an iterator of optional values.
     pub fn from_option_iter<T: NativeDecimalType, I: IntoIterator<Item = Option<T>>>(
         iter: I,
         decimal_dtype: DecimalDType,
@@ -346,18 +462,19 @@ impl DecimalArray {
         let mut values = BufferMut::with_capacity(iter.size_hint().0);
         let mut validity = BitBufferMut::with_capacity(values.capacity());
 
-        for i in iter {
-            match i {
+        for value in iter {
+            match value {
+                Some(value) => {
+                    values.push(value);
+                    validity.append(true);
+                }
                 None => {
-                    validity.append(false);
                     values.push(T::default());
-                }
-                Some(e) => {
-                    validity.append(true);
-                    values.push(e);
+                    validity.append(false);
                 }
             }
         }
+
         Self::new(
             values.freeze(),
             decimal_dtype,
@@ -365,40 +482,97 @@ impl DecimalArray {
         )
     }
 
-    #[expect(
+    /// Creates a new [`DecimalArray`] from a [`BufferHandle`].
+    pub fn new_handle(
+        values: BufferHandle,
+        values_type: DecimalType,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> Self {
+        Self::try_new_handle(values, values_type, decimal_dtype, validity)
+            .vortex_expect("DecimalArray construction failed")
+    }
+
+    /// Creates a new [`DecimalArray`] from a [`BufferHandle`] with validation.
+    pub fn try_new_handle(
+        values: BufferHandle,
+        values_type: DecimalType,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let dtype = DType::Decimal(decimal_dtype, validity.nullability());
+        let len = values.len() / values_type.byte_width();
+        let slots = DecimalData::make_slots(&validity, len);
+        let data = DecimalData::try_new_handle(values, values_type, decimal_dtype)?;
+        Array::try_from_parts(ArrayParts::new(Decimal, dtype, len, data).with_slots(slots))
+    }
+
+    /// Creates a new [`DecimalArray`] without validation from a [`BufferHandle`].
+    ///
+    /// # Safety
+    ///
+    /// See [`DecimalData::new_unchecked_handle`].
+    pub unsafe fn new_unchecked_handle(
+        values: BufferHandle,
+        values_type: DecimalType,
+        decimal_dtype: DecimalDType,
+        validity: Validity,
+    ) -> Self {
+        let dtype = DType::Decimal(decimal_dtype, validity.nullability());
+        let len = values.len() / values_type.byte_width();
+        let slots = DecimalData::make_slots(&validity, len);
+        let data = unsafe { DecimalData::new_unchecked_handle(values, values_type, decimal_dtype) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Decimal, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    #[allow(
         clippy::cognitive_complexity,
-        reason = "complexity from nested match_each_* macros"
+        reason = "patching depends on both patch and value physical types"
     )]
-    pub fn patch(self, patches: &Patches) -> VortexResult<Self> {
+    pub fn patch(self, patches: &Patches, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
         let offset = patches.offset();
-        let patch_indices = patches.indices().to_primitive();
-        let patch_values = patches.values().to_decimal();
+        let dtype = self.dtype().clone();
+        let len = self.len();
+        let patch_indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
+        let patch_values = patches.values().clone().execute::<DecimalArray>(ctx)?;
 
-        let patched_validity = self.validity().clone().patch(
+        let patch_validity = patch_values.validity()?;
+        let patched_validity = self.validity()?.patch(
             self.len(),
             offset,
-            patch_indices.as_ref(),
-            patch_values.validity(),
+            &patch_indices.clone().into_array(),
+            &patch_validity,
+            ctx,
         )?;
         assert_eq!(self.decimal_dtype(), patch_values.decimal_dtype());
 
-        Ok(match_each_integer_ptype!(patch_indices.ptype(), |I| {
+        let data = self.into_data();
+        let data = match_each_integer_ptype!(patch_indices.ptype(), |I| {
             let patch_indices = patch_indices.as_slice::<I>();
             match_each_decimal_value_type!(patch_values.values_type(), |PatchDVT| {
                 let patch_values = patch_values.buffer::<PatchDVT>();
-                match_each_decimal_value_type!(self.values_type(), |ValuesDVT| {
-                    let buffer = self.buffer::<ValuesDVT>().into_mut();
+                match_each_decimal_value_type!(data.values_type(), |ValuesDVT| {
+                    let buffer = data.buffer::<ValuesDVT>().into_mut();
                     patch_typed(
                         buffer,
-                        self.decimal_dtype(),
+                        data.decimal_dtype(),
                         patch_indices,
                         offset,
                         patch_values,
-                        patched_validity,
                     )
                 })
             })
-        }))
+        });
+        let slots = DecimalData::make_slots(&patched_validity, len);
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Decimal, dtype, len, data).with_slots(slots),
+            )
+        })
     }
 }
 
@@ -408,8 +582,7 @@ fn patch_typed<I, ValuesDVT, PatchDVT>(
     patch_indices: &[I],
     patch_indices_offset: usize,
     patch_values: Buffer<PatchDVT>,
-    patched_validity: Validity,
-) -> DecimalArray
+) -> DecimalData
 where
     I: IntegerPType,
     PatchDVT: NativeDecimalType,
@@ -429,5 +602,5 @@ where
         );
     }
 
-    DecimalArray::new(buffer.freeze(), decimal_dtype, patched_validity)
+    DecimalData::new(buffer.freeze(), decimal_dtype)
 }
diff --git a/vortex-array/src/arrays/decimal/compute/between.rs b/vortex-array/src/arrays/decimal/compute/between.rs
index 55f9cd798c8..3594e5a268c 100644
--- a/vortex-array/src/arrays/decimal/compute/between.rs
+++ b/vortex-array/src/arrays/decimal/compute/between.rs
@@ -2,16 +2,16 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_buffer::BitBuffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::BoolArray;
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
+use crate::arrays::Decimal;
 use crate::dtype::NativeDecimalType;
 use crate::dtype::Nullability;
 use crate::match_each_decimal_value_type;
@@ -19,13 +19,12 @@ use crate::scalar::Scalar;
 use crate::scalar_fn::fns::between::BetweenKernel;
 use crate::scalar_fn::fns::between::BetweenOptions;
 use crate::scalar_fn::fns::between::StrictComparison;
-use crate::vtable::ValidityHelper;
 
-impl BetweenKernel for DecimalVTable {
+impl BetweenKernel for Decimal {
     fn between(
-        arr: &DecimalArray,
-        lower: &dyn Array,
-        upper: &dyn Array,
+        arr: ArrayView<'_, Decimal>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
         options: &BetweenOptions,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -38,7 +37,7 @@ impl BetweenKernel for DecimalVTable {
 
         // NOTE: we know that have checked before that the lower and upper bounds are not all null.
         let nullability =
-            arr.dtype.nullability() | lower.dtype().nullability() | upper.dtype().nullability();
+            arr.dtype().nullability() | lower.dtype().nullability() | upper.dtype().nullability();
 
         match_each_decimal_value_type!(arr.values_type(), |D| {
             between_unpack::<D>(arr, lower, upper, nullability, options)
@@ -47,7 +46,7 @@ impl BetweenKernel for DecimalVTable {
 }
 
 fn between_unpack<T: NativeDecimalType>(
-    arr: &DecimalArray,
+    arr: ArrayView<'_, Decimal>,
     lower: Scalar,
     upper: Scalar,
     nullability: Nullability,
@@ -95,7 +94,7 @@ fn between_unpack<T: NativeDecimalType>(
 }
 
 fn between_impl<T: NativeDecimalType>(
-    arr: &DecimalArray,
+    arr: ArrayView<'_, Decimal>,
     lower: T,
     upper: T,
     nullability: Nullability,
@@ -108,7 +107,9 @@ fn between_impl<T: NativeDecimalType>(
             let value = buffer[idx];
             lower_op(lower, value) & upper_op(value, upper)
         }),
-        arr.validity().clone().union_nullability(nullability),
+        arr.validity()
+            .vortex_expect("validity should be derivable")
+            .union_nullability(nullability),
     )
     .into_array()
 }
diff --git a/vortex-array/src/arrays/decimal/compute/cast.rs b/vortex-array/src/arrays/decimal/compute/cast.rs
index 2aa937d6d12..80377102b7d 100644
--- a/vortex-array/src/arrays/decimal/compute/cast.rs
+++ b/vortex-array/src/arrays/decimal/compute/cast.rs
@@ -9,18 +9,19 @@ use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
 use crate::dtype::DType;
 use crate::dtype::DecimalType;
 use crate::dtype::NativeDecimalType;
 use crate::match_each_decimal_value_type;
 use crate::scalar_fn::fns::cast::CastKernel;
-use crate::vtable::ValidityHelper;
 
-impl CastKernel for DecimalVTable {
+impl CastKernel for Decimal {
     fn cast(
-        array: &DecimalArray,
+        array: ArrayView<'_, Decimal>,
         dtype: &DType,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -55,13 +56,12 @@ impl CastKernel for DecimalVTable {
 
         // If the dtype is exactly the same, return self
         if array.dtype() == dtype {
-            return Ok(Some(array.to_array()));
+            return Ok(Some(array.array().clone()));
         }
 
         // Cast the validity to the new nullability
         let new_validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(*to_nullability, array.len())?;
 
         // If the target needs a wider physical type, upcast the values
@@ -69,7 +69,7 @@ impl CastKernel for DecimalVTable {
         let array = if target_values_type > array.values_type() {
             upcast_decimal_values(array, target_values_type)?
         } else {
-            array.clone()
+            array.array().as_::<Decimal>().into_owned()
         };
 
         // SAFETY: new_validity same length as previous validity, just cast
@@ -81,7 +81,7 @@ impl CastKernel for DecimalVTable {
                     *to_decimal_dtype,
                     new_validity,
                 )
-                .to_array(),
+                .into_array(),
             ))
         }
     }
@@ -99,14 +99,14 @@ impl CastKernel for DecimalVTable {
 /// Returns an error if `to_values_type` is narrower than the array's current values type.
 /// Only upcasting (widening) is supported.
 pub fn upcast_decimal_values(
-    array: &DecimalArray,
+    array: ArrayView<'_, Decimal>,
     to_values_type: DecimalType,
 ) -> VortexResult<DecimalArray> {
     let from_values_type = array.values_type();
 
     // If already the target type, just clone
     if from_values_type == to_values_type {
-        return Ok(array.clone());
+        return Ok(array.array().as_::<Decimal>().into_owned());
     }
 
     // Only allow upcasting (widening)
@@ -119,7 +119,7 @@ pub fn upcast_decimal_values(
     }
 
     let decimal_dtype = array.decimal_dtype();
-    let validity = array.validity().clone();
+    let validity = array.validity()?;
 
     // Use match_each_decimal_value_type to dispatch based on source and target types
     match_each_decimal_value_type!(from_values_type, |F| {
@@ -155,7 +155,6 @@ mod tests {
     use crate::dtype::DecimalType;
     use crate::dtype::Nullability;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn cast_decimal_to_nullable() {
@@ -169,13 +168,13 @@ mod tests {
         // Cast to nullable
         let nullable_dtype = DType::Decimal(decimal_dtype, Nullability::Nullable);
         let casted = array
-            .to_array()
+            .into_array()
             .cast(nullable_dtype.clone())
             .unwrap()
             .to_decimal();
 
         assert_eq!(casted.dtype(), &nullable_dtype);
-        assert_eq!(casted.validity(), &Validity::AllValid);
+        assert!(matches!(casted.validity(), Ok(Validity::AllValid)));
         assert_eq!(casted.len(), 3);
     }
 
@@ -189,13 +188,13 @@ mod tests {
         // Cast to non-nullable
         let non_nullable_dtype = DType::Decimal(decimal_dtype, Nullability::NonNullable);
         let casted = array
-            .to_array()
+            .into_array()
             .cast(non_nullable_dtype.clone())
             .unwrap()
             .to_decimal();
 
         assert_eq!(casted.dtype(), &non_nullable_dtype);
-        assert_eq!(casted.validity(), &Validity::NonNullable);
+        assert!(matches!(casted.validity(), Ok(Validity::NonNullable)));
     }
 
     #[test]
@@ -209,7 +208,7 @@ mod tests {
         // Attempt to cast to non-nullable should fail
         let non_nullable_dtype = DType::Decimal(decimal_dtype, Nullability::NonNullable);
         array
-            .to_array()
+            .into_array()
             .cast(non_nullable_dtype)
             .and_then(|a| a.to_canonical().map(|c| c.into_array()))
             .unwrap();
@@ -226,7 +225,7 @@ mod tests {
         // Try to cast to different scale - not supported
         let different_dtype = DType::Decimal(DecimalDType::new(15, 3), Nullability::NonNullable);
         let result = array
-            .to_array()
+            .into_array()
             .cast(different_dtype)
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
 
@@ -250,7 +249,7 @@ mod tests {
         // Try to downcast precision - not supported
         let smaller_dtype = DType::Decimal(DecimalDType::new(10, 2), Nullability::NonNullable);
         let result = array
-            .to_array()
+            .into_array()
             .cast(smaller_dtype)
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
 
@@ -273,7 +272,7 @@ mod tests {
 
         // Cast to higher precision with same scale - should succeed
         let wider_dtype = DType::Decimal(DecimalDType::new(38, 2), Nullability::NonNullable);
-        let casted = array.to_array().cast(wider_dtype).unwrap().to_decimal();
+        let casted = array.into_array().cast(wider_dtype).unwrap().to_decimal();
 
         assert_eq!(casted.precision(), 38);
         assert_eq!(casted.scale(), 2);
@@ -292,7 +291,7 @@ mod tests {
 
         // Try to cast to non-decimal type - should fail since no kernel can handle it
         let result = array
-            .to_array()
+            .into_array()
             .cast(DType::Utf8(Nullability::NonNullable))
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
 
@@ -311,7 +310,7 @@ mod tests {
     #[case(DecimalArray::from_option_iter([Some(100i32), None, Some(300)], DecimalDType::new(10, 2)))]
     #[case(DecimalArray::new(buffer![42i32], DecimalDType::new(5, 1), Validity::NonNullable))]
     fn test_cast_decimal_conformance(#[case] array: DecimalArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
@@ -325,7 +324,8 @@ mod tests {
 
         assert_eq!(array.values_type(), DecimalType::I32);
 
-        let casted = upcast_decimal_values(&array, DecimalType::I64).unwrap();
+        let array = array.as_view();
+        let casted = upcast_decimal_values(array, DecimalType::I64).unwrap();
 
         assert_eq!(casted.values_type(), DecimalType::I64);
         assert_eq!(casted.decimal_dtype(), decimal_dtype);
@@ -345,7 +345,8 @@ mod tests {
             Validity::NonNullable,
         );
 
-        let casted = upcast_decimal_values(&array, DecimalType::I128).unwrap();
+        let array = array.as_view();
+        let casted = upcast_decimal_values(array, DecimalType::I128).unwrap();
 
         assert_eq!(casted.values_type(), DecimalType::I128);
         assert_eq!(casted.decimal_dtype(), decimal_dtype);
@@ -363,7 +364,8 @@ mod tests {
             Validity::NonNullable,
         );
 
-        let casted = upcast_decimal_values(&array, DecimalType::I32).unwrap();
+        let array = array.as_view();
+        let casted = upcast_decimal_values(array, DecimalType::I32).unwrap();
 
         assert_eq!(casted.values_type(), DecimalType::I32);
         assert_eq!(casted.decimal_dtype(), decimal_dtype);
@@ -374,7 +376,8 @@ mod tests {
         let decimal_dtype = DecimalDType::new(10, 2);
         let array = DecimalArray::from_option_iter([Some(100i32), None, Some(300)], decimal_dtype);
 
-        let casted = upcast_decimal_values(&array, DecimalType::I64).unwrap();
+        let array = array.as_view();
+        let casted = upcast_decimal_values(array, DecimalType::I64).unwrap();
 
         assert_eq!(casted.values_type(), DecimalType::I64);
         assert_eq!(casted.len(), 3);
@@ -401,7 +404,8 @@ mod tests {
         );
 
         // Attempt to downcast from i64 to i32 should fail
-        let result = upcast_decimal_values(&array, DecimalType::I32);
+        let array = array.as_view();
+        let result = upcast_decimal_values(array, DecimalType::I32);
         assert!(result.is_err());
         assert!(
             result
diff --git a/vortex-array/src/arrays/decimal/compute/fill_null.rs b/vortex-array/src/arrays/decimal/compute/fill_null.rs
index ef7daa3e7ab..e697a277cca 100644
--- a/vortex-array/src/arrays/decimal/compute/fill_null.rs
+++ b/vortex-array/src/arrays/decimal/compute/fill_null.rs
@@ -12,28 +12,28 @@ use super::cast::upcast_decimal_values;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::DecimalVTable;
-use crate::arrays::decimal::DecimalArray;
+use crate::array::ArrayView;
+use crate::arrays::BoolArray;
+use crate::arrays::Decimal;
+use crate::arrays::DecimalArray;
 use crate::dtype::NativeDecimalType;
 use crate::match_each_decimal_value_type;
 use crate::scalar::DecimalValue;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNullKernel;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl FillNullKernel for DecimalVTable {
+impl FillNullKernel for Decimal {
     fn fill_null(
-        array: &DecimalArray,
+        array: ArrayView<'_, Decimal>,
         fill_value: &Scalar,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let result_validity = Validity::from(fill_value.dtype().nullability());
 
-        Ok(Some(match array.validity() {
+        Ok(Some(match array.validity()? {
             Validity::Array(is_valid) => {
-                let is_invalid = is_valid.to_bool().to_bit_buffer().not();
+                let is_invalid = is_valid.execute::<BoolArray>(ctx)?.into_bit_buffer().not();
                 let decimal_scalar = fill_value.as_decimal();
                 let decimal_value = decimal_scalar
                     .decimal_value()
@@ -53,7 +53,7 @@ impl FillNullKernel for DecimalVTable {
 }
 
 fn fill_invalid_positions<T: NativeDecimalType>(
-    array: &DecimalArray,
+    array: ArrayView<'_, Decimal>,
     is_invalid: &BitBuffer,
     decimal_value: &DecimalValue,
     result_validity: Validity,
@@ -64,14 +64,15 @@ fn fill_invalid_positions<T: NativeDecimalType>(
             let target = max(array.values_type(), decimal_value.decimal_type());
             let upcasted = upcast_decimal_values(array, target)?;
             match_each_decimal_value_type!(upcasted.values_type(), |U| {
-                fill_invalid_positions::<U>(&upcasted, is_invalid, decimal_value, result_validity)
+                let upcasted = upcasted.as_view();
+                fill_invalid_positions::<U>(upcasted, is_invalid, decimal_value, result_validity)
             })
         }
     }
 }
 
 fn fill_buffer<T: NativeDecimalType>(
-    array: &DecimalArray,
+    array: ArrayView<'_, Decimal>,
     is_invalid: &BitBuffer,
     fill_val: T,
     result_validity: Validity,
@@ -87,7 +88,8 @@ fn fill_buffer<T: NativeDecimalType>(
 mod tests {
     use vortex_buffer::buffer;
 
-    use crate::arrays::decimal::DecimalArray;
+    use crate::IntoArray;
+    use crate::arrays::DecimalArray;
     use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::canonical::ToCanonical;
@@ -105,7 +107,7 @@ mod tests {
             decimal_dtype,
         );
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::decimal(
                 DecimalValue::I128(4200i128),
                 DecimalDType::new(19, 2),
@@ -134,7 +136,7 @@ mod tests {
         );
 
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::decimal(
                 DecimalValue::I128(25500i128),
                 DecimalDType::new(19, 2),
@@ -155,7 +157,7 @@ mod tests {
         let arr = DecimalArray::from_option_iter([None, Some(10i8), None], decimal_dtype);
         // i8 max is 127, so 200 doesn't fit — the array should be widened to i16.
         let result = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::decimal(
                 DecimalValue::I128(200i128),
                 DecimalDType::new(3, 0),
@@ -179,7 +181,7 @@ mod tests {
             Validity::NonNullable,
         );
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::decimal(
                 DecimalValue::I128(25500i128),
                 DecimalDType::new(19, 2),
diff --git a/vortex-array/src/arrays/decimal/compute/is_constant.rs b/vortex-array/src/arrays/decimal/compute/is_constant.rs
deleted file mode 100644
index 9008fac4a37..00000000000
--- a/vortex-array/src/arrays/decimal/compute/is_constant.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use vortex_error::VortexResult;
-
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::match_each_decimal_value_type;
-use crate::register_kernel;
-
-impl IsConstantKernel for DecimalVTable {
-    fn is_constant(
-        &self,
-        array: &DecimalArray,
-        _opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        let constant = match_each_decimal_value_type!(array.values_type, |S| {
-            array.buffer::<S>().iter().all_equal()
-        });
-        Ok(Some(constant))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(DecimalVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::arrays::DecimalArray;
-    use crate::compute::is_constant;
-    use crate::dtype::DecimalDType;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_is_constant() {
-        let array = DecimalArray::new(
-            buffer![0i128, 1i128, 2i128],
-            DecimalDType::new(19, 0),
-            Validity::NonNullable,
-        );
-
-        assert!(!is_constant(array.as_ref()).unwrap().unwrap());
-
-        let array = DecimalArray::new(
-            buffer![100i128, 100i128, 100i128],
-            DecimalDType::new(19, 0),
-            Validity::NonNullable,
-        );
-
-        assert!(is_constant(array.as_ref()).unwrap().unwrap());
-    }
-}
diff --git a/vortex-array/src/arrays/decimal/compute/is_sorted.rs b/vortex-array/src/arrays/decimal/compute/is_sorted.rs
deleted file mode 100644
index f2aadd7e1a7..00000000000
--- a/vortex-array/src/arrays/decimal/compute/is_sorted.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::compute::IsSortedIteratorExt;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::dtype::NativeDecimalType;
-use crate::match_each_decimal_value_type;
-use crate::register_kernel;
-
-impl IsSortedKernel for DecimalVTable {
-    fn is_sorted(&self, array: &DecimalArray) -> VortexResult<Option<bool>> {
-        is_decimal_sorted(array, false)
-    }
-
-    fn is_strict_sorted(&self, array: &DecimalArray) -> VortexResult<Option<bool>> {
-        is_decimal_sorted(array, true)
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(DecimalVTable).lift());
-
-fn is_decimal_sorted(array: &DecimalArray, strict: bool) -> VortexResult<Option<bool>> {
-    match_each_decimal_value_type!(array.values_type, |S| {
-        compute_is_sorted::<S>(array, strict).map(Some)
-    })
-}
-
-fn compute_is_sorted<T: NativeDecimalType>(array: &DecimalArray, strict: bool) -> VortexResult<bool>
-where
-    dyn Iterator<Item = T>: IsSortedIteratorExt,
-{
-    match array.validity_mask()? {
-        Mask::AllFalse(_) => Ok(!strict),
-        Mask::AllTrue(_) => {
-            let buf = array.buffer::<T>();
-            let iter = buf.iter().copied();
-
-            Ok(if strict {
-                IsSortedIteratorExt::is_strict_sorted(iter)
-            } else {
-                iter.is_sorted()
-            })
-        }
-        Mask::Values(mask_values) => {
-            let values = array.buffer::<T>();
-            let iter = mask_values
-                .bit_buffer()
-                .iter()
-                .zip_eq(values)
-                .map(|(is_valid, v)| is_valid.then_some(v));
-
-            Ok(if strict {
-                IsSortedIteratorExt::is_strict_sorted(iter)
-            } else {
-                iter.is_sorted()
-            })
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use arrow_array::types::Decimal128Type;
-    use arrow_cast::parse::parse_decimal;
-    use vortex_buffer::buffer;
-
-    use crate::arrays::DecimalArray;
-    use crate::compute::is_sorted;
-    use crate::compute::is_strict_sorted;
-    use crate::dtype::DecimalDType;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_is_sorted() {
-        let dtype = DecimalDType::new(19, 2);
-        let i100 =
-            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
-        let i200 =
-            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();
-
-        let sorted = buffer![i100, i200, i200];
-        let unsorted = buffer![i200, i100, i200];
-
-        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);
-        let unsorted_array = DecimalArray::new(unsorted, dtype, Validity::NonNullable);
-
-        assert!(is_sorted(sorted_array.as_ref()).unwrap().unwrap());
-        assert!(!is_sorted(unsorted_array.as_ref()).unwrap().unwrap());
-    }
-
-    #[test]
-    fn test_is_strict_sorted() {
-        let dtype = DecimalDType::new(19, 2);
-        let i100 =
-            parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale()).unwrap();
-        let i200 =
-            parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale()).unwrap();
-        let i300 =
-            parse_decimal::<Decimal128Type>("300.00", dtype.precision(), dtype.scale()).unwrap();
-
-        let strict_sorted = buffer![i100, i200, i300];
-        let sorted = buffer![i100, i200, i200];
-
-        let dtype = DecimalDType::new(19, 2);
-
-        let strict_sorted_array = DecimalArray::new(strict_sorted, dtype, Validity::NonNullable);
-        let sorted_array = DecimalArray::new(sorted, dtype, Validity::NonNullable);
-
-        assert!(
-            is_strict_sorted(strict_sorted_array.as_ref())
-                .unwrap()
-                .unwrap()
-        );
-        assert!(!is_strict_sorted(sorted_array.as_ref()).unwrap().unwrap());
-    }
-}
diff --git a/vortex-array/src/arrays/decimal/compute/mask.rs b/vortex-array/src/arrays/decimal/compute/mask.rs
index 64f9d27c946..804e6557f5c 100644
--- a/vortex-array/src/arrays/decimal/compute/mask.rs
+++ b/vortex-array/src/arrays/decimal/compute/mask.rs
@@ -5,15 +5,15 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
 use crate::match_each_decimal_value_type;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for DecimalVTable {
-    fn mask(array: &DecimalArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Decimal {
+    fn mask(array: ArrayView<'_, Decimal>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(match_each_decimal_value_type!(
             array.values_type(),
             |D| {
@@ -22,10 +22,7 @@ impl MaskReduce for DecimalVTable {
                     DecimalArray::new_unchecked(
                         array.buffer::<D>(),
                         array.decimal_dtype(),
-                        array
-                            .validity()
-                            .clone()
-                            .and(Validity::Array(mask.clone()))?,
+                        array.validity()?.and(Validity::Array(mask.clone()))?,
                     )
                 }
                 .into_array()
diff --git a/vortex-array/src/arrays/decimal/compute/mod.rs b/vortex-array/src/arrays/decimal/compute/mod.rs
index 8a49ae7852e..09faba913c0 100644
--- a/vortex-array/src/arrays/decimal/compute/mod.rs
+++ b/vortex-array/src/arrays/decimal/compute/mod.rs
@@ -4,12 +4,8 @@
 mod between;
 mod cast;
 mod fill_null;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub mod rules;
-mod sum;
 mod take;
 
 #[cfg(test)]
@@ -17,6 +13,7 @@ mod tests {
     use rstest::rstest;
     use vortex_buffer::buffer;
 
+    use crate::IntoArray;
     use crate::arrays::DecimalArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DecimalDType;
@@ -56,6 +53,6 @@ mod tests {
         Validity::NonNullable,
     ))]
     fn test_decimal_consistency(#[case] array: DecimalArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/decimal/compute/rules.rs b/vortex-array/src/arrays/decimal/compute/rules.rs
index 48fbef5acb3..fae0c3dd866 100644
--- a/vortex-array/src/arrays/decimal/compute/rules.rs
+++ b/vortex-array/src/arrays/decimal/compute/rules.rs
@@ -7,22 +7,21 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
-use crate::arrays::SliceReduce;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Masked;
+use crate::arrays::slice::SliceReduce;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::match_each_decimal_value_type;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
-use crate::vtable::ValidityHelper;
 
-pub(crate) static RULES: ParentRuleSet<DecimalVTable> = ParentRuleSet::new(&[
+pub(crate) static RULES: ParentRuleSet<Decimal> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&DecimalMaskedValidityRule),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DecimalVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DecimalVTable)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Decimal)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Decimal)),
 ]);
 
 /// Rule to push down validity masking from MaskedArray parent into DecimalArray child.
@@ -32,13 +31,13 @@ pub(crate) static RULES: ParentRuleSet<DecimalVTable> = ParentRuleSet::new(&[
 #[derive(Default, Debug)]
 pub struct DecimalMaskedValidityRule;
 
-impl ArrayParentReduceRule<DecimalVTable> for DecimalMaskedValidityRule {
-    type Parent = MaskedVTable;
+impl ArrayParentReduceRule<Decimal> for DecimalMaskedValidityRule {
+    type Parent = Masked;
 
     fn reduce_parent(
         &self,
-        array: &DecimalArray,
-        parent: &MaskedArray,
+        array: ArrayView<'_, Decimal>,
+        parent: ArrayView<'_, Masked>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // Merge the parent's validity mask into the child's validity
@@ -50,7 +49,7 @@ impl ArrayParentReduceRule<DecimalVTable> for DecimalMaskedValidityRule {
                 DecimalArray::new_unchecked(
                     array.buffer::<D>(),
                     array.decimal_dtype(),
-                    array.validity().clone().and(parent.validity().clone())?,
+                    array.validity()?.and(parent.validity()?)?,
                 )
             }
             .into_array()
@@ -60,11 +59,11 @@ impl ArrayParentReduceRule<DecimalVTable> for DecimalMaskedValidityRule {
     }
 }
 
-impl SliceReduce for DecimalVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Decimal {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let result = match_each_decimal_value_type!(array.values_type(), |D| {
             let sliced = array.buffer::<D>().slice(range.clone());
-            let validity = array.validity().clone().slice(range)?;
+            let validity = array.validity()?.slice(range)?;
             // SAFETY: Slicing preserves all DecimalArray invariants
             unsafe { DecimalArray::new_unchecked(sliced, array.decimal_dtype(), validity) }
                 .into_array()
diff --git a/vortex-array/src/arrays/decimal/compute/sum.rs b/vortex-array/src/arrays/decimal/compute/sum.rs
deleted file mode 100644
index 76faef78665..00000000000
--- a/vortex-array/src/arrays/decimal/compute/sum.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use num_traits::AsPrimitive;
-use num_traits::CheckedAdd;
-use vortex_buffer::BitBuffer;
-use vortex_buffer::Buffer;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_mask::Mask;
-
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::dtype::DType;
-use crate::dtype::DecimalDType;
-use crate::dtype::DecimalType;
-use crate::dtype::Nullability::Nullable;
-use crate::expr::stats::Stat;
-use crate::match_each_decimal_value_type;
-use crate::register_kernel;
-use crate::scalar::DecimalValue;
-use crate::scalar::Scalar;
-
-impl SumKernel for DecimalVTable {
-    fn sum(&self, array: &DecimalArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        let return_dtype = Stat::Sum
-            .dtype(array.dtype())
-            .vortex_expect("sum for decimals exists");
-        let return_decimal_dtype = *return_dtype
-            .as_decimal_opt()
-            .vortex_expect("must be decimal");
-
-        // Extract the initial value as a `DecimalValue`.
-        let initial_decimal = accumulator
-            .as_decimal()
-            .decimal_value()
-            .vortex_expect("cannot be null");
-
-        let mask = array.validity_mask()?;
-        let validity = match &mask {
-            Mask::AllTrue(_) => None,
-            Mask::Values(mask_values) => Some(mask_values.bit_buffer()),
-            Mask::AllFalse(_) => {
-                vortex_bail!("invalid state, all-null array should be checked by top-level sum fn")
-            }
-        };
-
-        let values_type = DecimalType::smallest_decimal_value_type(&return_decimal_dtype);
-        match_each_decimal_value_type!(array.values_type(), |I| {
-            match_each_decimal_value_type!(values_type, |O| {
-                let initial_val: O = initial_decimal
-                    .cast()
-                    .vortex_expect("cannot fail to cast initial value");
-
-                Ok(sum_to_scalar(
-                    array.buffer::<I>(),
-                    validity,
-                    initial_val,
-                    return_decimal_dtype,
-                    &return_dtype,
-                ))
-            })
-        })
-    }
-}
-
-/// Compute the checked sum and convert the result to a [`Scalar`].
-///
-/// Returns a null scalar if the sum overflows the underlying integer type or if the result
-/// exceeds the declared decimal precision.
-fn sum_to_scalar<T, O>(
-    values: Buffer<T>,
-    validity: Option<&BitBuffer>,
-    initial: O,
-    return_decimal_dtype: DecimalDType,
-    return_dtype: &DType,
-) -> Scalar
-where
-    T: AsPrimitive<O>,
-    O: Copy + CheckedAdd + Into<DecimalValue> + 'static,
-{
-    let raw_sum = match validity {
-        Some(v) => sum_decimal_with_validity(values, v, initial),
-        None => sum_decimal(values, initial),
-    };
-
-    raw_sum
-        .map(Into::<DecimalValue>::into)
-        // We have to make sure that the decimal value fits the precision of the decimal dtype.
-        .filter(|v| v.fits_in_precision(return_decimal_dtype))
-        .map(|v| Scalar::decimal(v, return_decimal_dtype, Nullable))
-        // If an overflow occurs during summation, or final value does not fit, then return a null.
-        .unwrap_or_else(|| Scalar::null(return_dtype.clone()))
-}
-
-fn sum_decimal<T: AsPrimitive<I>, I: Copy + CheckedAdd + 'static>(
-    values: Buffer<T>,
-    initial: I,
-) -> Option<I> {
-    let mut sum = initial;
-    for v in values.iter() {
-        let v: I = v.as_();
-        sum = CheckedAdd::checked_add(&sum, &v)?;
-    }
-    Some(sum)
-}
-
-fn sum_decimal_with_validity<T: AsPrimitive<I>, I: Copy + CheckedAdd + 'static>(
-    values: Buffer<T>,
-    validity: &BitBuffer,
-    initial: I,
-) -> Option<I> {
-    let mut sum = initial;
-    for (v, valid) in values.iter().zip_eq(validity) {
-        if valid {
-            let v: I = v.as_();
-            sum = CheckedAdd::checked_add(&sum, &v)?;
-        }
-    }
-    Some(sum)
-}
-
-register_kernel!(SumKernelAdapter(DecimalVTable).lift());
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-    use vortex_error::VortexExpect;
-
-    use crate::arrays::DecimalArray;
-    use crate::compute::sum;
-    use crate::dtype::DType;
-    use crate::dtype::DecimalDType;
-    use crate::dtype::Nullability;
-    use crate::dtype::i256;
-    use crate::scalar::DecimalValue;
-    use crate::scalar::Scalar;
-    use crate::scalar::ScalarValue;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_sum_basic() {
-        let decimal = DecimalArray::new(
-            buffer![100i32, 200i32, 300i32],
-            DecimalDType::new(4, 2),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(600i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_with_nulls() {
-        let decimal = DecimalArray::new(
-            buffer![100i32, 200i32, 300i32, 400i32],
-            DecimalDType::new(4, 2),
-            Validity::from_iter([true, false, true, true]),
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(14, 2), Nullability::Nullable),
-            Some(ScalarValue::from(DecimalValue::from(800i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_negative_values() {
-        let decimal = DecimalArray::new(
-            buffer![100i32, -200i32, 300i32, -50i32],
-            DecimalDType::new(4, 2),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(14, 2), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(150i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_near_i32_max() {
-        // Test values close to i32::MAX to ensure proper handling
-        let near_max = i32::MAX - 1000;
-        let decimal = DecimalArray::new(
-            buffer![near_max, 500i32, 400i32],
-            DecimalDType::new(10, 2),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        // Should use i64 for accumulation since precision increases
-        let expected_sum = near_max as i64 + 500 + 400;
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(20, 2), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_large_i64_values() {
-        // Test with large i64 values that require i128 accumulation
-        let large_val = i64::MAX / 4;
-        let decimal = DecimalArray::new(
-            buffer![large_val, large_val, large_val, large_val + 1],
-            DecimalDType::new(19, 0),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected_sum = (large_val as i128) * 4 + 1;
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(29, 0), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_overflow_detection() {
-        use crate::dtype::i256;
-
-        // Create values that will overflow when summed
-        // Use maximum i128 values that will overflow when added
-        let max_val = i128::MAX / 2;
-        let decimal = DecimalArray::new(
-            buffer![max_val, max_val, max_val],
-            DecimalDType::new(38, 0),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        // Should use i256 for accumulation
-        let expected_sum =
-            i256::from_i128(max_val) + i256::from_i128(max_val) + i256::from_i128(max_val);
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(48, 0), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_mixed_signs_near_overflow() {
-        // Test that mixed signs work correctly near overflow boundaries
-        let large_pos = i64::MAX / 2;
-        let large_neg = -(i64::MAX / 2);
-        let decimal = DecimalArray::new(
-            buffer![large_pos, large_neg, large_pos, 1000i64],
-            DecimalDType::new(19, 3),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected_sum = (large_pos as i128) + (large_neg as i128) + (large_pos as i128) + 1000;
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(29, 3), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_preserves_scale() {
-        let decimal = DecimalArray::new(
-            buffer![12345i32, 67890i32, 11111i32],
-            DecimalDType::new(6, 4),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        // Scale should be preserved, precision increased by 10
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(16, 4), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(91346i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_single_value() {
-        let decimal =
-            DecimalArray::new(buffer![42i32], DecimalDType::new(3, 1), Validity::AllValid);
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(13, 1), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(42i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_with_all_nulls_except_one() {
-        let decimal = DecimalArray::new(
-            buffer![100i32, 200i32, 300i32, 400i32],
-            DecimalDType::new(4, 2),
-            Validity::from_iter([false, false, true, false]),
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(14, 2), Nullability::Nullable),
-            Some(ScalarValue::from(DecimalValue::from(300i32))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_i128_to_i256_boundary() {
-        // Test the boundary between i128 and i256 accumulation
-        let large_i128 = i128::MAX / 10;
-        let decimal = DecimalArray::new(
-            buffer![
-                large_i128, large_i128, large_i128, large_i128, large_i128, large_i128, large_i128,
-                large_i128, large_i128
-            ],
-            DecimalDType::new(38, 0),
-            Validity::AllValid,
-        );
-
-        let result = sum(decimal.as_ref()).unwrap();
-
-        // Should use i256 for accumulation since 9 * (i128::MAX / 10) fits in i128 but we increase precision
-        let expected_sum = i256::from_i128(large_i128).wrapping_pow(1) * i256::from_i128(9);
-        let expected = Scalar::try_new(
-            DType::Decimal(DecimalDType::new(48, 0), Nullability::NonNullable),
-            Some(ScalarValue::from(DecimalValue::from(expected_sum))),
-        )
-        .unwrap();
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_sum_precision_overflow_without_i256_overflow() {
-        // Construct values that individually fit in precision 76 but whose sum exceeds it,
-        // while still fitting in `i256`. This ensures we return null for precision overflow
-        // and not just for arithmetic overflow.
-        let ten_to_38 = i256::from_i128(10i128.pow(38));
-        let ten_to_75 = ten_to_38 * i256::from_i128(10i128.pow(37));
-        // 6 * 10^75 is a 76-digit number, which fits in precision 76.
-        let val = ten_to_75 * i256::from_i128(6);
-
-        let decimal_dtype = DecimalDType::new(76, 0);
-        let decimal = DecimalArray::new(buffer![val, val], decimal_dtype, Validity::AllValid);
-
-        // Sum = 12 * 10^75 = 1.2 * 10^76, which exceeds precision 76 but fits in `i256`.
-        let result = sum(decimal.as_ref()).unwrap();
-        assert_eq!(
-            result,
-            Scalar::null(DType::Decimal(decimal_dtype, Nullability::Nullable))
-        );
-    }
-
-    #[test]
-    fn test_i256_overflow() {
-        let decimal_dtype = DecimalDType::new(76, 0);
-        let decimal = DecimalArray::new(
-            buffer![i256::MAX, i256::MAX, i256::MAX],
-            decimal_dtype,
-            Validity::AllValid,
-        );
-
-        assert_eq!(
-            sum(decimal.as_ref()).vortex_expect("operation should succeed in test"),
-            Scalar::null(DType::Decimal(decimal_dtype, Nullability::Nullable))
-        );
-    }
-}
diff --git a/vortex-array/src/arrays/decimal/compute/take.rs b/vortex-array/src/arrays/decimal/compute/take.rs
index 17e15f51d18..444fe313d15 100644
--- a/vortex-array/src/arrays/decimal/compute/take.rs
+++ b/vortex-array/src/arrays/decimal/compute/take.rs
@@ -4,27 +4,27 @@
 use vortex_buffer::Buffer;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ToCanonical;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::dict::TakeExecute;
 use crate::dtype::IntegerPType;
 use crate::dtype::NativeDecimalType;
 use crate::executor::ExecutionCtx;
 use crate::match_each_decimal_value_type;
 use crate::match_each_integer_ptype;
-use crate::vtable::ValidityHelper;
 
-impl TakeExecute for DecimalVTable {
+impl TakeExecute for Decimal {
     fn take(
-        array: &DecimalArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Decimal>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let indices = indices.to_primitive();
-        let validity = array.validity().take(indices.as_ref())?;
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
+        let validity = array.validity()?.take(&indices.clone().into_array())?;
 
         // TODO(joe): if the true count of take indices validity is low, only take array values with
         // valid indices.
@@ -38,11 +38,10 @@ impl TakeExecute for DecimalVTable {
             })
         });
 
-        Ok(Some(decimal.to_array()))
+        Ok(Some(decimal.into_array()))
     }
 }
 
-#[inline]
 fn take_to_buffer<I: IntegerPType, T: NativeDecimalType>(indices: &[I], values: &[T]) -> Buffer<T> {
     indices.iter().map(|idx| values[idx.as_()]).collect()
 }
@@ -71,7 +70,7 @@ mod tests {
         );
 
         let indices = buffer![0, 2, 3].into_array();
-        let taken = array.take(indices.to_array()).unwrap();
+        let taken = array.take(indices).unwrap();
 
         let expected = DecimalArray::from_iter([10i128, 12, 13], ddtype);
         assert_arrays_eq!(expected, taken);
@@ -87,7 +86,7 @@ mod tests {
         );
 
         let indices = PrimitiveArray::from_option_iter([None, Some(2), Some(3)]).into_array();
-        let taken = array.take(indices.to_array()).unwrap();
+        let taken = array.take(indices).unwrap();
 
         let expected = DecimalArray::from_option_iter([None, Some(12i128), Some(13)], ddtype);
         assert_arrays_eq!(expected, taken);
@@ -128,6 +127,6 @@ mod tests {
         )
     })]
     fn test_take_decimal_conformance(#[case] array: DecimalArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/decimal/mod.rs b/vortex-array/src/arrays/decimal/mod.rs
index 8784c4ac21f..489a67a0531 100644
--- a/vortex-array/src/arrays/decimal/mod.rs
+++ b/vortex-array/src/arrays/decimal/mod.rs
@@ -2,14 +2,16 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::DecimalArray;
-pub use array::DecimalArrayParts;
+pub use array::DecimalArrayExt;
+pub use array::DecimalData;
+pub use array::DecimalDataParts;
+pub use vtable::DecimalArray;
 
 pub(crate) mod compute;
 
 mod vtable;
 pub use compute::rules::DecimalMaskedValidityRule;
-pub use vtable::DecimalVTable;
+pub use vtable::Decimal;
 
 mod utils;
 pub use utils::*;
diff --git a/vortex-array/src/arrays/decimal/utils.rs b/vortex-array/src/arrays/decimal/utils.rs
index 40dd7d9cff6..a1eafde0fe3 100644
--- a/vortex-array/src/arrays/decimal/utils.rs
+++ b/vortex-array/src/arrays/decimal/utils.rs
@@ -8,7 +8,6 @@ use vortex_error::VortexExpect;
 use crate::arrays::DecimalArray;
 use crate::dtype::DecimalType;
 use crate::dtype::i256;
-use crate::vtable::ValidityHelper;
 
 macro_rules! try_downcast {
     ($array:expr, from: $src:ty, to: $($dst:ty),*) => {{
@@ -29,7 +28,9 @@ macro_rules! try_downcast {
                                 .map(|v| <$dst as BigCast>::from(v).vortex_expect("decimal conversion failure"))
                                 .collect(),
                             $array.decimal_dtype(),
-                            $array.validity().clone(),
+                            $array
+                                .validity()
+                                .vortex_expect("decimal validity should be derivable"),
                         );
                     }
                 )*
diff --git a/vortex-array/src/arrays/decimal/vtable/array.rs b/vortex-array/src/arrays/decimal/vtable/array.rs
deleted file mode 100644
index 257b2b8c0de..00000000000
--- a/vortex-array/src/arrays/decimal/vtable/array.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::dtype::DType;
-use crate::dtype::DecimalType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<DecimalVTable> for DecimalVTable {
-    fn len(array: &DecimalArray) -> usize {
-        let divisor = match array.values_type {
-            DecimalType::I8 => 1,
-            DecimalType::I16 => 2,
-            DecimalType::I32 => 4,
-            DecimalType::I64 => 8,
-            DecimalType::I128 => 16,
-            DecimalType::I256 => 32,
-        };
-        array.values.len() / divisor
-    }
-
-    fn dtype(array: &DecimalArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &DecimalArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &DecimalArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.values.array_hash(state, precision);
-        std::mem::discriminant(&array.values_type).hash(state);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &DecimalArray, other: &DecimalArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.values.array_eq(&other.values, precision)
-            && array.values_type == other.values_type
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/decimal/vtable/kernel.rs b/vortex-array/src/arrays/decimal/vtable/kernel.rs
index f3004089c06..9ad3803be1d 100644
--- a/vortex-array/src/arrays/decimal/vtable/kernel.rs
+++ b/vortex-array/src/arrays/decimal/vtable/kernel.rs
@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::DecimalVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Decimal;
+use crate::arrays::dict::TakeExecuteAdaptor;
 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;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<DecimalVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&BetweenExecuteAdaptor(DecimalVTable)),
-    ParentKernelSet::lift(&CastExecuteAdaptor(DecimalVTable)),
-    ParentKernelSet::lift(&FillNullExecuteAdaptor(DecimalVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DecimalVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<Decimal> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&BetweenExecuteAdaptor(Decimal)),
+    ParentKernelSet::lift(&CastExecuteAdaptor(Decimal)),
+    ParentKernelSet::lift(&FillNullExecuteAdaptor(Decimal)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Decimal)),
 ]);
diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs
index cbc8bd44171..1894466ed6b 100644
--- a/vortex-array/src/arrays/decimal/vtable/mod.rs
+++ b/vortex-array/src/arrays/decimal/vtable/mod.rs
@@ -1,20 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
+
 use kernel::PARENT_KERNELS;
+use prost::Message;
 use vortex_buffer::Alignment;
-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 crate::ArrayRef;
-use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ProstMetadata;
-use crate::SerializeMetadata;
-use crate::arrays::DecimalArray;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::decimal::DecimalData;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::DecimalType;
@@ -22,20 +26,20 @@ use crate::dtype::NativeDecimalType;
 use crate::match_each_decimal_value_type;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
 
-use crate::arrays::decimal::compute::rules::RULES;
-use crate::vtable::ArrayId;
+use std::hash::Hash;
 
-vtable!(Decimal);
+use crate::Precision;
+use crate::array::ArrayId;
+use crate::arrays::decimal::array::SLOT_NAMES;
+use crate::arrays::decimal::compute::rules::RULES;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
+/// A [`Decimal`]-encoded Vortex array.
+pub type DecimalArray = Array<Decimal>;
 
 // The type of the values can be determined by looking at the type info...right?
 #[derive(prost::Message)]
@@ -44,48 +48,101 @@ pub struct DecimalMetadata {
     pub(super) values_type: i32,
 }
 
-impl VTable for DecimalVTable {
-    type Array = DecimalArray;
+impl ArrayHash for DecimalData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.values.array_hash(state, precision);
+        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
+    }
+}
 
-    type Metadata = ProstMetadata<DecimalMetadata>;
+impl VTable for Decimal {
+    type ArrayData = DecimalData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &DecimalArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DecimalMetadata {
-            values_type: array.values_type() as i32,
-        }))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.values.clone(),
+            _ => vortex_panic!("DecimalArray buffer index {idx} out of bounds"),
+        }
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("values".to_string()),
+            _ => None,
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let metadata = ProstMetadata::<DecimalMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(metadata))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            DecimalMetadata {
+                values_type: array.values_type() as i32,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn validate(
+        &self,
+        data: &DecimalData,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let DType::Decimal(_, nullability) = dtype else {
+            vortex_bail!("Expected decimal dtype, got {dtype:?}");
+        };
+        vortex_ensure!(
+            data.len() == len,
+            InvalidArgument:
+            "DecimalArray length {} does not match outer length {}",
+            data.len(),
+            len
+        );
+        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure!(
+                validity_len == len,
+                InvalidArgument:
+                "DecimalArray validity len {} does not match outer length {}",
+                validity_len,
+                len
+            );
+        }
+
+        Ok(())
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<DecimalArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = DecimalMetadata::decode(metadata)?;
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
@@ -104,43 +161,29 @@ impl VTable for DecimalVTable {
             vortex_bail!("Expected Decimal dtype, got {:?}", dtype)
         };
 
-        match_each_decimal_value_type!(metadata.values_type(), |D| {
+        let slots = DecimalData::make_slots(&validity, len);
+        let data = match_each_decimal_value_type!(metadata.values_type(), |D| {
             // Check and reinterpret-cast the buffer
             vortex_ensure!(
                 values.is_aligned_to(Alignment::of::<D>()),
                 "DecimalArray buffer not aligned for values type {:?}",
                 D::DECIMAL_TYPE
             );
-            DecimalArray::try_new_handle(values, metadata.values_type(), *decimal_dtype, validity)
-        })
+            DecimalData::try_new_handle(values, metadata.values_type(), *decimal_dtype)
+        })?;
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "DecimalArray expects 0 or 1 child (validity), got {}",
-            children.len()
-        );
-
-        if children.is_empty() {
-            array.validity = Validity::from(array.dtype.nullability());
-        } else {
-            array.validity = Validity::Array(
-                children
-                    .into_iter()
-                    .next()
-                    .vortex_expect("children length already validated"),
-            );
-        }
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -148,7 +191,7 @@ impl VTable for DecimalVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -157,10 +200,10 @@ impl VTable for DecimalVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct DecimalVTable;
+#[derive(Clone, Debug)]
+pub struct Decimal;
 
-impl DecimalVTable {
+impl Decimal {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.decimal");
 }
 
@@ -168,15 +211,17 @@ impl DecimalVTable {
 mod tests {
     use vortex_buffer::ByteBufferMut;
     use vortex_buffer::buffer;
+    use vortex_session::registry::ReadContext;
 
     use crate::ArrayContext;
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
+    use crate::arrays::Decimal;
     use crate::arrays::DecimalArray;
-    use crate::arrays::DecimalVTable;
+    use crate::assert_arrays_eq;
     use crate::dtype::DecimalDType;
-    use crate::serde::ArrayParts;
     use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
     use crate::validity::Validity;
 
     #[test]
@@ -191,7 +236,7 @@ mod tests {
         let ctx = ArrayContext::empty();
         let out = array
             .into_array()
-            .serialize(&ctx, &SerializeOptions::default())
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
             .unwrap();
         // Concat into a single buffer
         let mut concat = ByteBufferMut::empty();
@@ -201,8 +246,44 @@ mod tests {
 
         let concat = concat.freeze();
 
-        let parts = ArrayParts::try_from(concat).unwrap();
-        let decoded = parts.decode(&dtype, 5, &ctx, &LEGACY_SESSION).unwrap();
-        assert!(decoded.is::<DecimalVTable>());
+        let parts = SerializedArray::try_from(concat).unwrap();
+        let decoded = parts
+            .decode(&dtype, 5, &ReadContext::new(ctx.to_ids()), &LEGACY_SESSION)
+            .unwrap();
+        assert!(decoded.is::<Decimal>());
+    }
+
+    #[test]
+    fn test_nullable_decimal_serde_roundtrip() {
+        let array = DecimalArray::new(
+            buffer![1234567i32, 0i32, -9999999i32],
+            DecimalDType::new(7, 3),
+            Validity::from_iter([true, false, true]),
+        );
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let ctx = ArrayContext::empty();
+        let out = array
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+        let mut concat = ByteBufferMut::empty();
+        for buf in out {
+            concat.extend_from_slice(buf.as_ref());
+        }
+
+        let parts = SerializedArray::try_from(concat.freeze()).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
+
+        assert_arrays_eq!(decoded, array);
     }
 }
diff --git a/vortex-array/src/arrays/decimal/vtable/operations.rs b/vortex-array/src/arrays/decimal/vtable/operations.rs
index e1eeca36977..cfd14d95d63 100644
--- a/vortex-array/src/arrays/decimal/vtable/operations.rs
+++ b/vortex-array/src/arrays/decimal/vtable/operations.rs
@@ -3,15 +3,20 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Decimal;
 use crate::match_each_decimal_value_type;
 use crate::scalar::DecimalValue;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<DecimalVTable> for DecimalVTable {
-    fn scalar_at(array: &DecimalArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Decimal> for Decimal {
+    fn scalar_at(
+        array: ArrayView<'_, Decimal>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(match_each_decimal_value_type!(array.values_type(), |D| {
             Scalar::decimal(
                 DecimalValue::from(array.buffer::<D>()[index]),
@@ -26,9 +31,9 @@ impl OperationsVTable<DecimalVTable> for DecimalVTable {
 mod tests {
     use vortex_buffer::buffer;
 
-    use crate::Array;
+    use crate::IntoArray;
+    use crate::arrays::Decimal;
     use crate::arrays::DecimalArray;
-    use crate::arrays::DecimalVTable;
     use crate::dtype::DecimalDType;
     use crate::dtype::Nullability;
     use crate::scalar::DecimalValue;
@@ -42,12 +47,12 @@ mod tests {
             DecimalDType::new(3, 2),
             Validity::NonNullable,
         )
-        .to_array();
+        .into_array();
 
         let sliced = array.slice(1..3).unwrap();
         assert_eq!(sliced.len(), 2);
 
-        let decimal = sliced.as_::<DecimalVTable>();
+        let decimal = sliced.as_::<Decimal>();
         assert_eq!(decimal.buffer::<i128>(), buffer![200i128, 300i128]);
     }
 
@@ -58,7 +63,7 @@ mod tests {
             DecimalDType::new(3, 2),
             Validity::from_iter([false, true, false, true]),
         )
-        .to_array();
+        .into_array();
 
         let sliced = array.slice(1..3).unwrap();
         assert_eq!(sliced.len(), 2);
diff --git a/vortex-array/src/arrays/decimal/vtable/validity.rs b/vortex-array/src/arrays/decimal/vtable/validity.rs
index fd66742629c..500fb191fad 100644
--- a/vortex-array/src/arrays/decimal/vtable/validity.rs
+++ b/vortex-array/src/arrays/decimal/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::DecimalArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::decimal::DecimalArrayExt;
+use crate::arrays::decimal::vtable::Decimal;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for DecimalArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<Decimal> for Decimal {
+    fn validity(array: ArrayView<'_, Decimal>) -> VortexResult<Validity> {
+        Ok(DecimalArrayExt::validity(&array))
     }
 }
diff --git a/vortex-array/src/arrays/decimal/vtable/visitor.rs b/vortex-array/src/arrays/decimal/vtable/visitor.rs
deleted file mode 100644
index 0c1e3df430e..00000000000
--- a/vortex-array/src/arrays/decimal/vtable/visitor.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<DecimalVTable> for DecimalVTable {
-    fn visit_buffers(array: &DecimalArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle("values", &array.values);
-    }
-
-    fn nbuffers(_array: &DecimalArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &DecimalArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(array.validity(), array.len())
-    }
-
-    fn nchildren(array: &DecimalArray) -> usize {
-        validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &DecimalArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/dict/array.rs b/vortex-array/src/arrays/dict/array.rs
index d6fa3bfe23d..b7d0cc6c0f4 100644
--- a/vortex-array/src/arrays/dict/array.rs
+++ b/vortex-array/src/arrays/dict/array.rs
@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -10,10 +13,14 @@ use vortex_mask::AllOr;
 
 use crate::ArrayRef;
 use crate::ToCanonical;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array_slots;
+use crate::arrays::Dict;
 use crate::dtype::DType;
 use crate::dtype::PType;
 use crate::match_each_integer_ptype;
-use crate::stats::ArrayStats;
 
 #[derive(Clone, prost::Message)]
 pub struct DictMetadata {
@@ -31,12 +38,16 @@ pub struct DictMetadata {
     pub(super) all_values_referenced: Option<bool>,
 }
 
+#[array_slots(Dict)]
+pub struct DictSlots {
+    /// The codes array mapping each element to a dictionary entry.
+    pub codes: ArrayRef,
+    /// The dictionary values array containing the unique values.
+    pub values: ArrayRef,
+}
+
 #[derive(Debug, Clone)]
-pub struct DictArray {
-    pub(super) codes: ArrayRef,
-    pub(super) values: ArrayRef,
-    pub(super) stats_set: ArrayStats,
-    pub(super) dtype: DType,
+pub struct DictData {
     /// Indicates whether all dictionary values are definitely referenced by at least one code.
     /// `true` = all values are referenced (computed during encoding).
     /// `false` = unknown/might have unreferenced values.
@@ -45,28 +56,21 @@ pub struct DictArray {
     pub(super) all_values_referenced: bool,
 }
 
-pub struct DictArrayParts {
-    pub codes: ArrayRef,
-    pub values: ArrayRef,
-    pub dtype: DType,
+impl Display for DictData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "all_values_referenced: {}", self.all_values_referenced)
+    }
 }
 
-impl DictArray {
+impl DictData {
     /// Build a new `DictArray` without validating the codes or values.
     ///
     /// # Safety
     /// This should be called only when you can guarantee the invariants checked
-    /// by the safe [`DictArray::try_new`] constructor are valid, for example when
+    /// by the safe `DictArray::try_new` constructor are valid, for example when
     /// you are filtering or slicing an existing valid `DictArray`.
-    pub unsafe fn new_unchecked(codes: ArrayRef, values: ArrayRef) -> Self {
-        let dtype = values
-            .dtype()
-            .union_nullability(codes.dtype().nullability());
+    pub unsafe fn new_unchecked() -> Self {
         Self {
-            codes,
-            values,
-            stats_set: Default::default(),
-            dtype,
             all_values_referenced: false,
         }
     }
@@ -82,23 +86,15 @@ impl DictArray {
     /// that all values are referenced.
     pub unsafe fn set_all_values_referenced(mut self, all_values_referenced: bool) -> Self {
         self.all_values_referenced = all_values_referenced;
-
-        #[cfg(debug_assertions)]
-        {
-            use vortex_error::VortexExpect;
-            self.validate_all_values_referenced()
-                .vortex_expect("validation should succeed when all values are referenced")
-        }
-
         self
     }
 
     /// Build a new `DictArray` from its components, `codes` and `values`.
     ///
     /// This constructor will panic if `codes` or `values` do not pass validation for building
-    /// a new `DictArray`. See [`DictArray::try_new`] for a description of the error conditions.
-    pub fn new(codes: ArrayRef, values: ArrayRef) -> Self {
-        Self::try_new(codes, values).vortex_expect("DictArray new")
+    /// a new `DictArray`. See `DictArray::try_new` for a description of the error conditions.
+    pub fn new(codes_dtype: &DType) -> Self {
+        Self::try_new(codes_dtype).vortex_expect("DictArray new")
     }
 
     /// Build a new `DictArray` from its components, `codes` and `values`.
@@ -112,51 +108,23 @@ impl DictArray {
     /// of the `values` array. Otherwise, this constructor returns an error.
     ///
     /// It is an error to provide a nullable `codes` with non-nullable `values`.
-    pub fn try_new(codes: ArrayRef, values: ArrayRef) -> VortexResult<Self> {
-        if !codes.dtype().is_int() {
-            vortex_bail!(MismatchedTypes: "int", codes.dtype());
+    pub(crate) fn try_new(codes_dtype: &DType) -> VortexResult<Self> {
+        if !codes_dtype.is_int() {
+            vortex_bail!(MismatchedTypes: "int", codes_dtype);
         }
 
-        Ok(unsafe { Self::new_unchecked(codes, values) })
-    }
-
-    pub fn into_parts(self) -> DictArrayParts {
-        DictArrayParts {
-            codes: self.codes,
-            values: self.values,
-            dtype: self.dtype,
-        }
-    }
-
-    #[inline]
-    pub fn codes(&self) -> &ArrayRef {
-        &self.codes
-    }
-
-    #[inline]
-    pub fn values(&self) -> &ArrayRef {
-        &self.values
+        Ok(unsafe { Self::new_unchecked() })
     }
+}
 
-    /// Returns `true` if all dictionary values are definitely referenced by at least one code.
-    ///
-    /// When `true`, operations like min/max can safely operate on all values without needing to
-    /// compute which values are actually referenced. When `false`, it is unknown whether all
-    /// values are referenced (conservative default).
+pub trait DictArrayExt: TypedArrayRef<Dict> + DictArraySlotsExt {
     #[inline]
-    pub fn has_all_values_referenced(&self) -> bool {
+    fn has_all_values_referenced(&self) -> bool {
         self.all_values_referenced
     }
 
-    /// Validates that the `all_values_referenced` flag matches reality.
-    ///
-    /// Returns `Ok(())` if the flag is consistent with the actual referenced values,
-    /// or an error describing the mismatch.
-    ///
-    /// This is primarily useful for testing and debugging.
-    pub fn validate_all_values_referenced(&self) -> VortexResult<()> {
-        if self.all_values_referenced {
-            // Skip host-only validation when codes are not host-resident.
+    fn validate_all_values_referenced(&self) -> VortexResult<()> {
+        if self.has_all_values_referenced() {
             if !self.codes().is_host() {
                 return Ok(());
             }
@@ -170,24 +138,16 @@ impl DictArray {
         Ok(())
     }
 
-    /// Compute a mask indicating which values in the dictionary are referenced by at least one code.
-    ///
-    /// When `referenced = true`, returns a `BitBuffer` where set bits (true) correspond to
-    /// referenced values, and unset bits (false) correspond to unreferenced values.
-    ///
-    /// When `referenced = false` (default for unreferenced values), returns the inverse:
-    /// set bits (true) correspond to unreferenced values, and unset bits (false) correspond
-    /// to referenced values.
-    ///
-    /// This is useful for operations like min/max that need to ignore unreferenced values.
-    pub fn compute_referenced_values_mask(&self, referenced: bool) -> VortexResult<BitBuffer> {
+    #[allow(
+        clippy::cognitive_complexity,
+        reason = "branching depends on validity representation and code type"
+    )]
+    fn compute_referenced_values_mask(&self, referenced: bool) -> VortexResult<BitBuffer> {
         let codes_validity = self.codes().validity_mask()?;
         let codes_primitive = self.codes().to_primitive();
         let values_len = self.values().len();
 
-        // Initialize with the starting value: false for referenced, true for unreferenced
         let init_value = !referenced;
-        // Value to set when we find a referenced code: true for referenced, false for unreferenced
         let referenced_value = referenced;
 
         let mut values_vec = vec![init_value; values_len];
@@ -199,13 +159,13 @@ impl DictArray {
                         clippy::cast_sign_loss,
                         reason = "codes are non-negative indices; a negative signed code would wrap to a large usize and panic on the bounds-checked array index"
                     )]
-                    for &code in codes_primitive.as_slice::<P>().iter() {
-                        values_vec[code as usize] = referenced_value;
+                    for &idx in codes_primitive.as_slice::<P>() {
+                        values_vec[idx as usize] = referenced_value;
                     }
                 });
             }
             AllOr::None => {}
-            AllOr::Some(buf) => {
+            AllOr::Some(mask) => {
                 match_each_integer_ptype!(codes_primitive.ptype(), |P| {
                     let codes = codes_primitive.as_slice::<P>();
 
@@ -214,14 +174,79 @@ impl DictArray {
                         clippy::cast_sign_loss,
                         reason = "codes are non-negative indices; a negative signed code would wrap to a large usize and panic on the bounds-checked array index"
                     )]
-                    buf.set_indices().for_each(|idx| {
+                    mask.set_indices().for_each(|idx| {
                         values_vec[codes[idx] as usize] = referenced_value;
-                    })
+                    });
                 });
             }
         }
 
-        Ok(BitBuffer::collect_bool(values_len, |idx| values_vec[idx]))
+        Ok(BitBuffer::from(values_vec))
+    }
+}
+impl<T: TypedArrayRef<Dict>> DictArrayExt for T {}
+
+impl Array<Dict> {
+    /// Build a new `DictArray` from its components, `codes` and `values`.
+    pub fn new(codes: ArrayRef, values: ArrayRef) -> Self {
+        Self::try_new(codes, values).vortex_expect("DictArray new")
+    }
+
+    /// Build a new `DictArray` from its components, `codes` and `values`.
+    pub fn try_new(codes: ArrayRef, values: ArrayRef) -> VortexResult<Self> {
+        let dtype = values
+            .dtype()
+            .union_nullability(codes.dtype().nullability());
+        let len = codes.len();
+        let data = DictData::try_new(codes.dtype())?;
+        Array::try_from_parts(
+            ArrayParts::new(Dict, dtype, len, data).with_slots(vec![Some(codes), Some(values)]),
+        )
+    }
+
+    /// Build a new `DictArray` without validating the codes or values.
+    ///
+    /// # Safety
+    ///
+    /// See [`DictData::new_unchecked`].
+    pub unsafe fn new_unchecked(codes: ArrayRef, values: ArrayRef) -> Self {
+        let dtype = values
+            .dtype()
+            .union_nullability(codes.dtype().nullability());
+        let len = codes.len();
+        let data = unsafe { DictData::new_unchecked() };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Dict, dtype, len, data).with_slots(vec![Some(codes), Some(values)]),
+            )
+        }
+    }
+
+    /// Set whether all values in the dictionary are referenced by at least one code.
+    ///
+    /// # Safety
+    ///
+    /// See [`DictData::set_all_values_referenced`].
+    pub unsafe fn set_all_values_referenced(self, all_values_referenced: bool) -> Self {
+        let dtype = self.dtype().clone();
+        let len = self.len();
+        let slots = self.slots().to_vec();
+        let data = unsafe {
+            self.into_data()
+                .set_all_values_referenced(all_values_referenced)
+        };
+        let array = unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Dict, dtype, len, data).with_slots(slots))
+        };
+
+        #[cfg(debug_assertions)]
+        if all_values_referenced {
+            array
+                .validate_all_values_referenced()
+                .vortex_expect("validation should succeed when all values are referenced");
+        }
+
+        array
     }
 }
 
@@ -229,7 +254,7 @@ impl DictArray {
 mod test {
     #[allow(unused_imports)]
     use itertools::Itertools;
-    use rand::Rng;
+    use rand::RngExt;
     use rand::SeedableRng;
     use rand::distr::Distribution;
     use rand::distr::StandardUniform;
@@ -241,15 +266,14 @@ mod test {
     use vortex_error::vortex_panic;
     use vortex_mask::AllOr;
 
-    use crate::Array;
     use crate::ArrayRef;
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
     use crate::ToCanonical;
     use crate::VortexSessionExecute;
     use crate::arrays::ChunkedArray;
+    use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::dict::DictArray;
     use crate::assert_arrays_eq;
     use crate::builders::builder_with_capacity;
     use crate::dtype::DType;
@@ -374,9 +398,7 @@ mod test {
             &DType::Primitive(PType::U64, NonNullable),
             len * chunk_count,
         );
-        array
-            .clone()
-            .append_to_builder(builder.as_mut(), &mut LEGACY_SESSION.create_execution_ctx())?;
+        array.append_to_builder(builder.as_mut(), &mut LEGACY_SESSION.create_execution_ctx())?;
 
         let into_prim = array.to_primitive();
         let prim_into = builder.finish_into_canonical().into_primitive();
@@ -388,18 +410,20 @@ mod test {
     #[cfg_attr(miri, ignore)]
     #[test]
     fn test_dict_metadata() {
+        use prost::Message;
+
         use super::DictMetadata;
-        use crate::ProstMetadata;
         use crate::test_harness::check_metadata;
 
         check_metadata(
             "dict.metadata",
-            ProstMetadata(DictMetadata {
+            &DictMetadata {
                 codes_ptype: PType::U64 as i32,
                 values_len: u32::MAX,
                 is_nullable_codes: None,
                 all_values_referenced: None,
-            }),
+            }
+            .encode_to_vec(),
         );
     }
 }
diff --git a/vortex-array/src/arrays/dict/compute/cast.rs b/vortex-array/src/arrays/dict/compute/cast.rs
index 498b202576f..2398ed2c161 100644
--- a/vortex-array/src/arrays/dict/compute/cast.rs
+++ b/vortex-array/src/arrays/dict/compute/cast.rs
@@ -3,17 +3,19 @@
 
 use vortex_error::VortexResult;
 
+use super::Dict;
 use super::DictArray;
-use super::DictVTable;
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
 
-impl CastReduce for DictVTable {
-    fn cast(array: &DictArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+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()
@@ -52,8 +54,9 @@ mod tests {
 
     use crate::IntoArray;
     use crate::ToCanonical;
+    use crate::arrays::Dict;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::dict::DictVTable;
+    use crate::arrays::dict::DictArraySlotsExt;
     use crate::assert_arrays_eq;
     use crate::builders::dict::dict_encode;
     use crate::builtins::ArrayBuiltins;
@@ -68,7 +71,7 @@ mod tests {
         let dict = dict_encode(&values).unwrap();
 
         let casted = dict
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -84,10 +87,10 @@ mod tests {
     fn test_cast_dict_nullable() {
         let values =
             PrimitiveArray::from_option_iter([Some(10i32), None, Some(20), Some(10), None]);
-        let dict = dict_encode(values.as_ref()).unwrap();
+        let dict = dict_encode(&values.into_array()).unwrap();
 
         let casted = dict
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I64, Nullability::Nullable))
             .unwrap();
         assert_eq!(
@@ -111,7 +114,8 @@ mod tests {
 
         // Cast to NonNullable (should be identity since already NonNullable)
         let non_nullable = dict
-            .to_array()
+            .clone()
+            .into_array()
             .cast(DType::Primitive(PType::I32, Nullability::NonNullable))
             .unwrap();
         assert_eq!(
@@ -120,7 +124,7 @@ mod tests {
         );
 
         // Check that codes and values are still NonNullable
-        let non_nullable_dict = non_nullable.as_::<DictVTable>();
+        let non_nullable_dict = non_nullable.as_::<Dict>();
         assert_eq!(
             non_nullable_dict.codes().dtype().nullability(),
             Nullability::NonNullable
@@ -140,7 +144,7 @@ mod tests {
         );
 
         // Check that both codes and values are now Nullable
-        let nullable_dict = nullable.as_::<DictVTable>();
+        let nullable_dict = nullable.as_::<Dict>();
         assert_eq!(
             nullable_dict.codes().dtype().nullability(),
             Nullability::NonNullable
@@ -160,7 +164,7 @@ mod tests {
         );
 
         // Check that both codes and values are NonNullable again
-        let back_dict = back_to_non_nullable.as_::<DictVTable>();
+        let back_dict = back_to_non_nullable.as_::<Dict>();
         assert_eq!(
             back_dict.codes().dtype().nullability(),
             Nullability::NonNullable
@@ -171,8 +175,8 @@ mod tests {
         );
 
         // Verify values are unchanged
-        let original_values = dict.to_primitive();
-        let final_values = back_dict.to_primitive();
+        let original_values = dict.as_array().to_primitive();
+        let final_values = back_dict.array().to_primitive();
         assert_arrays_eq!(original_values, final_values);
     }
 
@@ -182,12 +186,12 @@ mod tests {
     #[case(dict_encode(&PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), Some(1), None]).into_array()).unwrap().into_array())]
     #[case(dict_encode(&buffer![1.5f32, 2.5, 1.5, 3.5].into_array()).unwrap().into_array())]
     fn test_cast_dict_conformance(#[case] array: crate::ArrayRef) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 
     #[test]
     fn test_cast_dict_with_unreferenced_null_values_to_nonnullable() {
-        use crate::arrays::dict::DictArray;
+        use crate::arrays::DictArray;
         use crate::validity::Validity;
 
         // Create a dict with nullable values that have unreferenced null entries.
@@ -209,7 +213,7 @@ mod tests {
 
         // Casting to NonNullable should succeed since all logical values are non-null.
         let result = dict
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::F64, Nullability::NonNullable));
         assert!(
             result.is_ok(),
diff --git a/vortex-array/src/arrays/dict/compute/compare.rs b/vortex-array/src/arrays/dict/compute/compare.rs
index 9d1df12e570..d59be4bf963 100644
--- a/vortex-array/src/arrays/dict/compute/compare.rs
+++ b/vortex-array/src/arrays/dict/compute/compare.rs
@@ -3,24 +3,27 @@
 
 use vortex_error::VortexResult;
 
+use super::Dict;
 use super::DictArray;
-use super::DictVTable;
-use crate::Array;
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar_fn::fns::binary::CompareKernel;
 use crate::scalar_fn::fns::operators::CompareOperator;
 use crate::scalar_fn::fns::operators::Operator;
 
-impl CompareKernel for DictVTable {
+impl CompareKernel for Dict {
     fn compare(
-        lhs: &DictArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Dict>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         // if we have more values than codes, it is faster to canonicalise first.
         if lhs.values().len() > lhs.codes().len() {
@@ -29,8 +32,8 @@ impl CompareKernel for DictVTable {
 
         // If the RHS is constant, then we just need to compare against our encoded values.
         if let Some(rhs) = rhs.as_constant() {
-            let compare_result = lhs.values().to_array().binary(
-                ConstantArray::new(rhs, lhs.values().len()).to_array(),
+            let compare_result = lhs.values().clone().binary(
+                ConstantArray::new(rhs, lhs.values().len()).into_array(),
                 Operator::from(operator),
             )?;
 
@@ -42,7 +45,7 @@ impl CompareKernel for DictVTable {
             };
 
             // We canonicalize the result because dictionary-encoded bools is dumb.
-            return Ok(Some(result.to_canonical()?.into_array()));
+            return Ok(Some(result.execute::<Canonical>(ctx)?.into_array()));
         }
 
         // It's a little more complex, but we could perform a comparison against the dictionary
diff --git a/vortex-array/src/arrays/dict/compute/fill_null.rs b/vortex-array/src/arrays/dict/compute/fill_null.rs
index 0f47dd73563..fb1b4034bde 100644
--- a/vortex-array/src/arrays/dict/compute/fill_null.rs
+++ b/vortex-array/src/arrays/dict/compute/fill_null.rs
@@ -3,14 +3,18 @@
 
 use vortex_error::VortexResult;
 
+use super::Dict;
 use super::DictArray;
-use super::DictVTable;
-use crate::Array;
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::builtins::ArrayBuiltins;
 use crate::match_each_integer_ptype;
 use crate::scalar::Scalar;
@@ -18,22 +22,22 @@ use crate::scalar::ScalarValue;
 use crate::scalar_fn::fns::fill_null::FillNullKernel;
 use crate::scalar_fn::fns::operators::Operator;
 
-impl FillNullKernel for DictVTable {
+impl FillNullKernel for Dict {
     fn fill_null(
-        array: &DictArray,
+        array: ArrayView<'_, Dict>,
         fill_value: &Scalar,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         // If the fill value already exists in the dictionary, we can simply rewrite the null codes
         // to point to the value.
         let found_fill_values = array
             .values()
-            .to_array()
+            .clone()
             .binary(
-                ConstantArray::new(fill_value.clone(), array.values().len()).to_array(),
+                ConstantArray::new(fill_value.clone(), array.values().len()).into_array(),
                 Operator::Eq,
             )?
-            .to_bool();
+            .execute::<BoolArray>(ctx)?;
 
         // We found the fill value already in the values at this given index.
         let Some(existing_fill_value_index) =
@@ -42,7 +46,9 @@ impl FillNullKernel for DictVTable {
             // No fill values found, so we must canonicalize and fill_null.
             return Ok(Some(
                 array
-                    .to_canonical()?
+                    .array()
+                    .clone()
+                    .execute::<Canonical>(ctx)?
                     .into_array()
                     .fill_null(fill_value.clone())?,
             ));
@@ -64,11 +70,11 @@ impl FillNullKernel for DictVTable {
 
         // Fill nulls in both the codes and the values. Note that the precondition of this function
         // states that the fill value is non-null, so we do not have to worry about the nullability.
-        let codes = codes.to_array().fill_null(Scalar::try_new(
+        let codes = codes.clone().fill_null(Scalar::try_new(
             codes.dtype().as_nonnullable(),
             Some(fill_scalar_value),
         )?)?;
-        let values = array.values().to_array().fill_null(fill_value.clone())?;
+        let values = array.values().clone().fill_null(fill_value.clone())?;
 
         // SAFETY: invariants are still satisfied after patching nulls.
         unsafe {
@@ -89,8 +95,8 @@ mod tests {
 
     use crate::IntoArray;
     use crate::ToCanonical;
+    use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::dict::DictArray;
     use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::dtype::Nullability;
@@ -110,7 +116,7 @@ mod tests {
         .vortex_expect("operation should succeed in test");
 
         let filled = dict
-            .to_array()
+            .into_array()
             .fill_null(Scalar::primitive(20, Nullability::NonNullable))
             .vortex_expect("operation should succeed in test");
         let filled_primitive = filled.to_primitive();
diff --git a/vortex-array/src/arrays/dict/compute/is_constant.rs b/vortex-array/src/arrays/dict/compute/is_constant.rs
index 1a786e53e0a..f5a903a126f 100644
--- a/vortex-array/src/arrays/dict/compute/is_constant.rs
+++ b/vortex-array/src/arrays/dict/compute/is_constant.rs
@@ -2,23 +2,57 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
-use super::DictArray;
-use super::DictVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::is_constant_opts;
-use crate::register_kernel;
-
-impl IsConstantKernel for DictVTable {
-    fn is_constant(&self, array: &DictArray, opts: &IsConstantOpts) -> VortexResult<Option<bool>> {
-        if is_constant_opts(array.codes(), opts)? == Some(true) {
-            return Ok(Some(true));
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::fns::is_constant::IsConstant;
+use crate::aggregate_fn::fns::is_constant::is_constant;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::arrays::Dict;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::scalar::Scalar;
+
+/// Dict-specific is_constant kernel.
+///
+/// If codes are constant, the whole array is constant.
+/// When all dictionary values are referenced, is_constant can be computed directly on the values
+/// array. Otherwise, unreferenced values are filtered out first.
+#[derive(Debug)]
+pub(crate) struct DictIsConstantKernel;
+
+impl DynAggregateKernel for DictIsConstantKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<IsConstant>() {
+            return Ok(None);
         }
 
-        is_constant_opts(array.values(), opts)
+        let Some(dict) = batch.as_opt::<Dict>() else {
+            return Ok(None);
+        };
+
+        // If codes are constant, only one dictionary value is referenced → constant.
+        if is_constant(dict.codes(), ctx)? {
+            return Ok(Some(IsConstant::make_partial(batch, true)?));
+        }
+
+        // Otherwise, check the values array. Filter to only referenced values if needed.
+        let result = if dict.has_all_values_referenced() {
+            is_constant(dict.values(), ctx)?
+        } else {
+            let referenced_mask = dict.compute_referenced_values_mask(true)?;
+            let mask = Mask::from(referenced_mask);
+            let filtered_values = dict.values().filter(mask)?;
+            is_constant(&filtered_values, ctx)?
+        };
+
+        Ok(Some(IsConstant::make_partial(batch, result)?))
     }
 }
-
-register_kernel!(IsConstantKernelAdapter(DictVTable).lift());
diff --git a/vortex-array/src/arrays/dict/compute/is_sorted.rs b/vortex-array/src/arrays/dict/compute/is_sorted.rs
index d4d8e8b5bb4..cb20287ae83 100644
--- a/vortex-array/src/arrays/dict/compute/is_sorted.rs
+++ b/vortex-array/src/arrays/dict/compute/is_sorted.rs
@@ -3,30 +3,52 @@
 
 use vortex_error::VortexResult;
 
-use super::DictArray;
-use super::DictVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::compute::is_sorted;
-use crate::compute::is_strict_sorted;
-use crate::register_kernel;
-
-impl IsSortedKernel for DictVTable {
-    fn is_sorted(&self, array: &DictArray) -> VortexResult<Option<bool>> {
-        if Some((true, true)) == is_sorted(array.values())?.zip(is_sorted(array.codes())?) {
-            return Ok(Some(true));
-        }
-        Ok(None)
-    }
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::fns::is_sorted::IsSorted;
+use crate::aggregate_fn::fns::is_sorted::is_sorted;
+use crate::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::arrays::Dict;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::scalar::Scalar;
+
+/// Dict-specific is_sorted kernel.
+///
+/// If both values and codes are sorted (with the same strictness), then the dict array is sorted.
+#[derive(Debug)]
+pub(crate) struct DictIsSortedKernel;
+
+impl DynAggregateKernel for DictIsSortedKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let Some(options) = aggregate_fn.as_opt::<IsSorted>() else {
+            return Ok(None);
+        };
 
-    fn is_strict_sorted(&self, array: &DictArray) -> VortexResult<Option<bool>> {
-        if Some((true, true))
-            == is_strict_sorted(array.values())?.zip(is_strict_sorted(array.codes())?)
-        {
-            return Ok(Some(true));
+        let Some(dict) = batch.as_opt::<Dict>() else {
+            return Ok(None);
+        };
+
+        let strict = options.strict;
+
+        let result = if strict {
+            is_strict_sorted(dict.values(), ctx)? && is_strict_sorted(dict.codes(), ctx)?
+        } else {
+            is_sorted(dict.values(), ctx)? && is_sorted(dict.codes(), ctx)?
+        };
+
+        if result {
+            Ok(Some(IsSorted::make_partial(batch, true, strict)?))
+        } else {
+            // We can't definitively say it's NOT sorted without canonicalizing,
+            // so return None to let the accumulator handle it.
+            Ok(None)
         }
-        Ok(None)
     }
 }
-
-register_kernel!(IsSortedKernelAdapter(DictVTable).lift());
diff --git a/vortex-array/src/arrays/dict/compute/like.rs b/vortex-array/src/arrays/dict/compute/like.rs
index d50feb70be9..40bcea8fcf1 100644
--- a/vortex-array/src/arrays/dict/compute/like.rs
+++ b/vortex-array/src/arrays/dict/compute/like.rs
@@ -3,22 +3,24 @@
 
 use vortex_error::VortexResult;
 
+use super::Dict;
 use super::DictArray;
-use super::DictVTable;
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::optimizer::ArrayOptimizer;
 use crate::scalar_fn::fns::like::Like;
 use crate::scalar_fn::fns::like::LikeOptions;
 use crate::scalar_fn::fns::like::LikeReduce;
 
-impl LikeReduce for DictVTable {
+impl LikeReduce for Dict {
     fn like(
-        array: &DictArray,
-        pattern: &dyn Array,
+        array: ArrayView<'_, Dict>,
+        pattern: &ArrayRef,
         options: LikeOptions,
     ) -> VortexResult<Option<ArrayRef>> {
         // If we have more values than codes, it is faster to canonicalize first.
@@ -55,10 +57,10 @@ mod tests {
 
     use crate::IntoArray;
     use crate::arrays::BoolArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::DictArray;
-    use crate::arrays::ScalarFnArrayExt;
     use crate::arrays::VarBinArray;
+    use crate::arrays::dict::compute::like::ConstantArray;
+    use crate::arrays::scalar_fn::ScalarFnFactoryExt;
     use crate::assert_arrays_eq;
     use crate::optimizer::ArrayOptimizer;
     use crate::scalar_fn::fns::like::Like;
diff --git a/vortex-array/src/arrays/dict/compute/mask.rs b/vortex-array/src/arrays/dict/compute/mask.rs
index e18dc4d16af..05bb3cf091f 100644
--- a/vortex-array/src/arrays/dict/compute/mask.rs
+++ b/vortex-array/src/arrays/dict/compute/mask.rs
@@ -5,15 +5,17 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Dict;
 use crate::arrays::DictArray;
-use crate::arrays::DictVTable;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::scalar_fn::EmptyOptions;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
 use crate::scalar_fn::fns::mask::MaskReduce;
 
-impl MaskReduce for DictVTable {
-    fn mask(array: &DictArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Dict {
+    fn mask(array: ArrayView<'_, Dict>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_codes = MaskExpr.try_new_array(
             array.codes().len(),
             EmptyOptions,
diff --git a/vortex-array/src/arrays/dict/compute/min_max.rs b/vortex-array/src/arrays/dict/compute/min_max.rs
index 8eaaa56d766..8abd34dbc0a 100644
--- a/vortex-array/src/arrays/dict/compute/min_max.rs
+++ b/vortex-array/src/arrays/dict/compute/min_max.rs
@@ -2,73 +2,94 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
-use super::DictArray;
-use super::DictVTable;
-use crate::Array as _;
-use crate::IntoArray;
-use crate::arrays::BoolArray;
-use crate::builtins::ArrayBuiltins;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::compute::min_max;
-use crate::register_kernel;
-use crate::validity::Validity;
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::fns::min_max::MinMax;
+use crate::aggregate_fn::fns::min_max::make_minmax_dtype;
+use crate::aggregate_fn::fns::min_max::min_max;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::arrays::Dict;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::scalar::Scalar;
 
-impl MinMaxKernel for DictVTable {
-    fn min_max(&self, array: &DictArray) -> VortexResult<Option<MinMaxResult>> {
-        let codes_validity = array.codes().validity_mask()?;
-        if codes_validity.all_false() {
+/// Dict-specific min/max kernel.
+///
+/// When all dictionary values are referenced, min/max can be computed directly on the values
+/// array. Otherwise, unreferenced values are filtered out first.
+#[derive(Debug)]
+pub(crate) struct DictMinMaxKernel;
+
+impl DynAggregateKernel for DictMinMaxKernel {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        if !aggregate_fn.is::<MinMax>() {
             return Ok(None);
         }
 
-        // Fast path: if all values are referenced, directly compute min/max on values
-        if array.has_all_values_referenced() {
-            return min_max(array.values());
-        }
+        let Some(dict) = batch.as_opt::<Dict>() else {
+            return Ok(None);
+        };
 
-        // Slow path: compute which values are unreferenced and mask them out
-        let unreferenced_mask = BoolArray::new(
-            array.compute_referenced_values_mask(true)?,
-            Validity::NonNullable,
-        )
-        .into_array();
+        let struct_dtype = make_minmax_dtype(batch.dtype());
 
-        min_max(&array.values().clone().mask(unreferenced_mask)?)
+        let result = if dict.has_all_values_referenced() {
+            // All values are referenced, compute min/max directly on the values array.
+            min_max(dict.values(), ctx)?
+        } else {
+            // Filter to only referenced values, then compute min/max.
+            let referenced_mask = dict.compute_referenced_values_mask(true)?;
+            let mask = Mask::from(referenced_mask);
+            let filtered_values = dict.values().filter(mask)?;
+            min_max(&filtered_values, ctx)?
+        };
+
+        match result {
+            Some(r) => Ok(Some(Scalar::struct_(struct_dtype, vec![r.min, r.max]))),
+            None => Ok(Some(Scalar::null(struct_dtype))),
+        }
     }
 }
 
-register_kernel!(MinMaxKernelAdapter(DictVTable).lift());
-
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
 
-    use super::DictArray;
-    use crate::Array;
+    use crate::ArrayRef;
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::min_max::min_max;
+    use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
     use crate::builders::dict::dict_encode;
-    use crate::compute::min_max;
 
-    fn assert_min_max(array: &dyn Array, expected: Option<(i32, i32)>) {
-        match (min_max(array).unwrap(), expected) {
+    fn assert_min_max(array: &ArrayRef, expected: Option<(i32, i32)>) -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        match (min_max(array, &mut ctx)?, expected) {
             (Some(result), Some((expected_min, expected_max))) => {
-                assert_eq!(i32::try_from(&result.min).unwrap(), expected_min);
-                assert_eq!(i32::try_from(&result.max).unwrap(), expected_max);
+                assert_eq!(i32::try_from(&result.min)?, expected_min);
+                assert_eq!(i32::try_from(&result.max)?, expected_max);
             }
             (None, None) => {}
             (got, expected) => panic!(
-                "min_max mismatch: expected {:?}, got {:?}",
-                expected,
+                "min_max mismatch: expected {expected:?}, got {:?}",
                 got.as_ref().map(|r| (
                     i32::try_from(&r.min.clone()).ok(),
                     i32::try_from(&r.max.clone()).ok()
                 ))
             ),
         }
+        Ok(())
     }
 
     #[rstest]
@@ -86,7 +107,6 @@ mod tests {
         ).unwrap(),
         (2, 4)
     )]
-    // Non-covering: codes with gaps
     #[case::non_covering_gaps(
         DictArray::try_new(
             buffer![0u32, 2, 4].into_array(),
@@ -104,20 +124,20 @@ mod tests {
     )]
     #[case::nullable_values(
         dict_encode(
-            PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), Some(1), None]).as_ref()
+            &PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), Some(1), None]).into_array()
         ).unwrap(),
         (1, 2)
     )]
-    fn test_min_max(#[case] dict: DictArray, #[case] expected: (i32, i32)) {
-        assert_min_max(dict.as_ref(), Some(expected));
+    fn test_min_max(#[case] dict: DictArray, #[case] expected: (i32, i32)) -> VortexResult<()> {
+        assert_min_max(&dict.into_array(), Some(expected))
     }
 
     #[test]
-    fn test_sliced_dict() {
+    fn test_sliced_dict() -> VortexResult<()> {
         let reference = PrimitiveArray::from_iter([1, 5, 10, 50, 100]);
-        let dict = dict_encode(reference.as_ref()).unwrap();
-        let sliced = dict.slice(1..3).unwrap();
-        assert_min_max(sliced.as_ref(), Some((5, 10)));
+        let dict = dict_encode(&reference.into_array())?;
+        let sliced = dict.slice(1..3)?;
+        assert_min_max(&sliced, Some((5, 10)))
     }
 
     #[rstest]
@@ -133,7 +153,7 @@ mod tests {
             buffer![10i32, 20, 30].into_array(),
         ).unwrap()
     )]
-    fn test_min_max_none(#[case] dict: DictArray) {
-        assert_min_max(dict.as_ref(), None);
+    fn test_min_max_none(#[case] dict: DictArray) -> VortexResult<()> {
+        assert_min_max(&dict.into_array(), None)
     }
 }
diff --git a/vortex-array/src/arrays/dict/compute/mod.rs b/vortex-array/src/arrays/dict/compute/mod.rs
index 1890345e272..575dab50f50 100644
--- a/vortex-array/src/arrays/dict/compute/mod.rs
+++ b/vortex-array/src/arrays/dict/compute/mod.rs
@@ -4,37 +4,34 @@
 mod cast;
 mod compare;
 mod fill_null;
-mod is_constant;
-mod is_sorted;
+pub(crate) mod is_constant;
+pub(crate) mod is_sorted;
 mod like;
 mod mask;
-mod min_max;
+pub(crate) mod min_max;
 pub(crate) mod rules;
 mod slice;
 
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use super::Dict;
 use super::DictArray;
-use super::DictVTable;
 use super::TakeExecute;
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::arrays::filter::FilterReduce;
 
-impl TakeExecute for DictVTable {
+impl TakeExecute for Dict {
     fn take(
-        array: &DictArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Dict>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let codes = array
-            .codes()
-            .take(indices.to_array())?
-            .to_canonical()?
-            .into_array();
+        let codes = array.codes().take(indices.clone())?;
         // SAFETY: selecting codes doesn't change the invariants of DictArray
         // Preserve all_values_referenced since taking codes doesn't affect which values are referenced
         Ok(Some(unsafe {
@@ -43,8 +40,8 @@ impl TakeExecute for DictVTable {
     }
 }
 
-impl FilterReduce for DictVTable {
-    fn filter(array: &DictArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for Dict {
+    fn filter(array: ArrayView<'_, Dict>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         let codes = array.codes().filter(mask.clone())?;
 
         // SAFETY: filtering codes doesn't change invariants
@@ -61,7 +58,6 @@ mod test {
     use itertools::Itertools;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::ArrayRef;
     use crate::IntoArray;
     use crate::ToCanonical;
@@ -91,8 +87,9 @@ mod test {
             })
             .collect();
 
-        let dict = dict_encode(PrimitiveArray::from_option_iter(values.clone()).as_ref()).unwrap();
-        let actual = dict.to_primitive();
+        let dict =
+            dict_encode(&PrimitiveArray::from_option_iter(values.clone()).into_array()).unwrap();
+        let actual = dict.as_array().to_primitive();
 
         let expected = PrimitiveArray::from_option_iter(values);
 
@@ -104,8 +101,8 @@ mod test {
         let unique_values: Vec<i32> = (0..32).collect();
         let expected = PrimitiveArray::from_iter((0..1000).map(|i| unique_values[i % 32]));
 
-        let dict = dict_encode(expected.as_ref()).unwrap();
-        let actual = dict.to_primitive();
+        let dict = dict_encode(&expected.clone().into_array()).unwrap();
+        let actual = dict.as_array().to_primitive();
 
         assert_arrays_eq!(actual, expected);
     }
@@ -115,8 +112,8 @@ mod test {
         let unique_values: Vec<i32> = (0..100).collect();
         let expected = PrimitiveArray::from_iter((0..1000).map(|i| unique_values[i % 100]));
 
-        let dict = dict_encode(expected.as_ref()).unwrap();
-        let actual = dict.to_primitive();
+        let dict = dict_encode(&expected.clone().into_array()).unwrap();
+        let actual = dict.as_array().to_primitive();
 
         assert_arrays_eq!(actual, expected);
     }
@@ -128,8 +125,8 @@ mod test {
             DType::Utf8(Nullability::Nullable),
         );
         assert_eq!(reference.len(), 6);
-        let dict = dict_encode(reference.as_ref()).unwrap();
-        let flattened_dict = dict.to_varbinview();
+        let dict = dict_encode(&reference.clone().into_array()).unwrap();
+        let flattened_dict = dict.as_array().to_varbinview();
         assert_eq!(
             flattened_dict.with_iterator(|iter| iter
                 .map(|slice| slice.map(|s| s.to_vec()))
@@ -149,7 +146,7 @@ mod test {
             Some(1),
             Some(5),
         ]);
-        let dict = dict_encode(reference.as_ref()).unwrap();
+        let dict = dict_encode(&reference.into_array()).unwrap();
         dict.slice(1..4).unwrap()
     }
 
@@ -158,23 +155,24 @@ mod test {
         use crate::arrays::BoolArray;
         let sliced = sliced_dict_array();
         let compared = sliced
-            .binary(ConstantArray::new(42, 3).to_array(), Operator::Eq)
+            .binary(ConstantArray::new(42, 3).into_array(), Operator::Eq)
             .unwrap();
 
         let expected = BoolArray::from_iter([Some(false), None, Some(true)]);
-        assert_arrays_eq!(compared, expected.to_array());
+        assert_arrays_eq!(compared, expected.into_array());
     }
 
     #[test]
     fn test_mask_dict_array() {
         let array = dict_encode(&buffer![2, 0, 2, 0, 10].into_array()).unwrap();
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
 
         let array = dict_encode(
-            PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)]).as_ref(),
+            &PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)])
+                .into_array(),
         )
         .unwrap();
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
 
         let array = dict_encode(
             &VarBinArray::from_iter(
@@ -190,19 +188,20 @@ mod test {
             .into_array(),
         )
         .unwrap();
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 
     #[test]
     fn test_filter_dict_array() {
         let array = dict_encode(&buffer![2, 0, 2, 0, 10].into_array()).unwrap();
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
 
         let array = dict_encode(
-            PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)]).as_ref(),
+            &PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)])
+                .into_array(),
         )
         .unwrap();
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
 
         let array = dict_encode(
             &VarBinArray::from_iter(
@@ -218,16 +217,16 @@ mod test {
             .into_array(),
         )
         .unwrap();
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
     fn test_take_dict() {
-        let array = dict_encode(buffer![1, 2].into_array().as_ref()).unwrap();
+        let array = dict_encode(&buffer![1, 2].into_array()).unwrap();
 
         assert_eq!(
             array
-                .take(PrimitiveArray::from_option_iter([Option::<i32>::None]).to_array())
+                .take(PrimitiveArray::from_option_iter([Option::<i32>::None]).into_array())
                 .unwrap()
                 .dtype(),
             &DType::Primitive(I32, Nullability::Nullable)
@@ -237,13 +236,14 @@ mod test {
     #[test]
     fn test_take_dict_conformance() {
         let array = dict_encode(&buffer![2, 0, 2, 0, 10].into_array()).unwrap();
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
 
         let array = dict_encode(
-            PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)]).as_ref(),
+            &PrimitiveArray::from_option_iter([Some(2), None, Some(2), Some(0), Some(10)])
+                .into_array(),
         )
         .unwrap();
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
 
         let array = dict_encode(
             &VarBinArray::from_iter(
@@ -259,7 +259,7 @@ mod test {
             .into_array(),
         )
         .unwrap();
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
 
@@ -269,9 +269,9 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinArray;
-    use crate::arrays::dict::DictArray;
     use crate::builders::dict::dict_encode;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DType;
@@ -285,7 +285,7 @@ mod tests {
         PrimitiveArray::from_option_iter([Some(10), Some(20), None]).into_array(),
     ).unwrap())]
     #[case::dict_nullable_values(dict_encode(
-        PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), Some(1), None]).as_ref()
+        &PrimitiveArray::from_option_iter([Some(1i32), None, Some(2), Some(1), None]).into_array()
     ).unwrap())]
     #[case::dict_u64(dict_encode(&buffer![100u64, 200, 100, 300, 200].into_array()).unwrap())]
     // String arrays
@@ -306,6 +306,6 @@ mod tests {
     #[case::dict_all_same(dict_encode(&buffer![5i32, 5, 5, 5, 5].into_array()).unwrap())]
     #[case::dict_large(dict_encode(&PrimitiveArray::from_iter((0..1000).map(|i| i % 10)).into_array()).unwrap())]
     fn test_dict_consistency(#[case] array: DictArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/dict/compute/rules.rs b/vortex-array/src/arrays/dict/compute/rules.rs
index 6a109e39cf7..c6817a39d58 100644
--- a/vortex-array/src/arrays/dict/compute/rules.rs
+++ b/vortex-array/src/arrays/dict/compute/rules.rs
@@ -3,19 +3,22 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayEq;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::Precision;
-use crate::arrays::AnyScalarFn;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::arrays::Dict;
 use crate::arrays::DictArray;
-use crate::arrays::DictVTable;
-use crate::arrays::FilterReduceAdaptor;
 use crate::arrays::ScalarFnArray;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::ScalarFnVTable;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::scalar_fn::AnyScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::builtins::ArrayBuiltins;
 use crate::optimizer::ArrayOptimizer;
 use crate::optimizer::rules::ArrayParentReduceRule;
@@ -26,27 +29,27 @@ use crate::scalar_fn::fns::like::LikeReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 use crate::scalar_fn::fns::pack::Pack;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<DictVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&FilterReduceAdaptor(DictVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(DictVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(DictVTable)),
-    ParentRuleSet::lift(&LikeReduceAdaptor(DictVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<Dict> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&FilterReduceAdaptor(Dict)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Dict)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Dict)),
+    ParentRuleSet::lift(&LikeReduceAdaptor(Dict)),
     ParentRuleSet::lift(&DictionaryScalarFnValuesPushDownRule),
     ParentRuleSet::lift(&DictionaryScalarFnCodesPullUpRule),
-    ParentRuleSet::lift(&SliceReduceAdaptor(DictVTable)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Dict)),
 ]);
 
 /// Push down a scalar function to run only over the values of a dictionary array.
 #[derive(Debug)]
 struct DictionaryScalarFnValuesPushDownRule;
 
-impl ArrayParentReduceRule<DictVTable> for DictionaryScalarFnValuesPushDownRule {
+impl ArrayParentReduceRule<Dict> for DictionaryScalarFnValuesPushDownRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        array: &DictArray,
-        parent: &ScalarFnArray,
+        array: ArrayView<'_, Dict>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // Check that the scalar function can actually be pushed down.
@@ -77,7 +80,7 @@ impl ArrayParentReduceRule<DictVTable> for DictionaryScalarFnValuesPushDownRule
             tracing::trace!(
                 "Not pushing down fallible scalar function {} over dictionary with sparse codes {}",
                 parent.scalar_fn(),
-                array.encoding_id(),
+                Dict::ID,
             );
             return Ok(None);
         }
@@ -85,34 +88,35 @@ impl ArrayParentReduceRule<DictVTable> for DictionaryScalarFnValuesPushDownRule
         // Check that all siblings are constant
         // TODO(ngates): we can also support other dictionaries if the values are the same!
         if !parent
-            .children()
-            .iter()
+            .iter_children()
             .enumerate()
-            .all(|(idx, c)| idx == child_idx || c.is::<ConstantVTable>())
+            .all(|(idx, c)| idx == child_idx || c.is::<Constant>())
         {
             return Ok(None);
         }
 
         // If the scalar function is null-sensitive, then we cannot push it down to values if
         // we have any nulls in the codes.
-        if array.codes.dtype().is_nullable() && !array.codes.all_valid()? && sig.is_null_sensitive()
+        if array.codes().dtype().is_nullable()
+            && !array.codes().all_valid()?
+            && sig.is_null_sensitive()
         {
             tracing::trace!(
                 "Not pushing down null-sensitive scalar function {} over dictionary with null codes {}",
                 parent.scalar_fn(),
-                array.encoding_id(),
+                Dict::ID,
             );
             return Ok(None);
         }
 
         // Now we push the parent scalar function into the dictionary values.
         let values_len = array.values().len();
-        let mut new_children = Vec::with_capacity(parent.children().len());
-        for (idx, child) in parent.children().iter().enumerate() {
+        let mut new_children = Vec::with_capacity(parent.nchildren());
+        for (idx, child) in parent.iter_children().enumerate() {
             if idx == child_idx {
                 new_children.push(array.values().clone());
             } else {
-                let scalar = child.as_::<ConstantVTable>().scalar().clone();
+                let scalar = child.as_::<Constant>().scalar().clone();
                 new_children.push(ConstantArray::new(scalar, values_len).into_array());
             }
         }
@@ -141,25 +145,25 @@ impl ArrayParentReduceRule<DictVTable> for DictionaryScalarFnValuesPushDownRule
 #[derive(Debug)]
 struct DictionaryScalarFnCodesPullUpRule;
 
-impl ArrayParentReduceRule<DictVTable> for DictionaryScalarFnCodesPullUpRule {
+impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
     type Parent = AnyScalarFn;
 
     fn reduce_parent(
         &self,
-        array: &DictArray,
-        parent: &ScalarFnArray,
+        array: ArrayView<'_, Dict>,
+        parent: ArrayView<'_, ScalarFnVTable>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // Don't attempt to pull up if there are less than 2 siblings.
-        if parent.children().len() < 2 {
+        if parent.nchildren() < 2 {
             return Ok(None);
         }
 
         // Check that all siblings are dictionaries, and have the same number of values as us.
         // This is a cheap first loop.
-        if !parent.children().iter().enumerate().all(|(idx, c)| {
+        if !parent.iter_children().enumerate().all(|(idx, c)| {
             idx == child_idx
-                || c.as_opt::<DictVTable>()
+                || c.as_opt::<Dict>()
                     .is_some_and(|c| c.values().len() == array.values().len())
         }) {
             return Ok(None);
@@ -167,27 +171,30 @@ impl ArrayParentReduceRule<DictVTable> 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.children().iter().enumerate().all(|(idx, c)| {
+        if !parent.iter_children().enumerate().all(|(idx, c)| {
             idx == child_idx
-                || c.as_opt::<DictVTable>()
+                || c.as_opt::<Dict>()
                     .is_some_and(|c| c.codes().array_eq(array.codes(), Precision::Value))
         }) {
             return Ok(None);
         }
 
-        let mut new_children = Vec::with_capacity(parent.children().len());
-        for (idx, child) in parent.children().iter().enumerate() {
+        let mut new_children = Vec::with_capacity(parent.nchildren());
+        for (idx, child) in parent.iter_children().enumerate() {
             if idx == child_idx {
                 new_children.push(array.values().clone());
             } else {
-                new_children.push(child.as_::<DictVTable>().values().clone());
+                new_children.push(child.as_::<Dict>().values().clone());
             }
         }
 
-        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,
+            array.values().len(),
+        )?
+        .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 29a61454849..509fa7535d8 100644
--- a/vortex-array/src/arrays/dict/compute/slice.rs
+++ b/vortex-array/src/arrays/dict/compute/slice.rs
@@ -7,18 +7,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::arrays::Dict;
 use crate::arrays::DictArray;
-use crate::arrays::DictVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::dict::DictArraySlotsExt;
+use crate::arrays::slice::SliceReduce;
 use crate::scalar::Scalar;
 
-impl SliceReduce for DictVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Dict {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let sliced_code = 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::<ConstantVTable>() {
+        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)?;
@@ -32,7 +34,7 @@ impl SliceReduce for DictVTable {
             } else {
                 Ok(Some(
                     ConstantArray::new(Scalar::null(array.dtype().clone()), sliced_code.len())
-                        .to_array(),
+                        .into_array(),
                 ))
             };
         }
@@ -48,11 +50,10 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
 
-    use crate::Array;
     use crate::IntoArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::dict::compute::slice::ConstantArray;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
     use crate::dtype::Nullability::Nullable;
diff --git a/vortex-array/src/arrays/dict/execute.rs b/vortex-array/src/arrays/dict/execute.rs
index 0e1dfd506bb..d95cd239a44 100644
--- a/vortex-array/src/arrays/dict/execute.rs
+++ b/vortex-array/src/arrays/dict/execute.rs
@@ -8,24 +8,28 @@ use vortex_error::VortexResult;
 
 use crate::Canonical;
 use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalVTable;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
 use crate::arrays::NullArray;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::VariantArray;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::variant::VariantArrayExt;
 
 /// Take from a canonical array using indices (codes), returning a new canonical array.
 ///
@@ -42,12 +46,19 @@ pub fn take_canonical(
         Canonical::Primitive(a) => Canonical::Primitive(take_primitive(&a, codes, ctx)),
         Canonical::Decimal(a) => Canonical::Decimal(take_decimal(&a, codes, ctx)),
         Canonical::VarBinView(a) => Canonical::VarBinView(take_varbinview(&a, codes, ctx)),
-        Canonical::List(a) => Canonical::List(take_listview(&a, codes, ctx)),
+        Canonical::List(a) => Canonical::List(take_listview(&a, codes)),
         Canonical::FixedSizeList(a) => {
             Canonical::FixedSizeList(take_fixed_size_list(&a, codes, ctx))
         }
-        Canonical::Struct(a) => Canonical::Struct(take_struct(&a, codes, ctx)),
+        Canonical::Struct(a) => Canonical::Struct(take_struct(&a, codes)),
         Canonical::Extension(a) => Canonical::Extension(take_extension(&a, codes, ctx)),
+        Canonical::Variant(a) => {
+            let taken_child = a
+                .child()
+                .take(codes.clone().into_array())
+                .vortex_expect("VariantArray child could not be taken");
+            Canonical::Variant(VariantArray::new(taken_child))
+        }
     })
 }
 
@@ -62,12 +73,12 @@ fn take_bool(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<BoolArray> {
-    Ok(
-        <BoolVTable as TakeExecute>::take(array, codes.as_ref(), ctx)?
-            .vortex_expect("take bool should not return None")
-            .as_::<BoolVTable>()
-            .clone(),
-    )
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    Ok(<Bool as TakeExecute>::take(array, &codes_ref, ctx)?
+        .vortex_expect("take bool should not return None")
+        .as_::<Bool>()
+        .into_owned())
 }
 
 fn take_primitive(
@@ -75,11 +86,13 @@ fn take_primitive(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> PrimitiveArray {
-    <PrimitiveVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <Primitive as TakeExecute>::take(array, &codes_ref, ctx)
         .vortex_expect("take primitive array")
         .vortex_expect("take primitive should not return None")
-        .as_::<PrimitiveVTable>()
-        .clone()
+        .as_::<Primitive>()
+        .into_owned()
 }
 
 fn take_decimal(
@@ -87,11 +100,13 @@ fn take_decimal(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> DecimalArray {
-    <DecimalVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <Decimal as TakeExecute>::take(array, &codes_ref, ctx)
         .vortex_expect("take decimal array")
         .vortex_expect("take decimal should not return None")
-        .as_::<DecimalVTable>()
-        .clone()
+        .as_::<Decimal>()
+        .into_owned()
 }
 
 fn take_varbinview(
@@ -99,23 +114,23 @@ fn take_varbinview(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> VarBinViewArray {
-    <VarBinViewVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <VarBinView as TakeExecute>::take(array, &codes_ref, ctx)
         .vortex_expect("take varbinview array")
         .vortex_expect("take varbinview should not return None")
-        .as_::<VarBinViewVTable>()
-        .clone()
+        .as_::<VarBinView>()
+        .into_owned()
 }
 
-fn take_listview(
-    array: &ListViewArray,
-    codes: &PrimitiveArray,
-    ctx: &mut ExecutionCtx,
-) -> ListViewArray {
-    <ListViewVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+fn take_listview(array: &ListViewArray, codes: &PrimitiveArray) -> ListViewArray {
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <ListView as TakeReduce>::take(array, &codes_ref)
         .vortex_expect("take listview array")
         .vortex_expect("take listview should not return None")
-        .as_::<ListViewVTable>()
-        .clone()
+        .as_::<ListView>()
+        .into_owned()
 }
 
 fn take_fixed_size_list(
@@ -123,19 +138,23 @@ fn take_fixed_size_list(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> FixedSizeListArray {
-    <FixedSizeListVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <FixedSizeList as TakeExecute>::take(array, &codes_ref, ctx)
         .vortex_expect("take fixed size list array")
         .vortex_expect("take fixed size list should not return None")
-        .as_::<FixedSizeListVTable>()
-        .clone()
+        .as_::<FixedSizeList>()
+        .into_owned()
 }
 
-fn take_struct(array: &StructArray, codes: &PrimitiveArray, ctx: &mut ExecutionCtx) -> StructArray {
-    <StructVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+fn take_struct(array: &StructArray, codes: &PrimitiveArray) -> StructArray {
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <Struct as TakeReduce>::take(array, &codes_ref)
         .vortex_expect("take struct array")
         .vortex_expect("take struct should not return None")
-        .as_::<StructVTable>()
-        .clone()
+        .as_::<Struct>()
+        .into_owned()
 }
 
 fn take_extension(
@@ -143,9 +162,11 @@ fn take_extension(
     codes: &PrimitiveArray,
     ctx: &mut ExecutionCtx,
 ) -> ExtensionArray {
-    <ExtensionVTable as TakeExecute>::take(array, codes.as_ref(), ctx)
+    let codes_ref = codes.clone().into_array();
+    let array = array.as_view();
+    <Extension as TakeExecute>::take(array, &codes_ref, ctx)
         .vortex_expect("take extension storage")
         .vortex_expect("take extension should not return None")
-        .as_::<ExtensionVTable>()
-        .clone()
+        .as_::<Extension>()
+        .into_owned()
 }
diff --git a/vortex-array/src/arrays/dict/take.rs b/vortex-array/src/arrays/dict/take.rs
index d38db57c923..7886f0b898a 100644
--- a/vortex-array/src/arrays/dict/take.rs
+++ b/vortex-array/src/arrays/dict/take.rs
@@ -3,14 +3,15 @@
 
 use vortex_error::VortexResult;
 
-use super::DictArray;
-use super::DictVTable;
-use crate::Array;
+use super::Dict;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ConstantArray;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::expr::stats::Precision;
 use crate::expr::stats::Stat;
 use crate::expr::stats::StatsProvider;
@@ -20,7 +21,6 @@ use crate::matcher::Matcher;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar::Scalar;
 use crate::stats::StatsSet;
-use crate::vtable::VTable;
 
 pub trait TakeReduce: VTable {
     /// Take elements from an array at the given indices without reading buffers.
@@ -32,7 +32,7 @@ pub trait TakeReduce: VTable {
     /// # Preconditions
     ///
     /// The indices are guaranteed to be non-empty.
-    fn take(array: &Self::Array, indices: &dyn Array) -> VortexResult<Option<ArrayRef>>;
+    fn take(array: ArrayView<'_, Self>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
 }
 
 pub trait TakeExecute: VTable {
@@ -45,8 +45,8 @@ pub trait TakeExecute: VTable {
     ///
     /// The indices are guaranteed to be non-empty.
     fn take(
-        array: &Self::Array,
-        indices: &dyn Array,
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
@@ -55,7 +55,7 @@ pub trait TakeExecute: VTable {
 ///
 /// Returns `Some(result)` if the precondition short-circuits the take operation,
 /// or `None` if the take should proceed normally.
-fn precondition<V: VTable>(array: &V::Array, indices: &dyn Array) -> Option<ArrayRef> {
+fn precondition<V: VTable>(array: ArrayView<'_, V>, indices: &ArrayRef) -> Option<ArrayRef> {
     // Fast-path for empty indices.
     if indices.is_empty() {
         let result_dtype = array
@@ -83,12 +83,12 @@ impl<V> ArrayParentReduceRule<V> for TakeReduceAdaptor<V>
 where
     V: TakeReduce,
 {
-    type Parent = DictVTable;
+    type Parent = Dict;
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
-        parent: &DictArray,
+        array: ArrayView<'_, V>,
+        parent: ArrayView<'_, Dict>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // Only handle the values child (index 1), not the codes child (index 0).
@@ -100,7 +100,7 @@ where
         }
         let result = <V as TakeReduce>::take(array, parent.codes())?;
         if let Some(ref taken) = result {
-            propagate_take_stats(&**array, taken.as_ref(), parent.codes())?;
+            propagate_take_stats(array.array(), taken, parent.codes())?;
         }
         Ok(result)
     }
@@ -113,11 +113,11 @@ impl<V> ExecuteParentKernel<V> for TakeExecuteAdaptor<V>
 where
     V: TakeExecute,
 {
-    type Parent = DictVTable;
+    type Parent = Dict;
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -131,16 +131,16 @@ where
         }
         let result = <V as TakeExecute>::take(array, parent.codes(), ctx)?;
         if let Some(ref taken) = result {
-            propagate_take_stats(&**array, taken.as_ref(), parent.codes())?;
+            propagate_take_stats(array.array(), taken, parent.codes())?;
         }
         Ok(result)
     }
 }
 
 pub(crate) fn propagate_take_stats(
-    source: &dyn Array,
-    target: &dyn Array,
-    indices: &dyn Array,
+    source: &ArrayRef,
+    target: &ArrayRef,
+    indices: &ArrayRef,
 ) -> VortexResult<()> {
     target.statistics().with_mut_typed_stats_set(|mut st| {
         if indices.all_valid().unwrap_or(false) {
diff --git a/vortex-array/src/arrays/dict/tests.rs b/vortex-array/src/arrays/dict/tests.rs
index b5fae87ae35..bc69998b0de 100644
--- a/vortex-array/src/arrays/dict/tests.rs
+++ b/vortex-array/src/arrays/dict/tests.rs
@@ -4,7 +4,6 @@
 use vortex_buffer::buffer;
 
 use super::DictArray;
-use crate::Array;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::ListArray;
@@ -16,7 +15,7 @@ use crate::validity::Validity;
 #[test]
 fn test_scalar_at_null_code() {
     let dict = DictArray::try_new(
-        PrimitiveArray::from_option_iter(vec![None, Some(0u32), None]).to_array(),
+        PrimitiveArray::from_option_iter(vec![None, Some(0u32), None]).into_array(),
         buffer![1i32].into_array(),
     )
     .unwrap();
diff --git a/vortex-array/src/arrays/dict/vtable/array.rs b/vortex-array/src/arrays/dict/vtable/array.rs
deleted file mode 100644
index 0773d81f259..00000000000
--- a/vortex-array/src/arrays/dict/vtable/array.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use super::DictVTable;
-use crate::Precision;
-use crate::arrays::dict::DictArray;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<DictVTable> for DictVTable {
-    fn len(array: &DictArray) -> usize {
-        array.codes.len()
-    }
-
-    fn dtype(array: &DictArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &DictArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &DictArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.codes.array_hash(state, precision);
-        array.values.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &DictArray, other: &DictArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.codes.array_eq(&other.codes, precision)
-            && array.values.array_eq(&other.values, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/dict/vtable/kernel.rs b/vortex-array/src/arrays/dict/vtable/kernel.rs
index 4bce59d47c4..fd1b0ed0a6d 100644
--- a/vortex-array/src/arrays/dict/vtable/kernel.rs
+++ b/vortex-array/src/arrays/dict/vtable/kernel.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::DictVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Dict;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::binary::CompareExecuteAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<DictVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(DictVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(DictVTable)),
-    ParentKernelSet::lift(&FillNullExecuteAdaptor(DictVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<Dict> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(Dict)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Dict)),
+    ParentKernelSet::lift(&FillNullExecuteAdaptor(Dict)),
 ]);
diff --git a/vortex-array/src/arrays/dict/vtable/mod.rs b/vortex-array/src/arrays/dict/vtable/mod.rs
index cdf654438a0..b13374b9d8d 100644
--- a/vortex-array/src/arrays/dict/vtable/mod.rs
+++ b/vortex-array/src/arrays/dict/vtable/mod.rs
@@ -1,101 +1,145 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
+
 use kernel::PARENT_KERNELS;
+use prost::Message;
+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_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use super::DictArray;
+use super::DictData;
 use super::DictMetadata;
+use super::array::DictSlots;
+use super::array::DictSlotsView;
 use super::take_canonical;
-use crate::Array;
+use crate::AnyCanonical;
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
-use crate::DeserializeMetadata;
-use crate::IntoArray;
-use crate::ProstMetadata;
-use crate::SerializeMetadata;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ConstantArray;
+use crate::arrays::Primitive;
+use crate::arrays::dict::DictArrayExt;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::arrays::dict::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+use crate::require_child;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
 
-vtable!(Dict);
+/// A [`Dict`]-encoded Vortex array.
+pub type DictArray = Array<Dict>;
 
-#[derive(Debug)]
-pub struct DictVTable;
+#[derive(Clone, Debug)]
+pub struct Dict;
 
-impl DictVTable {
+impl Dict {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.dict");
 }
 
-impl VTable for DictVTable {
-    type Array = DictArray;
+impl ArrayHash for DictData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
 
-    type Metadata = ProstMetadata<DictMetadata>;
+impl ArrayEq for DictData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+
+impl VTable for Dict {
+    type ArrayData = DictData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &DictArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(DictMetadata {
-            codes_ptype: PType::try_from(array.codes().dtype())? as i32,
-            values_len: u32::try_from(array.values().len()).map_err(|_| {
-                vortex_err!(
-                    "Dictionary values size {} overflowed u32",
-                    array.values().len()
-                )
-            })?,
-            is_nullable_codes: Some(array.codes().dtype().is_nullable()),
-            all_values_referenced: Some(array.all_values_referenced),
-        }))
+    fn validate(
+        &self,
+        _data: &DictData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let view = DictSlotsView::from_slots(slots);
+        let codes = view.codes;
+        let values = view.values;
+        vortex_ensure!(codes.len() == len, "DictArray codes length mismatch");
+        vortex_ensure!(
+            values
+                .dtype()
+                .union_nullability(codes.dtype().nullability())
+                == *dtype,
+            "DictArray dtype does not match codes/values dtype"
+        );
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("DictArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let metadata = <Self::Metadata as DeserializeMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(metadata))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            DictMetadata {
+                codes_ptype: PType::try_from(array.codes().dtype())? as i32,
+                values_len: u32::try_from(array.values().len()).map_err(|_| {
+                    vortex_err!(
+                        "Dictionary values size {} overflowed u32",
+                        array.values().len()
+                    )
+                })?,
+                is_nullable_codes: Some(array.codes().dtype().is_nullable()),
+                all_values_referenced: Some(array.has_all_values_referenced()),
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
+
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<DictArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = DictMetadata::decode(metadata)?;
         if children.len() != 2 {
             vortex_bail!(
                 "Expected 2 children for dict encoding, found {}",
@@ -113,49 +157,56 @@ impl VTable for DictVTable {
         let values = children.get(1, dtype, metadata.values_len as usize)?;
         let all_values_referenced = metadata.all_values_referenced.unwrap_or(false);
 
-        // SAFETY: We've validated the metadata and children.
-        Ok(unsafe {
-            DictArray::new_unchecked(codes, values).set_all_values_referenced(all_values_referenced)
-        })
+        Ok(
+            crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, unsafe {
+                DictData::new_unchecked().set_all_values_referenced(all_values_referenced)
+            })
+            .with_slots(vec![Some(codes), Some(values)]),
+        )
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 2,
-            "DictArray expects exactly 2 children (codes, values), got {}",
-            children.len()
-        );
-        let [codes, values]: [ArrayRef; 2] = children
-            .try_into()
-            .map_err(|_| vortex_err!("Failed to convert children to array"))?;
-        array.codes = codes;
-        array.values = values;
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        DictSlots::NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        if let Some(canonical) = execute_fast_path(array, ctx)? {
-            return Ok(canonical);
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        if array.is_empty() {
+            let result_dtype = array
+                .dtype()
+                .union_nullability(array.codes().dtype().nullability());
+            return Ok(ExecutionResult::done(Canonical::empty(&result_dtype)));
         }
 
-        // TODO(joe): if the values are constant return a constant
-        let values = array.values().clone().execute::<Canonical>(ctx)?;
+        let array = require_child!(array, array.codes(), DictSlots::CODES => Primitive);
+
+        // TODO(joe): use stat get instead computing.
+        // Also not the check to do here it take value validity using code validity, but this approx
+        // is correct.
+        if array.codes().all_invalid()? {
+            return Ok(ExecutionResult::done(ConstantArray::new(
+                Scalar::null(array.dtype().as_nullable()),
+                array.codes().len(),
+            )));
+        }
+
+        let array = require_child!(array, array.values(), DictSlots::VALUES => AnyCanonical);
+
         let codes = array
             .codes()
             .clone()
-            .execute::<Canonical>(ctx)?
-            .into_primitive();
-
-        // TODO(ngates): if indices are sorted and unique (strict-sorted), then we should delegate to
-        //  the filter function since they're typically optimised for this case.
-        // TODO(ngates): if indices min is quite high, we could slice self and offset the indices
-        //  such that canonicalize does less work.
-
-        Ok(take_canonical(values, &codes, ctx)?.into_array())
+            .try_downcast::<Primitive>()
+            .ok()
+            .vortex_expect("must be primitive");
+        let values = array.values().clone();
+        debug_assert!(values.is_canonical());
+        // TODO: add canonical owned cast.
+        let values = values.to_canonical()?;
+
+        Ok(ExecutionResult::done(take_canonical(values, &codes, ctx)?))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -163,7 +214,7 @@ impl VTable for DictVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -171,27 +222,3 @@ impl VTable for DictVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 }
-
-/// Check for fast-path execution conditions.
-pub(super) fn execute_fast_path(
-    array: &DictArray,
-    _ctx: &mut ExecutionCtx,
-) -> VortexResult<Option<ArrayRef>> {
-    // Empty array - nothing to do
-    if array.is_empty() {
-        let result_dtype = array
-            .dtype()
-            .union_nullability(array.codes().dtype().nullability());
-        return Ok(Some(Canonical::empty(&result_dtype).into_array()));
-    }
-
-    // All codes are null - result is all nulls
-    if array.codes.all_invalid()? {
-        return Ok(Some(
-            ConstantArray::new(Scalar::null(array.dtype().as_nullable()), array.codes.len())
-                .into_array(),
-        ));
-    }
-
-    Ok(None)
-}
diff --git a/vortex-array/src/arrays/dict/vtable/operations.rs b/vortex-array/src/arrays/dict/vtable/operations.rs
index edfbd408165..9c75e4f2924 100644
--- a/vortex-array/src/arrays/dict/vtable/operations.rs
+++ b/vortex-array/src/arrays/dict/vtable/operations.rs
@@ -4,14 +4,19 @@
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use super::DictVTable;
-use crate::Array;
-use crate::arrays::dict::DictArray;
+use super::Dict;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<DictVTable> for DictVTable {
-    fn scalar_at(array: &DictArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Dict> for Dict {
+    fn scalar_at(
+        array: ArrayView<'_, Dict>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let Some(dict_index) = array
             .codes()
             .scalar_at(index)?
diff --git a/vortex-array/src/arrays/dict/vtable/validity.rs b/vortex-array/src/arrays/dict/vtable/validity.rs
index 838d66aae36..471f429b86b 100644
--- a/vortex-array/src/arrays/dict/vtable/validity.rs
+++ b/vortex-array/src/arrays/dict/vtable/validity.rs
@@ -3,18 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use super::DictVTable;
-use crate::Array;
+use super::Dict;
 use crate::IntoArray;
-use crate::arrays::dict::DictArray;
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::DictArray;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::Nullability;
 use crate::scalar::Scalar;
 use crate::validity::Validity;
-use crate::vtable::ValidityVTable;
 
-impl ValidityVTable<DictVTable> for DictVTable {
-    fn validity(array: &DictArray) -> VortexResult<Validity> {
+impl ValidityVTable<Dict> for Dict {
+    fn validity(array: ArrayView<'_, Dict>) -> VortexResult<Validity> {
         Ok(
             match (array.codes().validity()?, array.values().validity()?) {
                 (
diff --git a/vortex-array/src/arrays/dict/vtable/visitor.rs b/vortex-array/src/arrays/dict/vtable/visitor.rs
deleted file mode 100644
index 1d958c4d514..00000000000
--- a/vortex-array/src/arrays/dict/vtable/visitor.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use super::DictVTable;
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::dict::DictArray;
-use crate::vtable::VisitorVTable;
-
-impl VisitorVTable<DictVTable> for DictVTable {
-    fn visit_buffers(_array: &DictArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &DictArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &DictArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("codes", array.codes());
-        visitor.visit_child("values", array.values());
-    }
-
-    fn nchildren(_array: &DictArray) -> usize {
-        2
-    }
-
-    fn nth_child(array: &DictArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.codes().clone()),
-            1 => Some(array.values().clone()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/dict_test.rs b/vortex-array/src/arrays/dict_test.rs
index e042c303160..8402b66c670 100644
--- a/vortex-array/src/arrays/dict_test.rs
+++ b/vortex-array/src/arrays/dict_test.rs
@@ -3,7 +3,7 @@
 
 #![allow(clippy::unwrap_used)]
 
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Alphanumeric;
 use rand::distr::Distribution;
@@ -14,11 +14,11 @@ use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use super::ChunkedArray;
-use super::DictArray;
-use super::PrimitiveArray;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::ChunkedArray;
+use crate::arrays::DictArray;
+use crate::arrays::PrimitiveArray;
 use crate::dtype::NativePType;
 use crate::validity::Validity;
 
diff --git a/vortex-array/src/arrays/extension/array.rs b/vortex-array/src/arrays/extension/array.rs
index 8df5963a5e9..4ff2ad1bcfb 100644
--- a/vortex-array/src/arrays/extension/array.rs
+++ b/vortex-array/src/arrays/extension/array.rs
@@ -1,11 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
 use crate::ArrayRef;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Extension;
 use crate::dtype::DType;
 use crate::dtype::extension::ExtDTypeRef;
-use crate::dtype::extension::ExtId;
-use crate::stats::ArrayStats;
+
+/// The backing storage array for this extension array.
+pub(super) const STORAGE_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["storage"];
 
 /// An extension array that wraps another array with additional type information.
 ///
@@ -46,39 +59,108 @@ use crate::stats::ArrayStats;
 /// - Slicing preserves the extension type
 /// - Scalar access wraps storage scalars with extension metadata
 #[derive(Clone, Debug)]
-pub struct ExtensionArray {
-    pub(super) dtype: DType,
-    pub(super) storage: ArrayRef,
-    pub(super) stats_set: ArrayStats,
+pub struct ExtensionData {
+    /// The storage dtype. This **must** be a [`Extension::DType`] variant.
+    pub(super) ext_dtype: ExtDTypeRef,
+}
+
+impl Display for ExtensionData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ext_dtype: {}", self.ext_dtype)
+    }
 }
 
-impl ExtensionArray {
-    pub fn new(ext_dtype: ExtDTypeRef, storage: ArrayRef) -> Self {
+impl ExtensionData {
+    /// Constructs a new `ExtensionArray`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the storage array in not compatible with the extension dtype.
+    pub fn new(ext_dtype: ExtDTypeRef, storage_dtype: &DType) -> Self {
+        Self::try_new(ext_dtype, storage_dtype).vortex_expect("Failed to create `ExtensionArray`")
+    }
+
+    /// Tries to construct a new `ExtensionArray`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the storage array in not compatible with the extension dtype.
+    pub fn try_new(ext_dtype: ExtDTypeRef, storage_dtype: &DType) -> VortexResult<Self> {
+        // TODO(connor): Replace these statements once we add `validate_storage_array`.
+        // ext_dtype.validate_storage_array(&storage_array)?;
         assert_eq!(
             ext_dtype.storage_dtype(),
-            storage.dtype(),
+            storage_dtype,
             "ExtensionArray: storage_dtype must match storage array DType",
         );
-        Self {
-            dtype: DType::Extension(ext_dtype),
-            storage,
-            stats_set: ArrayStats::default(),
-        }
+
+        // SAFETY: we validate that the inputs are valid above.
+        Ok(unsafe { Self::new_unchecked(ext_dtype, storage_dtype) })
     }
 
+    /// Creates a new `ExtensionArray`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the storage array is compatible with the extension dtype. In
+    /// other words, they must know that `ext_dtype.validate_storage_array(&storage_array)` has been
+    /// called successfully on this storage array.
+    pub unsafe fn new_unchecked(ext_dtype: ExtDTypeRef, storage_dtype: &DType) -> Self {
+        // TODO(connor): Replace these statements once we add `validate_storage_array`.
+        // #[cfg(debug_assertions)]
+        // ext_dtype
+        //     .validate_storage_array(&storage_array)
+        //     .vortex_expect("[Debug Assertion]: Invalid storage array for `ExtensionArray`");
+        debug_assert_eq!(
+            ext_dtype.storage_dtype(),
+            storage_dtype,
+            "ExtensionArray: storage_dtype must match storage array DType",
+        );
+
+        Self { ext_dtype }
+    }
+
+    /// The extension dtype of this array.
     pub fn ext_dtype(&self) -> &ExtDTypeRef {
-        let DType::Extension(ext) = &self.dtype else {
-            unreachable!("ExtensionArray: dtype must be an ExtDType")
-        };
-        ext
+        &self.ext_dtype
     }
+}
 
-    pub fn storage(&self) -> &ArrayRef {
-        &self.storage
+pub trait ExtensionArrayExt: TypedArrayRef<Extension> {
+    fn storage_array(&self) -> &ArrayRef {
+        self.as_ref().slots()[STORAGE_SLOT]
+            .as_ref()
+            .vortex_expect("ExtensionArray storage slot")
+    }
+}
+impl<T: TypedArrayRef<Extension>> ExtensionArrayExt for T {}
+
+impl Array<Extension> {
+    /// Constructs a new `ExtensionArray`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the storage array is not compatible with the extension dtype.
+    pub fn new(ext_dtype: ExtDTypeRef, storage_array: ArrayRef) -> Self {
+        let dtype = DType::Extension(ext_dtype.clone());
+        let len = storage_array.len();
+        let data = ExtensionData::new(ext_dtype, storage_array.dtype());
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Extension, dtype, len, data).with_slots(vec![Some(storage_array)]),
+            )
+        }
     }
 
-    #[inline]
-    pub fn id(&self) -> ExtId {
-        self.ext_dtype().id()
+    /// Tries to construct a new `ExtensionArray`.
+    pub fn try_new(ext_dtype: ExtDTypeRef, storage_array: ArrayRef) -> VortexResult<Self> {
+        let dtype = DType::Extension(ext_dtype.clone());
+        let len = storage_array.len();
+        let data = ExtensionData::try_new(ext_dtype, storage_array.dtype())?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Extension, dtype, len, data).with_slots(vec![Some(storage_array)]),
+            )
+        })
     }
 }
diff --git a/vortex-array/src/arrays/extension/compute/cast.rs b/vortex-array/src/arrays/extension/compute/cast.rs
index c6cb284a4ec..aa0394c73a3 100644
--- a/vortex-array/src/arrays/extension/compute/cast.rs
+++ b/vortex-array/src/arrays/extension/compute/cast.rs
@@ -9,9 +9,11 @@ use vortex_mask::AllOr;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::PType;
@@ -19,17 +21,16 @@ use crate::extension::datetime::AnyTemporal;
 use crate::extension::datetime::TemporalMetadata;
 use crate::extension::datetime::TimeUnit;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for ExtensionVTable {
-    fn cast(array: &ExtensionArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for Extension {
+    fn cast(array: ArrayView<'_, Extension>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         let DType::Extension(ext_dtype) = dtype else {
             return Ok(None);
         };
 
         if array.ext_dtype().eq_ignore_nullability(ext_dtype) {
             let new_storage = match array
-                .storage()
+                .storage_array()
                 .cast(ext_dtype.storage_dtype().clone())
                 .and_then(|a| a.to_canonical().map(|c| c.into_array()))
             {
@@ -45,7 +46,7 @@ impl CastReduce for ExtensionVTable {
             ));
         }
 
-        if let Some(new_storage) = cast_temporal_date_to_timestamp(array, dtype)? {
+        if let Some(new_storage) = cast_temporal_date_to_timestamp(&array, dtype)? {
             return Ok(Some(
                 ExtensionArray::new(ext_dtype.clone(), new_storage).into_array(),
             ));
@@ -56,7 +57,7 @@ impl CastReduce for ExtensionVTable {
 }
 
 fn cast_temporal_date_to_timestamp(
-    array: &ExtensionArray,
+    array: &ArrayView<'_, Extension>,
     target_dtype: &DType,
 ) -> VortexResult<Option<ArrayRef>> {
     let DType::Extension(target_ext_dtype) = target_dtype else {
@@ -77,14 +78,14 @@ fn cast_temporal_date_to_timestamp(
     };
 
     let source_i64 = array
-        .storage()
+        .storage_array()
         .cast(DType::Primitive(PType::I64, array.dtype().nullability()))?;
     let source_i64 = source_i64.to_primitive();
 
     let converted = cast_date_values_to_timestamp(&source_i64, *source_unit, *target_unit)?;
 
     converted
-        .to_array()
+        .into_array()
         .cast(target_ext_dtype.storage_dtype().clone())
         .map(Some)
 }
@@ -126,10 +127,7 @@ fn cast_date_values_to_timestamp(
         }
     }
 
-    Ok(PrimitiveArray::new(
-        output.freeze(),
-        values.validity().clone(),
-    ))
+    Ok(PrimitiveArray::new(output.freeze(), values.validity()?))
 }
 
 fn date_to_timestamp_scale(
@@ -193,7 +191,6 @@ mod tests {
     use vortex_buffer::buffer;
 
     use super::*;
-    use crate::Array;
     use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
     use crate::builtins::ArrayBuiltins;
@@ -211,7 +208,8 @@ mod tests {
         let arr = ExtensionArray::new(ext_dtype.clone(), storage);
 
         let output = arr
-            .to_array()
+            .clone()
+            .into_array()
             .cast(DType::Extension(ext_dtype.clone()))
             .unwrap();
         assert_eq!(arr.len(), output.len());
@@ -225,11 +223,11 @@ mod tests {
         let storage = Buffer::<i64>::empty().into_array();
 
         let arr = ExtensionArray::new(ext_dtype.clone(), storage);
-        assert!(!arr.dtype.is_nullable());
+        assert!(!arr.dtype().is_nullable());
 
         let new_dtype = DType::Extension(ext_dtype).with_nullability(Nullability::Nullable);
 
-        let output = arr.to_array().cast(new_dtype.clone()).unwrap();
+        let output = arr.clone().into_array().cast(new_dtype.clone()).unwrap();
         assert_eq!(arr.len(), output.len());
         assert!(arr.dtype().eq_ignore_nullability(output.dtype()));
         assert_eq!(output.dtype(), &new_dtype);
@@ -242,14 +240,14 @@ mod tests {
 
         let arr = ExtensionArray::new(source_dtype, buffer![0i32, 1, -1].into_array());
         let output = arr
-            .to_array()
+            .into_array()
             .cast(DType::Extension(target_dtype.clone()))
             .unwrap()
             .to_extension();
 
         assert_eq!(output.dtype(), &DType::Extension(target_dtype));
 
-        let storage = output.storage().to_primitive();
+        let storage = output.storage_array().to_primitive();
         assert_eq!(
             storage.as_slice::<i64>(),
             &[0, 86_400_000_000_000, -86_400_000_000_000]
@@ -267,14 +265,14 @@ mod tests {
         );
 
         let output = arr
-            .to_array()
+            .into_array()
             .cast(DType::Extension(target_dtype.clone()))
             .unwrap()
             .to_extension();
 
         assert_eq!(output.dtype(), &DType::Extension(target_dtype));
 
-        let storage = output.storage().to_primitive();
+        let storage = output.storage_array().to_primitive();
         assert_eq!(
             storage.scalar_at(0).unwrap().as_primitive().as_::<i64>(),
             Some(0)
@@ -297,7 +295,7 @@ mod tests {
         let arr = ExtensionArray::new(original_dtype, storage);
 
         assert!(
-            arr.to_array()
+            arr.into_array()
                 .cast(DType::Extension(target_dtype))
                 .and_then(|a| a.to_canonical().map(|c| c.into_array()))
                 .is_err()
@@ -310,7 +308,7 @@ mod tests {
     #[case(create_timestamp_array(TimeUnit::Nanoseconds, false))]
     #[case(create_timestamp_array(TimeUnit::Seconds, true))]
     fn test_cast_extension_conformance(#[case] array: ExtensionArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     fn create_timestamp_array(time_unit: TimeUnit, nullable: bool) -> ExtensionArray {
diff --git a/vortex-array/src/arrays/extension/compute/compare.rs b/vortex-array/src/arrays/extension/compute/compare.rs
index 9f7edeb0f91..ecd6bbd5614 100644
--- a/vortex-array/src/arrays/extension/compute/compare.rs
+++ b/vortex-array/src/arrays/extension/compute/compare.rs
@@ -3,21 +3,22 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
-use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
+use crate::arrays::Extension;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar_fn::fns::binary::CompareKernel;
 use crate::scalar_fn::fns::operators::CompareOperator;
 use crate::scalar_fn::fns::operators::Operator;
 
-impl CompareKernel for ExtensionVTable {
+impl CompareKernel for Extension {
     fn compare(
-        lhs: &ExtensionArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Extension>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -25,21 +26,21 @@ impl CompareKernel for ExtensionVTable {
         if let Some(const_ext) = rhs.as_constant() {
             let storage_scalar = const_ext.as_extension().to_storage_scalar();
             return lhs
-                .storage()
-                .to_array()
+                .storage_array()
+                .clone()
                 .binary(
-                    ConstantArray::new(storage_scalar, lhs.len()).to_array(),
+                    ConstantArray::new(storage_scalar, lhs.len()).into_array(),
                     Operator::from(operator),
                 )
                 .map(Some);
         }
 
         // If the RHS is an extension array matching ours, we can extract the storage.
-        if let Some(rhs_ext) = rhs.as_opt::<ExtensionVTable>() {
+        if let Some(rhs_ext) = rhs.as_opt::<Extension>() {
             return lhs
-                .storage()
-                .to_array()
-                .binary(rhs_ext.storage().to_array(), Operator::from(operator))
+                .storage_array()
+                .clone()
+                .binary(rhs_ext.storage_array().clone(), Operator::from(operator))
                 .map(Some);
         }
 
diff --git a/vortex-array/src/arrays/extension/compute/filter.rs b/vortex-array/src/arrays/extension/compute/filter.rs
index bd5b668ffe9..1a9ffe499c5 100644
--- a/vortex-array/src/arrays/extension/compute/filter.rs
+++ b/vortex-array/src/arrays/extension/compute/filter.rs
@@ -6,16 +6,18 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::arrays::filter::FilterReduce;
 
-impl FilterReduce for ExtensionVTable {
-    fn filter(array: &ExtensionArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for Extension {
+    fn filter(array: ArrayView<'_, Extension>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             ExtensionArray::new(
                 array.ext_dtype().clone(),
-                array.storage().filter(mask.clone())?,
+                array.storage_array().filter(mask.clone())?,
             )
             .into_array(),
         ))
diff --git a/vortex-array/src/arrays/extension/compute/is_constant.rs b/vortex-array/src/arrays/extension/compute/is_constant.rs
deleted file mode 100644
index d65bb34a978..00000000000
--- a/vortex-array/src/arrays/extension/compute/is_constant.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::{self};
-use crate::register_kernel;
-
-impl IsConstantKernel for ExtensionVTable {
-    fn is_constant(
-        &self,
-        array: &ExtensionArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        compute::is_constant_opts(array.storage(), opts)
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(ExtensionVTable).lift());
diff --git a/vortex-array/src/arrays/extension/compute/is_sorted.rs b/vortex-array/src/arrays/extension/compute/is_sorted.rs
deleted file mode 100644
index e25850551ba..00000000000
--- a/vortex-array/src/arrays/extension/compute/is_sorted.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::compute::{self};
-use crate::register_kernel;
-
-impl IsSortedKernel for ExtensionVTable {
-    fn is_sorted(&self, array: &ExtensionArray) -> VortexResult<Option<bool>> {
-        compute::is_sorted(array.storage())
-    }
-
-    fn is_strict_sorted(&self, array: &ExtensionArray) -> VortexResult<Option<bool>> {
-        compute::is_strict_sorted(array.storage())
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(ExtensionVTable).lift());
diff --git a/vortex-array/src/arrays/extension/compute/mask.rs b/vortex-array/src/arrays/extension/compute/mask.rs
index ae73d13e5b4..817df8d7fc8 100644
--- a/vortex-array/src/arrays/extension/compute/mask.rs
+++ b/vortex-array/src/arrays/extension/compute/mask.rs
@@ -5,19 +5,21 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::scalar_fn::EmptyOptions;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
 use crate::scalar_fn::fns::mask::MaskReduce;
 
-impl MaskReduce for ExtensionVTable {
-    fn mask(array: &ExtensionArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Extension {
+    fn mask(array: ArrayView<'_, Extension>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let masked_storage = MaskExpr.try_new_array(
-            array.storage().len(),
+            array.storage_array().len(),
             EmptyOptions,
-            [array.storage().clone(), mask.clone()],
+            [array.storage_array().clone(), mask.clone()],
         )?;
         Ok(Some(
             ExtensionArray::new(
diff --git a/vortex-array/src/arrays/extension/compute/min_max.rs b/vortex-array/src/arrays/extension/compute/min_max.rs
deleted file mode 100644
index 3835e67a810..00000000000
--- a/vortex-array/src/arrays/extension/compute/min_max.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::compute::{self};
-use crate::dtype::Nullability;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl MinMaxKernel for ExtensionVTable {
-    fn min_max(&self, array: &ExtensionArray) -> VortexResult<Option<MinMaxResult>> {
-        let non_nullable_ext_dtype = array.ext_dtype().with_nullability(Nullability::NonNullable);
-        Ok(
-            compute::min_max(array.storage())?.map(|MinMaxResult { min, max }| MinMaxResult {
-                min: Scalar::extension_ref(non_nullable_ext_dtype.clone(), min),
-                max: Scalar::extension_ref(non_nullable_ext_dtype, max),
-            }),
-        )
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(ExtensionVTable).lift());
diff --git a/vortex-array/src/arrays/extension/compute/mod.rs b/vortex-array/src/arrays/extension/compute/mod.rs
index 81f5f0f5668..ce25ab2c0ea 100644
--- a/vortex-array/src/arrays/extension/compute/mod.rs
+++ b/vortex-array/src/arrays/extension/compute/mod.rs
@@ -4,13 +4,9 @@
 mod cast;
 mod compare;
 mod filter;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
-mod sum;
 mod take;
 
 #[cfg(test)]
@@ -35,14 +31,14 @@ mod test {
         // Create storage array
         let storage = buffer![1i32, 2, 3, 4, 5].into_array();
         let array = ExtensionArray::new(ext_dtype.clone(), storage);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
 
         // Test with nullable extension type
         let ext_dtype_nullable = ext_dtype.with_nullability(Nullability::Nullable);
         let storage = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None])
             .into_array();
         let array = ExtensionArray::new(ext_dtype_nullable, storage);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[rstest]
@@ -81,7 +77,7 @@ mod test {
         ExtensionArray::new(ext_dtype_large, storage)
     })]
     fn test_take_extension_array_conformance(#[case] array: ExtensionArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
 
@@ -112,18 +108,12 @@ mod tests {
         let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::Nullable).erased();
         ExtensionArray::new(ext_dtype, storage)
     })]
-    // Additional test cases
-    #[case::extension_single({
-        let storage = buffer![42i64].into_array();
-        let ext_dtype = Timestamp::new(TimeUnit::Days, Nullability::NonNullable).erased();
-        ExtensionArray::new(ext_dtype, storage)
-    })]
     #[case::extension_large({
         let storage = buffer![0..100i64].into_array();
         let ext_dtype = Timestamp::new(TimeUnit::Milliseconds, Nullability::NonNullable).erased();
         ExtensionArray::new(ext_dtype, storage)
     })]
     fn test_extension_consistency(#[case] array: ExtensionArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/extension/compute/rules.rs b/vortex-array/src/arrays/extension/compute/rules.rs
index ee3b49201cb..af1cbc832b9 100644
--- a/vortex-array/src/arrays/extension/compute/rules.rs
+++ b/vortex-array/src/arrays/extension/compute/rules.rs
@@ -5,41 +5,42 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterReduceAdaptor;
-use crate::arrays::FilterVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Filter;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<ExtensionVTable> = ParentRuleSet::new(&[
+pub(crate) const PARENT_RULES: ParentRuleSet<Extension> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&ExtensionFilterPushDownRule),
-    ParentRuleSet::lift(&CastReduceAdaptor(ExtensionVTable)),
-    ParentRuleSet::lift(&FilterReduceAdaptor(ExtensionVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ExtensionVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ExtensionVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Extension)),
+    ParentRuleSet::lift(&FilterReduceAdaptor(Extension)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Extension)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Extension)),
 ]);
 
 /// Push filter operations into the storage array of an extension array.
 #[derive(Debug)]
 struct ExtensionFilterPushDownRule;
 
-impl ArrayParentReduceRule<ExtensionVTable> for ExtensionFilterPushDownRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<Extension> for ExtensionFilterPushDownRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &ExtensionArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, Extension>,
+        parent: ArrayView<'_, Filter>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         debug_assert_eq!(child_idx, 0);
         let filtered_storage = child
-            .storage()
+            .storage_array()
             .clone()
             .filter(parent.filter_mask().clone())?;
         Ok(Some(
@@ -54,15 +55,16 @@ mod tests {
     use vortex_error::VortexResult;
     use vortex_mask::Mask;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::ConstantArray;
+    use crate::arrays::Extension;
     use crate::arrays::ExtensionArray;
-    use crate::arrays::ExtensionVTable;
     use crate::arrays::FilterArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::ScalarFnArrayExt;
+    use crate::arrays::extension::ExtensionArrayExt;
+    use crate::arrays::scalar_fn::ScalarFnArrayExt;
+    use crate::arrays::scalar_fn::ScalarFnFactoryExt;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -95,18 +97,12 @@ mod tests {
             Ok(EmptyMetadata)
         }
 
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
+        fn validate_dtype(_extension_dtype: &ExtDType<Self>) -> VortexResult<()> {
             Ok(())
         }
 
         fn unpack_native<'a>(
-            &self,
-            _metadata: &'a Self::Metadata,
-            _storage_dtype: &'a DType,
+            _extension_dtype: &'a ExtDType<Self>,
             _storage_value: &'a ScalarValue,
         ) -> VortexResult<Self::NativeValue<'a>> {
             Ok("")
@@ -137,17 +133,17 @@ mod tests {
 
         // The result should be an ExtensionArray, not a FilterArray
         assert!(
-            optimized.as_opt::<ExtensionVTable>().is_some(),
+            optimized.as_opt::<Extension>().is_some(),
             "Expected ExtensionArray after optimization, got {}",
             optimized.encoding_id()
         );
 
-        let ext_result = optimized.as_::<ExtensionVTable>();
+        let ext_result = optimized.as_::<Extension>();
         assert_eq!(ext_result.len(), 3);
         assert_eq!(ext_result.ext_dtype(), &ext_dtype);
 
         // Check the storage values
-        let storage_result: &[i64] = &ext_result.storage().to_primitive().to_buffer::<i64>();
+        let storage_result: &[i64] = &ext_result.storage_array().to_primitive().to_buffer::<i64>();
         assert_eq!(storage_result, &[1, 3, 5]);
     }
 
@@ -168,12 +164,12 @@ mod tests {
 
         let optimized = filter_array.optimize().unwrap();
 
-        assert!(optimized.as_opt::<ExtensionVTable>().is_some());
-        let ext_result = optimized.as_::<ExtensionVTable>();
+        assert!(optimized.as_opt::<Extension>().is_some());
+        let ext_result = optimized.as_::<Extension>();
         assert_eq!(ext_result.len(), 3);
 
         // Check values: should be [Some(1), None, None]
-        let canonical = ext_result.storage().to_primitive();
+        let canonical = ext_result.storage_array().to_primitive();
         assert_eq!(canonical.len(), 3);
     }
 
@@ -197,18 +193,12 @@ mod tests {
                 Ok(EmptyMetadata)
             }
 
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
+            fn validate_dtype(_extension_dtype: &ExtDType<Self>) -> VortexResult<()> {
                 Ok(())
             }
 
             fn unpack_native<'a>(
-                &self,
-                _metadata: &'a Self::Metadata,
-                _storage_dtype: &'a DType,
+                _extension_dtype: &'a ExtDType<Self>,
                 _storage_value: &'a ScalarValue,
             ) -> VortexResult<Self::NativeValue<'a>> {
                 Ok("")
@@ -230,7 +220,7 @@ mod tests {
         let const_array = ConstantArray::new(const_scalar, 3).into_array();
 
         let scalar_fn_array = Binary
-            .try_new_array(3, Operator::Lt, [ext_array.clone(), const_array])
+            .try_new_array(3, Operator::Lt, [ext_array, const_array])
             .unwrap();
 
         let optimized = scalar_fn_array.optimize().unwrap();
@@ -238,9 +228,7 @@ mod tests {
         // The first child should still be an ExtensionArray (no pushdown happened)
         let scalar_fn = optimized.as_opt::<crate::arrays::ScalarFnVTable>().unwrap();
         assert!(
-            scalar_fn.children()[0]
-                .as_opt::<ExtensionVTable>()
-                .is_some(),
+            scalar_fn.children()[0].as_opt::<Extension>().is_some(),
             "Expected first child to remain ExtensionArray when ext types differ"
         );
     }
@@ -257,7 +245,7 @@ mod tests {
 
         // Both children are extension arrays (not constants)
         let scalar_fn_array = Binary
-            .try_new_array(3, Operator::Lt, [ext_array1.clone(), ext_array2])
+            .try_new_array(3, Operator::Lt, [ext_array1, ext_array2])
             .unwrap();
 
         let optimized = scalar_fn_array.optimize().unwrap();
@@ -265,9 +253,7 @@ mod tests {
         // No pushdown should happen because sibling is not a constant
         let scalar_fn = optimized.as_opt::<crate::arrays::ScalarFnVTable>().unwrap();
         assert!(
-            scalar_fn.children()[0]
-                .as_opt::<ExtensionVTable>()
-                .is_some(),
+            scalar_fn.children()[0].as_opt::<Extension>().is_some(),
             "Expected first child to remain ExtensionArray when sibling is not constant"
         );
     }
@@ -282,7 +268,7 @@ mod tests {
         let const_array = ConstantArray::new(Scalar::from(25i64), 3).into_array();
 
         let scalar_fn_array = Binary
-            .try_new_array(3, Operator::Lt, [ext_array.clone(), const_array])
+            .try_new_array(3, Operator::Lt, [ext_array, const_array])
             .unwrap();
 
         let optimized = scalar_fn_array.optimize().unwrap();
@@ -290,9 +276,7 @@ mod tests {
         // No pushdown should happen because constant is not an extension scalar
         let scalar_fn = optimized.as_opt::<crate::arrays::ScalarFnVTable>().unwrap();
         assert!(
-            scalar_fn.children()[0]
-                .as_opt::<ExtensionVTable>()
-                .is_some(),
+            scalar_fn.children()[0].as_opt::<Extension>().is_some(),
             "Expected first child to remain ExtensionArray when constant is not extension"
         );
     }
diff --git a/vortex-array/src/arrays/extension/compute/slice.rs b/vortex-array/src/arrays/extension/compute/slice.rs
index 46d9857962d..3b5e4b707ff 100644
--- a/vortex-array/src/arrays/extension/compute/slice.rs
+++ b/vortex-array/src/arrays/extension/compute/slice.rs
@@ -7,15 +7,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for ExtensionVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Extension {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            ExtensionArray::new(array.ext_dtype().clone(), array.storage().slice(range)?)
-                .into_array(),
+            ExtensionArray::new(
+                array.ext_dtype().clone(),
+                array.storage_array().slice(range)?,
+            )
+            .into_array(),
         ))
     }
 }
diff --git a/vortex-array/src/arrays/extension/compute/sum.rs b/vortex-array/src/arrays/extension/compute/sum.rs
deleted file mode 100644
index a0b8a72bc06..00000000000
--- a/vortex-array/src/arrays/extension/compute/sum.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::compute::{self};
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl SumKernel for ExtensionVTable {
-    fn sum(&self, array: &ExtensionArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        compute::sum_with_accumulator(array.storage(), accumulator)
-    }
-}
-
-register_kernel!(SumKernelAdapter(ExtensionVTable).lift());
diff --git a/vortex-array/src/arrays/extension/compute/take.rs b/vortex-array/src/arrays/extension/compute/take.rs
index aa53205a5b1..8fb0da11222 100644
--- a/vortex-array/src/arrays/extension/compute/take.rs
+++ b/vortex-array/src/arrays/extension/compute/take.rs
@@ -3,21 +3,22 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::extension::ExtensionArrayExt;
 
-impl TakeExecute for ExtensionVTable {
+impl TakeExecute for Extension {
     fn take(
-        array: &ExtensionArray,
-        indices: &dyn Array,
+        array: ArrayView<'_, Extension>,
+        indices: &ArrayRef,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let taken_storage = array.storage().take(indices.to_array())?;
+        let taken_storage = array.storage_array().take(indices.clone())?;
         Ok(Some(
             ExtensionArray::new(
                 array
diff --git a/vortex-array/src/arrays/extension/mod.rs b/vortex-array/src/arrays/extension/mod.rs
index 6b6f8c5f000..802545025c1 100644
--- a/vortex-array/src/arrays/extension/mod.rs
+++ b/vortex-array/src/arrays/extension/mod.rs
@@ -2,9 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::ExtensionArray;
+pub use array::ExtensionArrayExt;
+pub use array::ExtensionData;
+pub use vtable::ExtensionArray;
 
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::ExtensionVTable;
+pub use vtable::Extension;
diff --git a/vortex-array/src/arrays/extension/vtable/array.rs b/vortex-array/src/arrays/extension/vtable/array.rs
deleted file mode 100644
index 62e000a5efd..00000000000
--- a/vortex-array/src/arrays/extension/vtable/array.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::extension::ExtensionArray;
-use crate::arrays::extension::ExtensionVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ExtensionVTable> for ExtensionVTable {
-    fn len(array: &ExtensionArray) -> usize {
-        array.storage.len()
-    }
-
-    fn dtype(array: &ExtensionArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ExtensionArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &ExtensionArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.storage.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &ExtensionArray, other: &ExtensionArray, precision: Precision) -> bool {
-        array.dtype == other.dtype && array.storage.array_eq(&other.storage, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/extension/vtable/kernel.rs b/vortex-array/src/arrays/extension/vtable/kernel.rs
index 7b45ec8f713..4cc5f9eb4ac 100644
--- a/vortex-array/src/arrays/extension/vtable/kernel.rs
+++ b/vortex-array/src/arrays/extension/vtable/kernel.rs
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::ExtensionVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Extension;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::binary::CompareExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<ExtensionVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(ExtensionVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ExtensionVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<Extension> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(Extension)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Extension)),
 ]);
diff --git a/vortex-array/src/arrays/extension/vtable/mod.rs b/vortex-array/src/arrays/extension/vtable/mod.rs
index 2a72b09dc36..ba403403dbe 100644
--- a/vortex-array/src/arrays/extension/vtable/mod.rs
+++ b/vortex-array/src/arrays/extension/vtable/mod.rs
@@ -1,74 +1,130 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-mod array;
 mod canonical;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
+
+use std::hash::Hasher;
 
 use kernel::PARENT_KERNELS;
 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 crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::arrays::extension::ExtensionArray;
+use crate::ExecutionResult;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::array::ValidityVTableFromChild;
+use crate::arrays::extension::ExtensionData;
+use crate::arrays::extension::array::SLOT_NAMES;
+use crate::arrays::extension::array::STORAGE_SLOT;
 use crate::arrays::extension::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::serde::ArrayChildren;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromChild;
 
-vtable!(Extension);
+/// A [`Extension`]-encoded Vortex array.
+pub type ExtensionArray = Array<Extension>;
 
-impl VTable for ExtensionVTable {
-    type Array = ExtensionArray;
+impl ArrayHash for ExtensionData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
 
-    type Metadata = EmptyMetadata;
+impl ArrayEq for ExtensionData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+
+impl VTable for Extension {
+    type ArrayData = ExtensionData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = ValidityVTableFromChild;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &ExtensionArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ExtensionArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
+    }
+
+    fn validate(
+        &self,
+        data: &ExtensionData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        _ = data;
+        let storage = slots[STORAGE_SLOT]
+            .as_ref()
+            .vortex_expect("ExtensionArray storage slot");
+        vortex_ensure!(
+            storage.len() == len,
+            "ExtensionArray length {} does not match outer length {}",
+            storage.len(),
+            len
+        );
+
+        let actual_dtype = DType::Extension(data.ext_dtype.clone());
+        vortex_ensure!(
+            &actual_dtype == dtype,
+            "ExtensionArray dtype {} does not match outer dtype {}",
+            actual_dtype,
+            dtype
+        );
+
+        Ok(())
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ExtensionArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "ExtensionArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         let DType::Extension(ext_dtype) = dtype else {
             vortex_bail!("Not an extension DType");
         };
@@ -76,28 +132,21 @@ impl VTable for ExtensionVTable {
             vortex_bail!("Expected 1 child, got {}", children.len());
         }
         let storage = children.get(0, ext_dtype.storage_dtype(), len)?;
-        Ok(ExtensionArray::new(ext_dtype.clone(), storage))
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1,
-            "ExtensionArray expects exactly 1 child (storage), got {}",
-            children.len()
-        );
-        array.storage = children
-            .into_iter()
-            .next()
-            .vortex_expect("children length already validated");
-        Ok(())
+        Ok(crate::array::ArrayParts::new(
+            self.clone(),
+            dtype.clone(),
+            len,
+            ExtensionData::new(ext_dtype.clone(), storage.dtype()),
+        )
+        .with_slots(vec![Some(storage)]))
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -105,7 +154,7 @@ impl VTable for ExtensionVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -114,9 +163,9 @@ impl VTable for ExtensionVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct ExtensionVTable;
+#[derive(Clone, Debug)]
+pub struct Extension;
 
-impl ExtensionVTable {
+impl Extension {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.ext");
 }
diff --git a/vortex-array/src/arrays/extension/vtable/operations.rs b/vortex-array/src/arrays/extension/vtable/operations.rs
index 3a3ac7c7de4..d86c7599aef 100644
--- a/vortex-array/src/arrays/extension/vtable/operations.rs
+++ b/vortex-array/src/arrays/extension/vtable/operations.rs
@@ -3,17 +3,22 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
-use crate::arrays::extension::ExtensionArray;
-use crate::arrays::extension::ExtensionVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Extension;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<ExtensionVTable> for ExtensionVTable {
-    fn scalar_at(array: &ExtensionArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Extension> for Extension {
+    fn scalar_at(
+        array: ArrayView<'_, Extension>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(Scalar::extension_ref(
             array.ext_dtype().clone(),
-            array.storage().scalar_at(index)?,
+            array.storage_array().scalar_at(index)?,
         ))
     }
 }
diff --git a/vortex-array/src/arrays/extension/vtable/validity.rs b/vortex-array/src/arrays/extension/vtable/validity.rs
index e9bebc04770..6d535687088 100644
--- a/vortex-array/src/arrays/extension/vtable/validity.rs
+++ b/vortex-array/src/arrays/extension/vtable/validity.rs
@@ -2,12 +2,13 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use crate::ArrayRef;
-use crate::arrays::ExtensionArray;
-use crate::arrays::extension::ExtensionVTable;
-use crate::vtable::ValidityChild;
+use crate::array::ArrayView;
+use crate::array::ValidityChild;
+use crate::arrays::Extension;
+use crate::arrays::extension::ExtensionArrayExt;
 
-impl ValidityChild<ExtensionVTable> for ExtensionVTable {
-    fn validity_child(array: &ExtensionArray) -> &ArrayRef {
-        &array.storage
+impl ValidityChild<Extension> for Extension {
+    fn validity_child(array: ArrayView<'_, Extension>) -> ArrayRef {
+        array.storage_array().clone()
     }
 }
diff --git a/vortex-array/src/arrays/extension/vtable/visitor.rs b/vortex-array/src/arrays/extension/vtable/visitor.rs
deleted file mode 100644
index a7a6e69a576..00000000000
--- a/vortex-array/src/arrays/extension/vtable/visitor.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::extension::ExtensionArray;
-use crate::arrays::extension::ExtensionVTable;
-use crate::vtable::VisitorVTable;
-
-impl VisitorVTable<ExtensionVTable> for ExtensionVTable {
-    fn visit_buffers(_array: &ExtensionArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &ExtensionArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ExtensionArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("storage", &array.storage);
-    }
-
-    fn nchildren(_array: &ExtensionArray) -> usize {
-        1
-    }
-
-    fn nth_child(array: &ExtensionArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.storage.clone()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/filter/array.rs b/vortex-array/src/arrays/filter/array.rs
index 40857487a65..8367c8009e9 100644
--- a/vortex-array/src/arrays/filter/array.rs
+++ b/vortex-array/src/arrays/filter/array.rs
@@ -1,21 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure_eq;
 use vortex_mask::Mask;
 
 use crate::ArrayRef;
-use crate::stats::ArrayStats;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Filter;
 
-/// Decomposed parts of the filter array.
-pub struct FilterArrayParts {
-    /// Child array that is filtered by the mask
-    pub child: ArrayRef,
-    /// Mask to apply at filter time. Child elements with set indices are kept, the rest discarded.
-    pub mask: Mask,
-}
+/// The source array being filtered.
+pub(super) const CHILD_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["child"];
 
 // TODO(connor): Write docs on why we have this, and what we had in the old world so that the future
 // does not repeat the mistakes of the past.
@@ -23,41 +26,55 @@ pub struct FilterArrayParts {
 ///
 /// The resulting array contains only the elements where the mask is true.
 #[derive(Clone, Debug)]
-pub struct FilterArray {
-    /// The source array being filtered.
-    pub(super) child: ArrayRef,
-
+pub struct FilterData {
     /// The boolean mask selecting which elements to keep.
     pub(super) mask: Mask,
+}
 
-    /// The stats for this array.
-    pub(super) stats: ArrayStats,
+impl Display for FilterData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "mask_len: {}", self.mask.len())
+    }
 }
 
-impl FilterArray {
-    pub fn new(array: ArrayRef, mask: Mask) -> Self {
-        Self::try_new(array, mask).vortex_expect("FilterArray construction failed")
+pub struct FilterDataParts {
+    pub mask: Mask,
+}
+
+pub trait FilterArrayExt: TypedArrayRef<Filter> {
+    fn child(&self) -> &ArrayRef {
+        self.as_ref().slots()[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated filter child slot")
     }
+}
+impl<T: TypedArrayRef<Filter>> FilterArrayExt for T {}
 
-    pub fn try_new(array: ArrayRef, mask: Mask) -> VortexResult<Self> {
+impl FilterData {
+    pub fn new(mask: Mask) -> Self {
+        Self { mask }
+    }
+
+    fn try_new(array_len: usize, mask: Mask) -> VortexResult<Self> {
         vortex_ensure_eq!(
-            array.len(),
+            array_len,
             mask.len(),
             "FilterArray length mismatch: array has length {} but mask has length {}",
-            array.len(),
+            array_len,
             mask.len()
         );
 
-        Ok(Self {
-            child: array,
-            mask,
-            stats: ArrayStats::default(),
-        })
+        Ok(Self { mask })
+    }
+
+    /// Returns the length of this array (number of elements after filtering).
+    pub fn len(&self) -> usize {
+        self.mask.true_count()
     }
 
-    /// The child array being filtered.
-    pub fn child(&self) -> &ArrayRef {
-        &self.child
+    /// Returns `true` if this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     /// The mask used to filter the child array.
@@ -65,11 +82,33 @@ impl FilterArray {
         &self.mask
     }
 
-    /// Consume the array and return its individual components.
-    pub fn into_parts(self) -> FilterArrayParts {
-        FilterArrayParts {
-            child: self.child,
-            mask: self.mask,
+    pub fn into_parts(self) -> FilterDataParts {
+        FilterDataParts { mask: self.mask }
+    }
+}
+
+impl Array<Filter> {
+    /// Creates a new `FilterArray`.
+    pub fn new(array: ArrayRef, mask: Mask) -> Self {
+        let dtype = array.dtype().clone();
+        let len = mask.true_count();
+        let data = FilterData::new(mask);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Filter, dtype, len, data).with_slots(vec![Some(array)]),
+            )
         }
     }
+
+    /// Constructs a new `FilterArray`.
+    pub fn try_new(array: ArrayRef, mask: Mask) -> VortexResult<Self> {
+        let dtype = array.dtype().clone();
+        let len = mask.true_count();
+        let data = FilterData::try_new(array.len(), mask)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Filter, dtype, len, data).with_slots(vec![Some(array)]),
+            )
+        })
+    }
 }
diff --git a/vortex-array/src/arrays/filter/execute/bool.rs b/vortex-array/src/arrays/filter/execute/bool.rs
index 8facd07e909..1a35d1e74aa 100644
--- a/vortex-array/src/arrays/filter/execute/bool.rs
+++ b/vortex-array/src/arrays/filter/execute/bool.rs
@@ -7,11 +7,14 @@ use vortex_error::VortexExpect;
 use vortex_mask::MaskValues;
 
 use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::arrays::filter::execute::bitbuffer;
 use crate::arrays::filter::execute::filter_validity;
 
 pub fn filter_bool(array: &BoolArray, mask: &Arc<MaskValues>) -> BoolArray {
-    let validity = array.validity().vortex_expect("missing BoolArray validity");
+    let validity = array
+        .validity()
+        .vortex_expect("bool validity should be derivable");
     let filtered_validity = filter_validity(validity, mask);
 
     let bit_buffer = array.to_bit_buffer();
@@ -26,7 +29,8 @@ mod test {
     use rstest::rstest;
     use vortex_mask::Mask;
 
-    use crate::arrays::BoolArray;
+    use crate::IntoArray;
+    use crate::arrays::filter::execute::bool::BoolArray;
     use crate::canonical::ToCanonical;
     use crate::compute::conformance::filter::test_filter_conformance;
 
@@ -52,6 +56,6 @@ mod test {
     #[case(BoolArray::from_iter((0..100).map(|i| i % 2 == 0)))]
     #[case(BoolArray::from_iter((0..1024).map(|i| i % 3 != 0)))]
     fn test_filter_bool_conformance(#[case] array: BoolArray) {
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/decimal.rs b/vortex-array/src/arrays/filter/execute/decimal.rs
index da8c7eab308..869e1fabe0c 100644
--- a/vortex-array/src/arrays/filter/execute/decimal.rs
+++ b/vortex-array/src/arrays/filter/execute/decimal.rs
@@ -3,16 +3,21 @@
 
 use std::sync::Arc;
 
+use vortex_error::VortexExpect;
 use vortex_mask::MaskValues;
 
 use crate::arrays::DecimalArray;
 use crate::arrays::filter::execute::buffer;
 use crate::arrays::filter::execute::filter_validity;
 use crate::match_each_decimal_value_type;
-use crate::vtable::ValidityHelper;
 
 pub fn filter_decimal(array: &DecimalArray, mask: &Arc<MaskValues>) -> DecimalArray {
-    let filtered_validity = filter_validity(array.validity().clone(), mask);
+    let filtered_validity = filter_validity(
+        array
+            .validity()
+            .vortex_expect("decimal validity should be derivable"),
+        mask,
+    );
 
     match_each_decimal_value_type!(array.values_type(), |T| {
         let filtered_buffer = buffer::filter_buffer(array.buffer::<T>(), mask.as_ref());
@@ -28,7 +33,8 @@ pub fn filter_decimal(array: &DecimalArray, mask: &Arc<MaskValues>) -> DecimalAr
 
 #[cfg(test)]
 mod test {
-    use crate::arrays::DecimalArray;
+    use crate::IntoArray;
+    use crate::arrays::filter::execute::decimal::DecimalArray;
     use crate::compute::conformance::filter::test_filter_conformance;
     use crate::dtype::DecimalDType;
 
@@ -43,7 +49,7 @@ mod test {
             Some(99999),
         ];
         let array = DecimalArray::from_option_iter(values, decimal_dtype);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -51,6 +57,6 @@ mod test {
         let decimal_dtype = DecimalDType::new(38, 4);
         let values = vec![Some(12345i128), None, Some(-12345), Some(0), None];
         let array = DecimalArray::from_option_iter(values, decimal_dtype);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/fixed_size_list.rs b/vortex-array/src/arrays/filter/execute/fixed_size_list.rs
index 6630e62399f..3085debf9e1 100644
--- a/vortex-array/src/arrays/filter/execute/fixed_size_list.rs
+++ b/vortex-array/src/arrays/filter/execute/fixed_size_list.rs
@@ -10,7 +10,7 @@ use vortex_mask::MaskValues;
 
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::filter::execute::filter_validity;
-use crate::vtable::ValidityHelper;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 
 /// Density threshold for choosing between indices and slices representation when expanding masks.
 ///
@@ -25,7 +25,12 @@ pub fn filter_fixed_size_list(
     array: &FixedSizeListArray,
     selection_mask: &Arc<MaskValues>,
 ) -> FixedSizeListArray {
-    let filtered_validity = filter_validity(array.validity().clone(), selection_mask);
+    let filtered_validity = filter_validity(
+        array
+            .validity()
+            .vortex_expect("fixed-size-list validity should be derivable"),
+        selection_mask,
+    );
 
     let elements = array.elements();
     let new_len = selection_mask.true_count();
@@ -130,7 +135,7 @@ mod test {
     fn test_filter_fixed_size_list_conformance() {
         let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6, 7, 8, 9]);
         let array = FixedSizeListArray::new(elements.into_array(), 3, Validity::NonNullable, 3);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -139,7 +144,7 @@ mod test {
             PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), Some(5), None]);
         let validity = Validity::from_iter([true, false, true]);
         let array = FixedSizeListArray::new(elements.into_array(), 2, validity, 3);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
diff --git a/vortex-array/src/arrays/filter/execute/listview.rs b/vortex-array/src/arrays/filter/execute/listview.rs
index c9e9d369cff..e6c30416e17 100644
--- a/vortex-array/src/arrays/filter/execute/listview.rs
+++ b/vortex-array/src/arrays/filter/execute/listview.rs
@@ -7,10 +7,10 @@ use vortex_error::VortexExpect;
 use vortex_mask::MaskValues;
 
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewRebuildMode;
 use crate::arrays::filter::execute::filter_validity;
 use crate::arrays::filter::execute::values_to_mask;
-use crate::vtable::ValidityHelper;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewRebuildMode;
 
 // TODO(connor)[ListView]: Make use of this threshold after we start migrating operators.
 /// The threshold for triggering a rebuild of the [`ListViewArray`].
@@ -41,7 +41,12 @@ pub fn filter_listview(array: &ListViewArray, selection_mask: &Arc<MaskValues>)
     let offsets = array.offsets();
     let sizes = array.sizes();
 
-    let new_validity = filter_validity(array.validity().clone(), selection_mask);
+    let new_validity = filter_validity(
+        array
+            .validity()
+            .vortex_expect("listview validity should be derivable"),
+        selection_mask,
+    );
     debug_assert!(
         new_validity
             .maybe_len()
@@ -81,9 +86,10 @@ mod test {
 
     use crate::IntoArray;
     use crate::ToCanonical;
-    use crate::arrays::ConstantArray;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::filter::execute::ConstantArray;
+    use crate::arrays::listview::ListViewArrayExt;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::filter::test_filter_conformance;
     use crate::validity::Validity;
@@ -96,7 +102,7 @@ mod test {
         let sizes = buffer![2u32, 2, 2].into_array();
         let array =
             ListViewArray::new(elements.into_array(), offsets, sizes, Validity::NonNullable);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -107,7 +113,7 @@ mod test {
         let sizes = buffer![2u32, 2, 2].into_array();
         let validity = Validity::from_iter([true, false, true]);
         let array = ListViewArray::new(elements.into_array(), offsets, sizes, validity);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -120,7 +126,7 @@ mod test {
             ListViewArray::new_unchecked(elements, offsets, sizes, Validity::NonNullable)
                 .with_zero_copy_to_list(true)
         };
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -131,7 +137,7 @@ mod test {
         let offsets = buffer![5u32, 2, 8, 0, 1].into_array();
         let sizes = buffer![3u32, 2, 2, 2, 4].into_array();
         let array = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -141,7 +147,7 @@ mod test {
         let offsets = buffer![0u32, 100, 200, 300, 400, 500, 600, 700, 800, 900].into_array();
         let sizes = buffer![50u32, 50, 50, 50, 50, 50, 50, 50, 50, 50].into_array();
         let array = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -183,7 +189,7 @@ mod test {
         let sizes = buffer![3u32, 2, 2, 2, 4].into_array();
 
         let listview =
-            ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
         // Filter to keep only 2 lists.
         let mask = Mask::from_iter([true, false, false, true, false]);
@@ -215,7 +221,7 @@ mod test {
         let sizes = buffer![3u32, 3, 2, 2, 2].into_array();
 
         let listview =
-            ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
         // Filter to keep lists with gaps and overlaps.
         let mask = Mask::from_iter([false, true, true, true, false]);
@@ -259,7 +265,7 @@ mod test {
             varying_sizes,
             Validity::NonNullable,
         )
-        .to_array();
+        .into_array();
 
         let mask1 = Mask::from_iter([true, false, true, false]);
         let result1 = const_offset_list.filter(mask1).unwrap();
@@ -282,7 +288,7 @@ mod test {
             both_constant_sizes,
             Validity::NonNullable,
         )
-        .to_array();
+        .into_array();
 
         let mask2 = Mask::from_iter([true, false, true]);
         let result2 = both_const_list.filter(mask2).unwrap();
@@ -307,7 +313,7 @@ mod test {
         let sizes = buffer![5u32, 2, 5, 3, 4].into_array();
 
         let listview =
-            ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
         // Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
         let mask = Mask::from_iter([false, true, false, false, true]);
diff --git a/vortex-array/src/arrays/filter/execute/mod.rs b/vortex-array/src/arrays/filter/execute/mod.rs
index 0863e6f0cc7..bcbf28c0d96 100644
--- a/vortex-array/src/arrays/filter/execute/mod.rs
+++ b/vortex-array/src/arrays/filter/execute/mod.rs
@@ -16,10 +16,15 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
 use crate::arrays::ExtensionArray;
-use crate::arrays::FilterArray;
+use crate::arrays::Filter;
 use crate::arrays::NullArray;
+use crate::arrays::VariantArray;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::filter::FilterArrayExt;
+use crate::arrays::variant::VariantArrayExt;
 use crate::scalar::Scalar;
 use crate::validity::Validity;
 
@@ -36,7 +41,7 @@ mod varbinview;
 
 /// Reconstruct a [`Mask`] from an [`Arc<MaskValues>`].
 fn values_to_mask(values: &Arc<MaskValues>) -> Mask {
-    Mask::Values(values.clone())
+    Mask::Values(Arc::clone(values))
 }
 
 /// A helper function that lazily filters a [`Validity`] with selection mask values.
@@ -48,7 +53,7 @@ fn filter_validity(validity: Validity, mask: &Arc<MaskValues>) -> Validity {
 
 /// Check for some fast-path execution conditions before calling [`execute_filter`].
 pub(super) fn execute_filter_fast_paths(
-    array: &FilterArray,
+    array: ArrayView<'_, Filter>,
     _ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<ArrayRef>> {
     let true_count = array.mask.true_count();
@@ -60,12 +65,12 @@ pub(super) fn execute_filter_fast_paths(
 
     // If the mask selects everything, then we can just fully decompress the whole thing.
     if true_count == array.mask.len() {
-        return Ok(Some(array.child.clone()));
+        return Ok(Some(array.child().clone()));
     }
 
     // Also check if the array itself is completely null, in which case we only care about the total
     // number of nulls, not the values.
-    if array.validity_mask()?.true_count() == 0 {
+    if array.array().validity_mask()?.true_count() == 0 {
         return Ok(Some(
             ConstantArray::new(Scalar::null(array.dtype().clone()), true_count).into_array(),
         ));
@@ -89,10 +94,17 @@ pub(super) fn execute_filter(canonical: Canonical, mask: &Arc<MaskValues>) -> Ca
         Canonical::Struct(a) => Canonical::Struct(struct_::filter_struct(&a, mask)),
         Canonical::Extension(a) => {
             let filtered_storage = a
-                .storage()
+                .storage_array()
                 .filter(values_to_mask(mask))
                 .vortex_expect("ExtensionArray storage type somehow could not be filtered");
             Canonical::Extension(ExtensionArray::new(a.ext_dtype().clone(), filtered_storage))
         }
+        Canonical::Variant(a) => {
+            let filtered_child = a
+                .child()
+                .filter(values_to_mask(mask))
+                .vortex_expect("VariantArray child could not be filtered");
+            Canonical::Variant(VariantArray::new(filtered_child))
+        }
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/primitive.rs b/vortex-array/src/arrays/filter/execute/primitive.rs
index 4ed7cb606ce..86ef8ecbbb2 100644
--- a/vortex-array/src/arrays/filter/execute/primitive.rs
+++ b/vortex-array/src/arrays/filter/execute/primitive.rs
@@ -14,7 +14,7 @@ use crate::match_each_native_ptype;
 pub fn filter_primitive(array: &PrimitiveArray, mask: &Arc<MaskValues>) -> PrimitiveArray {
     let validity = array
         .validity()
-        .vortex_expect("missing PrimitiveArray validity");
+        .vortex_expect("primitive validity should be derivable");
     let filtered_validity = filter_validity(validity, mask);
 
     match_each_native_ptype!(array.ptype(), |T| {
@@ -33,7 +33,8 @@ mod test {
     use rstest::rstest;
     use vortex_mask::Mask;
 
-    use crate::arrays::primitive::PrimitiveArray;
+    use crate::IntoArray;
+    use crate::arrays::PrimitiveArray;
     use crate::canonical::ToCanonical;
     use crate::compute::conformance::filter::LARGE_SIZE;
     use crate::compute::conformance::filter::MEDIUM_SIZE;
@@ -73,6 +74,6 @@ mod test {
     #[case(PrimitiveArray::from_iter([0.1f32, 0.2, 0.3, 0.4, 0.5]))]
     #[case(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]))]
     fn test_filter_primitive_conformance(#[case] array: PrimitiveArray) {
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/struct_.rs b/vortex-array/src/arrays/filter/execute/struct_.rs
index 8ed514985e2..c9dac73a8cd 100644
--- a/vortex-array/src/arrays/filter/execute/struct_.rs
+++ b/vortex-array/src/arrays/filter/execute/struct_.rs
@@ -10,15 +10,19 @@ use crate::ArrayRef;
 use crate::arrays::StructArray;
 use crate::arrays::filter::execute::filter_validity;
 use crate::arrays::filter::execute::values_to_mask;
-use crate::vtable::ValidityHelper;
+use crate::arrays::struct_::StructArrayExt;
 
 pub fn filter_struct(array: &StructArray, mask: &Arc<MaskValues>) -> StructArray {
-    let filtered_validity = filter_validity(array.validity().clone(), mask);
+    let filtered_validity = filter_validity(
+        array
+            .validity()
+            .vortex_expect("struct validity should be derivable"),
+        mask,
+    );
 
     let mask_for_filter = values_to_mask(mask);
     let fields: Vec<ArrayRef> = array
-        .unmasked_fields()
-        .iter()
+        .iter_unmasked_fields()
         .map(|field| {
             field
                 .filter(mask_for_filter.clone())
@@ -64,7 +68,7 @@ mod test {
         ];
         let array =
             StructArray::try_new(["a", "b"].into(), fields, 5, Validity::NonNullable).unwrap();
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -77,7 +81,7 @@ mod test {
         ];
         let array =
             StructArray::try_new(["a", "b"].into(), fields, 5, Validity::NonNullable).unwrap();
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[test]
@@ -138,9 +142,9 @@ mod test {
     #[test]
     fn test_filter_empty_struct_conformance() {
         test_filter_conformance(
-            StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
+            &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
                 .unwrap()
-                .as_ref(),
+                .into_array(),
         );
     }
 
@@ -156,7 +160,7 @@ mod test {
             BoolArray::from_iter([Some(true), Some(true), None, None, Some(false)]).into_array();
 
         test_filter_conformance(
-            StructArray::try_new(
+            &StructArray::try_new(
                 ["xs", "ys", "zs"].into(),
                 vec![
                     StructArray::try_new(
@@ -174,7 +178,7 @@ mod test {
                 Validity::NonNullable,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/varbinview.rs b/vortex-array/src/arrays/filter/execute/varbinview.rs
index 60286586ba3..b757baa7c77 100644
--- a/vortex-array/src/arrays/filter/execute/varbinview.rs
+++ b/vortex-array/src/arrays/filter/execute/varbinview.rs
@@ -3,42 +3,61 @@
 
 use std::sync::Arc;
 
+use arrow_array::BooleanArray;
 use vortex_error::VortexExpect;
+use vortex_mask::Mask;
 use vortex_mask::MaskValues;
 
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
 use crate::arrays::filter::execute::values_to_mask;
-use crate::compute::arrow_filter_fn;
+use crate::arrow::FromArrowArray;
+use crate::arrow::IntoArrowArray;
 
 pub fn filter_varbinview(array: &VarBinViewArray, mask: &Arc<MaskValues>) -> VarBinViewArray {
     // Delegate to the Arrow implementation of filter over `VarBinView`.
-    arrow_filter_fn(array.as_ref(), &values_to_mask(mask))
+    arrow_filter_fn(&array.clone().into_array(), &values_to_mask(mask))
         .vortex_expect("VarBinViewArray is Arrow-compatible and supports arrow_filter_fn")
-        .as_::<VarBinViewVTable>()
-        .clone()
+        .as_::<VarBinView>()
+        .into_owned()
+}
+
+fn arrow_filter_fn(array: &ArrayRef, mask: &Mask) -> vortex_error::VortexResult<ArrayRef> {
+    let values = match &mask {
+        Mask::Values(values) => values,
+        Mask::AllTrue(_) | Mask::AllFalse(_) => unreachable!("check in filter invoke"),
+    };
+
+    let array_ref = array.clone().into_arrow_preferred()?;
+    let mask_array = BooleanArray::new(values.bit_buffer().clone().into(), None);
+    let filtered = arrow_select::filter::filter(array_ref.as_ref(), &mask_array)?;
+
+    ArrayRef::from_arrow(filtered.as_ref(), array.dtype().is_nullable())
 }
 
 #[cfg(test)]
 mod test {
+    use crate::IntoArray;
     use crate::arrays::VarBinViewArray;
     use crate::compute::conformance::filter::test_filter_conformance;
 
     #[test]
     fn test_filter_varbinview_conformance() {
         test_filter_conformance(
-            VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).as_ref(),
+            &VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).into_array(),
         );
 
         test_filter_conformance(
-            VarBinViewArray::from_iter_nullable_str([
+            &VarBinViewArray::from_iter_nullable_str([
                 Some("one"),
                 None,
                 Some("three"),
                 Some("four"),
                 Some("five"),
             ])
-            .as_ref(),
+            .into_array(),
         );
     }
 }
diff --git a/vortex-array/src/arrays/filter/kernel.rs b/vortex-array/src/arrays/filter/kernel.rs
index fb1e6ab9fa4..ef8f8671eda 100644
--- a/vortex-array/src/arrays/filter/kernel.rs
+++ b/vortex-array/src/arrays/filter/kernel.rs
@@ -1,6 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Reduce and execute adaptors for filter operations.
+//!
+//! Encodings that know how to filter themselves implement [`FilterReduce`] (metadata-only)
+//! or [`FilterKernel`] (buffer-reading). The adaptors [`FilterReduceAdaptor`] and
+//! [`FilterExecuteAdaptor`] bridge these into the execution model as
+//! [`ArrayParentReduceRule`] and [`ExecuteParentKernel`] respectively.
+
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
@@ -8,12 +15,12 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterVTable;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::Filter;
 use crate::kernel::ExecuteParentKernel;
 use crate::matcher::Matcher;
 use crate::optimizer::rules::ArrayParentReduceRule;
-use crate::vtable::VTable;
 
 pub trait FilterReduce: VTable {
     /// Filter an array with the provided mask without reading buffers.
@@ -28,7 +35,7 @@ pub trait FilterReduce: VTable {
     ///
     /// Additionally, the mask is guaranteed to be a `Mask::Values` variant (i.e., neither
     /// `Mask::AllTrue` nor `Mask::AllFalse`).
-    fn filter(array: &Self::Array, mask: &Mask) -> VortexResult<Option<ArrayRef>>;
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>>;
 }
 
 pub trait FilterKernel: VTable {
@@ -44,7 +51,7 @@ pub trait FilterKernel: VTable {
     /// Additionally, the mask is guaranteed to be a `Mask::Values` variant (i.e., neither
     /// `Mask::AllTrue` nor `Mask::AllFalse`).
     fn filter(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         mask: &Mask,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -54,7 +61,7 @@ pub trait FilterKernel: VTable {
 ///
 /// Returns `Some(result)` if the precondition short-circuits the filter operation,
 /// or `None` if the filter should proceed normally.
-fn precondition<V: VTable>(array: &V::Array, mask: &Mask) -> Option<ArrayRef> {
+fn precondition<V: VTable>(array: ArrayView<'_, V>, mask: &Mask) -> Option<ArrayRef> {
     let true_count = mask.true_count();
 
     // Fast-path for empty mask (all false).
@@ -64,12 +71,13 @@ fn precondition<V: VTable>(array: &V::Array, mask: &Mask) -> Option<ArrayRef> {
 
     // Fast-path for full mask (all true).
     if true_count == mask.len() {
-        return Some(array.to_array());
+        return Some(array.array().clone());
     }
 
     None
 }
 
+/// Adaptor that wraps a [`FilterReduce`] impl as an [`ArrayParentReduceRule`].
 #[derive(Default, Debug)]
 pub struct FilterReduceAdaptor<V>(pub V);
 
@@ -77,12 +85,12 @@ impl<V> ArrayParentReduceRule<V> for FilterReduceAdaptor<V>
 where
     V: FilterReduce,
 {
-    type Parent = FilterVTable;
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
-        parent: &FilterArray,
+        array: ArrayView<'_, V>,
+        parent: ArrayView<'_, Filter>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         assert_eq!(child_idx, 0);
@@ -93,6 +101,7 @@ where
     }
 }
 
+/// Adaptor that wraps a [`FilterKernel`] impl as an [`ExecuteParentKernel`].
 #[derive(Default, Debug)]
 pub struct FilterExecuteAdaptor<V>(pub V);
 
@@ -100,11 +109,11 @@ impl<V> ExecuteParentKernel<V> for FilterExecuteAdaptor<V>
 where
     V: FilterKernel,
 {
-    type Parent = FilterVTable;
+    type Parent = Filter;
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
diff --git a/vortex-array/src/arrays/filter/mod.rs b/vortex-array/src/arrays/filter/mod.rs
index 612a09e74ac..39859bc5b25 100644
--- a/vortex-array/src/arrays/filter/mod.rs
+++ b/vortex-array/src/arrays/filter/mod.rs
@@ -2,8 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::FilterArray;
-pub use array::FilterArrayParts;
+pub use array::FilterArrayExt;
+pub use array::FilterData;
+pub use array::FilterDataParts;
+pub use vtable::FilterArray;
 
 mod execute;
 
@@ -16,4 +18,4 @@ pub use kernel::FilterReduceAdaptor;
 mod rules;
 
 mod vtable;
-pub use vtable::FilterVTable;
+pub use vtable::Filter;
diff --git a/vortex-array/src/arrays/filter/rules.rs b/vortex-array/src/arrays/filter/rules.rs
index 388ae2da254..45e938d7768 100644
--- a/vortex-array/src/arrays/filter/rules.rs
+++ b/vortex-array/src/arrays/filter/rules.rs
@@ -4,24 +4,24 @@
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterVTable;
+use crate::array::ArrayView;
+use crate::arrays::Filter;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructArrayParts;
-use crate::arrays::StructVTable;
+use crate::arrays::filter::FilterArrayExt;
+use crate::arrays::struct_::StructDataParts;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ArrayReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::optimizer::rules::ReduceRuleSet;
 
-pub(super) const PARENT_RULES: ParentRuleSet<FilterVTable> =
+pub(super) const PARENT_RULES: ParentRuleSet<Filter> =
     ParentRuleSet::new(&[ParentRuleSet::lift(&FilterFilterRule)]);
 
-pub(super) const RULES: ReduceRuleSet<FilterVTable> =
+pub(super) const RULES: ReduceRuleSet<Filter> =
     ReduceRuleSet::new(&[&TrivialFilterRule, &FilterStructRule]);
 
 /// A simple redecution rule that simplifies a [`FilterArray`] whose child is also a
@@ -29,29 +29,29 @@ pub(super) const RULES: ReduceRuleSet<FilterVTable> =
 #[derive(Debug)]
 struct FilterFilterRule;
 
-impl ArrayParentReduceRule<FilterVTable> for FilterFilterRule {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<Filter> for FilterFilterRule {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &FilterArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, Filter>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         let combined_mask = child.mask.intersect_by_rank(&parent.mask);
-        let new_array = child.child.filter(combined_mask)?;
+        let new_array = child.child().filter(combined_mask)?;
 
-        Ok(Some(new_array.into_array()))
+        Ok(Some(new_array))
     }
 }
 
 #[derive(Debug)]
 struct TrivialFilterRule;
 
-impl ArrayReduceRule<FilterVTable> for TrivialFilterRule {
-    fn reduce(&self, array: &FilterArray) -> VortexResult<Option<ArrayRef>> {
+impl ArrayReduceRule<Filter> for TrivialFilterRule {
+    fn reduce(&self, array: ArrayView<'_, Filter>) -> VortexResult<Option<ArrayRef>> {
         match array.filter_mask() {
-            Mask::AllTrue(_) => Ok(Some(array.child.clone())),
+            Mask::AllTrue(_) => Ok(Some(array.child().clone())),
             Mask::AllFalse(_) => Ok(Some(Canonical::empty(array.dtype()).into_array())),
             Mask::Values(_) => Ok(None),
         }
@@ -62,20 +62,20 @@ impl ArrayReduceRule<FilterVTable> for TrivialFilterRule {
 #[derive(Debug)]
 struct FilterStructRule;
 
-impl ArrayReduceRule<FilterVTable> for FilterStructRule {
-    fn reduce(&self, array: &FilterArray) -> VortexResult<Option<ArrayRef>> {
+impl ArrayReduceRule<Filter> for FilterStructRule {
+    fn reduce(&self, array: ArrayView<'_, Filter>) -> VortexResult<Option<ArrayRef>> {
         let mask = array.filter_mask();
-        let Some(struct_array) = array.child().as_opt::<StructVTable>() else {
+        let Some(struct_array) = array.child().as_opt::<Struct>() else {
             return Ok(None);
         };
 
         let len = mask.true_count();
-        let StructArrayParts {
+        let StructDataParts {
             fields,
             struct_fields,
             validity,
             ..
-        } = struct_array.clone().into_parts();
+        } = struct_array.into_owned().into_data_parts();
 
         let filtered_validity = validity.filter(mask)?;
 
diff --git a/vortex-array/src/arrays/filter/vtable.rs b/vortex-array/src/arrays/filter/vtable.rs
index 1689a29a5d4..8eb7fb62213 100644
--- a/vortex-array/src/arrays/filter/vtable.rs
+++ b/vortex-array/src/arrays/filter/vtable.rs
@@ -1,26 +1,34 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::fmt::Debug;
-use std::fmt::Formatter;
 use std::hash::Hasher;
+use std::sync::Arc;
 
 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_mask::Mask;
 use vortex_session::VortexSession;
 
-use crate::Array;
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
+use crate::AnyCanonical;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::IntoArray;
 use crate::Precision;
-use crate::arrays::filter::array::FilterArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::array::VTable;
+use crate::array::ValidityVTable;
+use crate::arrays::filter::FilterArrayExt;
+use crate::arrays::filter::array::CHILD_SLOT;
+use crate::arrays::filter::array::FilterData;
+use crate::arrays::filter::array::SLOT_NAMES;
 use crate::arrays::filter::execute::execute_filter;
 use crate::arrays::filter::execute::execute_filter_fast_paths;
 use crate::arrays::filter::rules::PARENT_RULES;
@@ -28,178 +36,160 @@ use crate::arrays::filter::rules::RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+use crate::require_child;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
-use crate::stats::StatsSetRef;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
 
-vtable!(Filter);
+/// A [`Filter`]-encoded Vortex array.
+pub type FilterArray = Array<Filter>;
 
-#[derive(Debug)]
-pub struct FilterVTable;
+#[derive(Clone, Debug)]
+pub struct Filter;
 
-impl FilterVTable {
+impl Filter {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.filter");
 }
 
-impl VTable for FilterVTable {
-    type Array = FilterArray;
-    type Metadata = FilterMetadata;
-    type ArrayVTable = Self;
+impl ArrayHash for FilterData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.mask.array_hash(state, precision);
+    }
+}
+
+impl ArrayEq for FilterData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.mask.array_eq(&other.mask, precision)
+    }
+}
+
+impl VTable for Filter {
+    type ArrayData = FilterData;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &Self::Array) -> VortexResult<Self::Metadata> {
-        Ok(FilterMetadata(array.mask.clone()))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots[CHILD_SLOT].is_some(),
+            "FilterArray child slot must be present"
+        );
+        let child = slots[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated child slot");
+        vortex_ensure!(
+            child.dtype() == dtype,
+            "FilterArray dtype {} does not match outer dtype {}",
+            child.dtype(),
+            dtype
+        );
+        vortex_ensure!(
+            data.len() == len,
+            "FilterArray length {} does not match outer length {}",
+            data.len(),
+            len
+        );
+        vortex_ensure!(
+            child.len() == data.mask.len(),
+            "FilterArray child length {} does not match mask length {}",
+            child.len(),
+            data.mask.len()
+        );
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, _idx: usize) -> BufferHandle {
+        vortex_panic!("FilterArray has no buffers")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
         // TODO(joe): make this configurable
         vortex_bail!("Filter array is not serializable")
     }
 
     fn deserialize(
-        _bytes: &[u8],
+        &self,
         _dtype: &DType,
         _len: usize,
+        _metadata: &[u8],
+
         _buffers: &[BufferHandle],
+        _children: &dyn ArrayChildren,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
         vortex_bail!("Filter array is not serializable")
     }
 
-    fn build(
-        dtype: &DType,
-        len: usize,
-        metadata: &FilterMetadata,
-        _buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-    ) -> VortexResult<Self::Array> {
-        assert_eq!(len, metadata.0.true_count());
-        let child = children.get(0, dtype, metadata.0.len())?;
-        Ok(FilterArray {
-            child,
-            mask: metadata.0.clone(),
-            stats: Default::default(),
-        })
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1,
-            "FilterArray expects exactly 1 child, got {}",
-            children.len()
-        );
-        array.child = children
-            .into_iter()
-            .next()
-            .vortex_expect("children length already validated");
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        if let Some(canonical) = execute_filter_fast_paths(array, ctx)? {
-            return Ok(canonical);
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        if let Some(canonical) = execute_filter_fast_paths(array.as_view(), ctx)? {
+            return Ok(ExecutionResult::done(canonical));
         }
-        let Mask::Values(mask_values) = &array.mask else {
-            unreachable!("`execute_filter_fast_paths` handles AllTrue and AllFalse")
+        let mask_values = match &array.mask {
+            Mask::Values(v) => Arc::clone(v),
+            _ => unreachable!("`execute_filter_fast_paths` handles AllTrue and AllFalse"),
         };
 
+        let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical);
+
         // We rely on the optimization pass that runs prior to this execution for filter pushdown,
         // so now we can just execute the filter without worrying.
-        Ok(execute_filter(array.child.clone().execute(ctx)?, mask_values).into_array())
+        // TODO(joe): fix the ownership of AnyCanonical
+        let child = Canonical::from(array.child().as_::<AnyCanonical>());
+        Ok(ExecutionResult::done(
+            execute_filter(child, &mask_values).into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
+    fn reduce(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>> {
         RULES.evaluate(array)
     }
 }
-
-impl BaseArrayVTable<FilterVTable> for FilterVTable {
-    fn len(array: &FilterArray) -> usize {
-        array.mask.true_count()
-    }
-
-    fn dtype(array: &FilterArray) -> &DType {
-        array.child.dtype()
-    }
-
-    fn stats(array: &FilterArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: Hasher>(array: &FilterArray, state: &mut H, precision: Precision) {
-        array.child.array_hash(state, precision);
-        array.mask.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &FilterArray, other: &FilterArray, precision: Precision) -> bool {
-        array.child.array_eq(&other.child, precision) && array.mask.array_eq(&other.mask, precision)
-    }
-}
-
-impl OperationsVTable<FilterVTable> for FilterVTable {
-    fn scalar_at(array: &FilterArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Filter> for Filter {
+    fn scalar_at(
+        array: ArrayView<'_, Filter>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let rank_idx = array.mask.rank(index);
-        array.child.scalar_at(rank_idx)
-    }
-}
-
-impl ValidityVTable<FilterVTable> for FilterVTable {
-    fn validity(array: &FilterArray) -> VortexResult<Validity> {
-        array.child.validity()?.filter(&array.mask)
-    }
-}
-
-impl VisitorVTable<FilterVTable> for FilterVTable {
-    fn visit_buffers(_array: &FilterArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(array: &FilterArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("child", &array.child);
-    }
-
-    fn nchildren(_array: &FilterArray) -> usize {
-        1
-    }
-
-    fn nth_child(array: &FilterArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.child.clone()),
-            _ => None,
-        }
+        array.child().scalar_at(rank_idx)
     }
 }
 
-pub struct FilterMetadata(pub(super) Mask);
-
-impl Debug for FilterMetadata {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{} / {} => {}",
-            self.0.true_count(),
-            self.0.len(),
-            self.0.density()
-        )
+impl ValidityVTable<Filter> for Filter {
+    fn validity(array: ArrayView<'_, Filter>) -> VortexResult<Validity> {
+        array.child().validity()?.filter(&array.mask)
     }
 }
diff --git a/vortex-array/src/arrays/fixed_size_list/array.rs b/vortex-array/src/arrays/fixed_size_list/array.rs
index ec7750920b2..dcbee9f8f6f 100644
--- a/vortex-array/src/arrays/fixed_size_list/array.rs
+++ b/vortex-array/src/arrays/fixed_size_list/array.rs
@@ -1,18 +1,39 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::FixedSizeList;
 use crate::dtype::DType;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// The `elements` data array, where each fixed-size list scalar is a _slice_ of the `elements`
+/// array, and each inner list element is a _scalar_ of the `elements` array.
+///
+/// The fixed-size list scalars are contiguous (regardless of nullability for easy lookups),
+/// each with equal size in memory.
+pub(super) const ELEMENTS_SLOT: usize = 0;
+/// The validity / null map of the array.
+///
+/// Note that this null map refers to which fixed-size list scalars are null, **not** which
+/// sub-elements of fixed-size list scalars are null. The `elements` array will track individual
+/// value nullability.
+pub(super) const VALIDITY_SLOT: usize = 1;
+pub(super) const NUM_SLOTS: usize = 2;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["elements", "validity"];
+
 /// The canonical encoding for fixed-size list arrays.
 ///
 /// A fixed-size list array stores lists where each list has the same number of elements. This is
@@ -36,6 +57,7 @@ use crate::validity::Validity;
 /// ```
 /// # fn main() -> vortex_error::VortexResult<()> {
 /// use vortex_array::arrays::{FixedSizeListArray, PrimitiveArray};
+/// use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
 /// use vortex_array::validity::Validity;
 /// use vortex_array::IntoArray;
 /// use vortex_buffer::buffer;
@@ -61,31 +83,7 @@ use crate::validity::Validity;
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct FixedSizeListArray {
-    /// The [`DType`] of the fixed-size list.
-    ///
-    /// This type **must** be the variant [`DType::FixedSizeList`].
-    pub(super) dtype: DType,
-
-    /// The `elements` data array, where each fixed-size list scalar is a _slice_ of the `elements`
-    /// array, and each inner list element is a _scalar_ of the `elements` array.
-    ///
-    /// The fixed-size list scalars (or the elements of the array) are contiguous (regardless of
-    /// nullability for easy lookups), each with equal size in memory.
-    elements: ArrayRef,
-
-    /// The size of each fixed-size list scalar in the array.
-    ///
-    /// We store the size of each fixed-size list in the array as a field for convenience.
-    list_size: u32,
-
-    /// The validity / null map of the array.
-    ///
-    /// Note that this null map refers to which fixed-size list scalars are null, **not** which
-    /// sub-elements of fixed-size list scalars are null. The `elements` array will track individual
-    /// value nullability.
-    pub(super) validity: Validity,
-
+pub struct FixedSizeListData {
     /// The length of the array.
     ///
     /// Note that this is different from the size of each fixed-size list scalar (`list_size`).
@@ -93,33 +91,50 @@ pub struct FixedSizeListArray {
     /// The main reason we need to store this (rather than calculate it on the fly via `list_size`
     /// and `elements.len()`) is because in the degenerate case where `list_size == 0`, we cannot
     /// use `0 / 0` to determine the length.
-    pub(super) len: usize,
+    pub(super) degenerate_len: usize,
+}
 
-    /// The stats for this array.
-    pub(super) stats_set: ArrayStats,
+impl Display for FixedSizeListData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "degenerate_len: {}", self.degenerate_len)
+    }
 }
 
-impl FixedSizeListArray {
-    /// Creates a new [`FixedSizeListArray`].
+pub struct FixedSizeListDataParts {
+    pub elements: ArrayRef,
+    pub validity: Validity,
+    pub dtype: DType,
+}
+
+impl FixedSizeListData {
+    pub(crate) fn make_slots(
+        elements: &ArrayRef,
+        validity: &Validity,
+        len: usize,
+    ) -> Vec<Option<ArrayRef>> {
+        vec![Some(elements.clone()), validity_to_child(validity, len)]
+    }
+
+    /// Creates a new `FixedSizeListArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`FixedSizeListArray::new_unchecked`].
-    pub fn new(elements: ArrayRef, list_size: u32, validity: Validity, len: usize) -> Self {
-        Self::try_new(elements, list_size, validity, len)
+    /// in `FixedSizeListArray::new_unchecked`.
+    pub fn build(elements: ArrayRef, list_size: u32, validity: Validity, len: usize) -> Self {
+        Self::try_build(elements, list_size, validity, len)
             .vortex_expect("FixedSizeListArray construction failed")
     }
 
     /// Constructs a new `FixedSizeListArray`.
     ///
-    /// See [`FixedSizeListArray::new_unchecked`] for more information.
+    /// See `FixedSizeListArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented
-    /// in [`FixedSizeListArray::new_unchecked`].
-    pub fn try_new(
+    /// in `FixedSizeListArray::new_unchecked`.
+    pub(crate) fn try_build(
         elements: ArrayRef,
         list_size: u32,
         validity: Validity,
@@ -128,10 +143,10 @@ impl FixedSizeListArray {
         Self::validate(&elements, len, list_size, &validity)?;
 
         // SAFETY: we validate that the inputs are valid above.
-        Ok(unsafe { Self::new_unchecked(elements, list_size, validity, len) })
+        Ok(unsafe { Self::new_unchecked(list_size, len) })
     }
 
-    /// Creates a new [`FixedSizeListArray`] without validation from these components:
+    /// Creates a new `FixedSizeListArray` without validation from these components:
     ///
     /// * `elements` is the data array where each fixed-size list is a slice.
     /// * `list_size` is the fixed number of elements in each list.
@@ -147,37 +162,17 @@ impl FixedSizeListArray {
     ///   fixed-size list is equal to the length of the validity).
     /// - The length of the `elements` array is equal to the length of the outer array times the
     ///   `list_size` (`elements.len() == list_size * len`).
-    pub unsafe fn new_unchecked(
-        elements: ArrayRef,
-        list_size: u32,
-        validity: Validity,
-        len: usize,
-    ) -> Self {
-        #[cfg(debug_assertions)]
-        Self::validate(&elements, len, list_size, &validity)
-            .vortex_expect("[Debug Assertion]: Invalid `FixedSizeListArray` parameters");
-
-        let nullability = validity.nullability();
-
+    pub unsafe fn new_unchecked(list_size: u32, len: usize) -> Self {
         Self {
-            dtype: DType::FixedSizeList(Arc::new(elements.dtype().clone()), list_size, nullability),
-            elements,
-            list_size,
-            validity,
-            len,
-            stats_set: Default::default(),
+            degenerate_len: if list_size == 0 { len } else { 0 },
         }
     }
 
-    pub fn into_parts(self) -> (ArrayRef, Validity, DType) {
-        (self.elements, self.validity, self.dtype)
-    }
-
-    /// Validates the components that would be used to create a [`FixedSizeListArray`].
+    /// Validates the components that would be used to create a `FixedSizeListArray`.
     ///
-    /// This function checks all the invariants required by [`FixedSizeListArray::new_unchecked`].
+    /// This function checks all the invariants required by `FixedSizeListArray::new_unchecked`.
     pub fn validate(
-        elements: &dyn Array,
+        elements: &ArrayRef,
         len: usize,
         list_size: u32,
         validity: &Validity,
@@ -208,33 +203,131 @@ impl FixedSizeListArray {
 
         Ok(())
     }
+}
 
-    /// Returns the elements array.
-    pub fn elements(&self) -> &ArrayRef {
-        &self.elements
+pub trait FixedSizeListArrayExt: TypedArrayRef<FixedSizeList> {
+    fn dtype_parts(&self) -> (&DType, u32, crate::dtype::Nullability) {
+        match self.as_ref().dtype() {
+            DType::FixedSizeList(element_dtype, list_size, nullability) => {
+                (element_dtype.as_ref(), *list_size, *nullability)
+            }
+            _ => unreachable!("FixedSizeListArrayExt requires a fixed-size list dtype"),
+        }
     }
 
-    /// The size of each fixed-size list scalar in the array.
-    pub const fn list_size(&self) -> u32 {
-        self.list_size
+    fn elements(&self) -> &ArrayRef {
+        self.as_ref().slots()[ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("FixedSizeListArray elements slot")
     }
 
-    /// Returns the elements of the fixed-size list scalar at the given index of the list array.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the index is out of bounds or the slice operation fails.
-    pub fn fixed_size_list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
+    fn list_size(&self) -> u32 {
+        let (_, list_size, _) = self.dtype_parts();
+        list_size
+    }
+
+    fn fixed_size_list_validity(&self) -> Validity {
+        let (_, _, nullability) = self.dtype_parts();
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], nullability)
+    }
+
+    fn fixed_size_list_validity_mask(&self) -> vortex_mask::Mask {
+        self.fixed_size_list_validity().to_mask(self.as_ref().len())
+    }
+
+    fn fixed_size_list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
         debug_assert!(
-            index < self.len,
+            index < self.as_ref().len(),
             "index {} out of bounds: the len is {}",
             index,
-            self.len,
+            self.as_ref().len(),
+        );
+        debug_assert!(
+            self.fixed_size_list_validity()
+                .is_valid(index)
+                .unwrap_or(false)
         );
-        debug_assert!(self.validity.is_valid(index).unwrap_or(false));
 
-        let start = self.list_size as usize * index;
-        let end = self.list_size as usize * (index + 1);
+        let start = self.list_size() as usize * index;
+        let end = self.list_size() as usize * (index + 1);
         self.elements().slice(start..end)
     }
 }
+impl<T: TypedArrayRef<FixedSizeList>> FixedSizeListArrayExt for T {}
+
+impl Array<FixedSizeList> {
+    /// Creates a new `FixedSizeListArray`.
+    pub fn new(elements: ArrayRef, list_size: u32, validity: Validity, len: usize) -> Self {
+        let dtype = DType::FixedSizeList(
+            Arc::new(elements.dtype().clone()),
+            list_size,
+            validity.nullability(),
+        );
+        let slots = FixedSizeListData::make_slots(&elements, &validity, len);
+        let data = FixedSizeListData::build(elements, list_size, validity, len);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(FixedSizeList, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Constructs a new `FixedSizeListArray`.
+    pub fn try_new(
+        elements: ArrayRef,
+        list_size: u32,
+        validity: Validity,
+        len: usize,
+    ) -> VortexResult<Self> {
+        let dtype = DType::FixedSizeList(
+            Arc::new(elements.dtype().clone()),
+            list_size,
+            validity.nullability(),
+        );
+        let slots = FixedSizeListData::make_slots(&elements, &validity, len);
+        let data = FixedSizeListData::try_build(elements, list_size, validity, len)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(FixedSizeList, dtype, len, data).with_slots(slots),
+            )
+        })
+    }
+
+    /// Creates a new `FixedSizeListArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`FixedSizeListData::new_unchecked`].
+    pub unsafe fn new_unchecked(
+        elements: ArrayRef,
+        list_size: u32,
+        validity: Validity,
+        len: usize,
+    ) -> Self {
+        let dtype = DType::FixedSizeList(
+            Arc::new(elements.dtype().clone()),
+            list_size,
+            validity.nullability(),
+        );
+        let slots = FixedSizeListData::make_slots(&elements, &validity, len);
+        let data = unsafe { FixedSizeListData::new_unchecked(list_size, len) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(FixedSizeList, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    pub fn into_data_parts(self) -> FixedSizeListDataParts {
+        let dtype = self.dtype().clone();
+        let elements = self.slots()[ELEMENTS_SLOT]
+            .clone()
+            .vortex_expect("FixedSizeListArray elements slot");
+        let validity = self.fixed_size_list_validity();
+        FixedSizeListDataParts {
+            elements,
+            validity,
+            dtype,
+        }
+    }
+}
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/cast.rs b/vortex-array/src/arrays/fixed_size_list/compute/cast.rs
index 424d5717975..791462d51c9 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/cast.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/cast.rs
@@ -5,31 +5,27 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
 /// Cast implementation for [`FixedSizeListArray`].
 ///
 /// Recursively casts the inner elements array to the target element type while preserving the list
 /// structure.
-impl CastReduce for FixedSizeListVTable {
-    fn cast(array: &FixedSizeListArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for FixedSizeList {
+    fn cast(array: ArrayView<'_, FixedSizeList>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         let Some(target_element_type) = dtype.as_fixed_size_list_element_opt() else {
             return Ok(None);
         };
 
-        let elements = array
-            .elements()
-            .cast((**target_element_type).clone())?
-            .to_canonical()?
-            .into_array();
+        let elements = array.elements().cast((**target_element_type).clone())?;
         let validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(dtype.nullability(), array.len())?;
 
         Ok(Some(
@@ -43,7 +39,7 @@ impl CastReduce for FixedSizeListVTable {
                     array.len(),
                 )
             }
-            .to_array(),
+            .into_array(),
         ))
     }
 }
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/is_constant.rs b/vortex-array/src/arrays/fixed_size_list/compute/is_constant.rs
deleted file mode 100644
index 1786fe7a7c4..00000000000
--- a/vortex-array/src/arrays/fixed_size_list/compute/is_constant.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::register_kernel;
-
-/// IsConstant implementation for [`FixedSizeListArray`].
-///
-/// Compares each list scalar against the first to determine if all lists are identical.
-impl IsConstantKernel for FixedSizeListVTable {
-    fn is_constant(
-        &self,
-        array: &FixedSizeListArray,
-        _opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        // Since all of the lists have fixed size, we just need to check that each list scalar is
-        // identical. Note that this check is always "expensive".
-
-        debug_assert!(
-            array.len() > 1,
-            "precondition for `is_constant` is incorrect"
-        );
-        let first_scalar = array.scalar_at(0)?; // We checked the array length above.
-
-        // TODO(connor): There must be a more efficient way to do this. Each `scalar_at()` call
-        // makes several allocations...
-        for i in 1..array.len() {
-            let current_scalar = array.scalar_at(i)?;
-            if current_scalar != first_scalar {
-                return Ok(Some(false));
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(FixedSizeListVTable).lift());
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/is_sorted.rs b/vortex-array/src/arrays/fixed_size_list/compute/is_sorted.rs
deleted file mode 100644
index b1a719a1ce1..00000000000
--- a/vortex-array/src/arrays/fixed_size_list/compute/is_sorted.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-/// IsSorted implementation for [`FixedSizeListArray`].
-impl IsSortedKernel for FixedSizeListVTable {
-    fn is_sorted(&self, _array: &FixedSizeListArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically.
-        Ok(None)
-    }
-
-    fn is_strict_sorted(&self, _array: &FixedSizeListArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically without duplicates.
-        Ok(None)
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(FixedSizeListVTable).lift());
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/mask.rs b/vortex-array/src/arrays/fixed_size_list/compute/mask.rs
index 2f6ec241b56..3df0413e1aa 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/mask.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/mask.rs
@@ -5,24 +5,25 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for FixedSizeListVTable {
-    fn mask(array: &FixedSizeListArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for FixedSizeList {
+    fn mask(
+        array: ArrayView<'_, FixedSizeList>,
+        mask: &ArrayRef,
+    ) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: masking the validity does not affect the invariants
         Ok(Some(
             unsafe {
                 FixedSizeListArray::new_unchecked(
                     array.elements().clone(),
                     array.list_size(),
-                    array
-                        .validity()
-                        .clone()
-                        .and(Validity::Array(mask.clone()))?,
+                    array.validity()?.and(Validity::Array(mask.clone()))?,
                     array.len(),
                 )
             }
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/min_max.rs b/vortex-array/src/arrays/fixed_size_list/compute/min_max.rs
deleted file mode 100644
index 4e3d3d1f25e..00000000000
--- a/vortex-array/src/arrays/fixed_size_list/compute/min_max.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-/// MinMax implementation for [`FixedSizeListArray`].
-impl MinMaxKernel for FixedSizeListVTable {
-    fn min_max(&self, _array: &FixedSizeListArray) -> VortexResult<Option<MinMaxResult>> {
-        // This would require finding the lexicographically minimum and maximum lists.
-        Ok(None)
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(FixedSizeListVTable).lift());
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/mod.rs b/vortex-array/src/arrays/fixed_size_list/compute/mod.rs
index 45204326ebd..9a43503c4b5 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/mod.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/mod.rs
@@ -2,10 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod cast;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/rules.rs b/vortex-array/src/arrays/fixed_size_list/compute/rules.rs
index 78b37deca1e..da1d91423e2 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/rules.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/rules.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FixedSizeListVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::FixedSizeList;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<FixedSizeListVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(FixedSizeListVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(FixedSizeListVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(FixedSizeListVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<FixedSizeList> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(FixedSizeList)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(FixedSizeList)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(FixedSizeList)),
 ]);
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/slice.rs b/vortex-array/src/arrays/fixed_size_list/compute/slice.rs
index c72707105a1..5146fd2b600 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/slice.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/slice.rs
@@ -7,13 +7,14 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::arrays::SliceReduce;
-use crate::vtable::ValidityHelper;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for FixedSizeListVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for FixedSizeList {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let new_len = range.len();
         let list_size = array.list_size() as usize;
 
@@ -25,7 +26,7 @@ impl SliceReduce for FixedSizeListVTable {
                         .elements()
                         .slice(range.start * list_size..range.end * list_size)?,
                     array.list_size(),
-                    array.validity().slice(range)?,
+                    array.validity()?.slice(range)?,
                     new_len,
                 )
             }
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 f6bd6b6ebb0..259eb382013 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/take.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/take.rs
@@ -7,46 +7,53 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::dtype::IntegerPType;
 use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
+use crate::match_smallest_offset_type;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 /// Take implementation for [`FixedSizeListArray`].
 ///
 /// Unlike `ListView`, `FixedSizeListArray` must rebuild the elements array because it requires
 /// that elements start at offset 0 and be perfectly packed without gaps. We expand list indices
 /// into element indices and push them down to the child elements array.
-impl TakeExecute for FixedSizeListVTable {
+impl TakeExecute for FixedSizeList {
+    #[expect(clippy::cognitive_complexity)]
     fn take(
-        array: &FixedSizeListArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, FixedSizeList>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
+        let max_element_idx = array.elements().len();
         match_each_integer_ptype!(indices.dtype().as_ptype(), |I| {
-            take_with_indices::<I>(array, indices)
+            match_smallest_offset_type!(max_element_idx, |E| {
+                take_with_indices::<I, E>(array, indices, ctx)
+            })
         })
         .map(Some)
     }
 }
 
 /// Dispatches to the appropriate take implementation based on list size and nullability.
-fn take_with_indices<I: IntegerPType>(
-    array: &FixedSizeListArray,
-    indices: &dyn Array,
+fn take_with_indices<I: IntegerPType, E: IntegerPType>(
+    array: ArrayView<'_, FixedSizeList>,
+    indices: &ArrayRef,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let list_size = array.list_size() as usize;
 
-    let indices_array = indices.to_primitive();
+    let indices_array = indices.clone().execute::<PrimitiveArray>(ctx)?;
 
     // Make sure to handle degenerate case where lists have size 0 (these can take fast paths).
     if list_size == 0 {
@@ -56,7 +63,7 @@ fn take_with_indices<I: IntegerPType>(
         );
 
         // Since there are no elements to take, we just need to take on the validity map.
-        let new_validity = array.validity().take(indices)?;
+        let new_validity = array.validity()?.take(indices)?;
         let new_len = indices_array.len();
 
         Ok(
@@ -74,24 +81,26 @@ fn take_with_indices<I: IntegerPType>(
     } else {
         // The result's nullability is the union of the input nullabilities.
         if array.dtype().is_nullable() || indices_array.dtype().is_nullable() {
-            take_nullable_fsl::<I>(array, &indices_array)
+            let indices_array = indices_array.as_view();
+            take_nullable_fsl::<I, E>(array, indices_array)
         } else {
-            take_non_nullable_fsl::<I>(array, &indices_array)
+            let indices_array = indices_array.as_view();
+            take_non_nullable_fsl::<I, E>(array, indices_array)
         }
     }
 }
 
 /// Takes from an array when both the array and indices are non-nullable.
-fn take_non_nullable_fsl<I: IntegerPType>(
-    array: &FixedSizeListArray,
-    indices_array: &PrimitiveArray,
+fn take_non_nullable_fsl<I: IntegerPType, E: IntegerPType>(
+    array: ArrayView<'_, FixedSizeList>,
+    indices_array: ArrayView<'_, Primitive>,
 ) -> VortexResult<ArrayRef> {
     let list_size = array.list_size() as usize;
     let indices: &[I] = indices_array.as_slice::<I>();
     let new_len = indices.len();
 
     // Build the element indices directly without validity tracking.
-    let mut elements_indices = BufferMut::<I>::with_capacity(new_len * list_size);
+    let mut elements_indices = BufferMut::<E>::with_capacity(new_len * list_size);
 
     // Build the element indices for each list.
     for data_idx in indices {
@@ -106,7 +115,7 @@ fn take_non_nullable_fsl<I: IntegerPType>(
         for i in list_start..list_end {
             // SAFETY: We've allocated enough space for enough indices for all `new_len` lists (that each consist of `list_size = list_end - list_start` elements), so we know we have enough capacity.
             unsafe {
-                elements_indices.push_unchecked(I::from_usize(i).vortex_expect("i < list_end"))
+                elements_indices.push_unchecked(E::from_usize(i).vortex_expect("i < list_end"))
             };
         }
     }
@@ -115,7 +124,7 @@ fn take_non_nullable_fsl<I: IntegerPType>(
     debug_assert_eq!(elements_indices.len(), new_len * list_size);
 
     let elements_indices_array = PrimitiveArray::new(elements_indices, Validity::NonNullable);
-    let new_elements = array.elements().take(elements_indices_array.to_array())?;
+    let new_elements = array.elements().take(elements_indices_array.into_array())?;
     debug_assert_eq!(new_elements.len(), new_len * list_size);
 
     // Both inputs are non-nullable, so the result is non-nullable.
@@ -131,20 +140,20 @@ fn take_non_nullable_fsl<I: IntegerPType>(
 }
 
 /// Takes from an array when either the array or indices are nullable.
-fn take_nullable_fsl<I: IntegerPType>(
-    array: &FixedSizeListArray,
-    indices_array: &PrimitiveArray,
+fn take_nullable_fsl<I: IntegerPType, E: IntegerPType>(
+    array: ArrayView<'_, FixedSizeList>,
+    indices_array: ArrayView<'_, Primitive>,
 ) -> VortexResult<ArrayRef> {
     let list_size = array.list_size() as usize;
     let indices: &[I] = indices_array.as_slice::<I>();
     let new_len = indices.len();
 
-    let array_validity = array.validity_mask()?;
-    let indices_validity = indices_array.validity_mask()?;
+    let array_validity = array.fixed_size_list_validity_mask();
+    let indices_validity = indices_array.validity_mask();
 
     // We must use placeholder zeros for null lists to maintain the array length without
     // propagating nullability to the element array's take operation.
-    let mut elements_indices = BufferMut::<I>::with_capacity(new_len * list_size);
+    let mut elements_indices = BufferMut::<E>::with_capacity(new_len * list_size);
     let mut new_validity_builder = BitBufferMut::with_capacity(new_len);
 
     // Build the element indices while tracking which lists are null.
@@ -159,7 +168,7 @@ fn take_nullable_fsl<I: IntegerPType>(
         if !is_index_valid || !array_validity.value(data_idx) {
             // Append placeholder zeros for null lists. These will be masked by the validity array.
             // We cannot use append_nulls here as explained above.
-            unsafe { elements_indices.push_n_unchecked(I::zero(), list_size) };
+            unsafe { elements_indices.push_n_unchecked(E::zero(), list_size) };
             new_validity_builder.append(false);
         } else {
             // Append the actual element indices for this list.
@@ -170,7 +179,7 @@ fn take_nullable_fsl<I: IntegerPType>(
             for i in list_start..list_end {
                 // SAFETY: We've allocated enough space for enough indices for all `new_len` lists (that each consist of `list_size = list_end - list_start` elements), so we know we have enough capacity.
                 unsafe {
-                    elements_indices.push_unchecked(I::from_usize(i).vortex_expect("i < list_end"))
+                    elements_indices.push_unchecked(E::from_usize(i).vortex_expect("i < list_end"))
                 };
             }
 
@@ -182,7 +191,7 @@ fn take_nullable_fsl<I: IntegerPType>(
     debug_assert_eq!(elements_indices.len(), new_len * list_size);
 
     let elements_indices_array = PrimitiveArray::new(elements_indices, Validity::NonNullable);
-    let new_elements = array.elements().take(elements_indices_array.to_array())?;
+    let new_elements = array.elements().take(elements_indices_array.into_array())?;
     debug_assert_eq!(new_elements.len(), new_len * list_size);
 
     // At least one input was nullable, so the result is nullable.
diff --git a/vortex-array/src/arrays/fixed_size_list/mod.rs b/vortex-array/src/arrays/fixed_size_list/mod.rs
index 5a0792a2fb3..5d55d22d880 100644
--- a/vortex-array/src/arrays/fixed_size_list/mod.rs
+++ b/vortex-array/src/arrays/fixed_size_list/mod.rs
@@ -2,12 +2,15 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::FixedSizeListArray;
+pub use array::FixedSizeListArrayExt;
+pub use array::FixedSizeListData;
+pub use array::FixedSizeListDataParts;
+pub use vtable::FixedSizeListArray;
 
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::FixedSizeListVTable;
+pub use vtable::FixedSizeList;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
index a53c62ae8ea..3d4b6e20ce2 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
@@ -5,9 +5,9 @@ use std::sync::Arc;
 
 use vortex_buffer::buffer;
 
-use crate::Array;
 use crate::IntoArray;
 use crate::arrays::FixedSizeListArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
index dec183141f3..a6fb279788d 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
@@ -5,10 +5,10 @@ use std::sync::Arc;
 
 use vortex_buffer::buffer;
 
-use crate::Array;
 use crate::IntoArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/filter.rs b/vortex-array/src/arrays/fixed_size_list/tests/filter.rs
index a0e1b0b8af9..7efa87eedee 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/filter.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/filter.rs
@@ -6,7 +6,6 @@ use vortex_buffer::BitBuffer;
 use vortex_buffer::buffer;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::FixedSizeListArray;
@@ -177,7 +176,7 @@ fn test_filter_nested_fixed_size_lists() {
 #[case(create_fsl_single_element())]
 #[case(create_fsl_empty())]
 fn test_filter_fsl_conformance(#[case] array: ArrayRef) {
-    test_filter_conformance(array.as_ref());
+    test_filter_conformance(&array);
 }
 
 // Helper functions for creating test arrays.
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 e63969b9862..41447881996 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
@@ -5,12 +5,12 @@ use std::sync::Arc;
 
 use vortex_buffer::buffer;
 
-use crate::Array;
 use crate::IntoArray;
 use crate::ToCanonical;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::ListBuilder;
 use crate::dtype::DType;
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
index 4cba013426c..13894ae3ec4 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
@@ -9,6 +9,7 @@ use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/take.rs b/vortex-array/src/arrays/fixed_size_list/tests/take.rs
index 80c6d41fdd6..53b959d22a6 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/take.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/take.rs
@@ -9,7 +9,7 @@ use super::common::create_empty_fsl;
 use super::common::create_large_fsl;
 use super::common::create_nullable_fsl;
 use super::common::create_single_element_fsl;
-use crate::Array;
+use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
@@ -31,7 +31,7 @@ use crate::validity::Validity;
 #[case::single_element(create_single_element_fsl())]
 #[case::empty(create_empty_fsl())]
 fn test_take_fsl_conformance(#[case] fsl: FixedSizeListArray) {
-    test_take_conformance(fsl.as_ref());
+    test_take_conformance(&fsl.into_array());
 }
 
 // FSL-specific edge case tests that aren't covered by conformance.
@@ -42,7 +42,7 @@ fn test_take_basic_smoke_test() {
     let fsl = FixedSizeListArray::new(elements.into_array(), 2, Validity::NonNullable, 3);
 
     let indices = buffer![2u32, 0, 1].into_array();
-    let result = fsl.take(indices.to_array()).unwrap();
+    let result = fsl.take(indices).unwrap();
 
     // Expected: [[5,6], [1,2], [3,4]]
     let expected = FixedSizeListArray::new(
@@ -85,11 +85,11 @@ fn test_take_degenerate_lists(
     let elements = PrimitiveArray::empty::<i32>(Nullability::NonNullable);
     let fsl = FixedSizeListArray::new(elements.into_array(), 0, validity, 5);
 
-    test_take_conformance(fsl.as_ref());
+    test_take_conformance(&fsl.clone().into_array());
 
     // Also test the specific behavior.
     let indices_array = PrimitiveArray::from_option_iter(indices);
-    let result = fsl.take(indices_array.to_array()).unwrap();
+    let result = fsl.take(indices_array.into_array()).unwrap();
 
     assert_eq!(result.len(), expected_len);
     for (i, expected_null) in expected_nulls.iter().enumerate() {
@@ -103,7 +103,7 @@ fn test_take_large_list_size() {
     let fsl = FixedSizeListArray::new(elements, 100, Validity::NonNullable, 3);
 
     let indices = buffer![2u16, 0].into_array();
-    let result = fsl.take(indices.to_array()).unwrap();
+    let result = fsl.take(indices).unwrap();
 
     // Expected: [[200..300], [0..100]]
     let expected_elems = PrimitiveArray::from_iter((200i32..300).chain(0..100)).into_array();
@@ -118,7 +118,7 @@ fn test_take_fsl_with_null_indices_preserves_elements() {
 
     // Indices with nulls: [1, null, 0].
     let indices = PrimitiveArray::from_option_iter([Some(1u32), None, Some(0)]);
-    let result = fsl.take(indices.to_array()).unwrap();
+    let result = fsl.take(indices.into_array()).unwrap();
 
     // Expected: [[3,4], null, [1,2]]
     let expected = FixedSizeListArray::new(
@@ -130,6 +130,39 @@ fn test_take_fsl_with_null_indices_preserves_elements() {
     assert_arrays_eq!(expected, result);
 }
 
+// Element index overflow: with u8 indices and list_size=16, data_idx=16 produces element index
+// 16*16=256 which overflows u8. The take kernel must widen the element index type.
+#[rstest]
+#[case::non_nullable(
+    FixedSizeListArray::new(
+        PrimitiveArray::from_iter(0u32..320).into_array(), 16, Validity::NonNullable, 20,
+    ),
+    buffer![0u8, 16, 5].into_array(),
+    FixedSizeListArray::new(
+        PrimitiveArray::from_iter((0u32..16).chain(256..272).chain(80..96)).into_array(),
+        16, Validity::NonNullable, 3,
+    ),
+)]
+#[case::nullable(
+    FixedSizeListArray::new(
+        PrimitiveArray::from_iter(0u32..320).into_array(), 16,
+        Validity::from_iter((0..20).map(|i| i != 5)), 20,
+    ),
+    buffer![0u8, 16, 5].into_array(),
+    FixedSizeListArray::new(
+        PrimitiveArray::from_iter((0u32..16).chain(256..272).chain(80..96)).into_array(),
+        16, Validity::from_iter([true, true, false]), 3,
+    ),
+)]
+fn test_element_index_overflow(
+    #[case] fsl: FixedSizeListArray,
+    #[case] indices: ArrayRef,
+    #[case] expected: FixedSizeListArray,
+) {
+    let result = fsl.take(indices).unwrap();
+    assert_arrays_eq!(result, expected);
+}
+
 // Parameterized test for nullable array scenarios that are specific to FSL's implementation.
 #[rstest]
 #[case::nullable_mixed_elements(
@@ -184,7 +217,7 @@ fn test_take_nullable_arrays_fsl_specific(
 
     // Create indices (with possible nulls).
     let indices_array = PrimitiveArray::from_option_iter(indices.clone());
-    let result = fsl.take(indices_array.to_array()).unwrap();
+    let result = fsl.take(indices_array.into_array()).unwrap();
 
     assert_eq!(result.len(), indices.len());
     for (i, expected_null) in expected_nulls.iter().enumerate() {
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/array.rs b/vortex-array/src/arrays/fixed_size_list/vtable/array.rs
deleted file mode 100644
index c210cedeeeb..00000000000
--- a/vortex-array/src/arrays/fixed_size_list/vtable/array.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<FixedSizeListVTable> for FixedSizeListVTable {
-    fn len(array: &FixedSizeListArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &FixedSizeListArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &FixedSizeListArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &FixedSizeListArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.elements().array_hash(state, precision);
-        array.list_size().hash(state);
-        array.validity.array_hash(state, precision);
-        array.len.hash(state);
-    }
-
-    fn array_eq(
-        array: &FixedSizeListArray,
-        other: &FixedSizeListArray,
-        precision: Precision,
-    ) -> bool {
-        array.dtype == other.dtype
-            && array.elements().array_eq(other.elements(), precision)
-            && array.list_size() == other.list_size()
-            && array.validity.array_eq(&other.validity, precision)
-            && array.len == other.len
-    }
-}
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/kernel.rs b/vortex-array/src/arrays/fixed_size_list/vtable/kernel.rs
index 6d38dccf2fa..c28a3a2a805 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/kernel.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/kernel.rs
@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FixedSizeListVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::FixedSizeList;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 
-impl FixedSizeListVTable {
-    pub(crate) const PARENT_KERNELS: ParentKernelSet<FixedSizeListVTable> =
-        ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(
-            FixedSizeListVTable,
-        ))]);
+impl FixedSizeList {
+    pub(crate) const PARENT_KERNELS: ParentKernelSet<FixedSizeList> =
+        ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(FixedSizeList))]);
 }
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 8892cf31ae3..b2c02ec6891 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
@@ -1,57 +1,87 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
 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 crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::arrays::FixedSizeListArray;
+use crate::ExecutionResult;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::fixed_size_list::FixedSizeListData;
+use crate::arrays::fixed_size_list::array::NUM_SLOTS;
+use crate::arrays::fixed_size_list::array::SLOT_NAMES;
 use crate::arrays::fixed_size_list::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
 
-vtable!(FixedSizeList);
+/// A [`FixedSizeList`]-encoded Vortex array.
+pub type FixedSizeListArray = Array<FixedSizeList>;
 
-#[derive(Debug)]
-pub struct FixedSizeListVTable;
+#[derive(Clone, Debug)]
+pub struct FixedSizeList;
 
-impl FixedSizeListVTable {
+impl FixedSizeList {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.fixed_size_list");
 }
 
-impl VTable for FixedSizeListVTable {
-    type Array = FixedSizeListArray;
+impl ArrayHash for FixedSizeListData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        let _precision = precision;
+        self.degenerate_len.hash(state);
+    }
+}
+
+impl ArrayEq for FixedSizeListData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        let _precision = precision;
+        self.degenerate_len == other.degenerate_len
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl VTable for FixedSizeList {
+    type ArrayData = FixedSizeListData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("FixedSizeListArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("FixedSizeListArray buffer_name index {idx} out of bounds")
+    }
+
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -59,7 +89,7 @@ impl VTable for FixedSizeListVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -67,37 +97,73 @@ impl VTable for FixedSizeListVTable {
         Self::PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn metadata(_array: &FixedSizeListArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
-    }
-
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
         Ok(Some(vec![]))
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        data: &FixedSizeListData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == NUM_SLOTS,
+            "FixedSizeListArray expected {NUM_SLOTS} slots, found {}",
+            slots.len()
+        );
+        let DType::FixedSizeList(_, list_size, nullability) = dtype else {
+            vortex_bail!("Expected `DType::FixedSizeList`, got {dtype:?}");
+        };
+        let elements = slots[crate::arrays::fixed_size_list::array::ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("FixedSizeListArray elements slot");
+        vortex_ensure!(
+            if *list_size == 0 {
+                data.degenerate_len == len
+            } else {
+                elements.len() / *list_size as usize == len
+            },
+            "FixedSizeListArray length {} does not match outer length {}",
+            len,
+            len
+        );
+
+        let actual_dtype =
+            DType::FixedSizeList(Arc::new(elements.dtype().clone()), *list_size, *nullability);
+        vortex_ensure!(
+            &actual_dtype == dtype,
+            "FixedSizeListArray dtype {} does not match outer dtype {}",
+            actual_dtype,
+            dtype
+        );
+
+        Ok(())
     }
 
-    /// Builds a [`FixedSizeListArray`].
-    ///
-    /// This method expects 1 or 2 children (a second child indicates a validity array).
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<FixedSizeListArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "FixedSizeListArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         vortex_ensure!(
             buffers.is_empty(),
-            "`FixedSizeListVTable::build` expects no buffers"
+            "`FixedSizeList::build` expects no buffers"
         );
 
         let DType::FixedSizeList(element_dtype, list_size, _) = &dtype else {
@@ -106,7 +172,7 @@ impl VTable for FixedSizeListVTable {
 
         let validity = {
             if children.len() > 2 {
-                vortex_bail!("`FixedSizeListVTable::build` method expected 1 or 2 children")
+                vortex_bail!("`FixedSizeList::build` method expected 1 or 2 children")
             }
 
             if children.len() == 2 {
@@ -121,33 +187,17 @@ impl VTable for FixedSizeListVTable {
         let num_elements = len * (*list_size as usize);
         let elements = children.get(0, element_dtype.as_ref(), num_elements)?;
 
-        FixedSizeListArray::try_new(elements, *list_size, validity, len)
+        let data =
+            FixedSizeListData::try_build(elements.clone(), *list_size, validity.clone(), len)?;
+        let slots = FixedSizeListData::make_slots(&elements, &validity, len);
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1 || children.len() == 2,
-            "FixedSizeListArray expects 1 or 2 children, got {}",
-            children.len()
-        );
-
-        let mut iter = children.into_iter();
-        let elements = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let validity = if let Some(validity_array) = iter.next() {
-            Validity::Array(validity_array)
-        } else {
-            Validity::from(array.dtype.nullability())
-        };
-
-        let new_array =
-            FixedSizeListArray::try_new(elements, array.list_size(), validity, array.len())?;
-        *array = new_array;
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 }
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/operations.rs b/vortex-array/src/arrays/fixed_size_list/vtable/operations.rs
index 3c57bfaac11..ebd2ed463a4 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/operations.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/operations.rs
@@ -3,13 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::FixedSizeList;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<FixedSizeListVTable> for FixedSizeListVTable {
-    fn scalar_at(array: &FixedSizeListArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<FixedSizeList> for FixedSizeList {
+    fn scalar_at(
+        array: ArrayView<'_, FixedSizeList>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // By the preconditions we know that the list scalar is not null.
         let list = array.fixed_size_list_elements_at(index)?;
         let children_elements: Vec<Scalar> = (0..list.len())
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/validity.rs b/vortex-array/src/arrays/fixed_size_list/vtable/validity.rs
index bcde797a32e..2740dd95d9c 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/validity.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FixedSizeListArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::fixed_size_list::vtable::FixedSizeList;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for FixedSizeListArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<FixedSizeList> for FixedSizeList {
+    fn validity(array: ArrayView<'_, FixedSizeList>) -> VortexResult<Validity> {
+        Ok(array.fixed_size_list_validity())
     }
 }
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/visitor.rs b/vortex-array/src/arrays/fixed_size_list/vtable/visitor.rs
deleted file mode 100644
index 25b04b2cc27..00000000000
--- a/vortex-array/src/arrays/fixed_size_list/vtable/visitor.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<FixedSizeListVTable> for FixedSizeListVTable {
-    fn visit_buffers(_array: &FixedSizeListArray, _visitor: &mut dyn ArrayBufferVisitor) {
-        // `FixedSizeListArray` has no byte buffers.
-    }
-
-    fn nbuffers(_array: &FixedSizeListArray) -> usize {
-        0
-    }
-
-    // We define the children for [`FixedSizeListArray`] as the `elements` array and the `validity`.
-    fn visit_children(array: &FixedSizeListArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("elements", array.elements());
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &FixedSizeListArray) -> usize {
-        1 + validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &FixedSizeListArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.elements().clone()),
-            1 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs
index 295e06cdc6c..75db7d0f08c 100644
--- a/vortex-array/src/arrays/list/array.rs
+++ b/vortex-array/src/arrays/list/array.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::sync::Arc;
 
 use num_traits::AsPrimitive;
@@ -10,22 +12,36 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::min_max::min_max;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
 use crate::arrays::ConstantArray;
-use crate::arrays::ListVTable;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::List;
+use crate::arrays::Primitive;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::min_max;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::match_each_integer_ptype;
 use crate::match_each_native_ptype;
 use crate::scalar_fn::fns::operators::Operator;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// The elements data array containing all list elements concatenated together.
+pub(super) const ELEMENTS_SLOT: usize = 0;
+/// The offsets array defining the start/end of each list within the elements array.
+pub(super) const OFFSETS_SLOT: usize = 1;
+/// The validity bitmap indicating which list elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 2;
+pub(super) const NUM_SLOTS: usize = 3;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["elements", "offsets", "validity"];
+
 /// A list array that stores variable-length lists of elements, similar to `Vec<Vec<T>>`.
 ///
 /// This mirrors the Apache Arrow List array encoding and provides efficient storage
@@ -54,6 +70,7 @@ use crate::validity::Validity;
 ///
 /// ```
 /// use vortex_array::arrays::{ListArray, PrimitiveArray};
+/// use vortex_array::arrays::list::ListArrayExt;
 /// use vortex_array::validity::Validity;
 /// use vortex_array::IntoArray;
 /// use vortex_buffer::buffer;
@@ -78,42 +95,55 @@ use crate::validity::Validity;
 /// let third_list = list_array.list_elements_at(2).unwrap();
 /// assert!(third_list.is_empty()); // []
 /// ```
-#[derive(Clone, Debug)]
-pub struct ListArray {
-    pub(super) dtype: DType,
-    pub(super) elements: ArrayRef,
-    pub(super) offsets: ArrayRef,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
+#[derive(Clone, Debug, Default)]
+pub struct ListData;
+
+impl Display for ListData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
 }
 
-pub struct ListArrayParts {
-    pub dtype: DType,
+pub struct ListDataParts {
     pub elements: ArrayRef,
     pub offsets: ArrayRef,
     pub validity: Validity,
+    pub dtype: DType,
 }
 
-impl ListArray {
-    /// Creates a new [`ListArray`].
+impl ListData {
+    pub(crate) fn make_slots(
+        elements: &ArrayRef,
+        offsets: &ArrayRef,
+        validity: &Validity,
+        len: usize,
+    ) -> Vec<Option<ArrayRef>> {
+        vec![
+            Some(elements.clone()),
+            Some(offsets.clone()),
+            validity_to_child(validity, len),
+        ]
+    }
+
+    /// Creates a new `ListArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`ListArray::new_unchecked`].
-    pub fn new(elements: ArrayRef, offsets: ArrayRef, validity: Validity) -> Self {
-        Self::try_new(elements, offsets, validity).vortex_expect("ListArray new")
+    /// in `ListArray::new_unchecked`.
+    pub fn build(elements: ArrayRef, offsets: ArrayRef, validity: Validity) -> Self {
+        Self::try_build(elements, offsets, validity).vortex_expect("ListArray new")
     }
 
     /// Constructs a new `ListArray`.
     ///
-    /// See [`ListArray::new_unchecked`] for more information.
+    /// See `ListArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`ListArray::new_unchecked`].
-    pub fn try_new(
+    /// `ListArray::new_unchecked`.
+    pub(crate) fn try_build(
         elements: ArrayRef,
         offsets: ArrayRef,
         validity: Validity,
@@ -121,10 +151,10 @@ impl ListArray {
         Self::validate(&elements, &offsets, &validity)?;
 
         // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked(elements, offsets, validity) })
+        Ok(unsafe { Self::new_unchecked() })
     }
 
-    /// Creates a new [`ListArray`] without validation from these components:
+    /// Creates a new `ListArray` without validation from these components:
     ///
     /// * `elements` is a flat array containing all list elements concatenated.
     /// * `offsets` is an integer array where `offsets[i]` is the start index for list `i`.
@@ -140,26 +170,16 @@ impl ListArray {
     /// - All offset values must be non-negative.
     /// - The maximum offset must not exceed `elements.len()`.
     /// - If validity is an array, its length must equal `offsets.len() - 1`.
-    pub unsafe fn new_unchecked(elements: ArrayRef, offsets: ArrayRef, validity: Validity) -> Self {
-        #[cfg(debug_assertions)]
-        Self::validate(&elements, &offsets, &validity)
-            .vortex_expect("[Debug Assertion]: Invalid `ListViewArray` parameters");
-
-        Self {
-            dtype: DType::List(Arc::new(elements.dtype().clone()), validity.nullability()),
-            elements,
-            offsets,
-            validity,
-            stats_set: Default::default(),
-        }
+    pub unsafe fn new_unchecked() -> Self {
+        Self
     }
 
-    /// Validates the components that would be used to create a [`ListArray`].
+    /// Validates the components that would be used to create a `ListArray`.
     ///
-    /// This function checks all the invariants required by [`ListArray::new_unchecked`].
+    /// This function checks all the invariants required by `ListArray::new_unchecked`.
     pub fn validate(
-        elements: &dyn Array,
-        offsets: &dyn Array,
+        elements: &ArrayRef,
+        offsets: &ArrayRef,
         validity: &Validity,
     ) -> VortexResult<()> {
         // Offsets must have at least one element
@@ -187,7 +207,8 @@ impl ListArray {
 
         // Validate that offsets min is non-negative, and max does not exceed the length of
         // the elements array.
-        if let Some(min_max) = min_max(offsets)? {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        if let Some(min_max) = min_max(offsets, &mut ctx)? {
             match_each_integer_ptype!(offsets_ptype, |P| {
                 #[allow(clippy::absurd_extreme_comparisons, unused_comparisons)]
                 {
@@ -237,28 +258,48 @@ impl ListArray {
 
         Ok(())
     }
+    // TODO(connor)[ListView]: Create 2 functions `reset_offsets` and `recursive_reset_offsets`,
+    // where `reset_offsets` is infallible.
+    // Also, `reset_offsets` can be made more efficient by replacing `sub_scalar` with a match on
+    // the offset type and manual subtraction and fast path where `offsets[0] == 0`.
+}
 
-    /// Splits an array into its parts
-    pub fn into_parts(self) -> ListArrayParts {
-        ListArrayParts {
-            dtype: self.dtype,
-            elements: self.elements,
-            offsets: self.offsets,
-            validity: self.validity,
+pub trait ListArrayExt: TypedArrayRef<List> {
+    fn nullability(&self) -> crate::dtype::Nullability {
+        match self.as_ref().dtype() {
+            DType::List(_, nullability) => *nullability,
+            _ => unreachable!("ListArrayExt requires a list dtype"),
         }
     }
 
-    /// Returns the offset at the given index from the list array.
-    ///
-    /// Returns an error if the index is out of bounds or scalar_at fails.
-    pub fn offset_at(&self, index: usize) -> VortexResult<usize> {
+    fn elements(&self) -> &ArrayRef {
+        self.as_ref().slots()[ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("ListArray elements slot")
+    }
+
+    fn offsets(&self) -> &ArrayRef {
+        self.as_ref().slots()[OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("ListArray offsets slot")
+    }
+
+    fn list_validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn list_validity_mask(&self) -> vortex_mask::Mask {
+        self.list_validity().to_mask(self.as_ref().len())
+    }
+
+    fn offset_at(&self, index: usize) -> VortexResult<usize> {
         vortex_ensure!(
-            index <= self.len(),
+            index <= self.as_ref().len(),
             "Index {index} out of bounds 0..={}",
-            self.len()
+            self.as_ref().len()
         );
 
-        if let Some(p) = self.offsets().as_opt::<PrimitiveVTable>() {
+        if let Some(p) = self.offsets().as_opt::<Primitive>() {
             Ok(match_each_native_ptype!(p.ptype(), |P| {
                 p.as_slice::<P>()[index].as_()
             }))
@@ -271,63 +312,101 @@ impl ListArray {
         }
     }
 
-    /// Returns the elements of the list scalar at the given index of the list array.
-    pub fn list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
+    fn list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
         let start = self.offset_at(index)?;
         let end = self.offset_at(index + 1)?;
         self.elements().slice(start..end)
     }
 
-    /// Returns elements of the list array referenced by the offsets array.
-    ///
-    /// This is useful for discarding any potentially unused parts of the underlying `elements`
-    /// child array.
-    pub fn sliced_elements(&self) -> VortexResult<ArrayRef> {
+    fn sliced_elements(&self) -> VortexResult<ArrayRef> {
         let start = self.offset_at(0)?;
-        let end = self.offset_at(self.len())?;
+        let end = self.offset_at(self.as_ref().len())?;
         self.elements().slice(start..end)
     }
 
-    /// Returns the offsets array.
-    pub fn offsets(&self) -> &ArrayRef {
-        &self.offsets
-    }
-
-    /// Returns the element dtype of the list array.
-    pub fn element_dtype(&self) -> &Arc<DType> {
-        match &self.dtype {
-            DType::List(element_dtype, _) => element_dtype,
-            _ => vortex_panic!("ListArray has invalid dtype {}", self.dtype),
-        }
-    }
-
-    /// Returns the elements array.
-    pub fn elements(&self) -> &ArrayRef {
-        &self.elements
+    fn element_dtype(&self) -> &DType {
+        self.elements().dtype()
     }
 
-    // TODO(connor)[ListView]: Create 2 functions `reset_offsets` and `recursive_reset_offsets`,
-    // where `reset_offsets` is infallible.
-    // Also, `reset_offsets` can be made more efficient by replacing `sub_scalar` with a match on
-    // the offset type and manual subtraction and fast path where `offsets[0] == 0`.
-
-    /// Create a copy of this array by adjusting `offsets` to start at `0` and removing elements not
-    /// referenced by the `offsets`.
-    pub fn reset_offsets(&self, recurse: bool) -> VortexResult<Self> {
+    fn reset_offsets(&self, recurse: bool) -> VortexResult<Array<List>> {
         let mut elements = self.sliced_elements()?;
         if recurse && elements.is_canonical() {
             elements = elements.to_canonical()?.compact()?.into_array();
-        } else if recurse && let Some(child_list_array) = elements.as_opt::<ListVTable>() {
-            elements = child_list_array.reset_offsets(recurse)?.into_array();
+        } else if recurse && let Some(child_list_array) = elements.as_opt::<List>() {
+            elements = child_list_array
+                .into_owned()
+                .reset_offsets(recurse)?
+                .into_array();
         }
 
         let offsets = self.offsets();
         let first_offset = offsets.scalar_at(0)?;
-        let adjusted_offsets = offsets.to_array().binary(
+        let adjusted_offsets = offsets.clone().binary(
             ConstantArray::new(first_offset, offsets.len()).into_array(),
             Operator::Sub,
         )?;
 
-        Self::try_new(elements, adjusted_offsets, self.validity.clone())
+        Array::<List>::try_new(elements, adjusted_offsets, self.list_validity())
+    }
+}
+impl<T: TypedArrayRef<List>> ListArrayExt for T {}
+
+impl Array<List> {
+    /// Creates a new `ListArray`.
+    pub fn new(elements: ArrayRef, offsets: ArrayRef, validity: Validity) -> Self {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len().saturating_sub(1);
+        let slots = ListData::make_slots(&elements, &offsets, &validity, len);
+        let data = ListData::build(elements, offsets, validity);
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(List, dtype, len, data).with_slots(slots))
+        }
+    }
+
+    /// Constructs a new `ListArray`.
+    pub fn try_new(
+        elements: ArrayRef,
+        offsets: ArrayRef,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len().saturating_sub(1);
+        let slots = ListData::make_slots(&elements, &offsets, &validity, len);
+        let data = ListData::try_build(elements, offsets, validity)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(List, dtype, len, data).with_slots(slots))
+        })
+    }
+
+    /// Creates a new `ListArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`ListData::new_unchecked`].
+    pub unsafe fn new_unchecked(elements: ArrayRef, offsets: ArrayRef, validity: Validity) -> Self {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len().saturating_sub(1);
+        let slots = ListData::make_slots(&elements, &offsets, &validity, len);
+        let data = unsafe { ListData::new_unchecked() };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(List, dtype, len, data).with_slots(slots))
+        }
+    }
+
+    pub fn into_data_parts(self) -> ListDataParts {
+        let dtype = self.dtype().clone();
+        let elements = self.slots()[ELEMENTS_SLOT]
+            .clone()
+            .vortex_expect("ListArray elements slot");
+        let offsets = self.slots()[OFFSETS_SLOT]
+            .clone()
+            .vortex_expect("ListArray offsets slot");
+        let validity = self.list_validity();
+        ListDataParts {
+            elements,
+            offsets,
+            validity,
+            dtype,
+        }
     }
 }
diff --git a/vortex-array/src/arrays/list/compute/cast.rs b/vortex-array/src/arrays/list/compute/cast.rs
index 1932d3083eb..bac84916390 100644
--- a/vortex-array/src/arrays/list/compute/cast.rs
+++ b/vortex-array/src/arrays/list/compute/cast.rs
@@ -5,32 +5,28 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::arrays::list::ListArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for ListVTable {
-    fn cast(array: &ListArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for List {
+    fn cast(array: ArrayView<'_, List>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         let Some(target_element_type) = dtype.as_list_element_opt() else {
             return Ok(None);
         };
 
         let validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(dtype.nullability(), array.len())?;
 
-        let new_elements = array
-            .elements()
-            .cast((**target_element_type).clone())?
-            .to_canonical()?
-            .into_array();
+        let new_elements = array.elements().cast((**target_element_type).clone())?;
 
         ListArray::try_new(new_elements, array.offsets().clone(), validity)
-            .map(|a| Some(a.to_array()))
+            .map(|a| Some(a.into_array()))
     }
 }
 
@@ -42,6 +38,9 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::RecursiveCanonical;
+    use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
     use crate::arrays::ListArray;
     use crate::arrays::PrimitiveArray;
@@ -56,8 +55,8 @@ mod tests {
     #[test]
     fn test_cast_list_success() {
         let list = ListArray::try_new(
-            buffer![1i32, 2, 3, 4].into_array().to_array(),
-            buffer![0, 2, 3].into_array().to_array(),
+            buffer![1i32, 2, 3, 4].into_array(),
+            buffer![0, 2, 3].into_array(),
             Validity::NonNullable,
         )
         .unwrap();
@@ -67,7 +66,11 @@ mod tests {
             Nullability::Nullable,
         );
 
-        let result = list.to_array().cast(target_dtype.clone()).unwrap();
+        let result = list
+            .clone()
+            .into_array()
+            .cast(target_dtype.clone())
+            .unwrap();
         assert_eq!(result.dtype(), &target_dtype);
         assert_eq!(result.len(), list.len());
     }
@@ -75,8 +78,8 @@ mod tests {
     #[test]
     fn test_cast_to_wrong_type() {
         let list = ListArray::try_new(
-            buffer![0i32, 2, 3, 4].into_array().to_array(),
-            buffer![0, 2, 3].into_array().to_array(),
+            buffer![0i32, 2, 3, 4].into_array(),
+            buffer![0, 2, 3].into_array(),
             Validity::NonNullable,
         )
         .unwrap();
@@ -85,7 +88,7 @@ mod tests {
         // can't cast list to u64
 
         let result = list
-            .to_array()
+            .into_array()
             .cast(target_dtype)
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
         assert!(result.is_err());
@@ -97,9 +100,9 @@ mod tests {
 
         // Nulls in the list itself
         let list = ListArray::try_new(
-            buffer![0i32, 2, 3, 4].into_array().to_array(),
-            buffer![0, 2, 3].into_array().to_array(),
-            Validity::Array(BoolArray::from_iter(vec![false, true]).to_array()),
+            buffer![0i32, 2, 3, 4].into_array(),
+            buffer![0, 2, 3].into_array(),
+            Validity::Array(BoolArray::from_iter(vec![false, true]).into_array()),
         )
         .unwrap();
 
@@ -109,15 +112,16 @@ mod tests {
         );
 
         let result = list
-            .to_array()
+            .into_array()
             .cast(target_dtype)
             .and_then(|a| a.to_canonical().map(|c| c.into_array()));
         assert!(result.is_err());
 
-        // Nulls in list element array
+        // Nulls in list element array — the inner cast error is deferred until
+        // the elements are executed.
         let list = ListArray::try_new(
-            PrimitiveArray::from_option_iter([Some(0i32), Some(2), None, None]).to_array(),
-            buffer![0, 2, 3].into_array().to_array(),
+            PrimitiveArray::from_option_iter([Some(0i32), Some(2), None, None]).into_array(),
+            buffer![0, 2, 3].into_array(),
             Validity::NonNullable,
         )
         .unwrap();
@@ -127,10 +131,10 @@ mod tests {
             Nullability::NonNullable,
         );
 
-        let result = list
-            .to_array()
-            .cast(target_dtype)
-            .and_then(|a| a.to_canonical().map(|c| c.into_array()));
+        let result = list.into_array().cast(target_dtype).and_then(|a| {
+            a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+                .map(|c| c.0.into_array())
+        });
         assert!(result.is_err());
     }
 
@@ -141,7 +145,7 @@ mod tests {
     #[case(create_nested_list())]
     #[case(create_empty_lists())]
     fn test_cast_list_conformance(#[case] array: ListArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     fn create_simple_list() -> ListArray {
diff --git a/vortex-array/src/arrays/list/compute/filter.rs b/vortex-array/src/arrays/list/compute/filter.rs
index 359c467fe7d..2b98e3c36d1 100644
--- a/vortex-array/src/arrays/list/compute/filter.rs
+++ b/vortex-array/src/arrays/list/compute/filter.rs
@@ -16,14 +16,15 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
-use crate::arrays::FilterKernel;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::arrays::filter::FilterKernel;
+use crate::arrays::list::ListArrayExt;
 use crate::dtype::IntegerPType;
 use crate::match_each_integer_ptype;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 /// Density threshold for choosing between indices and slices representation when expanding masks.
 ///
@@ -92,9 +93,9 @@ fn process_element_range(
     }
 }
 
-impl FilterKernel for ListVTable {
+impl FilterKernel for List {
     fn filter(
-        array: &ListArray,
+        array: ArrayView<'_, List>,
         mask: &Mask,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -103,7 +104,7 @@ impl FilterKernel for ListVTable {
             Mask::Values(v) => v,
         };
 
-        let new_validity = match array.validity() {
+        let new_validity = match array.validity()? {
             Validity::NonNullable => Validity::NonNullable,
             Validity::AllValid => Validity::AllValid,
             Validity::AllInvalid => {
diff --git a/vortex-array/src/arrays/list/compute/is_constant.rs b/vortex-array/src/arrays/list/compute/is_constant.rs
deleted file mode 100644
index 79ace8e83a7..00000000000
--- a/vortex-array/src/arrays/list/compute/is_constant.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::builtins::ArrayBuiltins;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::is_constant;
-use crate::register_kernel;
-use crate::scalar_fn::fns::operators::Operator;
-
-const SMALL_ARRAY_THRESHOLD: usize = 64;
-
-impl IsConstantKernel for ListVTable {
-    fn is_constant(&self, array: &ListArray, opts: &IsConstantOpts) -> VortexResult<Option<bool>> {
-        // At this point, we're guaranteed:
-        // - Array has at least 2 elements
-        // - All elements are valid (no nulls)
-
-        let manual_check_until = std::cmp::min(SMALL_ARRAY_THRESHOLD, array.len());
-
-        // We can first quickly check if all of the list lengths are equal. If not, then we know the
-        // array cannot be constant.
-        let first_list_len = array.offset_at(1)? - array.offset_at(0)?;
-        for i in 1..manual_check_until {
-            let current_list_len = array.offset_at(i + 1)? - array.offset_at(i)?;
-            if current_list_len != first_list_len {
-                return Ok(Some(false));
-            }
-        }
-
-        // Since we were not able to determine that this list array was **not** constant, and the
-        // cost is negligible, then don't bother doing the rest of this expensive check.
-        if opts.is_negligible_cost() {
-            return Ok(None);
-        }
-
-        // If the array is long, do an optimistic check on the remainder of the list lengths.
-        if array.len() > SMALL_ARRAY_THRESHOLD {
-            // check the rest of the element lengths
-            let start_offsets = array.offsets().slice(SMALL_ARRAY_THRESHOLD..array.len())?;
-            let end_offsets = array
-                .offsets()
-                .slice(SMALL_ARRAY_THRESHOLD + 1..array.len() + 1)?;
-            let list_lengths = end_offsets.binary(start_offsets, Operator::Sub)?;
-
-            if !is_constant(&list_lengths)?.unwrap_or_default() {
-                return Ok(Some(false));
-            }
-        }
-
-        debug_assert!(
-            array.len() > 1,
-            "precondition for `is_constant` is incorrect"
-        );
-        let first_scalar = array.scalar_at(0)?; // We checked the array length above.
-
-        // All lists have the same length, so compare the actual list contents.
-        for i in 1..array.len() {
-            let current_scalar = array.scalar_at(i)?;
-            if current_scalar != first_scalar {
-                return Ok(Some(false));
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(ListVTable).lift());
-
-#[cfg(test)]
-mod tests {
-
-    use rstest::rstest;
-    use vortex_buffer::buffer;
-
-    use crate::IntoArray;
-    use crate::arrays::ListArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::arrays::StructArray;
-    use crate::compute::is_constant;
-    use crate::dtype::FieldNames;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_is_constant_nested_list() {
-        let xs = ListArray::try_new(
-            buffer![0i32, 1, 0, 1].into_array(),
-            buffer![0u32, 2, 4].into_array(),
-            Validity::NonNullable,
-        )
-        .unwrap();
-
-        let struct_of_lists = StructArray::try_new(
-            FieldNames::from(["xs"]),
-            vec![xs.into_array()],
-            2,
-            Validity::NonNullable,
-        )
-        .unwrap();
-        assert!(
-            is_constant(&struct_of_lists.clone().into_array())
-                .unwrap()
-                .unwrap()
-        );
-        assert!(
-            is_constant(struct_of_lists.as_ref())
-                .unwrap()
-                .unwrap_or_default()
-        );
-    }
-
-    #[rstest]
-    #[case(
-        // [1,2], [1, 2], [1, 2]
-        vec![1i32, 2, 1, 2, 1, 2],
-        vec![0u32, 2, 4, 6],
-        true
-    )]
-    #[case(
-        // [1, 2], [3], [4, 5]
-        vec![1i32, 2, 3, 4, 5],
-        vec![0u32, 2, 3, 5],
-        false
-    )]
-    #[case(
-        // [1, 2], [3, 4]
-        vec![1i32, 2, 3, 4],
-        vec![0u32, 2, 4],
-        false
-    )]
-    #[case(
-        // [], [], []
-        vec![],
-        vec![0u32, 0, 0, 0],
-        true
-    )]
-    fn test_list_is_constant(
-        #[case] elements: Vec<i32>,
-        #[case] offsets: Vec<u32>,
-        #[case] expected: bool,
-    ) {
-        let list_array = ListArray::try_new(
-            PrimitiveArray::from_iter(elements).into_array(),
-            PrimitiveArray::from_iter(offsets).into_array(),
-            Validity::NonNullable,
-        )
-        .unwrap();
-
-        let result = is_constant(&list_array.into_array()).unwrap();
-        assert_eq!(result.unwrap(), expected);
-    }
-
-    #[test]
-    fn test_list_is_constant_nested_lists() {
-        let inner_elements = buffer![1i32, 2, 1, 2].into_array();
-        let inner_offsets = buffer![0u32, 1, 2, 3, 4].into_array();
-        let inner_lists =
-            ListArray::try_new(inner_elements, inner_offsets, Validity::NonNullable).unwrap();
-
-        let outer_offsets = buffer![0u32, 2, 4].into_array();
-        let outer_list = ListArray::try_new(
-            inner_lists.into_array(),
-            outer_offsets,
-            Validity::NonNullable,
-        )
-        .unwrap();
-
-        // Both outer lists contain [[1], [2]], so should be constant
-        assert!(is_constant(&outer_list.into_array()).unwrap().unwrap());
-    }
-
-    #[rstest]
-    #[case(
-        // 100 identical [1, 2] lists
-        [1i32, 2].repeat(100),
-        (0..101).map(|i| (i * 2) as u32).collect(),
-        true
-    )]
-    #[case(
-        // Difference after threshold: 64 identical [1, 2] + one [3, 4]
-        {
-            let mut elements = [1i32, 2].repeat(64);
-            elements.extend_from_slice(&[3, 4]);
-            elements
-        },
-        (0..66).map(|i| (i * 2) as u32).collect(),
-        false
-    )]
-    #[case(
-        // Difference in first 64: first 63 identical [1, 2] + one [3, 4] + rest identical [1, 2]
-        {
-            let mut elements = [1i32, 2].repeat(63);
-            elements.extend_from_slice(&[3, 4]);
-            elements.extend([1i32, 2].repeat(37));
-            elements
-        },
-        (0..101).map(|i| (i * 2) as u32).collect(),
-        false
-    )]
-    fn test_list_is_constant_with_threshold(
-        #[case] elements: Vec<i32>,
-        #[case] offsets: Vec<u32>,
-        #[case] expected: bool,
-    ) {
-        let list_array = ListArray::try_new(
-            PrimitiveArray::from_iter(elements).into_array(),
-            PrimitiveArray::from_iter(offsets).into_array(),
-            Validity::NonNullable,
-        )
-        .unwrap();
-
-        let result = is_constant(&list_array.into_array()).unwrap();
-        assert_eq!(result.unwrap(), expected);
-    }
-}
diff --git a/vortex-array/src/arrays/list/compute/is_sorted.rs b/vortex-array/src/arrays/list/compute/is_sorted.rs
deleted file mode 100644
index 6761f3ddf11..00000000000
--- a/vortex-array/src/arrays/list/compute/is_sorted.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-impl IsSortedKernel for ListVTable {
-    fn is_sorted(&self, _array: &ListArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically.
-        Ok(None)
-    }
-
-    fn is_strict_sorted(&self, _array: &ListArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically without duplicates.
-        Ok(None)
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(ListVTable).lift());
diff --git a/vortex-array/src/arrays/list/compute/kernels.rs b/vortex-array/src/arrays/list/compute/kernels.rs
index 6f3ea7c4579..b4268642e82 100644
--- a/vortex-array/src/arrays/list/compute/kernels.rs
+++ b/vortex-array/src/arrays/list/compute/kernels.rs
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FilterExecuteAdaptor;
-use crate::arrays::ListVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::List;
+use crate::arrays::dict::TakeExecuteAdaptor;
+use crate::arrays::filter::FilterExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 
-pub(crate) const PARENT_KERNELS: ParentKernelSet<ListVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&FilterExecuteAdaptor(ListVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(ListVTable)),
+pub(crate) const PARENT_KERNELS: ParentKernelSet<List> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&FilterExecuteAdaptor(List)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(List)),
 ]);
diff --git a/vortex-array/src/arrays/list/compute/mask.rs b/vortex-array/src/arrays/list/compute/mask.rs
index 65a39676c69..e9e895d08f1 100644
--- a/vortex-array/src/arrays/list/compute/mask.rs
+++ b/vortex-array/src/arrays/list/compute/mask.rs
@@ -5,21 +5,19 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::arrays::list::ListArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for ListVTable {
-    fn mask(array: &ListArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for List {
+    fn mask(array: ArrayView<'_, List>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         ListArray::try_new(
             array.elements().clone(),
             array.offsets().clone(),
-            array
-                .validity()
-                .clone()
-                .and(Validity::Array(mask.clone()))?,
+            array.validity()?.and(Validity::Array(mask.clone()))?,
         )
         .map(|a| Some(a.into_array()))
     }
diff --git a/vortex-array/src/arrays/list/compute/min_max.rs b/vortex-array/src/arrays/list/compute/min_max.rs
deleted file mode 100644
index 8faea22eb5c..00000000000
--- a/vortex-array/src/arrays/list/compute/min_max.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for ListVTable {
-    fn min_max(&self, _array: &ListArray) -> VortexResult<Option<MinMaxResult>> {
-        // This would require finding the lexicographically minimum and maximum lists.
-        Ok(None)
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(ListVTable).lift());
diff --git a/vortex-array/src/arrays/list/compute/mod.rs b/vortex-array/src/arrays/list/compute/mod.rs
index 44717beeaac..65bacbebdf5 100644
--- a/vortex-array/src/arrays/list/compute/mod.rs
+++ b/vortex-array/src/arrays/list/compute/mod.rs
@@ -3,11 +3,8 @@
 
 mod cast;
 mod filter;
-mod is_constant;
-mod is_sorted;
 mod kernels;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
@@ -36,7 +33,7 @@ mod tests {
         let array =
             ListArray::try_new(elements.into_array(), offsets.into_array(), validity).unwrap();
 
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 
     #[test]
@@ -47,7 +44,7 @@ mod tests {
         let array =
             ListArray::try_new(elements.into_array(), offsets.into_array(), validity).unwrap();
 
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 
     #[rstest]
@@ -79,6 +76,6 @@ mod tests {
         Validity::NonNullable,
     ).unwrap())]
     fn test_list_consistency(#[case] array: ListArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/list/compute/rules.rs b/vortex-array/src/arrays/list/compute/rules.rs
index 816d1992d22..d2aca066f7f 100644
--- a/vortex-array/src/arrays/list/compute/rules.rs
+++ b/vortex-array/src/arrays/list/compute/rules.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::ListVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::List;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<ListVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(ListVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ListVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ListVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<List> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(List)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(List)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(List)),
 ]);
diff --git a/vortex-array/src/arrays/list/compute/slice.rs b/vortex-array/src/arrays/list/compute/slice.rs
index 327b9dd3c8d..d29eaa5184c 100644
--- a/vortex-array/src/arrays/list/compute/slice.rs
+++ b/vortex-array/src/arrays/list/compute/slice.rs
@@ -7,18 +7,19 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::arrays::SliceReduce;
-use crate::vtable::ValidityHelper;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for ListVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for List {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             ListArray::new(
                 array.elements().clone(),
                 array.offsets().slice(range.start..range.end + 1)?,
-                array.validity().slice(range)?,
+                array.validity()?.slice(range)?,
             )
             .into_array(),
         ))
diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs
index a8f813c7507..841fd4ac45b 100644
--- a/vortex-array/src/arrays/list/compute/take.rs
+++ b/vortex-array/src/arrays/list/compute/take.rs
@@ -4,13 +4,16 @@
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ToCanonical;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::PrimitiveBuilder;
 use crate::dtype::IntegerPType;
@@ -18,12 +21,11 @@ use crate::dtype::Nullability;
 use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
 use crate::match_smallest_offset_type;
-use crate::vtable::ValidityHelper;
 
 // TODO(connor)[ListView]: Re-revert to the version where we simply convert to a `ListView` and call
 // the `ListView::take` compute function once `ListView` is more stable.
 
-impl TakeExecute for ListVTable {
+impl TakeExecute for List {
     /// Take implementation for [`ListArray`].
     ///
     /// Unlike `ListView`, `ListArray` must rebuild the elements array to maintain its invariant
@@ -31,18 +33,21 @@ impl TakeExecute for ListVTable {
     /// non-contiguous indices would violate this requirement.
     #[expect(clippy::cognitive_complexity)]
     fn take(
-        array: &ListArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, List>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let indices = indices.to_primitive();
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
         // This is an over-approximation of the total number of elements in the resulting array.
         let total_approx = array.elements().len().saturating_mul(indices.len());
 
         match_each_integer_ptype!(array.offsets().dtype().as_ptype(), |O| {
             match_each_integer_ptype!(indices.ptype(), |I| {
                 match_smallest_offset_type!(total_approx, |OutputOffsetType| {
-                    _take::<I, O, OutputOffsetType>(array, &indices).map(Some)
+                    {
+                        let indices = indices.as_view();
+                        _take::<I, O, OutputOffsetType>(array, indices, ctx).map(Some)
+                    }
                 })
             })
         })
@@ -50,17 +55,18 @@ impl TakeExecute for ListVTable {
 }
 
 fn _take<I: IntegerPType, O: IntegerPType, OutputOffsetType: IntegerPType>(
-    array: &ListArray,
-    indices_array: &PrimitiveArray,
+    array: ArrayView<'_, List>,
+    indices_array: ArrayView<'_, Primitive>,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
-    let data_validity = array.validity_mask()?;
-    let indices_validity = indices_array.validity_mask()?;
+    let data_validity = array.list_validity_mask();
+    let indices_validity = indices_array.validity_mask();
 
     if !indices_validity.all_true() || !data_validity.all_true() {
-        return _take_nullable::<I, O, OutputOffsetType>(array, indices_array);
+        return _take_nullable::<I, O, OutputOffsetType>(array, indices_array, ctx);
     }
 
-    let offsets_array = array.offsets().to_primitive();
+    let offsets_array = array.offsets().clone().execute::<PrimitiveArray>(ctx)?;
     let offsets: &[O] = offsets_array.as_slice();
     let indices: &[I] = indices_array.as_slice();
 
@@ -100,25 +106,26 @@ fn _take<I: IntegerPType, O: IntegerPType, OutputOffsetType: IntegerPType>(
     let elements_to_take = elements_to_take.finish();
     let new_offsets = new_offsets.finish();
 
-    let new_elements = array.elements().take(elements_to_take.to_array())?;
+    let new_elements = array.elements().take(elements_to_take)?;
 
     Ok(ListArray::try_new(
         new_elements,
         new_offsets,
-        array.validity().clone().take(indices_array.as_ref())?,
+        array.validity()?.take(indices_array.array())?,
     )?
-    .to_array())
+    .into_array())
 }
 
 fn _take_nullable<I: IntegerPType, O: IntegerPType, OutputOffsetType: IntegerPType>(
-    array: &ListArray,
-    indices_array: &PrimitiveArray,
+    array: ArrayView<'_, List>,
+    indices_array: ArrayView<'_, Primitive>,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
-    let offsets_array = array.offsets().to_primitive();
+    let offsets_array = array.offsets().clone().execute::<PrimitiveArray>(ctx)?;
     let offsets: &[O] = offsets_array.as_slice();
     let indices: &[I] = indices_array.as_slice();
-    let data_validity = array.validity_mask()?;
-    let indices_validity = indices_array.validity_mask()?;
+    let data_validity = array.list_validity_mask();
+    let indices_validity = indices_array.validity_mask();
 
     let mut new_offsets = PrimitiveBuilder::<OutputOffsetType>::with_capacity(
         Nullability::NonNullable,
@@ -168,14 +175,14 @@ fn _take_nullable<I: IntegerPType, O: IntegerPType, OutputOffsetType: IntegerPTy
 
     let elements_to_take = elements_to_take.finish();
     let new_offsets = new_offsets.finish();
-    let new_elements = array.elements().take(elements_to_take.to_array())?;
+    let new_elements = array.elements().take(elements_to_take)?;
 
     Ok(ListArray::try_new(
         new_elements,
         new_offsets,
-        array.validity().clone().take(indices_array.as_ref())?,
+        array.validity()?.take(indices_array.array())?,
     )?
-    .to_array())
+    .into_array())
 }
 
 #[cfg(test)]
@@ -185,12 +192,11 @@ mod test {
     use rstest::rstest;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray as _;
     use crate::ToCanonical;
     use crate::arrays::BoolArray;
+    use crate::arrays::ListArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::list::ListArray;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -203,15 +209,15 @@ mod test {
         let list = ListArray::try_new(
             buffer![0i32, 5, 3, 4].into_array(),
             buffer![0, 2, 3, 4, 4].into_array(),
-            Validity::Array(BoolArray::from_iter(vec![true, true, false, true]).to_array()),
+            Validity::Array(BoolArray::from_iter(vec![true, true, false, true]).into_array()),
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         let idx =
-            PrimitiveArray::from_option_iter(vec![Some(0), None, Some(1), Some(3)]).to_array();
+            PrimitiveArray::from_option_iter(vec![Some(0), None, Some(1), Some(3)]).into_array();
 
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
 
         assert_eq!(
             result.dtype(),
@@ -231,7 +237,7 @@ mod test {
         assert_eq!(
             result.scalar_at(0).unwrap(),
             Scalar::list(
-                element_dtype.clone(),
+                Arc::clone(&element_dtype),
                 vec![0i32.into(), 5.into()],
                 Nullability::Nullable
             )
@@ -243,7 +249,7 @@ mod test {
         assert_eq!(
             result.scalar_at(2).unwrap(),
             Scalar::list(
-                element_dtype.clone(),
+                Arc::clone(&element_dtype),
                 vec![3i32.into()],
                 Nullability::Nullable
             )
@@ -264,12 +270,12 @@ mod test {
             Validity::NonNullable,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
-        let idx = PrimitiveArray::from_option_iter(vec![Some(0), Some(1), None]).to_array();
+        let idx = PrimitiveArray::from_option_iter(vec![Some(0), Some(1), None]).into_array();
         // since idx is nullable, the final list will also be nullable
 
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
         assert_eq!(
             result.dtype(),
             &DType::List(
@@ -287,11 +293,11 @@ mod test {
             Validity::NonNullable,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         let idx = buffer![1, 0, 2].into_array();
 
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
 
         assert_eq!(
             result.dtype(),
@@ -311,7 +317,7 @@ mod test {
         assert_eq!(
             result.scalar_at(0).unwrap(),
             Scalar::list(
-                element_dtype.clone(),
+                Arc::clone(&element_dtype),
                 vec![3i32.into()],
                 Nullability::NonNullable
             )
@@ -321,7 +327,7 @@ mod test {
         assert_eq!(
             result.scalar_at(1).unwrap(),
             Scalar::list(
-                element_dtype.clone(),
+                Arc::clone(&element_dtype),
                 vec![0i32.into(), 5.into()],
                 Nullability::NonNullable
             )
@@ -342,11 +348,11 @@ mod test {
             Validity::NonNullable,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
-        let idx = PrimitiveArray::empty::<i32>(Nullability::Nullable).to_array();
+        let idx = PrimitiveArray::empty::<i32>(Nullability::Nullable).into_array();
 
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
         assert_eq!(
             result.dtype(),
             &DType::List(
@@ -366,7 +372,7 @@ mod test {
     #[case(ListArray::try_new(
         buffer![10i32, 20, 30, 40, 50].into_array(),
         buffer![0, 2, 3, 4, 5].into_array(),
-        Validity::Array(BoolArray::from_iter(vec![true, false, true, true]).to_array()),
+        Validity::Array(BoolArray::from_iter(vec![true, false, true, true]).into_array()),
     ).unwrap())]
     #[case(ListArray::try_new(
         buffer![1i32, 2, 3].into_array(),
@@ -386,17 +392,17 @@ mod test {
         }
         ListArray::try_new(
             elements,
-            PrimitiveArray::from_iter(offsets).to_array(),
+            PrimitiveArray::from_iter(offsets).into_array(),
             Validity::NonNullable,
         ).unwrap()
     })]
     #[case(ListArray::try_new(
-        PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]).to_array(),
+        PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]).into_array(),
         buffer![0, 2, 3, 5].into_array(),
         Validity::NonNullable,
     ).unwrap())]
     fn test_take_list_conformance(#[case] list: ListArray) {
-        test_take_conformance(list.as_ref());
+        test_take_conformance(&list.into_array());
     }
 
     #[test]
@@ -405,11 +411,11 @@ mod test {
         let offsets = buffer![0u8, 200].into_array();
         let list = ListArray::try_new(elements, offsets, Validity::NonNullable)
             .unwrap()
-            .to_array();
+            .into_array();
 
         // Take the same large list twice - would overflow u8 but works with u64.
         let idx = buffer![0u8, 0].into_array();
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
 
         assert_eq!(result.len(), 2);
 
@@ -423,14 +429,14 @@ mod test {
     fn test_u64_offset_accumulation_nullable() {
         let elements = buffer![0i32; 150].into_array();
         let offsets = buffer![0u8, 150, 150].into_array();
-        let validity = BoolArray::from_iter(vec![true, false]).to_array();
+        let validity = BoolArray::from_iter(vec![true, false]).into_array();
         let list = ListArray::try_new(elements, offsets, Validity::Array(validity))
             .unwrap()
-            .to_array();
+            .into_array();
 
         // Take the same large list twice - would overflow u8 but works with u64.
-        let idx = PrimitiveArray::from_option_iter(vec![Some(0u8), None, Some(0u8)]).to_array();
-        let result = list.take(idx.to_array()).unwrap();
+        let idx = PrimitiveArray::from_option_iter(vec![Some(0u8), None, Some(0u8)]).into_array();
+        let result = list.take(idx).unwrap();
 
         assert_eq!(result.len(), 3);
 
@@ -451,16 +457,16 @@ mod test {
         let list = ListArray::try_new(
             buffer![1i32, 2, 3, 4].into_array(),
             buffer![0, 2, 4].into_array(),
-            Validity::Array(BoolArray::from_iter(vec![true, true]).to_array()),
+            Validity::Array(BoolArray::from_iter(vec![true, true]).into_array()),
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         // Take more indices than source length (4 vs 2) with non-nullable indices.
         let idx = buffer![0u32, 1, 0, 1].into_array();
 
         // This should not panic - result should have length 4.
-        let result = list.take(idx.to_array()).unwrap();
+        let result = list.take(idx).unwrap();
         assert_eq!(result.len(), 4);
     }
 }
diff --git a/vortex-array/src/arrays/list/mod.rs b/vortex-array/src/arrays/list/mod.rs
index f84f9904f41..c884f343a10 100644
--- a/vortex-array/src/arrays/list/mod.rs
+++ b/vortex-array/src/arrays/list/mod.rs
@@ -2,13 +2,15 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::ListArray;
-pub use array::ListArrayParts;
+pub use array::ListArrayExt;
+pub use array::ListData;
+pub use array::ListDataParts;
+pub use vtable::ListArray;
 
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::ListVTable;
+pub use vtable::List;
 
 #[cfg(feature = "_test-harness")]
 mod test_harness;
diff --git a/vortex-array/src/arrays/list/test_harness.rs b/vortex-array/src/arrays/list/test_harness.rs
index 7ced1eb878f..42351484c19 100644
--- a/vortex-array/src/arrays/list/test_harness.rs
+++ b/vortex-array/src/arrays/list/test_harness.rs
@@ -28,7 +28,7 @@ impl ListArray {
     {
         let iter = iter.into_iter();
         let mut builder = ListBuilder::<O>::with_capacity(
-            dtype.clone(),
+            Arc::clone(&dtype),
             crate::dtype::Nullability::NonNullable,
             2 * iter.size_hint().0,
             iter.size_hint().0,
@@ -36,7 +36,7 @@ impl ListArray {
 
         for v in iter {
             let elem = Scalar::list(
-                dtype.clone(),
+                Arc::clone(&dtype),
                 v.into_iter().map(|x| x.into()).collect_vec(),
                 dtype.nullability(),
             );
@@ -55,7 +55,7 @@ impl ListArray {
     {
         let iter = iter.into_iter();
         let mut builder = ListBuilder::<O>::with_capacity(
-            dtype.clone(),
+            Arc::clone(&dtype),
             crate::dtype::Nullability::Nullable,
             2 * iter.size_hint().0,
             iter.size_hint().0,
@@ -64,7 +64,7 @@ impl ListArray {
         for v in iter {
             if let Some(v) = v {
                 let elem = Scalar::list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     v.into_iter().map(|x| x.into()).collect_vec(),
                     dtype.nullability(),
                 );
diff --git a/vortex-array/src/arrays/list/tests.rs b/vortex-array/src/arrays/list/tests.rs
index 9d63372ba6b..e2e7407d111 100644
--- a/vortex-array/src/arrays/list/tests.rs
+++ b/vortex-array/src/arrays/list/tests.rs
@@ -15,7 +15,7 @@ use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::arrays::FilterArray;
-use crate::arrays::ListVTable;
+use crate::arrays::List;
 use crate::arrays::PrimitiveArray;
 use crate::assert_arrays_eq;
 use crate::builders::ArrayBuilder;
@@ -430,7 +430,7 @@ fn test_offset_to_0() {
     assert_eq!(list.len(), 2);
 
     // For a sliced ListArray, we need to check it's still a ListArray
-    let list_array = list.as_::<ListVTable>();
+    let list_array = list.as_::<List>();
 
     // Check the offsets array has correct length (n+1 for n lists)
     assert_eq!(list_array.offsets().len(), 3);
@@ -592,7 +592,7 @@ fn test_list_of_lists() {
 
     // Access the first list of lists and verify its contents.
     let first_outer = list_of_lists.list_elements_at(0).unwrap();
-    let first_outer_list = first_outer.as_::<ListVTable>();
+    let first_outer_list = first_outer.as_::<List>();
     assert_eq!(first_outer_list.len(), 2);
 
     // Check first inner list [1, 2].
@@ -605,7 +605,7 @@ fn test_list_of_lists() {
 
     // Check the second list of lists [[4, 5, 6]].
     let second_outer = list_of_lists.list_elements_at(1).unwrap();
-    let second_outer_list = second_outer.as_::<ListVTable>();
+    let second_outer_list = second_outer.as_::<List>();
     assert_eq!(second_outer_list.len(), 1);
 
     let inner = second_outer_list.list_elements_at(0).unwrap();
@@ -618,7 +618,7 @@ fn test_list_of_lists() {
 
     // Check the fourth list of lists [[7]].
     let fourth_outer = list_of_lists.list_elements_at(3).unwrap();
-    let fourth_outer_list = fourth_outer.as_::<ListVTable>();
+    let fourth_outer_list = fourth_outer.as_::<List>();
     assert_eq!(fourth_outer_list.len(), 1);
 
     let inner = fourth_outer_list.list_elements_at(0).unwrap();
@@ -632,12 +632,12 @@ fn test_list_of_lists() {
 
     // Test slicing.
     let sliced = list_of_lists.slice(1..3).unwrap();
-    let sliced_list = sliced.as_::<ListVTable>();
+    let sliced_list = sliced.as_::<List>();
     assert_eq!(sliced_list.len(), 2);
 
     // First element of slice should be [[4, 5, 6]].
     let first_sliced = sliced_list.list_elements_at(0).unwrap();
-    let first_sliced_list = first_sliced.as_::<ListVTable>();
+    let first_sliced_list = first_sliced.as_::<List>();
     assert_eq!(first_sliced_list.len(), 1);
 
     // Second element of slice should be empty [].
@@ -679,14 +679,14 @@ fn test_list_of_lists_nullable_outer() {
 
     // Third element should be [[4, 5, 6]].
     let third = list_of_lists.list_elements_at(2).unwrap();
-    let third_list = third.as_::<ListVTable>();
+    let third_list = third.as_::<List>();
     assert_eq!(third_list.len(), 1);
     let inner = third_list.list_elements_at(0).unwrap();
     assert_eq!(inner.len(), 3);
 
     // Fourth element should be [[7]].
     let fourth = list_of_lists.list_elements_at(3).unwrap();
-    let fourth_list = fourth.as_::<ListVTable>();
+    let fourth_list = fourth.as_::<List>();
     assert_eq!(fourth_list.len(), 1);
 }
 
@@ -723,11 +723,11 @@ fn test_list_of_lists_nullable_inner() {
 
     // First outer list should have 3 inner lists with the second being null.
     let first_outer = list_of_lists.list_elements_at(0).unwrap();
-    let first_list = first_outer.as_::<ListVTable>();
+    let first_list = first_outer.as_::<List>();
     assert_eq!(first_list.len(), 3);
 
     // Check that second inner list is null.
-    let second_inner = first_list.scalar_at(1).unwrap();
+    let second_inner = first_list.array().scalar_at(1).unwrap();
     assert!(second_inner.is_null());
 }
 
@@ -758,7 +758,7 @@ fn test_list_of_lists_both_nullable() {
     let first_outer = list_of_lists.scalar_at(0).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_::<ListVTable>();
+    let first_list = first_outer_array.as_::<List>();
     assert_eq!(first_list.len(), 2);
 
     // First inner list should be [1, 2].
@@ -766,7 +766,7 @@ fn test_list_of_lists_both_nullable() {
     assert_eq!(first_inner.len(), 2);
 
     // Second inner list should be null.
-    let second_inner = first_list.scalar_at(1).unwrap();
+    let second_inner = first_list.array().scalar_at(1).unwrap();
     assert!(second_inner.is_null());
 
     // Second outer list should be null.
@@ -775,16 +775,16 @@ fn test_list_of_lists_both_nullable() {
 
     // Third outer list should have [3].
     let third_outer = list_of_lists.list_elements_at(2).unwrap();
-    let third_list = third_outer.as_::<ListVTable>();
+    let third_list = third_outer.as_::<List>();
     assert_eq!(third_list.len(), 1);
     let inner = third_list.list_elements_at(0).unwrap();
     assert_arrays_eq!(inner, PrimitiveArray::from_iter([3]));
 
     // Fourth outer list should have a null inner list.
     let fourth_outer = list_of_lists.list_elements_at(3).unwrap();
-    let fourth_list = fourth_outer.as_::<ListVTable>();
+    let fourth_list = fourth_outer.as_::<List>();
     assert_eq!(fourth_list.len(), 1);
-    let inner = fourth_list.scalar_at(0).unwrap();
+    let inner = fourth_list.array().scalar_at(0).unwrap();
     assert!(inner.is_null());
 }
 
@@ -890,7 +890,7 @@ fn test_recursive_compact_list_of_lists() {
     let original = create_list_of_lists_nullable(nested_data);
     // Slice to remove prefix - creates wasted space since offsets no longer reference early elements
     let sliced = original.slice(1..3).unwrap();
-    let sliced_list = sliced.as_::<ListVTable>();
+    let sliced_list = sliced.as_::<List>();
 
     // Test non-recursive compaction: only resets outer list offsets
     let non_recursive = sliced_list.reset_offsets(false).unwrap();
@@ -901,8 +901,10 @@ fn test_recursive_compact_list_of_lists() {
     assert_eq!(recursive.len(), 2);
 
     // Check the flattened elements - this shows the actual compaction difference
-    let non_recursive_flat_elements = non_recursive.elements().as_::<ListVTable>().elements();
-    let recursive_flat_elements = recursive.elements().as_::<ListVTable>().elements();
+    let non_recursive_inner = non_recursive.elements().as_::<List>();
+    let non_recursive_flat_elements = non_recursive_inner.elements();
+    let recursive_inner = recursive.elements().as_::<List>();
+    let recursive_flat_elements = recursive_inner.elements();
 
     // Non-recursive should still have all original elements [1,2,3,4,5,6,7,8,9,10,11,12]
     assert_eq!(non_recursive_flat_elements.len(), 12);
@@ -911,9 +913,11 @@ fn test_recursive_compact_list_of_lists() {
     assert_eq!(recursive_flat_elements.len(), 7);
 
     // Verify data integrity is preserved
+    let non_recursive_array = non_recursive.into_array();
+    let recursive_array = recursive.into_array();
     assert_eq!(
-        non_recursive.scalar_at(0).unwrap(),
-        recursive.scalar_at(0).unwrap()
+        non_recursive_array.scalar_at(0).unwrap(),
+        recursive_array.scalar_at(0).unwrap()
     );
 }
 
diff --git a/vortex-array/src/arrays/list/vtable/array.rs b/vortex-array/src/arrays/list/vtable/array.rs
deleted file mode 100644
index e2897ca1bb2..00000000000
--- a/vortex-array/src/arrays/list/vtable/array.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ListVTable> for ListVTable {
-    fn len(array: &ListArray) -> usize {
-        array.offsets.len().saturating_sub(1)
-    }
-
-    fn dtype(array: &ListArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ListArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &ListArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.elements.array_hash(state, precision);
-        array.offsets.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &ListArray, other: &ListArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.elements.array_eq(&other.elements, precision)
-            && array.offsets.array_eq(&other.offsets, precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/list/vtable/mod.rs b/vortex-array/src/arrays/list/vtable/mod.rs
index c61ffa6580b..d9624f49560 100644
--- a/vortex-array/src/arrays/list/vtable/mod.rs
+++ b/vortex-array/src/arrays/list/vtable/mod.rs
@@ -1,40 +1,45 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use prost::Message;
 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 crate::Array;
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::ProstMetadata;
-use crate::arrays::ListArray;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::list::ListData;
+use crate::arrays::list::array::NUM_SLOTS;
+use crate::arrays::list::array::SLOT_NAMES;
 use crate::arrays::list::compute::PARENT_KERNELS;
 use crate::arrays::list::compute::rules::PARENT_RULES;
-use crate::arrays::list_view_from_list;
+use crate::arrays::listview::list_view_from_list;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
-use crate::metadata::DeserializeMetadata;
-use crate::metadata::SerializeMetadata;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod operations;
 mod validity;
-mod visitor;
-
-vtable!(List);
+/// A [`List`]-encoded Vortex array.
+pub type ListArray = Array<List>;
 
 #[derive(Clone, prost::Message)]
 pub struct ListMetadata {
@@ -44,58 +49,106 @@ pub struct ListMetadata {
     offset_ptype: i32,
 }
 
-impl VTable for ListVTable {
-    type Array = ListArray;
+impl ArrayHash for ListData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
 
-    type Metadata = ProstMetadata<ListMetadata>;
+impl ArrayEq for ListData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+
+impl VTable for List {
+    type ArrayData = ListData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ListArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("ListArray buffer_name index {idx} out of bounds")
+    }
+
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn metadata(array: &ListArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ListMetadata {
-            elements_len: array.elements().len() as u64,
-            offset_ptype: PType::try_from(array.offsets().dtype())? as i32,
-        }))
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            ListMetadata {
+                elements_len: array.elements().len() as u64,
+                offset_ptype: PType::try_from(array.offsets().dtype())? as i32,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(SerializeMetadata::serialize(metadata)))
-    }
+    fn validate(
+        &self,
+        _data: &ListData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == NUM_SLOTS,
+            "ListArray expected {NUM_SLOTS} slots, found {}",
+            slots.len()
+        );
+        let elements = slots[crate::arrays::list::array::ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("ListArray elements slot");
+        let offsets = slots[crate::arrays::list::array::OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("ListArray offsets slot");
+        vortex_ensure!(
+            offsets.len().saturating_sub(1) == len,
+            "ListArray length {} does not match outer length {}",
+            offsets.len().saturating_sub(1),
+            len
+        );
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(
-            <ProstMetadata<ListMetadata> as DeserializeMetadata>::deserialize(bytes)?,
-        ))
+        let actual_dtype = DType::List(Arc::new(elements.dtype().clone()), dtype.nullability());
+        vortex_ensure!(
+            &actual_dtype == dtype,
+            "ListArray dtype {} does not match outer dtype {}",
+            actual_dtype,
+            dtype
+        );
+
+        Ok(())
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
+
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ListArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = ListMetadata::decode(metadata)?;
         let validity = if children.len() == 2 {
             Validity::from(dtype.nullability())
         } else if children.len() == 3 {
@@ -111,49 +164,32 @@ impl VTable for ListVTable {
         let elements = children.get(
             0,
             element_dtype.as_ref(),
-            usize::try_from(metadata.0.elements_len)?,
+            usize::try_from(metadata.elements_len)?,
         )?;
 
         let offsets = children.get(
             1,
-            &DType::Primitive(metadata.0.offset_ptype(), Nullability::NonNullable),
+            &DType::Primitive(metadata.offset_ptype(), Nullability::NonNullable),
             len + 1,
         )?;
 
-        ListArray::try_new(elements, offsets, validity)
+        let data = ListData::try_build(elements.clone(), offsets.clone(), validity.clone())?;
+        let slots = ListData::make_slots(&elements, &offsets, &validity, len);
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 2 || children.len() == 3,
-            "ListArray expects 2 or 3 children, got {}",
-            children.len()
-        );
-
-        let mut iter = children.into_iter();
-        let elements = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let offsets = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let validity = if let Some(validity_array) = iter.next() {
-            Validity::Array(validity_array)
-        } else {
-            Validity::from(array.dtype.nullability())
-        };
-
-        let new_array = ListArray::try_new(elements, offsets, validity)?;
-        *array = new_array;
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(list_view_from_list(array.clone(), ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            list_view_from_list(array, ctx)?.into_array(),
+        ))
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -162,9 +198,9 @@ impl VTable for ListVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct ListVTable;
+#[derive(Clone, Debug)]
+pub struct List;
 
-impl ListVTable {
+impl List {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.list");
 }
diff --git a/vortex-array/src/arrays/list/vtable/operations.rs b/vortex-array/src/arrays/list/vtable/operations.rs
index c326786a510..c9fc69c7bbe 100644
--- a/vortex-array/src/arrays/list/vtable/operations.rs
+++ b/vortex-array/src/arrays/list/vtable/operations.rs
@@ -5,13 +5,19 @@ use std::sync::Arc;
 
 use vortex_error::VortexResult;
 
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::List;
+use crate::arrays::list::ListArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<ListVTable> for ListVTable {
-    fn scalar_at(array: &ListArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<List> for List {
+    fn scalar_at(
+        array: ArrayView<'_, List>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // By the preconditions we know that the list scalar is not null.
         let elems = array.list_elements_at(index)?;
         let scalars: Vec<Scalar> = (0..elems.len())
diff --git a/vortex-array/src/arrays/list/vtable/validity.rs b/vortex-array/src/arrays/list/vtable/validity.rs
index 3accef4d97c..679468529a4 100644
--- a/vortex-array/src/arrays/list/vtable/validity.rs
+++ b/vortex-array/src/arrays/list/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::ListArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::list::vtable::List;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for ListArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<List> for List {
+    fn validity(array: ArrayView<'_, List>) -> VortexResult<Validity> {
+        Ok(array.list_validity())
     }
 }
diff --git a/vortex-array/src/arrays/list/vtable/visitor.rs b/vortex-array/src/arrays/list/vtable/visitor.rs
deleted file mode 100644
index c69530dd922..00000000000
--- a/vortex-array/src/arrays/list/vtable/visitor.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<ListVTable> for ListVTable {
-    fn visit_buffers(_array: &ListArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &ListArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ListArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("elements", array.elements());
-        visitor.visit_child("offsets", array.offsets());
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &ListArray) -> usize {
-        2 + validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &ListArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.elements().clone()),
-            1 => Some(array.offsets().clone()),
-            2 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/listview/array.rs b/vortex-array/src/arrays/listview/array.rs
index b71b13f59cb..72c376b2f44 100644
--- a/vortex-array/src/arrays/listview/array.rs
+++ b/vortex-array/src/arrays/listview/array.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::sync::Arc;
 
 use num_traits::AsPrimitive;
@@ -10,18 +12,40 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ToCanonical;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::ListView;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
 use crate::arrays::bool;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::match_each_integer_ptype;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// The `elements` data array, where each list scalar is a _slice_ of the `elements` array, and
+/// each inner list element is a _scalar_ of the `elements` array.
+pub(super) const ELEMENTS_SLOT: usize = 0;
+/// The `offsets` array indicating the start position of each list in elements.
+///
+/// Since we also store `sizes`, this `offsets` field is allowed to be stored out-of-order
+/// (which is different from [`ListArray`](crate::arrays::ListArray)).
+pub(super) const OFFSETS_SLOT: usize = 1;
+/// The `sizes` array indicating the length of each list.
+///
+/// This field is intended to be paired with a corresponding offset to determine the list scalar
+/// we want to access.
+pub(super) const SIZES_SLOT: usize = 2;
+/// The validity bitmap indicating which list elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 3;
+pub(super) const NUM_SLOTS: usize = 4;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["elements", "offsets", "sizes", "validity"];
+
 /// The canonical encoding for variable-length list arrays.
 ///
 /// The `ListViewArray` encoding differs from [`ListArray`] in that it stores a child `sizes` array
@@ -49,6 +73,7 @@ use crate::validity::Validity;
 /// ```
 /// # fn main() -> vortex_error::VortexResult<()> {
 /// # use vortex_array::arrays::{ListViewArray, PrimitiveArray};
+/// # use vortex_array::arrays::listview::ListViewArrayExt;
 /// # use vortex_array::validity::Validity;
 /// # use vortex_array::IntoArray;
 /// # use vortex_buffer::buffer;
@@ -85,28 +110,7 @@ use crate::validity::Validity;
 ///
 /// [`ListArray`]: crate::arrays::ListArray
 #[derive(Clone, Debug)]
-pub struct ListViewArray {
-    /// The [`DType`] of the list array.
-    ///
-    /// This type **must** be the variant [`DType::List`].
-    pub(super) dtype: DType,
-
-    /// The `elements` data array, where each list scalar is a _slice_ of the `elements` array, and
-    /// each inner list element is a _scalar_ of the `elements` array.
-    elements: ArrayRef,
-
-    /// The `offsets` array indicating the start position of each list in elements.
-    ///
-    /// Since we also store `sizes`, this `offsets` field is allowed to be stored out-of-order
-    /// (which is different from [`ListArray`](crate::arrays::ListArray)),
-    offsets: ArrayRef,
-
-    /// The `sizes` array indicating the length of each list.
-    ///
-    /// This field is intended to be paired with a corresponding offset to determine the list scalar
-    /// we want to access.
-    sizes: ArrayRef,
-
+pub struct ListViewData {
     // TODO(connor)[ListView]: Add the n+1 memory allocation optimization.
     /// A flag denoting if the array is zero-copyable* to a [`ListArray`](crate::arrays::ListArray).
     ///
@@ -116,18 +120,15 @@ pub struct ListViewArray {
     /// `offsets[i] + sizes[i]` are in order), conversions can bypass the very expensive rebuild
     /// process which must rebuild the array from scratch.
     is_zero_copy_to_list: bool,
+}
 
-    /// The validity / null map of the array.
-    ///
-    /// Note that this null map refers to which list scalars are null, **not** which sub-elements of
-    /// list scalars are null. The `elements` array will track individual value nullability.
-    pub(super) validity: Validity,
-
-    /// The stats for this array.
-    pub(super) stats_set: ArrayStats,
+impl Display for ListViewData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "is_zero_copy_to_list: {}", self.is_zero_copy_to_list)
+    }
 }
 
-pub struct ListViewArrayParts {
+pub struct ListViewDataParts {
     pub elements_dtype: Arc<DType>,
 
     /// See `ListViewArray::elements`
@@ -143,16 +144,32 @@ pub struct ListViewArrayParts {
     pub validity: Validity,
 }
 
-impl ListViewArray {
-    /// Creates a new [`ListViewArray`].
+impl ListViewData {
+    pub(crate) fn make_slots(
+        elements: &ArrayRef,
+        offsets: &ArrayRef,
+        sizes: &ArrayRef,
+        validity: &Validity,
+        len: usize,
+    ) -> Vec<Option<ArrayRef>> {
+        vec![
+            Some(elements.clone()),
+            Some(offsets.clone()),
+            Some(sizes.clone()),
+            validity_to_child(validity, len),
+        ]
+    }
+
+    /// Creates a new `ListViewArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`ListViewArray::new_unchecked`].
-    pub fn new(elements: ArrayRef, offsets: ArrayRef, sizes: ArrayRef, validity: Validity) -> Self {
-        Self::try_new(elements, offsets, sizes, validity)
-            .vortex_expect("`ListViewArray` construction failed")
+    /// in `ListViewArray::new_unchecked`.
+    pub fn new() -> Self {
+        Self {
+            is_zero_copy_to_list: false,
+        }
     }
 
     /// Constructs a new `ListViewArray`.
@@ -160,27 +177,12 @@ impl ListViewArray {
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented
-    /// in [`ListViewArray::new_unchecked`].
-    pub fn try_new(
-        elements: ArrayRef,
-        offsets: ArrayRef,
-        sizes: ArrayRef,
-        validity: Validity,
-    ) -> VortexResult<Self> {
-        Self::validate(&elements, &offsets, &sizes, &validity)?;
-
-        Ok(Self {
-            dtype: DType::List(Arc::new(elements.dtype().clone()), validity.nullability()),
-            elements,
-            offsets,
-            sizes,
-            validity,
-            is_zero_copy_to_list: false,
-            stats_set: Default::default(),
-        })
+    /// in `ListViewArray::new_unchecked`.
+    pub fn try_new() -> VortexResult<Self> {
+        Ok(Self::new())
     }
 
-    /// Creates a new [`ListViewArray`] without validation.
+    /// Creates a new `ListViewArray` without validation.
     ///
     /// This unsafe function does not check the validity of the data. Prefer calling [`new()`] or
     /// [`try_new()`] over this function, as they will check the validity of the data.
@@ -199,33 +201,15 @@ impl ListViewArray {
     /// - For each `i`, `offsets[i] + sizes[i]` must not overflow and must be `<= elements.len()`
     ///   (even if the corresponding view is defined as null by the validity array).
     /// - If validity is an array, its length must equal `offsets.len()`.
-    pub unsafe fn new_unchecked(
-        elements: ArrayRef,
-        offsets: ArrayRef,
-        sizes: ArrayRef,
-        validity: Validity,
-    ) -> Self {
-        if cfg!(debug_assertions) {
-            Self::validate(&elements, &offsets, &sizes, &validity)
-                .vortex_expect("Failed to crate `ListViewArray`");
-        }
-
-        Self {
-            dtype: DType::List(Arc::new(elements.dtype().clone()), validity.nullability()),
-            elements,
-            offsets,
-            sizes,
-            validity,
-            is_zero_copy_to_list: false,
-            stats_set: Default::default(),
-        }
+    pub unsafe fn new_unchecked() -> Self {
+        Self::new()
     }
 
-    /// Validates the components that would be used to create a [`ListViewArray`].
+    /// Validates the components that would be used to create a `ListViewArray`.
     pub fn validate(
-        elements: &dyn Array,
-        offsets: &dyn Array,
-        sizes: &dyn Array,
+        elements: &ArrayRef,
+        offsets: &ArrayRef,
+        sizes: &ArrayRef,
         validity: &Validity,
     ) -> VortexResult<()> {
         // Check that offsets and sizes are integer arrays and non-nullable.
@@ -284,7 +268,7 @@ impl ListViewArray {
         Ok(())
     }
 
-    /// Sets whether this [`ListViewArray`] is zero-copyable to a [`ListArray`].
+    /// Sets whether this `ListViewArray` is zero-copyable to a [`ListArray`].
     ///
     /// This is an optimization flag that enables more efficient conversion to [`ListArray`] without
     /// needing to copy or reorganize the data.
@@ -293,7 +277,7 @@ impl ListViewArray {
     ///
     /// # Safety
     ///
-    /// When setting `is_zctl` to `true`, the caller must ensure that the [`ListViewArray`] is
+    /// When setting `is_zctl` to `true`, the caller must ensure that the `ListViewArray` is
     /// actually zero-copyable to a [`ListArray`]. This means:
     ///
     /// - Offsets must be sorted (but not strictly sorted, zero-length lists are allowed).
@@ -303,74 +287,68 @@ impl ListViewArray {
     ///
     /// Note that leading and trailing unreferenced elements **ARE** allowed.
     pub unsafe fn with_zero_copy_to_list(mut self, is_zctl: bool) -> Self {
-        if cfg!(debug_assertions) && is_zctl {
-            validate_zctl(
-                &self.elements,
-                self.offsets.to_primitive(),
-                self.sizes.to_primitive(),
-            )
-            .vortex_expect("Failed to validate zero-copy to list flag");
-        }
         self.is_zero_copy_to_list = is_zctl;
         self
     }
 
-    /// Verifies that the `ListViewArray` is zero-copyable to a [`ListArray`].
-    ///
-    /// This will run an expensive validation of the `ListViewArray`'s components. It will check the
-    /// following things:
-    ///
-    /// - Offsets must be sorted (but not strictly sorted, zero-length lists are allowed).
-    /// - No gaps in elements between first and last referenced elements.
-    /// - No overlapping list views (each element referenced at most once).
-    ///
-    /// Note that leading and trailing unreferenced elements **ARE** allowed.
-    ///
-    /// This method should really only be called if the caller knows that the `ListViewArray` will
-    /// be converted into a [`ListArray`] in the future, and the caller wants to set the
-    /// optimization flag to `true` with the unsafe [`with_zero_copy_to_list`] method.
-    ///
-    /// [`ListArray`]: crate::arrays::ListArray
-    /// [`with_zero_copy_to_list`]: Self::with_zero_copy_to_list
-    pub fn verify_is_zero_copy_to_list(&self) -> bool {
-        validate_zctl(
-            &self.elements,
-            self.offsets.to_primitive(),
-            self.sizes.to_primitive(),
-        )
-        .is_ok()
+    /// Returns true if the `ListViewArray` is zero-copyable to a
+    /// [`ListArray`](crate::arrays::ListArray).
+    pub fn is_zero_copy_to_list(&self) -> bool {
+        self.is_zero_copy_to_list
     }
+}
 
-    pub fn into_parts(self) -> ListViewArrayParts {
-        let dtype = self.dtype.into_list_element_opt().vortex_expect("is list");
-        ListViewArrayParts {
-            elements_dtype: dtype,
-            elements: self.elements,
-            offsets: self.offsets,
-            sizes: self.sizes,
-            validity: self.validity,
+impl Default for ListViewData {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub trait ListViewArrayExt: TypedArrayRef<ListView> {
+    fn nullability(&self) -> crate::dtype::Nullability {
+        match self.as_ref().dtype() {
+            DType::List(_, nullability) => *nullability,
+            _ => unreachable!("ListViewArrayExt requires a list dtype"),
         }
     }
 
-    /// Returns the offset at the given index.
-    ///
-    /// Note that it is possible the corresponding list view is null (which is only defined by the
-    /// validity map). Regardless, we are still guaranteed that this offset is valid by the
-    /// invariants of [`ListViewArray`].
-    pub fn offset_at(&self, index: usize) -> usize {
+    fn elements(&self) -> &ArrayRef {
+        self.as_ref().slots()[ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray elements slot")
+    }
+
+    fn offsets(&self) -> &ArrayRef {
+        self.as_ref().slots()[OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray offsets slot")
+    }
+
+    fn sizes(&self) -> &ArrayRef {
+        self.as_ref().slots()[SIZES_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray sizes slot")
+    }
+
+    fn listview_validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn listview_validity_mask(&self) -> vortex_mask::Mask {
+        self.listview_validity().to_mask(self.as_ref().len())
+    }
+
+    fn offset_at(&self, index: usize) -> usize {
         assert!(
-            index < self.len(),
+            index < self.as_ref().len(),
             "Index {index} out of bounds 0..{}",
-            self.len()
+            self.as_ref().len()
         );
-
-        // Fast path for `PrimitiveArray`.
-        self.offsets
-            .as_opt::<PrimitiveVTable>()
+        self.offsets()
+            .as_opt::<Primitive>()
             .map(|p| match_each_integer_ptype!(p.ptype(), |P| { p.as_slice::<P>()[index].as_() }))
             .unwrap_or_else(|| {
-                // Slow path: use `scalar_at` if we can't downcast directly to `PrimitiveArray`.
-                self.offsets
+                self.offsets()
                     .scalar_at(index)
                     .vortex_expect("offsets must support scalar_at")
                     .as_primitive()
@@ -379,26 +357,18 @@ impl ListViewArray {
             })
     }
 
-    /// Returns the size at the given index.
-    ///
-    /// Note that it is possible the corresponding list view is null (which is only defined by the
-    /// validity map). Regardless, we are still guaranteed that this size is valid by the invariants
-    /// of [`ListViewArray`].
-    pub fn size_at(&self, index: usize) -> usize {
+    fn size_at(&self, index: usize) -> usize {
         assert!(
-            index < self.len(),
+            index < self.as_ref().len(),
             "Index {} out of bounds 0..{}",
             index,
-            self.len()
+            self.as_ref().len()
         );
-
-        // Fast path for `PrimitiveArray`.
-        self.sizes
-            .as_opt::<PrimitiveVTable>()
+        self.sizes()
+            .as_opt::<Primitive>()
             .map(|p| match_each_integer_ptype!(p.ptype(), |P| { p.as_slice::<P>()[index].as_() }))
             .unwrap_or_else(|| {
-                // Slow path: use `scalar_at` if we can't downcast directly to `PrimitiveArray`.
-                self.sizes
+                self.sizes()
                     .scalar_at(index)
                     .vortex_expect("sizes must support scalar_at")
                     .as_primitive()
@@ -407,36 +377,123 @@ impl ListViewArray {
             })
     }
 
-    /// Returns the elements at the given index from the list array.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the slice operation fails.
-    pub fn list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
+    fn list_elements_at(&self, index: usize) -> VortexResult<ArrayRef> {
         let offset = self.offset_at(index);
         let size = self.size_at(index);
         self.elements().slice(offset..offset + size)
     }
 
-    /// Returns the offsets array.
-    pub fn offsets(&self) -> &ArrayRef {
-        &self.offsets
+    fn verify_is_zero_copy_to_list(&self) -> bool {
+        validate_zctl(
+            self.elements(),
+            self.offsets().to_primitive(),
+            self.sizes().to_primitive(),
+        )
+        .is_ok()
     }
+}
+impl<T: TypedArrayRef<ListView>> ListViewArrayExt for T {}
 
-    /// Returns the sizes array.
-    pub fn sizes(&self) -> &ArrayRef {
-        &self.sizes
+impl Array<ListView> {
+    /// Creates a new `ListViewArray`.
+    pub fn new(elements: ArrayRef, offsets: ArrayRef, sizes: ArrayRef, validity: Validity) -> Self {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len();
+        let slots = ListViewData::make_slots(&elements, &offsets, &sizes, &validity, len);
+        ListViewData::validate(&elements, &offsets, &sizes, &validity)
+            .vortex_expect("`ListViewArray` construction failed");
+        let data = ListViewData::new();
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ListView, dtype, len, data).with_slots(slots),
+            )
+        }
     }
 
-    /// Returns the elements array.
-    pub fn elements(&self) -> &ArrayRef {
-        &self.elements
+    /// Constructs a new `ListViewArray`.
+    pub fn try_new(
+        elements: ArrayRef,
+        offsets: ArrayRef,
+        sizes: ArrayRef,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len();
+        let slots = ListViewData::make_slots(&elements, &offsets, &sizes, &validity, len);
+        ListViewData::validate(&elements, &offsets, &sizes, &validity)?;
+        let data = ListViewData::try_new()?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ListView, dtype, len, data).with_slots(slots),
+            )
+        })
     }
 
-    /// Returns true if the `ListViewArray` is zero-copyable to a
-    /// [`ListArray`](crate::arrays::ListArray).
-    pub fn is_zero_copy_to_list(&self) -> bool {
-        self.is_zero_copy_to_list
+    /// Creates a new `ListViewArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`ListViewData::new_unchecked`].
+    pub unsafe fn new_unchecked(
+        elements: ArrayRef,
+        offsets: ArrayRef,
+        sizes: ArrayRef,
+        validity: Validity,
+    ) -> Self {
+        let dtype = DType::List(Arc::new(elements.dtype().clone()), validity.nullability());
+        let len = offsets.len();
+        let slots = ListViewData::make_slots(&elements, &offsets, &sizes, &validity, len);
+        let data = unsafe { ListViewData::new_unchecked() };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ListView, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Mark whether this list view can be zero-copy converted to a list.
+    ///
+    /// # Safety
+    ///
+    /// See [`ListViewData::with_zero_copy_to_list`].
+    pub unsafe fn with_zero_copy_to_list(self, is_zctl: bool) -> Self {
+        if cfg!(debug_assertions) && is_zctl {
+            validate_zctl(
+                self.elements(),
+                self.offsets().to_primitive(),
+                self.sizes().to_primitive(),
+            )
+            .vortex_expect("Failed to validate zero-copy to list flag");
+        }
+        let dtype = self.dtype().clone();
+        let len = self.len();
+        let slots = self.slots().to_vec();
+        let data = unsafe { self.into_data().with_zero_copy_to_list(is_zctl) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(ListView, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    pub fn into_data_parts(self) -> ListViewDataParts {
+        let elements = self.slots()[ELEMENTS_SLOT]
+            .clone()
+            .vortex_expect("ListViewArray elements slot");
+        let offsets = self.slots()[OFFSETS_SLOT]
+            .clone()
+            .vortex_expect("ListViewArray offsets slot");
+        let sizes = self.slots()[SIZES_SLOT]
+            .clone()
+            .vortex_expect("ListViewArray sizes slot");
+        let validity = self.listview_validity();
+        ListViewDataParts {
+            elements_dtype: Arc::new(elements.dtype().clone()),
+            elements,
+            offsets,
+            sizes,
+            validity,
+        }
     }
 }
 
@@ -491,10 +548,10 @@ where
     Ok(())
 }
 
-/// Helper function to validate if the [`ListViewArray`] components are actually zero-copyable to
+/// Helper function to validate if the `ListViewArray` components are actually zero-copyable to
 /// [`ListArray`](crate::arrays::ListArray).
 fn validate_zctl(
-    elements: &dyn Array,
+    elements: &ArrayRef,
     offsets_primitive: PrimitiveArray,
     sizes_primitive: PrimitiveArray,
 ) -> VortexResult<()> {
diff --git a/vortex-array/src/arrays/listview/compute/cast.rs b/vortex-array/src/arrays/listview/compute/cast.rs
index 996b7bd94b9..77cd7ab7736 100644
--- a/vortex-array/src/arrays/listview/compute/cast.rs
+++ b/vortex-array/src/arrays/listview/compute/cast.rs
@@ -5,29 +5,25 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for ListViewVTable {
-    fn cast(array: &ListViewArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for ListView {
+    fn cast(array: ArrayView<'_, ListView>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Check if we're casting to a `List` type.
         let Some(target_element_type) = dtype.as_list_element_opt() else {
             return Ok(None);
         };
 
         // Cast the elements to the target element type.
-        let new_elements = array
-            .elements()
-            .cast((**target_element_type).clone())?
-            .to_canonical()?
-            .into_array();
+        let new_elements = array.elements().cast((**target_element_type).clone())?;
         let validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(dtype.nullability(), array.len())?;
 
         // SAFETY: Since `cast` is length-preserving, all of the invariants remain the same.
diff --git a/vortex-array/src/arrays/listview/compute/is_constant.rs b/vortex-array/src/arrays/listview/compute/is_constant.rs
deleted file mode 100644
index 5a064be752e..00000000000
--- a/vortex-array/src/arrays/listview/compute/is_constant.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::is_constant_opts;
-use crate::register_kernel;
-
-impl IsConstantKernel for ListViewVTable {
-    fn is_constant(
-        &self,
-        array: &ListViewArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        // At this point, we're guaranteed:
-        // - Array has at least 2 elements
-        // - All elements are valid (no nulls)
-
-        // First check if all list sizes are constant.
-        if !is_constant_opts(array.sizes().as_ref(), opts)?.unwrap_or_default() {
-            return Ok(Some(false));
-        }
-
-        // If checking is too expensive, return None early.
-        if opts.is_negligible_cost() {
-            return Ok(None);
-        }
-
-        // Get the first scalar for comparison.
-        debug_assert!(
-            array.len() > 1,
-            "precondition for `is_constant` is incorrect"
-        );
-        let first_scalar = array.scalar_at(0)?;
-
-        // Compare all other scalars to the first.
-        for i in 1..array.len() {
-            if array.scalar_at(i)? != first_scalar {
-                return Ok(Some(false));
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(ListViewVTable).lift());
diff --git a/vortex-array/src/arrays/listview/compute/is_sorted.rs b/vortex-array/src/arrays/listview/compute/is_sorted.rs
deleted file mode 100644
index fcc97736bb5..00000000000
--- a/vortex-array/src/arrays/listview/compute/is_sorted.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-impl IsSortedKernel for ListViewVTable {
-    fn is_sorted(&self, _array: &ListViewArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically.
-        Ok(None)
-    }
-
-    fn is_strict_sorted(&self, _array: &ListViewArray) -> VortexResult<Option<bool>> {
-        // This would require comparing lists lexicographically without duplicates.
-        Ok(None)
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(ListViewVTable).lift());
diff --git a/vortex-array/src/arrays/listview/compute/mask.rs b/vortex-array/src/arrays/listview/compute/mask.rs
index 94a6977cde6..e14233a71d0 100644
--- a/vortex-array/src/arrays/listview/compute/mask.rs
+++ b/vortex-array/src/arrays/listview/compute/mask.rs
@@ -5,14 +5,15 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for ListViewVTable {
-    fn mask(array: &ListViewArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for ListView {
+    fn mask(array: ArrayView<'_, ListView>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: masking the validity does not affect the invariants
         Ok(Some(
             unsafe {
@@ -20,10 +21,7 @@ impl MaskReduce for ListViewVTable {
                     array.elements().clone(),
                     array.offsets().clone(),
                     array.sizes().clone(),
-                    array
-                        .validity()
-                        .clone()
-                        .and(Validity::Array(mask.clone()))?,
+                    array.validity()?.and(Validity::Array(mask.clone()))?,
                 )
                 .with_zero_copy_to_list(array.is_zero_copy_to_list())
             }
diff --git a/vortex-array/src/arrays/listview/compute/min_max.rs b/vortex-array/src/arrays/listview/compute/min_max.rs
deleted file mode 100644
index 6596cc7a596..00000000000
--- a/vortex-array/src/arrays/listview/compute/min_max.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for ListViewVTable {
-    fn min_max(&self, _array: &ListViewArray) -> VortexResult<Option<MinMaxResult>> {
-        // This would require finding the lexicographically minimum and maximum lists.
-        Ok(None)
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(ListViewVTable).lift());
diff --git a/vortex-array/src/arrays/listview/compute/mod.rs b/vortex-array/src/arrays/listview/compute/mod.rs
index 45204326ebd..9a43503c4b5 100644
--- a/vortex-array/src/arrays/listview/compute/mod.rs
+++ b/vortex-array/src/arrays/listview/compute/mod.rs
@@ -2,10 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod cast;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
diff --git a/vortex-array/src/arrays/listview/compute/rules.rs b/vortex-array/src/arrays/listview/compute/rules.rs
index 2b8b19d3ed3..9b9396d7fe7 100644
--- a/vortex-array/src/arrays/listview/compute/rules.rs
+++ b/vortex-array/src/arrays/listview/compute/rules.rs
@@ -3,37 +3,38 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterVTable;
+use crate::array::ArrayView;
+use crate::arrays::Filter;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::dict::TakeReduceAdaptor;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
-use crate::vtable::ValidityHelper;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<ListViewVTable> = ParentRuleSet::new(&[
+pub(crate) const PARENT_RULES: ParentRuleSet<ListView> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&ListViewFilterPushDown),
-    ParentRuleSet::lift(&CastReduceAdaptor(ListViewVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(ListViewVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ListViewVTable)),
+    ParentRuleSet::lift(&CastReduceAdaptor(ListView)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(ListView)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(ListView)),
+    ParentRuleSet::lift(&TakeReduceAdaptor(ListView)),
 ]);
 
 #[derive(Debug)]
 struct ListViewFilterPushDown;
 
-impl ArrayParentReduceRule<ListViewVTable> for ListViewFilterPushDown {
-    type Parent = FilterVTable;
+impl ArrayParentReduceRule<ListView> for ListViewFilterPushDown {
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        array: &ListViewArray,
-        parent: &FilterArray,
+        array: ArrayView<'_, ListView>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // NOTE(ngates): if the filter is super selective, we maybe ought to consider masking
@@ -46,7 +47,7 @@ impl ArrayParentReduceRule<ListViewVTable> for ListViewFilterPushDown {
                     array.elements().clone(),
                     array.offsets().filter(parent.filter_mask().clone())?,
                     array.sizes().filter(parent.filter_mask().clone())?,
-                    array.validity().filter(parent.filter_mask())?,
+                    array.validity()?.filter(parent.filter_mask())?,
                 )
             }
             .into_array(),
diff --git a/vortex-array/src/arrays/listview/compute/slice.rs b/vortex-array/src/arrays/listview/compute/slice.rs
index 7c6ec0951d5..2dd29278392 100644
--- a/vortex-array/src/arrays/listview/compute/slice.rs
+++ b/vortex-array/src/arrays/listview/compute/slice.rs
@@ -7,12 +7,14 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for ListViewVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for ListView {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             unsafe {
                 ListViewArray::new_unchecked(
diff --git a/vortex-array/src/arrays/listview/compute/take.rs b/vortex-array/src/arrays/listview/compute/take.rs
index 2930a356215..5cfadd40214 100644
--- a/vortex-array/src/arrays/listview/compute/take.rs
+++ b/vortex-array/src/arrays/listview/compute/take.rs
@@ -4,19 +4,18 @@
 use num_traits::Zero;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewRebuildMode;
-use crate::arrays::ListViewVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewRebuildMode;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::Nullability;
-use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
 use crate::scalar::Scalar;
-use crate::vtable::ValidityHelper;
 
 // TODO(connor)[ListView]: Make use of this threshold after we start migrating operators.
 /// The threshold for triggering a rebuild of the [`ListViewArray`].
@@ -42,24 +41,20 @@ const REBUILD_DENSITY_THRESHOLD: f64 = 0.1;
 ///
 /// The trade-off is that we may keep unreferenced elements in memory, but this is acceptable since
 /// we're optimizing for read performance and the data isn't being copied.
-impl TakeExecute for ListViewVTable {
-    fn take(
-        array: &ListViewArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
+impl TakeReduce for ListView {
+    fn take(array: ArrayView<'_, ListView>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let elements = array.elements();
         let offsets = array.offsets();
         let sizes = array.sizes();
 
         // Compute the new validity by combining the array's validity with the indices' validity.
-        let new_validity = array.validity().take(indices)?;
+        let new_validity = array.validity()?.take(indices)?;
 
         // Take the offsets and sizes arrays at the requested indices.
         // Take can reorder offsets, create gaps, and may introduce overlaps if the `indices`
         // contain duplicates.
-        let nullable_new_offsets = offsets.take(indices.to_array())?;
-        let nullable_new_sizes = sizes.take(indices.to_array())?;
+        let nullable_new_offsets = offsets.take(indices.clone())?;
+        let nullable_new_sizes = sizes.take(indices.clone())?;
 
         // Since `take` returns nullable arrays, we simply cast it back to non-nullable (filled with
         // zeros to represent null lists).
diff --git a/vortex-array/src/arrays/listview/conversion.rs b/vortex-array/src/arrays/listview/conversion.rs
index 3bc3d461209..54571ecdf21 100644
--- a/vortex-array/src/arrays/listview/conversion.rs
+++ b/vortex-array/src/arrays/listview/conversion.rs
@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::sync::Arc;
-
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
@@ -16,18 +13,22 @@ use crate::arrays::ExtensionArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::ListArray;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewRebuildMode;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewRebuildMode;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builders::PrimitiveBuilder;
 use crate::dtype::IntegerPType;
 use crate::dtype::Nullability;
 use crate::match_each_integer_ptype;
-use crate::vtable::ValidityHelper;
 
-/// Creates a [`ListViewArray`] from a [`ListArray`] by computing `sizes` from `offsets`.
+/// 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
+/// 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
@@ -61,13 +62,13 @@ pub fn list_view_from_list(list: ListArray, ctx: &mut ExecutionCtx) -> VortexRes
             list.elements().clone(),
             adjusted_offsets,
             sizes,
-            list.validity().clone(),
+            list.validity()?,
         )
         .with_zero_copy_to_list(true)
     })
 }
 
-/// Builds a sizes array from a [`ListArray`] by computing differences between consecutive offsets.
+/// Builds a sizes array from a `ListArray` by computing differences between consecutive offsets.
 fn build_sizes_from_offsets<O: IntegerPType>(
     list: &ListArray,
     ctx: &mut ExecutionCtx,
@@ -99,13 +100,13 @@ fn build_sizes_from_offsets<O: IntegerPType>(
 
 // TODO(connor)[ListView]: Note that it is not exactly zero-copy because we have to add a single
 // offset at the end, but it is fast enough.
-/// Creates a [`ListArray`] from a [`ListViewArray`]. The resulting [`ListArray`] will not have any
+/// Creates a `ListArray` from a `ListViewArray`. The resulting `ListArray` will not have any
 /// leading or trailing garbage data.
 ///
-/// If [`ListViewArray::is_zero_copy_to_list`] is `true`, then this operation is fast
+/// If `ListViewArray::is_zero_copy_to_list` is `true`, then this operation is fast
 ///
 /// Otherwise, this function fall back to the (very) expensive path and will rebuild the
-/// [`ListArray`] from scratch.
+/// `ListArray` from scratch.
 pub fn list_from_list_view(list_view: ListViewArray) -> 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)?;
@@ -124,19 +125,19 @@ pub fn list_from_list_view(list_view: ListViewArray) -> VortexResult<ListArray>
         ListArray::new_unchecked(
             zctl_array.elements().clone(),
             list_offsets,
-            zctl_array.validity().clone(),
+            zctl_array.validity()?,
         )
     })
 }
 
 // TODO(connor)[ListView]: We can optimize this by always keeping extra memory in `ListViewArray`
 // offsets for an `n+1`th offset.
-/// Builds a [`ListArray`] offsets array from a [`ListViewArray`] by constructing `n+1` offsets.
+/// Builds a `ListArray` offsets array from a `ListViewArray` by constructing `n+1` offsets.
 /// The last offset is computed as `last_offset + last_size`.
 ///
 /// # Safety
 ///
-/// The [`ListViewArray`] must have offsets that are sorted, and every size must be equal to the gap
+/// The `ListViewArray` must have offsets that are sorted, and every size must be equal to the gap
 /// between `offset[i]` and `offset[i + 1]`.
 unsafe fn build_list_offsets_from_list_view<O: IntegerPType>(
     list_view: &ListViewArray,
@@ -178,7 +179,7 @@ unsafe fn build_list_offsets_from_list_view<O: IntegerPType>(
     offsets_builder.finish_into_primitive().into_array()
 }
 
-/// Recursively converts all [`ListViewArray`]s to [`ListArray`]s in a nested array structure.
+/// 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> {
@@ -195,7 +196,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
 
             // Avoid cloning if elements didn't change.
             let listview_with_converted_elements =
-                if !Arc::ptr_eq(&converted_elements, listview.elements()) {
+                if !ArrayRef::ptr_eq(&converted_elements, listview.elements()) {
                     // SAFETY: We are effectively just replacing the child elements array, which
                     // must have the same length, so all invariants are maintained.
                     unsafe {
@@ -203,7 +204,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
                             converted_elements,
                             listview.offsets().clone(),
                             listview.sizes().clone(),
-                            listview.validity().clone(),
+                            listview.validity()?,
                         )
                         .with_zero_copy_to_list(listview.is_zero_copy_to_list())
                     }
@@ -220,11 +221,11 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
                 recursive_list_from_list_view(fixed_size_list.elements().clone())?;
 
             // Avoid cloning if elements didn't change.
-            if !Arc::ptr_eq(&converted_elements, fixed_size_list.elements()) {
+            if !ArrayRef::ptr_eq(&converted_elements, fixed_size_list.elements()) {
                 FixedSizeListArray::try_new(
                     converted_elements,
                     fixed_size_list.list_size(),
-                    fixed_size_list.validity().clone(),
+                    fixed_size_list.validity()?,
                     fixed_size_list.len(),
                 )
                 .vortex_expect(
@@ -243,7 +244,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
             for field in fields.iter() {
                 let converted_field = recursive_list_from_list_view(field.clone())?;
                 // Avoid cloning if elements didn't change.
-                any_changed |= !Arc::ptr_eq(&converted_field, field);
+                any_changed |= !ArrayRef::ptr_eq(&converted_field, field);
                 converted_fields.push(converted_field);
             }
 
@@ -252,7 +253,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
                     struct_array.names().clone(),
                     converted_fields,
                     struct_array.len(),
-                    struct_array.validity().clone(),
+                    struct_array.validity()?,
                 )
                 .vortex_expect("StructArray reconstruction should not fail with valid components")
                 .into_array()
@@ -261,10 +262,11 @@ 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().clone())?;
+            let converted_storage =
+                recursive_list_from_list_view(ext_array.storage_array().clone())?;
 
             // Avoid cloning if elements didn't change.
-            if !Arc::ptr_eq(&converted_storage, ext_array.storage()) {
+            if !ArrayRef::ptr_eq(&converted_storage, ext_array.storage_array()) {
                 ExtensionArray::new(ext_array.ext_dtype().clone(), converted_storage).into_array()
             } else {
                 ext_array.into_array()
@@ -276,9 +278,9 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
 
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
 
     use super::super::tests::common::create_basic_listview;
@@ -286,8 +288,11 @@ mod tests {
     use super::super::tests::common::create_nullable_listview;
     use super::super::tests::common::create_overlapping_listview;
     use super::recursive_list_from_list_view;
+    use crate::ArrayEq;
+    use crate::ArrayRef;
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
+    use crate::Precision;
     use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
     use crate::arrays::FixedSizeListArray;
@@ -295,20 +300,21 @@ mod tests {
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
-    use crate::arrays::list_from_list_view;
-    use crate::arrays::list_view_from_list;
+    use crate::arrays::VarBinViewArray;
+    use crate::arrays::list::ListArrayExt;
+    use crate::arrays::listview::ListViewArrayExt;
+    use crate::arrays::listview::list_from_list_view;
+    use crate::arrays::listview::list_view_from_list;
     use crate::assert_arrays_eq;
     use crate::dtype::FieldNames;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_list_to_listview_basic() -> VortexResult<()> {
         // Create a basic ListArray: [[0,1,2], [3,4], [5,6], [7,8,9]].
         let elements = buffer![0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9].into_array();
         let offsets = buffer![0u32, 3, 5, 7, 10].into_array();
-        let list_array =
-            ListArray::try_new(elements.clone(), offsets.clone(), Validity::NonNullable).unwrap();
+        let list_array = ListArray::try_new(elements.clone(), offsets, Validity::NonNullable)?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let list_view = list_view_from_list(list_array.clone(), &mut ctx)?;
@@ -353,9 +359,7 @@ mod tests {
         // Empty ListArray to ListViewArray.
         let empty_elements = PrimitiveArray::from_iter::<[i32; 0]>([]).into_array();
         let empty_offsets = buffer![0u32].into_array();
-        let empty_list =
-            ListArray::try_new(empty_elements.clone(), empty_offsets, Validity::NonNullable)
-                .unwrap();
+        let empty_list = ListArray::try_new(empty_elements, empty_offsets, Validity::NonNullable)?;
 
         // This conversion will create an empty ListViewArray.
         // Note: list_view_from_list handles the empty case specially.
@@ -378,14 +382,18 @@ mod tests {
         let elements = buffer![10i32, 20, 30, 40, 50].into_array();
         let offsets = buffer![0u32, 2, 4, 5].into_array();
         let validity = Validity::Array(BoolArray::from_iter(vec![true, false, true]).into_array());
-        let nullable_list =
-            ListArray::try_new(elements.clone(), offsets.clone(), validity.clone()).unwrap();
+        let nullable_list = ListArray::try_new(elements, offsets, validity.clone())?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let nullable_list_view = list_view_from_list(nullable_list.clone(), &mut ctx)?;
 
         // Verify validity is preserved.
-        assert_eq!(nullable_list_view.validity(), &validity);
+        assert!(
+            nullable_list_view
+                .validity()
+                .vortex_expect("listview validity should be derivable")
+                .array_eq(&validity, Precision::Ptr)
+        );
         assert_eq!(nullable_list_view.len(), 3);
 
         // Round-trip conversion.
@@ -438,8 +446,7 @@ mod tests {
         let elements = buffer![1i32, 2, 3, 4, 5].into_array();
         let i32_offsets = buffer![0i32, 2, 5].into_array();
         let list_i32 =
-            ListArray::try_new(elements.clone(), i32_offsets.clone(), Validity::NonNullable)
-                .unwrap();
+            ListArray::try_new(elements.clone(), i32_offsets.clone(), Validity::NonNullable)?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let list_view_i32 = list_view_from_list(list_i32.clone(), &mut ctx)?;
@@ -448,9 +455,7 @@ mod tests {
 
         // Test with i64 offsets.
         let i64_offsets = buffer![0i64, 2, 5].into_array();
-        let list_i64 =
-            ListArray::try_new(elements.clone(), i64_offsets.clone(), Validity::NonNullable)
-                .unwrap();
+        let list_i64 = ListArray::try_new(elements, i64_offsets.clone(), Validity::NonNullable)?;
 
         let list_view_i64 = list_view_from_list(list_i64.clone(), &mut ctx)?;
         assert_eq!(list_view_i64.offsets().dtype(), i64_offsets.dtype());
@@ -492,8 +497,7 @@ mod tests {
         // Create lists with single elements: [[100], [200], [300]].
         let elements = buffer![100i32, 200, 300].into_array();
         let offsets = buffer![0u32, 1, 2, 3].into_array();
-        let single_elem_list =
-            ListArray::try_new(elements.clone(), offsets, Validity::NonNullable).unwrap();
+        let single_elem_list = ListArray::try_new(elements, offsets, Validity::NonNullable)?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let list_view = list_view_from_list(single_elem_list.clone(), &mut ctx)?;
@@ -514,8 +518,7 @@ mod tests {
         // Create: [[1,2], [], [3], [], [4,5,6]].
         let elements = buffer![1i32, 2, 3, 4, 5, 6].into_array();
         let offsets = buffer![0u32, 2, 2, 3, 3, 6].into_array();
-        let mixed_list =
-            ListArray::try_new(elements.clone(), offsets.clone(), Validity::NonNullable).unwrap();
+        let mixed_list = ListArray::try_new(elements, offsets, Validity::NonNullable)?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let list_view = list_view_from_list(mixed_list.clone(), &mut ctx)?;
@@ -585,8 +588,7 @@ mod tests {
             vec![listview_field, primitive_field],
             4,
             Validity::NonNullable,
-        )
-        .unwrap();
+        )?;
 
         let result = recursive_list_from_list_view(struct_array.clone().into_array())?;
 
@@ -625,8 +627,7 @@ mod tests {
 
         let dtype = lv1.dtype().clone();
         let chunked_listviews =
-            crate::arrays::ChunkedArray::try_new(vec![lv1.into_array(), lv2.into_array()], dtype)
-                .unwrap();
+            crate::arrays::ChunkedArray::try_new(vec![lv1.into_array(), lv2.into_array()], dtype)?;
 
         let fixed_list =
             FixedSizeListArray::new(chunked_listviews.into_array(), 1, Validity::NonNullable, 2);
@@ -658,8 +659,7 @@ mod tests {
             vec![innermost_listview.into_array()],
             2,
             Validity::NonNullable,
-        )
-        .unwrap();
+        )?;
 
         let outer_offsets = buffer![0u32, 1].into_array();
         let outer_sizes = buffer![1u32, 1].into_array();
@@ -686,7 +686,7 @@ mod tests {
         let prim_clone = prim.clone();
         let result = recursive_list_from_list_view(prim)?;
 
-        assert!(Arc::ptr_eq(&result, &prim_clone));
+        assert!(ArrayRef::ptr_eq(&result, &prim_clone));
         Ok(())
     }
 
@@ -700,8 +700,7 @@ mod tests {
             vec![listview.into_array(), list.into_array()],
             4,
             Validity::NonNullable,
-        )
-        .unwrap();
+        )?;
 
         let result = recursive_list_from_list_view(struct_array.clone().into_array())?;
 
@@ -709,4 +708,24 @@ mod tests {
         assert_arrays_eq!(struct_array.into_array(), result);
         Ok(())
     }
+
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/6882>.
+    ///
+    /// An empty `ListViewArray` constructed via `try_new` has `is_zero_copy_to_list: false`.
+    /// `list_from_list_view` should still succeed because empty arrays are trivially
+    /// zero-copyable.
+    #[test]
+    fn test_empty_listview_to_list_without_zctl_flag() -> VortexResult<()> {
+        let elements = VarBinViewArray::from_iter_str(Vec::<&str>::new()).into_array();
+        let offsets = PrimitiveArray::from_iter(Vec::<i16>::new()).into_array();
+        let sizes = PrimitiveArray::from_iter(Vec::<i16>::new()).into_array();
+        let list_view = ListViewArray::try_new(elements, offsets, sizes, Validity::AllValid)?;
+
+        // `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)?;
+        assert_eq!(list_array.len(), 0);
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/arrays/listview/mod.rs b/vortex-array/src/arrays/listview/mod.rs
index 30f485993d0..77f2a279160 100644
--- a/vortex-array/src/arrays/listview/mod.rs
+++ b/vortex-array/src/arrays/listview/mod.rs
@@ -2,13 +2,15 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::ListViewArray;
-pub use array::ListViewArrayParts;
+pub use array::ListViewArrayExt;
+pub use array::ListViewData;
+pub use array::ListViewDataParts;
+pub use vtable::ListViewArray;
 
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::ListViewVTable;
+pub use vtable::ListView;
 
 mod conversion;
 pub use conversion::list_from_list_view;
diff --git a/vortex-array/src/arrays/listview/rebuild.rs b/vortex-array/src/arrays/listview/rebuild.rs
index 1e6ca4752d4..4bcfb8311f8 100644
--- a/vortex-array/src/arrays/listview/rebuild.rs
+++ b/vortex-array/src/arrays/listview/rebuild.rs
@@ -6,20 +6,23 @@ use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
 use crate::ToCanonical;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::min_max::min_max;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::builders::builder_with_capacity;
 use crate::builtins::ArrayBuiltins;
-use crate::compute;
+use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::dtype::Nullability;
+use crate::dtype::PType;
 use crate::match_each_integer_ptype;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::operators::Operator;
-use crate::vtable::ValidityHelper;
 
 /// Modes for rebuilding a [`ListViewArray`].
 pub enum ListViewRebuildMode {
@@ -57,7 +60,8 @@ impl ListViewArray {
     /// Rebuilds the [`ListViewArray`] according to the specified mode.
     pub fn rebuild(&self, mode: ListViewRebuildMode) -> VortexResult<ListViewArray> {
         if self.is_empty() {
-            return Ok(self.clone());
+            // SAFETY: An empty array is trivially zero-copyable to a `ListArray`.
+            return Ok(unsafe { self.clone().with_zero_copy_to_list(true) });
         }
 
         match mode {
@@ -158,7 +162,7 @@ impl ListViewArray {
 
         let mut n_elements = NewOffset::zero();
         for index in 0..len {
-            if !self.is_valid(index)? {
+            if !self.validity()?.is_valid(index)? {
                 new_offsets.push(n_elements);
                 new_sizes.push(S::zero());
                 continue;
@@ -183,7 +187,7 @@ impl ListViewArray {
         // non-overlapping, all (offset, size) pairs reference valid elements, and the validity
         // array is preserved from the original.
         Ok(unsafe {
-            ListViewArray::new_unchecked(elements, offsets, sizes, self.validity.clone())
+            ListViewArray::new_unchecked(elements, offsets, sizes, self.validity()?)
                 .with_zero_copy_to_list(true)
         })
     }
@@ -226,7 +230,7 @@ impl ListViewArray {
 
         let mut n_elements = NewOffset::zero();
         for index in 0..len {
-            if !self.is_valid(index)? {
+            if !self.validity()?.is_valid(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);
@@ -266,7 +270,7 @@ impl ListViewArray {
         // - The array satisfies the zero-copy-to-list property by having sorted offsets, no gaps,
         //   and no overlaps.
         Ok(unsafe {
-            ListViewArray::new_unchecked(elements, offsets, sizes, self.validity.clone())
+            ListViewArray::new_unchecked(elements, offsets, sizes, self.validity()?)
                 .with_zero_copy_to_list(true)
         })
     }
@@ -293,12 +297,23 @@ impl ListViewArray {
             let last_size = self.size_at(self.len() - 1);
             last_offset + last_size
         } else {
-            let min_max = compute::min_max(
-                &self
-                    .offsets()
-                    .clone()
-                    .binary(self.sizes().clone(), Operator::Add)
+            // Cast offsets and sizes to the widest integer type to prevent
+            // overflow when computing offsets + sizes. The end offset may not
+            // fit in the integer width otherwise.
+            let wide_dtype = DType::from(if self.offsets().dtype().as_ptype().is_unsigned_int() {
+                PType::U64
+            } else {
+                PType::I64
+            });
+            let offsets = self.offsets().cast(wide_dtype.clone())?;
+            let sizes = self.sizes().cast(wide_dtype)?;
+
+            let mut ctx = LEGACY_SESSION.create_execution_ctx();
+            let min_max = min_max(
+                &offsets
+                    .binary(sizes, Operator::Add)
                     .vortex_expect("`offsets + sizes` somehow overflowed"),
+                &mut ctx,
             )
             .vortex_expect("Something went wrong while computing min and max")
             .vortex_expect("We checked that the array was not empty in the top-level `rebuild`");
@@ -316,7 +331,7 @@ impl ListViewArray {
             let scalar = Scalar::primitive(offset, Nullability::NonNullable);
 
             self.offsets()
-                .to_array()
+                .clone()
                 .binary(
                     ConstantArray::new(scalar, self.offsets().len()).into_array(),
                     Operator::Sub,
@@ -335,7 +350,7 @@ impl ListViewArray {
                 sliced_elements,
                 adjusted_offsets,
                 self.sizes().clone(),
-                self.validity().clone(),
+                self.validity()?,
             )
             .with_zero_copy_to_list(self.is_zero_copy_to_list())
         })
@@ -363,10 +378,10 @@ mod tests {
     use crate::ToCanonical;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::listview::ListViewArrayExt;
     use crate::assert_arrays_eq;
     use crate::dtype::Nullability;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_rebuild_flatten_removes_overlaps() -> VortexResult<()> {
@@ -426,9 +441,9 @@ mod tests {
 
         // Verify nullability is preserved
         assert_eq!(flattened.dtype().nullability(), Nullability::Nullable);
-        assert!(flattened.validity().is_valid(0).unwrap());
-        assert!(!flattened.validity().is_valid(1).unwrap());
-        assert!(flattened.validity().is_valid(2).unwrap());
+        assert!(flattened.validity()?.is_valid(0).unwrap());
+        assert!(!flattened.validity()?.is_valid(1).unwrap());
+        assert!(flattened.validity()?.is_valid(2).unwrap());
 
         // Verify valid lists contain correct data
         assert_arrays_eq!(
@@ -541,6 +556,48 @@ mod tests {
         Ok(())
     }
 
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/6773>.
+    /// u32 offsets exceed u16::MAX, so u16 sizes are widened to u32 for the add.
+    #[test]
+    fn test_rebuild_trim_elements_offsets_wider_than_sizes() -> VortexResult<()> {
+        let mut elems = vec![0i32; 70_005];
+        elems[70_000] = 10;
+        elems[70_001] = 20;
+        elems[70_002] = 30;
+        elems[70_003] = 40;
+        let elements = PrimitiveArray::from_iter(elems).into_array();
+        let offsets = PrimitiveArray::from_iter(vec![70_000u32, 70_002]).into_array();
+        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)?;
+        assert_arrays_eq!(
+            trimmed.list_elements_at(1).unwrap(),
+            PrimitiveArray::from_iter([30i32, 40])
+        );
+        Ok(())
+    }
+
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/6773>.
+    /// u32 sizes exceed u16::MAX, so u16 offsets are widened to u32 for the add.
+    #[test]
+    fn test_rebuild_trim_elements_sizes_wider_than_offsets() -> VortexResult<()> {
+        let mut elems = vec![0i32; 70_001];
+        elems[3] = 30;
+        elems[4] = 40;
+        let elements = PrimitiveArray::from_iter(elems).into_array();
+        let offsets = PrimitiveArray::from_iter(vec![1u16, 3]).into_array();
+        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)?;
+        assert_arrays_eq!(
+            trimmed.list_elements_at(1).unwrap(),
+            PrimitiveArray::from_iter([30i32, 40])
+        );
+        Ok(())
+    }
+
     // ── should_use_take heuristic tests ────────────────────────────────────
 
     #[test]
@@ -555,4 +612,20 @@ mod tests {
         // avg = 128 → LBL
         assert!(!ListViewArray::should_use_take(128_000, 1_000));
     }
+
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/6973>.
+    /// Both offsets and sizes are u8, and offset + size exceeds u8::MAX.
+    #[test]
+    fn test_rebuild_trim_elements_sum_overflows_type() -> VortexResult<()> {
+        let elements = PrimitiveArray::from_iter(vec![0i32; 261]).into_array();
+        let offsets = PrimitiveArray::from_iter(vec![215u8, 0]).into_array();
+        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)?;
+
+        // min(offsets) = 0, so nothing to trim; output should equal input.
+        assert_arrays_eq!(trimmed, listview);
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/arrays/listview/tests/basic.rs b/vortex-array/src/arrays/listview/tests/basic.rs
index 331af7ee484..5a1bf09d028 100644
--- a/vortex-array/src/arrays/listview/tests/basic.rs
+++ b/vortex-array/src/arrays/listview/tests/basic.rs
@@ -7,7 +7,6 @@ use rstest::rstest;
 use vortex_buffer::buffer;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
@@ -16,7 +15,8 @@ use crate::arrays::ConstantArray;
 use crate::arrays::ListArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::list_view_from_list;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::list_view_from_list;
 use crate::assert_arrays_eq;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
diff --git a/vortex-array/src/arrays/listview/tests/filter.rs b/vortex-array/src/arrays/listview/tests/filter.rs
index 6181df6de47..40eef10d825 100644
--- a/vortex-array/src/arrays/listview/tests/filter.rs
+++ b/vortex-array/src/arrays/listview/tests/filter.rs
@@ -15,6 +15,7 @@ use crate::ToCanonical;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::assert_arrays_eq;
 use crate::compute::conformance::filter::test_filter_conformance;
 use crate::validity::Validity;
@@ -27,7 +28,7 @@ use crate::validity::Validity;
 #[case::overlapping(create_overlapping_listview())]
 #[case::large(create_large_listview())]
 fn test_filter_listview_conformance(#[case] listview: ListViewArray) {
-    test_filter_conformance(listview.as_ref());
+    test_filter_conformance(&listview.into_array());
 }
 
 #[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
@@ -41,8 +42,7 @@ fn test_filter_preserves_unreferenced_elements() {
     let offsets = buffer![5u32, 2, 8, 0, 1].into_array();
     let sizes = buffer![3u32, 2, 2, 2, 4].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Filter to keep only 2 lists.
     let mask = Mask::from_iter([true, false, false, true, false]);
@@ -73,8 +73,7 @@ fn test_filter_with_gaps() {
     let offsets = buffer![0u32, 6, 10, 1, 7].into_array();
     let sizes = buffer![3u32, 3, 2, 2, 2].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Filter to keep lists with gaps and overlaps.
     let mask = Mask::from_iter([false, true, true, true, false]);
@@ -118,7 +117,7 @@ fn test_filter_constant_arrays() {
         varying_sizes,
         Validity::NonNullable,
     )
-    .to_array();
+    .into_array();
 
     let mask1 = Mask::from_iter([true, false, true, false]);
     let result1 = const_offset_list.filter(mask1).unwrap();
@@ -141,7 +140,7 @@ fn test_filter_constant_arrays() {
         both_constant_sizes,
         Validity::NonNullable,
     )
-    .to_array();
+    .into_array();
 
     let mask2 = Mask::from_iter([true, false, true]);
     let result2 = both_const_list.filter(mask2).unwrap();
@@ -165,8 +164,7 @@ fn test_filter_extreme_offsets() {
     let offsets = buffer![0u32, 4999, 9995, 2500, 7500].into_array();
     let sizes = buffer![5u32, 2, 5, 3, 4].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
     let mask = Mask::from_iter([false, true, false, false, true]);
diff --git a/vortex-array/src/arrays/listview/tests/nested.rs b/vortex-array/src/arrays/listview/tests/nested.rs
index b72b64af558..e5ec85a690c 100644
--- a/vortex-array/src/arrays/listview/tests/nested.rs
+++ b/vortex-array/src/arrays/listview/tests/nested.rs
@@ -3,12 +3,12 @@
 
 use vortex_buffer::buffer;
 
-use crate::Array;
 use crate::IntoArray;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::dtype::DType;
 use crate::dtype::FieldNames;
 use crate::dtype::Nullability;
@@ -61,7 +61,7 @@ fn test_listview_of_listview_with_overlapping() {
 
     // Verify the outer structure.
     let first_outer = outer_listview.list_elements_at(0).unwrap();
-    let first_outer_lv = first_outer.as_::<ListViewVTable>();
+    let first_outer_lv = first_outer.as_::<ListView>();
     assert_eq!(first_outer_lv.len(), 3);
 
     // Verify overlapping data is preserved correctly.
@@ -112,7 +112,7 @@ fn test_listview_of_listview_with_overlapping() {
     // Test slicing the outer ListView.
     let sliced = outer_listview.slice(1..2).unwrap();
     assert_eq!(sliced.len(), 1);
-    let sliced_lv = sliced.as_::<ListViewVTable>();
+    let sliced_lv = sliced.as_::<ListView>();
     let inner_after_slice = sliced_lv.list_elements_at(0).unwrap();
     assert_eq!(inner_after_slice.len(), 3);
 }
@@ -164,12 +164,12 @@ fn test_deeply_nested_out_of_order() {
 
     // Navigate through the scrambled structure.
     let top0 = level3.list_elements_at(0).unwrap();
-    let top0_lv = top0.as_::<ListViewVTable>();
+    let top0_lv = top0.as_::<ListView>();
     assert_eq!(top0_lv.len(), 2);
 
     // Due to out-of-order at level3, top0 actually contains level2[2] and level2[3].
     let mid0 = top0_lv.list_elements_at(0).unwrap();
-    let mid0_lv = mid0.as_::<ListViewVTable>();
+    let mid0_lv = mid0.as_::<ListView>();
     assert_eq!(mid0_lv.len(), 2);
 
     // Verify data integrity through the scrambled offsets.
@@ -200,12 +200,8 @@ fn test_mixed_offset_size_types() {
     let inner_offsets = buffer![0u32, 10, 20, 30, 40, 50, 100, 150, 200].into_array();
     let inner_sizes = buffer![5u16, 8, 10, 7, 15, 20, 25, 30, 50].into_array();
 
-    let inner_listview = ListViewArray::new(
-        elements,
-        inner_offsets.clone(),
-        inner_sizes.clone(),
-        Validity::NonNullable,
-    );
+    let inner_listview =
+        ListViewArray::new(elements, inner_offsets, inner_sizes, Validity::NonNullable);
 
     // Outer ListView with u64 offsets and u8 sizes.
     // Using small sizes that fit in u8 to test the type difference.
@@ -229,7 +225,7 @@ fn test_mixed_offset_size_types() {
     // Test slicing with mixed types.
     let sliced = outer_listview.slice(1..3).unwrap();
     assert_eq!(sliced.len(), 2);
-    let sliced_lv = sliced.as_::<ListViewVTable>();
+    let sliced_lv = sliced.as_::<ListView>();
 
     // Verify the sliced data maintains correct offsets despite type differences.
     let sliced_first = sliced_lv.list_elements_at(0).unwrap();
@@ -280,7 +276,7 @@ fn test_listview_zero_and_overlapping() {
 
     // Test first outer list with mixed empty/non-empty.
     let first_outer = outer_listview.list_elements_at(0).unwrap();
-    let first_outer_lv = first_outer.as_::<ListViewVTable>();
+    let first_outer_lv = first_outer.as_::<ListView>();
 
     let inner0 = first_outer_lv.list_elements_at(0).unwrap();
     assert_eq!(inner0.len(), 0); // Empty
@@ -302,7 +298,7 @@ fn test_listview_zero_and_overlapping() {
 
     // Test second outer list with overlapping data.
     let second_outer = outer_listview.list_elements_at(1).unwrap();
-    let second_outer_lv = second_outer.as_::<ListViewVTable>();
+    let second_outer_lv = second_outer.as_::<ListView>();
 
     let inner3 = second_outer_lv.list_elements_at(0).unwrap();
     assert_eq!(inner3.len(), 3); // [2, 3, 4]
diff --git a/vortex-array/src/arrays/listview/tests/nullability.rs b/vortex-array/src/arrays/listview/tests/nullability.rs
index 30b2a192ef1..aa56291e233 100644
--- a/vortex-array/src/arrays/listview/tests/nullability.rs
+++ b/vortex-array/src/arrays/listview/tests/nullability.rs
@@ -10,6 +10,7 @@ use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
diff --git a/vortex-array/src/arrays/listview/tests/operations.rs b/vortex-array/src/arrays/listview/tests/operations.rs
index e5f10a99ab2..09cf700bb98 100644
--- a/vortex-array/src/arrays/listview/tests/operations.rs
+++ b/vortex-array/src/arrays/listview/tests/operations.rs
@@ -10,20 +10,20 @@ use vortex_mask::Mask;
 use super::common::create_basic_listview;
 use super::common::create_large_listview;
 use super::common::create_nullable_listview;
-use crate::Array;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
 use crate::ToCanonical;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::is_constant::is_constant;
 use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::assert_arrays_eq;
 use crate::builtins::ArrayBuiltins;
 use crate::compute::conformance::mask::test_mask_conformance;
-use crate::compute::is_constant;
-#[expect(deprecated)]
-use crate::compute::mask;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
@@ -41,11 +41,11 @@ fn test_slice_comprehensive() {
     let offsets = buffer![0i32, 3, 5, 7].into_array();
     let sizes = buffer![3i32, 2, 3, 2].into_array();
 
-    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Test basic slice [1..3] - middle portion.
     let sliced = listview.slice(1..3).unwrap();
-    let sliced_list = sliced.as_::<ListViewVTable>();
+    let sliced_list = sliced.as_::<ListView>();
     assert_eq!(sliced_list.len(), 2, "Wrong slice length");
     assert_eq!(sliced_list.offset_at(0), 3, "Wrong offset for list[1]");
     assert_eq!(sliced_list.size_at(0), 2, "Wrong size for list[1]");
@@ -54,12 +54,12 @@ fn test_slice_comprehensive() {
 
     // Test full array slice [0..4].
     let full = listview.slice(0..4).unwrap();
-    let full_list = full.as_::<ListViewVTable>();
+    let full_list = full.as_::<ListView>();
     assert_eq!(full_list.len(), 4, "Full slice should preserve length");
     for i in 0..4 {
         // Compare the sliced elements
         assert_eq!(
-            full_list.scalar_at(i).unwrap(),
+            full_list.array().scalar_at(i).unwrap(),
             listview.scalar_at(i).unwrap(),
             "Mismatch at index {}",
             i
@@ -68,7 +68,7 @@ fn test_slice_comprehensive() {
 
     // Test single element slice [2..3].
     let single = listview.slice(2..3).unwrap();
-    let single_list = single.as_::<ListViewVTable>();
+    let single_list = single.as_::<ListView>();
     assert_eq!(single_list.len(), 1, "Single element slice failed");
     assert_eq!(single_list.offset_at(0), 5, "Wrong offset for single slice");
     assert_eq!(single_list.size_at(0), 3, "Wrong size for single slice");
@@ -82,11 +82,11 @@ fn test_slice_out_of_order() {
     let offsets = buffer![6i32, 0, 3, 8, 2].into_array(); // Out of order.
     let sizes = buffer![2i32, 3, 3, 1, 1].into_array();
 
-    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Slice [1..4] should maintain the out-of-order offsets.
     let sliced = listview.slice(1..4).unwrap();
-    let sliced_list = sliced.as_::<ListViewVTable>();
+    let sliced_list = sliced.as_::<ListView>();
 
     assert_eq!(
         sliced_list.len(),
@@ -145,11 +145,11 @@ fn test_slice_with_nulls() {
 
     // Slice [1..3] should preserve nulls.
     let sliced = listview.slice(1..3).unwrap();
-    let sliced_list = sliced.as_::<ListViewVTable>();
+    let sliced_list = sliced.as_::<ListView>();
 
     assert_eq!(sliced_list.len(), 2);
-    assert!(sliced_list.is_invalid(0).unwrap()); // Original index 1 was null.
-    assert!(sliced_list.is_valid(1).unwrap()); // Original index 2 was valid.
+    assert!(sliced_list.array().is_invalid(0).unwrap()); // Original index 1 was null.
+    assert!(sliced_list.array().is_valid(1).unwrap()); // Original index 2 was valid.
 
     // Verify offsets and sizes are preserved.
     assert_eq!(sliced_list.offset_at(0), 2);
@@ -226,7 +226,7 @@ fn test_cast_numeric_types(#[case] from_ptype: PType, #[case] to_ptype: PType) {
         ListViewArray::new_unchecked(elements, offsets, sizes, Validity::NonNullable)
             .with_zero_copy_to_list(true)
     }
-    .to_array();
+    .into_array();
 
     let target_dtype = DType::List(
         Arc::new(DType::Primitive(to_ptype, Nullability::NonNullable)),
@@ -262,7 +262,7 @@ fn test_cast_with_nulls() {
         ListViewArray::new_unchecked(elements, offsets, sizes, validity)
             .with_zero_copy_to_list(true)
     }
-    .to_array();
+    .into_array();
 
     let target_dtype = DType::List(
         Arc::new(DType::Primitive(PType::I64, Nullability::NonNullable)),
@@ -299,7 +299,7 @@ fn test_cast_special_patterns(#[case] expected_sizes: Vec<usize>, #[case] list_c
         )
     };
 
-    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     let target_dtype = if is_empty_case {
         DType::List(
@@ -338,7 +338,7 @@ fn test_cast_large_dataset() {
         ListViewArray::new_unchecked(elements, offsets, sizes, Validity::NonNullable)
             .with_zero_copy_to_list(true)
     }
-    .to_array();
+    .into_array();
 
     let target_dtype = DType::List(
         Arc::new(DType::Primitive(PType::U32, Nullability::NonNullable)),
@@ -408,9 +408,10 @@ fn test_is_constant_basic(
         sizes.into_array(),
         validity,
     )
-    .to_array();
+    .into_array();
 
-    assert_eq!(is_constant(&listview).unwrap(), Some(expected));
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert_eq!(is_constant(&listview, &mut ctx).unwrap(), expected);
 }
 
 #[test]
@@ -428,7 +429,8 @@ fn test_constant_with_constant_elements() {
     .into_array();
 
     // All lists contain [42, 42] so should be constant.
-    assert_eq!(is_constant(&listview).unwrap(), Some(true));
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert!(is_constant(&listview, &mut ctx).unwrap());
 }
 
 #[test]
@@ -451,21 +453,18 @@ fn test_constant_with_nulls() {
         .with_zero_copy_to_list(true)
     }
     .into_array();
-    assert_eq!(is_constant(&listview_mixed).unwrap(), Some(false));
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert!(!is_constant(&listview_mixed, &mut ctx).unwrap());
 
     // Case 2: All nulls - should be constant.
     let validity_all_null = Validity::AllInvalid;
     let listview_all_null = unsafe {
-        ListViewArray::new_unchecked(
-            elements.clone(),
-            offsets.clone(),
-            sizes.clone(),
-            validity_all_null,
-        )
-        .with_zero_copy_to_list(true)
+        ListViewArray::new_unchecked(elements, offsets, sizes, validity_all_null)
+            .with_zero_copy_to_list(true)
     }
     .into_array();
-    assert_eq!(is_constant(&listview_all_null).unwrap(), Some(true));
+    let mut ctx2 = LEGACY_SESSION.create_execution_ctx();
+    assert!(is_constant(&listview_all_null, &mut ctx2).unwrap());
 }
 
 #[test]
@@ -476,10 +475,11 @@ fn test_constant_repeated_same_lists() {
     let offsets = buffer![0i32, 0, 0, 0].into_array(); // All point to same start.
     let sizes = buffer![3i32, 3, 3, 3].into_array(); // All same size.
 
-    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // All lists are [10, 20, 30] so should be constant.
-    assert_eq!(is_constant(&listview).unwrap(), Some(true));
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert!(is_constant(&listview, &mut ctx).unwrap());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -492,7 +492,7 @@ fn test_constant_repeated_same_lists() {
 #[case::nullable(create_nullable_listview())]
 #[case::large(create_large_listview())]
 fn test_mask_listview_conformance(#[case] listview: ListViewArray) {
-    test_mask_conformance(listview.as_ref());
+    test_mask_conformance(&listview.into_array());
 }
 
 #[test]
@@ -507,17 +507,16 @@ fn test_mask_preserves_structure() {
         ListViewArray::new_unchecked(elements, offsets, sizes, Validity::NonNullable)
             .with_zero_copy_to_list(true)
     }
-    .to_array();
+    .into_array();
 
     // Mask sets elements to null where true.
     let selection = Mask::from_iter([true, false, true, true]);
-    #[expect(deprecated)]
-    let result = mask(&listview, &selection).unwrap();
+    let result = listview.mask((!&selection).into_array()).unwrap();
 
     assert_eq!(result.len(), 4); // Length is preserved.
     let result_list = result.to_listview();
 
-    // Check validity: true in mask means null.
+    // Check validity: true in selection means null.
     assert!(!result_list.is_valid(0).unwrap()); // Masked.
     assert!(result_list.is_valid(1).unwrap()); // Not masked.
     assert!(!result_list.is_valid(2).unwrap()); // Masked.
@@ -547,12 +546,11 @@ fn test_mask_with_existing_nulls() {
         ListViewArray::new_unchecked(elements, offsets, sizes, validity)
             .with_zero_copy_to_list(true)
     }
-    .to_array();
+    .into_array();
 
     // Mask additional elements.
     let selection = Mask::from_iter([false, true, true]);
-    #[expect(deprecated)]
-    let result = mask(&listview, &selection).unwrap();
+    let result = listview.mask((!&selection).into_array()).unwrap();
     let result_list = result.to_listview();
 
     // Check combined validity:
@@ -569,11 +567,10 @@ fn test_mask_with_gaps() {
     let offsets = buffer![0u32, 4, 8].into_array();
     let sizes = buffer![2u32, 2, 2].into_array();
 
-    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     let selection = Mask::from_iter([true, false, false]);
-    #[expect(deprecated)]
-    let result = mask(&listview, &selection).unwrap();
+    let result = listview.mask((!&selection).into_array()).unwrap();
     let result_list = result.to_listview();
 
     assert_eq!(result_list.len(), 3);
@@ -602,11 +599,10 @@ fn test_mask_constant_arrays() {
         constant_sizes,
         Validity::NonNullable,
     )
-    .to_array();
+    .into_array();
 
     let selection = Mask::from_iter([false, true, false]);
-    #[expect(deprecated)]
-    let result = mask(&const_list, &selection).unwrap();
+    let result = const_list.mask((!&selection).into_array()).unwrap();
     let result_list = result.to_listview();
 
     assert_eq!(result_list.len(), 3);
diff --git a/vortex-array/src/arrays/listview/tests/take.rs b/vortex-array/src/arrays/listview/tests/take.rs
index 7f596d25847..042d93dfe59 100644
--- a/vortex-array/src/arrays/listview/tests/take.rs
+++ b/vortex-array/src/arrays/listview/tests/take.rs
@@ -9,12 +9,12 @@ use super::common::create_empty_lists_listview;
 use super::common::create_large_listview;
 use super::common::create_nullable_listview;
 use super::common::create_overlapping_listview;
-use crate::Array;
 use crate::IntoArray;
 use crate::ToCanonical;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::assert_arrays_eq;
 use crate::compute::conformance::take::test_take_conformance;
 use crate::validity::Validity;
@@ -27,7 +27,7 @@ use crate::validity::Validity;
 #[case::overlapping(create_overlapping_listview())]
 #[case::large(create_large_listview())]
 fn test_take_listview_conformance(#[case] listview: ListViewArray) {
-    test_take_conformance(listview.as_ref());
+    test_take_conformance(&listview.into_array());
 }
 
 // ListView-specific tests that aren't covered by conformance.
@@ -41,12 +41,11 @@ fn test_take_preserves_unreferenced_elements() {
     let offsets = buffer![5u32, 2, 8, 0, 1].into_array();
     let sizes = buffer![3u32, 2, 2, 2, 4].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Take only 2 lists.
     let indices = buffer![1u32, 3].into_array();
-    let result = listview.take(indices.to_array()).unwrap();
+    let result = listview.take(indices).unwrap();
     let result_list = result.to_listview();
 
     assert_eq!(result_list.len(), 2);
@@ -71,11 +70,10 @@ fn test_take_with_gaps() {
     let offsets = buffer![0u32, 6, 10, 1, 7].into_array();
     let sizes = buffer![3u32, 3, 2, 2, 2].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     let indices = buffer![1u32, 3, 4, 2].into_array();
-    let result = listview.take(indices.to_array()).unwrap();
+    let result = listview.take(indices).unwrap();
     let result_list = result.to_listview();
 
     // Verify the entire elements array is preserved including gaps.
@@ -107,10 +105,10 @@ fn test_take_constant_arrays() {
         varying_sizes,
         Validity::NonNullable,
     )
-    .to_array();
+    .into_array();
 
     let indices = buffer![3u32, 0, 2].into_array();
-    let result = const_offset_list.take(indices.to_array()).unwrap();
+    let result = const_offset_list.take(indices).unwrap();
     let result_list = result.to_listview();
 
     assert_eq!(result_list.len(), 3);
@@ -131,10 +129,10 @@ fn test_take_constant_arrays() {
         both_constant_sizes,
         Validity::NonNullable,
     )
-    .to_array();
+    .into_array();
 
     let indices2 = buffer![2u32, 0].into_array();
-    let result2 = both_const_list.take(indices2.to_array()).unwrap();
+    let result2 = both_const_list.take(indices2).unwrap();
     let result2_list = result2.to_listview();
 
     assert_eq!(result2_list.len(), 2);
@@ -155,12 +153,11 @@ fn test_take_extreme_offsets() {
     let offsets = buffer![0u32, 4999, 9995, 2500, 7500].into_array();
     let sizes = buffer![5u32, 2, 5, 3, 4].into_array();
 
-    let listview =
-        ListViewArray::new(elements.clone(), offsets, sizes, Validity::NonNullable).to_array();
+    let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // Take only 2 lists, demonstrating we keep all 10000 elements.
     let indices = buffer![1u32, 4].into_array();
-    let result = listview.take(indices.to_array()).unwrap();
+    let result = listview.take(indices).unwrap();
     let result_list = result.to_listview();
 
     assert_eq!(result_list.len(), 2);
diff --git a/vortex-array/src/arrays/listview/vtable/array.rs b/vortex-array/src/arrays/listview/vtable/array.rs
deleted file mode 100644
index 23dbae700c6..00000000000
--- a/vortex-array/src/arrays/listview/vtable/array.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ListViewVTable> for ListViewVTable {
-    fn len(array: &ListViewArray) -> usize {
-        debug_assert_eq!(array.offsets().len(), array.sizes().len());
-        array.offsets().len()
-    }
-
-    fn dtype(array: &ListViewArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ListViewArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &ListViewArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        array.elements().array_hash(state, precision);
-        array.offsets().array_hash(state, precision);
-        array.sizes().array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &ListViewArray, other: &ListViewArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.elements().array_eq(other.elements(), precision)
-            && array.offsets().array_eq(other.offsets(), precision)
-            && array.sizes().array_eq(other.sizes(), precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/listview/vtable/kernel.rs b/vortex-array/src/arrays/listview/vtable/kernel.rs
deleted file mode 100644
index 4403eaa46a4..00000000000
--- a/vortex-array/src/arrays/listview/vtable/kernel.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::arrays::ListViewVTable;
-use crate::arrays::TakeExecuteAdaptor;
-use crate::kernel::ParentKernelSet;
-
-pub(super) const PARENT_KERNELS: ParentKernelSet<ListViewVTable> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(ListViewVTable))]);
diff --git a/vortex-array/src/arrays/listview/vtable/mod.rs b/vortex-array/src/arrays/listview/vtable/mod.rs
index 49ae5e7a2a6..6338c6504c1 100644
--- a/vortex-array/src/arrays/listview/vtable/mod.rs
+++ b/vortex-array/src/arrays/listview/vtable/mod.rs
@@ -1,19 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use kernel::PARENT_KERNELS;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use prost::Message;
 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 crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ProstMetadata;
-use crate::SerializeMetadata;
-use crate::arrays::ListViewArray;
+use crate::ExecutionResult;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewData;
+use crate::arrays::listview::array::NUM_SLOTS;
+use crate::arrays::listview::array::SLOT_NAMES;
 use crate::arrays::listview::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
@@ -21,23 +34,15 @@ use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
-mod kernel;
 mod operations;
 mod validity;
-mod visitor;
-
-vtable!(ListView);
+/// A [`ListView`]-encoded Vortex array.
+pub type ListViewArray = Array<ListView>;
 
-#[derive(Debug)]
-pub struct ListViewVTable;
+#[derive(Clone, Debug)]
+pub struct ListView;
 
-impl ListViewVTable {
+impl ListView {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.listview");
 }
 
@@ -51,50 +56,104 @@ pub struct ListViewMetadata {
     size_ptype: i32,
 }
 
-impl VTable for ListViewVTable {
-    type Array = ListViewArray;
+impl ArrayHash for ListViewData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.is_zero_copy_to_list().hash(state);
+    }
+}
+
+impl ArrayEq for ListViewData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.is_zero_copy_to_list() == other.is_zero_copy_to_list()
+    }
+}
 
-    type Metadata = ProstMetadata<ListViewMetadata>;
+impl VTable for ListView {
+    type ArrayData = ListViewData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &ListViewArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ListViewMetadata {
-            elements_len: array.elements().len() as u64,
-            offset_ptype: PType::try_from(array.offsets().dtype())? as i32,
-            size_ptype: PType::try_from(array.sizes().dtype())? as i32,
-        }))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ListViewArray buffer index {idx} out of bounds")
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("ListViewArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        let metadata = <Self::Metadata as DeserializeMetadata>::deserialize(bytes)?;
-        Ok(ProstMetadata(metadata))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            ListViewMetadata {
+                elements_len: array.elements().len() as u64,
+                offset_ptype: PType::try_from(array.offsets().dtype())? as i32,
+                size_ptype: PType::try_from(array.sizes().dtype())? as i32,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn validate(
+        &self,
+        _data: &ListViewData,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == NUM_SLOTS,
+            "ListViewArray expected {NUM_SLOTS} slots, found {}",
+            slots.len()
+        );
+        let elements = slots[crate::arrays::listview::array::ELEMENTS_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray elements slot");
+        let offsets = slots[crate::arrays::listview::array::OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray offsets slot");
+        let sizes = slots[crate::arrays::listview::array::SIZES_SLOT]
+            .as_ref()
+            .vortex_expect("ListViewArray sizes slot");
+        vortex_ensure!(
+            offsets.len() == len && sizes.len() == len,
+            "ListViewArray length {} does not match outer length {}",
+            offsets.len(),
+            len
+        );
+
+        let actual_dtype = DType::List(Arc::new(elements.dtype().clone()), dtype.nullability());
+        vortex_ensure!(
+            &actual_dtype == dtype,
+            "ListViewArray dtype {} does not match outer dtype {}",
+            actual_dtype,
+            dtype
+        );
+
+        Ok(())
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<ListViewArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = ListViewMetadata::decode(metadata)?;
         vortex_ensure!(
             buffers.is_empty(),
             "`ListViewArray::build` expects no buffers"
@@ -120,72 +179,42 @@ impl VTable for ListViewVTable {
         let elements = children.get(
             0,
             element_dtype.as_ref(),
-            usize::try_from(metadata.0.elements_len)?,
+            usize::try_from(metadata.elements_len)?,
         )?;
 
         // Get offsets with proper type from metadata.
         let offsets = children.get(
             1,
-            &DType::Primitive(metadata.0.offset_ptype(), Nullability::NonNullable),
+            &DType::Primitive(metadata.offset_ptype(), Nullability::NonNullable),
             len,
         )?;
 
         // Get sizes with proper type from metadata.
         let sizes = children.get(
             2,
-            &DType::Primitive(metadata.0.size_ptype(), Nullability::NonNullable),
+            &DType::Primitive(metadata.size_ptype(), Nullability::NonNullable),
             len,
         )?;
 
-        ListViewArray::try_new(elements, offsets, sizes, validity)
+        ListViewData::validate(&elements, &offsets, &sizes, &validity)?;
+        let data = ListViewData::try_new()?;
+        let slots = ListViewData::make_slots(&elements, &offsets, &sizes, &validity, len);
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 3 || children.len() == 4,
-            "ListViewArray expects 3 or 4 children, got {}",
-            children.len()
-        );
-
-        let mut iter = children.into_iter();
-        let elements = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let offsets = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let sizes = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let validity = if let Some(validity_array) = iter.next() {
-            Validity::Array(validity_array)
-        } else {
-            Validity::from(array.dtype.nullability())
-        };
-
-        let new_array = ListViewArray::try_new(elements, offsets, sizes, validity)?;
-        *array = new_array;
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
-
-    fn execute_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
-    }
 }
diff --git a/vortex-array/src/arrays/listview/vtable/operations.rs b/vortex-array/src/arrays/listview/vtable/operations.rs
index 60bfc873548..c899083027a 100644
--- a/vortex-array/src/arrays/listview/vtable/operations.rs
+++ b/vortex-array/src/arrays/listview/vtable/operations.rs
@@ -5,13 +5,19 @@ use std::sync::Arc;
 
 use vortex_error::VortexResult;
 
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::ListView;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<ListViewVTable> for ListViewVTable {
-    fn scalar_at(array: &ListViewArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<ListView> for ListView {
+    fn scalar_at(
+        array: ArrayView<'_, ListView>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // By the preconditions we know that the list scalar is not null.
         let list = array.list_elements_at(index)?;
         let children: Vec<Scalar> = (0..list.len())
@@ -21,7 +27,7 @@ impl OperationsVTable<ListViewVTable> for ListViewVTable {
         Ok(Scalar::list(
             Arc::new(list.dtype().clone()),
             children,
-            array.dtype.nullability(),
+            array.dtype().nullability(),
         ))
     }
 }
diff --git a/vortex-array/src/arrays/listview/vtable/validity.rs b/vortex-array/src/arrays/listview/vtable/validity.rs
index 185f970e10d..64ede5cc142 100644
--- a/vortex-array/src/arrays/listview/vtable/validity.rs
+++ b/vortex-array/src/arrays/listview/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::ListViewArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::vtable::ListView;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for ListViewArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<ListView> for ListView {
+    fn validity(array: ArrayView<'_, ListView>) -> VortexResult<Validity> {
+        Ok(array.listview_validity())
     }
 }
diff --git a/vortex-array/src/arrays/listview/vtable/visitor.rs b/vortex-array/src/arrays/listview/vtable/visitor.rs
deleted file mode 100644
index 27c684b4176..00000000000
--- a/vortex-array/src/arrays/listview/vtable/visitor.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::ListViewArray;
-use crate::arrays::ListViewVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<ListViewVTable> for ListViewVTable {
-    fn visit_buffers(_array: &ListViewArray, _visitor: &mut dyn ArrayBufferVisitor) {
-        // ListView has no byte buffers.
-    }
-
-    fn nbuffers(_array: &ListViewArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ListViewArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("elements", array.elements());
-        visitor.visit_child("offsets", array.offsets());
-        visitor.visit_child("sizes", array.sizes());
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &ListViewArray) -> usize {
-        3 + validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &ListViewArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.elements().clone()),
-            1 => Some(array.offsets().clone()),
-            2 => Some(array.sizes().clone()),
-            3 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/masked/array.rs b/vortex-array/src/arrays/masked/array.rs
index 38317caacd7..4f6d53e5b35 100644
--- a/vortex-array/src/arrays/masked/array.rs
+++ b/vortex-array/src/arrays/masked/array.rs
@@ -1,51 +1,100 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
 use crate::ArrayRef;
-use crate::dtype::DType;
-use crate::stats::ArrayStats;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::Masked;
 use crate::validity::Validity;
 
+/// The underlying child array being masked.
+pub(super) const CHILD_SLOT: usize = 0;
+/// The validity bitmap defining which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 1;
+pub(super) const NUM_SLOTS: usize = 2;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["child", "validity"];
+
 #[derive(Clone, Debug)]
-pub struct MaskedArray {
-    pub(super) child: ArrayRef,
-    pub(super) validity: Validity,
-    pub(super) dtype: DType,
-    pub(super) stats: ArrayStats,
+pub struct MaskedData;
+
+impl Display for MaskedData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
 }
 
-impl MaskedArray {
-    pub fn try_new(child: ArrayRef, validity: Validity) -> VortexResult<Self> {
+pub trait MaskedArrayExt: TypedArrayRef<Masked> {
+    fn child(&self) -> &ArrayRef {
+        self.as_ref().slots()[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated masked child slot")
+    }
+
+    fn validity_child(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[VALIDITY_SLOT].as_ref()
+    }
+
+    fn masked_validity(&self) -> Validity {
+        child_to_validity(
+            &self.as_ref().slots()[VALIDITY_SLOT],
+            self.as_ref().dtype().nullability(),
+        )
+    }
+
+    fn masked_validity_mask(&self) -> vortex_mask::Mask {
+        self.masked_validity().to_mask(self.as_ref().len())
+    }
+}
+impl<T: TypedArrayRef<Masked>> MaskedArrayExt for T {}
+
+impl MaskedData {
+    pub(crate) fn try_new(
+        child_len: usize,
+        child_all_valid: bool,
+        validity: Validity,
+    ) -> VortexResult<Self> {
         if matches!(validity, Validity::NonNullable) {
             vortex_bail!("MaskedArray must have nullable validity, got {validity:?}")
         }
 
-        if !child.all_valid()? {
+        if !child_all_valid {
             vortex_bail!("MaskedArray children must not have nulls");
         }
 
         if let Some(validity_len) = validity.maybe_len()
-            && validity_len != child.len()
+            && validity_len != child_len
         {
             vortex_bail!("Validity must be the same length as a MaskedArray's child");
         }
 
         // MaskedArray's nullability is determined solely by its validity, not the child's dtype.
         // The child can have nullable dtype but must not have any actual null values.
-        let dtype = child.dtype().as_nullable();
-
-        Ok(Self {
-            child,
-            validity,
-            dtype,
-            stats: ArrayStats::default(),
-        })
+        Ok(Self)
     }
+}
 
-    pub fn child(&self) -> &ArrayRef {
-        &self.child
+impl Array<Masked> {
+    /// Constructs a new `MaskedArray`.
+    pub fn try_new(child: ArrayRef, validity: Validity) -> VortexResult<Self> {
+        let dtype = child.dtype().as_nullable();
+        let len = child.len();
+        let validity_slot = validity_to_child(&validity, len);
+        let data = MaskedData::try_new(len, child.all_valid()?, validity)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Masked, dtype, len, data)
+                    .with_slots(vec![Some(child), validity_slot]),
+            )
+        })
     }
 }
diff --git a/vortex-array/src/arrays/masked/compute/filter.rs b/vortex-array/src/arrays/masked/compute/filter.rs
index 44be1ff111f..fb3969b4bb8 100644
--- a/vortex-array/src/arrays/masked/compute/filter.rs
+++ b/vortex-array/src/arrays/masked/compute/filter.rs
@@ -6,19 +6,20 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Masked;
 use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
 use crate::arrays::filter::FilterReduce;
-use crate::vtable::ValidityHelper;
+use crate::arrays::masked::MaskedArrayExt;
 
-impl FilterReduce for MaskedVTable {
-    fn filter(array: &MaskedArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for Masked {
+    fn filter(array: ArrayView<'_, Masked>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         // Filter the validity to get the new validity
-        let filtered_validity = array.validity().filter(mask)?;
+        let filtered_validity = array.validity()?.filter(mask)?;
 
         // Filter the child array
         // The child is guaranteed to have no nulls, so filtering it is straightforward
-        let filtered_child = array.child.filter(mask.clone())?;
+        let filtered_child = array.child().filter(mask.clone())?;
 
         // Construct new MaskedArray
         Ok(Some(
@@ -57,6 +58,6 @@ mod tests {
         ).unwrap()
     )]
     fn test_filter_masked_conformance(#[case] array: MaskedArray) {
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/masked/compute/mask.rs b/vortex-array/src/arrays/masked/compute/mask.rs
index 00d845fece2..d8590a68d34 100644
--- a/vortex-array/src/arrays/masked/compute/mask.rs
+++ b/vortex-array/src/arrays/masked/compute/mask.rs
@@ -4,27 +4,26 @@
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
-use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
-use crate::arrays::ScalarFnArrayExt;
+use crate::array::ArrayView;
+use crate::arrays::Masked;
+use crate::arrays::masked::MaskedArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::scalar_fn::EmptyOptions;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for MaskedVTable {
-    fn mask(array: &MaskedArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Masked {
+    fn mask(array: ArrayView<'_, Masked>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // AND the existing validity mask with the new mask and push into child.
         let combined_mask = array
-            .validity()
-            .clone()
+            .validity()?
             .and(Validity::Array(mask.clone()))?
             .to_array(array.len());
         let masked_child = MaskExpr.try_new_array(
-            array.child.len(),
+            array.child().len(),
             EmptyOptions,
-            [array.child.clone(), combined_mask],
+            [array.child().clone(), combined_mask],
         )?;
         Ok(Some(masked_child))
     }
@@ -60,6 +59,6 @@ mod tests {
         ).unwrap()
     )]
     fn test_mask_masked_conformance(#[case] array: MaskedArray) {
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/masked/compute/rules.rs b/vortex-array/src/arrays/masked/compute/rules.rs
index daaad4b3235..3accb455c3f 100644
--- a/vortex-array/src/arrays/masked/compute/rules.rs
+++ b/vortex-array/src/arrays/masked/compute/rules.rs
@@ -1,14 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FilterReduceAdaptor;
-use crate::arrays::MaskedVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Masked;
+use crate::arrays::dict::TakeReduceAdaptor;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<MaskedVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&FilterReduceAdaptor(MaskedVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(MaskedVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(MaskedVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<Masked> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&FilterReduceAdaptor(Masked)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Masked)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Masked)),
+    ParentRuleSet::lift(&TakeReduceAdaptor(Masked)),
 ]);
diff --git a/vortex-array/src/arrays/masked/compute/slice.rs b/vortex-array/src/arrays/masked/compute/slice.rs
index 89df02d9a9d..fe295bd6826 100644
--- a/vortex-array/src/arrays/masked/compute/slice.rs
+++ b/vortex-array/src/arrays/masked/compute/slice.rs
@@ -7,24 +7,17 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Masked;
 use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
-use crate::arrays::SliceReduce;
-use crate::stats::ArrayStats;
+use crate::arrays::masked::MaskedArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for MaskedVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let child = array.child.slice(range.clone())?;
-        let validity = array.validity.slice(range)?;
+impl SliceReduce for Masked {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        let child = array.child().slice(range.clone())?;
+        let validity = array.validity()?.slice(range)?;
 
-        Ok(Some(
-            MaskedArray {
-                child,
-                validity,
-                dtype: array.dtype.clone(),
-                stats: ArrayStats::default(),
-            }
-            .into_array(),
-        ))
+        Ok(Some(MaskedArray::try_new(child, validity)?.into_array()))
     }
 }
diff --git a/vortex-array/src/arrays/masked/compute/take.rs b/vortex-array/src/arrays/masked/compute/take.rs
index c6d5b6084f3..c02a88a08fe 100644
--- a/vortex-array/src/arrays/masked/compute/take.rs
+++ b/vortex-array/src/arrays/masked/compute/take.rs
@@ -3,42 +3,29 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Masked;
 use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::masked::MaskedArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar::Scalar;
-use crate::vtable::ValidityHelper;
 
-impl TakeExecute for MaskedVTable {
-    fn take(
-        array: &MaskedArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
+impl TakeReduce for Masked {
+    fn take(array: ArrayView<'_, Masked>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let taken_child = if !indices.all_valid()? {
             // This is safe because we'll mask out these positions in the validity.
             let fill_scalar = Scalar::zero_value(indices.dtype());
-            let filled_take_indices = indices.to_array().fill_null(fill_scalar)?;
-            array
-                .child
-                .take(filled_take_indices)?
-                .to_canonical()?
-                .into_array()
+            let filled_take_indices = indices.clone().fill_null(fill_scalar)?;
+            array.child().take(filled_take_indices)?
         } else {
-            array
-                .child
-                .take(indices.to_array())?
-                .to_canonical()?
-                .into_array()
+            array.child().take(indices.clone())?
         };
 
         // Compute the new validity by taking from array's validity and merging with indices validity
-        let taken_validity = array.validity().take(indices)?;
+        let taken_validity = array.validity()?.take(indices)?;
 
         // Construct new MaskedArray
         Ok(Some(
@@ -77,6 +64,6 @@ mod tests {
         ).unwrap()
     )]
     fn test_take_masked_conformance(#[case] array: MaskedArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/masked/execute.rs b/vortex-array/src/arrays/masked/execute.rs
index c6c0fc64348..4bc6449ead3 100644
--- a/vortex-array/src/arrays/masked/execute.rs
+++ b/vortex-array/src/arrays/masked/execute.rs
@@ -4,6 +4,7 @@
 //! Execution logic for MaskedArray - applies a validity mask to canonical arrays.
 
 use std::ops::BitAnd;
+use std::sync::Arc;
 
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -15,15 +16,22 @@ use crate::arrays::DecimalArray;
 use crate::arrays::ExtensionArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::ListViewArray;
+use crate::arrays::MaskedArray;
 use crate::arrays::NullArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::VariantArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::struct_::StructArrayExt;
+use crate::arrays::variant::VariantArrayExt;
 use crate::dtype::Nullability;
 use crate::executor::ExecutionCtx;
 use crate::match_each_decimal_value_type;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 /// TODO: replace usage of compute fn.
 /// Apply a validity mask to a canonical array, ANDing with existing validity.
@@ -37,112 +45,148 @@ pub fn mask_validity_canonical(
 ) -> VortexResult<Canonical> {
     Ok(match canonical {
         Canonical::Null(a) => Canonical::Null(mask_validity_null(a, validity_mask)),
-        Canonical::Bool(a) => Canonical::Bool(mask_validity_bool(a, validity_mask)),
-        Canonical::Primitive(a) => Canonical::Primitive(mask_validity_primitive(a, validity_mask)),
-        Canonical::Decimal(a) => Canonical::Decimal(mask_validity_decimal(a, validity_mask)),
+        Canonical::Bool(a) => Canonical::Bool(mask_validity_bool(a, validity_mask, ctx)?),
+        Canonical::Primitive(a) => {
+            Canonical::Primitive(mask_validity_primitive(a, validity_mask, ctx)?)
+        }
+        Canonical::Decimal(a) => Canonical::Decimal(mask_validity_decimal(a, validity_mask, ctx)?),
         Canonical::VarBinView(a) => {
-            Canonical::VarBinView(mask_validity_varbinview(a, validity_mask))
+            Canonical::VarBinView(mask_validity_varbinview(a, validity_mask, ctx)?)
         }
-        Canonical::List(a) => Canonical::List(mask_validity_listview(a, validity_mask)),
+        Canonical::List(a) => Canonical::List(mask_validity_listview(a, validity_mask, ctx)?),
         Canonical::FixedSizeList(a) => {
-            Canonical::FixedSizeList(mask_validity_fixed_size_list(a, validity_mask))
+            Canonical::FixedSizeList(mask_validity_fixed_size_list(a, validity_mask, ctx)?)
         }
-        Canonical::Struct(a) => Canonical::Struct(mask_validity_struct(a, validity_mask)),
+        Canonical::Struct(a) => Canonical::Struct(mask_validity_struct(a, validity_mask, ctx)?),
         Canonical::Extension(a) => {
             Canonical::Extension(mask_validity_extension(a, validity_mask, ctx)?)
         }
+        Canonical::Variant(a) => Canonical::Variant(mask_validity_variant(a, validity_mask, ctx)?),
     })
 }
 
-fn combine_validity(validity: &Validity, mask: &Mask, len: usize) -> Validity {
-    let current_mask = validity.to_mask(len);
+fn combine_validity(
+    validity: &Validity,
+    mask: &Mask,
+    len: usize,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Validity> {
+    let current_mask = validity.execute_mask(len, ctx)?;
     let combined = current_mask.bitand(mask);
-    Validity::from_mask(combined, Nullability::Nullable)
+    Ok(Validity::from_mask(combined, Nullability::Nullable))
 }
 
 fn mask_validity_null(array: NullArray, _mask: &Mask) -> NullArray {
     array
 }
 
-fn mask_validity_bool(array: BoolArray, mask: &Mask) -> BoolArray {
+fn mask_validity_bool(
+    array: BoolArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<BoolArray> {
     let len = array.len();
-    let new_validity = combine_validity(array.validity(), mask, len);
-    BoolArray::new(array.to_bit_buffer(), new_validity)
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
+    Ok(BoolArray::new(array.to_bit_buffer(), new_validity))
 }
 
-fn mask_validity_primitive(array: PrimitiveArray, mask: &Mask) -> PrimitiveArray {
+fn mask_validity_primitive(
+    array: PrimitiveArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<PrimitiveArray> {
     let len = array.len();
     let ptype = array.ptype();
-    let new_validity = combine_validity(array.validity(), mask, len);
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
     // SAFETY: validity has same length as values
-    unsafe {
+    Ok(unsafe {
         PrimitiveArray::new_unchecked_from_handle(
             array.buffer_handle().clone(),
             ptype,
             new_validity,
         )
-    }
+    })
 }
 
-fn mask_validity_decimal(array: DecimalArray, mask: &Mask) -> DecimalArray {
+fn mask_validity_decimal(
+    array: DecimalArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<DecimalArray> {
     let len = array.len();
     let dec_dtype = array.decimal_dtype();
     let values_type = array.values_type();
-    let new_validity = combine_validity(array.validity(), mask, len);
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
     // SAFETY: We're only changing validity, not the data structure
-    match_each_decimal_value_type!(values_type, |T| {
+    Ok(match_each_decimal_value_type!(values_type, |T| {
         let buffer = array.buffer::<T>();
         unsafe { DecimalArray::new_unchecked(buffer, dec_dtype, new_validity) }
-    })
+    }))
 }
 
 /// Mask validity for VarBinViewArray.
-fn mask_validity_varbinview(array: VarBinViewArray, mask: &Mask) -> VarBinViewArray {
+fn mask_validity_varbinview(
+    array: VarBinViewArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<VarBinViewArray> {
     let len = array.len();
     let dtype = array.dtype().as_nullable();
-    let new_validity = combine_validity(array.validity(), mask, len);
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
     // SAFETY: We're only changing validity, not the data structure
-    unsafe {
+    Ok(unsafe {
         VarBinViewArray::new_handle_unchecked(
             array.views_handle().clone(),
-            array.buffers().clone(),
+            Arc::clone(array.data_buffers()),
             dtype,
             new_validity,
         )
-    }
+    })
 }
 
-fn mask_validity_listview(array: ListViewArray, mask: &Mask) -> ListViewArray {
+fn mask_validity_listview(
+    array: ListViewArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ListViewArray> {
     let len = array.len();
-    let new_validity = combine_validity(array.validity(), mask, len);
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
     // SAFETY: We're only changing validity, not the data structure
-    unsafe {
+    Ok(unsafe {
         ListViewArray::new_unchecked(
             array.elements().clone(),
             array.offsets().clone(),
             array.sizes().clone(),
             new_validity,
         )
-    }
+    })
 }
 
-fn mask_validity_fixed_size_list(array: FixedSizeListArray, mask: &Mask) -> FixedSizeListArray {
+fn mask_validity_fixed_size_list(
+    array: FixedSizeListArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<FixedSizeListArray> {
     let len = array.len();
     let list_size = array.list_size();
-    let new_validity = combine_validity(array.validity(), mask, len);
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
     // SAFETY: We're only changing validity, not the data structure
-    unsafe {
+    Ok(unsafe {
         FixedSizeListArray::new_unchecked(array.elements().clone(), list_size, new_validity, len)
-    }
+    })
 }
 
-fn mask_validity_struct(array: StructArray, mask: &Mask) -> StructArray {
+fn mask_validity_struct(
+    array: StructArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<StructArray> {
     let len = array.len();
-    let new_validity = combine_validity(array.validity(), mask, len);
-    let fields = array.unmasked_fields().clone();
-    let struct_fields = array.struct_fields().clone();
+    let new_validity = combine_validity(&array.validity()?, mask, len, ctx)?;
+    let fields = array.unmasked_fields();
+    let struct_fields = array.struct_fields();
     // SAFETY: We're only changing validity, not the data structure
-    unsafe { StructArray::new_unchecked(fields, struct_fields, len, new_validity) }
+    Ok(unsafe { StructArray::new_unchecked(fields, struct_fields.clone(), len, new_validity) })
 }
 
 fn mask_validity_extension(
@@ -151,7 +195,7 @@ fn mask_validity_extension(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ExtensionArray> {
     // For extension arrays, we need to mask the underlying storage
-    let storage = array.storage().clone().execute::<Canonical>(ctx)?;
+    let storage = array.storage_array().clone().execute::<Canonical>(ctx)?;
     let masked_storage = mask_validity_canonical(storage, mask, ctx)?;
     let masked_storage = masked_storage.into_array();
     Ok(ExtensionArray::new(
@@ -161,3 +205,33 @@ fn mask_validity_extension(
         masked_storage,
     ))
 }
+
+fn mask_validity_variant(
+    array: VariantArray,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<VariantArray> {
+    let child = array.child().clone();
+    let len = child.len();
+    let child_validity = child.validity()?;
+
+    match child_validity {
+        Validity::NonNullable | Validity::AllValid => {
+            // Child has no nulls — wrap in MaskedArray to apply the mask.
+            let new_validity = Validity::from_mask(mask.clone(), Nullability::Nullable);
+            let masked_child = MaskedArray::try_new(child, new_validity)?;
+            Ok(VariantArray::new(masked_child.into_array()))
+        }
+        Validity::AllInvalid => {
+            // Already all-null, ANDing with any mask is still all-null.
+            Ok(array)
+        }
+        Validity::Array(_) => {
+            // Child has an array-backed validity stored as its first child.
+            // Combine with the mask and replace that child via with_children.
+            let combined = combine_validity(&child_validity, mask, len, ctx)?;
+            let new_child = child.with_slot(0, combined.to_array(len))?;
+            Ok(VariantArray::new(new_child))
+        }
+    }
+}
diff --git a/vortex-array/src/arrays/masked/mod.rs b/vortex-array/src/arrays/masked/mod.rs
index 1762973019a..ac437d30321 100644
--- a/vortex-array/src/arrays/masked/mod.rs
+++ b/vortex-array/src/arrays/masked/mod.rs
@@ -2,7 +2,9 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::MaskedArray;
+pub use array::MaskedArrayExt;
+pub use array::MaskedData;
+pub use vtable::MaskedArray;
 
 pub(crate) mod compute;
 mod execute;
@@ -10,7 +12,7 @@ mod execute;
 pub use execute::mask_validity_canonical;
 
 mod vtable;
-pub use vtable::MaskedVTable;
+pub use vtable::Masked;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/arrays/masked/tests.rs b/vortex-array/src/arrays/masked/tests.rs
index 4024f4d8d79..35d533d4f23 100644
--- a/vortex-array/src/arrays/masked/tests.rs
+++ b/vortex-array/src/arrays/masked/tests.rs
@@ -2,12 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use rstest::rstest;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use super::*;
-use crate::Array;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
 use crate::ToCanonical as _;
+use crate::VortexSessionExecute;
 use crate::arrays::PrimitiveArray;
 use crate::assert_arrays_eq;
 use crate::dtype::DType;
@@ -45,7 +47,7 @@ fn test_canonical_dtype_matches_array_dtype() -> VortexResult<()> {
     let array = MaskedArray::try_new(child, Validity::AllValid).unwrap();
 
     let canonical = array.to_canonical()?;
-    assert_eq!(canonical.as_ref().dtype(), array.dtype());
+    assert_eq!(canonical.dtype(), array.dtype());
     Ok(())
 }
 
@@ -56,7 +58,7 @@ fn test_masked_child_with_validity() {
     let array =
         MaskedArray::try_new(child, Validity::from_iter([true, false, true, false, true])).unwrap();
 
-    let prim = array.to_primitive();
+    let prim = array.as_array().to_primitive();
 
     // Positions where validity is false should be null in masked_child.
     assert_eq!(prim.valid_count().unwrap(), 3);
@@ -71,7 +73,7 @@ fn test_masked_child_with_validity() {
 fn test_masked_child_all_valid() {
     // When validity is AllValid, masked_child should invert to AllInvalid.
     let child = PrimitiveArray::from_iter([10i32, 20, 30]).into_array();
-    let array = MaskedArray::try_new(child.clone(), Validity::AllValid).unwrap();
+    let array = MaskedArray::try_new(child, Validity::AllValid).unwrap();
 
     assert_eq!(array.len(), 3);
     assert_eq!(array.valid_count().unwrap(), 3);
@@ -97,5 +99,13 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) {
     let array = MaskedArray::try_new(child, validity.clone()).unwrap();
 
     assert_eq!(array.len(), len);
-    assert_eq!(array.validity_mask().unwrap(), validity.to_mask(len));
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    assert!(
+        array
+            .validity()
+            .vortex_expect("masked validity should be derivable")
+            .mask_eq(&validity, &mut ctx)
+            .unwrap(),
+    );
 }
diff --git a/vortex-array/src/arrays/masked/vtable/array.rs b/vortex-array/src/arrays/masked/vtable/array.rs
deleted file mode 100644
index 96c8c519ee2..00000000000
--- a/vortex-array/src/arrays/masked/vtable/array.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::masked::MaskedArray;
-use crate::arrays::masked::MaskedVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<MaskedVTable> for MaskedVTable {
-    fn len(array: &MaskedArray) -> usize {
-        array.child.len()
-    }
-
-    fn dtype(array: &MaskedArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &MaskedArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &MaskedArray, state: &mut H, precision: Precision) {
-        array.child.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-        array.dtype.hash(state);
-    }
-
-    fn array_eq(array: &MaskedArray, other: &MaskedArray, precision: Precision) -> bool {
-        array.child.array_eq(&other.child, precision)
-            && array.validity.array_eq(&other.validity, precision)
-            && array.dtype == other.dtype
-    }
-}
diff --git a/vortex-array/src/arrays/masked/vtable/canonical.rs b/vortex-array/src/arrays/masked/vtable/canonical.rs
index 429af6f83ae..c612f522ef8 100644
--- a/vortex-array/src/arrays/masked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/masked/vtable/canonical.rs
@@ -7,7 +7,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::ToCanonical;
     use crate::arrays::MaskedArray;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::Nullability;
@@ -33,11 +32,8 @@ mod tests {
         #[case] expected_nullability: Nullability,
     ) -> VortexResult<()> {
         let canonical = array.to_canonical()?;
-        assert_eq!(
-            canonical.as_ref().dtype().nullability(),
-            expected_nullability
-        );
-        assert_eq!(canonical.as_ref().dtype(), array.dtype());
+        assert_eq!(canonical.dtype().nullability(), expected_nullability);
+        assert_eq!(canonical.dtype(), array.dtype());
         Ok(())
     }
 
@@ -50,7 +46,7 @@ mod tests {
         .unwrap();
 
         let canonical = array.to_canonical()?;
-        let prim = canonical.as_ref().to_primitive();
+        let prim = canonical.into_primitive();
 
         // Check that null positions match validity.
         assert_eq!(prim.valid_count().unwrap(), 3);
@@ -71,11 +67,8 @@ mod tests {
         .unwrap();
 
         let canonical = array.to_canonical()?;
-        assert_eq!(canonical.as_ref().valid_count().unwrap(), 3);
-        assert_eq!(
-            canonical.as_ref().dtype().nullability(),
-            Nullability::Nullable
-        );
+        assert_eq!(canonical.dtype().nullability(), Nullability::Nullable);
+        assert_eq!(canonical.into_array().valid_count().unwrap(), 3);
         Ok(())
     }
 }
diff --git a/vortex-array/src/arrays/masked/vtable/kernel.rs b/vortex-array/src/arrays/masked/vtable/kernel.rs
deleted file mode 100644
index cacfbd98cd4..00000000000
--- a/vortex-array/src/arrays/masked/vtable/kernel.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::arrays::MaskedVTable;
-use crate::arrays::TakeExecuteAdaptor;
-use crate::kernel::ParentKernelSet;
-
-// TODO(joe): add CompareExecuteAdaptor to push comparisons through the mask without canonicalizing.
-pub(super) const PARENT_KERNELS: ParentKernelSet<MaskedVTable> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(MaskedVTable))]);
diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs
index 1d6a70b39d3..cc5ef29a758 100644
--- a/vortex-array/src/arrays/masked/vtable/mod.rs
+++ b/vortex-array/src/arrays/masked/vtable/mod.rs
@@ -1,143 +1,170 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-mod array;
 mod canonical;
 mod operations;
 mod validity;
 
-use kernel::PARENT_KERNELS;
+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 crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
+use crate::AnyCanonical;
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
-use crate::EmptyMetadata;
 use crate::IntoArray;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::array::validity_to_child;
 use crate::arrays::ConstantArray;
-use crate::arrays::masked::MaskedArray;
+use crate::arrays::masked::MaskedArrayExt;
+use crate::arrays::masked::MaskedData;
+use crate::arrays::masked::array::CHILD_SLOT;
+use crate::arrays::masked::array::SLOT_NAMES;
+use crate::arrays::masked::array::VALIDITY_SLOT;
 use crate::arrays::masked::compute::rules::PARENT_RULES;
 use crate::arrays::masked::mask_validity_canonical;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+use crate::require_child;
+use crate::require_validity;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-mod kernel;
-
-vtable!(Masked);
+/// A [`Masked`]-encoded Vortex array.
+pub type MaskedArray = Array<Masked>;
 
-#[derive(Debug)]
-pub struct MaskedVTable;
+#[derive(Clone, Debug)]
+pub struct Masked;
 
-impl MaskedVTable {
+impl Masked {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.masked");
 }
 
-impl VisitorVTable<MaskedVTable> for MaskedVTable {
-    fn visit_buffers(_array: &MaskedArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(array: &MaskedArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("child", &array.child);
-        visitor.visit_validity(&array.validity, array.child.len());
-    }
-
-    fn nchildren(array: &MaskedArray) -> usize {
-        1 + validity_nchildren(&array.validity)
-    }
+impl ArrayHash for MaskedData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
 
-    fn nth_child(array: &MaskedArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.child.clone()),
-            1 => validity_to_child(&array.validity, array.child.len()),
-            _ => None,
-        }
+impl ArrayEq for MaskedData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
     }
 }
 
-impl VTable for MaskedVTable {
-    type Array = MaskedArray;
+impl VTable for Masked {
+    type ArrayData = MaskedData;
 
-    type Metadata = EmptyMetadata;
-
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &MaskedArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        _data: &MaskedData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots[CHILD_SLOT].is_some(),
+            "MaskedArray child slot must be present"
+        );
+        let child = slots[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated child slot");
+        vortex_ensure!(child.len() == len, "MaskedArray child length mismatch");
+        vortex_ensure!(
+            child.dtype().as_nullable() == *dtype,
+            "MaskedArray dtype does not match child and validity"
+        );
+        Ok(())
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, _idx: usize) -> BufferHandle {
+        vortex_panic!("MaskedArray has no buffers")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<MaskedArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "MaskedArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         if !buffers.is_empty() {
             vortex_bail!("Expected 0 buffer, got {}", buffers.len());
         }
 
+        vortex_ensure!(
+            children.len() == 1 || children.len() == 2,
+            "`MaskedArray::build` expects 1 or 2 children, got {}",
+            children.len()
+        );
+
         let child = children.get(0, &dtype.as_nonnullable(), len)?;
 
-        let validity = if children.len() == 1 {
-            Validity::from(dtype.nullability())
-        } else if children.len() == 2 {
+        let validity = if children.len() == 2 {
             let validity = children.get(1, &Validity::DTYPE, len)?;
             Validity::Array(validity)
         } else {
-            vortex_bail!(
-                "`MaskedArray::build` expects 1 or 2 children, got {}",
-                children.len()
-            );
+            Validity::from(dtype.nullability())
         };
 
-        MaskedArray::try_new(child, validity)
+        let validity_slot = validity_to_child(&validity, len);
+        let data = MaskedData::try_new(len, child.all_valid()?, validity)?;
+        Ok(
+            crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data)
+                .with_slots(vec![Some(child), validity_slot]),
+        )
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        let validity_mask = array.validity_mask()?;
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let validity_mask = array.masked_validity_mask();
 
         // Fast path: all masked means result is all nulls.
         if validity_mask.all_false() {
-            return Ok(
+            return Ok(ExecutionResult::done(
                 ConstantArray::new(Scalar::null(array.dtype().as_nullable()), array.len())
                     .into_array(),
-            );
+            ));
         }
 
         // NB: We intentionally do NOT have a fast path for `validity_mask.all_true()`.
@@ -146,47 +173,24 @@ impl VTable for MaskedVTable {
         // While we could manually convert the dtype, `mask_validity_canonical` is already O(1) for
         // `AllTrue` masks (no data copying), so there's no benefit.
 
-        let child = array.child().clone().execute::<Canonical>(ctx)?;
-        Ok(mask_validity_canonical(child, &validity_mask, ctx)?.into_array())
+        let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical);
+        require_validity!(array, VALIDITY_SLOT);
+
+        let child = Canonical::from(array.child().as_::<AnyCanonical>());
+        Ok(ExecutionResult::done(
+            mask_validity_canonical(child, &validity_mask, ctx)?.into_array(),
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
-
-    fn execute_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1 || children.len() == 2,
-            "MaskedArray expects 1 or 2 children, got {}",
-            children.len()
-        );
-
-        let mut iter = children.into_iter();
-        let child = iter
-            .next()
-            .vortex_expect("children length already validated");
-        let validity = if let Some(validity_array) = iter.next() {
-            Validity::Array(validity_array)
-        } else {
-            Validity::from(array.dtype.nullability())
-        };
-
-        let new_array = MaskedArray::try_new(child, validity)?;
-        *array = new_array;
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 }
 
@@ -195,18 +199,19 @@ mod tests {
     use rstest::rstest;
     use vortex_buffer::ByteBufferMut;
     use vortex_error::VortexError;
+    use vortex_session::registry::ReadContext;
 
     use crate::ArrayContext;
     use crate::Canonical;
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::arrays::Masked;
     use crate::arrays::MaskedArray;
-    use crate::arrays::MaskedVTable;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::Nullability;
-    use crate::serde::ArrayParts;
     use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
     use crate::validity::Validity;
 
     #[rstest]
@@ -234,8 +239,9 @@ mod tests {
 
         let ctx = ArrayContext::empty();
         let serialized = array
-            .to_array()
-            .serialize(&ctx, &SerializeOptions::default())
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
             .unwrap();
 
         // Concat into a single buffer.
@@ -245,10 +251,17 @@ mod tests {
         }
         let concat = concat.freeze();
 
-        let parts = ArrayParts::try_from(concat).unwrap();
-        let decoded = parts.decode(&dtype, len, &ctx, &LEGACY_SESSION).unwrap();
+        let parts = SerializedArray::try_from(concat).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
 
-        assert!(decoded.is::<MaskedVTable>());
+        assert!(decoded.is::<Masked>());
         assert_eq!(
             array.as_ref().display_values().to_string(),
             decoded.display_values().to_string()
@@ -276,7 +289,7 @@ mod tests {
         let result: Canonical = array.into_array().execute(&mut ctx)?;
 
         assert_eq!(
-            result.as_ref().dtype().nullability(),
+            result.dtype().nullability(),
             Nullability::Nullable,
             "MaskedArray execute should produce Nullable dtype"
         );
diff --git a/vortex-array/src/arrays/masked/vtable/operations.rs b/vortex-array/src/arrays/masked/vtable/operations.rs
index 5109c6993e9..eb3132cf957 100644
--- a/vortex-array/src/arrays/masked/vtable/operations.rs
+++ b/vortex-array/src/arrays/masked/vtable/operations.rs
@@ -3,15 +3,20 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
-use crate::arrays::MaskedVTable;
-use crate::arrays::masked::MaskedArray;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Masked;
+use crate::arrays::masked::MaskedArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<MaskedVTable> for MaskedVTable {
-    fn scalar_at(array: &MaskedArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Masked> for Masked {
+    fn scalar_at(
+        array: ArrayView<'_, Masked>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         // Invalid indices are handled by the entrypoint function.
-        Ok(array.child.scalar_at(index)?.into_nullable())
+        Ok(array.child().scalar_at(index)?.into_nullable())
     }
 }
diff --git a/vortex-array/src/arrays/masked/vtable/validity.rs b/vortex-array/src/arrays/masked/vtable/validity.rs
index 96ab2f829c1..e79c882e003 100644
--- a/vortex-array/src/arrays/masked/vtable/validity.rs
+++ b/vortex-array/src/arrays/masked/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::masked::MaskedArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::masked::MaskedArrayExt;
+use crate::arrays::masked::vtable::Masked;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for MaskedArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<Masked> for Masked {
+    fn validity(array: ArrayView<'_, Masked>) -> VortexResult<Validity> {
+        Ok(array.masked_validity())
     }
 }
diff --git a/vortex-array/src/arrays/mod.rs b/vortex-array/src/arrays/mod.rs
index 0d5fa96c258..2597708919a 100644
--- a/vortex-array/src/arrays/mod.rs
+++ b/vortex-array/src/arrays/mod.rs
@@ -7,7 +7,7 @@
 mod assertions;
 
 #[cfg(any(test, feature = "_test-harness"))]
-pub use assertions::format_indices;
+pub use assertions::assert_arrays_eq_impl;
 
 #[cfg(test)]
 mod validation_tests;
@@ -15,49 +15,92 @@ mod validation_tests;
 #[cfg(any(test, feature = "_test-harness"))]
 pub mod dict_test;
 
-mod bool;
-mod chunked;
-mod constant;
-mod datetime;
-mod decimal;
-mod dict;
-mod extension;
-mod filter;
-mod fixed_size_list;
-mod list;
-mod listview;
-mod masked;
-mod null;
-mod primitive;
-mod scalar_fn;
-mod shared;
-mod slice;
-mod struct_;
-mod varbin;
-mod varbinview;
+pub mod bool;
+pub use bool::Bool;
+pub use bool::BoolArray;
+
+pub mod chunked;
+pub use chunked::Chunked;
+pub use chunked::ChunkedArray;
+
+pub mod constant;
+pub use constant::Constant;
+pub use constant::ConstantArray;
+
+pub mod datetime;
+pub use datetime::TemporalArray;
+
+pub mod decimal;
+pub use decimal::Decimal;
+pub use decimal::DecimalArray;
+
+pub mod dict;
+pub use dict::Dict;
+pub use dict::DictArray;
+
+pub mod extension;
+pub use extension::Extension;
+pub use extension::ExtensionArray;
+
+pub mod filter;
+pub use filter::Filter;
+pub use filter::FilterArray;
+
+pub mod fixed_size_list;
+pub use fixed_size_list::FixedSizeList;
+pub use fixed_size_list::FixedSizeListArray;
+
+pub mod list;
+pub use list::List;
+pub use list::ListArray;
+
+pub mod listview;
+pub use listview::ListView;
+pub use listview::ListViewArray;
+
+pub mod masked;
+pub use masked::Masked;
+pub use masked::MaskedArray;
+
+pub mod null;
+pub use null::Null;
+pub use null::NullArray;
+
+pub mod patched;
+pub use patched::Patched;
+pub use patched::PatchedArray;
+
+pub mod primitive;
+pub use primitive::Primitive;
+pub use primitive::PrimitiveArray;
+
+pub mod scalar_fn;
+pub use scalar_fn::ScalarFnArray;
+pub use scalar_fn::ScalarFnVTable;
+
+pub mod shared;
+pub use shared::Shared;
+pub use shared::SharedArray;
+
+pub mod slice;
+pub use slice::Slice;
+pub use slice::SliceArray;
+
+pub mod struct_;
+pub use struct_::Struct;
+pub use struct_::StructArray;
+
+pub mod varbin;
+pub use varbin::VarBin;
+pub use varbin::VarBinArray;
+
+pub mod varbinview;
+pub use varbinview::VarBinView;
+pub use varbinview::VarBinViewArray;
+
+pub mod variant;
+pub use variant::Variant;
+pub use variant::VariantArray;
 
 #[cfg(feature = "arbitrary")]
 pub mod arbitrary;
-// pub mod pipeline;
-// TODO(connor): Export exact types, not glob.
-
-pub use bool::*;
-pub use chunked::*;
-pub use constant::*;
-pub use datetime::*;
-pub use decimal::*;
-pub use dict::*;
-pub use extension::*;
-pub use filter::*;
-pub use fixed_size_list::*;
-pub use list::*;
-pub use listview::*;
-pub use masked::*;
-pub use null::*;
-pub use primitive::*;
-pub use scalar_fn::*;
-pub use shared::*;
-pub use slice::*;
-pub use struct_::*;
-pub use varbin::*;
-pub use varbinview::*;
diff --git a/vortex-array/src/arrays/null/compute/cast.rs b/vortex-array/src/arrays/null/compute/cast.rs
index dff6c440d92..b39dea5988b 100644
--- a/vortex-array/src/arrays/null/compute/cast.rs
+++ b/vortex-array/src/arrays/null/compute/cast.rs
@@ -6,20 +6,20 @@ use vortex_error::vortex_bail;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
-use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
+use crate::arrays::Null;
 use crate::dtype::DType;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::cast::CastReduce;
 
-impl CastReduce for NullVTable {
-    fn cast(array: &NullArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for Null {
+    fn cast(array: ArrayView<'_, Null>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !dtype.is_nullable() {
             vortex_bail!("Cannot cast Null to {}", dtype);
         }
         if dtype == &DType::Null {
-            return Ok(Some(array.to_array()));
+            return Ok(Some(array.array().clone()));
         }
 
         let scalar = Scalar::null(dtype.clone());
@@ -31,6 +31,7 @@ impl CastReduce for NullVTable {
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::NullArray;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -41,7 +42,7 @@ mod tests {
     #[test]
     fn test_cast_null_to_null() {
         let null_array = NullArray::new(5);
-        let result = null_array.to_array().cast(DType::Null).unwrap();
+        let result = null_array.into_array().cast(DType::Null).unwrap();
         assert_eq!(result.len(), 5);
         assert_eq!(result.dtype(), &DType::Null);
     }
@@ -50,7 +51,7 @@ mod tests {
     fn test_cast_null_to_nullable_succeeds() {
         let null_array = NullArray::new(5);
         let result = null_array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I32, Nullability::Nullable))
             .unwrap();
 
@@ -71,7 +72,7 @@ mod tests {
     fn test_cast_null_to_non_nullable_fails() {
         let null_array = NullArray::new(5);
         let result = null_array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::I32, Nullability::NonNullable));
         assert!(result.is_err());
     }
@@ -82,6 +83,6 @@ mod tests {
     #[case(NullArray::new(100))]
     #[case(NullArray::new(0))]
     fn test_cast_null_conformance(#[case] array: NullArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/null/compute/filter.rs b/vortex-array/src/arrays/null/compute/filter.rs
index 8aff0d53367..23e35b1fec1 100644
--- a/vortex-array/src/arrays/null/compute/filter.rs
+++ b/vortex-array/src/arrays/null/compute/filter.rs
@@ -6,12 +6,13 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Null;
 use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
 use crate::arrays::filter::FilterReduce;
 
-impl FilterReduce for NullVTable {
-    fn filter(_array: &NullArray, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+impl FilterReduce for Null {
+    fn filter(_array: ArrayView<'_, Null>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(NullArray::new(mask.true_count()).into_array()))
     }
 }
diff --git a/vortex-array/src/arrays/null/compute/mask.rs b/vortex-array/src/arrays/null/compute/mask.rs
index d8fad1e002e..dbb3afaad1c 100644
--- a/vortex-array/src/arrays/null/compute/mask.rs
+++ b/vortex-array/src/arrays/null/compute/mask.rs
@@ -4,13 +4,13 @@
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
-use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
+use crate::array::ArrayView;
+use crate::arrays::Null;
 use crate::scalar_fn::fns::mask::MaskReduce;
 
-impl MaskReduce for NullVTable {
-    fn mask(array: &NullArray, _mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Null {
+    fn mask(array: ArrayView<'_, Null>, _mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // Null array is already all nulls, masking has no effect.
-        Ok(Some(array.to_array()))
+        Ok(Some(array.array().clone()))
     }
 }
diff --git a/vortex-array/src/arrays/null/compute/min_max.rs b/vortex-array/src/arrays/null/compute/min_max.rs
deleted file mode 100644
index 06dfdcdecd9..00000000000
--- a/vortex-array/src/arrays/null/compute/min_max.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for NullVTable {
-    fn min_max(&self, _array: &NullArray) -> VortexResult<Option<MinMaxResult>> {
-        Ok(None)
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(NullVTable).lift());
diff --git a/vortex-array/src/arrays/null/compute/mod.rs b/vortex-array/src/arrays/null/compute/mod.rs
index c902415c3d2..ad5558a8807 100644
--- a/vortex-array/src/arrays/null/compute/mod.rs
+++ b/vortex-array/src/arrays/null/compute/mod.rs
@@ -4,7 +4,6 @@
 mod cast;
 mod filter;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
@@ -30,7 +29,10 @@ mod test {
         let sliced = nulls.slice(0..4).unwrap().to_null();
 
         assert_eq!(sliced.len(), 4);
-        assert!(matches!(sliced.validity_mask().unwrap(), Mask::AllFalse(4)));
+        assert!(matches!(
+            sliced.as_array().validity_mask().unwrap(),
+            Mask::AllFalse(4)
+        ));
     }
 
     #[test]
@@ -42,7 +44,10 @@ mod test {
             .to_null();
 
         assert_eq!(taken.len(), 5);
-        assert!(matches!(taken.validity_mask().unwrap(), Mask::AllFalse(5)));
+        assert!(matches!(
+            taken.as_array().validity_mask().unwrap(),
+            Mask::AllFalse(5)
+        ));
     }
 
     #[test]
@@ -56,21 +61,21 @@ mod test {
 
     #[test]
     fn test_filter_null_array() {
-        test_filter_conformance(NullArray::new(5).as_ref());
-        test_filter_conformance(NullArray::new(1).as_ref());
-        test_filter_conformance(NullArray::new(10).as_ref());
+        test_filter_conformance(&NullArray::new(5).into_array());
+        test_filter_conformance(&NullArray::new(1).into_array());
+        test_filter_conformance(&NullArray::new(10).into_array());
     }
 
     #[test]
     fn test_mask_null_array() {
-        test_mask_conformance(NullArray::new(5).as_ref());
+        test_mask_conformance(&NullArray::new(5).into_array());
     }
 
     #[test]
     fn test_take_null_array_conformance() {
-        test_take_conformance(NullArray::new(5).as_ref());
-        test_take_conformance(NullArray::new(1).as_ref());
-        test_take_conformance(NullArray::new(10).as_ref());
+        test_take_conformance(&NullArray::new(5).into_array());
+        test_take_conformance(&NullArray::new(1).into_array());
+        test_take_conformance(&NullArray::new(10).into_array());
     }
 
     #[rstest]
@@ -82,6 +87,6 @@ mod test {
     #[case::null_array_large(NullArray::new(1000))]
     #[case::null_array_empty(NullArray::new(0))]
     fn test_null_consistency(#[case] array: NullArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/null/compute/rules.rs b/vortex-array/src/arrays/null/compute/rules.rs
index 4f5ce1deb67..f63c904667a 100644
--- a/vortex-array/src/arrays/null/compute/rules.rs
+++ b/vortex-array/src/arrays/null/compute/rules.rs
@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::FilterReduceAdaptor;
-use crate::arrays::NullVTable;
-use crate::arrays::SliceReduceAdaptor;
-use crate::arrays::TakeReduceAdaptor;
+use crate::arrays::Null;
+use crate::arrays::dict::TakeReduceAdaptor;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<NullVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&FilterReduceAdaptor(NullVTable)),
-    ParentRuleSet::lift(&CastReduceAdaptor(NullVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(NullVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(NullVTable)),
-    ParentRuleSet::lift(&TakeReduceAdaptor(NullVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<Null> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&FilterReduceAdaptor(Null)),
+    ParentRuleSet::lift(&CastReduceAdaptor(Null)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Null)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Null)),
+    ParentRuleSet::lift(&TakeReduceAdaptor(Null)),
 ]);
diff --git a/vortex-array/src/arrays/null/compute/slice.rs b/vortex-array/src/arrays/null/compute/slice.rs
index 00ca16c5a13..19e46dd652d 100644
--- a/vortex-array/src/arrays/null/compute/slice.rs
+++ b/vortex-array/src/arrays/null/compute/slice.rs
@@ -7,12 +7,13 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Null;
 use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for NullVTable {
-    fn slice(_array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Null {
+    fn slice(_array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(NullArray::new(range.len()).into_array()))
     }
 }
diff --git a/vortex-array/src/arrays/null/compute/take.rs b/vortex-array/src/arrays/null/compute/take.rs
index 90840590df6..f24b89aea45 100644
--- a/vortex-array/src/arrays/null/compute/take.rs
+++ b/vortex-array/src/arrays/null/compute/take.rs
@@ -4,20 +4,20 @@
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
+use crate::array::ArrayView;
+use crate::arrays::Null;
 use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
-use crate::arrays::TakeReduce;
-use crate::arrays::TakeReduceAdaptor;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::dict::TakeReduceAdaptor;
 use crate::match_each_integer_ptype;
 use crate::optimizer::rules::ParentRuleSet;
 
-impl TakeReduce for NullVTable {
+impl TakeReduce for Null {
     #[allow(clippy::cast_possible_truncation)]
-    fn take(array: &NullArray, indices: &dyn Array) -> VortexResult<Option<ArrayRef>> {
+    fn take(array: ArrayView<'_, Null>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         let indices = indices.to_primitive();
 
         // Enforce all indices are valid
@@ -33,7 +33,7 @@ impl TakeReduce for NullVTable {
     }
 }
 
-impl NullVTable {
+impl Null {
     pub const TAKE_RULES: ParentRuleSet<Self> =
         ParentRuleSet::new(&[ParentRuleSet::lift(&TakeReduceAdaptor::<Self>(Self))]);
 }
diff --git a/vortex-array/src/arrays/null/mod.rs b/vortex-array/src/arrays/null/mod.rs
index 16620f3ccc9..b2bdcc3a840 100644
--- a/vortex-array/src/arrays/null/mod.rs
+++ b/vortex-array/src/arrays/null/mod.rs
@@ -1,99 +1,111 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::hash::Hash;
-
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::Precision;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArrayView;
+use crate::array::EmptyArrayData;
+use crate::array::OperationsVTable;
+use crate::array::VTable;
+use crate::array::ValidityVTable;
 use crate::arrays::null::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
-use crate::stats::ArrayStats;
-use crate::stats::StatsSetRef;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
 
 pub(crate) mod compute;
 
-vtable!(Null);
-
-impl VTable for NullVTable {
-    type Array = NullArray;
+/// A [`Null`]-encoded Vortex array.
+pub type NullArray = Array<Null>;
 
-    type Metadata = EmptyMetadata;
+impl VTable for Null {
+    type ArrayData = EmptyArrayData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &NullArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn validate(
+        &self,
+        _data: &EmptyArrayData,
+        dtype: &DType,
+        _len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(*dtype == DType::Null, "NullArray dtype must be DType::Null");
+        Ok(())
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("NullArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        vortex_panic!("NullArray slot_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
-        _dtype: &DType,
+    fn deserialize(
+        &self,
+        dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         _buffers: &[BufferHandle],
         _children: &dyn ArrayChildren,
-    ) -> VortexResult<NullArray> {
-        Ok(NullArray::new(len))
-    }
-
-    fn with_children(_array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
         vortex_ensure!(
-            children.is_empty(),
-            "NullArray has no children, got {}",
-            children.len()
+            metadata.is_empty(),
+            "NullArray expects empty metadata, got {} bytes",
+            metadata.len()
         );
-        Ok(())
+        Ok(ArrayParts::new(
+            self.clone(),
+            dtype.clone(),
+            len,
+            EmptyArrayData,
+        ))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 }
 
@@ -125,71 +137,32 @@ impl VTable for NullVTable {
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct NullArray {
-    len: usize,
-    stats_set: ArrayStats,
-}
-
-#[derive(Debug)]
-pub struct NullVTable;
+pub struct Null;
 
-impl NullVTable {
+impl Null {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.null");
 }
 
-impl NullArray {
+impl Array<Null> {
     pub fn new(len: usize) -> Self {
-        Self {
-            len,
-            stats_set: Default::default(),
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(Null, DType::Null, len, EmptyArrayData))
         }
     }
 }
 
-impl BaseArrayVTable<NullVTable> for NullVTable {
-    fn len(array: &NullArray) -> usize {
-        array.len
-    }
-
-    fn dtype(_array: &NullArray) -> &DType {
-        &DType::Null
-    }
-
-    fn stats(array: &NullArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &NullArray, state: &mut H, _precision: Precision) {
-        array.len.hash(state);
-    }
-
-    fn array_eq(array: &NullArray, other: &NullArray, _precision: Precision) -> bool {
-        array.len == other.len
-    }
-}
-
-impl VisitorVTable<NullVTable> for NullVTable {
-    fn visit_buffers(_array: &NullArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(_array: &NullArray, _visitor: &mut dyn ArrayChildVisitor) {}
-
-    fn nchildren(_array: &NullArray) -> usize {
-        0
-    }
-
-    fn nth_child(_array: &NullArray, _idx: usize) -> Option<ArrayRef> {
-        None
-    }
-}
-
-impl OperationsVTable<NullVTable> for NullVTable {
-    fn scalar_at(_array: &NullArray, _index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Null> for Null {
+    fn scalar_at(
+        _array: ArrayView<'_, Null>,
+        _index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(Scalar::null(DType::Null))
     }
 }
 
-impl ValidityVTable<NullVTable> for NullVTable {
-    fn validity(_array: &NullArray) -> VortexResult<Validity> {
+impl ValidityVTable<Null> for Null {
+    fn validity(_array: ArrayView<'_, Null>) -> VortexResult<Validity> {
         Ok(Validity::AllInvalid)
     }
 }
diff --git a/vortex-array/src/arrays/patched/array.rs b/vortex-array/src/arrays/patched/array.rs
new file mode 100644
index 00000000000..869671d396a
--- /dev/null
+++ b/vortex-array/src/arrays/patched/array.rs
@@ -0,0 +1,400 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::ops::Range;
+
+use vortex_buffer::Buffer;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array_slots;
+use crate::arrays::Patched;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::patched::TransposedPatches;
+use crate::arrays::patched::patch_lanes;
+use crate::buffer::BufferHandle;
+use crate::dtype::DType;
+use crate::dtype::IntegerPType;
+use crate::dtype::NativePType;
+use crate::dtype::PType;
+use crate::match_each_native_ptype;
+use crate::match_each_unsigned_integer_ptype;
+use crate::patches::Patches;
+use crate::validity::Validity;
+
+#[derive(Debug, Clone)]
+pub struct PatchedData {
+    /// Number of lanes the patch indices and values have been split into. Each of the `n_chunks`
+    /// of 1024 values is split into `n_lanes` lanes horizontally, each lane having 1024 / n_lanes
+    /// values that might be patched.
+    pub(super) n_lanes: usize,
+
+    /// The offset into that first chunk that is considered in bounds.
+    ///
+    /// The patch indices of the first chunk less than `offset` should be skipped, and the offset
+    /// should be subtracted out of the remaining offsets to get their final position in the
+    /// executed array.
+    pub(super) offset: usize,
+}
+
+#[array_slots(Patched)]
+pub struct PatchedSlots {
+    /// The inner array containing the base unpatched values.
+    pub inner: ArrayRef,
+    /// The lane offsets array for locating patches within lanes.
+    pub lane_offsets: ArrayRef,
+    /// The indices of patched (exception) values.
+    pub patch_indices: ArrayRef,
+    /// The patched (exception) values at the corresponding indices.
+    pub patch_values: ArrayRef,
+}
+
+impl Display for PatchedData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "n_lanes: {}, offset: {}", self.n_lanes, self.offset)
+    }
+}
+
+impl PatchedData {
+    pub(crate) fn validate(
+        &self,
+        dtype: &DType,
+        len: usize,
+        slots: &PatchedSlotsView,
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.inner.dtype() == dtype,
+            "PatchedArray base dtype {} does not match outer dtype {}",
+            slots.inner.dtype(),
+            dtype
+        );
+        vortex_ensure!(
+            slots.inner.len() == len,
+            "PatchedArray base len {} does not match outer len {}",
+            slots.inner.len(),
+            len
+        );
+        vortex_ensure!(
+            slots.patch_indices.len() == slots.patch_values.len(),
+            "PatchedArray patch indices len {} does not match patch values len {}",
+            slots.patch_indices.len(),
+            slots.patch_values.len()
+        );
+        Ok(())
+    }
+}
+
+pub trait PatchedArrayExt: PatchedArraySlotsExt {
+    #[inline]
+    fn n_lanes(&self) -> usize {
+        self.n_lanes
+    }
+
+    #[inline]
+    fn offset(&self) -> usize {
+        self.offset
+    }
+
+    #[inline]
+    fn lane_range(&self, chunk: usize, lane: usize) -> VortexResult<Range<usize>> {
+        assert!(chunk * 1024 <= self.as_ref().len() + self.offset());
+        assert!(lane < self.n_lanes());
+
+        let start = self
+            .lane_offsets()
+            .scalar_at(chunk * self.n_lanes() + lane)?;
+        let stop = self
+            .lane_offsets()
+            .scalar_at(chunk * self.n_lanes() + lane + 1)?;
+
+        let start = start
+            .as_primitive()
+            .as_::<usize>()
+            .ok_or_else(|| vortex_err!("could not cast lane_offset to usize"))?;
+
+        let stop = stop
+            .as_primitive()
+            .as_::<usize>()
+            .ok_or_else(|| vortex_err!("could not cast lane_offset to usize"))?;
+
+        Ok(start..stop)
+    }
+
+    fn slice_chunks(&self, chunks: Range<usize>) -> VortexResult<Array<Patched>> {
+        let lane_offsets_start = chunks.start * self.n_lanes();
+        let lane_offsets_stop = chunks.end * self.n_lanes() + 1;
+
+        let sliced_lane_offsets = self
+            .lane_offsets()
+            .slice(lane_offsets_start..lane_offsets_stop)?;
+        let indices = self.patch_indices().clone();
+        let values = self.patch_values().clone();
+
+        let begin = (chunks.start * 1024).saturating_sub(self.offset());
+        let end = (chunks.end * 1024)
+            .saturating_sub(self.offset())
+            .min(self.as_ref().len());
+
+        let offset = if chunks.start == 0 { self.offset() } else { 0 };
+        let inner = self.inner().slice(begin..end)?;
+        let len = inner.len();
+        let dtype = self.as_ref().dtype().clone();
+        let slots = PatchedSlots {
+            inner,
+            lane_offsets: sliced_lane_offsets,
+            patch_indices: indices,
+            patch_values: values,
+        }
+        .into_slots();
+
+        Ok(unsafe { Patched::new_unchecked(dtype, len, slots, self.n_lanes(), offset) })
+    }
+}
+
+impl<T: TypedArrayRef<Patched>> PatchedArrayExt for T {}
+
+impl Patched {
+    pub fn from_array_and_patches(
+        inner: ArrayRef,
+        patches: &Patches,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Array<Patched>> {
+        vortex_ensure!(
+            inner.dtype().eq_with_nullability_superset(patches.dtype()),
+            "array DType must match patches DType"
+        );
+
+        vortex_ensure!(
+            inner.dtype().is_primitive(),
+            "Creating PatchedArray from Patches only supported for primitive arrays"
+        );
+
+        vortex_ensure!(
+            patches.num_patches() <= u32::MAX as usize,
+            "PatchedArray does not support > u32::MAX patch values"
+        );
+
+        vortex_ensure!(
+            patches.values().all_valid()?,
+            "PatchedArray cannot be built from Patches with nulls"
+        );
+
+        let values_ptype = patches.dtype().as_ptype();
+
+        let TransposedPatches {
+            n_lanes,
+            lane_offsets,
+            indices,
+            values,
+        } = transpose_patches(patches, ctx)?;
+
+        let lane_offsets = PrimitiveArray::from_buffer_handle(
+            BufferHandle::new_host(lane_offsets),
+            PType::U32,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let indices = PrimitiveArray::from_buffer_handle(
+            BufferHandle::new_host(indices),
+            PType::U16,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let values = PrimitiveArray::from_buffer_handle(
+            BufferHandle::new_host(values),
+            values_ptype,
+            Validity::NonNullable,
+        )
+        .into_array();
+
+        let dtype = inner.dtype().clone();
+        let len = inner.len();
+        let slots = PatchedSlots {
+            inner,
+            lane_offsets,
+            patch_indices: indices,
+            patch_values: values,
+        }
+        .into_slots();
+        Ok(unsafe { Self::new_unchecked(dtype, len, slots, n_lanes, 0) })
+    }
+
+    pub(crate) unsafe fn new_unchecked(
+        dtype: DType,
+        len: usize,
+        slots: Vec<Option<ArrayRef>>,
+        n_lanes: usize,
+        offset: usize,
+    ) -> Array<Patched> {
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Patched, dtype, len, PatchedData { n_lanes, offset })
+                    .with_slots(slots),
+            )
+        }
+    }
+}
+
+/// Transpose a set of patches from the default sorted layout into the data parallel layout.
+#[allow(clippy::cognitive_complexity)]
+fn transpose_patches(patches: &Patches, ctx: &mut ExecutionCtx) -> VortexResult<TransposedPatches> {
+    let array_len = patches.array_len();
+    let offset = patches.offset();
+
+    let indices = patches
+        .indices()
+        .clone()
+        .execute::<Canonical>(ctx)?
+        .into_primitive();
+
+    let values = patches
+        .values()
+        .clone()
+        .execute::<Canonical>(ctx)?
+        .into_primitive();
+
+    let indices_ptype = indices.ptype();
+    let values_ptype = values.ptype();
+
+    let indices = indices.buffer_handle().clone().unwrap_host();
+    let values = values.buffer_handle().clone().unwrap_host();
+
+    match_each_unsigned_integer_ptype!(indices_ptype, |I| {
+        match_each_native_ptype!(values_ptype, |V| {
+            let indices: Buffer<I> = Buffer::from_byte_buffer(indices);
+            let values: Buffer<V> = Buffer::from_byte_buffer(values);
+
+            Ok(transpose(
+                indices.as_slice(),
+                values.as_slice(),
+                offset,
+                array_len,
+            ))
+        })
+    })
+}
+
+#[allow(clippy::cast_possible_truncation)]
+fn transpose<I: IntegerPType, V: NativePType>(
+    indices_in: &[I],
+    values_in: &[V],
+    offset: usize,
+    array_len: usize,
+) -> TransposedPatches {
+    // Total number of slots is number of chunks times number of lanes.
+    let n_chunks = array_len.div_ceil(1024);
+    assert!(
+        n_chunks <= u32::MAX as usize,
+        "Cannot transpose patches for array with >= 4 trillion elements"
+    );
+
+    let n_lanes = patch_lanes::<V>();
+
+    // We know upfront how many indices and values we'll have.
+    let mut indices_buffer = BufferMut::with_capacity(indices_in.len());
+    let mut values_buffer = BufferMut::with_capacity(values_in.len());
+
+    // Number of patches in each chunk/lane.
+    let mut lane_offsets: BufferMut<u32> = BufferMut::zeroed(n_chunks * n_lanes + 1);
+
+    // Scan the index/value pairs once to get chunk/lane counts.
+    for index in indices_in {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        lane_offsets[chunk * n_lanes + lane + 1] += 1;
+    }
+
+    for index in 1..lane_offsets.len() {
+        lane_offsets[index] += lane_offsets[index - 1];
+    }
+
+    // Loop over patches, writing them to final positions.
+    let indices_out = indices_buffer.spare_capacity_mut();
+    let values_out = values_buffer.spare_capacity_mut();
+    for (index, &value) in std::iter::zip(indices_in, values_in) {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        let position = &mut lane_offsets[chunk * n_lanes + lane];
+        indices_out[*position as usize].write((index % 1024) as u16);
+        values_out[*position as usize].write(value);
+        *position += 1;
+    }
+
+    unsafe {
+        indices_buffer.set_len(indices_in.len());
+        values_buffer.set_len(values_in.len());
+    }
+
+    for index in indices_in {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        lane_offsets[chunk * n_lanes + lane] -= 1;
+    }
+
+    TransposedPatches {
+        n_lanes,
+        lane_offsets: lane_offsets.freeze().into_byte_buffer(),
+        indices: indices_buffer.freeze().into_byte_buffer(),
+        values: values_buffer.freeze().into_byte_buffer(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+
+    use super::PatchedSlots;
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::array_slots;
+    use crate::arrays::Null;
+    use crate::arrays::PrimitiveArray;
+    use crate::validity::Validity;
+
+    #[array_slots(Null)]
+    struct OptionalPatchedSlots {
+        required: ArrayRef,
+        maybe: Option<ArrayRef>,
+    }
+
+    #[test]
+    fn generated_slots_round_trip() {
+        let required = PrimitiveArray::new(buffer![1u8, 2, 3], Validity::NonNullable).into_array();
+        let optional = PrimitiveArray::new(buffer![4u8, 5, 6], Validity::NonNullable).into_array();
+
+        let slot_vec = vec![Some(required.clone()), Some(optional.clone())];
+        let view = OptionalPatchedSlotsView::from_slots(&slot_vec);
+        assert_eq!(view.required.len(), 3);
+        assert_eq!(view.maybe.expect("optional slot").len(), 3);
+
+        let cloned = OptionalPatchedSlots::from_slots(slot_vec);
+        assert_eq!(cloned.required.len(), required.len());
+        assert_eq!(cloned.maybe.expect("optional clone").len(), optional.len());
+
+        let rebuilt = PatchedSlots::from_slots(vec![
+            Some(required.clone()),
+            Some(optional.clone()),
+            Some(required.clone()),
+            Some(optional.clone()),
+        ]);
+        assert_eq!(rebuilt.inner.len(), required.len());
+        assert_eq!(rebuilt.patch_values.len(), optional.len());
+    }
+}
diff --git a/vortex-array/src/arrays/patched/compute/compare.rs b/vortex-array/src/arrays/patched/compute/compare.rs
new file mode 100644
index 00000000000..abd54574940
--- /dev/null
+++ b/vortex-array/src/arrays/patched/compute/compare.rs
@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_buffer::BitBufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::child_to_validity;
+use crate::arrays::BoolArray;
+use crate::arrays::ConstantArray;
+use crate::arrays::Patched;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::bool::BoolDataParts;
+use crate::arrays::patched::PatchedArrayExt;
+use crate::arrays::patched::PatchedArraySlotsExt;
+use crate::arrays::primitive::NativeValue;
+use crate::builtins::ArrayBuiltins;
+use crate::dtype::NativePType;
+use crate::match_each_native_ptype;
+use crate::scalar_fn::fns::binary::CompareKernel;
+use crate::scalar_fn::fns::operators::CompareOperator;
+
+impl CompareKernel for Patched {
+    fn compare(
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
+        operator: CompareOperator,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        // We only accelerate comparisons for primitives
+        if !lhs.dtype().is_primitive() {
+            return Ok(None);
+        }
+
+        // We only accelerate comparisons against constants
+        let Some(constant) = rhs.as_constant() else {
+            return Ok(None);
+        };
+
+        // NOTE: due to offset, it's possible that the inner.len != array.len.
+        //  We slice the inner before performing the comparison.
+        let result = lhs
+            .inner()
+            .binary(
+                ConstantArray::new(constant.clone(), lhs.len()).into_array(),
+                operator.into(),
+            )?
+            .execute::<Canonical>(ctx)?
+            .into_bool();
+
+        let validity = child_to_validity(&result.slots()[0], result.dtype().nullability());
+        let len = result.len();
+        let BoolDataParts { bits, offset, len } = result.into_data().into_parts(len);
+
+        let mut bits = BitBufferMut::from_buffer(bits.unwrap_host().into_mut(), offset, len);
+
+        let lane_offsets = lhs.lane_offsets().clone().execute::<PrimitiveArray>(ctx)?;
+        let indices = lhs.patch_indices().clone().execute::<PrimitiveArray>(ctx)?;
+        let values = lhs.patch_values().clone().execute::<PrimitiveArray>(ctx)?;
+        let n_lanes = lhs.n_lanes();
+
+        match_each_native_ptype!(values.ptype(), |V| {
+            let offset = lhs.offset();
+            let indices = indices.as_slice::<u16>();
+            let values = values.as_slice::<V>();
+            let constant = constant
+                .as_primitive()
+                .as_::<V>()
+                .vortex_expect("compare constant not null");
+
+            let apply_patches = ApplyPatches {
+                bits: &mut bits,
+                offset,
+                n_lanes,
+                lane_offsets: lane_offsets.as_slice::<u32>(),
+                indices,
+                values,
+                constant,
+            };
+
+            match operator {
+                CompareOperator::Eq => {
+                    apply_patches.apply(|l, r| NativeValue(l) == NativeValue(r))?;
+                }
+                CompareOperator::NotEq => {
+                    apply_patches.apply(|l, r| NativeValue(l) != NativeValue(r))?;
+                }
+                CompareOperator::Gt => {
+                    apply_patches.apply(|l, r| NativeValue(l) > NativeValue(r))?;
+                }
+                CompareOperator::Gte => {
+                    apply_patches.apply(|l, r| NativeValue(l) >= NativeValue(r))?;
+                }
+                CompareOperator::Lt => {
+                    apply_patches.apply(|l, r| NativeValue(l) < NativeValue(r))?;
+                }
+                CompareOperator::Lte => {
+                    apply_patches.apply(|l, r| NativeValue(l) <= NativeValue(r))?;
+                }
+            }
+        });
+
+        let result = BoolArray::new(bits.freeze(), validity);
+        Ok(Some(result.into_array()))
+    }
+}
+
+struct ApplyPatches<'a, V: NativePType> {
+    bits: &'a mut BitBufferMut,
+    offset: usize,
+    n_lanes: usize,
+    lane_offsets: &'a [u32],
+    indices: &'a [u16],
+    values: &'a [V],
+    constant: V,
+}
+
+impl<V: NativePType> ApplyPatches<'_, V> {
+    fn apply<F>(self, cmp: F) -> VortexResult<()>
+    where
+        F: Fn(V, V) -> bool,
+    {
+        for index in 0..(self.lane_offsets.len() - 1) {
+            let chunk = index / self.n_lanes;
+
+            let lane_start = self.lane_offsets[index] as usize;
+            let lane_end = self.lane_offsets[index + 1] as usize;
+
+            for (&patch_index, &patch_value) in std::iter::zip(
+                &self.indices[lane_start..lane_end],
+                &self.values[lane_start..lane_end],
+            ) {
+                let bit_index = chunk * 1024 + patch_index as usize;
+                // Skip any indices < the offset.
+                if bit_index < self.offset {
+                    continue;
+                }
+                let bit_index = bit_index - self.offset;
+                if bit_index >= self.bits.len() {
+                    break;
+                }
+                if cmp(patch_value, self.constant) {
+                    self.bits.set(bit_index)
+                } else {
+                    self.bits.unset(bit_index)
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::BoolArray;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::Patched;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::optimizer::ArrayOptimizer;
+    use crate::patches::Patches;
+    use crate::scalar_fn::fns::binary::CompareKernel;
+    use crate::scalar_fn::fns::operators::CompareOperator;
+    use crate::validity::Validity;
+
+    #[test]
+    fn test_basic() {
+        let lhs = PrimitiveArray::from_iter(0u32..512).into_array();
+        let patches = Patches::new(
+            512,
+            0,
+            buffer![509u16, 510, 511].into_array(),
+            buffer![u32::MAX; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx)
+            .unwrap()
+            .into_array()
+            .try_downcast::<Patched>()
+            .unwrap();
+
+        let rhs = ConstantArray::new(u32::MAX, 512).into_array();
+
+        let result =
+            <Patched as CompareKernel>::compare(lhs.as_view(), &rhs, CompareOperator::Eq, &mut ctx)
+                .unwrap()
+                .unwrap();
+
+        let expected =
+            BoolArray::from_indices(512, [509, 510, 511], Validity::NonNullable).into_array();
+
+        assert_arrays_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_with_offset() {
+        let lhs = PrimitiveArray::from_iter(0u32..512).into_array();
+        let patches = Patches::new(
+            512,
+            0,
+            buffer![5u16, 510, 511].into_array(),
+            buffer![u32::MAX; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx).unwrap();
+        // Slice the array so that the first patch should be skipped.
+        let lhs_ref = lhs.into_array().slice(10..512).unwrap().optimize().unwrap();
+        let lhs = lhs_ref.try_downcast::<Patched>().unwrap();
+
+        assert_eq!(lhs.len(), 502);
+
+        let rhs = ConstantArray::new(u32::MAX, lhs.len()).into_array();
+
+        let result =
+            <Patched as CompareKernel>::compare(lhs.as_view(), &rhs, CompareOperator::Eq, &mut ctx)
+                .unwrap()
+                .unwrap();
+
+        let expected = BoolArray::from_indices(502, [500, 501], Validity::NonNullable).into_array();
+
+        assert_arrays_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_subnormal_f32() -> VortexResult<()> {
+        // Subnormal f32 values are smaller than f32::MIN_POSITIVE but greater than 0
+        let subnormal: f32 = f32::MIN_POSITIVE / 2.0;
+        assert!(subnormal > 0.0 && subnormal < f32::MIN_POSITIVE);
+
+        let lhs = PrimitiveArray::from_iter((0..512).map(|i| i as f32)).into_array();
+
+        let patches = Patches::new(
+            512,
+            0,
+            buffer![509u16, 510, 511].into_array(),
+            buffer![f32::NAN, subnormal, f32::NEG_INFINITY].into_array(),
+            None,
+        )?;
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+        let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx)?
+            .into_array()
+            .try_downcast::<Patched>()
+            .unwrap();
+
+        let rhs = ConstantArray::new(subnormal, 512).into_array();
+
+        let result = <Patched as CompareKernel>::compare(
+            lhs.as_view(),
+            &rhs,
+            CompareOperator::Eq,
+            &mut ctx,
+        )?
+        .unwrap();
+
+        let expected = BoolArray::from_indices(512, [510], Validity::NonNullable).into_array();
+
+        assert_arrays_eq!(expected, result);
+        Ok(())
+    }
+
+    #[test]
+    fn test_pos_neg_zero() -> VortexResult<()> {
+        let lhs = PrimitiveArray::from_iter([-0.0f32; 10]).into_array();
+
+        let patches = Patches::new(
+            10,
+            0,
+            buffer![5u16, 6, 7, 8, 9].into_array(),
+            buffer![f32::NAN, f32::NEG_INFINITY, 0f32, -0.0f32, f32::INFINITY].into_array(),
+            None,
+        )?;
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+        let lhs = Patched::from_array_and_patches(lhs, &patches, &mut ctx)?
+            .into_array()
+            .try_downcast::<Patched>()
+            .unwrap();
+
+        let rhs = ConstantArray::new(0.0f32, 10).into_array();
+
+        let result = <Patched as CompareKernel>::compare(
+            lhs.as_view(),
+            &rhs,
+            CompareOperator::Eq,
+            &mut ctx,
+        )?
+        .unwrap();
+
+        let expected = BoolArray::from_indices(10, [7], Validity::NonNullable).into_array();
+
+        assert_arrays_eq!(expected, result);
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/patched/compute/filter.rs b/vortex-array/src/arrays/patched/compute/filter.rs
new file mode 100644
index 00000000000..d2c60941059
--- /dev/null
+++ b/vortex-array/src/arrays/patched/compute/filter.rs
@@ -0,0 +1,301 @@
+// 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 crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::FilterArray;
+use crate::arrays::Patched;
+use crate::arrays::filter::FilterReduce;
+use crate::arrays::patched::PatchedArrayExt;
+
+impl FilterReduce for Patched {
+    fn filter(array: ArrayView<'_, Self>, mask: &Mask) -> VortexResult<Option<ArrayRef>> {
+        // Find the contiguous chunk range that the mask covers. We use this to slice the inner
+        // components, then wrap the rest up with another FilterArray.
+        //
+        // This is helpful when we have a very selective filter that is clustered to a small
+        // range.
+        let (chunk_start, chunk_stop) = match mask.slices() {
+            AllOr::All | AllOr::None => {
+                // This is handled as the precondition to this method, see the FilterReduce
+                // documentation.
+                unreachable!("mask must be a MaskValues here")
+            }
+            AllOr::Some(slices) => {
+                let (first, _) = slices[0];
+                let (_, last) = slices[slices.len() - 1];
+
+                // Convert mask indices to absolute positions by adding offset
+                (
+                    (array.offset() + first) / 1024,
+                    (array.offset() + last).div_ceil(1024),
+                )
+            }
+        };
+
+        let n_chunks = (array.offset() + array.len()).div_ceil(1024);
+
+        // If all chunks already covered, there is nothing to do.
+        if chunk_start == 0 && chunk_stop == n_chunks {
+            return Ok(None);
+        }
+
+        let sliced = array.slice_chunks(chunk_start..chunk_stop)?;
+
+        // Slice the mask according to if the chunk is sliced.
+        // Convert chunk bounds back to mask indices by subtracting offset.
+        let mask_start = (chunk_start * 1024).saturating_sub(array.offset());
+        let mask_end = (chunk_stop * 1024)
+            .saturating_sub(array.offset())
+            .min(array.len());
+        let remainder = mask.slice(mask_start..mask_end);
+
+        Ok(Some(
+            FilterArray::new(sliced.into_array(), remainder).into_array(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+    use vortex_mask::Mask;
+
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::Patched;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::optimizer::ArrayOptimizer;
+    use crate::patches::Patches;
+
+    #[test]
+    fn test_filter_noop() -> VortexResult<()> {
+        // Filter that doesn't prune any chunks (all data fits in one chunk).
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let array = buffer![u16::MIN; 5].into_array();
+        let patched_indices = buffer![3u8, 4].into_array();
+        let patched_values = buffer![u16::MAX; 2].into_array();
+
+        let patches = Patches::new(5, 0, patched_indices, patched_values, None)?;
+
+        let array = Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array();
+
+        let mask = Mask::from_iter([true, false, false, false, true]);
+        let filtered = array
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        // Values at indices 0 and 4: MIN and MAX.
+        let expected = PrimitiveArray::from_iter([u16::MIN, u16::MAX]);
+
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_with_offset() -> VortexResult<()> {
+        // Test filtering where offset > 0.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let array = buffer![u16::MIN; 4096].into_array();
+        let patched_indices = buffer![5u16, 1030].into_array();
+        let patched_values = buffer![u16::MAX; 2].into_array();
+
+        let patches = Patches::new(4096, 0, patched_indices, patched_values, None)?;
+
+        let array = Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array();
+
+        let sliced = array.slice(5..4096)?.optimize()?;
+
+        // Filter that touches only the first 2 chunks.
+        let mask = Mask::from_indices(4091, vec![0, 1, 2, 1025]);
+        let filtered = sliced
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        let expected = PrimitiveArray::from_iter([u16::MAX, u16::MIN, u16::MIN, u16::MAX]);
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_basic() -> VortexResult<()> {
+        // Basic test: filter with mask that crosses boundaries.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let array = buffer![u16::MIN; 4096].into_array();
+        let patched_indices = buffer![1024u16, 1025].into_array();
+        let patched_values = buffer![u16::MAX, u16::MAX].into_array();
+
+        let patches = Patches::new(4096, 0, patched_indices, patched_values, None)?;
+
+        let array = Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array();
+
+        // Filter that only touches the middle 2 chunks.
+        let mask = Mask::from_indices(4096, vec![1024, 1025, 3000]);
+        let filtered = array
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        let expected = PrimitiveArray::from_iter([u16::MAX, u16::MAX, u16::MIN]);
+
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_complex() -> VortexResult<()> {
+        // Filter with mask that crosses boundaries, with patches offset.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let array = buffer![u16::MIN; 4096].into_array();
+        let patched_indices = buffer![1024u16, 1025].into_array();
+        let patched_values = buffer![u16::MAX, u16::MAX].into_array();
+
+        let patches = Patches::new(4096, 1, patched_indices, patched_values, None)?;
+
+        let array = Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array();
+
+        // Filter that only touches the middle 2 chunks.
+        let mask = Mask::from_indices(4096, vec![1024, 1025, 3000]);
+        let filtered = array
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        let expected = PrimitiveArray::from_iter([u16::MAX, u16::MIN, u16::MIN]);
+
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_sliced() -> VortexResult<()> {
+        // Test filter on a sliced PatchedArray to exercise codepath where offset > 0.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        // Create a larger array (6 chunks) so we can slice and still have room
+        // for the filter to prune chunks.
+        let array = buffer![u16::MIN; 6144].into_array();
+        // Patches at indices 2048 and 2049 (start of chunk 2).
+        let patched_indices = buffer![2048u16, 2049].into_array();
+        let patched_values = buffer![u16::MAX, u16::MAX].into_array();
+
+        let patches = Patches::new(6144, 0, patched_indices, patched_values, None)?;
+
+        let patched = Patched::from_array_and_patches(array, &patches, &mut ctx)?;
+
+        // Slice at chunk boundary to create offset > 0. After slicing [1024..5120],
+        // we have 4096 elements and patches are at relative indices 1024 and 1025.
+        let sliced = patched.into_array().slice(1024..5120)?;
+        assert_eq!(sliced.len(), 4096);
+
+        // Filter that only touches the middle 2 chunks (chunks 1 and 2).
+        // Indices 1024 and 1025 fall in chunk 1, and 3000 falls in chunk 2.
+        let mask = Mask::from_indices(4096, vec![1024, 1025, 3000]);
+
+        let filtered = sliced
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        let expected = PrimitiveArray::from_iter([u16::MAX, u16::MAX, u16::MIN]);
+
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_with_offset_nonuniform() -> VortexResult<()> {
+        // Test filtering with offset > 0 using non-uniform base values.
+        // This catches slice_chunks bugs where inner coordinates are miscalculated.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        // Use non-uniform values so that incorrect slicing is detectable.
+        let base_values: Vec<u16> = (0u16..4096).collect();
+        let array = PrimitiveArray::from_iter(base_values).into_array();
+
+        // Patch at index 5 (value becomes 9999) and index 1030 (value becomes 8888).
+        let patched_indices = buffer![5u16, 1030].into_array();
+        let patched_values = buffer![9999u16, 8888].into_array();
+
+        let patches = Patches::new(4096, 0, patched_indices, patched_values, None)?;
+        let array = Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array();
+
+        // Slice to create offset > 0.
+        // After slice(5..4096), logical position 0 = original position 5 (patched to 9999).
+        let sliced = array.slice(5..4096)?.optimize()?;
+        assert_eq!(sliced.len(), 4091);
+
+        // Filter that touches the first 2 chunks.
+        // Logical indices: 0 (was 5, patched), 1 (was 6, value 6), 1025 (was 1030, patched).
+        let mask = Mask::from_indices(4091, vec![0, 1, 1025]);
+        let filtered = sliced
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        // Expected: 9999 (patched at logical 0), 6 (original at logical 1), 8888 (patched at logical 1025).
+        let expected = PrimitiveArray::from_iter([9999u16, 6, 8888]);
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter_with_offset_last_chunk() -> VortexResult<()> {
+        // Test filtering with offset > 0 where the mask touches the last chunk.
+        // This ensures we don't accidentally slice past the end of the array or mask.
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        // Create a 6-chunk array (6144 elements).
+        let array = buffer![u16::MIN; 6144].into_array();
+        // Patches near the end of the array at indices 5000 and 6000.
+        let patched_indices = buffer![5000u16, 6000].into_array();
+        let patched_values = buffer![u16::MAX; 2].into_array();
+
+        let patches = Patches::new(6144, 0, patched_indices, patched_values, None)?;
+
+        let patched = Patched::from_array_and_patches(array, &patches, &mut ctx)?;
+
+        // Slice at chunk boundary to create offset > 0.
+        // Slice [1024..6144] gives us 5120 elements (5 chunks).
+        // Original patches at 5000 and 6000 become relative indices 3976 and 4976.
+        let sliced = patched.into_array().slice(1024..6144)?.optimize()?;
+        assert_eq!(sliced.len(), 5120);
+
+        // Filter that touches only the last 2 chunks (chunks 3 and 4).
+        // Chunk 3: indices 3072-4095, Chunk 4: indices 4096-5119.
+        // Patch at 3976 is in chunk 3, patch at 4976 is in chunk 4.
+        let mask = Mask::from_indices(5120, vec![3976, 4976, 5119]);
+
+        let filtered = sliced
+            .filter(mask)?
+            .optimize()?
+            .execute::<PrimitiveArray>(&mut ctx)?;
+
+        // Expected: patch at 3976 (was 5000), patch at 4976 (was 6000), and MIN at 5119.
+        let expected = PrimitiveArray::from_iter([u16::MAX, u16::MAX, u16::MIN]);
+
+        assert_arrays_eq!(expected, filtered);
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/patched/compute/mod.rs b/vortex-array/src/arrays/patched/compute/mod.rs
new file mode 100644
index 00000000000..8634a22f90b
--- /dev/null
+++ b/vortex-array/src/arrays/patched/compute/mod.rs
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod compare;
+mod filter;
+pub(crate) mod rules;
+mod take;
diff --git a/vortex-array/src/arrays/patched/compute/rules.rs b/vortex-array/src/arrays/patched/compute/rules.rs
new file mode 100644
index 00000000000..3ecb25c1efa
--- /dev/null
+++ b/vortex-array/src/arrays/patched/compute/rules.rs
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use crate::arrays::Patched;
+use crate::arrays::filter::FilterReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
+use crate::optimizer::rules::ParentRuleSet;
+
+pub(crate) const PARENT_RULES: ParentRuleSet<Patched> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&FilterReduceAdaptor(Patched)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Patched)),
+]);
diff --git a/vortex-array/src/arrays/patched/compute/take.rs b/vortex-array/src/arrays/patched/compute/take.rs
new file mode 100644
index 00000000000..49aa726c51c
--- /dev/null
+++ b/vortex-array/src/arrays/patched/compute/take.rs
@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use rustc_hash::FxHashMap;
+use vortex_buffer::Buffer;
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Patched;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::patched::PatchedArrayExt;
+use crate::arrays::patched::PatchedArraySlotsExt;
+use crate::arrays::primitive::PrimitiveDataParts;
+use crate::dtype::IntegerPType;
+use crate::dtype::NativePType;
+use crate::match_each_native_ptype;
+use crate::match_each_unsigned_integer_ptype;
+
+impl TakeExecute for Patched {
+    fn take(
+        array: ArrayView<'_, Self>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        // Only pushdown take when we have primitive types.
+        if !array.dtype().is_primitive() {
+            return Ok(None);
+        }
+
+        // Perform take on the inner array, including the placeholders.
+        let inner = array
+            .inner()
+            .take(indices.clone())?
+            .execute::<PrimitiveArray>(ctx)?;
+
+        let PrimitiveDataParts {
+            buffer,
+            validity,
+            ptype,
+        } = inner.into_data_parts();
+
+        let indices_ptype = indices.dtype().as_ptype();
+
+        match_each_unsigned_integer_ptype!(indices_ptype, |I| {
+            match_each_native_ptype!(ptype, |V| {
+                let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
+                let lane_offsets = array
+                    .lane_offsets()
+                    .clone()
+                    .execute::<PrimitiveArray>(ctx)?;
+                let patch_indices = array
+                    .patch_indices()
+                    .clone()
+                    .execute::<PrimitiveArray>(ctx)?;
+                let patch_values = array
+                    .patch_values()
+                    .clone()
+                    .execute::<PrimitiveArray>(ctx)?;
+                let mut output = Buffer::<V>::from_byte_buffer(buffer.unwrap_host()).into_mut();
+                take_map(
+                    output.as_mut(),
+                    indices.as_slice::<I>(),
+                    array.offset(),
+                    array.len(),
+                    array.n_lanes(),
+                    lane_offsets.as_slice::<u32>(),
+                    patch_indices.as_slice::<u16>(),
+                    patch_values.as_slice::<V>(),
+                );
+
+                // SAFETY: output and validity still have same length after take_map returns.
+                unsafe {
+                    Ok(Some(
+                        PrimitiveArray::new_unchecked(output.freeze(), validity).into_array(),
+                    ))
+                }
+            })
+        })
+    }
+}
+
+/// Take patches for the given `indices` and apply them onto an `output` using a hash map.
+///
+/// First, builds a hashmap from index to patch value, then uses the hashmap in a loop to collect
+/// the values.
+#[allow(clippy::too_many_arguments)]
+fn take_map<I: IntegerPType, V: NativePType>(
+    output: &mut [V],
+    indices: &[I],
+    offset: usize,
+    len: usize,
+    n_lanes: usize,
+    lane_offsets: &[u32],
+    patch_index: &[u16],
+    patch_value: &[V],
+) {
+    let n_chunks = (offset + len).div_ceil(1024);
+    // Build a hashmap of patch_index -> values.
+    let mut index_map = FxHashMap::with_capacity_and_hasher(patch_index.len(), Default::default());
+    for chunk in 0..n_chunks {
+        for lane in 0..n_lanes {
+            let lane_start = lane_offsets[chunk * n_lanes + lane];
+            let lane_end = lane_offsets[chunk * n_lanes + lane + 1];
+            for i in lane_start..lane_end {
+                let patch_idx = patch_index[i as usize];
+                let patch_value = patch_value[i as usize];
+
+                let index = chunk * 1024 + patch_idx as usize;
+                if index >= offset && index < offset + len {
+                    index_map.insert(index - offset, patch_value);
+                }
+            }
+        }
+    }
+
+    // Now, iterate the take indices using the prebuilt hashmap.
+    // Undefined/null indices will miss the hash map, which we can ignore.
+    for (output_index, index) in indices.iter().enumerate() {
+        let index = index.as_();
+        if let Some(&patch_value) = index_map.get(&index) {
+            output[output_index] = patch_value;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::ArrayRef;
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::arrays::Patched;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::patches::Patches;
+
+    fn make_patched_array(
+        base: &[u16],
+        patch_indices: &[u32],
+        patch_values: &[u16],
+        slice: Range<usize>,
+    ) -> VortexResult<ArrayRef> {
+        let values = PrimitiveArray::from_iter(base.iter().copied()).into_array();
+        let patches = Patches::new(
+            base.len(),
+            0,
+            PrimitiveArray::from_iter(patch_indices.iter().copied()).into_array(),
+            PrimitiveArray::from_iter(patch_values.iter().copied()).into_array(),
+            None,
+        )?;
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        Patched::from_array_and_patches(values, &patches, &mut ctx)?
+            .into_array()
+            .slice(slice)
+    }
+
+    #[test]
+    fn test_take_basic() -> VortexResult<()> {
+        // Array with base values [0, 0, 0, 0, 0] patched at indices [1, 3] with values [10, 30]
+        let array = make_patched_array(&[0; 5], &[1, 3], &[10, 30], 0..5)?;
+
+        // Take indices [0, 1, 2, 3, 4] - should get [0, 10, 0, 30, 0]
+        let indices = buffer![0u32, 1, 2, 3, 4].into_array();
+        let result = array.take(indices)?.to_canonical()?.into_array();
+
+        let expected = PrimitiveArray::from_iter([0u16, 10, 0, 30, 0]).into_array();
+        assert_arrays_eq!(expected, result);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_sliced() -> VortexResult<()> {
+        let array = make_patched_array(&[0; 10], &[1, 3], &[100, 200], 2..10)?;
+
+        let indices = buffer![0u32, 1, 2, 3, 7].into_array();
+        let result = array.take(indices)?.to_canonical()?.into_array();
+
+        let expected = PrimitiveArray::from_iter([0u16, 200, 0, 0, 0]).into_array();
+        assert_arrays_eq!(expected, result);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_out_of_order() -> VortexResult<()> {
+        // Array with base values [0, 0, 0, 0, 0] patched at indices [1, 3] with values [10, 30]
+        let array = make_patched_array(&[0; 5], &[1, 3], &[10, 30], 0..5)?;
+
+        // Take indices in reverse order
+        let indices = buffer![4u32, 3, 2, 1, 0].into_array();
+        let result = array.take(indices)?.to_canonical()?.into_array();
+
+        let expected = PrimitiveArray::from_iter([0u16, 30, 0, 10, 0]).into_array();
+        assert_arrays_eq!(expected, result);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_duplicates() -> VortexResult<()> {
+        // Array with base values [0, 0, 0, 0, 0] patched at index [2] with value [99]
+        let array = make_patched_array(&[0; 5], &[2], &[99], 0..5)?;
+
+        // Take the same patched index multiple times
+        let indices = buffer![2u32, 2, 0, 2].into_array();
+        let result = array.take(indices)?.to_canonical()?.into_array();
+
+        // execute the array.
+        let _canonical = result.to_canonical()?.into_primitive();
+
+        let expected = PrimitiveArray::from_iter([99u16, 99, 0, 99]).into_array();
+        assert_arrays_eq!(expected, result);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_take_with_null_indices() -> VortexResult<()> {
+        use crate::arrays::BoolArray;
+        use crate::validity::Validity;
+
+        // Array: 10 elements, base value 0, patches at indices 2, 5, 8 with values 20, 50, 80
+        let array = make_patched_array(&[0; 10], &[2, 5, 8], &[20, 50, 80], 0..10)?;
+
+        // Take 10 indices, with nulls at positions 1, 4, 7
+        // Indices: [0, 2, 2, 5, 8, 0, 5, 8, 3, 1]
+        // Nulls:   [ ,  , N,  ,  , N,  ,  , N,  ]
+        // Position 2 (index=2, patched) is null
+        // Position 5 (index=0, unpatched) is null
+        // Position 8 (index=3, unpatched) is null
+        let indices = PrimitiveArray::new(
+            buffer![0u32, 2, 2, 5, 8, 0, 5, 8, 3, 1],
+            Validity::Array(
+                BoolArray::from_iter([
+                    true, true, false, true, true, false, true, true, false, true,
+                ])
+                .into_array(),
+            ),
+        );
+        let result = array
+            .take(indices.into_array())?
+            .to_canonical()?
+            .into_array();
+
+        // Expected: [0, 20, null, 50, 80, null, 50, 80, null, 0]
+        let expected = PrimitiveArray::new(
+            buffer![0u16, 20, 0, 50, 80, 0, 50, 80, 0, 0],
+            Validity::Array(
+                BoolArray::from_iter([
+                    true, true, false, true, true, false, true, true, false, true,
+                ])
+                .into_array(),
+            ),
+        );
+        assert_arrays_eq!(expected.into_array(), result);
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/patched/mod.rs b/vortex-array/src/arrays/patched/mod.rs
new file mode 100644
index 00000000000..56024f50d8e
--- /dev/null
+++ b/vortex-array/src/arrays/patched/mod.rs
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! An array that partially "patches" another array with new values.
+//!
+//! # Background
+//!
+//! This is meant to be the foundation of a fully data-parallel patching strategy, based on the
+//! work published in ["G-ALP" from Hepkema et al.](https://ir.cwi.nl/pub/35205/35205.pdf)
+//!
+//! Patching is common when an encoding almost completely covers an array save a few exceptions.
+//! In that case, rather than avoid the encoding entirely, it's preferable to
+//!
+//! * Replace unencodable values with fillers (zeros, frequent values, nulls, etc.)
+//! * Wrap the array with a `PatchedArray` signaling that when the original array is executed,
+//!   some of the decoded values must be overwritten.
+//!
+//! In Vortex, the FastLanes bit-packing encoding is often the terminal node in an encoding tree,
+//! and FastLanes has an intrinsic chunking of 1024 elements. Thus, 1024 elements is pervasively
+//! a useful unit of chunking throughout Vortex, and so we use 1024 as a chunk size here
+//! as well.
+//!
+//! # Details
+//!
+//! To patch an array, we first divide it into a set of chunks of length 1024, and then within
+//! each chunk, we assign each position to a lane. The number of lanes depends on the width of
+//! the underlying type.
+//!
+//! Thus, rather than sorting patch indices and values by their global offset, they are sorted
+//! primarily by their chunk, and then subsequently by their lanes.
+//!
+//! The Patched array layout has 4 children
+//!
+//! * `inner`: the inner array is the one containing encoded values, including the filler values
+//!   that need to be patched over at execution time
+//! * `lane_offsets`: this is an indexing buffer that allows you to see into ranges of the other
+//!   two children
+//! * `indices`: An array of `u16` chunk indices, indicating where within the chunk should the value
+//!   be overwritten by the patch value
+//! * `values`: The child array containing the patch values, which should be inserted over
+//!   the values of the `inner` at the locations provided by `indices`
+//!
+//! `indices` and `values` are aligned and accessed together.
+//!
+//! ```text
+//!
+//!                  chunk 0      chunk 0      chunk 0     chunk 0       chunk 0     chunk 0
+//!                  lane  0      lane 1       lane  2     lane 3        lane  4     lane  5
+//!              ┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┐
+//! lane_offsets │     0      │     0      │     2      │     2      │     3      │     5      │  ...
+//!              └─────┬──────┴─────┬──────┴─────┬──────┴──────┬─────┴──────┬─────┴──────┬─────┘
+//!                    │            │            │             │            │            │
+//!                    │            │            │             │            │            │
+//!              ┌─────┴────────────┘            └──────┬──────┘     ┌──────┘            └─────┐
+//!              │                                      │            │                         │
+//!              │                                      │            │                         │
+//!              │                                      │            │                         │
+//!              ▼────────────┬────────────┬────────────▼────────────▼────────────┬────────────▼
+//!    indices   │            │            │            │            │            │            │
+//!              │            │            │            │            │            │            │
+//!              ├────────────┼────────────┼────────────┼────────────┼────────────┼────────────┤
+//!    values    │            │            │            │            │            │            │
+//!              │            │            │            │            │            │            │
+//!              └────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘
+//! ```
+//!
+//! It turns out that this layout is optimal for executing patching on GPUs, because the
+//! `lane_offsets` allows each thread in a warp to seek to its patches in constant time.
+
+mod array;
+mod compute;
+mod vtable;
+
+pub use array::*;
+use vortex_buffer::ByteBuffer;
+pub use vtable::*;
+
+/// Patches that have been transposed into GPU format.
+struct TransposedPatches {
+    n_lanes: usize,
+    lane_offsets: ByteBuffer,
+    indices: ByteBuffer,
+    values: ByteBuffer,
+}
+
+/// Number of lanes used at patch time for a value of type `V`.
+///
+/// This is *NOT* equal to the number of FastLanes lanes for the type `V`, rather this is going to
+/// correspond to how many "lanes" we will end up copying data on.
+///
+/// When applied on the CPU, this configuration doesn't really matter. On the GPU, it is based
+/// on the number of patches involved here.
+const fn patch_lanes<V: Sized>() -> usize {
+    // For types 32-bits or smaller, we use a 32 lane configuration, and for 64-bit we use 16 lanes.
+    // This matches up with the number of lanes we use to execute copying results from bit-unpacking
+    // from shared to global memory.
+    if size_of::<V>() < 8 { 32 } else { 16 }
+}
diff --git a/vortex-array/src/arrays/patched/vtable/kernels.rs b/vortex-array/src/arrays/patched/vtable/kernels.rs
new file mode 100644
index 00000000000..7994b19e02e
--- /dev/null
+++ b/vortex-array/src/arrays/patched/vtable/kernels.rs
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use crate::arrays::Patched;
+use crate::arrays::dict::TakeExecuteAdaptor;
+use crate::kernel::ParentKernelSet;
+use crate::scalar_fn::fns::binary::CompareExecuteAdaptor;
+
+pub(super) const PARENT_KERNELS: ParentKernelSet<Patched> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(Patched)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(Patched)),
+]);
diff --git a/vortex-array/src/arrays/patched/vtable/mod.rs b/vortex-array/src/arrays/patched/vtable/mod.rs
new file mode 100644
index 00000000000..4d430277bc8
--- /dev/null
+++ b/vortex-array/src/arrays/patched/vtable/mod.rs
@@ -0,0 +1,672 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use prost::Message;
+
+use crate::ArrayEq;
+use crate::ArrayHash;
+mod kernels;
+mod operations;
+mod slice;
+
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::Canonical;
+use crate::ExecutionCtx;
+use crate::ExecutionResult;
+use crate::IntoArray;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::array::ValidityChild;
+use crate::array::ValidityVTableFromChild;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::patched::PatchedArrayExt;
+use crate::arrays::patched::PatchedArraySlotsExt;
+use crate::arrays::patched::PatchedData;
+use crate::arrays::patched::PatchedSlots;
+use crate::arrays::patched::PatchedSlotsView;
+use crate::arrays::patched::compute::rules::PARENT_RULES;
+use crate::arrays::patched::vtable::kernels::PARENT_KERNELS;
+use crate::arrays::primitive::PrimitiveDataParts;
+use crate::buffer::BufferHandle;
+use crate::builders::ArrayBuilder;
+use crate::builders::PrimitiveBuilder;
+use crate::dtype::DType;
+use crate::dtype::NativePType;
+use crate::dtype::PType;
+use crate::match_each_native_ptype;
+use crate::require_child;
+use crate::serde::ArrayChildren;
+
+/// A [`Patched`]-encoded Vortex array.
+pub type PatchedArray = Array<Patched>;
+
+#[derive(Clone, Debug)]
+pub struct Patched;
+
+impl ValidityChild<Patched> for Patched {
+    fn validity_child(array: ArrayView<'_, Patched>) -> ArrayRef {
+        array.inner().clone()
+    }
+}
+
+#[derive(Clone, prost::Message)]
+pub struct PatchedMetadata {
+    /// The total number of patches, and the length of the indices and values child arrays.
+    #[prost(uint32, tag = "1")]
+    pub(crate) n_patches: u32,
+
+    /// The number of lanes used for patch indexing. Must be a power of two between 1 and 128.
+    #[prost(uint32, tag = "2")]
+    pub(crate) n_lanes: u32,
+
+    /// An offset into the first chunk's patches that should be considered in-view.
+    ///
+    /// Always between 0 and 1023.
+    #[prost(uint32, tag = "3")]
+    pub(crate) offset: u32,
+}
+
+impl ArrayHash for PatchedData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.offset.hash(state);
+        self.n_lanes.hash(state);
+    }
+}
+
+impl ArrayEq for PatchedData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.offset == other.offset && self.n_lanes == other.n_lanes
+    }
+}
+
+impl VTable for Patched {
+    type ArrayData = PatchedData;
+    type OperationsVTable = Self;
+    type ValidityVTable = ValidityVTableFromChild;
+
+    fn id(&self) -> ArrayId {
+        ArrayId::new_ref("vortex.patched")
+    }
+
+    fn validate(
+        &self,
+        data: &PatchedData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        data.validate(dtype, len, &PatchedSlotsView::from_slots(slots))
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("invalid buffer index for PatchedArray: {idx}");
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("invalid buffer index for PatchedArray: {idx}");
+    }
+
+    fn child(array: ArrayView<'_, Self>, idx: usize) -> ArrayRef {
+        match idx {
+            PatchedSlots::INNER => array.inner().clone(),
+            PatchedSlots::LANE_OFFSETS => array.lane_offsets().clone(),
+            PatchedSlots::PATCH_INDICES => array.patch_indices().clone(),
+            PatchedSlots::PATCH_VALUES => array.patch_values().clone(),
+            _ => vortex_panic!("invalid child index for PatchedArray: {idx}"),
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            PatchedMetadata {
+                n_patches: u32::try_from(array.patch_indices().len())?,
+                n_lanes: u32::try_from(array.n_lanes())?,
+                offset: u32::try_from(array.offset())?,
+            }
+            .encode_to_vec(),
+        ))
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        _buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = PatchedMetadata::decode(metadata)?;
+        let n_patches = metadata.n_patches as usize;
+        let n_lanes = metadata.n_lanes as usize;
+        let offset = metadata.offset as usize;
+
+        // n_chunks should correspond to the chunk in the `inner`.
+        // After slicing when offset > 0, there may be additional chunks.
+        let n_chunks = (len + offset).div_ceil(1024);
+
+        let inner = children.get(0, dtype, len)?;
+        let lane_offsets = children.get(1, PType::U32.into(), n_chunks * n_lanes + 1)?;
+        let indices = children.get(2, PType::U16.into(), n_patches)?;
+        let values = children.get(3, dtype, n_patches)?;
+
+        let data = PatchedData { n_lanes, offset };
+        let slots = PatchedSlots {
+            inner,
+            lane_offsets,
+            patch_indices: indices,
+            patch_values: values,
+        }
+        .into_slots();
+        Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
+    }
+
+    fn append_to_builder(
+        array: ArrayView<'_, Self>,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        let dtype = array.array().dtype();
+
+        if !dtype.is_primitive() {
+            // Default pathway: canonicalize and propagate.
+            let canonical = array
+                .array()
+                .clone()
+                .execute::<Canonical>(ctx)?
+                .into_array();
+            builder.extend_from_array(&canonical);
+            return Ok(());
+        }
+
+        let ptype = dtype.as_ptype();
+
+        let len = array.len();
+
+        array.inner().append_to_builder(builder, ctx)?;
+
+        let offset = array.offset();
+        let lane_offsets = array
+            .lane_offsets()
+            .clone()
+            .execute::<PrimitiveArray>(ctx)?;
+        let indices = array
+            .patch_indices()
+            .clone()
+            .execute::<PrimitiveArray>(ctx)?;
+        let values = array
+            .patch_values()
+            .clone()
+            .execute::<PrimitiveArray>(ctx)?;
+
+        match_each_native_ptype!(ptype, |V| {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<PrimitiveBuilder<V>>()
+                .vortex_expect("correctly typed builder");
+
+            // Overwrite the last `len` elements of the builder. These would have been
+            // populated by the inner.append_to_builder() call above.
+            let output = typed_builder.values_mut();
+            let trailer = output.len() - len;
+
+            apply_patches_primitive::<V>(
+                &mut output[trailer..],
+                offset,
+                len,
+                array.n_lanes(),
+                lane_offsets.as_slice::<u32>(),
+                indices.as_slice::<u16>(),
+                values.as_slice::<V>(),
+            );
+        });
+
+        Ok(())
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        PatchedSlots::NAMES[idx].to_string()
+    }
+
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = require_child!(array, array.inner(), PatchedSlots::INNER => Primitive);
+        let array =
+            require_child!(array, array.lane_offsets(), PatchedSlots::LANE_OFFSETS => Primitive);
+        let array =
+            require_child!(array, array.patch_indices(), PatchedSlots::PATCH_INDICES => Primitive);
+        let array =
+            require_child!(array, array.patch_values(), PatchedSlots::PATCH_VALUES => Primitive);
+
+        let len = array.len();
+
+        let n_lanes = array.n_lanes;
+        let offset = array.offset;
+        let slots = match array.try_into_parts() {
+            Ok(parts) => PatchedSlots::from_slots(parts.slots),
+            Err(array) => PatchedSlotsView::from_slots(array.slots()).to_owned(),
+        };
+
+        // TODO(joe): use iterative execution
+        let PrimitiveDataParts {
+            buffer,
+            ptype,
+            validity,
+        } = slots.inner.downcast::<Primitive>().into_data_parts();
+
+        let values = slots.patch_values.downcast::<Primitive>();
+        let lane_offsets = slots.lane_offsets.downcast::<Primitive>();
+        let patch_indices = slots.patch_indices.downcast::<Primitive>();
+
+        let patched_values = match_each_native_ptype!(values.ptype(), |V| {
+            let mut output = Buffer::<V>::from_byte_buffer(buffer.unwrap_host()).into_mut();
+
+            apply_patches_primitive::<V>(
+                &mut output,
+                offset,
+                len,
+                n_lanes,
+                lane_offsets.as_slice::<u32>(),
+                patch_indices.as_slice::<u16>(),
+                values.as_slice::<V>(),
+            );
+
+            let output = output.freeze();
+
+            PrimitiveArray::from_byte_buffer(output.into_byte_buffer(), ptype, validity)
+        });
+
+        Ok(ExecutionResult::done(patched_values.into_array()))
+    }
+
+    fn execute_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
+    }
+
+    fn reduce_parent(
+        array: ArrayView<'_, Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        PARENT_RULES.evaluate(array, parent, child_idx)
+    }
+}
+
+/// Apply patches on top of the existing value types.
+#[allow(clippy::too_many_arguments)]
+fn apply_patches_primitive<V: NativePType>(
+    output: &mut [V],
+    offset: usize,
+    len: usize,
+    n_lanes: usize,
+    lane_offsets: &[u32],
+    indices: &[u16],
+    values: &[V],
+) {
+    let n_chunks = (offset + len).div_ceil(1024);
+    for chunk in 0..n_chunks {
+        let start = lane_offsets[chunk * n_lanes] as usize;
+        let stop = lane_offsets[chunk * n_lanes + n_lanes] as usize;
+
+        for idx in start..stop {
+            // the indices slice is measured as an offset into the 1024-value chunk.
+            let index = chunk * 1024 + indices[idx] as usize;
+            if index < offset || index >= offset + len {
+                continue;
+            }
+
+            let value = values[idx];
+            output[index - offset] = value;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_buffer::buffer;
+    use vortex_buffer::buffer_mut;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+    use vortex_session::registry::ReadContext;
+
+    use crate::ArrayContext;
+    use crate::Canonical;
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::Patched;
+    use crate::arrays::PatchedArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::patched::PatchedArraySlotsExt;
+    use crate::arrays::patched::PatchedSlots;
+    use crate::arrays::patched::PatchedSlotsView;
+    use crate::assert_arrays_eq;
+    use crate::builders::builder_with_capacity;
+    use crate::patches::Patches;
+    use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
+    use crate::validity::Validity;
+
+    #[test]
+    fn test_execute() {
+        let values = buffer![0u16; 1024].into_array();
+        let patches = Patches::new(
+            1024,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![1u16; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        let executed = array
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_primitive()
+            .into_buffer::<u16>();
+
+        let mut expected = buffer_mut![0u16; 1024];
+        expected[1] = 1;
+        expected[2] = 1;
+        expected[3] = 1;
+
+        assert_eq!(executed, expected.freeze());
+    }
+
+    #[test]
+    fn test_execute_sliced() {
+        let values = buffer![0u16; 1024].into_array();
+        let patches = Patches::new(
+            1024,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![1u16; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array()
+            .slice(3..1024)
+            .unwrap();
+
+        let executed = array
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_primitive()
+            .into_buffer::<u16>();
+
+        let mut expected = buffer_mut![0u16; 1021];
+        expected[0] = 1;
+
+        assert_eq!(executed, expected.freeze());
+    }
+
+    #[test]
+    fn test_append_to_builder_non_nullable() {
+        let values = PrimitiveArray::new(buffer![0u16; 1024], Validity::NonNullable).into_array();
+        let patches = Patches::new(
+            1024,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![10u16, 20, 30].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        let mut builder = builder_with_capacity(array.dtype(), array.len());
+        array.append_to_builder(builder.as_mut(), &mut ctx).unwrap();
+
+        let result = builder.finish();
+
+        let mut expected = buffer_mut![0u16; 1024];
+        expected[1] = 10;
+        expected[2] = 20;
+        expected[3] = 30;
+        let expected = expected.into_array();
+
+        assert_arrays_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_append_to_builder_sliced() {
+        let values = PrimitiveArray::new(buffer![0u16; 1024], Validity::NonNullable).into_array();
+        let patches = Patches::new(
+            1024,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![10u16, 20, 30].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array()
+            .slice(3..1024)
+            .unwrap();
+
+        let mut builder = builder_with_capacity(array.dtype(), array.len());
+        array.append_to_builder(builder.as_mut(), &mut ctx).unwrap();
+
+        let result = builder.finish();
+
+        let mut expected = buffer_mut![0u16; 1021];
+        expected[0] = 30;
+        let expected = expected.into_array();
+
+        assert_arrays_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_append_to_builder_with_validity() {
+        // Create inner array with nulls at indices 0 and 5.
+        let validity = Validity::from_iter((0..10).map(|i| i != 0 && i != 5));
+        let values = PrimitiveArray::new(buffer![0u16; 10], validity).into_array();
+
+        // Apply patches at indices 1, 2, 3.
+        let patches = Patches::new(
+            10,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![10u16, 20, 30].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        let mut builder = builder_with_capacity(array.dtype(), array.len());
+        array.append_to_builder(builder.as_mut(), &mut ctx).unwrap();
+
+        let result = builder.finish();
+
+        // Expected: null at 0, patched 10/20/30 at 1/2/3, zero at 4, null at 5, zeros at 6-9.
+        let expected = PrimitiveArray::from_option_iter([
+            None,
+            Some(10u16),
+            Some(20),
+            Some(30),
+            Some(0),
+            None,
+            Some(0),
+            Some(0),
+            Some(0),
+            Some(0),
+        ])
+        .into_array();
+
+        assert_arrays_eq!(expected, result);
+    }
+
+    fn make_patched_array(
+        inner: impl IntoIterator<Item = u16>,
+        patch_indices: &[u32],
+        patch_values: &[u16],
+    ) -> VortexResult<PatchedArray> {
+        let values: Vec<u16> = inner.into_iter().collect();
+        let len = values.len();
+        let array = PrimitiveArray::from_iter(values).into_array();
+
+        let indices = PrimitiveArray::from_iter(patch_indices.iter().copied()).into_array();
+        let patch_vals = PrimitiveArray::from_iter(patch_values.iter().copied()).into_array();
+
+        let patches = Patches::new(len, 0, indices, patch_vals, None)?;
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        Patched::from_array_and_patches(array, &patches, &mut ctx)
+    }
+
+    #[rstest]
+    #[case::basic(
+        make_patched_array(vec![0u16; 1024], &[1, 2, 3], &[10, 20, 30]).unwrap().into_array()
+    )]
+    #[case::multi_chunk(
+        make_patched_array(vec![0u16; 4096], &[100, 1500, 2500, 3500], &[11, 22, 33, 44]).unwrap().into_array()
+    )]
+    #[case::sliced({
+        let arr = make_patched_array(vec![0u16; 1024], &[1, 2, 3], &[10, 20, 30]).unwrap();
+        arr.into_array().slice(2..1024).unwrap()
+    })]
+    fn test_serde_roundtrip(#[case] array: crate::ArrayRef) {
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+
+        // Concat into a single buffer.
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+        let concat = concat.freeze();
+
+        let parts = SerializedArray::try_from(concat).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
+
+        assert!(decoded.is::<Patched>());
+        assert_eq!(
+            array.display_values().to_string(),
+            decoded.display_values().to_string()
+        );
+    }
+
+    #[test]
+    fn test_with_slots_basic() -> VortexResult<()> {
+        let array = make_patched_array(vec![0u16; 1024], &[1, 2, 3], &[10, 20, 30])?;
+
+        // Get original children via accessor methods
+        let slots = PatchedSlots::from_slots(array.as_array().slots().to_vec());
+        let view = PatchedSlotsView::from_slots(array.as_array().slots());
+        assert_eq!(view.inner.len(), array.inner().len());
+
+        // Create new PatchedArray with same children using with_slots
+        let array_ref = array.into_array();
+        let new_array = array_ref.clone().with_slots(slots.into_slots())?;
+
+        assert!(new_array.is::<Patched>());
+        assert_eq!(array_ref.len(), new_array.len());
+        assert_eq!(array_ref.dtype(), new_array.dtype());
+
+        // Execute both and compare results
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+        let original_executed = array_ref.execute::<Canonical>(&mut ctx)?.into_primitive();
+        let new_executed = new_array.execute::<Canonical>(&mut ctx)?.into_primitive();
+
+        assert_arrays_eq!(original_executed, new_executed);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_with_slots_modified_inner() -> VortexResult<()> {
+        let array = make_patched_array(vec![0u16; 10], &[1, 2, 3], &[10, 20, 30])?;
+
+        // Create a different inner array (all 5s instead of 0s)
+        let new_inner = PrimitiveArray::from_iter(vec![5u16; 10]).into_array();
+        let slots = PatchedSlots {
+            inner: new_inner,
+            lane_offsets: array.lane_offsets().clone(),
+            patch_indices: array.patch_indices().clone(),
+            patch_values: array.patch_values().clone(),
+        };
+
+        let array_ref = array.into_array();
+        let new_array = array_ref.with_slots(slots.into_slots())?;
+
+        // Execute and verify the inner values changed (except at patch positions)
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+        let executed = new_array.execute::<Canonical>(&mut ctx)?.into_primitive();
+
+        // Expected: all 5s except indices 1, 2, 3 which are patched to 10, 20, 30
+        let expected = PrimitiveArray::from_iter([5u16, 10, 20, 30, 5, 5, 5, 5, 5, 5]);
+        assert_arrays_eq!(expected, executed);
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/patched/vtable/operations.rs b/vortex-array/src/arrays/patched/vtable/operations.rs
new file mode 100644
index 00000000000..95beeaaf87f
--- /dev/null
+++ b/vortex-array/src/arrays/patched/vtable/operations.rs
@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::patched::Patched;
+use crate::arrays::patched::PatchedArrayExt;
+use crate::arrays::patched::PatchedArraySlotsExt;
+use crate::optimizer::ArrayOptimizer;
+use crate::scalar::Scalar;
+
+impl OperationsVTable<Patched> for Patched {
+    fn scalar_at(
+        array: ArrayView<'_, Patched>,
+        index: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        let chunk = (index + array.offset()) / 1024;
+
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "N % 1024 always fits in u16"
+        )]
+        let chunk_index = ((index + array.offset()) % 1024) as u16;
+
+        let lane = (index + array.offset()) % array.n_lanes();
+
+        let range = array.lane_range(chunk, lane)?;
+
+        // Get the range of indices corresponding to the lane, potentially decoding them to avoid
+        // the overhead of repeated scalar_at calls.
+        let patch_indices = array
+            .patch_indices()
+            .slice(range.clone())?
+            .optimize()?
+            .execute::<PrimitiveArray>(ctx)?;
+
+        // NOTE: we do linear scan as lane has <= 32 patches, binary search would likely
+        //  be slower.
+        for (&patch_index, idx) in std::iter::zip(patch_indices.as_slice::<u16>(), range) {
+            if patch_index == chunk_index {
+                return array.patch_values().scalar_at(idx)?.cast(array.dtype());
+            }
+        }
+
+        // Otherwise, access the underlying value.
+        array.inner().scalar_at(index)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_session::VortexSession;
+
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::arrays::Patched;
+    use crate::dtype::Nullability;
+    use crate::optimizer::ArrayOptimizer;
+    use crate::patches::Patches;
+    use crate::scalar::Scalar;
+
+    #[test]
+    fn test_simple() {
+        let values = buffer![0u16; 1024].into_array();
+        let patches = Patches::new(
+            1024,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![1u16; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        assert_eq!(
+            array.scalar_at(0).unwrap(),
+            Scalar::primitive(0u16, Nullability::NonNullable)
+        );
+        assert_eq!(
+            array.scalar_at(1).unwrap(),
+            Scalar::primitive(1u16, Nullability::NonNullable)
+        );
+        assert_eq!(
+            array.scalar_at(2).unwrap(),
+            Scalar::primitive(1u16, Nullability::NonNullable)
+        );
+        assert_eq!(
+            array.scalar_at(3).unwrap(),
+            Scalar::primitive(1u16, Nullability::NonNullable)
+        );
+    }
+
+    #[test]
+    fn test_multi_chunk() {
+        let values = buffer![0u16; 4096].into_array();
+        let patches = Patches::new(
+            4096,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![1u16; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        for index in 0..array.len() {
+            let value = array.scalar_at(index).unwrap();
+
+            if [1, 2, 3].contains(&index) {
+                assert_eq!(value, 1u16.into());
+            } else {
+                assert_eq!(value, 0u16.into());
+            }
+        }
+    }
+
+    #[test]
+    fn test_multi_chunk_sliced() {
+        let values = buffer![0u16; 4096].into_array();
+        let patches = Patches::new(
+            4096,
+            0,
+            buffer![1u32, 2, 3].into_array(),
+            buffer![1u16; 3].into_array(),
+            None,
+        )
+        .unwrap();
+
+        let session = VortexSession::empty();
+        let mut ctx = ExecutionCtx::new(session);
+
+        let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array()
+            .slice(3..4096)
+            .unwrap()
+            .optimize()
+            .unwrap();
+
+        assert!(array.is::<Patched>());
+
+        assert_eq!(array.scalar_at(0).unwrap(), 1u16.into());
+        for index in 1..array.len() {
+            assert_eq!(array.scalar_at(index).unwrap(), 0u16.into());
+        }
+    }
+}
diff --git a/vortex-array/src/arrays/patched/vtable/slice.rs b/vortex-array/src/arrays/patched/vtable/slice.rs
new file mode 100644
index 00000000000..8655e0c7d84
--- /dev/null
+++ b/vortex-array/src/arrays/patched/vtable/slice.rs
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::Range;
+
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Patched;
+use crate::arrays::patched::PatchedArrayExt;
+use crate::arrays::patched::PatchedArraySlotsExt;
+use crate::arrays::patched::PatchedSlots;
+use crate::arrays::slice::SliceReduce;
+
+impl SliceReduce for Patched {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        // We **always** slice the patches at 1024-element chunk boundaries. We keep the offset + len
+        // around so that when we execute we know how much to chop off.
+        let new_offset = (range.start + array.offset()) % 1024;
+        let chunk_start = (range.start + array.offset()) / 1024;
+        let chunk_stop = (range.end + array.offset()).div_ceil(1024);
+        let sliced_lane_offsets = array
+            .lane_offsets()
+            .slice((chunk_start * array.n_lanes())..(chunk_stop * array.n_lanes()) + 1)?;
+
+        // Unlike the patches, we slice the inner to the exact range. This is handled
+        // at execution time by making sure to skip patch indices that are < offset
+        // or >= len.
+        let inner = array.inner().slice(range.start..range.end)?;
+        let len = inner.len();
+
+        let slots = PatchedSlots {
+            inner,
+            lane_offsets: sliced_lane_offsets,
+            patch_indices: array.patch_indices().clone(),
+            patch_values: array.patch_values().clone(),
+        }
+        .into_slots();
+
+        Ok(Some(
+            unsafe {
+                Patched::new_unchecked(
+                    array.dtype().clone(),
+                    len,
+                    slots,
+                    array.n_lanes(),
+                    new_offset,
+                )
+            }
+            .into_array(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use rstest::rstest;
+    use vortex_buffer::Buffer;
+    use vortex_buffer::BufferMut;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::Canonical;
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::Patched;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::dtype::NativePType;
+    use crate::patches::Patches;
+
+    #[test]
+    fn test_reduce() -> VortexResult<()> {
+        let values = buffer![0u16; 512].into_array();
+        let patch_indices = buffer![1u32, 8, 30].into_array();
+        let patch_values = buffer![u16::MAX; 3].into_array();
+        let patches = Patches::new(512, 0, patch_indices, patch_values, None)?;
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let patched_array = Patched::from_array_and_patches(values, &patches, &mut ctx)?;
+
+        let sliced = patched_array.into_array().slice(1..10)?;
+
+        insta::assert_snapshot!(
+            sliced.display_tree_encodings_only(),
+            @r#"
+            root: vortex.patched(u16, len=9)
+              inner: vortex.primitive(u16, len=9)
+              lane_offsets: vortex.primitive(u32, len=33)
+              patch_indices: vortex.primitive(u16, len=3)
+              patch_values: vortex.primitive(u16, len=3)
+            "#);
+
+        let executed = sliced.execute::<Canonical>(&mut ctx)?.into_primitive();
+
+        assert_eq!(
+            &[u16::MAX, 0, 0, 0, 0, 0, 0, u16::MAX, 0],
+            executed.as_slice::<u16>()
+        );
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::trivial(buffer![1u64; 2], buffer![1u32], buffer![u64::MAX], 1..2)]
+    #[case::one_chunk(buffer![0u64; 1024], buffer![1u32, 8, 30], buffer![u64::MAX; 3], 1..10)]
+    #[case::multichunk(buffer![1u64; 10_000], buffer![0u32, 1, 2, 3, 4, 16, 17, 18, 19, 1024, 2048, 2049], buffer![u64::MAX; 12], 1024..5000)]
+    fn test_cases<T: NativePType>(
+        #[case] inner: Buffer<T>,
+        #[case] patch_indices: Buffer<u32>,
+        #[case] patch_values: Buffer<T>,
+        #[case] range: Range<usize>,
+    ) {
+        // Create patched array.
+        let patches = Patches::new(
+            inner.len(),
+            0,
+            patch_indices.into_array(),
+            patch_values.into_array(),
+            None,
+        )
+        .unwrap();
+
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let patched_array = Patched::from_array_and_patches(inner.into_array(), &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        // Verify that applying slice first yields same result as applying slice at end.
+        let slice_first = patched_array
+            .slice(range.clone())
+            .unwrap()
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_array();
+
+        let slice_last = patched_array
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_primitive()
+            .slice(range)
+            .unwrap();
+
+        assert_arrays_eq!(slice_first, slice_last);
+    }
+
+    #[test]
+    fn test_stacked_slices() {
+        let values = PrimitiveArray::from_iter(0u64..10_000).into_array();
+
+        let patched_indices = buffer![1u32, 2, 1024, 2048, 3072, 3088].into_array();
+        let patched_values = buffer![0u64, 1, 2, 3, 4, 5].into_array();
+
+        let patches = Patches::new(10_000, 0, patched_indices, patched_values, None).unwrap();
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+
+        let patched_array = Patched::from_array_and_patches(values, &patches, &mut ctx)
+            .unwrap()
+            .into_array();
+
+        let sliced = patched_array
+            .slice(1024..5000)
+            .unwrap()
+            .slice(1..2065)
+            .unwrap()
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_array();
+
+        let mut expected = BufferMut::from_iter(1025u64..=3088);
+        expected[1023] = 3;
+        expected[2047] = 4;
+        expected[2063] = 5;
+
+        let expected = expected.into_array();
+
+        assert_arrays_eq!(expected, sliced);
+    }
+}
diff --git a/vortex-array/src/arrays/primitive/array/accessor.rs b/vortex-array/src/arrays/primitive/array/accessor.rs
index ae9a7126c53..5a3665c71ed 100644
--- a/vortex-array/src/arrays/primitive/array/accessor.rs
+++ b/vortex-array/src/arrays/primitive/array/accessor.rs
@@ -3,19 +3,23 @@
 
 use std::iter;
 
+use vortex_error::VortexExpect;
+
 use crate::ToCanonical;
 use crate::accessor::ArrayAccessor;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::arrays::PrimitiveArray;
 use crate::dtype::NativePType;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 impl<T: NativePType> ArrayAccessor<T> for PrimitiveArray {
     fn with_iterator<F, R>(&self, f: F) -> R
     where
         F: for<'a> FnOnce(&mut dyn Iterator<Item = Option<&'a T>>) -> R,
     {
-        match self.validity() {
+        match self
+            .validity()
+            .vortex_expect("primitive validity should be derivable")
+        {
             Validity::NonNullable | Validity::AllValid => {
                 let mut iter = self.as_slice::<T>().iter().map(Some);
                 f(&mut iter)
diff --git a/vortex-array/src/arrays/primitive/array/cast.rs b/vortex-array/src/arrays/primitive/array/cast.rs
index eb1df99671b..0023ea71fb7 100644
--- a/vortex-array/src/arrays/primitive/array/cast.rs
+++ b/vortex-array/src/arrays/primitive/array/cast.rs
@@ -1,21 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::ToCanonical;
-use crate::arrays::PrimitiveArray;
-use crate::builtins::ArrayBuiltins;
-use crate::compute::min_max;
-use crate::dtype::DType;
+use super::PrimitiveData;
 use crate::dtype::NativePType;
-use crate::dtype::PType;
-use crate::vtable::ValidityHelper;
 
-impl PrimitiveArray {
+impl PrimitiveData {
     /// Return a slice of the array's buffer.
     ///
     /// NOTE: these values may be nonsense if the validity buffer indicates that the value is null.
@@ -41,103 +33,6 @@ impl PrimitiveArray {
         // SAFETY: alignment of Buffer is checked on construction
         unsafe { std::slice::from_raw_parts(raw_slice.cast(), byte_buffer.len() / size_of::<T>()) }
     }
-
-    pub fn reinterpret_cast(&self, ptype: PType) -> Self {
-        if self.ptype() == ptype {
-            return self.clone();
-        }
-
-        assert_eq!(
-            self.ptype().byte_width(),
-            ptype.byte_width(),
-            "can't reinterpret cast between integers of two different widths"
-        );
-
-        PrimitiveArray::from_buffer_handle(
-            self.buffer_handle().clone(),
-            ptype,
-            self.validity().clone(),
-        )
-    }
-
-    /// Narrow the array to the smallest possible integer type that can represent all values.
-    pub fn narrow(&self) -> VortexResult<PrimitiveArray> {
-        if !self.ptype().is_int() {
-            return Ok(self.clone());
-        }
-
-        let Some(min_max) = min_max(self.as_ref())? else {
-            return Ok(PrimitiveArray::new(
-                Buffer::<u8>::zeroed(self.len()),
-                self.validity.clone(),
-            ));
-        };
-
-        // If we can't cast to i64, then leave the array as its original type.
-        // It's too big to downcast anyway.
-        let Ok(min) = min_max
-            .min
-            .cast(&PType::I64.into())
-            .and_then(|s| i64::try_from(&s))
-        else {
-            return Ok(self.clone());
-        };
-        let Ok(max) = min_max
-            .max
-            .cast(&PType::I64.into())
-            .and_then(|s| i64::try_from(&s))
-        else {
-            return Ok(self.clone());
-        };
-
-        if min < 0 || max < 0 {
-            // Signed
-            if min >= i8::MIN as i64 && max <= i8::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::I8, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-
-            if min >= i16::MIN as i64 && max <= i16::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::I16, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-
-            if min >= i32::MIN as i64 && max <= i32::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::I32, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-        } else {
-            // Unsigned
-            if max <= u8::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::U8, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-
-            if max <= u16::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::U16, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-
-            if max <= u32::MAX as i64 {
-                return Ok(self
-                    .to_array()
-                    .cast(DType::Primitive(PType::U32, self.dtype().nullability()))?
-                    .to_primitive());
-            }
-        }
-
-        Ok(self.clone())
-    }
 }
 
 #[cfg(test)]
@@ -147,6 +42,7 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::primitive::PrimitiveArrayExt;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -164,7 +60,7 @@ mod tests {
             result.dtype(),
             &DType::Primitive(PType::U8, Nullability::Nullable)
         );
-        assert_eq!(result.validity, Validity::AllInvalid);
+        assert!(matches!(result.validity(), Ok(Validity::AllInvalid)));
     }
 
     #[rstest]
@@ -210,7 +106,7 @@ mod tests {
             &DType::Primitive(PType::U8, Nullability::Nullable)
         );
         // Check that validity is preserved (the array should still have nullable values)
-        assert!(matches!(&result.validity, Validity::Array(_)));
+        assert!(matches!(result.validity(), Ok(Validity::Array(_))));
     }
 
     #[test]
@@ -247,7 +143,7 @@ mod tests {
         let array2 = PrimitiveArray::new(Buffer::<i64>::empty(), Validity::NonNullable);
         let result2 = array2.narrow().unwrap();
         // Empty arrays should not have their validity changed
-        assert_eq!(result.validity, Validity::AllInvalid);
-        assert_eq!(result2.validity, Validity::NonNullable);
+        assert!(matches!(result.validity(), Ok(Validity::AllInvalid)));
+        assert!(matches!(result2.validity(), Ok(Validity::NonNullable)));
     }
 }
diff --git a/vortex-array/src/arrays/primitive/array/conversion.rs b/vortex-array/src/arrays/primitive/array/conversion.rs
index b01988674c4..444b79dfe41 100644
--- a/vortex-array/src/arrays/primitive/array/conversion.rs
+++ b/vortex-array/src/arrays/primitive/array/conversion.rs
@@ -54,35 +54,18 @@ impl PrimitiveArray {
 
     /// Consume the array and get a host Buffer containing the data values.
     pub fn into_buffer<T: NativePType>(self) -> Buffer<T> {
-        if T::PTYPE != self.ptype() {
-            vortex_panic!(
-                "Attempted to get buffer of type {} from array of type {}",
-                T::PTYPE,
-                self.ptype()
-            )
-        }
-
-        Buffer::from_byte_buffer(self.buffer.into_host_sync())
+        self.into_data().into_buffer()
     }
 
     /// Extract a mutable buffer from the PrimitiveArray. Attempts to do this with zero-copy
     /// if the buffer is uniquely owned, otherwise will make a copy.
     pub fn into_buffer_mut<T: NativePType>(self) -> BufferMut<T> {
-        self.try_into_buffer_mut()
-            .unwrap_or_else(|buffer| BufferMut::<T>::copy_from(&buffer))
+        self.into_data().into_buffer_mut()
     }
 
     /// Try to extract a mutable buffer from the PrimitiveArray with zero copy.
     pub fn try_into_buffer_mut<T: NativePType>(self) -> Result<BufferMut<T>, Buffer<T>> {
-        if T::PTYPE != self.ptype() {
-            vortex_panic!(
-                "Attempted to get buffer_mut of type {} from array of type {}",
-                T::PTYPE,
-                self.ptype()
-            )
-        }
-        let buffer = Buffer::<T>::from_byte_buffer(self.buffer.into_host_sync());
-        buffer.try_into_mut()
+        self.into_data().try_into_buffer_mut()
     }
 }
 
diff --git a/vortex-array/src/arrays/primitive/array/mod.rs b/vortex-array/src/arrays/primitive/array/mod.rs
index c4389d30aa8..e64cc891d4e 100644
--- a/vortex-array/src/arrays/primitive/array/mod.rs
+++ b/vortex-array/src/arrays/primitive/array/mod.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::iter;
 
 use vortex_buffer::Alignment;
@@ -11,16 +13,22 @@ use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
 
+use crate::LEGACY_SESSION;
 use crate::ToCanonical;
+use crate::VortexSessionExecute;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::match_each_native_ptype;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 mod accessor;
 mod cast;
@@ -31,7 +39,18 @@ mod top_value;
 pub use patch::chunk_range;
 pub use patch::patch_chunk;
 
+use crate::ArrayRef;
+use crate::aggregate_fn::fns::min_max::min_max;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::bool::BoolArrayExt;
 use crate::buffer::BufferHandle;
+use crate::builtins::ArrayBuiltins;
+
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
 
 /// A primitive array that stores [native types][crate::dtype::NativePType] in a contiguous buffer
 /// of memory, along with an optional validity child.
@@ -49,7 +68,6 @@ use crate::buffer::BufferHandle;
 /// ```
 /// # fn main() -> vortex_error::VortexResult<()> {
 /// use vortex_array::arrays::PrimitiveArray;
-/// use vortex_array::compute::sum;
 ///
 /// // Create from iterator using FromIterator impl
 /// let array: PrimitiveArray = [1i32, 2, 3, 4, 5].into_iter().collect();
@@ -61,28 +79,163 @@ use crate::buffer::BufferHandle;
 /// let value = sliced.scalar_at(0).unwrap();
 /// assert_eq!(value, 2i32.into());
 ///
-/// // Convert into a type-erased array that can be passed to compute functions.
-/// let summed = sum(sliced.as_ref()).unwrap().as_primitive().typed_value::<i64>().unwrap();
-/// assert_eq!(summed, 5i64);
 /// # Ok(())
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct PrimitiveArray {
-    pub(super) dtype: DType,
+pub struct PrimitiveData {
+    pub(super) ptype: PType,
     pub(super) buffer: BufferHandle,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
 }
 
-pub struct PrimitiveArrayParts {
+impl Display for PrimitiveData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ptype: {}", self.ptype)
+    }
+}
+
+pub struct PrimitiveDataParts {
     pub ptype: PType,
     pub buffer: BufferHandle,
     pub validity: Validity,
 }
 
+pub trait PrimitiveArrayExt: TypedArrayRef<Primitive> {
+    fn ptype(&self) -> PType {
+        match self.as_ref().dtype() {
+            DType::Primitive(ptype, _) => *ptype,
+            _ => unreachable!("PrimitiveArrayExt requires a primitive dtype"),
+        }
+    }
+
+    fn nullability(&self) -> Nullability {
+        match self.as_ref().dtype() {
+            DType::Primitive(_, nullability) => *nullability,
+            _ => unreachable!("PrimitiveArrayExt requires a primitive dtype"),
+        }
+    }
+
+    fn validity_child(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[VALIDITY_SLOT].as_ref()
+    }
+
+    fn validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn validity_mask(&self) -> vortex_mask::Mask {
+        self.validity().to_mask(self.as_ref().len())
+    }
+
+    fn buffer_handle(&self) -> &BufferHandle {
+        &self.buffer
+    }
+
+    fn reinterpret_cast(&self, ptype: PType) -> PrimitiveArray {
+        if self.ptype() == ptype {
+            return self.to_owned();
+        }
+
+        assert_eq!(
+            self.ptype().byte_width(),
+            ptype.byte_width(),
+            "can't reinterpret cast between integers of two different widths"
+        );
+
+        PrimitiveArray::from_buffer_handle(self.buffer_handle().clone(), ptype, self.validity())
+    }
+
+    /// Narrow the array to the smallest possible integer type that can represent all values.
+    fn narrow(&self) -> VortexResult<PrimitiveArray> {
+        if !self.ptype().is_int() {
+            return Ok(self.to_owned());
+        }
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let Some(min_max) = min_max(self.as_ref(), &mut ctx)? else {
+            return Ok(PrimitiveArray::new(
+                Buffer::<u8>::zeroed(self.len()),
+                self.validity(),
+            ));
+        };
+
+        // If we can't cast to i64, then leave the array as its original type.
+        // It's too big to downcast anyway.
+        let Ok(min) = min_max
+            .min
+            .cast(&PType::I64.into())
+            .and_then(|s| i64::try_from(&s))
+        else {
+            return Ok(self.to_owned());
+        };
+        let Ok(max) = min_max
+            .max
+            .cast(&PType::I64.into())
+            .and_then(|s| i64::try_from(&s))
+        else {
+            return Ok(self.to_owned());
+        };
+
+        let nullability = self.as_ref().dtype().nullability();
+
+        if min < 0 || max < 0 {
+            // Signed
+            if min >= i8::MIN as i64 && max <= i8::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::I8, nullability))?
+                    .to_primitive());
+            }
+
+            if min >= i16::MIN as i64 && max <= i16::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::I16, nullability))?
+                    .to_primitive());
+            }
+
+            if min >= i32::MIN as i64 && max <= i32::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::I32, nullability))?
+                    .to_primitive());
+            }
+        } else {
+            // Unsigned
+            if max <= u8::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::U8, nullability))?
+                    .to_primitive());
+            }
+
+            if max <= u16::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::U16, nullability))?
+                    .to_primitive());
+            }
+
+            if max <= u32::MAX as i64 {
+                return Ok(self
+                    .as_ref()
+                    .cast(DType::Primitive(PType::U32, nullability))?
+                    .to_primitive());
+            }
+        }
+
+        Ok(self.to_owned())
+    }
+}
+impl<T: TypedArrayRef<Primitive>> PrimitiveArrayExt for T {}
+
 // TODO(connor): There are a lot of places where we could be using `new_unchecked` in the codebase.
-impl PrimitiveArray {
+impl PrimitiveData {
+    /// Build the slots vector for this array.
+    pub(super) fn make_slots(validity: &Validity, len: usize) -> Vec<Option<ArrayRef>> {
+        vec![validity_to_child(validity, len)]
+    }
+
     /// Create a new array from a buffer handle.
     ///
     /// # Safety
@@ -92,22 +245,20 @@ impl PrimitiveArray {
     pub unsafe fn new_unchecked_from_handle(
         handle: BufferHandle,
         ptype: PType,
-        validity: Validity,
+        _validity: Validity,
     ) -> Self {
         Self {
+            ptype,
             buffer: handle,
-            dtype: DType::Primitive(ptype, validity.nullability()),
-            validity,
-            stats_set: ArrayStats::default(),
         }
     }
 
-    /// Creates a new [`PrimitiveArray`].
+    /// Creates a new `PrimitiveArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`PrimitiveArray::new_unchecked`].
+    /// in `PrimitiveArray::new_unchecked`.
     pub fn new<T: NativePType>(buffer: impl Into<Buffer<T>>, validity: Validity) -> Self {
         let buffer = buffer.into();
         Self::try_new(buffer, validity).vortex_expect("PrimitiveArray construction failed")
@@ -115,12 +266,12 @@ impl PrimitiveArray {
 
     /// Constructs a new `PrimitiveArray`.
     ///
-    /// See [`PrimitiveArray::new_unchecked`] for more information.
+    /// See `PrimitiveArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`PrimitiveArray::new_unchecked`].
+    /// `PrimitiveArray::new_unchecked`.
     #[inline]
     pub fn try_new<T: NativePType>(buffer: Buffer<T>, validity: Validity) -> VortexResult<Self> {
         Self::validate(&buffer, &validity)?;
@@ -129,7 +280,7 @@ impl PrimitiveArray {
         Ok(unsafe { Self::new_unchecked(buffer, validity) })
     }
 
-    /// Creates a new [`PrimitiveArray`] without validation from these components:
+    /// Creates a new `PrimitiveArray` without validation from these components:
     ///
     /// * `buffer` is a typed buffer containing the primitive values.
     /// * `validity` holds the null values.
@@ -142,22 +293,20 @@ impl PrimitiveArray {
     ///
     /// - If `validity` is [`Validity::Array`], its length must exactly equal `buffer.len()`.
     #[inline]
-    pub unsafe fn new_unchecked<T: NativePType>(buffer: Buffer<T>, validity: Validity) -> Self {
+    pub unsafe fn new_unchecked<T: NativePType>(buffer: Buffer<T>, _validity: Validity) -> Self {
         #[cfg(debug_assertions)]
-        Self::validate(&buffer, &validity)
+        Self::validate(&buffer, &_validity)
             .vortex_expect("[Debug Assertion]: Invalid `PrimitiveArray` parameters");
 
         Self {
-            dtype: DType::Primitive(T::PTYPE, validity.nullability()),
+            ptype: T::PTYPE,
             buffer: BufferHandle::new_host(buffer.into_byte_buffer()),
-            validity,
-            stats_set: Default::default(),
         }
     }
 
-    /// Validates the components that would be used to create a [`PrimitiveArray`].
+    /// Validates the components that would be used to create a `PrimitiveArray`.
     ///
-    /// This function checks all the invariants required by [`PrimitiveArray::new_unchecked`].
+    /// This function checks all the invariants required by `PrimitiveArray::new_unchecked`.
     #[inline]
     pub fn validate<T: NativePType>(buffer: &Buffer<T>, validity: &Validity) -> VortexResult<()> {
         if let Some(len) = validity.maybe_len()
@@ -178,21 +327,184 @@ impl PrimitiveArray {
     }
 }
 
-impl PrimitiveArray {
-    /// Consume the primitive array and returns its component parts.
-    pub fn into_parts(self) -> PrimitiveArrayParts {
-        let ptype = self.ptype();
-        PrimitiveArrayParts {
+impl Array<Primitive> {
+    pub fn empty<T: NativePType>(nullability: Nullability) -> Self {
+        let dtype = DType::Primitive(T::PTYPE, nullability);
+        let len = 0;
+        let data = PrimitiveData::empty::<T>(nullability);
+        let slots = PrimitiveData::make_slots(&Validity::from(nullability), len);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Creates a new `PrimitiveArray`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided components do not satisfy the invariants.
+    pub fn new<T: NativePType>(buffer: impl Into<Buffer<T>>, validity: Validity) -> Self {
+        let buffer = buffer.into();
+        let dtype = DType::Primitive(T::PTYPE, validity.nullability());
+        let len = buffer.len();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = PrimitiveData::new(buffer, validity);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Constructs a new `PrimitiveArray`.
+    pub fn try_new<T: NativePType>(buffer: Buffer<T>, validity: Validity) -> VortexResult<Self> {
+        let dtype = DType::Primitive(T::PTYPE, validity.nullability());
+        let len = buffer.len();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = PrimitiveData::try_new(buffer, validity)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        })
+    }
+
+    /// Creates a new `PrimitiveArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`PrimitiveData::new_unchecked`].
+    pub unsafe fn new_unchecked<T: NativePType>(buffer: Buffer<T>, validity: Validity) -> Self {
+        let dtype = DType::Primitive(T::PTYPE, validity.nullability());
+        let len = buffer.len();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = unsafe { PrimitiveData::new_unchecked(buffer, validity) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Create a new array from a buffer handle.
+    ///
+    /// # Safety
+    ///
+    /// See [`PrimitiveData::new_unchecked_from_handle`].
+    pub unsafe fn new_unchecked_from_handle(
+        handle: BufferHandle,
+        ptype: PType,
+        validity: Validity,
+    ) -> Self {
+        let dtype = DType::Primitive(ptype, validity.nullability());
+        let len = handle.len() / ptype.byte_width();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = unsafe { PrimitiveData::new_unchecked_from_handle(handle, ptype, validity) };
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Creates a new `PrimitiveArray` from a [`BufferHandle`].
+    pub fn from_buffer_handle(handle: BufferHandle, ptype: PType, validity: Validity) -> Self {
+        let dtype = DType::Primitive(ptype, validity.nullability());
+        let len = handle.len() / ptype.byte_width();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = PrimitiveData::from_buffer_handle(handle, ptype, validity);
+        Array::try_from_parts(ArrayParts::new(Primitive, dtype, len, data).with_slots(slots))
+            .vortex_expect("PrimitiveData is always valid")
+    }
+
+    /// Creates a new `PrimitiveArray` from a [`ByteBuffer`].
+    pub fn from_byte_buffer(buffer: ByteBuffer, ptype: PType, validity: Validity) -> Self {
+        let dtype = DType::Primitive(ptype, validity.nullability());
+        let len = buffer.len() / ptype.byte_width();
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = PrimitiveData::from_byte_buffer(buffer, ptype, validity);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Create a PrimitiveArray from a byte buffer containing only the valid elements.
+    pub fn from_values_byte_buffer(
+        valid_elems_buffer: ByteBuffer,
+        ptype: PType,
+        validity: Validity,
+        n_rows: usize,
+    ) -> Self {
+        let dtype = DType::Primitive(ptype, validity.nullability());
+        let len = n_rows;
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data =
+            PrimitiveData::from_values_byte_buffer(valid_elems_buffer, ptype, validity, n_rows);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Primitive, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Validates the components that would be used to create a `PrimitiveArray`.
+    pub fn validate<T: NativePType>(buffer: &Buffer<T>, validity: &Validity) -> VortexResult<()> {
+        PrimitiveData::validate(buffer, validity)
+    }
+
+    pub fn into_data_parts(self) -> PrimitiveDataParts {
+        let validity = PrimitiveArrayExt::validity(&self);
+        let ptype = PrimitiveArrayExt::ptype(&self);
+        let data = self.into_data();
+        PrimitiveDataParts {
             ptype,
-            buffer: self.buffer,
-            validity: self.validity,
+            buffer: data.buffer,
+            validity,
         }
     }
+
+    pub fn map_each_with_validity<T, R, F>(self, f: F) -> VortexResult<Self>
+    where
+        T: NativePType,
+        R: NativePType,
+        F: FnMut((T, bool)) -> R,
+    {
+        let validity = PrimitiveArrayExt::validity(&self);
+        let data = self.into_data();
+        let buf_iter = data.to_buffer::<T>().into_iter();
+
+        let buffer = match &validity {
+            Validity::NonNullable | Validity::AllValid => {
+                BufferMut::<R>::from_iter(buf_iter.zip(iter::repeat(true)).map(f))
+            }
+            Validity::AllInvalid => {
+                BufferMut::<R>::from_iter(buf_iter.zip(iter::repeat(false)).map(f))
+            }
+            Validity::Array(val) => {
+                let val = val.to_bool().into_bit_buffer();
+                BufferMut::<R>::from_iter(buf_iter.zip(val.iter()).map(f))
+            }
+        };
+        Ok(PrimitiveArray::new(buffer.freeze(), validity))
+    }
 }
 
-impl PrimitiveArray {
+impl PrimitiveData {
+    pub fn len(&self) -> usize {
+        self.buffer.len() / self.ptype.byte_width()
+    }
+
+    /// Returns `true` if the array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
     pub fn ptype(&self) -> PType {
-        self.dtype().as_ptype()
+        self.ptype
     }
 
     /// Get access to the buffer handle backing the array.
@@ -200,13 +512,10 @@ impl PrimitiveArray {
         &self.buffer
     }
 
-    pub fn from_buffer_handle(handle: BufferHandle, ptype: PType, validity: Validity) -> Self {
-        let dtype = DType::Primitive(ptype, validity.nullability());
+    pub fn from_buffer_handle(handle: BufferHandle, ptype: PType, _validity: Validity) -> Self {
         Self {
+            ptype,
             buffer: handle,
-            dtype,
-            validity,
-            stats_set: ArrayStats::default(),
         }
     }
 
@@ -243,52 +552,49 @@ impl PrimitiveArray {
         Self::from_byte_buffer(buffer, ptype, validity)
     }
 
-    /// Map each element in the array to a new value.
+    /// Get a buffer in host memory holding all the values.
     ///
-    /// This ignores validity and maps over all maybe-null elements.
-    ///
-    /// TODO(ngates): we could be smarter here if validity is sparse and only run the function
-    ///   over the valid elements.
-    pub fn map_each<T, R, F>(self, f: F) -> PrimitiveArray
-    where
-        T: NativePType,
-        R: NativePType,
-        F: FnMut(T) -> R,
-    {
-        let validity = self.validity().clone();
-        let buffer = match self.try_into_buffer_mut() {
-            Ok(buffer_mut) => buffer_mut.map_each_in_place(f),
-            Err(buffer) => BufferMut::from_iter(buffer.iter().copied().map(f)),
-        };
-        PrimitiveArray::new(buffer.freeze(), validity)
+    /// NOTE: some values may be nonsense if the validity buffer indicates that the value is null.
+    pub fn to_buffer<T: NativePType>(&self) -> Buffer<T> {
+        if T::PTYPE != self.ptype() {
+            vortex_panic!(
+                "Attempted to get buffer of type {} from array of type {}",
+                T::PTYPE,
+                self.ptype()
+            )
+        }
+        Buffer::from_byte_buffer(self.buffer_handle().to_host_sync())
     }
 
-    /// Map each element in the array to a new value.
-    ///
-    /// This doesn't ignore validity and maps over all maybe-null elements, with a bool true if
-    /// valid and false otherwise.
-    pub fn map_each_with_validity<T, R, F>(self, f: F) -> VortexResult<PrimitiveArray>
-    where
-        T: NativePType,
-        R: NativePType,
-        F: FnMut((T, bool)) -> R,
-    {
-        let validity = self.validity();
+    /// Consume the array and get a host Buffer containing the data values.
+    pub fn into_buffer<T: NativePType>(self) -> Buffer<T> {
+        if T::PTYPE != self.ptype() {
+            vortex_panic!(
+                "Attempted to get buffer of type {} from array of type {}",
+                T::PTYPE,
+                self.ptype()
+            )
+        }
+        Buffer::from_byte_buffer(self.buffer.into_host_sync())
+    }
 
-        let buf_iter = self.to_buffer::<T>().into_iter();
+    /// Extract a mutable buffer from the PrimitiveData. Attempts to do this with zero-copy
+    /// if the buffer is uniquely owned, otherwise will make a copy.
+    pub fn into_buffer_mut<T: NativePType>(self) -> BufferMut<T> {
+        self.try_into_buffer_mut()
+            .unwrap_or_else(|buffer| BufferMut::<T>::copy_from(&buffer))
+    }
 
-        let buffer = match &validity {
-            Validity::NonNullable | Validity::AllValid => {
-                BufferMut::<R>::from_iter(buf_iter.zip(iter::repeat(true)).map(f))
-            }
-            Validity::AllInvalid => {
-                BufferMut::<R>::from_iter(buf_iter.zip(iter::repeat(false)).map(f))
-            }
-            Validity::Array(val) => {
-                let val = val.to_bool().into_bit_buffer();
-                BufferMut::<R>::from_iter(buf_iter.zip(val.iter()).map(f))
-            }
-        };
-        Ok(PrimitiveArray::new(buffer.freeze(), validity.clone()))
+    /// Try to extract a mutable buffer from the PrimitiveData with zero copy.
+    pub fn try_into_buffer_mut<T: NativePType>(self) -> Result<BufferMut<T>, Buffer<T>> {
+        if T::PTYPE != self.ptype() {
+            vortex_panic!(
+                "Attempted to get buffer_mut of type {} from array of type {}",
+                T::PTYPE,
+                self.ptype()
+            )
+        }
+        let buffer = Buffer::<T>::from_byte_buffer(self.buffer.into_host_sync());
+        buffer.try_into_mut()
     }
 }
diff --git a/vortex-array/src/arrays/primitive/array/patch.rs b/vortex-array/src/arrays/primitive/array/patch.rs
index dc862ff8623..51fae5e9cd0 100644
--- a/vortex-array/src/arrays/primitive/array/patch.rs
+++ b/vortex-array/src/arrays/primitive/array/patch.rs
@@ -5,7 +5,8 @@ use std::ops::Range;
 
 use vortex_error::VortexResult;
 
-use crate::Array;
+use crate::ExecutionCtx;
+use crate::IntoArray;
 use crate::arrays::PrimitiveArray;
 use crate::dtype::IntegerPType;
 use crate::dtype::NativePType;
@@ -15,18 +16,19 @@ use crate::match_each_native_ptype;
 use crate::patches::PATCH_CHUNK_SIZE;
 use crate::patches::Patches;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 impl PrimitiveArray {
-    pub fn patch(self, patches: &Patches) -> VortexResult<Self> {
-        let patch_indices = patches.indices().to_canonical()?.into_primitive();
-        let patch_values = patches.values().to_canonical()?.into_primitive();
+    pub fn patch(self, patches: &Patches, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
+        let patch_indices = patches.indices().clone().execute::<PrimitiveArray>(ctx)?;
+        let patch_values = patches.values().clone().execute::<PrimitiveArray>(ctx)?;
 
-        let patched_validity = self.validity().clone().patch(
+        let patch_validity = patch_values.validity()?;
+        let patched_validity = self.validity()?.patch(
             self.len(),
             patches.offset(),
-            patch_indices.as_ref(),
-            patch_values.validity(),
+            &patch_indices.clone().into_array(),
+            &patch_validity,
+            ctx,
         )?;
         Ok(match_each_integer_ptype!(patch_indices.ptype(), |I| {
             match_each_native_ptype!(self.ptype(), |T| {
@@ -90,7 +92,6 @@ pub fn chunk_range(chunk_idx: usize, offset: usize, array_len: usize) -> Range<u
 /// * `chunk_offsets_slice` - Slice containing offsets for each chunk
 /// * `chunk_idx` - Index of the chunk to patch
 /// * `offset_within_chunk` - Number of patches to skip at the start of the first chunk
-#[inline]
 pub fn patch_chunk<T, I, C>(
     decoded_values: &mut [T],
     patches_indices: &[I],
@@ -110,8 +111,12 @@ pub fn patch_chunk<T, I, C>(
     // Use the same logic as patches slice implementation for calculating patch ranges.
     let patches_start_idx =
         (chunk_offsets_slice[chunk_idx].as_() - base_offset).saturating_sub(offset_within_chunk);
+    // Clamp: chunk_offsets are sliced at chunk granularity but patches at element
+    // granularity, so the next chunk offset may exceed the actual patches length.
     let patches_end_idx = if chunk_idx + 1 < chunk_offsets_slice.len() {
-        chunk_offsets_slice[chunk_idx + 1].as_() - base_offset - offset_within_chunk
+        (chunk_offsets_slice[chunk_idx + 1].as_() - base_offset)
+            .saturating_sub(offset_within_chunk)
+            .min(patches_indices.len())
     } else {
         patches_indices.len()
     };
@@ -134,6 +139,37 @@ mod tests {
     use crate::assert_arrays_eq;
     use crate::validity::Validity;
 
+    /// Regression: patch_chunk must not OOB when chunk_offsets (chunk granularity)
+    /// reference more patches than patches_indices (element granularity) contains.
+    #[test]
+    fn patch_chunk_no_oob_on_mid_chunk_slice() {
+        let mut decoded_values = vec![0.0f64; PATCH_CHUNK_SIZE];
+        // 10 patches, but chunk_offsets claim 15 exist past offset adjustment.
+        let patches_indices: Vec<u64> = (0..10)
+            .map(|i| (PATCH_CHUNK_SIZE as u64) + i * 10)
+            .collect();
+        let patches_values: Vec<f64> = (0..10).map(|i| (i + 1) as f64 * 100.0).collect();
+        // chunk_offsets [5, 12, 20]: for chunk_idx=1 with offset_within_chunk=3,
+        // unclamped end = (20-5)-3 = 12, which exceeds patches len of 10.
+        let chunk_offsets: Vec<u32> = vec![5, 12, 20];
+
+        patch_chunk(
+            &mut decoded_values,
+            &patches_indices,
+            &patches_values,
+            0,
+            &chunk_offsets,
+            1,
+            3,
+        );
+
+        // Spot-check: patch index 4 (first in range) should be applied.
+        assert_ne!(
+            decoded_values[usize::try_from(patches_indices[4]).unwrap() - PATCH_CHUNK_SIZE],
+            0.0
+        );
+    }
+
     #[test]
     fn patch_sliced() {
         let input = PrimitiveArray::new(buffer![2u32; 10], Validity::AllValid);
diff --git a/vortex-array/src/arrays/primitive/array/top_value.rs b/vortex-array/src/arrays/primitive/array/top_value.rs
index d85975f0325..dae36a5a523 100644
--- a/vortex-array/src/arrays/primitive/array/top_value.rs
+++ b/vortex-array/src/arrays/primitive/array/top_value.rs
@@ -10,11 +10,12 @@ use vortex_mask::AllOr;
 use vortex_mask::Mask;
 use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::arrays::NativeValue;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::primitive::NativeValue;
 use crate::dtype::NativePType;
 use crate::match_each_native_ptype;
 use crate::scalar::PValue;
+use crate::validity::Validity;
 
 impl PrimitiveArray {
     /// Compute most common present value of this array
@@ -23,7 +24,7 @@ impl PrimitiveArray {
             return Ok(None);
         }
 
-        if self.all_invalid()? {
+        if matches!(self.validity()?, Validity::AllInvalid) {
             return Ok(None);
         }
 
diff --git a/vortex-array/src/arrays/primitive/compute/between.rs b/vortex-array/src/arrays/primitive/compute/between.rs
index e4509285afd..9a6c7f60c1b 100644
--- a/vortex-array/src/arrays/primitive/compute/between.rs
+++ b/vortex-array/src/arrays/primitive/compute/between.rs
@@ -2,28 +2,27 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex_buffer::BitBuffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::BoolArray;
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::Primitive;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
 use crate::match_each_native_ptype;
 use crate::scalar_fn::fns::between::BetweenKernel;
 use crate::scalar_fn::fns::between::BetweenOptions;
 use crate::scalar_fn::fns::between::StrictComparison;
-use crate::vtable::ValidityHelper;
 
-impl BetweenKernel for PrimitiveVTable {
+impl BetweenKernel for Primitive {
     fn between(
-        arr: &PrimitiveArray,
-        lower: &dyn Array,
-        upper: &dyn Array,
+        arr: ArrayView<'_, Primitive>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
         options: &BetweenOptions,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -35,7 +34,7 @@ impl BetweenKernel for PrimitiveVTable {
         // null values
 
         let nullability =
-            arr.dtype.nullability() | lower.dtype().nullability() | upper.dtype().nullability();
+            arr.dtype().nullability() | lower.dtype().nullability() | upper.dtype().nullability();
 
         Ok(Some(match_each_native_ptype!(arr.ptype(), |P| {
             between_impl::<P>(
@@ -50,7 +49,7 @@ impl BetweenKernel for PrimitiveVTable {
 }
 
 fn between_impl<T: NativePType + Copy>(
-    arr: &PrimitiveArray,
+    arr: ArrayView<'_, Primitive>,
     lower: T,
     upper: T,
     nullability: Nullability,
@@ -94,7 +93,7 @@ fn between_impl<T: NativePType + Copy>(
 }
 
 fn between_impl_<T>(
-    arr: &PrimitiveArray,
+    arr: ArrayView<'_, Primitive>,
     lower: T,
     lower_fn: impl Fn(T, T) -> bool,
     upper: T,
@@ -111,7 +110,9 @@ where
             let i = unsafe { *slice.get_unchecked(idx) };
             lower_fn(lower, i) & upper_fn(i, upper)
         }),
-        arr.validity().clone().union_nullability(nullability),
+        arr.validity()
+            .vortex_expect("validity should be derivable")
+            .union_nullability(nullability),
     )
     .into_array()
 }
diff --git a/vortex-array/src/arrays/primitive/compute/cast.rs b/vortex-array/src/arrays/primitive/compute/cast.rs
index 35fcc314af6..9053afaf66f 100644
--- a/vortex-array/src/arrays/primitive/compute/cast.rs
+++ b/vortex-array/src/arrays/primitive/compute/cast.rs
@@ -4,6 +4,7 @@
 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::AllOr;
 use vortex_mask::Mask;
@@ -11,19 +12,23 @@ use vortex_mask::Mask;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::aggregate_fn;
+use crate::array::ArrayView;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
 use crate::match_each_native_ptype;
 use crate::scalar_fn::fns::cast::CastKernel;
-use crate::vtable::ValidityHelper;
 
-impl CastKernel for PrimitiveVTable {
+impl CastKernel for Primitive {
     fn cast(
-        array: &PrimitiveArray,
+        array: ArrayView<'_, Primitive>,
         dtype: &DType,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let DType::Primitive(new_ptype, new_nullability) = dtype else {
             return Ok(None);
@@ -32,11 +37,10 @@ impl CastKernel for PrimitiveVTable {
 
         // First, check that the cast is compatible with the source array's validity
         let new_validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(new_nullability, array.len())?;
 
-        // If the bit width is the same, we can short-circuit and simply update the validity
+        // Same ptype: zero-copy, just update validity.
         if array.ptype() == new_ptype {
             // SAFETY: validity and data buffer still have same length
             return Ok(Some(unsafe {
@@ -49,9 +53,35 @@ impl CastKernel for PrimitiveVTable {
             }));
         }
 
-        let mask = array.validity_mask()?;
+        // Same-width integers have identical bit representations due to 2's
+        // complement. If all values fit in the target range, reinterpret with
+        // no allocation.
+        if array.ptype().is_int()
+            && new_ptype.is_int()
+            && array.ptype().byte_width() == new_ptype.byte_width()
+        {
+            if !values_fit_in(array, new_ptype, ctx) {
+                vortex_bail!(
+                    Compute: "Cannot cast {} to {} — values exceed target range",
+                    array.ptype(),
+                    new_ptype,
+                );
+            }
+            // SAFETY: both types are integers with the same size and alignment, and
+            // min/max confirm all valid values are representable in the target type.
+            return Ok(Some(unsafe {
+                PrimitiveArray::new_unchecked_from_handle(
+                    array.buffer_handle().clone(),
+                    new_ptype,
+                    new_validity,
+                )
+                .into_array()
+            }));
+        }
+
+        let mask = array.validity_mask();
 
-        // Otherwise, we need to cast the values one-by-one
+        // Otherwise, we need to cast the values one-by-one.
         Ok(Some(match_each_native_ptype!(new_ptype, |T| {
             match_each_native_ptype!(array.ptype(), |F| {
                 PrimitiveArray::new(cast::<F, T>(array.as_slice(), mask)?, new_validity)
@@ -61,34 +91,39 @@ impl CastKernel for PrimitiveVTable {
     }
 }
 
+/// Returns `true` if all valid values in `array` are representable as `target_ptype`.
+fn values_fit_in(
+    array: ArrayView<'_, Primitive>,
+    target_ptype: PType,
+    ctx: &mut ExecutionCtx,
+) -> bool {
+    let target_dtype = DType::Primitive(target_ptype, Nullability::NonNullable);
+    aggregate_fn::fns::min_max::min_max(array.array(), ctx)
+        .ok()
+        .flatten()
+        .is_none_or(|mm| mm.min.cast(&target_dtype).is_ok() && mm.max.cast(&target_dtype).is_ok())
+}
+
 fn cast<F: NativePType, T: NativePType>(array: &[F], mask: Mask) -> VortexResult<Buffer<T>> {
+    let try_cast = |src: F| -> VortexResult<T> {
+        T::from(src).ok_or_else(|| vortex_err!(Compute: "Failed to cast {} to {:?}", src, T::PTYPE))
+    };
     match mask.bit_buffer() {
+        AllOr::None => Ok(Buffer::zeroed(array.len())),
         AllOr::All => {
             let mut buffer = BufferMut::with_capacity(array.len());
-            for item in array {
-                let item = T::from(*item).ok_or_else(
-                    || vortex_err!(Compute: "Failed to cast {} to {:?}", item, T::PTYPE),
-                )?;
+            for &src in array {
                 // SAFETY: we've pre-allocated the required capacity
-                unsafe { buffer.push_unchecked(item) }
+                unsafe { buffer.push_unchecked(try_cast(src)?) }
             }
             Ok(buffer.freeze())
         }
-        AllOr::None => Ok(Buffer::zeroed(array.len())),
         AllOr::Some(b) => {
-            // TODO(robert): Depending on density of the buffer might be better to prefill Buffer and only write valid values
             let mut buffer = BufferMut::with_capacity(array.len());
-            for (item, valid) in array.iter().zip(b.iter()) {
-                if valid {
-                    let item = T::from(*item).ok_or_else(
-                        || vortex_err!(Compute: "Failed to cast {} to {:?}", item, T::PTYPE),
-                    )?;
-                    // SAFETY: we've pre-allocated the required capacity
-                    unsafe { buffer.push_unchecked(item) }
-                } else {
-                    // SAFETY: we've pre-allocated the required capacity
-                    unsafe { buffer.push_unchecked(T::default()) }
-                }
+            for (&src, valid) in array.iter().zip(b.iter()) {
+                let dst = if valid { try_cast(src)? } else { T::default() };
+                // SAFETY: we've pre-allocated the required capacity
+                unsafe { buffer.push_unchecked(dst) }
             }
             Ok(buffer.freeze())
         }
@@ -113,8 +148,8 @@ mod test {
     use crate::dtype::Nullability;
     use crate::dtype::PType;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
+    #[allow(clippy::cognitive_complexity)]
     #[test]
     fn cast_u32_u8() {
         let arr = buffer![0u32, 10, 200].into_array();
@@ -122,11 +157,11 @@ mod test {
         // cast from u32 to u8
         let p = arr.cast(PType::U8.into()).unwrap().to_primitive();
         assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
-        assert_eq!(p.validity(), &Validity::NonNullable);
+        assert!(matches!(p.validity(), Ok(Validity::NonNullable)));
 
         // to nullable
         let p = p
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U8, Nullability::Nullable))
             .unwrap()
             .to_primitive();
@@ -134,20 +169,20 @@ mod test {
             p,
             PrimitiveArray::new(buffer![0u8, 10, 200], Validity::AllValid)
         );
-        assert_eq!(p.validity(), &Validity::AllValid);
+        assert!(matches!(p.validity(), Ok(Validity::AllValid)));
 
         // back to non-nullable
         let p = p
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U8, Nullability::NonNullable))
             .unwrap()
             .to_primitive();
         assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
-        assert_eq!(p.validity(), &Validity::NonNullable);
+        assert!(matches!(p.validity(), Ok(Validity::NonNullable)));
 
         // to nullable u32
         let p = p
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap()
             .to_primitive();
@@ -155,16 +190,16 @@ mod test {
             p,
             PrimitiveArray::new(buffer![0u32, 10, 200], Validity::AllValid)
         );
-        assert_eq!(p.validity(), &Validity::AllValid);
+        assert!(matches!(p.validity(), Ok(Validity::AllValid)));
 
         // to non-nullable u8
         let p = p
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U8, Nullability::NonNullable))
             .unwrap()
             .to_primitive();
         assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
-        assert_eq!(p.validity(), &Validity::NonNullable);
+        assert!(matches!(p.validity(), Ok(Validity::NonNullable)));
     }
 
     #[test]
@@ -182,14 +217,14 @@ mod test {
             .and_then(|a| a.to_canonical().map(|c| c.into_array()))
             .unwrap_err();
         assert!(matches!(error, VortexError::Compute(..)));
-        assert!(error.to_string().contains("Failed to cast -1 to U32"));
+        assert!(error.to_string().contains("values exceed target range"));
     }
 
     #[test]
     fn cast_array_with_nulls_to_nonnullable() {
         let arr = PrimitiveArray::from_option_iter([Some(-1i32), None, Some(10)]);
         let err = arr
-            .to_array()
+            .into_array()
             .cast(PType::I32.into())
             .and_then(|a| a.to_canonical().map(|c| c.into_array()))
             .unwrap_err();
@@ -208,7 +243,7 @@ mod test {
             Validity::from_iter([false, true, true]),
         );
         let p = arr
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(PType::U32, Nullability::Nullable))
             .unwrap()
             .to_primitive();
@@ -222,6 +257,69 @@ mod test {
         );
     }
 
+    /// Same-width integer cast where all values fit: should reinterpret the
+    /// buffer without allocation (pointer identity).
+    #[test]
+    fn cast_same_width_int_reinterprets_buffer() -> vortex_error::VortexResult<()> {
+        let src = PrimitiveArray::from_iter([0u32, 10, 100]);
+        let src_ptr = src.as_slice::<u32>().as_ptr();
+
+        let dst = src.into_array().cast(PType::I32.into())?.to_primitive();
+        let dst_ptr = dst.as_slice::<i32>().as_ptr();
+
+        // Zero-copy: the data pointer should be identical.
+        assert_eq!(src_ptr as usize, dst_ptr as usize);
+        assert_arrays_eq!(dst, PrimitiveArray::from_iter([0i32, 10, 100]));
+        Ok(())
+    }
+
+    /// Same-width integer cast where values don't fit: should fall through
+    /// to the allocating path and produce an error.
+    #[test]
+    fn cast_same_width_int_out_of_range_errors() {
+        let arr = buffer![u32::MAX].into_array();
+        let err = arr
+            .cast(PType::I32.into())
+            .and_then(|a| a.to_canonical().map(|c| c.into_array()))
+            .unwrap_err();
+        assert!(matches!(err, VortexError::Compute(..)));
+    }
+
+    /// All-null array cast between same-width types should succeed without
+    /// touching the buffer contents.
+    #[test]
+    fn cast_same_width_all_null() -> vortex_error::VortexResult<()> {
+        let arr = PrimitiveArray::new(buffer![0xFFu8, 0xFF], Validity::AllInvalid);
+        let casted = arr
+            .into_array()
+            .cast(DType::Primitive(PType::I8, Nullability::Nullable))?
+            .to_primitive();
+        assert_eq!(casted.len(), 2);
+        assert!(matches!(casted.validity(), Ok(Validity::AllInvalid)));
+        Ok(())
+    }
+
+    /// Same-width integer cast with nullable values: out-of-range nulls should
+    /// not prevent the cast from succeeding.
+    #[test]
+    fn cast_same_width_int_nullable_with_out_of_range_nulls() -> vortex_error::VortexResult<()> {
+        // The null position holds u32::MAX which doesn't fit in i32, but it's
+        // masked as invalid so the cast should still succeed via reinterpret.
+        let arr = PrimitiveArray::new(
+            buffer![u32::MAX, 0u32, 42u32],
+            Validity::from_iter([false, true, true]),
+        );
+        let casted = arr
+            .into_array()
+            .cast(DType::Primitive(PType::I32, Nullability::Nullable))?
+            .to_primitive();
+        assert_arrays_eq!(
+            casted,
+            PrimitiveArray::from_option_iter([None, Some(0i32), Some(42)])
+        );
+        Ok(())
+    }
+
     #[rstest]
     #[case(buffer![0u8, 1, 2, 3, 255].into_array())]
     #[case(buffer![0u16, 100, 1000, 65535].into_array())]
@@ -237,6 +335,6 @@ mod test {
     #[case(PrimitiveArray::from_option_iter([Some(1i32), None, Some(-100), Some(0), None]).into_array())]
     #[case(buffer![42u32].into_array())]
     fn test_cast_primitive_conformance(#[case] array: crate::ArrayRef) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/fill_null.rs b/vortex-array/src/arrays/primitive/compute/fill_null.rs
index 31d4325045e..d0de9a81a4f 100644
--- a/vortex-array/src/arrays/primitive/compute/fill_null.rs
+++ b/vortex-array/src/arrays/primitive/compute/fill_null.rs
@@ -9,26 +9,26 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::array::ArrayView;
+use crate::arrays::BoolArray;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
 use crate::match_each_native_ptype;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNullKernel;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl FillNullKernel for PrimitiveVTable {
+impl FillNullKernel for Primitive {
     fn fill_null(
-        array: &PrimitiveArray,
+        array: ArrayView<'_, Primitive>,
         fill_value: &Scalar,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let result_validity = Validity::from(fill_value.dtype().nullability());
 
-        Ok(Some(match array.validity() {
+        Ok(Some(match array.validity()? {
             Validity::Array(is_valid) => {
-                let is_invalid = is_valid.to_bool().to_bit_buffer().not();
+                let is_invalid = is_valid.execute::<BoolArray>(ctx)?.into_bit_buffer().not();
                 match_each_native_ptype!(array.ptype(), |T| {
                     let mut buffer = array.to_buffer::<T>().into_mut();
                     let fill_value = fill_value
@@ -51,8 +51,8 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
-    use crate::arrays::BoolArray;
-    use crate::arrays::primitive::PrimitiveArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::primitive::compute::fill_null::BoolArray;
     use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::canonical::ToCanonical;
@@ -63,7 +63,7 @@ mod test {
     fn fill_null_leading_none() {
         let arr = PrimitiveArray::from_option_iter([None, Some(8u8), None, Some(10), None]);
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::from(42u8))
             .unwrap()
             .to_primitive();
@@ -76,7 +76,7 @@ mod test {
         let arr = PrimitiveArray::from_option_iter([Option::<u8>::None, None, None, None, None]);
 
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::from(255u8))
             .unwrap()
             .to_primitive();
@@ -91,7 +91,7 @@ mod test {
             Validity::Array(BoolArray::from_iter([true, true, true, true, true]).into_array()),
         );
         let p = arr
-            .to_array()
+            .into_array()
             .fill_null(Scalar::from(255u8))
             .unwrap()
             .to_primitive();
diff --git a/vortex-array/src/arrays/primitive/compute/is_sorted.rs b/vortex-array/src/arrays/primitive/compute/is_sorted.rs
deleted file mode 100644
index 2d6ab6aa254..00000000000
--- a/vortex-array/src/arrays/primitive/compute/is_sorted.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::compute::IsSortedIteratorExt;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::dtype::NativePType;
-use crate::match_each_native_ptype;
-use crate::register_kernel;
-
-impl IsSortedKernel for PrimitiveVTable {
-    fn is_sorted(&self, array: &PrimitiveArray) -> VortexResult<Option<bool>> {
-        match_each_native_ptype!(array.ptype(), |P| {
-            compute_is_sorted::<P>(array, false).map(Some)
-        })
-    }
-
-    fn is_strict_sorted(&self, array: &PrimitiveArray) -> VortexResult<Option<bool>> {
-        match_each_native_ptype!(array.ptype(), |P| {
-            compute_is_sorted::<P>(array, true).map(Some)
-        })
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(PrimitiveVTable).lift());
-
-#[derive(Copy, Clone)]
-struct ComparablePrimitive<T: NativePType>(T);
-
-impl<T> From<&T> for ComparablePrimitive<T>
-where
-    T: NativePType,
-{
-    fn from(value: &T) -> Self {
-        Self(*value)
-    }
-}
-
-impl<T> PartialOrd for ComparablePrimitive<T>
-where
-    T: NativePType,
-{
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.0.total_compare(other.0))
-    }
-}
-
-impl<T> PartialEq for ComparablePrimitive<T>
-where
-    T: NativePType,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.0.is_eq(other.0)
-    }
-}
-
-fn compute_is_sorted<T: NativePType>(array: &PrimitiveArray, strict: bool) -> VortexResult<bool> {
-    match array.validity_mask()? {
-        Mask::AllFalse(_) => Ok(!strict),
-        Mask::AllTrue(_) => {
-            let slice = array.as_slice::<T>();
-            let iter = slice.iter().map(ComparablePrimitive::from);
-
-            Ok(if strict {
-                iter.is_strict_sorted()
-            } else {
-                iter.is_sorted()
-            })
-        }
-        Mask::Values(mask_values) => {
-            let iter = mask_values
-                .bit_buffer()
-                .iter()
-                .zip_eq(array.as_slice::<T>())
-                .map(|(is_valid, value)| is_valid.then_some(ComparablePrimitive::from(value)));
-
-            Ok(if strict {
-                iter.is_strict_sorted()
-            } else {
-                iter.is_sorted()
-            })
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-    use vortex_error::VortexExpect;
-
-    use super::*;
-    use crate::compute::is_sorted;
-    use crate::compute::is_strict_sorted;
-
-    #[rstest]
-    #[case(PrimitiveArray::from_iter([1, 2, 3, 4, 5]), true)]
-    #[case(PrimitiveArray::from_iter([1, 1, 2, 3, 4, 5]), true)]
-    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(2)]), true)]
-    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1)]), true)]
-    #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
-    fn test_primitive_is_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
-        assert_eq!(
-            is_sorted(array.as_ref()).vortex_expect("operation should succeed in test"),
-            Some(expected)
-        );
-    }
-
-    #[rstest]
-    #[case(PrimitiveArray::from_iter([1, 2, 3, 4, 5]), true)]
-    #[case(PrimitiveArray::from_iter([1, 1, 2, 3, 4, 5]), false)]
-    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(2), None]), false)]
-    #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1), None]), false)]
-    #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
-    fn test_primitive_is_strict_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
-        assert_eq!(
-            is_strict_sorted(array.as_ref()).vortex_expect("operation should succeed in test"),
-            Some(expected)
-        );
-    }
-}
diff --git a/vortex-array/src/arrays/primitive/compute/mask.rs b/vortex-array/src/arrays/primitive/compute/mask.rs
index a03ec99cf50..6768efd6fbf 100644
--- a/vortex-array/src/arrays/primitive/compute/mask.rs
+++ b/vortex-array/src/arrays/primitive/compute/mask.rs
@@ -5,23 +5,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::array::ArrayView;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for PrimitiveVTable {
-    fn mask(array: &PrimitiveArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Primitive {
+    fn mask(array: ArrayView<'_, Primitive>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: validity and data buffer still have same length
         Ok(Some(unsafe {
             PrimitiveArray::new_unchecked_from_handle(
                 array.buffer_handle().clone(),
                 array.ptype(),
-                array
-                    .validity()
-                    .clone()
-                    .and(Validity::Array(mask.clone()))?,
+                array.validity()?.and(Validity::Array(mask.clone()))?,
             )
             .into_array()
         }))
@@ -32,6 +29,7 @@ impl MaskReduce for PrimitiveVTable {
 mod test {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
     use crate::compute::conformance::mask::test_mask_conformance;
 
@@ -44,6 +42,6 @@ mod test {
     #[case(PrimitiveArray::from_iter([0.1f32, 0.2, 0.3, 0.4, 0.5]))]
     #[case(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]))]
     fn test_mask_primitive_conformance(#[case] array: PrimitiveArray) {
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/mod.rs b/vortex-array/src/arrays/primitive/compute/mod.rs
index 91e75d25a10..867ddf69d03 100644
--- a/vortex-array/src/arrays/primitive/compute/mod.rs
+++ b/vortex-array/src/arrays/primitive/compute/mod.rs
@@ -4,18 +4,11 @@
 mod between;
 mod cast;
 mod fill_null;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
-mod nan_count;
 pub(crate) mod rules;
 mod slice;
-mod sum;
 mod take;
 
-pub use is_constant::*;
-
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
@@ -42,7 +35,7 @@ mod tests {
     #[case::i16_negative(PrimitiveArray::from_iter([-100i16, -50, 0, 50, 100]))]
     #[case::f64_special(PrimitiveArray::from_iter([0.0f64, 1.0, -1.0, f64::INFINITY, f64::NEG_INFINITY]))]
     fn test_primitive_consistency(#[case] array: PrimitiveArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 
     #[rstest]
diff --git a/vortex-array/src/arrays/primitive/compute/nan_count.rs b/vortex-array/src/arrays/primitive/compute/nan_count.rs
deleted file mode 100644
index 258333c6054..00000000000
--- a/vortex-array/src/arrays/primitive/compute/nan_count.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::compute::NaNCountKernel;
-use crate::compute::NaNCountKernelAdapter;
-use crate::dtype::NativePType;
-use crate::match_each_float_ptype;
-use crate::register_kernel;
-
-impl NaNCountKernel for PrimitiveVTable {
-    fn nan_count(&self, array: &PrimitiveArray) -> VortexResult<usize> {
-        Ok(match_each_float_ptype!(array.ptype(), |F| {
-            compute_nan_count_with_validity(array.as_slice::<F>(), array.validity_mask()?)
-        }))
-    }
-}
-
-register_kernel!(NaNCountKernelAdapter(PrimitiveVTable).lift());
-
-#[inline]
-fn compute_nan_count_with_validity<T: NativePType>(values: &[T], validity: Mask) -> usize {
-    match validity {
-        Mask::AllTrue(_) => values.iter().filter(|v| v.is_nan()).count(),
-        Mask::AllFalse(_) => 0,
-        Mask::Values(v) => values
-            .iter()
-            .zip(v.bit_buffer().iter())
-            .filter_map(|(v, m)| m.then_some(v))
-            .filter(|v| v.is_nan())
-            .count(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::nan_count;
-    use crate::validity::Validity;
-
-    #[test]
-    fn primitive_nan_count() {
-        let p = PrimitiveArray::new(
-            buffer![
-                -f32::NAN,
-                f32::NAN,
-                0.1,
-                1.1,
-                -0.0,
-                f32::INFINITY,
-                f32::NEG_INFINITY
-            ],
-            Validity::NonNullable,
-        );
-        assert_eq!(nan_count(p.as_ref()).unwrap(), 2);
-    }
-}
diff --git a/vortex-array/src/arrays/primitive/compute/rules.rs b/vortex-array/src/arrays/primitive/compute/rules.rs
index 3539e2d26e8..99b0a7464d5 100644
--- a/vortex-array/src/arrays/primitive/compute/rules.rs
+++ b/vortex-array/src/arrays/primitive/compute/rules.rs
@@ -5,20 +5,19 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::MaskedArray;
-use crate::arrays::MaskedVTable;
+use crate::array::ArrayView;
+use crate::arrays::Masked;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
-use crate::vtable::ValidityHelper;
 
-pub(crate) const RULES: ParentRuleSet<PrimitiveVTable> = ParentRuleSet::new(&[
+pub(crate) const RULES: ParentRuleSet<Primitive> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&PrimitiveMaskedValidityRule),
-    ParentRuleSet::lift(&MaskReduceAdaptor(PrimitiveVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(PrimitiveVTable)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Primitive)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Primitive)),
 ]);
 
 /// Rule to push down validity masking from MaskedArray parent into PrimitiveArray child.
@@ -28,18 +27,18 @@ pub(crate) const RULES: ParentRuleSet<PrimitiveVTable> = ParentRuleSet::new(&[
 #[derive(Default, Debug)]
 pub struct PrimitiveMaskedValidityRule;
 
-impl ArrayParentReduceRule<PrimitiveVTable> for PrimitiveMaskedValidityRule {
-    type Parent = MaskedVTable;
+impl ArrayParentReduceRule<Primitive> for PrimitiveMaskedValidityRule {
+    type Parent = Masked;
 
     fn reduce_parent(
         &self,
-        array: &PrimitiveArray,
-        parent: &MaskedArray,
+        array: ArrayView<'_, Primitive>,
+        parent: ArrayView<'_, Masked>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // TODO(joe): make this lazy
         // Merge the parent's validity mask into the child's validity
-        let new_validity = array.validity().clone().and(parent.validity().clone())?;
+        let new_validity = array.validity()?.and(parent.validity()?)?;
 
         // SAFETY: masking validity does not change PrimitiveArray invariants
         let masked_array = unsafe {
diff --git a/vortex-array/src/arrays/primitive/compute/slice.rs b/vortex-array/src/arrays/primitive/compute/slice.rs
index ac8b26279c8..1830ef3f8c6 100644
--- a/vortex-array/src/arrays/primitive/compute/slice.rs
+++ b/vortex-array/src/arrays/primitive/compute/slice.rs
@@ -7,20 +7,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::SliceReduce;
+use crate::arrays::slice::SliceReduce;
 use crate::dtype::NativePType;
 use crate::match_each_native_ptype;
-use crate::vtable::ValidityHelper;
 
-impl SliceReduce for PrimitiveVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+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)?,
+                array.validity()?.slice(range)?,
             )
             .into_array()
         });
diff --git a/vortex-array/src/arrays/primitive/compute/sum.rs b/vortex-array/src/arrays/primitive/compute/sum.rs
deleted file mode 100644
index 28ecff0a62b..00000000000
--- a/vortex-array/src/arrays/primitive/compute/sum.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use num_traits::CheckedAdd;
-use num_traits::Float;
-use num_traits::ToPrimitive;
-use vortex_buffer::BitBuffer;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_mask::AllOr;
-
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::compute::SumKernel;
-use crate::compute::SumKernelAdapter;
-use crate::dtype::NativePType;
-use crate::dtype::Nullability;
-use crate::match_each_native_ptype;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl SumKernel for PrimitiveVTable {
-    fn sum(&self, array: &PrimitiveArray, accumulator: &Scalar) -> VortexResult<Scalar> {
-        let array_sum_scalar = match array.validity_mask()?.bit_buffer() {
-            AllOr::All => {
-                // All-valid
-                match_each_native_ptype!(
-                    array.ptype(),
-                    unsigned: |T| {
-                        Scalar::from(sum_integer::<_, u64>(
-                            array.as_slice::<T>(),
-                            accumulator.as_primitive().as_::<u64>().vortex_expect("cannot be null"),
-                        ))
-                    },
-                    signed: |T| {
-                        Scalar::from(sum_integer::<_, i64>(
-                            array.as_slice::<T>(),
-                            accumulator.as_primitive().as_::<i64>().vortex_expect("cannot be null"),
-                        ))
-                    },
-                    floating: |T| {
-                        Scalar::primitive(
-                            sum_float(
-                                array.as_slice::<T>(),
-                                accumulator.as_primitive().as_::<f64>().vortex_expect("cannot be null"),
-                            ),
-                            Nullability::Nullable,
-                        )
-                    }
-                )
-            }
-            AllOr::None => {
-                // All-invalid, return accumulator
-                return Ok(accumulator.clone());
-            }
-            AllOr::Some(validity_mask) => {
-                // Some-valid
-                match_each_native_ptype!(
-                    array.ptype(),
-                    unsigned: |T| {
-                        Scalar::from(sum_integer_with_validity::<_, u64>(
-                            array.as_slice::<T>(),
-                            validity_mask,
-                            accumulator.as_primitive().as_::<u64>().vortex_expect("cannot be null"),
-                        ))
-                    },
-                    signed: |T| {
-                        Scalar::from(sum_integer_with_validity::<_, i64>(
-                            array.as_slice::<T>(),
-                            validity_mask,
-                            accumulator.as_primitive().as_::<i64>().vortex_expect("cannot be null"),
-                        ))
-                    },
-                    floating: |T| {
-                        Scalar::primitive(
-                            sum_float_with_validity(
-                                array.as_slice::<T>(),
-                                validity_mask,
-                                accumulator.as_primitive().as_::<f64>().vortex_expect("cannot be null"),
-                            ),
-                            Nullability::Nullable,
-                        )
-                    }
-                )
-            }
-        };
-
-        Ok(array_sum_scalar)
-    }
-}
-
-register_kernel!(SumKernelAdapter(PrimitiveVTable).lift());
-
-fn sum_integer<T: NativePType + ToPrimitive, R: NativePType + CheckedAdd>(
-    values: &[T],
-    accumulator: R,
-) -> Option<R> {
-    let mut sum = accumulator;
-    for &x in values {
-        sum = sum.checked_add(&R::from(x)?)?;
-    }
-    Some(sum)
-}
-
-fn sum_integer_with_validity<T: NativePType + ToPrimitive, R: NativePType + CheckedAdd>(
-    values: &[T],
-    validity: &BitBuffer,
-    accumulator: R,
-) -> Option<R> {
-    let mut sum: R = accumulator;
-    for (&x, valid) in values.iter().zip_eq(validity.iter()) {
-        if valid {
-            sum = sum.checked_add(&R::from(x)?)?;
-        }
-    }
-    Some(sum)
-}
-
-fn sum_float<T: NativePType + Float>(values: &[T], accumulator: f64) -> f64 {
-    let mut sum = accumulator;
-    for &x in values {
-        sum += x.to_f64().vortex_expect("Failed to cast value to f64");
-    }
-    sum
-}
-
-fn sum_float_with_validity<T: NativePType + Float>(
-    array: &[T],
-    validity: &BitBuffer,
-    accumulator: f64,
-) -> f64 {
-    let mut sum = accumulator;
-    for (&x, valid) in array.iter().zip_eq(validity.iter()) {
-        if valid {
-            sum += x.to_f64().vortex_expect("Failed to cast value to f64");
-        }
-    }
-    sum
-}
diff --git a/vortex-array/src/arrays/primitive/compute/take/avx2.rs b/vortex-array/src/arrays/primitive/compute/take/avx2.rs
index 7027bff25dd..e92304dc34b 100644
--- a/vortex-array/src/arrays/primitive/compute/take/avx2.rs
+++ b/vortex-array/src/arrays/primitive/compute/take/avx2.rs
@@ -14,6 +14,7 @@ use std::arch::x86_64::_mm_setzero_si128;
 use std::arch::x86_64::_mm_shuffle_epi32;
 use std::arch::x86_64::_mm_storeu_si128;
 use std::arch::x86_64::_mm_unpacklo_epi64;
+use std::arch::x86_64::_mm256_andnot_si256;
 use std::arch::x86_64::_mm256_cmpgt_epi32;
 use std::arch::x86_64::_mm256_cmpgt_epi64;
 use std::arch::x86_64::_mm256_cvtepu8_epi32;
@@ -39,9 +40,11 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::array::ArrayView;
+use crate::arrays::PrimitiveArray;
 use crate::arrays::primitive::compute::take::TakeImpl;
 use crate::arrays::primitive::compute::take::take_primitive_scalar;
+use crate::arrays::primitive::vtable::Primitive;
 use crate::dtype::NativePType;
 use crate::dtype::PType;
 use crate::dtype::UnsignedPType;
@@ -56,8 +59,8 @@ impl TakeImpl for TakeKernelAVX2 {
     #[inline(always)]
     fn take(
         &self,
-        values: &PrimitiveArray,
-        indices: &PrimitiveArray,
+        values: ArrayView<'_, Primitive>,
+        indices: ArrayView<'_, Primitive>,
         validity: Validity,
     ) -> VortexResult<ArrayRef> {
         assert!(indices.ptype().is_unsigned_int());
@@ -116,9 +119,7 @@ where
 /// # Safety
 ///
 /// The caller must ensure the `avx2` feature is enabled.
-#[allow(dead_code, unused_variables, reason = "TODO(connor): Implement this")]
 #[target_feature(enable = "avx2")]
-#[inline]
 #[doc(hidden)]
 unsafe fn take_avx2<V: NativePType, I: UnsignedPType>(buffer: &[V], indices: &[I]) -> Buffer<V> {
     macro_rules! dispatch_avx2 {
@@ -134,6 +135,10 @@ unsafe fn take_avx2<V: NativePType, I: UnsignedPType>(buffer: &[V], indices: &[I
         }};
     }
 
+    if buffer.is_empty() {
+        return Buffer::zeroed(indices.len());
+    }
+
     match (I::PTYPE, V::PTYPE) {
         // Int value types. Only 32 and 64 bit types are supported.
         (PType::U8, PType::I32) => dispatch_avx2!(u8, i32),
@@ -222,7 +227,7 @@ macro_rules! impl_gather {
                     // Create a vec of the max idx.
                     let max_idx_vec = unsafe { $splat(max_idx as _) };
                     // Create a mask for valid indices (where the max_idx > provided index).
-                    let invalid_mask = unsafe { $mask_indices(max_idx_vec, indices_vec) };
+                    let invalid_mask = unsafe { _mm256_andnot_si256($mask_indices(indices_vec, max_idx_vec), $splat(-1)) };
                     let invalid_mask = {
                         let $mask_var = invalid_mask;
                         $mask_cvt
@@ -578,4 +583,22 @@ mod avx2_tests {
         index_type => u64,
         value_types => u32, i32, u64, i64, f32, f64
     );
+
+    #[test]
+    fn test_avx2_take_last_valid_index_u8() {
+        let values: Vec<i64> = (0..(255 + 1)).collect();
+        let indices: Vec<u8> = vec![255; 20];
+
+        let result = unsafe { take_avx2(&values, &indices) };
+        assert_eq!(&vec![255; indices.len()], result.as_slice());
+    }
+
+    #[test]
+    fn test_avx2_take_last_valid_index_u16() {
+        let values: Vec<i64> = (0..(65535 + 1)).collect();
+        let indices: Vec<u16> = vec![65535; 20];
+
+        let result = unsafe { take_avx2(&values, &indices) };
+        assert_eq!(&vec![65535; indices.len()], result.as_slice());
+    }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/take/mod.rs b/vortex-array/src/arrays/primitive/compute/take/mod.rs
index 994bdda1b71..230595039fa 100644
--- a/vortex-array/src/arrays/primitive/compute/take/mod.rs
+++ b/vortex-array/src/arrays/primitive/compute/take/mod.rs
@@ -14,13 +14,12 @@ use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::TakeExecute;
-use crate::arrays::primitive::PrimitiveArray;
+use crate::array::ArrayView;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::dict::TakeExecute;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
@@ -29,7 +28,6 @@ use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
 use crate::match_each_native_ptype;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 // Kernel selection happens on the first call to `take` and uses a combination of compile-time
 // and runtime feature detection to infer the best kernel for the platform.
@@ -56,8 +54,8 @@ static PRIMITIVE_TAKE_KERNEL: LazyLock<&'static dyn TakeImpl> = LazyLock::new(||
 trait TakeImpl: Send + Sync {
     fn take(
         &self,
-        array: &PrimitiveArray,
-        indices: &PrimitiveArray,
+        array: ArrayView<'_, Primitive>,
+        indices: ArrayView<'_, Primitive>,
         validity: Validity,
     ) -> VortexResult<ArrayRef>;
 }
@@ -68,8 +66,8 @@ struct TakeKernelScalar;
 impl TakeImpl for TakeKernelScalar {
     fn take(
         &self,
-        array: &PrimitiveArray,
-        indices: &PrimitiveArray,
+        array: ArrayView<'_, Primitive>,
+        indices: ArrayView<'_, Primitive>,
         validity: Validity,
     ) -> VortexResult<ArrayRef> {
         match_each_native_ptype!(array.ptype(), |T| {
@@ -81,31 +79,36 @@ impl TakeImpl for TakeKernelScalar {
     }
 }
 
-impl TakeExecute for PrimitiveVTable {
+impl TakeExecute for Primitive {
     fn take(
-        array: &PrimitiveArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, Primitive>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let DType::Primitive(ptype, null) = indices.dtype() else {
             vortex_bail!("Invalid indices dtype: {}", indices.dtype())
         };
 
         let unsigned_indices = if ptype.is_unsigned_int() {
-            indices.to_primitive()
+            indices.clone().execute::<PrimitiveArray>(ctx)?
         } else {
             // This will fail if all values cannot be converted to unsigned
             indices
-                .to_array()
+                .clone()
                 .cast(DType::Primitive(ptype.to_unsigned(), *null))?
-                .to_primitive()
+                .execute::<PrimitiveArray>(ctx)?
         };
 
-        let validity = array.validity().take(unsigned_indices.as_ref())?;
+        let validity = array
+            .validity()?
+            .take(&unsigned_indices.clone().into_array())?;
         // Delegate to the best kernel based on the target CPU
-        PRIMITIVE_TAKE_KERNEL
-            .take(array, &unsigned_indices, validity)
-            .map(Some)
+        {
+            let unsigned_indices = unsigned_indices.as_view();
+            PRIMITIVE_TAKE_KERNEL
+                .take(array, unsigned_indices, validity)
+                .map(Some)
+        }
     }
 }
 
@@ -141,7 +144,6 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_error::VortexExpect;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
@@ -167,7 +169,7 @@ mod test {
             buffer![0, 3, 4],
             Validity::Array(BoolArray::from_iter([true, true, false]).into_array()),
         );
-        let actual = values.take(indices.to_array()).unwrap();
+        let actual = values.take(indices.into_array()).unwrap();
         assert_eq!(
             actual.scalar_at(0).vortex_expect("no fail"),
             Scalar::from(Some(1))
@@ -196,6 +198,6 @@ mod test {
     ))]
     #[case(PrimitiveArray::from_option_iter([Some(1), None, Some(3), Some(4), None]))]
     fn test_take_primitive_conformance(#[case] array: PrimitiveArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/take/portable.rs b/vortex-array/src/arrays/primitive/compute/take/portable.rs
index c3c05af1687..2a9fec9cfb8 100644
--- a/vortex-array/src/arrays/primitive/compute/take/portable.rs
+++ b/vortex-array/src/arrays/primitive/compute/take/portable.rs
@@ -23,8 +23,11 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::arrays::primitive::compute::take::TakeImpl;
+use crate::arrays::primitive::vtable::Primitive;
 use crate::dtype::NativePType;
 use crate::dtype::PType;
 use crate::dtype::UnsignedPType;
@@ -38,8 +41,8 @@ pub(super) struct TakeKernelPortableSimd;
 impl TakeImpl for TakeKernelPortableSimd {
     fn take(
         &self,
-        array: &PrimitiveArray,
-        unsigned_indices: &PrimitiveArray,
+        array: ArrayView<'_, Primitive>,
+        unsigned_indices: ArrayView<'_, Primitive>,
         validity: Validity,
     ) -> VortexResult<ArrayRef> {
         if array.ptype() == PType::F16 {
@@ -79,7 +82,6 @@ const SIMD_WIDTH: usize = 64;
 ///
 /// This function handles the type matching required to satisfy [`simd::SimdElement`] bounds. For
 /// `f16` values, it reinterprets them as `u16` since `f16` doesn't implement `SimdElement`.
-#[inline]
 fn take_portable<T: NativePType, I: UnsignedPType>(buffer: &[T], indices: &[I]) -> Buffer<T> {
     if T::PTYPE == PType::F16 {
         assert_eq!(size_of::<f16>(), size_of::<T>());
@@ -106,7 +108,6 @@ fn take_portable<T: NativePType, I: UnsignedPType>(buffer: &[T], indices: &[I])
 /// Helper that matches on index type and calls [`take_portable_simd`].
 ///
 /// We separate this code out from above to add the [`simd::SimdElement`] constraint.
-#[inline]
 fn take_with_indices<T: NativePType + simd::SimdElement, I: UnsignedPType>(
     buffer: &[T],
     indices: &[I],
diff --git a/vortex-array/src/arrays/primitive/mod.rs b/vortex-array/src/arrays/primitive/mod.rs
index c69209fcdce..4d62f1da517 100644
--- a/vortex-array/src/arrays/primitive/mod.rs
+++ b/vortex-array/src/arrays/primitive/mod.rs
@@ -2,18 +2,18 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::PrimitiveArray;
-pub use array::PrimitiveArrayParts;
+pub use array::PrimitiveArrayExt;
+pub use array::PrimitiveData;
+pub use array::PrimitiveDataParts;
 pub use array::chunk_range;
 pub use array::patch_chunk;
+pub use vtable::PrimitiveArray;
 
 pub(crate) mod compute;
-pub use compute::IS_CONST_LANE_WIDTH;
-pub use compute::compute_is_constant;
 
 mod vtable;
 pub use compute::rules::PrimitiveMaskedValidityRule;
-pub use vtable::PrimitiveVTable;
+pub use vtable::Primitive;
 
 mod native_value;
 pub use native_value::NativeValue;
diff --git a/vortex-array/src/arrays/primitive/tests.rs b/vortex-array/src/arrays/primitive/tests.rs
index 932afe9b6b2..f623479c7b0 100644
--- a/vortex-array/src/arrays/primitive/tests.rs
+++ b/vortex-array/src/arrays/primitive/tests.rs
@@ -35,44 +35,50 @@ fn test_search_sorted_primitive(
 #[test]
 fn test_mask_primitive_array() {
     test_mask_conformance(
-        PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).as_ref(),
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).into_array(),
     );
-    test_mask_conformance(PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).as_ref());
     test_mask_conformance(
-        PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllInvalid).as_ref(),
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).into_array(),
     );
     test_mask_conformance(
-        PrimitiveArray::new(
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllInvalid).into_array(),
+    );
+    test_mask_conformance(
+        &PrimitiveArray::new(
             buffer![0, 1, 2, 3, 4],
             Validity::Array(BoolArray::from_iter([true, false, true, false, true]).into_array()),
         )
-        .as_ref(),
+        .into_array(),
     );
 }
 
 #[test]
 fn test_filter_primitive_array() {
     // Test various sizes
-    test_filter_conformance(PrimitiveArray::new(buffer![42i32], Validity::NonNullable).as_ref());
-    test_filter_conformance(PrimitiveArray::new(buffer![0, 1], Validity::NonNullable).as_ref());
     test_filter_conformance(
-        PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).as_ref(),
+        &PrimitiveArray::new(buffer![42i32], Validity::NonNullable).into_array(),
+    );
+    test_filter_conformance(
+        &PrimitiveArray::new(buffer![0, 1], Validity::NonNullable).into_array(),
+    );
+    test_filter_conformance(
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::NonNullable).into_array(),
     );
     test_filter_conformance(
-        PrimitiveArray::new(buffer![0, 1, 2, 3, 4, 5, 6, 7], Validity::NonNullable).as_ref(),
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4, 5, 6, 7], Validity::NonNullable).into_array(),
     );
 
     // Test with validity
     test_filter_conformance(
-        PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).as_ref(),
+        &PrimitiveArray::new(buffer![0, 1, 2, 3, 4], Validity::AllValid).into_array(),
     );
     test_filter_conformance(
-        PrimitiveArray::new(
+        &PrimitiveArray::new(
             buffer![0, 1, 2, 3, 4, 5],
             Validity::Array(
                 BoolArray::from_iter([true, false, true, false, true, true]).into_array(),
             ),
         )
-        .as_ref(),
+        .into_array(),
     );
 }
diff --git a/vortex-array/src/arrays/primitive/vtable/array.rs b/vortex-array/src/arrays/primitive/vtable/array.rs
deleted file mode 100644
index 2e4e56c6c45..00000000000
--- a/vortex-array/src/arrays/primitive/vtable/array.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use crate::Precision;
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<PrimitiveVTable> for PrimitiveVTable {
-    fn len(array: &PrimitiveArray) -> usize {
-        array.buffer_handle().len() / array.ptype().byte_width()
-    }
-
-    fn dtype(array: &PrimitiveArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &PrimitiveArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: Hasher>(array: &PrimitiveArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.buffer.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &PrimitiveArray, other: &PrimitiveArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.buffer.array_eq(&other.buffer, precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/primitive/vtable/kernel.rs b/vortex-array/src/arrays/primitive/vtable/kernel.rs
index 0f813fe4686..03b6cfa2b98 100644
--- a/vortex-array/src/arrays/primitive/vtable/kernel.rs
+++ b/vortex-array/src/arrays/primitive/vtable/kernel.rs
@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Primitive;
+use crate::arrays::dict::TakeExecuteAdaptor;
 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;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<PrimitiveVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&BetweenExecuteAdaptor(PrimitiveVTable)),
-    ParentKernelSet::lift(&CastExecuteAdaptor(PrimitiveVTable)),
-    ParentKernelSet::lift(&FillNullExecuteAdaptor(PrimitiveVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(PrimitiveVTable)),
+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)),
 ]);
diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs
index 19433eded85..806c95b6a8f 100644
--- a/vortex-array/src/arrays/primitive/vtable/mod.rs
+++ b/vortex-array/src/arrays/primitive/vtable/mod.rs
@@ -2,77 +2,134 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use kernel::PARENT_KERNELS;
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::arrays::PrimitiveArray;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::primitive::PrimitiveData;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::PType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
+
+use std::hash::Hasher;
 
 use vortex_buffer::Alignment;
 use vortex_session::VortexSession;
 
+use crate::Precision;
+use crate::array::ArrayId;
+use crate::arrays::primitive::array::SLOT_NAMES;
 use crate::arrays::primitive::compute::rules::RULES;
-use crate::vtable::ArrayId;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
 
-vtable!(Primitive);
+/// A [`Primitive`]-encoded Vortex array.
+pub type PrimitiveArray = Array<Primitive>;
 
-impl VTable for PrimitiveVTable {
-    type Array = PrimitiveArray;
+impl ArrayHash for PrimitiveData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.buffer.array_hash(state, precision);
+    }
+}
+
+impl ArrayEq for PrimitiveData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.buffer.array_eq(&other.buffer, precision)
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl VTable for Primitive {
+    type ArrayData = PrimitiveData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &PrimitiveArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.buffer_handle().clone(),
+            _ => vortex_panic!("PrimitiveArray buffer index {idx} out of bounds"),
+        }
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("values".to_string()),
+            _ => None,
+        }
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
+    }
+
+    fn validate(
+        &self,
+        data: &PrimitiveData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let DType::Primitive(_, nullability) = dtype else {
+            vortex_bail!("Expected primitive dtype, got {dtype:?}");
+        };
+        vortex_ensure!(
+            data.len() == len,
+            "PrimitiveArray length {} does not match outer length {}",
+            data.len(),
+            len
+        );
+        let validity = crate::array::child_to_validity(&slots[0], *nullability);
+        if let Some(validity_len) = validity.maybe_len() {
+            vortex_ensure!(
+                validity_len == len,
+                "PrimitiveArray validity len {} does not match outer length {}",
+                validity_len,
+                len
+            );
+        }
+
+        Ok(())
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<PrimitiveArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "PrimitiveArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         if buffers.len() != 1 {
             vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
@@ -112,35 +169,21 @@ impl VTable for PrimitiveVTable {
         );
 
         // SAFETY: checked ahead of time
-        unsafe {
-            Ok(PrimitiveArray::new_unchecked_from_handle(
-                buffer, ptype, validity,
-            ))
-        }
+        let slots = PrimitiveData::make_slots(&validity, len);
+        let data = unsafe { PrimitiveData::new_unchecked_from_handle(buffer, ptype, validity) };
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() <= 1,
-            "PrimitiveArray can have at most 1 child (validity), got {}",
-            children.len()
-        );
-
-        array.validity = if children.is_empty() {
-            Validity::from(array.dtype().nullability())
-        } else {
-            Validity::Array(children.into_iter().next().vortex_expect("checked"))
-        };
-
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -148,7 +191,7 @@ impl VTable for PrimitiveVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -157,9 +200,58 @@ impl VTable for PrimitiveVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct PrimitiveVTable;
+#[derive(Clone, Debug)]
+pub struct Primitive;
 
-impl PrimitiveVTable {
+impl Primitive {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.primitive");
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::ByteBufferMut;
+    use vortex_buffer::buffer;
+    use vortex_session::registry::ReadContext;
+
+    use crate::ArrayContext;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
+    use crate::validity::Validity;
+
+    #[test]
+    fn test_nullable_primitive_serde_roundtrip() {
+        let array = PrimitiveArray::new(
+            buffer![1i32, 2, 3, 4],
+            Validity::from_iter([true, false, true, false]),
+        );
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+        let parts = SerializedArray::try_from(concat.freeze()).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
+
+        assert_arrays_eq!(decoded, array);
+    }
+}
diff --git a/vortex-array/src/arrays/primitive/vtable/operations.rs b/vortex-array/src/arrays/primitive/vtable/operations.rs
index 8d45b31f231..ddeaa386485 100644
--- a/vortex-array/src/arrays/primitive/vtable/operations.rs
+++ b/vortex-array/src/arrays/primitive/vtable/operations.rs
@@ -3,14 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Primitive;
 use crate::match_each_native_ptype;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<PrimitiveVTable> for PrimitiveVTable {
-    fn scalar_at(array: &PrimitiveArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Primitive> for Primitive {
+    fn scalar_at(
+        array: ArrayView<'_, Primitive>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(match_each_native_ptype!(array.ptype(), |T| {
             Scalar::primitive(array.as_slice::<T>()[index], array.dtype().nullability())
         }))
diff --git a/vortex-array/src/arrays/primitive/vtable/validity.rs b/vortex-array/src/arrays/primitive/vtable/validity.rs
index 47903e81a09..c6891ba0f4b 100644
--- a/vortex-array/src/arrays/primitive/vtable/validity.rs
+++ b/vortex-array/src/arrays/primitive/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::PrimitiveArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::primitive::PrimitiveArrayExt;
+use crate::arrays::primitive::vtable::Primitive;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for PrimitiveArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<Primitive> for Primitive {
+    fn validity(array: ArrayView<'_, Primitive>) -> VortexResult<Validity> {
+        Ok(PrimitiveArrayExt::validity(&array))
     }
 }
diff --git a/vortex-array/src/arrays/primitive/vtable/visitor.rs b/vortex-array/src/arrays/primitive/vtable/visitor.rs
deleted file mode 100644
index 29634dfb62c..00000000000
--- a/vortex-array/src/arrays/primitive/vtable/visitor.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<PrimitiveVTable> for PrimitiveVTable {
-    fn visit_buffers(array: &PrimitiveArray, visitor: &mut dyn ArrayBufferVisitor) {
-        visitor.visit_buffer_handle("values", array.buffer_handle());
-    }
-
-    fn nbuffers(_array: &PrimitiveArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &PrimitiveArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &PrimitiveArray) -> usize {
-        validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &PrimitiveArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/scalar_fn/array.rs b/vortex-array/src/arrays/scalar_fn/array.rs
index b91592d3e84..301713761b5 100644
--- a/vortex-array/src/arrays/scalar_fn/array.rs
+++ b/vortex-array/src/arrays/scalar_fn/array.rs
@@ -1,52 +1,106 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::dtype::DType;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::ScalarFnVTable;
 use crate::scalar_fn::ScalarFnRef;
-use crate::stats::ArrayStats;
+
+// ScalarFnArray has a variable number of slots (one per child)
 
 #[derive(Clone, Debug)]
-pub struct ScalarFnArray {
+pub struct ScalarFnData {
     pub(super) scalar_fn: ScalarFnRef,
-    pub(super) dtype: DType,
-    pub(super) len: usize,
-    pub(super) children: Vec<ArrayRef>,
-    pub(super) stats: ArrayStats,
 }
 
-impl ScalarFnArray {
-    /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn try_new(bound: ScalarFnRef, children: Vec<ArrayRef>, len: usize) -> VortexResult<Self> {
-        let arg_dtypes: Vec<_> = children.iter().map(|c| c.dtype().clone()).collect();
-        let dtype = bound.return_dtype(&arg_dtypes)?;
+impl Display for ScalarFnData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "scalar_fn: {}", self.scalar_fn)
+    }
+}
 
+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: bound,
-            dtype,
-            len,
-            children,
-            stats: Default::default(),
-        })
+        Ok(Self { scalar_fn })
     }
 
     /// Get the scalar function bound to this array.
     #[allow(clippy::same_name_method)]
+    #[inline(always)]
     pub fn scalar_fn(&self) -> &ScalarFnRef {
         &self.scalar_fn
     }
+}
+
+pub trait ScalarFnArrayExt: TypedArrayRef<ScalarFnVTable> {
+    fn scalar_fn(&self) -> &ScalarFnRef {
+        &self.scalar_fn
+    }
+
+    fn child_at(&self, idx: usize) -> &ArrayRef {
+        self.as_ref().slots()[idx]
+            .as_ref()
+            .vortex_expect("ScalarFnArray child slot")
+    }
 
-    /// Get the children arrays of this scalar function array.
-    pub fn children(&self) -> &[ArrayRef] {
-        &self.children
+    fn child_count(&self) -> usize {
+        self.as_ref().slots().len()
+    }
+
+    #[allow(clippy::same_name_method)]
+    fn nchildren(&self) -> usize {
+        self.child_count()
+    }
+
+    #[allow(clippy::same_name_method)]
+    fn get_child(&self, idx: usize) -> &ArrayRef {
+        self.child_at(idx)
+    }
+
+    fn iter_children(&self) -> impl Iterator<Item = &ArrayRef> + '_ {
+        (0..self.child_count()).map(|idx| self.child_at(idx))
+    }
+
+    fn children(&self) -> Vec<ArrayRef> {
+        self.iter_children().cloned().collect()
+    }
+}
+impl<T: TypedArrayRef<ScalarFnVTable>> ScalarFnArrayExt for T {}
+
+impl Array<ScalarFnVTable> {
+    /// Create a new ScalarFnArray from a scalar function and its children.
+    pub fn try_new(
+        scalar_fn: ScalarFnRef,
+        children: Vec<ArrayRef>,
+        len: usize,
+    ) -> VortexResult<Self> {
+        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 vtable = ScalarFnVTable { scalar_fn };
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(vtable, dtype, len, data)
+                    .with_slots(children.into_iter().map(Some).collect()),
+            )
+        })
     }
 }
diff --git a/vortex-array/src/arrays/scalar_fn/metadata.rs b/vortex-array/src/arrays/scalar_fn/metadata.rs
deleted file mode 100644
index 8a0817bf089..00000000000
--- a/vortex-array/src/arrays/scalar_fn/metadata.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Debug;
-use std::fmt::Formatter;
-
-use crate::dtype::DType;
-use crate::scalar_fn::ScalarFnRef;
-
-#[derive(Clone)]
-pub struct ScalarFnMetadata {
-    pub(super) scalar_fn: ScalarFnRef,
-    pub(super) child_dtypes: Vec<DType>,
-}
-
-// Array tree display wrongly uses debug...
-impl Debug for ScalarFnMetadata {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.scalar_fn.options())
-    }
-}
diff --git a/vortex-array/src/arrays/scalar_fn/mod.rs b/vortex-array/src/arrays/scalar_fn/mod.rs
index 781170596fa..9d2e9e66ed8 100644
--- a/vortex-array/src/arrays/scalar_fn/mod.rs
+++ b/vortex-array/src/arrays/scalar_fn/mod.rs
@@ -2,10 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-mod metadata;
 mod rules;
-mod slice;
 mod vtable;
 
-pub use array::*;
+pub use array::ScalarFnArrayExt;
+pub use array::ScalarFnData;
+pub use vtable::ScalarFnFactoryExt;
 pub use vtable::*;
diff --git a/vortex-array/src/arrays/scalar_fn/rules.rs b/vortex-array/src/arrays/scalar_fn/rules.rs
index 61d2e17d1ee..d0cb0efdbf4 100644
--- a/vortex-array/src/arrays/scalar_fn/rules.rs
+++ b/vortex-array/src/arrays/scalar_fn/rules.rs
@@ -8,18 +8,18 @@ use itertools::Itertools;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::FilterArray;
-use crate::arrays::FilterVTable;
+use crate::arrays::Filter;
 use crate::arrays::ScalarFnArray;
 use crate::arrays::ScalarFnVTable;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Slice;
 use crate::arrays::StructArray;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::dtype::DType;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ArrayReduceRule;
@@ -40,15 +40,15 @@ pub(super) const RULES: ReduceRuleSet<ScalarFnVTable> = ReduceRuleSet::new(&[
 
 pub(super) const PARENT_RULES: ParentRuleSet<ScalarFnVTable> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&ScalarFnUnaryFilterPushDownRule),
-    ParentRuleSet::lift(&SliceReduceAdaptor(ScalarFnVTable)),
+    ParentRuleSet::lift(&ScalarFnSliceReduceRule),
 ]);
 
 /// Converts a ScalarFnArray with Pack into a StructArray directly.
 #[derive(Debug)]
 struct ScalarFnPackToStructRule;
 impl ArrayReduceRule<ScalarFnVTable> for ScalarFnPackToStructRule {
-    fn reduce(&self, array: &ScalarFnArray) -> VortexResult<Option<ArrayRef>> {
-        let Some(pack_options) = array.scalar_fn.as_opt::<Pack>() else {
+    fn reduce(&self, array: ArrayView<'_, ScalarFnVTable>) -> VortexResult<Option<ArrayRef>> {
+        let Some(pack_options) = array.scalar_fn().as_opt::<Pack>() else {
             return Ok(None);
         };
 
@@ -60,8 +60,8 @@ impl ArrayReduceRule<ScalarFnVTable> for ScalarFnPackToStructRule {
         Ok(Some(
             StructArray::try_new(
                 pack_options.names.clone(),
-                array.children.clone(),
-                array.len,
+                array.children(),
+                array.len(),
                 validity,
             )?
             .into_array(),
@@ -72,26 +72,50 @@ impl ArrayReduceRule<ScalarFnVTable> for ScalarFnPackToStructRule {
 #[derive(Debug)]
 struct ScalarFnConstantRule;
 impl ArrayReduceRule<ScalarFnVTable> for ScalarFnConstantRule {
-    fn reduce(&self, array: &ScalarFnArray) -> VortexResult<Option<ArrayRef>> {
-        if !array.children.iter().all(|c| c.is::<ConstantVTable>()) {
+    fn reduce(&self, array: ArrayView<'_, ScalarFnVTable>) -> VortexResult<Option<ArrayRef>> {
+        if !array.children().iter().all(|c| c.is::<Constant>()) {
             return Ok(None);
         }
         if array.is_empty() {
             Ok(Some(Canonical::empty(array.dtype()).into_array()))
         } else {
-            let result = array.scalar_at(0)?;
-            Ok(Some(ConstantArray::new(result, array.len).into_array()))
+            let result = array.array().scalar_at(0)?;
+            Ok(Some(ConstantArray::new(result, array.len()).into_array()))
         }
     }
 }
 
+#[derive(Debug)]
+struct ScalarFnSliceReduceRule;
+impl ArrayParentReduceRule<ScalarFnVTable> for ScalarFnSliceReduceRule {
+    type Parent = Slice;
+
+    fn reduce_parent(
+        &self,
+        array: ArrayView<'_, ScalarFnVTable>,
+        parent: ArrayView<'_, Slice>,
+        _child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let range = parent.slice_range();
+
+        let children: Vec<_> = array
+            .iter_children()
+            .map(|c| c.slice(range.clone()))
+            .collect::<VortexResult<_>>()?;
+
+        Ok(Some(
+            ScalarFnArray::try_new(array.scalar_fn().clone(), children, range.len())?.into_array(),
+        ))
+    }
+}
+
 #[derive(Debug)]
 struct ScalarFnAbstractReduceRule;
 impl ArrayReduceRule<ScalarFnVTable> for ScalarFnAbstractReduceRule {
-    fn reduce(&self, array: &ScalarFnArray) -> VortexResult<Option<ArrayRef>> {
+    fn reduce(&self, array: ArrayView<'_, ScalarFnVTable>) -> VortexResult<Option<ArrayRef>> {
         if let Some(reduced) = array
-            .scalar_fn
-            .reduce(array, &ArrayReduceCtx { len: array.len })?
+            .scalar_fn()
+            .reduce(array.as_ref(), &ArrayReduceCtx { len: array.len() })?
         {
             return Ok(Some(
                 reduced
@@ -105,48 +129,26 @@ impl ArrayReduceRule<ScalarFnVTable> for ScalarFnAbstractReduceRule {
     }
 }
 
-impl ReduceNode for ScalarFnArray {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn node_dtype(&self) -> VortexResult<DType> {
-        Ok(self.dtype().clone())
-    }
-
-    #[allow(clippy::same_name_method)]
-    fn scalar_fn(&self) -> Option<&ScalarFnRef> {
-        Some(ScalarFnArray::scalar_fn(self))
-    }
-
-    fn child(&self, idx: usize) -> ReduceNodeRef {
-        Arc::new(self.children()[idx].clone())
-    }
-
-    fn child_count(&self) -> usize {
-        self.children.len()
-    }
-}
-
 impl ReduceNode for ArrayRef {
     fn as_any(&self) -> &dyn Any {
         self
     }
 
     fn node_dtype(&self) -> VortexResult<DType> {
-        self.as_ref().node_dtype()
+        Ok(self.dtype().clone())
     }
 
     fn scalar_fn(&self) -> Option<&ScalarFnRef> {
-        self.as_ref().scalar_fn()
+        self.as_opt::<ScalarFnVTable>()
+            .map(|a| a.data().scalar_fn())
     }
 
     fn child(&self, idx: usize) -> ReduceNodeRef {
-        self.as_ref().child(idx)
+        Arc::new(self.nth_child(idx).vortex_expect("child idx out of bounds"))
     }
 
     fn child_count(&self) -> usize {
-        self.as_ref().child_count()
+        self.nchildren()
     }
 }
 
@@ -183,27 +185,25 @@ impl ReduceCtx for ArrayReduceCtx {
 struct ScalarFnUnaryFilterPushDownRule;
 
 impl ArrayParentReduceRule<ScalarFnVTable> for ScalarFnUnaryFilterPushDownRule {
-    type Parent = FilterVTable;
+    type Parent = Filter;
 
     fn reduce_parent(
         &self,
-        child: &ScalarFnArray,
-        parent: &FilterArray,
+        child: ArrayView<'_, ScalarFnVTable>,
+        parent: ArrayView<'_, Filter>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         // If we only have one non-constant child, then it is _always_ cheaper to push down the
         // filter over the children of the scalar function array.
         if child
-            .children
-            .iter()
-            .filter(|c| !c.is::<ConstantVTable>())
+            .iter_children()
+            .filter(|c| !c.is::<Constant>())
             .count()
             == 1
         {
             let new_children: Vec<_> = child
-                .children
-                .iter()
-                .map(|c| match c.as_opt::<ConstantVTable>() {
+                .iter_children()
+                .map(|c| match c.as_opt::<Constant>() {
                     Some(array) => {
                         Ok(ConstantArray::new(array.scalar().clone(), parent.len()).into_array())
                     }
@@ -212,7 +212,7 @@ impl ArrayParentReduceRule<ScalarFnVTable> for ScalarFnUnaryFilterPushDownRule {
                 .try_collect()?;
 
             let new_array =
-                ScalarFnArray::try_new(child.scalar_fn.clone(), new_children, parent.len())?
+                ScalarFnArray::try_new(child.scalar_fn().clone(), new_children, parent.len())?
                     .into_array();
 
             return Ok(Some(new_array));
@@ -228,8 +228,8 @@ mod tests {
 
     use crate::array::IntoArray;
     use crate::arrays::ChunkedArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::scalar_fn::rules::ConstantArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -253,7 +253,7 @@ mod tests {
             DType::Primitive(PType::U64, Nullability::Nullable),
         )
         .vortex_expect("construction")
-        .to_array();
+        .into_array();
 
         let expr = is_null(root());
         array.apply(&expr).vortex_expect("expr evaluation");
diff --git a/vortex-array/src/arrays/scalar_fn/slice.rs b/vortex-array/src/arrays/scalar_fn/slice.rs
deleted file mode 100644
index d53204c0d03..00000000000
--- a/vortex-array/src/arrays/scalar_fn/slice.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::ops::Range;
-
-use vortex_error::VortexResult;
-
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::arrays::ScalarFnArray;
-use crate::arrays::ScalarFnVTable;
-use crate::arrays::SliceReduce;
-
-impl SliceReduce for ScalarFnVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let children: Vec<_> = array
-            .children()
-            .iter()
-            .map(|c| c.slice(range.clone()))
-            .collect::<VortexResult<_>>()?;
-
-        Ok(Some(
-            ScalarFnArray {
-                scalar_fn: array.scalar_fn.clone(),
-                dtype: array.dtype.clone(),
-                len: range.len(),
-                children,
-                stats: Default::default(),
-            }
-            .into_array(),
-        ))
-    }
-}
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/array.rs b/vortex-array/src/arrays/scalar_fn/vtable/array.rs
deleted file mode 100644
index 28f7503db68..00000000000
--- a/vortex-array/src/arrays/scalar_fn/vtable/array.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use crate::ArrayEq;
-use crate::ArrayHash;
-use crate::Precision;
-use crate::arrays::scalar_fn::array::ScalarFnArray;
-use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
-use crate::dtype::DType;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<ScalarFnVTable> for ScalarFnVTable {
-    fn len(array: &ScalarFnArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &ScalarFnArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ScalarFnArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: Hasher>(array: &ScalarFnArray, state: &mut H, precision: Precision) {
-        array.len.hash(state);
-        array.dtype.hash(state);
-        array.scalar_fn.hash(state);
-        for child in &array.children {
-            child.array_hash(state, precision);
-        }
-    }
-
-    fn array_eq(array: &ScalarFnArray, other: &ScalarFnArray, precision: Precision) -> bool {
-        if array.len != other.len {
-            return false;
-        }
-        if array.dtype != other.dtype {
-            return false;
-        }
-        if array.scalar_fn != other.scalar_fn {
-            return false;
-        }
-        for (child, other_child) in array.children.iter().zip(other.children.iter()) {
-            if !child.array_eq(other_child, precision) {
-                return false;
-            }
-        }
-        true
-    }
-}
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
index e3562883cd8..996fbee1046 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
@@ -1,11 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-mod array;
 mod operations;
 mod validity;
-mod visitor;
-
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hash;
@@ -14,22 +10,30 @@ use std::marker::PhantomData;
 use std::ops::Deref;
 
 use itertools::Itertools;
-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 crate::Array;
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::scalar_fn::array::ScalarFnArray;
-use crate::arrays::scalar_fn::metadata::ScalarFnMetadata;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::scalar_fn::array::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::array::ScalarFnData;
 use crate::arrays::scalar_fn::rules::PARENT_RULES;
 use crate::arrays::scalar_fn::rules::RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
 use crate::expr::Expression;
 use crate::matcher::Matcher;
 use crate::scalar_fn;
@@ -37,112 +41,125 @@ use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
 use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::ScalarFnId;
+use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::ScalarFnVTableExt;
+use crate::scalar_fn::VecExecutionArgs;
 use crate::serde::ArrayChildren;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
 
-vtable!(ScalarFn);
+/// A [`ScalarFnVTable`]-encoded Vortex array.
+pub type ScalarFnArray = Array<ScalarFnVTable>;
 
 #[derive(Clone, Debug)]
-pub struct ScalarFnVTable;
+pub struct ScalarFnVTable {
+    pub(super) scalar_fn: ScalarFnRef,
+}
+
+impl ArrayHash for ScalarFnData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.scalar_fn().hash(state);
+    }
+}
+
+impl ArrayEq for ScalarFnData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.scalar_fn() == other.scalar_fn()
+    }
+}
 
 impl VTable for ScalarFnVTable {
-    type Array = ScalarFnArray;
-    type Metadata = ScalarFnMetadata;
-    type ArrayVTable = Self;
+    type ArrayData = ScalarFnData;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(array: &Self::Array) -> ArrayId {
-        array.scalar_fn.id()
+    fn id(&self) -> ArrayId {
+        self.scalar_fn.id()
     }
 
-    fn metadata(array: &Self::Array) -> VortexResult<Self::Metadata> {
-        let child_dtypes = array.children().iter().map(|c| c.dtype().clone()).collect();
-        Ok(ScalarFnMetadata {
-            scalar_fn: array.scalar_fn.clone(),
-            child_dtypes,
-        })
+    fn validate(
+        &self,
+        data: &ScalarFnData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            data.scalar_fn == self.scalar_fn,
+            "ScalarFnArray data scalar_fn does not match vtable"
+        );
+        vortex_ensure!(
+            slots.iter().flatten().all(|c| c.len() == len),
+            "All child arrays must have the same length as the scalar function array"
+        );
+
+        let child_dtypes = slots
+            .iter()
+            .flatten()
+            .map(|c| c.dtype().clone())
+            .collect_vec();
+        vortex_ensure!(
+            self.scalar_fn.return_dtype(&child_dtypes)? == *dtype,
+            "ScalarFnArray dtype does not match scalar function return dtype"
+        );
+        Ok(())
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("ScalarFnArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
         // Not supported
         Ok(None)
     }
 
     fn deserialize(
-        _bytes: &[u8],
+        &self,
         _dtype: &DType,
         _len: usize,
+        _metadata: &[u8],
+
         _buffers: &[BufferHandle],
+        _children: &dyn ArrayChildren,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
+    ) -> VortexResult<ArrayParts<Self>> {
         vortex_bail!("Deserialization of ScalarFnVTable metadata is not supported");
     }
 
-    fn build(
-        dtype: &DType,
-        len: usize,
-        metadata: &ScalarFnMetadata,
-        _buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-    ) -> VortexResult<Self::Array> {
-        let children: Vec<_> = metadata
-            .child_dtypes
-            .iter()
-            .enumerate()
-            .map(|(idx, child_dtype)| children.get(idx, child_dtype, len))
-            .try_collect()?;
-
-        #[cfg(debug_assertions)]
-        {
-            let child_dtypes: Vec<_> = children.iter().map(|c| c.dtype().clone()).collect();
-            vortex_error::vortex_ensure!(
-                &metadata.scalar_fn.return_dtype(&child_dtypes)? == dtype,
-                "Return dtype mismatch when building ScalarFnArray"
-            );
-        }
-
-        Ok(ScalarFnArray {
-            // This requires a new Arc, but we plan to remove this later anyway.
-            scalar_fn: metadata.scalar_fn.clone(),
-            dtype: dtype.clone(),
-            len,
-            children,
-            stats: Default::default(),
-        })
+    fn slot_name(array: ArrayView<'_, Self>, idx: usize) -> String {
+        array
+            .scalar_fn()
+            .signature()
+            .child_name(idx)
+            .as_ref()
+            .to_string()
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == array.children.len(),
-            "ScalarFnArray expects {} children, got {}",
-            array.children.len(),
-            children.len()
-        );
-        array.children = children;
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        ctx.log(format_args!("scalar_fn({}): executing", array.scalar_fn));
-        let args = ExecutionArgs {
-            inputs: array.children.clone(),
-            row_count: array.len,
-            ctx,
-        };
-        array.scalar_fn.execute(args)
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        ctx.log(format_args!("scalar_fn({}): executing", array.scalar_fn()));
+        let args = VecExecutionArgs::new(array.children(), array.len());
+        array
+            .scalar_fn()
+            .execute(&args, ctx)
+            .map(ExecutionResult::done)
     }
 
-    fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
+    fn reduce(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>> {
         RULES.evaluate(array)
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -151,7 +168,7 @@ impl VTable for ScalarFnVTable {
 }
 
 /// Array factory functions for scalar functions.
-pub trait ScalarFnArrayExt: scalar_fn::ScalarFnVTable {
+pub trait ScalarFnFactoryExt: scalar_fn::ScalarFnVTable {
     fn try_new_array(
         &self,
         len: usize,
@@ -169,25 +186,32 @@ pub trait ScalarFnArrayExt: scalar_fn::ScalarFnVTable {
         let child_dtypes = children.iter().map(|c| c.dtype().clone()).collect_vec();
         let dtype = scalar_fn.return_dtype(&child_dtypes)?;
 
-        Ok(ScalarFnArray {
-            scalar_fn,
-            dtype,
-            len,
-            children,
-            stats: Default::default(),
+        let data = ScalarFnData {
+            scalar_fn: scalar_fn.clone(),
+        };
+        let vtable = ScalarFnVTable { scalar_fn };
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(vtable, dtype, len, data)
+                    .with_slots(children.into_iter().map(Some).collect()),
+            )
         }
         .into_array())
     }
 }
-impl<V: scalar_fn::ScalarFnVTable> ScalarFnArrayExt for V {}
+impl<V: scalar_fn::ScalarFnVTable> ScalarFnFactoryExt for V {}
 
 /// A matcher that matches any scalar function expression.
 #[derive(Debug)]
 pub struct AnyScalarFn;
 impl Matcher for AnyScalarFn {
-    type Match<'a> = &'a ScalarFnArray;
+    type Match<'a> = ArrayView<'a, ScalarFnVTable>;
+
+    fn matches(array: &ArrayRef) -> bool {
+        array.is::<ScalarFnVTable>()
+    }
 
-    fn try_match(array: &dyn Array) -> Option<Self::Match<'_>> {
+    fn try_match(array: &ArrayRef) -> Option<Self::Match<'_>> {
         array.as_opt::<ScalarFnVTable>()
     }
 }
@@ -199,40 +223,34 @@ pub struct ExactScalarFn<F: scalar_fn::ScalarFnVTable>(PhantomData<F>);
 impl<F: scalar_fn::ScalarFnVTable> Matcher for ExactScalarFn<F> {
     type Match<'a> = ScalarFnArrayView<'a, F>;
 
-    fn matches(array: &dyn Array) -> bool {
+    fn matches(array: &ArrayRef) -> bool {
         if let Some(scalar_fn_array) = array.as_opt::<ScalarFnVTable>() {
-            scalar_fn_array.scalar_fn().is::<F>()
+            scalar_fn_array.data().scalar_fn().is::<F>()
         } else {
             false
         }
     }
 
-    fn try_match(array: &dyn Array) -> Option<Self::Match<'_>> {
+    fn try_match(array: &ArrayRef) -> Option<Self::Match<'_>> {
         let scalar_fn_array = array.as_opt::<ScalarFnVTable>()?;
-        let scalar_fn_vtable = scalar_fn_array
-            .scalar_fn
-            .vtable_ref::<F>()
-            .vortex_expect("ScalarFn VTable type mismatch in ExactScalarFn matcher");
-        let scalar_fn_options = scalar_fn_array
-            .scalar_fn
-            .as_opt::<F>()
-            .vortex_expect("ScalarFn options type mismatch in ExactScalarFn matcher");
+        let scalar_fn_data = scalar_fn_array.data();
+        let scalar_fn = scalar_fn_data.scalar_fn().downcast_ref::<F>()?;
         Some(ScalarFnArrayView {
             array,
-            vtable: scalar_fn_vtable,
-            options: scalar_fn_options,
+            vtable: scalar_fn.vtable(),
+            options: scalar_fn.options(),
         })
     }
 }
 
 pub struct ScalarFnArrayView<'a, F: scalar_fn::ScalarFnVTable> {
-    array: &'a dyn Array,
+    array: &'a ArrayRef,
     pub vtable: &'a F,
     pub options: &'a F::Options,
 }
 
 impl<F: scalar_fn::ScalarFnVTable> Deref for ScalarFnArrayView<'_, F> {
-    type Target = dyn Array;
+    type Target = ArrayRef;
 
     fn deref(&self) -> &Self::Target {
         self.array
@@ -292,8 +310,13 @@ impl scalar_fn::ScalarFnVTable for ArrayExpr {
         Ok(options.0.dtype().clone())
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        crate::Executable::execute(options.0.clone(), args.ctx)
+    fn execute(
+        &self,
+        options: &Self::Options,
+        _args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        crate::Executable::execute(options.0.clone(), ctx)
     }
 
     fn validity(
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
index df94e16f3a6..bcb0368772a 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
@@ -3,52 +3,53 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
 use crate::arrays::ConstantArray;
-use crate::arrays::scalar_fn::array::ScalarFnArray;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
 use crate::columnar::Columnar;
 use crate::scalar::Scalar;
-use crate::scalar_fn::ExecutionArgs;
-use crate::vtable::OperationsVTable;
+use crate::scalar_fn::VecExecutionArgs;
 
 impl OperationsVTable<ScalarFnVTable> for ScalarFnVTable {
-    fn scalar_at(array: &ScalarFnArray, index: usize) -> VortexResult<Scalar> {
+    fn scalar_at(
+        array: ArrayView<'_, ScalarFnVTable>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         let inputs: Vec<_> = array
-            .children
+            .children()
             .iter()
             .map(|child| Ok(ConstantArray::new(child.scalar_at(index)?, 1).into_array()))
             .collect::<VortexResult<_>>()?;
 
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
-        let args = ExecutionArgs {
-            inputs,
-            row_count: 1,
-            ctx: &mut ctx,
-        };
-        let result = array.scalar_fn.execute(args)?;
+        let args = VecExecutionArgs::new(inputs, 1);
+        let result = array.scalar_fn().execute(&args, &mut ctx)?;
 
         let scalar = match result.execute::<Columnar>(&mut ctx)? {
             Columnar::Canonical(arr) => {
                 tracing::info!(
                     "Scalar function {} returned non-constant array from execution over all scalar inputs",
-                    array.scalar_fn,
+                    array.scalar_fn(),
                 );
-                arr.as_ref().scalar_at(0)?
+                arr.into_array().scalar_at(0)?
             }
             Columnar::Constant(constant) => constant.scalar().clone(),
         };
 
         debug_assert_eq!(
             scalar.dtype(),
-            &array.dtype,
+            array.dtype(),
             "Scalar function {} returned dtype {:?} but expected {:?}",
-            array.scalar_fn,
+            array.scalar_fn(),
             scalar.dtype(),
-            array.dtype
+            array.dtype()
         );
 
         Ok(scalar)
@@ -63,7 +64,7 @@ mod tests {
     use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::scalar_fn::array::ScalarFnArray;
+    use crate::arrays::ScalarFnArray;
     use crate::assert_arrays_eq;
     use crate::scalar_fn::ScalarFn;
     use crate::scalar_fn::fns::binary::Binary;
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/validity.rs b/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
index 29695a68643..2884530f8ba 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
@@ -7,18 +7,19 @@ use crate::ArrayRef;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
-use crate::arrays::scalar_fn::array::ScalarFnArray;
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::arrays::scalar_fn::vtable::ArrayExpr;
 use crate::arrays::scalar_fn::vtable::FakeEq;
 use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
 use crate::expr::Expression;
 use crate::expr::lit;
-use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::ScalarFn;
+use crate::scalar_fn::VecExecutionArgs;
 use crate::scalar_fn::fns::literal::Literal;
 use crate::scalar_fn::fns::root::Root;
 use crate::validity::Validity;
-use crate::vtable::ValidityVTable;
 
 /// Execute an expression tree recursively.
 ///
@@ -44,20 +45,15 @@ fn execute_expr(expr: &Expression, row_count: usize) -> VortexResult<ArrayRef> {
         .map(|child| execute_expr(child, row_count))
         .collect::<VortexResult<_>>()?;
 
-    let args = ExecutionArgs {
-        inputs,
-        row_count,
-        ctx: &mut ctx,
-    };
+    let args = VecExecutionArgs::new(inputs, row_count);
 
-    Ok(expr.scalar_fn().execute(args)?.into_array())
+    Ok(expr.scalar_fn().execute(&args, &mut ctx)?.into_array())
 }
 
 impl ValidityVTable<ScalarFnVTable> for ScalarFnVTable {
-    fn validity(array: &ScalarFnArray) -> VortexResult<Validity> {
+    fn validity(array: ArrayView<'_, ScalarFnVTable>) -> VortexResult<Validity> {
         let inputs: Vec<_> = array
-            .children
-            .iter()
+            .iter_children()
             .map(|child| {
                 if let Some(scalar) = child.as_constant() {
                     return Ok(lit(scalar));
@@ -66,7 +62,7 @@ impl ValidityVTable<ScalarFnVTable> for ScalarFnVTable {
             })
             .collect::<VortexResult<_>>()?;
 
-        let expr = Expression::try_new(array.scalar_fn.clone(), inputs)?;
+        let expr = Expression::try_new(array.scalar_fn().clone(), inputs)?;
         let validity_expr = array.scalar_fn().validity(&expr)?;
 
         // Execute the validity expression. All leaves are ArrayExpr nodes.
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/visitor.rs b/vortex-array/src/arrays/scalar_fn/vtable/visitor.rs
deleted file mode 100644
index 24289f6945a..00000000000
--- a/vortex-array/src/arrays/scalar_fn/vtable/visitor.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayChildVisitorUnnamed;
-use crate::ArrayRef;
-use crate::arrays::scalar_fn::array::ScalarFnArray;
-use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
-use crate::vtable::VisitorVTable;
-
-impl VisitorVTable<ScalarFnVTable> for ScalarFnVTable {
-    fn visit_buffers(_array: &ScalarFnArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &ScalarFnArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &ScalarFnArray, visitor: &mut dyn ArrayChildVisitor) {
-        for (idx, child) in array.children.iter().enumerate() {
-            let name = array.scalar_fn.signature().child_name(idx);
-            visitor.visit_child(name.as_ref(), child)
-        }
-    }
-
-    fn visit_children_unnamed(array: &ScalarFnArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
-        for child in array.children.iter() {
-            visitor.visit_child(child);
-        }
-    }
-
-    fn nchildren(array: &ScalarFnArray) -> usize {
-        array.children.len()
-    }
-
-    fn nth_child(array: &ScalarFnArray, idx: usize) -> Option<ArrayRef> {
-        array.children.get(idx).cloned()
-    }
-}
diff --git a/vortex-array/src/arrays/shared/array.rs b/vortex-array/src/arrays/shared/array.rs
index c69ae39395d..37d704db4d1 100644
--- a/vortex-array/src/arrays/shared/array.rs
+++ b/vortex-array/src/arrays/shared/array.rs
@@ -1,88 +1,87 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::future::Future;
 use std::sync::Arc;
 use std::sync::OnceLock;
 
 use async_lock::Mutex as AsyncMutex;
 use vortex_error::SharedVortexResult;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
-use crate::dtype::DType;
-use crate::stats::ArrayStats;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Shared;
+
+/// The source array that is shared and lazily computed.
+pub(super) const SOURCE_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["source"];
 
 /// A lazily-executing array wrapper with a one-way transition from source to cached form.
 ///
 /// Before materialization, operations delegate to the source array.
 /// After materialization (via `get_or_compute`), operations delegate to the cached result.
 #[derive(Debug, Clone)]
-pub struct SharedArray {
-    source: ArrayRef,
+pub struct SharedData {
     cached: Arc<OnceLock<SharedVortexResult<ArrayRef>>>,
     async_compute_lock: Arc<AsyncMutex<()>>,
-    pub(super) dtype: DType,
-    pub(super) stats: ArrayStats,
 }
 
-impl SharedArray {
-    pub fn new(source: ArrayRef) -> Self {
-        Self {
-            dtype: source.dtype().clone(),
-            source,
-            cached: Arc::new(OnceLock::new()),
-            async_compute_lock: Arc::new(AsyncMutex::new(())),
-            stats: ArrayStats::default(),
-        }
+impl Display for SharedData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+#[allow(async_fn_in_trait)]
+pub trait SharedArrayExt: TypedArrayRef<Shared> {
+    fn source(&self) -> &ArrayRef {
+        self.as_ref().slots()[SOURCE_SLOT]
+            .as_ref()
+            .vortex_expect("validated shared source slot")
     }
 
-    /// Returns the current array reference.
-    ///
-    /// After materialization, returns the cached result. Otherwise, returns the source.
-    /// If materialization failed, falls back to the source.
-    pub(super) fn current_array_ref(&self) -> &ArrayRef {
+    fn current_array_ref(&self) -> &ArrayRef {
         match self.cached.get() {
             Some(Ok(arr)) => arr,
-            _ => &self.source,
+            _ => self.source(),
         }
     }
 
-    /// Compute and cache the result. The computation runs exactly once via `OnceLock`.
-    ///
-    /// If the computation fails, the error is cached and returned on all subsequent calls.
-    pub fn get_or_compute(
+    fn get_or_compute(
         &self,
         f: impl FnOnce(&ArrayRef) -> VortexResult<Canonical>,
     ) -> VortexResult<ArrayRef> {
         let result = self
             .cached
-            .get_or_init(|| f(&self.source).map(|c| c.into_array()).map_err(Arc::new));
+            .get_or_init(|| f(self.source()).map(|c| c.into_array()).map_err(Arc::new));
         result.clone().map_err(Into::into)
     }
 
-    /// Async version of `get_or_compute`.
-    pub async fn get_or_compute_async<F, Fut>(&self, f: F) -> VortexResult<ArrayRef>
+    async fn get_or_compute_async<F, Fut>(&self, f: F) -> VortexResult<ArrayRef>
     where
         F: FnOnce(ArrayRef) -> Fut,
         Fut: Future<Output = VortexResult<Canonical>>,
     {
-        // Fast path: already computed.
         if let Some(result) = self.cached.get() {
             return result.clone().map_err(Into::into);
         }
 
-        // Serialize async computation to prevent redundant work.
         let _guard = self.async_compute_lock.lock().await;
 
-        // Double-check after acquiring the lock.
         if let Some(result) = self.cached.get() {
             return result.clone().map_err(Into::into);
         }
 
-        let computed = f(self.source.clone())
+        let computed = f(self.source().clone())
             .await
             .map(|c| c.into_array())
             .map_err(Arc::new);
@@ -90,11 +89,34 @@ impl SharedArray {
         let result = self.cached.get_or_init(|| computed);
         result.clone().map_err(Into::into)
     }
+}
+impl<T: TypedArrayRef<Shared>> SharedArrayExt for T {}
+
+impl SharedData {
+    pub fn new() -> Self {
+        Self {
+            cached: Arc::new(OnceLock::new()),
+            async_compute_lock: Arc::new(AsyncMutex::new(())),
+        }
+    }
+}
 
-    pub(super) fn set_source(&mut self, source: ArrayRef) {
-        self.dtype = source.dtype().clone();
-        self.source = source;
-        self.cached = Arc::new(OnceLock::new());
-        self.async_compute_lock = Arc::new(AsyncMutex::new(()));
+impl Default for SharedData {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Array<Shared> {
+    /// Creates a new `SharedArray`.
+    pub fn new(source: ArrayRef) -> Self {
+        let dtype = source.dtype().clone();
+        let len = source.len();
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Shared, dtype, len, SharedData::new())
+                    .with_slots(vec![Some(source)]),
+            )
+        }
     }
 }
diff --git a/vortex-array/src/arrays/shared/mod.rs b/vortex-array/src/arrays/shared/mod.rs
index 9249d5e2574..5d947388a5b 100644
--- a/vortex-array/src/arrays/shared/mod.rs
+++ b/vortex-array/src/arrays/shared/mod.rs
@@ -4,8 +4,10 @@
 mod array;
 mod vtable;
 
-pub use array::SharedArray;
-pub use vtable::SharedVTable;
+pub use array::SharedArrayExt;
+pub use array::SharedData;
+pub use vtable::Shared;
+pub use vtable::SharedArray;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/arrays/shared/tests.rs b/vortex-array/src/arrays/shared/tests.rs
index b828aa8191a..359a0919965 100644
--- a/vortex-array/src/arrays/shared/tests.rs
+++ b/vortex-array/src/arrays/shared/tests.rs
@@ -10,6 +10,7 @@ use crate::ExecutionCtx;
 use crate::IntoArray;
 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::session::ArraySession;
diff --git a/vortex-array/src/arrays/shared/vtable.rs b/vortex-array/src/arrays/shared/vtable.rs
index 3dead0de8d5..6be759c83eb 100644
--- a/vortex-array/src/arrays/shared/vtable.rs
+++ b/vortex-array/src/arrays/shared/vtable.rs
@@ -1,160 +1,134 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::hash::Hash;
+use std::hash::Hasher;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
+use crate::ArrayEq;
+use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
+use crate::ExecutionResult;
 use crate::Precision;
-use crate::arrays::shared::SharedArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::array::VTable;
+use crate::array::ValidityVTable;
+use crate::arrays::shared::SharedArrayExt;
+use crate::arrays::shared::SharedData;
+use crate::arrays::shared::array::SLOT_NAMES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
 use crate::scalar::Scalar;
-use crate::stats::StatsSetRef;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
 
-vtable!(Shared);
+/// A [`Shared`]-encoded Vortex array.
+pub type SharedArray = Array<Shared>;
 
 // TODO(ngates): consider hooking Shared into the iterative execution model. Cache either the
 //  most executed, or after each iteration, and return a shared cache for each execution.
-#[derive(Debug)]
-pub struct SharedVTable;
+#[derive(Clone, Debug)]
+pub struct Shared;
 
-impl SharedVTable {
+impl Shared {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.shared");
 }
 
-impl VTable for SharedVTable {
-    type Array = SharedArray;
-    type Metadata = EmptyMetadata;
+impl ArrayHash for SharedData {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+}
 
-    type ArrayVTable = Self;
+impl ArrayEq for SharedData {
+    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+        true
+    }
+}
+
+impl VTable for Shared {
+    type ArrayData = SharedData;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &Self::Array) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
-    }
-
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        vortex_error::vortex_bail!("Shared array is not serializable")
-    }
-
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        vortex_error::vortex_bail!("Shared array is not serializable")
-    }
-
-    fn build(
+    fn validate(
+        &self,
+        _data: &SharedData,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
-        children: &dyn crate::serde::ArrayChildren,
-    ) -> VortexResult<SharedArray> {
-        let child = children.get(0, dtype, len)?;
-        Ok(SharedArray::new(child))
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let source = slots[0]
+            .as_ref()
+            .vortex_expect("SharedArray source slot must be present");
+        vortex_error::vortex_ensure!(source.dtype() == dtype, "SharedArray dtype mismatch");
+        vortex_error::vortex_ensure!(source.len() == len, "SharedArray len mismatch");
+        Ok(())
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_error::vortex_ensure!(
-            children.len() == 1,
-            "SharedArray expects exactly 1 child, got {}",
-            children.len()
-        );
-        let child = children
-            .into_iter()
-            .next()
-            .vortex_expect("children length already validated");
-        array.set_source(child);
-        Ok(())
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        array.get_or_compute(|source| source.clone().execute::<Canonical>(ctx))
+    fn buffer(_array: ArrayView<'_, Self>, _idx: usize) -> BufferHandle {
+        vortex_panic!("SharedArray has no buffers")
     }
-}
 
-impl BaseArrayVTable<SharedVTable> for SharedVTable {
-    fn len(array: &SharedArray) -> usize {
-        array.current_array_ref().len()
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn dtype(array: &SharedArray) -> &DType {
-        &array.dtype
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
-    fn stats(array: &SharedArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        vortex_error::vortex_bail!("Shared array is not serializable")
     }
 
-    fn array_hash<H: std::hash::Hasher>(array: &SharedArray, state: &mut H, precision: Precision) {
-        let current = array.current_array_ref();
-        current.array_hash(state, precision);
-        array.dtype.hash(state);
+    fn deserialize(
+        &self,
+        _dtype: &DType,
+        _len: usize,
+        _metadata: &[u8],
+
+        _buffers: &[BufferHandle],
+        _children: &dyn crate::serde::ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        vortex_error::vortex_bail!("Shared array is not serializable")
     }
 
-    fn array_eq(array: &SharedArray, other: &SharedArray, precision: Precision) -> bool {
-        let current = array.current_array_ref();
-        let other_current = other.current_array_ref();
-        current.array_eq(other_current, precision) && array.dtype == other.dtype
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        array
+            .get_or_compute(|source| source.clone().execute::<Canonical>(ctx))
+            .map(ExecutionResult::done)
     }
 }
-
-impl OperationsVTable<SharedVTable> for SharedVTable {
-    fn scalar_at(array: &SharedArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<Shared> for Shared {
+    fn scalar_at(
+        array: ArrayView<'_, Shared>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         array.current_array_ref().scalar_at(index)
     }
 }
 
-impl ValidityVTable<SharedVTable> for SharedVTable {
-    fn validity(array: &SharedArray) -> VortexResult<Validity> {
+impl ValidityVTable<Shared> for Shared {
+    fn validity(array: ArrayView<'_, Shared>) -> VortexResult<Validity> {
         array.current_array_ref().validity()
     }
 }
-
-impl VisitorVTable<SharedVTable> for SharedVTable {
-    fn visit_buffers(_array: &SharedArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(array: &SharedArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("source", array.current_array_ref());
-    }
-
-    fn nchildren(_array: &SharedArray) -> usize {
-        1
-    }
-
-    fn nth_child(array: &SharedArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.current_array_ref().clone()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/slice/array.rs b/vortex-array/src/arrays/slice/array.rs
index 8a0dbbb642c..b1121e2604a 100644
--- a/vortex-array/src/arrays/slice/array.rs
+++ b/vortex-array/src/arrays/slice/array.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::ops::Range;
 
 use vortex_error::VortexExpect;
@@ -8,38 +10,64 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
-use crate::stats::ArrayStats;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::arrays::Slice;
+
+/// The underlying child array being sliced.
+pub(super) const CHILD_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["child"];
 
 #[derive(Clone, Debug)]
-pub struct SliceArray {
-    pub(super) child: ArrayRef,
+pub struct SliceData {
     pub(super) range: Range<usize>,
-    pub(super) stats: ArrayStats,
 }
 
-pub struct SliceArrayParts {
-    pub child: ArrayRef,
+impl Display for SliceData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "range: {}..{}", self.range.start, self.range.end)
+    }
+}
+
+pub struct SliceDataParts {
     pub range: Range<usize>,
 }
 
-impl SliceArray {
-    pub fn try_new(child: ArrayRef, range: Range<usize>) -> VortexResult<Self> {
-        if range.end > child.len() {
+pub trait SliceArrayExt: TypedArrayRef<Slice> {
+    fn child(&self) -> &ArrayRef {
+        self.as_ref().slots()[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated slice child slot")
+    }
+}
+impl<T: TypedArrayRef<Slice>> SliceArrayExt for T {}
+
+impl SliceData {
+    fn try_new(child_len: usize, range: Range<usize>) -> VortexResult<Self> {
+        if range.end > child_len {
             vortex_panic!(
                 "SliceArray range out of bounds: range {:?} exceeds child array length {}",
                 range,
-                child.len()
+                child_len
             );
         }
-        Ok(Self {
-            child,
-            range,
-            stats: ArrayStats::default(),
-        })
+        Ok(Self { range })
     }
 
-    pub fn new(child: ArrayRef, range: Range<usize>) -> Self {
-        Self::try_new(child, range).vortex_expect("failed")
+    pub fn new(range: Range<usize>) -> Self {
+        Self { range }
+    }
+
+    /// Returns the length of this array.
+    pub fn len(&self) -> usize {
+        self.range.len()
+    }
+
+    /// Returns `true` if this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     /// The range used to slice the child array.
@@ -47,16 +75,33 @@ impl SliceArray {
         &self.range
     }
 
-    /// The child array being sliced.
-    pub fn child(&self) -> &ArrayRef {
-        &self.child
+    pub fn into_parts(self) -> SliceDataParts {
+        SliceDataParts { range: self.range }
+    }
+}
+
+impl Array<Slice> {
+    /// Constructs a new `SliceArray`.
+    pub fn try_new(child: ArrayRef, range: Range<usize>) -> VortexResult<Self> {
+        let len = range.len();
+        let dtype = child.dtype().clone();
+        let data = SliceData::try_new(child.len(), range)?;
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Slice, dtype, len, data).with_slots(vec![Some(child)]),
+            )
+        })
     }
 
-    /// Consume the slice array and return its components.
-    pub fn into_parts(self) -> SliceArrayParts {
-        SliceArrayParts {
-            child: self.child,
-            range: self.range,
+    /// Constructs a new `SliceArray`.
+    pub fn new(child: ArrayRef, range: Range<usize>) -> Self {
+        let len = range.len();
+        let dtype = child.dtype().clone();
+        let data = SliceData::new(range);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Slice, dtype, len, data).with_slots(vec![Some(child)]),
+            )
         }
     }
 }
diff --git a/vortex-array/src/arrays/slice/mod.rs b/vortex-array/src/arrays/slice/mod.rs
index 2338fb7048e..8eec9d85310 100644
--- a/vortex-array/src/arrays/slice/mod.rs
+++ b/vortex-array/src/arrays/slice/mod.rs
@@ -1,6 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Reduce and execute adaptors for slice operations.
+//!
+//! Encodings that know how to slice themselves implement [`SliceReduce`] (metadata-only)
+//! or [`SliceKernel`] (buffer-reading). The adaptors [`SliceReduceAdaptor`] and
+//! [`SliceExecuteAdaptor`] bridge these into the execution model as
+//! [`ArrayParentReduceRule`] and [`ExecuteParentKernel`] respectively.
+
 mod array;
 mod rules;
 mod slice_;
@@ -8,7 +15,9 @@ mod vtable;
 
 use std::ops::Range;
 
-pub use array::*;
+pub use array::SliceArrayExt;
+pub use array::SliceData;
+pub use array::SliceDataParts;
 use vortex_error::VortexResult;
 pub use vtable::*;
 
@@ -16,10 +25,11 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::kernel::ExecuteParentKernel;
 use crate::matcher::Matcher;
 use crate::optimizer::rules::ArrayParentReduceRule;
-use crate::vtable::VTable;
 
 pub trait SliceReduce: VTable {
     /// Slice an array with the provided range without reading buffers.
@@ -33,7 +43,7 @@ pub trait SliceReduce: VTable {
     /// The range is guaranteed to be within bounds of the array (i.e., `range.end <= array.len()`).
     ///
     /// Additionally, the range is guaranteed to be non-empty (i.e., `range.start < range.end`).
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>>;
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>>;
 }
 
 pub trait SliceKernel: VTable {
@@ -48,15 +58,15 @@ pub trait SliceKernel: VTable {
     ///
     /// Additionally, the range is guaranteed to be non-empty (i.e., `range.start < range.end`).
     fn slice(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         range: Range<usize>,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
-fn precondition<V: VTable>(array: &V::Array, range: &Range<usize>) -> Option<ArrayRef> {
+fn precondition<V: VTable>(array: ArrayView<'_, V>, range: &Range<usize>) -> Option<ArrayRef> {
     if range.start == 0 && range.end == array.len() {
-        return Some(array.to_array());
+        return Some(array.array().clone());
     };
     if range.start == range.end {
         return Some(Canonical::empty(array.dtype()).into_array());
@@ -64,6 +74,7 @@ fn precondition<V: VTable>(array: &V::Array, range: &Range<usize>) -> Option<Arr
     None
 }
 
+/// Adaptor that wraps a [`SliceReduce`] impl as an [`ArrayParentReduceRule`].
 #[derive(Default, Debug)]
 pub struct SliceReduceAdaptor<V>(pub V);
 
@@ -71,11 +82,11 @@ impl<V> ArrayParentReduceRule<V> for SliceReduceAdaptor<V>
 where
     V: SliceReduce,
 {
-    type Parent = SliceVTable;
+    type Parent = Slice;
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -87,6 +98,7 @@ where
     }
 }
 
+/// Adaptor that wraps a [`SliceKernel`] impl as an [`ExecuteParentKernel`].
 #[derive(Default, Debug)]
 pub struct SliceExecuteAdaptor<V>(pub V);
 
@@ -94,11 +106,11 @@ impl<V> ExecuteParentKernel<V> for SliceExecuteAdaptor<V>
 where
     V: SliceKernel,
 {
-    type Parent = SliceVTable;
+    type Parent = Slice;
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
diff --git a/vortex-array/src/arrays/slice/rules.rs b/vortex-array/src/arrays/slice/rules.rs
index eaffd5620a6..3bc0a70f204 100644
--- a/vortex-array/src/arrays/slice/rules.rs
+++ b/vortex-array/src/arrays/slice/rules.rs
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::SliceReduceAdaptor;
-use crate::arrays::slice::SliceVTable;
+use crate::arrays::Slice;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 
-pub(super) const PARENT_RULES: ParentRuleSet<SliceVTable> =
-    ParentRuleSet::new(&[ParentRuleSet::lift(&SliceReduceAdaptor(SliceVTable))]);
+pub(super) const PARENT_RULES: ParentRuleSet<Slice> =
+    ParentRuleSet::new(&[ParentRuleSet::lift(&SliceReduceAdaptor(Slice))]);
diff --git a/vortex-array/src/arrays/slice/slice_.rs b/vortex-array/src/arrays/slice/slice_.rs
index ca1d97c6e15..0f5fba2d80b 100644
--- a/vortex-array/src/arrays/slice/slice_.rs
+++ b/vortex-array/src/arrays/slice/slice_.rs
@@ -7,12 +7,14 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Slice;
 use crate::arrays::SliceArray;
-use crate::arrays::SliceReduce;
-use crate::arrays::SliceVTable;
+use crate::arrays::slice::SliceArrayExt;
+use crate::arrays::slice::SliceReduce;
 
-impl SliceReduce for SliceVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Slice {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let inner_range = array.slice_range();
 
         let combined_start = inner_range.start + range.start;
diff --git a/vortex-array/src/arrays/slice/vtable.rs b/vortex-array/src/arrays/slice/vtable.rs
index 81fa1656f9b..2ac41a358b9 100644
--- a/vortex-array/src/arrays/slice/vtable.rs
+++ b/vortex-array/src/arrays/slice/vtable.rs
@@ -11,181 +11,170 @@ 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 crate::AnyCanonical;
-use crate::Array;
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::Canonical;
 use crate::Precision;
-use crate::arrays::slice::array::SliceArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::array::VTable;
+use crate::array::ValidityVTable;
+use crate::arrays::slice::SliceArrayExt;
+use crate::arrays::slice::array::CHILD_SLOT;
+use crate::arrays::slice::array::SLOT_NAMES;
+use crate::arrays::slice::array::SliceData;
 use crate::arrays::slice::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+use crate::require_child;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
-use crate::stats::StatsSetRef;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
 
-vtable!(Slice);
+/// A [`Slice`]-encoded Vortex array.
+pub type SliceArray = Array<Slice>;
 
-#[derive(Debug)]
-pub struct SliceVTable;
+#[derive(Clone, Debug)]
+pub struct Slice;
 
-impl SliceVTable {
+impl Slice {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.slice");
 }
 
-impl VTable for SliceVTable {
-    type Array = SliceArray;
-    type Metadata = SliceMetadata;
-    type ArrayVTable = Self;
+impl ArrayHash for SliceData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.range.start.hash(state);
+        self.range.end.hash(state);
+    }
+}
+
+impl ArrayEq for SliceData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.range == other.range
+    }
+}
+
+impl VTable for Slice {
+    type ArrayData = SliceData;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
-        SliceVTable::ID
+    fn id(&self) -> ArrayId {
+        Slice::ID
     }
 
-    fn metadata(array: &Self::Array) -> VortexResult<Self::Metadata> {
-        Ok(SliceMetadata(array.range.clone()))
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots[CHILD_SLOT].is_some(),
+            "SliceArray child slot must be present"
+        );
+        let child = slots[CHILD_SLOT]
+            .as_ref()
+            .vortex_expect("validated child slot");
+        vortex_ensure!(
+            child.dtype() == dtype,
+            "SliceArray dtype {} does not match outer dtype {}",
+            child.dtype(),
+            dtype
+        );
+        vortex_ensure!(
+            data.len() == len,
+            "SliceArray length {} does not match outer length {}",
+            data.len(),
+            len
+        );
+        vortex_ensure!(
+            data.range.end <= child.len(),
+            "SliceArray range {:?} exceeds child length {}",
+            data.range,
+            child.len()
+        );
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, _idx: usize) -> BufferHandle {
+        vortex_panic!("SliceArray has no buffers")
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
         // TODO(joe): make this configurable
         vortex_bail!("Slice array is not serializable")
     }
 
     fn deserialize(
-        _bytes: &[u8],
+        &self,
         _dtype: &DType,
         _len: usize,
+        _metadata: &[u8],
+
         _buffers: &[BufferHandle],
+        _children: &dyn ArrayChildren,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
         vortex_bail!("Slice array is not serializable")
     }
 
-    fn build(
-        dtype: &DType,
-        len: usize,
-        metadata: &SliceMetadata,
-        _buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-    ) -> VortexResult<Self::Array> {
-        assert_eq!(len, metadata.0.len());
-        let child = children.get(0, dtype, metadata.0.end)?;
-        Ok(SliceArray {
-            child,
-            range: metadata.0.clone(),
-            stats: Default::default(),
-        })
-    }
-
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.len() == 1,
-            "SliceArray expects exactly 1 child, got {}",
-            children.len()
-        );
-        array.child = children
-            .into_iter()
-            .next()
-            .vortex_expect("children length already validated");
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        // Execute the child to get canonical form, then slice it
-        let Some(canonical) = array.child.as_opt::<AnyCanonical>() else {
-            // If the child is not canonical, recurse.
-            return array
-                .child
-                .clone()
-                .execute::<ArrayRef>(ctx)?
-                .slice(array.slice_range().clone());
-        };
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = require_child!(array, array.child(), CHILD_SLOT => AnyCanonical);
 
+        debug_assert!(array.child().is_canonical());
         // TODO(ngates): we should inline canonical slice logic here.
-        Canonical::from(canonical)
-            .as_ref()
+        array
+            .child()
             .slice(array.range.clone())
+            .map(ExecutionResult::done)
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 }
-
-impl BaseArrayVTable<SliceVTable> for SliceVTable {
-    fn len(array: &SliceArray) -> usize {
-        array.range.len()
-    }
-
-    fn dtype(array: &SliceArray) -> &DType {
-        array.child.dtype()
-    }
-
-    fn stats(array: &SliceArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: Hasher>(array: &SliceArray, state: &mut H, precision: Precision) {
-        array.child.array_hash(state, precision);
-        array.range.start.hash(state);
-        array.range.end.hash(state);
-    }
-
-    fn array_eq(array: &SliceArray, other: &SliceArray, precision: Precision) -> bool {
-        array.child.array_eq(&other.child, precision) && array.range == other.range
-    }
-}
-
-impl OperationsVTable<SliceVTable> for SliceVTable {
-    fn scalar_at(array: &SliceArray, index: usize) -> VortexResult<Scalar> {
-        array.child.scalar_at(array.range.start + index)
-    }
-}
-
-impl ValidityVTable<SliceVTable> for SliceVTable {
-    fn validity(array: &SliceArray) -> VortexResult<Validity> {
-        array.child.validity()?.slice(array.range.clone())
+impl OperationsVTable<Slice> for Slice {
+    fn scalar_at(
+        array: ArrayView<'_, Slice>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        array.child().scalar_at(array.range.start + index)
     }
 }
 
-impl VisitorVTable<SliceVTable> for SliceVTable {
-    fn visit_buffers(_array: &SliceArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(array: &SliceArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("child", &array.child);
-    }
-
-    fn nchildren(_array: &SliceArray) -> usize {
-        1
-    }
-
-    fn nth_child(array: &SliceArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.child.clone()),
-            _ => None,
-        }
+impl ValidityVTable<Slice> for Slice {
+    fn validity(array: ArrayView<'_, Slice>) -> VortexResult<Validity> {
+        array.child().validity()?.slice(array.range.clone())
     }
 }
 
@@ -201,7 +190,6 @@ impl Debug for SliceMetadata {
 mod tests {
     use vortex_error::VortexResult;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::SliceArray;
diff --git a/vortex-array/src/arrays/struct_/array.rs b/vortex-array/src/arrays/struct_/array.rs
index b7a1a83b405..3d147f9c85e 100644
--- a/vortex-array/src/arrays/struct_/array.rs
+++ b/vortex-array/src/arrays/struct_/array.rs
@@ -1,25 +1,33 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::fmt::Debug;
 use std::iter::once;
 use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::EmptyArrayData;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::Struct;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
 use crate::dtype::FieldNames;
 use crate::dtype::StructFields;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
+
+// StructArray has a variable number of slots: [validity?, field_0, ..., field_N]
+/// The validity bitmap indicating which struct elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+/// The offset at which the struct field arrays begin in the slots vector.
+pub(super) const FIELDS_OFFSET: usize = 1;
 
 /// A struct array that stores multiple named fields as columns, similar to a database row.
 ///
@@ -75,6 +83,7 @@ use crate::vtable::ValidityHelper;
 ///
 /// ```
 /// use vortex_array::arrays::StructArray;
+/// use vortex_array::arrays::struct_::StructArrayExt;
 /// use vortex_array::validity::Validity;
 /// use vortex_array::dtype::FieldNames;
 /// use vortex_array::IntoArray;
@@ -115,6 +124,7 @@ use crate::vtable::ValidityHelper;
 ///
 /// ```
 /// use vortex_array::arrays::{StructArray, PrimitiveArray};
+/// use vortex_array::arrays::struct_::StructArrayExt;
 /// use vortex_array::validity::Validity;
 /// use vortex_array::dtype::FieldNames;
 /// use vortex_array::IntoArray;
@@ -139,74 +149,79 @@ use crate::vtable::ValidityHelper;
 /// let id_field = struct_array.unmasked_field_by_name("id").unwrap();
 /// assert_eq!(id_field.len(), 3);
 /// ```
-#[derive(Clone, Debug)]
-pub struct StructArray {
-    pub(super) len: usize,
-    pub(super) dtype: DType,
-    pub(super) fields: Arc<[ArrayRef]>,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
-}
-
-pub struct StructArrayParts {
+pub struct StructDataParts {
     pub struct_fields: StructFields,
     pub fields: Arc<[ArrayRef]>,
     pub validity: Validity,
 }
 
-impl StructArray {
-    /// Return the struct fields without the validity of the struct applied
-    pub fn unmasked_fields(&self) -> &Arc<[ArrayRef]> {
-        &self.fields
+pub(super) fn make_struct_slots(
+    fields: &[ArrayRef],
+    validity: &Validity,
+    length: usize,
+) -> Vec<Option<ArrayRef>> {
+    once(validity_to_child(validity, length))
+        .chain(fields.iter().cloned().map(Some))
+        .collect()
+}
+
+pub trait StructArrayExt: TypedArrayRef<Struct> {
+    fn nullability(&self) -> crate::dtype::Nullability {
+        match self.as_ref().dtype() {
+            DType::Struct(_, nullability) => *nullability,
+            _ => unreachable!("StructArrayExt requires a struct dtype"),
+        }
     }
 
-    /// Return the struct field without the validity of the struct applied
-    pub fn unmasked_field_by_name(&self, name: impl AsRef<str>) -> VortexResult<&ArrayRef> {
-        let name = name.as_ref();
-        self.unmasked_field_by_name_opt(name).ok_or_else(|| {
-            vortex_err!(
-                "Field {name} not found in struct array with names {:?}",
-                self.names()
-            )
-        })
+    fn names(&self) -> &FieldNames {
+        self.as_ref().dtype().as_struct_fields().names()
     }
 
-    /// Return the struct field without the validity of the struct applied
-    pub fn unmasked_field_by_name_opt(&self, name: impl AsRef<str>) -> Option<&ArrayRef> {
-        let name = name.as_ref();
-        self.struct_fields().find(name).map(|idx| &self.fields[idx])
+    fn struct_validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
     }
 
-    pub fn names(&self) -> &FieldNames {
-        self.struct_fields().names()
+    fn iter_unmasked_fields(&self) -> impl Iterator<Item = &ArrayRef> + '_ {
+        self.as_ref().slots()[FIELDS_OFFSET..]
+            .iter()
+            .map(|s| s.as_ref().vortex_expect("StructArray field slot"))
+    }
+
+    fn unmasked_fields(&self) -> Arc<[ArrayRef]> {
+        self.iter_unmasked_fields().cloned().collect()
     }
 
-    pub fn struct_fields(&self) -> &StructFields {
-        let Some(struct_dtype) = &self.dtype.as_struct_fields_opt() else {
-            unreachable!(
-                "struct arrays must have be a DType::Struct, this is likely an internal bug."
+    fn unmasked_field(&self, idx: usize) -> &ArrayRef {
+        self.as_ref().slots()[FIELDS_OFFSET + idx]
+            .as_ref()
+            .vortex_expect("StructArray field slot")
+    }
+
+    fn unmasked_field_by_name_opt(&self, name: impl AsRef<str>) -> Option<&ArrayRef> {
+        let name = name.as_ref();
+        self.struct_fields()
+            .find(name)
+            .map(|idx| self.unmasked_field(idx))
+    }
+
+    fn unmasked_field_by_name(&self, name: impl AsRef<str>) -> VortexResult<&ArrayRef> {
+        let name = name.as_ref();
+        self.unmasked_field_by_name_opt(name).ok_or_else(|| {
+            vortex_err!(
+                "Field {name} not found in struct array with names {:?}",
+                self.names()
             )
-        };
-        struct_dtype
+        })
     }
 
-    /// Create a new `StructArray` with the given length, but without any fields.
-    pub fn new_fieldless_with_len(len: usize) -> Self {
-        Self::try_new(
-            FieldNames::default(),
-            Vec::new(),
-            len,
-            Validity::NonNullable,
-        )
-        .vortex_expect("StructArray::new_with_len should not fail")
+    fn struct_fields(&self) -> &StructFields {
+        self.as_ref().dtype().as_struct_fields()
     }
+}
+impl<T: TypedArrayRef<Struct>> StructArrayExt for T {}
 
-    /// Creates a new [`StructArray`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`StructArray::new_unchecked`].
+impl Array<Struct> {
+    /// Creates a new `StructArray`.
     pub fn new(
         names: FieldNames,
         fields: impl Into<Arc<[ArrayRef]>>,
@@ -218,13 +233,6 @@ impl StructArray {
     }
 
     /// Constructs a new `StructArray`.
-    ///
-    /// See [`StructArray::new_unchecked`] for more information.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`StructArray::new_unchecked`].
     pub fn try_new(
         names: FieldNames,
         fields: impl Into<Arc<[ArrayRef]>>,
@@ -232,40 +240,25 @@ impl StructArray {
         validity: Validity,
     ) -> VortexResult<Self> {
         let fields = fields.into();
-        let field_dtypes: Vec<_> = fields.iter().map(|d| d.dtype()).cloned().collect();
+        let field_dtypes: Vec<_> = fields.iter().map(|d| d.dtype().clone()).collect();
         let dtype = StructFields::new(names, field_dtypes);
-
-        Self::validate(&fields, &dtype, length, &validity)?;
-
-        // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked(fields, dtype, length, validity) })
+        let slots = make_struct_slots(&fields, &validity, length);
+        Array::try_from_parts(
+            ArrayParts::new(
+                Struct,
+                DType::Struct(dtype, validity.nullability()),
+                length,
+                EmptyArrayData,
+            )
+            .with_slots(slots),
+        )
     }
 
-    /// Creates a new [`StructArray`] without validation from these components:
-    ///
-    /// * `fields` is a vector of arrays, one for each field in the struct.
-    /// * `dtype` contains the field names and types.
-    /// * `length` is the number of struct rows.
-    /// * `validity` holds the null values.
+    /// Creates a new `StructArray` without validation.
     ///
     /// # Safety
     ///
-    /// The caller must ensure all of the following invariants are satisfied:
-    ///
-    /// ## Field Requirements
-    ///
-    /// - `fields.len()` must exactly equal `dtype.names().len()`.
-    /// - Every field array in `fields` must have length exactly equal to `length`.
-    /// - For each index `i`, `fields[i].dtype()` must exactly match `dtype.fields()[i]`.
-    ///
-    /// ## Type Requirements
-    ///
-    /// - Field names in `dtype` may be duplicated (this is explicitly allowed).
-    /// - The nullability of `dtype` must match the nullability of `validity`.
-    ///
-    /// ## Validity Requirements
-    ///
-    /// - If `validity` is [`Validity::Array`], its length must exactly equal `length`.
+    /// Caller must ensure the field arrays match the supplied dtype, length, and validity.
     pub unsafe fn new_unchecked(
         fields: impl Into<Arc<[ArrayRef]>>,
         dtype: StructFields,
@@ -273,73 +266,16 @@ impl StructArray {
         validity: Validity,
     ) -> Self {
         let fields = fields.into();
-
-        #[cfg(debug_assertions)]
-        Self::validate(&fields, &dtype, length, &validity)
-            .vortex_expect("[Debug Assertion]: Invalid `StructArray` parameters");
-
-        Self {
-            len: length,
-            dtype: DType::Struct(dtype, validity.nullability()),
-            fields,
-            validity,
-            stats_set: Default::default(),
-        }
-    }
-
-    /// Validates the components that would be used to create a [`StructArray`].
-    ///
-    /// This function checks all the invariants required by [`StructArray::new_unchecked`].
-    pub fn validate(
-        fields: &[ArrayRef],
-        dtype: &StructFields,
-        length: usize,
-        validity: &Validity,
-    ) -> VortexResult<()> {
-        // Check field count matches
-        if fields.len() != dtype.names().len() {
-            vortex_bail!(
-                InvalidArgument: "Got {} fields but dtype has {} names",
-                fields.len(),
-                dtype.names().len()
-            );
-        }
-
-        // Check each field's length and dtype
-        for (i, (field, struct_dt)) in fields.iter().zip(dtype.fields()).enumerate() {
-            if field.len() != length {
-                vortex_bail!(
-                    InvalidArgument: "Field {} has length {} but expected {}",
-                    i,
-                    field.len(),
-                    length
-                );
-            }
-
-            if field.dtype() != &struct_dt {
-                vortex_bail!(
-                    InvalidArgument: "Field {} has dtype {} but expected {}",
-                    i,
-                    field.dtype(),
-                    struct_dt
-                );
-            }
-        }
-
-        // Check validity length
-        if let Some(validity_len) = validity.maybe_len()
-            && validity_len != length
-        {
-            vortex_bail!(
-                InvalidArgument: "Validity has length {} but expected {}",
-                validity_len,
-                length
-            );
+        let outer_dtype = DType::Struct(dtype, validity.nullability());
+        let slots = make_struct_slots(&fields, &validity, length);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Struct, outer_dtype, length, EmptyArrayData).with_slots(slots),
+            )
         }
-
-        Ok(())
     }
 
+    /// Constructs a new `StructArray` with an explicit dtype.
     pub fn try_new_with_dtype(
         fields: impl Into<Arc<[ArrayRef]>>,
         dtype: StructFields,
@@ -347,29 +283,19 @@ impl StructArray {
         validity: Validity,
     ) -> VortexResult<Self> {
         let fields = fields.into();
-        Self::validate(&fields, &dtype, length, &validity)?;
-
-        // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked(fields, dtype, length, validity) })
-    }
-
-    pub fn into_parts(self) -> StructArrayParts {
-        let struct_fields = self.dtype.into_struct_fields();
-        StructArrayParts {
-            struct_fields,
-            fields: self.fields,
-            validity: self.validity,
-        }
-    }
-
-    pub fn into_fields(self) -> Vec<ArrayRef> {
-        self.into_parts().fields.to_vec()
+        let outer_dtype = DType::Struct(dtype, validity.nullability());
+        let slots = make_struct_slots(&fields, &validity, length);
+        Array::try_from_parts(
+            ArrayParts::new(Struct, outer_dtype, length, EmptyArrayData).with_slots(slots),
+        )
     }
 
+    /// Construct a `StructArray` from named fields.
     pub fn from_fields<N: AsRef<str>>(items: &[(N, ArrayRef)]) -> VortexResult<Self> {
-        Self::try_from_iter(items.iter().map(|(a, b)| (a, b.to_array())))
+        Self::try_from_iter(items.iter().map(|(a, b)| (a, b.clone())))
     }
 
+    /// Create a `StructArray` from an iterator of (name, array) pairs with validity.
     pub fn try_from_iter_with_validity<
         N: AsRef<str>,
         A: IntoArray,
@@ -390,10 +316,25 @@ impl StructArray {
         Self::try_new(FieldNames::from_iter(names), fields, len, validity)
     }
 
+    /// Create a `StructArray` from an iterator of (name, array) pairs.
     pub fn try_from_iter<N: AsRef<str>, A: IntoArray, T: IntoIterator<Item = (N, A)>>(
         iter: T,
     ) -> VortexResult<Self> {
-        Self::try_from_iter_with_validity(iter, Validity::NonNullable)
+        let (names, fields): (Vec<FieldName>, Vec<ArrayRef>) = iter
+            .into_iter()
+            .map(|(name, field)| (FieldName::from(name.as_ref()), field.into_array()))
+            .unzip();
+        let len = fields
+            .first()
+            .map(ArrayRef::len)
+            .ok_or_else(|| vortex_err!("StructArray cannot be constructed from an empty slice of arrays because the length is unspecified"))?;
+
+        Self::try_new(
+            FieldNames::from_iter(names),
+            fields,
+            len,
+            Validity::NonNullable,
+        )
     }
 
     // TODO(aduffy): Add equivalent function to support field masks for nested column access.
@@ -407,66 +348,107 @@ impl StructArray {
         let mut children = Vec::with_capacity(projection.len());
         let mut names = Vec::with_capacity(projection.len());
 
-        let fields = self.unmasked_fields();
-        for f_name in projection.iter() {
+        for f_name in projection {
             let idx = self
-                .names()
-                .iter()
-                .position(|name| name == f_name)
+                .struct_fields()
+                .find(f_name.as_ref())
                 .ok_or_else(|| vortex_err!("Unknown field {f_name}"))?;
 
             names.push(self.names()[idx].clone());
-            children.push(fields[idx].clone());
+            children.push(self.unmasked_field(idx).clone());
         }
 
-        StructArray::try_new(
+        Self::try_new(
             FieldNames::from(names.as_slice()),
             children,
             self.len(),
-            self.validity().clone(),
+            self.validity()?,
         )
     }
 
-    /// Removes and returns a column from the struct array by name.
-    /// If the column does not exist, returns `None`.
-    pub fn remove_column(&mut self, name: impl Into<FieldName>) -> Option<ArrayRef> {
-        let name = name.into();
-
-        let struct_dtype = self.struct_fields().clone();
+    /// Create a fieldless `StructArray` with the given length.
+    pub fn new_fieldless_with_len(len: usize) -> Self {
+        let dtype = DType::Struct(
+            StructFields::new(FieldNames::default(), Vec::new()),
+            crate::dtype::Nullability::NonNullable,
+        );
+        let slots = make_struct_slots(&[], &Validity::NonNullable, len);
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Struct, dtype, len, EmptyArrayData).with_slots(slots),
+            )
+        }
+    }
 
-        let position = struct_dtype
-            .names()
+    // TODO(ngates): remove this... it doesn't help to consume self.
+    pub fn into_data_parts(self) -> StructDataParts {
+        let fields: Arc<[ArrayRef]> = self.slots()[FIELDS_OFFSET..]
             .iter()
-            .position(|field_name| field_name.as_ref() == name.as_ref())?;
+            .map(|s| s.as_ref().vortex_expect("StructArray field slot").clone())
+            .collect();
+        let validity = self.validity().vortex_expect("StructArray validity");
+        StructDataParts {
+            struct_fields: self.struct_fields().clone(),
+            fields,
+            validity,
+        }
+    }
 
-        let field = self.fields[position].clone();
-        let new_fields: Arc<[ArrayRef]> = self
-            .fields
+    pub fn remove_column(&self, name: impl Into<FieldName>) -> Option<(Self, ArrayRef)> {
+        let name = name.into();
+        let struct_dtype = self.struct_fields();
+        let len = self.len();
+
+        let position = struct_dtype.find(name.as_ref())?;
+
+        let slot_position = FIELDS_OFFSET + position;
+        let field = self.slots()[slot_position]
+            .as_ref()
+            .vortex_expect("StructArray field slot")
+            .clone();
+        let new_slots: Vec<Option<ArrayRef>> = self
+            .slots()
             .iter()
             .enumerate()
-            .filter(|(i, _)| *i != position)
-            .map(|(_, f)| f.clone())
+            .filter(|(i, _)| *i != slot_position)
+            .map(|(_, s)| s.clone())
             .collect();
 
-        if let Ok(new_dtype) = struct_dtype.without_field(position) {
-            self.fields = new_fields;
-            self.dtype = DType::Struct(new_dtype, self.dtype.nullability());
-            return Some(field);
-        }
-        None
+        let new_dtype = struct_dtype.without_field(position).ok()?;
+        let new_array = unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(
+                    Struct,
+                    DType::Struct(new_dtype, self.dtype().nullability()),
+                    len,
+                    EmptyArrayData,
+                )
+                .with_slots(new_slots),
+            )
+        };
+        Some((new_array, field))
     }
+}
 
-    /// Create a new StructArray by appending a new column onto the existing array.
+impl Array<Struct> {
     pub fn with_column(&self, name: impl Into<FieldName>, array: ArrayRef) -> VortexResult<Self> {
         let name = name.into();
-        let struct_dtype = self.struct_fields().clone();
+        let struct_dtype = self.struct_fields();
 
         let names = struct_dtype.names().iter().cloned().chain(once(name));
         let types = struct_dtype.fields().chain(once(array.dtype().clone()));
         let new_fields = StructFields::new(names.collect(), types.collect());
 
-        let children: Arc<[ArrayRef]> = self.fields.iter().cloned().chain(once(array)).collect();
+        let children: Arc<[ArrayRef]> = self.slots()[FIELDS_OFFSET..]
+            .iter()
+            .map(|s| s.as_ref().vortex_expect("StructArray field slot").clone())
+            .chain(once(array))
+            .collect();
+
+        Self::try_new_with_dtype(children, new_fields, self.len(), self.validity()?)
+    }
 
-        Self::try_new_with_dtype(children, new_fields, self.len, self.validity.clone())
+    pub fn remove_column_owned(&self, name: impl Into<FieldName>) -> Option<(Self, ArrayRef)> {
+        self.remove_column(name)
     }
 }
diff --git a/vortex-array/src/arrays/struct_/compute/cast.rs b/vortex-array/src/arrays/struct_/compute/cast.rs
index 1206e63fecc..5e63cdc2092 100644
--- a/vortex-array/src/arrays/struct_/compute/cast.rs
+++ b/vortex-array/src/arrays/struct_/compute/cast.rs
@@ -8,18 +8,19 @@ use vortex_error::vortex_ensure;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::cast::CastKernel;
-use crate::vtable::ValidityHelper;
 
-impl CastKernel for StructVTable {
+impl CastKernel for Struct {
     fn cast(
-        array: &StructArray,
+        array: ArrayView<'_, Struct>,
         dtype: &DType,
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -38,10 +39,7 @@ impl CastKernel for StructVTable {
 
         let mut cast_fields = Vec::with_capacity(target_sdtype.nfields());
         if fields_match_order {
-            for (field, target_type) in array
-                .unmasked_fields()
-                .iter()
-                .zip_eq(target_sdtype.fields())
+            for (field, target_type) in array.iter_unmasked_fields().zip_eq(target_sdtype.fields())
             {
                 let cast_field = field.cast(target_type)?;
                 cast_fields.push(cast_field);
@@ -66,8 +64,7 @@ impl CastKernel for StructVTable {
                     }
                     Some(src_field_idx) => {
                         // Field exists in source field. Cast it to the target type.
-                        let cast_field =
-                            array.unmasked_fields()[src_field_idx].cast(target_type)?;
+                        let cast_field = array.unmasked_field(src_field_idx).cast(target_type)?;
                         cast_fields.push(cast_field);
                     }
                 }
@@ -75,8 +72,7 @@ impl CastKernel for StructVTable {
         }
 
         let validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(dtype.nullability(), array.len())?;
 
         StructArray::try_new(
@@ -94,12 +90,12 @@ mod tests {
     use rstest::rstest;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::arrays::VarBinArray;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
     use crate::dtype::DType;
@@ -115,7 +111,7 @@ mod tests {
     #[case(create_nested_struct())]
     #[case(create_simple_struct())]
     fn test_cast_struct_conformance(#[case] array: StructArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     fn create_test_struct(nullable: bool) -> StructArray {
@@ -179,12 +175,12 @@ mod tests {
     fn cast_nullable_all_invalid() {
         let empty_struct = StructArray::try_new(
             FieldNames::from(["a"]),
-            vec![PrimitiveArray::new::<i32>(buffer![], Validity::AllInvalid).to_array()],
+            vec![PrimitiveArray::new::<i32>(buffer![], Validity::AllInvalid).into_array()],
             0,
             Validity::AllInvalid,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         let target_dtype = DType::struct_(
             [("a", DType::Primitive(PType::I32, Nullability::NonNullable))],
@@ -207,10 +203,13 @@ mod tests {
 
         let target_dtype = struct_array.dtype().as_nullable();
 
-        let result = struct_array.to_array().cast(target_dtype.clone()).unwrap();
+        let result = struct_array
+            .into_array()
+            .cast(target_dtype.clone())
+            .unwrap();
         assert_eq!(result.dtype(), &target_dtype);
         assert_eq!(result.len(), 3);
-        assert_eq!(result.to_struct().unmasked_fields().len(), 2);
+        assert_eq!(result.to_struct().struct_fields().nfields(), 2);
     }
 
     #[test]
@@ -233,9 +232,12 @@ mod tests {
         let struct_array =
             StructArray::try_new(names, vec![field1, field2], 3, Validity::NonNullable).unwrap();
 
-        let result = struct_array.to_array().cast(target_dtype.clone()).unwrap();
+        let result = struct_array
+            .into_array()
+            .cast(target_dtype.clone())
+            .unwrap();
         assert_eq!(result.dtype(), &target_dtype);
         assert_eq!(result.len(), 3);
-        assert_eq!(result.to_struct().unmasked_fields().len(), 3);
+        assert_eq!(result.to_struct().struct_fields().nfields(), 3);
     }
 }
diff --git a/vortex-array/src/arrays/struct_/compute/is_constant.rs b/vortex-array/src/arrays/struct_/compute/is_constant.rs
deleted file mode 100644
index 63719bc4c5b..00000000000
--- a/vortex-array/src/arrays/struct_/compute/is_constant.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::compute::{self};
-use crate::register_kernel;
-
-impl IsConstantKernel for StructVTable {
-    fn is_constant(
-        &self,
-        array: &StructArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        let children = array.children();
-        if children.is_empty() {
-            return Ok(Some(true));
-        }
-
-        for child in children.iter() {
-            match compute::is_constant_opts(child, opts)? {
-                // Un-determined
-                None => return Ok(None),
-                Some(false) => return Ok(Some(false)),
-                Some(true) => {}
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(StructVTable).lift());
diff --git a/vortex-array/src/arrays/struct_/compute/mask.rs b/vortex-array/src/arrays/struct_/compute/mask.rs
index 16331bd5afc..a36fa1743e1 100644
--- a/vortex-array/src/arrays/struct_/compute/mask.rs
+++ b/vortex-array/src/arrays/struct_/compute/mask.rs
@@ -5,22 +5,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
+use crate::arrays::struct_::StructArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for StructVTable {
-    fn mask(array: &StructArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for Struct {
+    fn mask(array: ArrayView<'_, Struct>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         StructArray::try_new_with_dtype(
-            array.unmasked_fields().clone(),
+            array.unmasked_fields().iter().cloned().collect::<Vec<_>>(),
             array.struct_fields().clone(),
             array.len(),
-            array
-                .validity()
-                .clone()
-                .and(Validity::Array(mask.clone()))?,
+            array.validity()?.and(Validity::Array(mask.clone()))?,
         )
         .map(|a| Some(a.into_array()))
     }
diff --git a/vortex-array/src/arrays/struct_/compute/min_max.rs b/vortex-array/src/arrays/struct_/compute/min_max.rs
deleted file mode 100644
index 6edb0333ef7..00000000000
--- a/vortex-array/src/arrays/struct_/compute/min_max.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for StructVTable {
-    fn min_max(&self, _array: &StructArray) -> VortexResult<Option<MinMaxResult>> {
-        // TODO(joe): Implement struct min max
-        Ok(None)
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(StructVTable).lift());
diff --git a/vortex-array/src/arrays/struct_/compute/mod.rs b/vortex-array/src/arrays/struct_/compute/mod.rs
index 7609a0a84e7..6d6e8c5b788 100644
--- a/vortex-array/src/arrays/struct_/compute/mod.rs
+++ b/vortex-array/src/arrays/struct_/compute/mod.rs
@@ -2,9 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod cast;
-mod is_constant;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
@@ -19,11 +17,11 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_error::VortexExpect;
 
-    use crate::Array;
     use crate::Canonical;
     use crate::IntoArray as _;
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::aggregate_fn::fns::is_constant::is_constant;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
@@ -33,7 +31,6 @@ mod tests {
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::compute::conformance::mask::test_mask_conformance;
     use crate::compute::conformance::take::test_take_conformance;
-    use crate::compute::is_constant;
     use crate::dtype::DType;
     use crate::dtype::FieldNames;
     use crate::dtype::Nullability;
@@ -46,7 +43,7 @@ mod tests {
         let struct_arr =
             StructArray::try_new(FieldNames::empty(), vec![], 10, Validity::NonNullable).unwrap();
         let indices = PrimitiveArray::from_option_iter([Some(1), None]);
-        let taken = struct_arr.take(indices.to_array()).unwrap();
+        let taken = struct_arr.take(indices.into_array()).unwrap();
 
         assert_arrays_eq!(
             taken,
@@ -68,7 +65,7 @@ mod tests {
         .unwrap();
         let indices = PrimitiveArray::from_option_iter([Option::<u64>::None]);
         let taken = struct_arr
-            .take(indices.to_array())
+            .take(indices.into_array())
             .unwrap()
             .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
@@ -81,7 +78,7 @@ mod tests {
         let arr = PrimitiveArray::from_iter(Vec::<u64>::new());
         let indices = PrimitiveArray::from_option_iter([Option::<u64>::None]);
         let taken = arr
-            .take(indices.to_array())
+            .take(indices.into_array())
             .unwrap()
             .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
@@ -91,10 +88,10 @@ mod tests {
     #[test]
     fn take_field_struct() {
         let struct_arr =
-            StructArray::from_fields(&[("a", PrimitiveArray::from_iter(0..10).to_array())])
+            StructArray::from_fields(&[("a", PrimitiveArray::from_iter(0..10).into_array())])
                 .unwrap();
         let indices = PrimitiveArray::from_option_iter([Some(1), None]);
-        let taken = struct_arr.take(indices.to_array()).unwrap();
+        let taken = struct_arr.take(indices.into_array()).unwrap();
         assert_arrays_eq!(
             taken,
             StructArray::try_from_iter_with_validity(
@@ -108,9 +105,9 @@ mod tests {
     #[test]
     fn test_mask_empty_struct() {
         test_mask_conformance(
-            StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
+            &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
                 .unwrap()
-                .as_ref(),
+                .into_array(),
         );
     }
 
@@ -126,7 +123,7 @@ mod tests {
             BoolArray::from_iter([Some(true), Some(true), None, None, Some(false)]).into_array();
 
         test_mask_conformance(
-            StructArray::try_new(
+            &StructArray::try_new(
                 ["xs", "ys", "zs"].into(),
                 vec![
                     StructArray::try_new(
@@ -144,7 +141,7 @@ mod tests {
                 Validity::NonNullable,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
     }
 
@@ -179,7 +176,7 @@ mod tests {
             vec![
                 StructArray::try_new(
                     ["left", "right"].into(),
-                    vec![xs.to_array(), xs.to_array()],
+                    vec![xs.clone().into_array(), xs.into_array()],
                     5,
                     Validity::AllValid,
                 )
@@ -252,17 +249,18 @@ mod tests {
     #[test]
     fn test_empty_struct_is_constant() {
         let array = StructArray::new_fieldless_with_len(2);
-        let is_constant =
-            is_constant(array.as_ref()).vortex_expect("operation should succeed in test");
-        assert_eq!(is_constant, Some(true));
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = is_constant(&array.into_array(), &mut ctx)
+            .vortex_expect("operation should succeed in test");
+        assert!(result);
     }
 
     #[test]
     fn test_take_empty_struct_conformance() {
         test_take_conformance(
-            StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
+            &StructArray::try_new(FieldNames::empty(), vec![], 5, Validity::NonNullable)
                 .unwrap()
-                .as_ref(),
+                .into_array(),
         );
     }
 
@@ -276,9 +274,9 @@ mod tests {
         .into_array();
 
         test_take_conformance(
-            StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 5, Validity::NonNullable)
+            &StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 5, Validity::NonNullable)
                 .unwrap()
-                .as_ref(),
+                .into_array(),
         );
     }
 
@@ -292,14 +290,14 @@ mod tests {
         );
 
         test_take_conformance(
-            StructArray::try_new(
+            &StructArray::try_new(
                 ["xs", "ys"].into(),
                 vec![xs.into_array(), ys.into_array()],
                 5,
                 Validity::NonNullable,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
     }
 
@@ -320,14 +318,14 @@ mod tests {
         let outer_zs = BoolArray::from_iter([true, false, true, false, true]).into_array();
 
         test_take_conformance(
-            StructArray::try_new(
+            &StructArray::try_new(
                 ["inner", "z"].into(),
                 vec![inner_struct, outer_zs],
                 5,
                 Validity::NonNullable,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
     }
 
@@ -337,9 +335,9 @@ mod tests {
         let ys = VarBinArray::from_iter(["hello"].map(Some), DType::Utf8(NonNullable)).into_array();
 
         test_take_conformance(
-            StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 1, Validity::NonNullable)
+            &StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 1, Validity::NonNullable)
                 .unwrap()
-                .as_ref(),
+                .into_array(),
         );
     }
 
@@ -355,14 +353,14 @@ mod tests {
         let zs = BoolArray::from_iter((0..100).map(|i| i % 2 == 0)).into_array();
 
         test_take_conformance(
-            StructArray::try_new(
+            &StructArray::try_new(
                 ["xs", "ys", "zs"].into(),
                 vec![xs, ys, zs],
                 100,
                 Validity::NonNullable,
             )
             .unwrap()
-            .as_ref(),
+            .into_array(),
         );
     }
 
@@ -412,6 +410,6 @@ mod tests {
         StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 100, Validity::NonNullable).unwrap()
     })]
     fn test_struct_consistency(#[case] array: StructArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/struct_/compute/rules.rs b/vortex-array/src/arrays/struct_/compute/rules.rs
index 3f5922dd757..91518ca7693 100644
--- a/vortex-array/src/arrays/struct_/compute/rules.rs
+++ b/vortex-array/src/arrays/struct_/compute/rules.rs
@@ -7,13 +7,16 @@ use vortex_error::vortex_err;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayExt;
-use crate::arrays::ScalarFnArrayView;
-use crate::arrays::SliceReduceAdaptor;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
+use crate::arrays::dict::TakeReduceAdaptor;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
+use crate::arrays::slice::SliceReduceAdaptor;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::optimizer::rules::ParentRuleSet;
@@ -23,13 +26,13 @@ use crate::scalar_fn::fns::get_item::GetItem;
 use crate::scalar_fn::fns::mask::Mask;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<StructVTable> = ParentRuleSet::new(&[
+pub(crate) const PARENT_RULES: ParentRuleSet<Struct> = ParentRuleSet::new(&[
     ParentRuleSet::lift(&StructCastPushDownRule),
     ParentRuleSet::lift(&StructGetItemRule),
-    ParentRuleSet::lift(&MaskReduceAdaptor(StructVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(StructVTable)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(Struct)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(Struct)),
+    ParentRuleSet::lift(&TakeReduceAdaptor(Struct)),
 ]);
 
 /// Rule to push down cast into struct fields.
@@ -40,16 +43,18 @@ pub(crate) const PARENT_RULES: ParentRuleSet<StructVTable> = ParentRuleSet::new(
 /// at the end of the struct, filled with null values.
 #[derive(Debug)]
 struct StructCastPushDownRule;
-impl ArrayParentReduceRule<StructVTable> for StructCastPushDownRule {
+impl ArrayParentReduceRule<Struct> for StructCastPushDownRule {
     type Parent = ExactScalarFn<Cast>;
 
     fn reduce_parent(
         &self,
-        array: &StructArray,
+        array: ArrayView<'_, Struct>,
         parent: ScalarFnArrayView<Cast>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
-        let target_fields = parent.options.as_struct_fields();
+        let Some(target_fields) = parent.options.as_struct_fields_opt() else {
+            return Ok(None);
+        };
         let mut new_fields = Vec::with_capacity(target_fields.nfields());
 
         for (target_name, target_dtype) in target_fields.names().iter().zip(target_fields.fields())
@@ -74,12 +79,11 @@ impl ArrayParentReduceRule<StructVTable> for StructCastPushDownRule {
         }
 
         let validity = if parent.options.is_nullable() {
-            array.validity().clone().into_nullable()
+            array.validity()?.into_nullable()
         } else {
             array
-                .validity()
-                .clone()
-                .into_non_nullable(array.len)
+                .validity()?
+                .into_non_nullable(array.len())
                 .ok_or_else(|| vortex_err!("Failed to cast nullable struct to non-nullable"))?
         };
 
@@ -94,21 +98,27 @@ impl ArrayParentReduceRule<StructVTable> for StructCastPushDownRule {
 /// Rule to flatten get_item from struct by field name
 #[derive(Debug)]
 pub(crate) struct StructGetItemRule;
-impl ArrayParentReduceRule<StructVTable> for StructGetItemRule {
+impl ArrayParentReduceRule<Struct> for StructGetItemRule {
     type Parent = ExactScalarFn<GetItem>;
 
     fn reduce_parent(
         &self,
-        child: &StructArray,
+        child: ArrayView<'_, Struct>,
         parent: ScalarFnArrayView<'_, GetItem>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         let field_name = parent.options;
-        let Some(field) = child.unmasked_field_by_name_opt(field_name) else {
-            return Ok(None);
-        };
+        let field = child
+            .unmasked_field_by_name_opt(field_name)
+            .ok_or_else(|| {
+                vortex_err!(
+                    "Field '{}' missing from struct array {}",
+                    field_name,
+                    child.struct_fields().names()
+                )
+            })?;
 
-        match child.validity() {
+        match child.validity()? {
             Validity::NonNullable | Validity::AllValid => {
                 // If the struct is non-nullable or all valid, the field's validity is unchanged
                 Ok(Some(field.clone()))
@@ -125,7 +135,7 @@ impl ArrayParentReduceRule<StructVTable> for StructGetItemRule {
             }
             Validity::Array(mask) => {
                 // If the validity is an array, we need to combine it with the field's validity
-                Mask.try_new_array(field.len(), EmptyOptions, [field.clone(), mask.clone()])
+                Mask.try_new_array(field.len(), EmptyOptions, [field.clone(), mask])
                     .map(Some)
             }
         }
@@ -134,16 +144,20 @@ impl ArrayParentReduceRule<StructVTable> for StructGetItemRule {
 
 #[cfg(test)]
 mod tests {
+    use vortex_buffer::buffer;
+
     use crate::IntoArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::StructArray;
     use crate::arrays::VarBinViewArray;
+    use crate::arrays::struct_::StructArrayExt;
+    use crate::arrays::struct_::compute::rules::ConstantArray;
     use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::canonical::ToCanonical;
     use crate::dtype::DType;
     use crate::dtype::FieldNames;
     use crate::dtype::Nullability;
+    use crate::dtype::PType;
     use crate::dtype::StructFields;
     use crate::scalar::Scalar;
     use crate::validity::Validity;
@@ -171,7 +185,8 @@ mod tests {
             Nullability::NonNullable,
         );
 
-        // Use ArrayBuiltins::cast which goes through the optimizer and applies StructCastPushDownRule
+        // Use `ArrayBuiltins::cast` which goes through the optimizer and applies
+        // `StructCastPushDownRule`.
         let result = source.into_array().cast(target).unwrap().to_struct();
         assert_arrays_eq!(
             result.unmasked_field_by_name("a").unwrap(),
@@ -186,4 +201,124 @@ mod tests {
             ConstantArray::new(Scalar::null(utf8_null), 1)
         );
     }
+
+    /// Regression test: casting a struct to a non-struct DType must not panic. Previously,
+    /// `StructCastPushDownRule` called `as_struct_fields()` which panics on non-struct types.
+    #[test]
+    fn cast_struct_to_non_struct_does_not_panic() {
+        let source = StructArray::try_new(
+            FieldNames::from(["x"]),
+            vec![buffer![1i32, 2, 3].into_array()],
+            3,
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        // Casting a struct to a primitive type should not panic. Before the fix,
+        // `StructCastPushDownRule` would panic via `as_struct_fields()` on the non-struct target.
+        let result = source
+            .into_array()
+            .cast(DType::Primitive(PType::I32, Nullability::NonNullable));
+        // Whether this errors or succeeds depends on execution, but the key invariant is that the
+        // optimizer rule does not panic.
+        if let Ok(arr) = &result {
+            assert_eq!(
+                arr.dtype(),
+                &DType::Primitive(PType::I32, Nullability::NonNullable)
+            );
+        }
+    }
+
+    #[test]
+    fn cast_struct_drop_field() {
+        // Casting to a struct with a subset of fields should succeed.
+        let source = StructArray::try_new(
+            FieldNames::from(["a", "b", "c"]),
+            vec![
+                buffer![1i32, 2, 3].into_array(),
+                buffer![10i64, 20, 30].into_array(),
+                buffer![100u8, 200, 255].into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let target = DType::Struct(
+            StructFields::new(
+                FieldNames::from(["a", "c"]),
+                vec![
+                    DType::Primitive(PType::I32, Nullability::NonNullable),
+                    DType::Primitive(PType::U8, Nullability::NonNullable),
+                ],
+            ),
+            Nullability::NonNullable,
+        );
+
+        let result = source.into_array().cast(target).unwrap().to_struct();
+        assert_eq!(result.unmasked_fields().len(), 2);
+        assert_arrays_eq!(
+            result.unmasked_field_by_name("a").unwrap(),
+            buffer![1i32, 2, 3].into_array()
+        );
+        assert_arrays_eq!(
+            result.unmasked_field_by_name("c").unwrap(),
+            buffer![100u8, 200, 255].into_array()
+        );
+    }
+
+    #[test]
+    fn cast_struct_field_type_widening() {
+        // Casting struct fields to wider types (i32 -> i64).
+        let source = StructArray::try_new(
+            FieldNames::from(["val"]),
+            vec![buffer![1i32, 2, 3].into_array()],
+            3,
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let target = DType::Struct(
+            StructFields::new(
+                FieldNames::from(["val"]),
+                vec![DType::Primitive(PType::I64, Nullability::NonNullable)],
+            ),
+            Nullability::NonNullable,
+        );
+
+        let result = source.into_array().cast(target).unwrap().to_struct();
+        assert_eq!(
+            result.unmasked_field_by_name("val").unwrap().dtype(),
+            &DType::Primitive(PType::I64, Nullability::NonNullable)
+        );
+        assert_arrays_eq!(
+            result.unmasked_field_by_name("val").unwrap(),
+            buffer![1i64, 2, 3].into_array()
+        );
+    }
+
+    #[test]
+    fn cast_struct_add_non_nullable_field_fails() {
+        // Adding a non-nullable field via cast should fail.
+        let source = StructArray::try_new(
+            FieldNames::from(["a"]),
+            vec![buffer![1i32].into_array()],
+            1,
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let target = DType::Struct(
+            StructFields::new(
+                FieldNames::from(["a", "b"]),
+                vec![
+                    DType::Primitive(PType::I32, Nullability::NonNullable),
+                    DType::Primitive(PType::I32, Nullability::NonNullable),
+                ],
+            ),
+            Nullability::NonNullable,
+        );
+
+        assert!(source.into_array().cast(target).is_err());
+    }
 }
diff --git a/vortex-array/src/arrays/struct_/compute/slice.rs b/vortex-array/src/arrays/struct_/compute/slice.rs
index 1249aa7e9da..6f32541d9c3 100644
--- a/vortex-array/src/arrays/struct_/compute/slice.rs
+++ b/vortex-array/src/arrays/struct_/compute/slice.rs
@@ -8,16 +8,16 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::SliceReduce;
+use crate::array::ArrayView;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
-use crate::vtable::ValidityHelper;
+use crate::arrays::slice::SliceReduce;
+use crate::arrays::struct_::StructArrayExt;
 
-impl SliceReduce for StructVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+impl SliceReduce for Struct {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
         let fields: Vec<_> = array
-            .unmasked_fields()
-            .iter()
+            .iter_unmasked_fields()
             .map(|field| field.slice(range.clone()))
             .try_collect()?;
 
@@ -28,7 +28,7 @@ impl SliceReduce for StructVTable {
                     fields,
                     array.struct_fields().clone(),
                     range.len(),
-                    array.validity().slice(range)?,
+                    array.validity()?.slice(range)?,
                 )
             }
             .into_array(),
diff --git a/vortex-array/src/arrays/struct_/compute/take.rs b/vortex-array/src/arrays/struct_/compute/take.rs
index 851c33d802e..a63c6c85cf6 100644
--- a/vortex-array/src/arrays/struct_/compute/take.rs
+++ b/vortex-array/src/arrays/struct_/compute/take.rs
@@ -3,29 +3,24 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
-use crate::arrays::TakeExecute;
+use crate::arrays::dict::TakeReduce;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar::Scalar;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl TakeExecute for StructVTable {
-    fn take(
-        array: &StructArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
+impl TakeReduce for Struct {
+    fn take(array: ArrayView<'_, Struct>, indices: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // If the struct array is empty then the indices must be all null, otherwise it will access
         // an out of bounds element.
         if array.is_empty() {
             return StructArray::try_new_with_dtype(
-                array.unmasked_fields().clone(),
+                array.iter_unmasked_fields().cloned().collect::<Vec<_>>(),
                 array.struct_fields().clone(),
                 indices.len(),
                 Validity::AllInvalid,
@@ -40,17 +35,16 @@ impl TakeExecute for StructVTable {
         // Note that we strip nullability so that `Take::return_dtype` doesn't union nullable into
         // each field's dtype (the struct-level validity already captures which rows are null).
         let fill_scalar = Scalar::zero_value(&indices.dtype().as_nonnullable());
-        let inner_indices = &indices.to_array().fill_null(fill_scalar)?;
+        let inner_indices = indices.clone().fill_null(fill_scalar)?;
 
         StructArray::try_new_with_dtype(
             array
-                .unmasked_fields()
-                .iter()
-                .map(|field| field.take(inner_indices.to_array()))
+                .iter_unmasked_fields()
+                .map(|field| field.take(inner_indices.clone()))
                 .collect::<Result<Vec<_>, _>>()?,
             array.struct_fields().clone(),
             indices.len(),
-            array.validity().take(indices)?,
+            array.validity()?.take(indices)?,
         )
         .map(|a| a.into_array())
         .map(Some)
diff --git a/vortex-array/src/arrays/struct_/compute/zip.rs b/vortex-array/src/arrays/struct_/compute/zip.rs
index fe8f8a559d0..cf7b7b91d6d 100644
--- a/vortex-array/src/arrays/struct_/compute/zip.rs
+++ b/vortex-array/src/arrays/struct_/compute/zip.rs
@@ -6,27 +6,26 @@ use std::ops::BitOr;
 use std::ops::Not;
 
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructVTable;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar_fn::fns::zip::ZipKernel;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ZipKernel for StructVTable {
+impl ZipKernel for Struct {
     fn zip(
-        if_true: &StructArray,
-        if_false: &dyn Array,
-        mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        if_true: ArrayView<'_, Struct>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let Some(if_false) = if_false.as_opt::<StructVTable>() else {
+        let Some(if_false) = if_false.as_opt::<Struct>() else {
             return Ok(None);
         };
         assert_eq!(
@@ -36,32 +35,34 @@ impl ZipKernel for StructVTable {
         );
 
         let fields = if_true
-            .unmasked_fields()
-            .iter()
-            .zip(if_false.unmasked_fields().iter())
-            .map(|(t, f)| ArrayBuiltins::zip(t, f.clone(), mask.clone().into_array()))
+            .iter_unmasked_fields()
+            .zip(if_false.iter_unmasked_fields())
+            .map(|(t, f)| ArrayBuiltins::zip(mask, t.clone(), f.clone()))
             .collect::<VortexResult<Vec<_>>>()?;
 
-        let validity = match (if_true.validity(), if_false.validity()) {
-            (&Validity::NonNullable, &Validity::NonNullable) => Validity::NonNullable,
-            (&Validity::AllValid, &Validity::AllValid) => Validity::AllValid,
-            (&Validity::AllInvalid, &Validity::AllInvalid) => Validity::AllInvalid,
+        let v1 = if_true.validity()?;
+        let v2 = if_false.validity()?;
+        let validity = match (&v1, &v2) {
+            (Validity::NonNullable, Validity::NonNullable) => Validity::NonNullable,
+            (Validity::AllValid, Validity::AllValid) => Validity::AllValid,
+            (Validity::AllInvalid, Validity::AllInvalid) => Validity::AllInvalid,
 
             (v1, v2) => {
-                let v1m = v1.to_mask(if_true.len());
-                let v2m = v2.to_mask(if_false.len());
+                let mask_mask = mask.try_to_mask_fill_null_false(ctx)?;
+                let v1m = v1.execute_mask(if_true.len(), ctx)?;
+                let v2m = v2.execute_mask(if_false.len(), ctx)?;
 
-                let combined = (v1m.bitand(mask)).bitor(&v2m.bitand(&mask.not()));
+                let combined = (v1m.bitand(&mask_mask)).bitor(&v2m.bitand(&mask_mask.not()));
                 Validity::from_mask(
                     combined,
-                    if_true.dtype.nullability() | if_false.dtype.nullability(),
+                    if_true.dtype().nullability() | if_false.dtype().nullability(),
                 )
             }
         };
 
         Ok(Some(
             StructArray::try_new(if_true.names().clone(), fields, if_true.len(), validity)?
-                .to_array(),
+                .into_array(),
         ))
     }
 }
@@ -73,8 +74,7 @@ mod tests {
     use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
-    #[expect(deprecated)]
-    use crate::compute::zip;
+    use crate::builtins::ArrayBuiltins;
     use crate::dtype::FieldNames;
     use crate::validity::Validity;
 
@@ -99,8 +99,7 @@ mod tests {
 
         let mask = Mask::from_iter([false, false, true, false]);
 
-        #[expect(deprecated)]
-        let result = zip(&if_true, &if_false, &mask).unwrap();
+        let result = mask.into_array().zip(if_true, if_false).unwrap();
 
         insta::assert_snapshot!(result.display_table(), @r"
         ┌───────┐
@@ -137,8 +136,7 @@ mod tests {
 
         let mask = Mask::from_iter([true, false, false, false]);
 
-        #[expect(deprecated)]
-        let result = zip(&if_true, &if_false, &mask).unwrap();
+        let result = mask.into_array().zip(if_true, if_false).unwrap();
 
         insta::assert_snapshot!(result.display_table(), @r"
         ┌───────┐
diff --git a/vortex-array/src/arrays/struct_/mod.rs b/vortex-array/src/arrays/struct_/mod.rs
index c8d95319854..5fccb58f9cd 100644
--- a/vortex-array/src/arrays/struct_/mod.rs
+++ b/vortex-array/src/arrays/struct_/mod.rs
@@ -2,12 +2,13 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::StructArray;
-pub use array::StructArrayParts;
+pub use array::StructArrayExt;
+pub use array::StructDataParts;
+pub use vtable::StructArray;
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::StructVTable;
+pub use vtable::Struct;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/arrays/struct_/tests.rs b/vortex-array/src/arrays/struct_/tests.rs
index 83df1440489..38b12074900 100644
--- a/vortex-array/src/arrays/struct_/tests.rs
+++ b/vortex-array/src/arrays/struct_/tests.rs
@@ -7,9 +7,10 @@ use vortex_error::VortexResult;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
-use crate::arrays::primitive::PrimitiveArray;
-use crate::arrays::struct_::StructArray;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::StructArray;
+use crate::arrays::VarBinArray;
+use crate::arrays::struct_::StructArrayExt;
 use crate::assert_arrays_eq;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
@@ -45,13 +46,13 @@ fn test_project() {
 
     assert_eq!(struct_b.len(), 5);
 
-    let bools = &struct_b.fields[0];
+    let bools = struct_b.unmasked_field(0);
     assert_arrays_eq!(
         bools,
         BoolArray::from_iter([true, true, true, false, false])
     );
 
-    let prims = &struct_b.fields[1];
+    let prims = struct_b.unmasked_field(1);
     assert_arrays_eq!(prims, PrimitiveArray::from_iter([0i64, 1, 2, 3, 4]));
 }
 
@@ -60,7 +61,7 @@ fn test_remove_column() {
     let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::NonNullable);
     let ys = PrimitiveArray::new(buffer![4u64, 5, 6, 7, 8], Validity::NonNullable);
 
-    let mut struct_a = StructArray::try_new(
+    let struct_a = StructArray::try_new(
         FieldNames::from(["xs", "ys"]),
         vec![xs.into_array(), ys.into_array()],
         5,
@@ -68,31 +69,31 @@ fn test_remove_column() {
     )
     .unwrap();
 
-    let removed = struct_a.remove_column("xs").unwrap();
+    let (data, removed) = struct_a.remove_column("xs").unwrap();
     assert_eq!(
         removed.dtype(),
         &DType::Primitive(PType::I64, Nullability::NonNullable)
     );
     assert_arrays_eq!(removed, PrimitiveArray::from_iter([0i64, 1, 2, 3, 4]));
 
-    assert_eq!(struct_a.names(), &["ys"]);
-    assert_eq!(struct_a.fields.len(), 1);
-    assert_eq!(struct_a.len(), 5);
+    assert_eq!(data.names(), &["ys"]);
+    assert_eq!(data.struct_fields().nfields(), 1);
+    assert_eq!(data.len(), 5);
     assert_eq!(
-        struct_a.fields[0].dtype(),
+        data.unmasked_field(0).dtype(),
         &DType::Primitive(PType::U64, Nullability::NonNullable)
     );
     assert_arrays_eq!(
-        struct_a.fields[0],
+        data.unmasked_field(0),
         PrimitiveArray::from_iter([4u64, 5, 6, 7, 8])
     );
 
-    let empty = struct_a.remove_column("non_existent");
+    let empty = data.remove_column("non_existent");
     assert!(
         empty.is_none(),
         "Expected None when removing non-existent column"
     );
-    assert_eq!(struct_a.names(), &["ys"]);
+    assert_eq!(data.names(), &["ys"]);
 }
 
 #[test]
@@ -126,7 +127,7 @@ fn test_duplicate_field_names() {
     );
 
     // Verify the third field (second "value") can be accessed by index
-    let third_field = &struct_array.unmasked_fields()[2];
+    let third_field = struct_array.unmasked_field(2);
     assert_arrays_eq!(third_field, PrimitiveArray::from_iter([100i32, 200, 300]));
 }
 
diff --git a/vortex-array/src/arrays/struct_/vtable/array.rs b/vortex-array/src/arrays/struct_/vtable/array.rs
deleted file mode 100644
index e8679511445..00000000000
--- a/vortex-array/src/arrays/struct_/vtable/array.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::struct_::StructArray;
-use crate::arrays::struct_::StructVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<StructVTable> for StructVTable {
-    fn len(array: &StructArray) -> usize {
-        array.len
-    }
-
-    fn dtype(array: &StructArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &StructArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &StructArray, state: &mut H, precision: Precision) {
-        array.len.hash(state);
-        array.dtype.hash(state);
-        for field in array.fields.iter() {
-            field.array_hash(state, precision);
-        }
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &StructArray, other: &StructArray, precision: Precision) -> bool {
-        array.len == other.len
-            && array.dtype == other.dtype
-            && array.fields.len() == other.fields.len()
-            && array
-                .fields
-                .iter()
-                .zip(other.fields.iter())
-                .all(|(a, b)| a.array_eq(b, precision))
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/struct_/vtable/kernel.rs b/vortex-array/src/arrays/struct_/vtable/kernel.rs
index 14c5d49616e..1c5c9f3db3a 100644
--- a/vortex-array/src/arrays/struct_/vtable/kernel.rs
+++ b/vortex-array/src/arrays/struct_/vtable/kernel.rs
@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::StructVTable;
-use crate::arrays::TakeExecuteAdaptor;
+use crate::arrays::Struct;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::cast::CastExecuteAdaptor;
 use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<StructVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CastExecuteAdaptor(StructVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(StructVTable)),
-    ParentKernelSet::lift(&ZipExecuteAdaptor(StructVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<Struct> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CastExecuteAdaptor(Struct)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(Struct)),
 ]);
diff --git a/vortex-array/src/arrays/struct_/vtable/mod.rs b/vortex-array/src/arrays/struct_/vtable/mod.rs
index 97283b3e944..f33cea360c3 100644
--- a/vortex-array/src/arrays/struct_/vtable/mod.rs
+++ b/vortex-array/src/arrays/struct_/vtable/mod.rs
@@ -1,78 +1,144 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::sync::Arc;
-
 use itertools::Itertools;
 use kernel::PARENT_KERNELS;
 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 crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::arrays::struct_::StructArray;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayView;
+use crate::array::EmptyArrayData;
+use crate::array::VTable;
+use crate::array::child_to_validity;
+use crate::arrays::struct_::array::FIELDS_OFFSET;
+use crate::arrays::struct_::array::VALIDITY_SLOT;
+use crate::arrays::struct_::array::make_struct_slots;
 use crate::arrays::struct_::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
-
-use crate::vtable::ArrayId;
 
-vtable!(Struct);
+use crate::array::ArrayId;
 
-impl VTable for StructVTable {
-    type Array = StructArray;
+/// A [`Struct`]-encoded Vortex array.
+pub type StructArray = Array<Struct>;
 
-    type Metadata = EmptyMetadata;
+impl VTable for Struct {
+    type ArrayData = EmptyArrayData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &StructArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn validate(
+        &self,
+        _data: &EmptyArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        let DType::Struct(struct_dtype, nullability) = dtype else {
+            vortex_bail!("Expected struct dtype, found {:?}", dtype)
+        };
+
+        let expected_slots = struct_dtype.nfields() + 1;
+        if slots.len() != expected_slots {
+            vortex_bail!(
+                InvalidArgument: "StructArray has {} slots but expected {}",
+                slots.len(),
+                expected_slots
+            );
+        }
+
+        let validity = child_to_validity(&slots[VALIDITY_SLOT], *nullability);
+        if let Some(validity_len) = validity.maybe_len()
+            && validity_len != len
+        {
+            vortex_bail!(
+                InvalidArgument: "StructArray validity length {} does not match outer length {}",
+                validity_len,
+                len
+            );
+        }
+
+        let field_slots = &slots[FIELDS_OFFSET..];
+        if field_slots.is_empty() {
+            return Ok(());
+        }
+
+        for (idx, (slot, field_dtype)) in field_slots.iter().zip(struct_dtype.fields()).enumerate()
+        {
+            let field = slot
+                .as_ref()
+                .ok_or_else(|| vortex_error::vortex_err!("StructArray missing field slot {idx}"))?;
+            if field.len() != len {
+                vortex_bail!(
+                    InvalidArgument: "StructArray field {idx} has length {} but expected {}",
+                    field.len(),
+                    len
+                );
+            }
+            if field.dtype() != &field_dtype {
+                vortex_bail!(
+                    InvalidArgument: "StructArray field {idx} has dtype {} but expected {}",
+                    field.dtype(),
+                    field_dtype
+                );
+            }
+        }
+
+        Ok(())
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("StructArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        vortex_panic!("StructArray buffer_name index {idx} out of bounds")
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         _buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<StructArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "StructArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         let DType::Struct(struct_dtype, nullability) = dtype else {
             vortex_bail!("Expected struct dtype, found {:?}", dtype)
         };
@@ -80,7 +146,6 @@ impl VTable for StructVTable {
         let (validity, non_data_children) = if children.len() == struct_dtype.nfields() {
             (Validity::from(*nullability), 0_usize)
         } else if children.len() == struct_dtype.nfields() + 1 {
-            // Validity is the first child if it exists.
             let validity = children.get(0, &Validity::DTYPE, len)?;
             (Validity::Array(validity), 1_usize)
         } else {
@@ -92,7 +157,7 @@ impl VTable for StructVTable {
             );
         };
 
-        let children: Vec<_> = (0..struct_dtype.nfields())
+        let field_children: Vec<_> = (0..struct_dtype.nfields())
             .map(|i| {
                 let child_dtype = struct_dtype
                     .field_by_index(i)
@@ -101,47 +166,27 @@ impl VTable for StructVTable {
             })
             .try_collect()?;
 
-        StructArray::try_new_with_dtype(children, struct_dtype.clone(), len, validity)
+        let slots = make_struct_slots(&field_children, &validity, len);
+        Ok(
+            crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, EmptyArrayData)
+                .with_slots(slots),
+        )
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        let DType::Struct(struct_dtype, _nullability) = &array.dtype else {
-            vortex_bail!("Expected struct dtype, found {:?}", array.dtype)
-        };
-
-        // First child is validity (if present), followed by fields
-        let (validity, non_data_children) = if children.len() == struct_dtype.nfields() {
-            (array.validity.clone(), 0_usize)
-        } else if children.len() == struct_dtype.nfields() + 1 {
-            (Validity::Array(children[0].clone()), 1_usize)
+    fn slot_name(array: ArrayView<'_, Self>, idx: usize) -> String {
+        if idx == VALIDITY_SLOT {
+            "validity".to_string()
         } else {
-            vortex_bail!(
-                "Expected {} or {} children, found {}",
-                struct_dtype.nfields(),
-                struct_dtype.nfields() + 1,
-                children.len()
-            );
-        };
-
-        let fields: Arc<[ArrayRef]> = children.into_iter().skip(non_data_children).collect();
-        vortex_ensure!(
-            fields.len() == struct_dtype.nfields(),
-            "Expected {} field children, found {}",
-            struct_dtype.nfields(),
-            fields.len()
-        );
-
-        array.fields = fields;
-        array.validity = validity;
-        Ok(())
+            array.dtype().as_struct_fields().names()[idx - FIELDS_OFFSET].to_string()
+        }
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -149,7 +194,7 @@ impl VTable for StructVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -158,9 +203,9 @@ impl VTable for StructVTable {
     }
 }
 
-#[derive(Debug)]
-pub struct StructVTable;
+#[derive(Clone, Debug)]
+pub struct Struct;
 
-impl StructVTable {
+impl Struct {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.struct");
 }
diff --git a/vortex-array/src/arrays/struct_/vtable/operations.rs b/vortex-array/src/arrays/struct_/vtable/operations.rs
index dba7a594ed1..021d93f3c2f 100644
--- a/vortex-array/src/arrays/struct_/vtable/operations.rs
+++ b/vortex-array/src/arrays/struct_/vtable/operations.rs
@@ -3,19 +3,25 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
-use crate::arrays::struct_::StructArray;
-use crate::arrays::struct_::StructVTable;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Struct;
+use crate::arrays::struct_::StructArrayExt;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<StructVTable> for StructVTable {
-    fn scalar_at(array: &StructArray, index: usize) -> VortexResult<Scalar> {
-        let field_scalars: VortexResult<Vec<_>> = array
-            .unmasked_fields()
-            .iter()
+impl OperationsVTable<Struct> for Struct {
+    fn scalar_at(
+        array: ArrayView<'_, Struct>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        let field_scalars: VortexResult<Vec<Scalar>> = array
+            .iter_unmasked_fields()
             .map(|field| field.scalar_at(index))
             .collect();
-        Ok(Scalar::struct_(array.dtype().clone(), field_scalars?))
+        // SAFETY: The vtable guarantees index is in-bounds and non-null before this is called.
+        // Each field's scalar_at returns a scalar with the field's own dtype.
+        Ok(unsafe { Scalar::struct_unchecked(array.dtype().clone(), field_scalars?) })
     }
 }
diff --git a/vortex-array/src/arrays/struct_/vtable/validity.rs b/vortex-array/src/arrays/struct_/vtable/validity.rs
index 8d676e1f8d4..1545162bae5 100644
--- a/vortex-array/src/arrays/struct_/vtable/validity.rs
+++ b/vortex-array/src/arrays/struct_/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::struct_::StructArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::struct_::StructArrayExt;
+use crate::arrays::struct_::vtable::Struct;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for StructArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<Struct> for Struct {
+    fn validity(array: ArrayView<'_, Struct>) -> VortexResult<Validity> {
+        Ok(array.struct_validity())
     }
 }
diff --git a/vortex-array/src/arrays/struct_/vtable/visitor.rs b/vortex-array/src/arrays/struct_/vtable/visitor.rs
deleted file mode 100644
index 0e38580be12..00000000000
--- a/vortex-array/src/arrays/struct_/vtable/visitor.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayChildVisitorUnnamed;
-use crate::ArrayRef;
-use crate::arrays::struct_::StructArray;
-use crate::arrays::struct_::StructVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<StructVTable> for StructVTable {
-    fn visit_buffers(_array: &StructArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn nbuffers(_array: &StructArray) -> usize {
-        0
-    }
-
-    fn visit_children(array: &StructArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(array.validity(), array.len());
-        for (name, field) in array.names().iter().zip_eq(array.unmasked_fields().iter()) {
-            visitor.visit_child(name.as_ref(), field);
-        }
-    }
-
-    fn visit_children_unnamed(array: &StructArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
-        visitor.visit_validity(array.validity(), array.len());
-        for field in array.unmasked_fields().iter() {
-            visitor.visit_child(field);
-        }
-    }
-
-    fn nchildren(array: &StructArray) -> usize {
-        validity_nchildren(array.validity()) + array.unmasked_fields().len()
-    }
-
-    fn nth_child(array: &StructArray, idx: usize) -> Option<ArrayRef> {
-        let validity_children = validity_nchildren(array.validity());
-        if idx < validity_children {
-            validity_to_child(array.validity(), array.len())
-        } else {
-            array
-                .unmasked_fields()
-                .get(idx - validity_children)
-                .cloned()
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/validation_tests.rs b/vortex-array/src/arrays/validation_tests.rs
index c4747fc9c50..30758a5c29e 100644
--- a/vortex-array/src/arrays/validation_tests.rs
+++ b/vortex-array/src/arrays/validation_tests.rs
@@ -16,8 +16,15 @@ mod tests {
     use vortex_error::VortexError;
 
     use crate::IntoArray;
-    use crate::arrays::BinaryView;
-    use crate::arrays::*;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::DecimalArray;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::StructArray;
+    use crate::arrays::VarBinArray;
+    use crate::arrays::VarBinViewArray;
+    use crate::arrays::varbinview::build_views::BinaryView;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
diff --git a/vortex-array/src/arrays/varbin/accessor.rs b/vortex-array/src/arrays/varbin/accessor.rs
index b9a5c613028..aa84ac64421 100644
--- a/vortex-array/src/arrays/varbin/accessor.rs
+++ b/vortex-array/src/arrays/varbin/accessor.rs
@@ -3,12 +3,14 @@
 
 use std::iter;
 
+use vortex_error::VortexExpect;
+
 use crate::ToCanonical;
 use crate::accessor::ArrayAccessor;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::VarBinArray;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::match_each_integer_ptype;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 impl ArrayAccessor<[u8]> for VarBinArray {
     fn with_iterator<F, R>(&self, f: F) -> R
@@ -16,7 +18,9 @@ impl ArrayAccessor<[u8]> for VarBinArray {
         F: for<'a> FnOnce(&mut dyn Iterator<Item = Option<&'a [u8]>>) -> R,
     {
         let offsets = self.offsets().to_primitive();
-        let validity = self.validity();
+        let validity = self
+            .validity()
+            .vortex_expect("varbin validity should be derivable");
 
         let bytes = self.bytes();
         let bytes = bytes.as_slice();
diff --git a/vortex-array/src/arrays/varbin/array.rs b/vortex-array/src/arrays/varbin/array.rs
index bc9ed6e639c..7fbbcb27b2c 100644
--- a/vortex-array/src/arrays/varbin/array.rs
+++ b/vortex-array/src/arrays/varbin/array.rs
@@ -1,71 +1,101 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+
 use num_traits::AsPrimitive;
-use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::IntoArray;
 use crate::ToCanonical;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::VarBin;
 use crate::arrays::varbin::builder::VarBinBuilder;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::dtype::Nullability;
 use crate::match_each_integer_ptype;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// The offsets array defining the start/end of each variable-length binary element.
+pub(super) const OFFSETS_SLOT: usize = 0;
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 1;
+pub(super) const NUM_SLOTS: usize = 2;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["offsets", "validity"];
+
 #[derive(Clone, Debug)]
-pub struct VarBinArray {
-    pub(super) dtype: DType,
+pub struct VarBinData {
     pub(super) bytes: BufferHandle,
-    pub(super) offsets: ArrayRef,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
 }
 
-impl VarBinArray {
-    /// Creates a new [`VarBinArray`].
+impl Display for VarBinData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+pub struct VarBinDataParts {
+    pub dtype: DType,
+    pub bytes: BufferHandle,
+    pub offsets: ArrayRef,
+    pub validity: Validity,
+}
+
+impl VarBinData {
+    /// Creates a new `VarBinArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`VarBinArray::new_unchecked`].
-    pub fn new(offsets: ArrayRef, bytes: ByteBuffer, dtype: DType, validity: Validity) -> Self {
-        Self::try_new(offsets, bytes, dtype, validity).vortex_expect("VarBinArray new")
+    /// in `VarBinArray::new_unchecked`.
+    pub fn build(offsets: ArrayRef, bytes: ByteBuffer, dtype: DType, validity: Validity) -> Self {
+        Self::try_build(offsets, bytes, dtype, validity).vortex_expect("VarBinArray new")
     }
 
-    /// Creates a new [`VarBinArray`].
+    /// Creates a new `VarBinArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`VarBinArray::new_unchecked`].
-    pub fn new_from_handle(
+    /// in `VarBinArray::new_unchecked`.
+    pub fn build_from_handle(
         offset: ArrayRef,
         bytes: BufferHandle,
         dtype: DType,
         validity: Validity,
     ) -> Self {
-        Self::try_new_from_handle(offset, bytes, dtype, validity).vortex_expect("VarBinArray new")
+        Self::try_build_from_handle(offset, bytes, dtype, validity).vortex_expect("VarBinArray new")
+    }
+
+    pub(crate) fn make_slots(
+        offsets: ArrayRef,
+        validity: &Validity,
+        len: usize,
+    ) -> Vec<Option<ArrayRef>> {
+        vec![Some(offsets), validity_to_child(validity, len)]
     }
 
     /// Constructs a new `VarBinArray`.
     ///
-    /// See [`VarBinArray::new_unchecked`] for more information.
+    /// See `VarBinArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`VarBinArray::new_unchecked`].
-    pub fn try_new(
+    /// `VarBinArray::new_unchecked`.
+    pub fn try_build(
         offsets: ArrayRef,
         bytes: ByteBuffer,
         dtype: DType,
@@ -75,19 +105,19 @@ impl VarBinArray {
         Self::validate(&offsets, &bytes, &dtype, &validity)?;
 
         // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked_from_handle(offsets, bytes, dtype, validity) })
+        Ok(unsafe { Self::new_unchecked_from_handle(bytes) })
     }
 
     /// Constructs a new `VarBinArray` from a `BufferHandle` of memory that may exist
     /// on the CPU or GPU.
     ///
-    /// See [`VarBinArray::new_unchecked`] for more information.
+    /// See `VarBinArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`VarBinArray::new_unchecked`].
-    pub fn try_new_from_handle(
+    /// `VarBinArray::new_unchecked`.
+    pub fn try_build_from_handle(
         offsets: ArrayRef,
         bytes: BufferHandle,
         dtype: DType,
@@ -96,10 +126,10 @@ impl VarBinArray {
         Self::validate(&offsets, &bytes, &dtype, &validity)?;
 
         // SAFETY: validate ensures all invariants are met.
-        Ok(unsafe { Self::new_unchecked_from_handle(offsets, bytes, dtype, validity) })
+        Ok(unsafe { Self::new_unchecked_from_handle(bytes) })
     }
 
-    /// Creates a new [`VarBinArray`] without validation from these components:
+    /// Creates a new `VarBinArray` without validation from these components:
     ///
     /// * `offsets` is an array of byte offsets into the `bytes` buffer.
     /// * `bytes` is a buffer containing all the variable-length data concatenated.
@@ -127,49 +157,27 @@ impl VarBinArray {
     /// ## Validity Requirements
     ///
     /// - If `validity` is [`Validity::Array`], its length must exactly equal `offsets.len() - 1`.
-    pub unsafe fn new_unchecked(
-        offsets: ArrayRef,
-        bytes: ByteBuffer,
-        dtype: DType,
-        validity: Validity,
-    ) -> Self {
+    pub unsafe fn new_unchecked(bytes: ByteBuffer) -> Self {
         // SAFETY: `new_unchecked_from_handle` has same invariants which should be checked
         //  by caller.
-        unsafe {
-            Self::new_unchecked_from_handle(offsets, BufferHandle::new_host(bytes), dtype, validity)
-        }
+        unsafe { Self::new_unchecked_from_handle(BufferHandle::new_host(bytes)) }
     }
 
-    /// Creates a new [`VarBinArray`] without validation from its components, with string data
+    /// Creates a new `VarBinArray` without validation from its components, with string data
     /// stored in a `BufferHandle` (CPU or GPU).
     ///
     /// # Safety
     ///
     /// The caller must ensure all the invariants documented in `new_unchecked` are satisfied.
-    pub unsafe fn new_unchecked_from_handle(
-        offsets: ArrayRef,
-        bytes: BufferHandle,
-        dtype: DType,
-        validity: Validity,
-    ) -> Self {
-        #[cfg(debug_assertions)]
-        Self::validate(&offsets, &bytes, &dtype, &validity)
-            .vortex_expect("[Debug Assertion]: Invalid `VarBinArray` parameters");
-
-        Self {
-            dtype,
-            bytes,
-            offsets,
-            validity,
-            stats_set: Default::default(),
-        }
+    pub unsafe fn new_unchecked_from_handle(bytes: BufferHandle) -> Self {
+        Self { bytes }
     }
 
-    /// Validates the components that would be used to create a [`VarBinArray`].
+    /// Validates the components that would be used to create a `VarBinArray`.
     ///
-    /// This function checks all the invariants required by [`VarBinArray::new_unchecked`].
+    /// This function checks all the invariants required by `VarBinArray::new_unchecked`.
     pub fn validate(
-        offsets: &dyn Array,
+        offsets: &ArrayRef,
         bytes: &BufferHandle,
         dtype: &DType,
         validity: &Validity,
@@ -188,7 +196,7 @@ impl VarBinArray {
 
         // Check nullability matches
         vortex_ensure!(
-            dtype.is_nullable() != (validity == &Validity::NonNullable),
+            dtype.is_nullable() != matches!(validity, Validity::NonNullable),
             InvalidArgument: "incorrect validity {:?} for dtype {}",
             validity,
             dtype
@@ -259,17 +267,12 @@ impl VarBinArray {
         Ok(())
     }
 
-    #[inline]
-    pub fn offsets(&self) -> &ArrayRef {
-        &self.offsets
-    }
-
     /// Access the value bytes child buffer
     ///
     /// # Note
     ///
     /// Bytes child buffer is never sliced when the array is sliced so this can include values
-    /// that are not logically present in the array. Users should prefer [sliced_bytes][Self::sliced_bytes]
+    /// that are not logically present in the array. Users should prefer `sliced_bytes`
     /// unless they're resolving values via the offset child array.
     #[inline]
     pub fn bytes(&self) -> &ByteBuffer {
@@ -281,16 +284,74 @@ impl VarBinArray {
     pub fn bytes_handle(&self) -> &BufferHandle {
         &self.bytes
     }
+}
 
-    /// Access value bytes child array limited to values that are logically present in
-    /// the array unlike [bytes][Self::bytes].
-    pub fn sliced_bytes(&self) -> ByteBuffer {
-        let first_offset: usize = self.offset_at(0);
-        let last_offset = self.offset_at(self.len());
+pub trait VarBinArrayExt: TypedArrayRef<VarBin> {
+    fn offsets(&self) -> &ArrayRef {
+        self.as_ref().slots()[OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("VarBinArray offsets slot")
+    }
 
+    fn validity_child(&self) -> Option<&ArrayRef> {
+        self.as_ref().slots()[VALIDITY_SLOT].as_ref()
+    }
+
+    fn dtype_parts(&self) -> (bool, Nullability) {
+        match self.as_ref().dtype() {
+            DType::Utf8(nullability) => (true, *nullability),
+            DType::Binary(nullability) => (false, *nullability),
+            _ => unreachable!("VarBinArrayExt requires a utf8 or binary dtype"),
+        }
+    }
+
+    fn is_utf8(&self) -> bool {
+        self.dtype_parts().0
+    }
+
+    fn nullability(&self) -> Nullability {
+        self.dtype_parts().1
+    }
+
+    fn varbin_validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.nullability())
+    }
+
+    fn varbin_validity_mask(&self) -> Mask {
+        self.varbin_validity().to_mask(self.as_ref().len())
+    }
+
+    fn offset_at(&self, index: usize) -> usize {
+        assert!(
+            index <= self.as_ref().len(),
+            "Index {index} out of bounds 0..={}",
+            self.as_ref().len()
+        );
+
+        (&self
+            .offsets()
+            .scalar_at(index)
+            .vortex_expect("offsets must support scalar_at"))
+            .try_into()
+            .vortex_expect("Failed to convert offset to usize")
+    }
+
+    fn bytes_at(&self, index: usize) -> ByteBuffer {
+        let start = self.offset_at(index);
+        let end = self.offset_at(index + 1);
+        self.bytes().slice(start..end)
+    }
+
+    fn sliced_bytes(&self) -> ByteBuffer {
+        let first_offset: usize = self.offset_at(0);
+        let last_offset = self.offset_at(self.as_ref().len());
         self.bytes().slice(first_offset..last_offset)
     }
+}
+impl<T: TypedArrayRef<VarBin>> VarBinArrayExt for T {}
 
+/// Forwarding constructors for `VarBinArray` (= `Array<VarBin>`).
+impl Array<VarBin> {
     pub fn from_vec<T: AsRef<[u8]>>(vec: Vec<T>, dtype: DType) -> Self {
         let size: usize = vec.iter().map(|v| v.as_ref().len()).sum();
         if size < u32::MAX as usize {
@@ -300,18 +361,6 @@ impl VarBinArray {
         }
     }
 
-    fn from_vec_sized<O, T>(vec: Vec<T>, dtype: DType) -> Self
-    where
-        O: IntegerPType,
-        T: AsRef<[u8]>,
-    {
-        let mut builder = VarBinBuilder::<O>::with_capacity(vec.len());
-        for v in vec {
-            builder.append_value(v.as_ref());
-        }
-        builder.finish(dtype)
-    }
-
     #[expect(
         clippy::same_name_method,
         reason = "intentionally named from_iter like Iterator::from_iter"
@@ -340,143 +389,195 @@ impl VarBinArray {
         builder.finish(dtype)
     }
 
-    /// Get value offset at a given index
-    ///
-    /// Note: There's 1 more offsets than the elements in the array, thus last offset is at array length index
-    ///
-    /// Panics if index is out of bounds
-    pub fn offset_at(&self, index: usize) -> usize {
-        assert!(
-            index <= self.len(),
-            "Index {index} out of bounds 0..={}",
-            self.len()
-        );
+    fn from_vec_sized<O, T>(vec: Vec<T>, dtype: DType) -> Self
+    where
+        O: IntegerPType,
+        T: AsRef<[u8]>,
+    {
+        let mut builder = VarBinBuilder::<O>::with_capacity(vec.len());
+        for v in vec {
+            builder.append_value(v.as_ref());
+        }
+        builder.finish(dtype)
+    }
 
-        (&self
-            .offsets()
-            .scalar_at(index)
-            .vortex_expect("offsets must support scalar_at"))
-            .try_into()
-            .vortex_expect("Failed to convert offset to usize")
+    /// Create from a vector of string slices.
+    pub fn from_strs(value: Vec<&str>) -> Self {
+        Self::from_vec(value, DType::Utf8(Nullability::NonNullable))
     }
 
-    /// Access value bytes at a given index
-    ///
-    /// Will return buffer referencing underlying data without performing a copy
-    pub fn bytes_at(&self, index: usize) -> ByteBuffer {
-        let start = self.offset_at(index);
-        let end = self.offset_at(index + 1);
+    /// Create from a vector of optional string slices.
+    pub fn from_nullable_strs(value: Vec<Option<&str>>) -> Self {
+        Self::from_iter(value, DType::Utf8(Nullability::Nullable))
+    }
 
-        self.bytes().slice(start..end)
+    /// Create from a vector of byte slices.
+    pub fn from_bytes(value: Vec<&[u8]>) -> Self {
+        Self::from_vec(value, DType::Binary(Nullability::NonNullable))
+    }
+
+    /// Create from a vector of optional byte slices.
+    pub fn from_nullable_bytes(value: Vec<Option<&[u8]>>) -> Self {
+        Self::from_iter(value, DType::Binary(Nullability::Nullable))
     }
 
-    /// Consumes self, returning a tuple containing the `DType`, the `bytes` array,
-    /// the `offsets` array, and the `validity`.
-    pub fn into_parts(self) -> (DType, BufferHandle, ArrayRef, Validity) {
-        (self.dtype, self.bytes, self.offsets, self.validity)
+    pub fn into_data_parts(self) -> VarBinDataParts {
+        let dtype = self.dtype().clone();
+        let validity = self.varbin_validity();
+        let offsets = self.offsets().clone();
+        let data = self.into_data();
+        VarBinDataParts {
+            dtype,
+            bytes: data.bytes,
+            offsets,
+            validity,
+        }
     }
 }
 
-impl VarBinArray {
-    /// Return an array containing the same data, but where the internal `offsets` start at zero
-    /// and all wasted space in the bytes child has been clipped.
-    #[doc(hidden)]
-    pub fn zero_offsets(self) -> Self {
-        if self.is_empty() {
-            return self;
+impl Array<VarBin> {
+    /// Creates a new `VarBinArray`.
+    pub fn new(offsets: ArrayRef, bytes: ByteBuffer, dtype: DType, validity: Validity) -> Self {
+        let len = offsets.len().saturating_sub(1);
+        let slots = VarBinData::make_slots(offsets, &validity, len);
+        let data = VarBinData::build(
+            slots[OFFSETS_SLOT]
+                .as_ref()
+                .vortex_expect("VarBinArray offsets slot")
+                .clone(),
+            bytes,
+            dtype.clone(),
+            validity,
+        );
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(VarBin, dtype, len, data).with_slots(slots))
         }
+    }
 
-        let first = self.offset_at(0);
+    /// Creates a new `VarBinArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`VarBinData::new_unchecked`].
+    pub unsafe fn new_unchecked(
+        offsets: ArrayRef,
+        bytes: ByteBuffer,
+        dtype: DType,
+        validity: Validity,
+    ) -> Self {
+        let len = offsets.len().saturating_sub(1);
+        let slots = VarBinData::make_slots(offsets, &validity, len);
+        let data = unsafe { VarBinData::new_unchecked(bytes) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(VarBin, dtype, len, data).with_slots(slots))
+        }
+    }
 
-        let bytes = self.sliced_bytes();
-        let dtype = self.dtype;
-        let validity = self.validity;
-        let offsets = self.offsets;
+    /// Creates a new `VarBinArray` without validation from a [`BufferHandle`].
+    ///
+    /// # Safety
+    ///
+    /// See [`VarBinData::new_unchecked_from_handle`].
+    pub unsafe fn new_unchecked_from_handle(
+        offsets: ArrayRef,
+        bytes: BufferHandle,
+        dtype: DType,
+        validity: Validity,
+    ) -> Self {
+        let len = offsets.len().saturating_sub(1);
+        let slots = VarBinData::make_slots(offsets, &validity, len);
+        let data = unsafe { VarBinData::new_unchecked_from_handle(bytes) };
+        unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(VarBin, dtype, len, data).with_slots(slots))
+        }
+    }
 
-        let offsets = if first == 0 {
-            offsets
-        } else {
-            let offsets = offsets.to_primitive();
-            match_each_integer_ptype!(offsets.ptype(), |P| {
-                let offsets = offsets.as_slice::<P>();
-                let buffer: Buffer<P> = offsets.iter().map(|index| index - offsets[0]).collect();
-                buffer.into_array()
-            })
-        };
-
-        // SAFETY: we make the first offset start at zero, and slice the bytes accordingly,
-        //  so all offsets stay valid.
-        unsafe { Self::new_unchecked(offsets, bytes, dtype, validity) }
+    /// Constructs a new `VarBinArray`.
+    pub fn try_new(
+        offsets: ArrayRef,
+        bytes: ByteBuffer,
+        dtype: DType,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let len = offsets.len() - 1;
+        let bytes = BufferHandle::new_host(bytes);
+        VarBinData::validate(&offsets, &bytes, &dtype, &validity)?;
+        let slots = VarBinData::make_slots(offsets, &validity, len);
+        // SAFETY: validate ensures all invariants are met.
+        let data = unsafe { VarBinData::new_unchecked_from_handle(bytes) };
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(VarBin, dtype, len, data).with_slots(slots))
+        })
     }
 }
 
-impl From<Vec<&[u8]>> for VarBinArray {
+impl From<Vec<&[u8]>> for Array<VarBin> {
     fn from(value: Vec<&[u8]>) -> Self {
         Self::from_vec(value, DType::Binary(Nullability::NonNullable))
     }
 }
 
-impl From<Vec<Vec<u8>>> for VarBinArray {
+impl From<Vec<Vec<u8>>> for Array<VarBin> {
     fn from(value: Vec<Vec<u8>>) -> Self {
         Self::from_vec(value, DType::Binary(Nullability::NonNullable))
     }
 }
 
-impl From<Vec<String>> for VarBinArray {
+impl From<Vec<String>> for Array<VarBin> {
     fn from(value: Vec<String>) -> Self {
         Self::from_vec(value, DType::Utf8(Nullability::NonNullable))
     }
 }
 
-impl From<Vec<&str>> for VarBinArray {
+impl From<Vec<&str>> for Array<VarBin> {
     fn from(value: Vec<&str>) -> Self {
         Self::from_vec(value, DType::Utf8(Nullability::NonNullable))
     }
 }
 
-impl From<Vec<Option<&[u8]>>> for VarBinArray {
+impl From<Vec<Option<&[u8]>>> for Array<VarBin> {
     fn from(value: Vec<Option<&[u8]>>) -> Self {
         Self::from_iter(value, DType::Binary(Nullability::Nullable))
     }
 }
 
-impl From<Vec<Option<Vec<u8>>>> for VarBinArray {
+impl From<Vec<Option<Vec<u8>>>> for Array<VarBin> {
     fn from(value: Vec<Option<Vec<u8>>>) -> Self {
         Self::from_iter(value, DType::Binary(Nullability::Nullable))
     }
 }
 
-impl From<Vec<Option<String>>> for VarBinArray {
+impl From<Vec<Option<String>>> for Array<VarBin> {
     fn from(value: Vec<Option<String>>) -> Self {
         Self::from_iter(value, DType::Utf8(Nullability::Nullable))
     }
 }
 
-impl From<Vec<Option<&str>>> for VarBinArray {
+impl From<Vec<Option<&str>>> for Array<VarBin> {
     fn from(value: Vec<Option<&str>>) -> Self {
         Self::from_iter(value, DType::Utf8(Nullability::Nullable))
     }
 }
 
-impl<'a> FromIterator<Option<&'a [u8]>> for VarBinArray {
+impl<'a> FromIterator<Option<&'a [u8]>> for Array<VarBin> {
     fn from_iter<T: IntoIterator<Item = Option<&'a [u8]>>>(iter: T) -> Self {
         Self::from_iter(iter, DType::Binary(Nullability::Nullable))
     }
 }
 
-impl FromIterator<Option<Vec<u8>>> for VarBinArray {
+impl FromIterator<Option<Vec<u8>>> for Array<VarBin> {
     fn from_iter<T: IntoIterator<Item = Option<Vec<u8>>>>(iter: T) -> Self {
         Self::from_iter(iter, DType::Binary(Nullability::Nullable))
     }
 }
 
-impl FromIterator<Option<String>> for VarBinArray {
+impl FromIterator<Option<String>> for Array<VarBin> {
     fn from_iter<T: IntoIterator<Item = Option<String>>>(iter: T) -> Self {
         Self::from_iter(iter, DType::Utf8(Nullability::Nullable))
     }
 }
 
-impl<'a> FromIterator<Option<&'a str>> for VarBinArray {
+impl<'a> FromIterator<Option<&'a str>> for Array<VarBin> {
     fn from_iter<T: IntoIterator<Item = Option<&'a str>>>(iter: T) -> Self {
         Self::from_iter(iter, DType::Utf8(Nullability::Nullable))
     }
diff --git a/vortex-array/src/arrays/varbin/builder.rs b/vortex-array/src/arrays/varbin/builder.rs
index c076730a870..9b63889e70f 100644
--- a/vortex-array/src/arrays/varbin/builder.rs
+++ b/vortex-array/src/arrays/varbin/builder.rs
@@ -7,8 +7,8 @@ use vortex_buffer::BufferMut;
 use vortex_error::vortex_panic;
 
 use crate::IntoArray;
-use crate::arrays::primitive::PrimitiveArray;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::VarBinArray;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::expr::stats::Precision;
@@ -122,6 +122,7 @@ impl<O: IntegerPType> VarBinBuilder<O> {
 mod tests {
     use vortex_error::VortexResult;
 
+    use crate::arrays::varbin::VarBinArrayExt;
     use crate::arrays::varbin::builder::VarBinBuilder;
     use crate::dtype::DType;
     use crate::dtype::Nullability::Nullable;
diff --git a/vortex-array/src/arrays/varbin/compute/cast.rs b/vortex-array/src/arrays/varbin/compute/cast.rs
index 51fdfbdf042..6b02283aec8 100644
--- a/vortex-array/src/arrays/varbin/compute/cast.rs
+++ b/vortex-array/src/arrays/varbin/compute/cast.rs
@@ -5,22 +5,22 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::VarBin;
 use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for VarBinVTable {
-    fn cast(array: &VarBinArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for VarBin {
+    fn cast(array: ArrayView<'_, VarBin>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !array.dtype().eq_ignore_nullability(dtype) {
             return Ok(None);
         }
 
         let new_nullability = dtype.nullability();
         let new_validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(new_nullability, array.len())?;
         let new_dtype = array.dtype().with_nullability(new_nullability);
         Ok(Some(
@@ -39,6 +39,7 @@ impl CastReduce for VarBinVTable {
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::VarBinArray;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -65,7 +66,7 @@ mod tests {
     fn try_cast_varbin_nullable(#[case] source: DType, #[case] target: DType) {
         let varbin = VarBinArray::from_iter(vec![Some("a"), Some("b"), Some("c")], source);
 
-        let res = varbin.to_array().cast(target.clone());
+        let res = varbin.into_array().cast(target.clone());
         assert_eq!(res.unwrap().dtype(), &target);
     }
 
@@ -77,7 +78,7 @@ mod tests {
     fn try_cast_varbin_fail(#[case] source: DType) {
         let non_nullable_source = source.as_nonnullable();
         let varbin = VarBinArray::from_iter(vec![Some("a"), Some("b"), None], source);
-        varbin.to_array().cast(non_nullable_source).unwrap();
+        varbin.into_array().cast(non_nullable_source).unwrap();
     }
 
     #[rstest]
@@ -87,6 +88,6 @@ mod tests {
     #[case(VarBinArray::from_iter(vec![Some(b"test".as_slice()), None], DType::Binary(Nullability::Nullable)))]
     #[case(VarBinArray::from_iter(vec![Some("single")], DType::Utf8(Nullability::NonNullable)))]
     fn test_cast_varbin_conformance(#[case] array: VarBinArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbin/compute/compare.rs b/vortex-array/src/arrays/varbin/compute/compare.rs
index 1a3147bed0a..b4ad470760e 100644
--- a/vortex-array/src/arrays/varbin/compute/compare.rs
+++ b/vortex-array/src/arrays/varbin/compute/compare.rs
@@ -4,41 +4,38 @@
 use arrow_array::BinaryArray;
 use arrow_array::StringArray;
 use arrow_ord::cmp;
-use itertools::Itertools;
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
 use crate::arrays::BoolArray;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
+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::builtins::ArrayBuiltins;
-use crate::compute::compare_lengths_to_empty;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::match_each_integer_ptype;
 use crate::scalar_fn::fns::binary::CompareKernel;
 use crate::scalar_fn::fns::operators::CompareOperator;
 use crate::scalar_fn::fns::operators::Operator;
-use crate::vtable::ValidityHelper;
 
 // This implementation exists so we can have custom translation of RHS to arrow that's not the same as IntoCanonical
-impl CompareKernel for VarBinVTable {
+impl CompareKernel for VarBin {
     fn compare(
-        lhs: &VarBinArray,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, VarBin>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         if let Some(rhs_const) = rhs.as_constant() {
             let nullable = lhs.dtype().is_nullable() || rhs_const.dtype().is_nullable();
@@ -60,13 +57,16 @@ impl CompareKernel for VarBinVTable {
                 let buffer = match operator {
                     CompareOperator::Gte => BitBuffer::new_set(len), // Every possible value is >= ""
                     CompareOperator::Lt => BitBuffer::new_unset(len), // No value is < ""
-                    CompareOperator::Eq
-                    | CompareOperator::NotEq
-                    | CompareOperator::Gt
-                    | CompareOperator::Lte => {
-                        let lhs_offsets = lhs.offsets().to_primitive();
+                    CompareOperator::Eq | CompareOperator::Lte => {
+                        let lhs_offsets = lhs.offsets().clone().execute::<PrimitiveArray>(ctx)?;
                         match_each_integer_ptype!(lhs_offsets.ptype(), |P| {
-                            compare_offsets_to_empty::<P>(lhs_offsets, operator)
+                            compare_offsets_to_empty::<P>(lhs_offsets, true)
+                        })
+                    }
+                    CompareOperator::NotEq | CompareOperator::Gt => {
+                        let lhs_offsets = lhs.offsets().clone().execute::<PrimitiveArray>(ctx)?;
+                        match_each_integer_ptype!(lhs_offsets.ptype(), |P| {
+                            compare_offsets_to_empty::<P>(lhs_offsets, false)
                         })
                     }
                 };
@@ -74,15 +74,13 @@ impl CompareKernel for VarBinVTable {
                 return Ok(Some(
                     BoolArray::new(
                         buffer,
-                        lhs.validity()
-                            .clone()
-                            .union_nullability(rhs.dtype().nullability()),
+                        lhs.validity()?.union_nullability(rhs.dtype().nullability()),
                     )
                     .into_array(),
                 ));
             }
 
-            let lhs = Datum::try_new(lhs.as_ref())?;
+            let lhs = Datum::try_new(lhs.array())?;
 
             // Use StringViewArray/BinaryViewArray to match the Utf8View/BinaryView types
             // produced by Datum::try_new (which uses into_arrow_preferred())
@@ -114,31 +112,31 @@ impl CompareKernel for VarBinVTable {
             .map_err(|err| vortex_err!("Failed to compare VarBin array: {}", err))?;
 
             Ok(Some(from_arrow_array_with_len(&array, len, nullable)?))
-        } else if !rhs.is::<VarBinVTable>() {
+        } 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
             // to VarBinView and re-invoke.
-            return Ok(Some(
-                lhs.to_varbinview()
-                    .to_array()
-                    .binary(rhs.to_array(), Operator::from(operator))?,
-            ));
+            Ok(Some(
+                lhs.array()
+                    .clone()
+                    .execute::<VarBinViewArray>(ctx)?
+                    .into_array()
+                    .binary(rhs.clone(), Operator::from(operator))?,
+            ))
         } else {
             Ok(None)
         }
     }
 }
 
-fn compare_offsets_to_empty<P: IntegerPType>(
-    offsets: PrimitiveArray,
-    operator: CompareOperator,
-) -> BitBuffer {
-    let lengths_iter = offsets
-        .as_slice::<P>()
-        .iter()
-        .tuple_windows()
-        .map(|(&s, &e)| e - s);
-    compare_lengths_to_empty(lengths_iter, operator)
+fn compare_offsets_to_empty<P: IntegerPType>(offsets: PrimitiveArray, eq: bool) -> BitBuffer {
+    let fn_ = if eq { P::eq } else { P::ne };
+    let offsets = offsets.as_slice::<P>();
+    BitBuffer::collect_bool(offsets.len() - 1, |idx| {
+        let left = unsafe { offsets.get_unchecked(idx) };
+        let right = unsafe { offsets.get_unchecked(idx + 1) };
+        fn_(left, right)
+    })
 }
 
 #[cfg(test)]
@@ -146,10 +144,12 @@ mod test {
     use vortex_buffer::BitBuffer;
     use vortex_buffer::ByteBuffer;
 
+    use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::ConstantArray;
     use crate::arrays::VarBinArray;
     use crate::arrays::VarBinViewArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::builtins::ArrayBuiltins;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -163,13 +163,13 @@ mod test {
             DType::Binary(Nullability::Nullable),
         );
         let result = array
-            .to_array()
+            .into_array()
             .binary(
                 ConstantArray::new(
                     Scalar::binary(ByteBuffer::copy_from(b"abc"), Nullability::Nullable),
                     3,
                 )
-                .to_array(),
+                .into_array(),
                 Operator::Eq,
             )
             .unwrap()
@@ -196,8 +196,8 @@ mod test {
             DType::Binary(Nullability::Nullable),
         );
         let result = array
-            .to_array()
-            .binary(vbv.to_array(), Operator::Eq)
+            .into_array()
+            .binary(vbv.into_array(), Operator::Eq)
             .unwrap()
             .to_bool();
 
@@ -214,7 +214,7 @@ mod test {
 
 #[cfg(test)]
 mod tests {
-    use crate::Array;
+    use crate::IntoArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::VarBinArray;
     use crate::builtins::ArrayBuiltins;
@@ -230,8 +230,8 @@ mod tests {
         let const_ = ConstantArray::new(Scalar::utf8("", Nullability::Nullable), 1);
 
         assert_eq!(
-            arr.to_array()
-                .binary(const_.to_array(), Operator::Eq)
+            arr.into_array()
+                .binary(const_.into_array(), Operator::Eq)
                 .unwrap()
                 .dtype(),
             &DType::Bool(Nullability::Nullable)
diff --git a/vortex-array/src/arrays/varbin/compute/filter.rs b/vortex-array/src/arrays/varbin/compute/filter.rs
index 6a785a77281..8f4b6793a72 100644
--- a/vortex-array/src/arrays/varbin/compute/filter.rs
+++ b/vortex-array/src/arrays/varbin/compute/filter.rs
@@ -14,53 +14,61 @@ use vortex_mask::MaskIter;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::VarBinVTable;
+use crate::array::ArrayView;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinArray;
 use crate::arrays::filter::FilterKernel;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::arrays::varbin::builder::VarBinBuilder;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::match_each_integer_ptype;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl FilterKernel for VarBinVTable {
+impl FilterKernel for VarBin {
     fn filter(
-        array: &VarBinArray,
+        array: ArrayView<'_, VarBin>,
         mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        filter_select_var_bin(array, mask).map(|a| Some(a.into_array()))
+        filter_select_var_bin(array, mask, ctx).map(|a| Some(a.into_array()))
     }
 }
 
-fn filter_select_var_bin(arr: &VarBinArray, mask: &Mask) -> VortexResult<VarBinArray> {
+fn filter_select_var_bin(
+    arr: ArrayView<'_, VarBin>,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<VarBinArray> {
     match mask
         .values()
         .vortex_expect("AllTrue and AllFalse are handled by filter fn")
         .threshold_iter(0.5)
     {
         MaskIter::Indices(indices) => {
-            filter_select_var_bin_by_index(arr, indices, mask.true_count())
+            filter_select_var_bin_by_index(arr, indices, mask.true_count(), ctx)
+        }
+        MaskIter::Slices(slices) => {
+            filter_select_var_bin_by_slice(arr, slices, mask.true_count(), ctx)
         }
-        MaskIter::Slices(slices) => filter_select_var_bin_by_slice(arr, slices, mask.true_count()),
     }
 }
 
 fn filter_select_var_bin_by_slice(
-    values: &VarBinArray,
+    values: ArrayView<'_, VarBin>,
     mask_slices: &[(usize, usize)],
     selection_count: usize,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<VarBinArray> {
-    let offsets = values.offsets().to_primitive();
+    let offsets = values.offsets().clone().execute::<PrimitiveArray>(ctx)?;
     match_each_integer_ptype!(offsets.ptype(), |O| {
         filter_select_var_bin_by_slice_primitive_offset(
             values.dtype().clone(),
             offsets.as_slice::<O>(),
             values.bytes().as_slice(),
             mask_slices,
-            values.validity_mask()?,
+            values.varbin_validity_mask(),
             selection_count,
         )
     })
@@ -147,18 +155,19 @@ fn update_non_nullable_slice<O>(
 }
 
 fn filter_select_var_bin_by_index(
-    values: &VarBinArray,
+    values: ArrayView<'_, VarBin>,
     mask_indices: &[usize],
     selection_count: usize,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<VarBinArray> {
-    let offsets = values.offsets().to_primitive();
+    let offsets = values.offsets().clone().execute::<PrimitiveArray>(ctx)?;
     match_each_integer_ptype!(offsets.ptype(), |O| {
         filter_select_var_bin_by_index_primitive_offset(
             values.dtype().clone(),
             offsets.as_slice::<O>(),
             values.bytes().as_slice(),
             mask_indices,
-            values.validity().clone(),
+            values.validity()?,
             selection_count,
         )
     })
@@ -198,8 +207,10 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
-    use crate::arrays::varbin::VarBinArray;
+    use crate::arrays::VarBinArray;
     use crate::arrays::varbin::compute::filter::filter_select_var_bin_by_index;
     use crate::arrays::varbin::compute::filter::filter_select_var_bin_by_slice;
     use crate::assert_arrays_eq;
@@ -219,7 +230,14 @@ mod test {
             ],
             DType::Utf8(NonNullable),
         );
-        let buf = filter_select_var_bin_by_index(&arr, &[0, 2], 2).unwrap();
+        let arr = arr.as_view();
+        let buf = filter_select_var_bin_by_index(
+            arr,
+            &[0, 2],
+            2,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
 
         assert_arrays_eq!(buf, VarBinArray::from(vec!["hello", "filter"]));
     }
@@ -237,7 +255,14 @@ mod test {
             DType::Utf8(NonNullable),
         );
 
-        let buf = filter_select_var_bin_by_slice(&arr, &[(0, 1), (2, 3), (4, 5)], 3).unwrap();
+        let arr = arr.as_view();
+        let buf = filter_select_var_bin_by_slice(
+            arr,
+            &[(0, 1), (2, 3), (4, 5)],
+            3,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
 
         assert_arrays_eq!(buf, VarBinArray::from(vec!["hello", "filter", "filter3"]));
     }
@@ -262,7 +287,14 @@ mod test {
         );
         let arr = VarBinArray::try_new(offsets, bytes, DType::Utf8(Nullable), validity).unwrap();
 
-        let buf = filter_select_var_bin_by_slice(&arr, &[(0, 3), (4, 6)], 5).unwrap();
+        let arr = arr.as_view();
+        let buf = filter_select_var_bin_by_slice(
+            arr,
+            &[(0, 3), (4, 6)],
+            5,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
 
         assert_arrays_eq!(
             buf,
@@ -287,7 +319,14 @@ mod test {
         let validity = Validity::Array(BoolArray::from_iter([false, true, true]).into_array());
         let arr = VarBinArray::try_new(offsets, bytes, DType::Utf8(Nullable), validity).unwrap();
 
-        let buf = filter_select_var_bin_by_slice(&arr, &[(0, 1), (2, 3)], 2).unwrap();
+        let arr = arr.as_view();
+        let buf = filter_select_var_bin_by_slice(
+            arr,
+            &[(0, 1), (2, 3)],
+            2,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
 
         assert_arrays_eq!(buf, VarBinArray::from(vec![None, Some("two")]));
     }
@@ -304,7 +343,14 @@ mod test {
         )
         .unwrap();
 
-        let buf = filter_select_var_bin_by_slice(&arr, &[(0, 1), (2, 3)], 2).unwrap();
+        let arr = arr.as_view();
+        let buf = filter_select_var_bin_by_slice(
+            arr,
+            &[(0, 1), (2, 3)],
+            2,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .unwrap();
 
         assert_arrays_eq!(buf, VarBinArray::from(vec![None::<&str>, None]));
     }
@@ -315,12 +361,12 @@ mod test {
             vec!["hello", "world", "filter", "good", "bye"],
             DType::Utf8(NonNullable),
         );
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
 
         let array = VarBinArray::from_iter(
             vec![Some("hello"), None, Some("filter"), Some("good"), None],
             DType::Utf8(Nullable),
         );
-        test_filter_conformance(array.as_ref());
+        test_filter_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbin/compute/is_constant.rs b/vortex-array/src/arrays/varbin/compute/is_constant.rs
deleted file mode 100644
index 6e2c6f3a32b..00000000000
--- a/vortex-array/src/arrays/varbin/compute/is_constant.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::accessor::ArrayAccessor;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::register_kernel;
-
-impl IsConstantKernel for VarBinVTable {
-    fn is_constant(
-        &self,
-        array: &VarBinArray,
-        opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        if opts.is_negligible_cost() {
-            return Ok(None);
-        }
-        Ok(Some(array.with_iterator(compute_is_constant)))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(VarBinVTable).lift());
-
-pub(super) fn compute_is_constant(iter: &mut dyn Iterator<Item = Option<&[u8]>>) -> bool {
-    let Some(first_value) = iter.next() else {
-        return false;
-    };
-    for v in iter {
-        if v != first_value {
-            return false;
-        }
-    }
-    true
-}
diff --git a/vortex-array/src/arrays/varbin/compute/is_sorted.rs b/vortex-array/src/arrays/varbin/compute/is_sorted.rs
deleted file mode 100644
index ae8a3638713..00000000000
--- a/vortex-array/src/arrays/varbin/compute/is_sorted.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::accessor::ArrayAccessor;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
-use crate::compute::IsSortedIteratorExt;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-impl IsSortedKernel for VarBinVTable {
-    fn is_sorted(&self, array: &VarBinArray) -> VortexResult<Option<bool>> {
-        Ok(Some(
-            array.with_iterator(|bytes_iter| bytes_iter.is_sorted()),
-        ))
-    }
-
-    fn is_strict_sorted(&self, array: &VarBinArray) -> VortexResult<Option<bool>> {
-        Ok(Some(
-            array.with_iterator(|bytes_iter| bytes_iter.is_strict_sorted()),
-        ))
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(VarBinVTable).lift());
diff --git a/vortex-array/src/arrays/varbin/compute/mask.rs b/vortex-array/src/arrays/varbin/compute/mask.rs
index ab5119def09..1c5567adea7 100644
--- a/vortex-array/src/arrays/varbin/compute/mask.rs
+++ b/vortex-array/src/arrays/varbin/compute/mask.rs
@@ -5,23 +5,21 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::VarBinVTable;
-use crate::arrays::varbin::VarBinArray;
+use crate::array::ArrayView;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinArray;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for VarBinVTable {
-    fn mask(array: &VarBinArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for VarBin {
+    fn mask(array: ArrayView<'_, VarBin>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
             VarBinArray::try_new(
                 array.offsets().clone(),
                 array.bytes().clone(),
                 array.dtype().as_nullable(),
-                array
-                    .validity()
-                    .clone()
-                    .and(Validity::Array(mask.clone()))?,
+                array.validity()?.and(Validity::Array(mask.clone()))?,
             )?
             .into_array(),
         ))
@@ -30,6 +28,7 @@ impl MaskReduce for VarBinVTable {
 
 #[cfg(test)]
 mod test {
+    use crate::IntoArray;
     use crate::arrays::VarBinArray;
     use crate::compute::conformance::mask::test_mask_conformance;
     use crate::dtype::DType;
@@ -41,12 +40,12 @@ mod test {
             vec!["hello", "world", "filter", "good", "bye"],
             DType::Utf8(Nullability::NonNullable),
         );
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
 
         let array = VarBinArray::from_iter(
             vec![Some("hello"), None, Some("filter"), Some("good"), None],
             DType::Utf8(Nullability::Nullable),
         );
-        test_mask_conformance(array.as_ref());
+        test_mask_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbin/compute/min_max.rs b/vortex-array/src/arrays/varbin/compute/min_max.rs
deleted file mode 100644
index 444d2362f9d..00000000000
--- a/vortex-array/src/arrays/varbin/compute/min_max.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use itertools::Itertools;
-use vortex_error::VortexResult;
-use vortex_error::vortex_panic;
-
-use crate::accessor::ArrayAccessor;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::dtype::DType;
-use crate::dtype::Nullability::NonNullable;
-use crate::register_kernel;
-use crate::scalar::Scalar;
-
-impl MinMaxKernel for VarBinVTable {
-    fn min_max(&self, array: &VarBinArray) -> VortexResult<Option<MinMaxResult>> {
-        Ok(varbin_compute_min_max(array, array.dtype()))
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(VarBinVTable).lift());
-
-/// Compute the min and max of VarBin like array.
-pub(crate) fn varbin_compute_min_max<T: ArrayAccessor<[u8]>>(
-    array: &T,
-    dtype: &DType,
-) -> Option<MinMaxResult> {
-    array.with_iterator(|iter| match iter.flatten().minmax() {
-        itertools::MinMaxResult::NoElements => None,
-        itertools::MinMaxResult::OneElement(value) => {
-            let scalar = make_scalar(dtype, value);
-            Some(MinMaxResult {
-                min: scalar.clone(),
-                max: scalar,
-            })
-        }
-        itertools::MinMaxResult::MinMax(min, max) => Some(MinMaxResult {
-            min: make_scalar(dtype, min),
-            max: make_scalar(dtype, max),
-        }),
-    })
-}
-
-/// Helper function to make sure that min/max has the right [`Scalar`] type.
-fn make_scalar(dtype: &DType, value: &[u8]) -> Scalar {
-    match dtype {
-        DType::Binary(_) => Scalar::binary(value.to_vec(), NonNullable),
-        DType::Utf8(_) => {
-            // SAFETY: We only call `compute_min_max` within `varbin/`, in which we always validate
-            // the arrays, and we always pass `array.dtype()` in as the `dtype` argument.
-            let value = unsafe { str::from_utf8_unchecked(value) };
-            Scalar::utf8(value, NonNullable)
-        }
-        _ => vortex_panic!("cannot make Scalar from bytes with dtype {dtype}"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::BufferString;
-
-    use crate::arrays::VarBinArray;
-    use crate::compute::MinMaxResult;
-    use crate::compute::min_max;
-    use crate::dtype::DType::Utf8;
-    use crate::dtype::Nullability::NonNullable;
-    use crate::dtype::Nullability::Nullable;
-    use crate::expr::stats::Stat;
-    use crate::expr::stats::StatsProvider;
-    use crate::scalar::Scalar;
-
-    #[test]
-    fn some_nulls() {
-        let array = VarBinArray::from_iter(
-            vec![
-                Some("hello world"),
-                None,
-                Some("hello world this is a long string"),
-                None,
-            ],
-            Utf8(Nullable),
-        );
-        let MinMaxResult { min, max } = min_max(array.as_ref()).unwrap().unwrap();
-
-        assert_eq!(
-            min,
-            Scalar::try_new(
-                Utf8(NonNullable),
-                Some(BufferString::from("hello world".to_string()).into()),
-            )
-            .unwrap()
-        );
-        assert_eq!(
-            max,
-            Scalar::try_new(
-                Utf8(NonNullable),
-                Some(BufferString::from("hello world this is a long string".to_string()).into()),
-            )
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn all_nulls() {
-        let array = VarBinArray::from_iter(vec![Option::<&str>::None, None, None], Utf8(Nullable));
-        let stats = array.statistics();
-        assert!(stats.get(Stat::Min).is_none());
-        assert!(stats.get(Stat::Max).is_none());
-    }
-}
diff --git a/vortex-array/src/arrays/varbin/compute/mod.rs b/vortex-array/src/arrays/varbin/compute/mod.rs
index 44b1a6698f6..ab2de942138 100644
--- a/vortex-array/src/arrays/varbin/compute/mod.rs
+++ b/vortex-array/src/arrays/varbin/compute/mod.rs
@@ -3,21 +3,18 @@
 
 pub(crate) mod rules;
 mod slice;
-pub(crate) use min_max::varbin_compute_min_max;
 
 mod cast;
 mod compare;
 mod filter;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 mod take;
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::VarBinArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DType;
@@ -63,6 +60,6 @@ mod tests {
         DType::Utf8(Nullability::NonNullable),
     ))]
     fn test_varbin_consistency(#[case] array: VarBinArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbin/compute/rules.rs b/vortex-array/src/arrays/varbin/compute/rules.rs
index 2a948fda95a..89e22ce0d20 100644
--- a/vortex-array/src/arrays/varbin/compute/rules.rs
+++ b/vortex-array/src/arrays/varbin/compute/rules.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::SliceReduceAdaptor;
-use crate::arrays::VarBinVTable;
+use crate::arrays::VarBin;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<VarBinVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(VarBinVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(VarBinVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(VarBinVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<VarBin> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(VarBin)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(VarBin)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(VarBin)),
 ]);
diff --git a/vortex-array/src/arrays/varbin/compute/slice.rs b/vortex-array/src/arrays/varbin/compute/slice.rs
index a0fd464aa87..b3ab91cc578 100644
--- a/vortex-array/src/arrays/varbin/compute/slice.rs
+++ b/vortex-array/src/arrays/varbin/compute/slice.rs
@@ -7,18 +7,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::SliceReduce;
+use crate::array::ArrayView;
+use crate::arrays::VarBin;
 use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
+use crate::arrays::slice::SliceReduce;
+use crate::arrays::varbin::VarBinArrayExt;
 
-impl SliceReduce for VarBinVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        VarBinVTable::_slice(array, range).map(Some)
+impl SliceReduce for VarBin {
+    fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+        VarBin::_slice(array, range).map(Some)
     }
 }
 
-impl VarBinVTable {
-    pub fn _slice(array: &VarBinArray, range: Range<usize>) -> VortexResult<ArrayRef> {
+impl VarBin {
+    pub fn _slice(array: ArrayView<'_, VarBin>, range: Range<usize>) -> VortexResult<ArrayRef> {
         Ok(unsafe {
             VarBinArray::new_unchecked_from_handle(
                 array.offsets().slice(range.start..range.end + 1)?,
diff --git a/vortex-array/src/arrays/varbin/compute/take.rs b/vortex-array/src/arrays/varbin/compute/take.rs
index 9d541dabf39..de8b1ffff77 100644
--- a/vortex-array/src/arrays/varbin/compute/take.rs
+++ b/vortex-array/src/arrays/varbin/compute/take.rs
@@ -9,35 +9,35 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::ToCanonical;
+use crate::array::ArrayView;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::TakeExecute;
-use crate::arrays::VarBinVTable;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinArray;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
 use crate::validity::Validity;
 
-impl TakeExecute for VarBinVTable {
+impl TakeExecute for VarBin {
     fn take(
-        array: &VarBinArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, VarBin>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         // TODO(joe): Be lazy with execute
-        let offsets = array.offsets().to_primitive();
+        let offsets = array.offsets().clone().execute::<PrimitiveArray>(ctx)?;
         let data = array.bytes();
-        let indices = indices.to_primitive();
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
         let dtype = array
             .dtype()
             .clone()
             .union_nullability(indices.dtype().nullability());
-        let array_validity = array.validity_mask()?;
+        let array_validity = array.varbin_validity_mask();
         let indices_validity = indices.validity_mask()?;
 
         let array = match_each_integer_ptype!(indices.ptype(), |I| {
@@ -252,11 +252,10 @@ mod tests {
     use vortex_buffer::ByteBuffer;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray;
-    use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinArray;
     use crate::arrays::VarBinViewArray;
+    use crate::arrays::varbin::compute::take::PrimitiveArray;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::dtype::DType;
@@ -270,14 +269,14 @@ mod tests {
         let idx1: PrimitiveArray = (0..1).collect();
 
         assert_eq!(
-            arr.take(idx1.to_array()).unwrap().dtype(),
+            arr.take(idx1.into_array()).unwrap().dtype(),
             &DType::Utf8(Nullability::NonNullable)
         );
 
         let idx2: PrimitiveArray = PrimitiveArray::from_option_iter(vec![Some(0)]);
 
         assert_eq!(
-            arr.take(idx2.to_array()).unwrap().dtype(),
+            arr.take(idx2.into_array()).unwrap().dtype(),
             &DType::Utf8(Nullability::Nullable)
         );
     }
@@ -297,7 +296,7 @@ mod tests {
     ))]
     #[case(VarBinArray::from_iter(["single"].map(Some), DType::Utf8(Nullability::NonNullable)))]
     fn test_take_varbin_conformance(#[case] array: VarBinArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 
     #[test]
@@ -314,7 +313,7 @@ mod tests {
         );
 
         let indices = buffer![0u32; 3].into_array();
-        let taken = array.take(indices.to_array()).unwrap();
+        let taken = array.take(indices).unwrap();
 
         let expected = VarBinViewArray::from_iter(
             [Some(scream.clone()), Some(scream.clone()), Some(scream)],
diff --git a/vortex-array/src/arrays/varbin/mod.rs b/vortex-array/src/arrays/varbin/mod.rs
index 78438d5a43e..a8f321fec9a 100644
--- a/vortex-array/src/arrays/varbin/mod.rs
+++ b/vortex-array/src/arrays/varbin/mod.rs
@@ -2,13 +2,15 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::VarBinArray;
+pub use array::VarBinArrayExt;
+pub use array::VarBinData;
+pub use array::VarBinDataParts;
+pub use vtable::VarBinArray;
 
 pub(crate) mod compute;
-pub(crate) use compute::varbin_compute_min_max;
 
 mod vtable;
-pub use vtable::VarBinVTable;
+pub use vtable::VarBin;
 
 pub mod builder;
 
diff --git a/vortex-array/src/arrays/varbin/tests.rs b/vortex-array/src/arrays/varbin/tests.rs
index 6727715d007..4711c69102e 100644
--- a/vortex-array/src/arrays/varbin/tests.rs
+++ b/vortex-array/src/arrays/varbin/tests.rs
@@ -6,11 +6,10 @@ use rstest::rstest;
 use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::VarBinArray;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::varbin::VarBinArray;
 use crate::assert_arrays_eq;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
@@ -47,21 +46,3 @@ pub fn slice_array(binary_array: ArrayRef) {
         VarBinViewArray::from_iter_str(["hello world this is a long string"])
     );
 }
-
-#[test]
-fn test_zero_offsets() -> vortex_error::VortexResult<()> {
-    use crate::arrays::VarBinVTable;
-    use crate::dtype::Nullability::NonNullable;
-
-    let items = VarBinArray::from_iter_nonnull(["abc", "def", "ghi"], DType::Utf8(NonNullable));
-    let sliced = items.slice(1..3)?.as_::<VarBinVTable>().clone();
-
-    // After slicing, there is some unused data at the front of the bytes.
-    assert_eq!(sliced.offset_at(0), 3);
-
-    // But after zeroing the offsets, the extraneous data is gone.
-    let truncated = sliced.zero_offsets();
-    assert_eq!(truncated.offset_at(0), 0);
-    assert_eq!(truncated.len(), 2);
-    Ok(())
-}
diff --git a/vortex-array/src/arrays/varbin/vtable/array.rs b/vortex-array/src/arrays/varbin/vtable/array.rs
deleted file mode 100644
index c995ca11261..00000000000
--- a/vortex-array/src/arrays/varbin/vtable/array.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::varbin::VarBinArray;
-use crate::arrays::varbin::VarBinVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<VarBinVTable> for VarBinVTable {
-    fn len(array: &VarBinArray) -> usize {
-        array.offsets().len().saturating_sub(1)
-    }
-
-    fn dtype(array: &VarBinArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &VarBinArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &VarBinArray, state: &mut H, precision: Precision) {
-        array.dtype.hash(state);
-        array.bytes().array_hash(state, precision);
-        array.offsets().array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &VarBinArray, other: &VarBinArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.bytes().array_eq(other.bytes(), precision)
-            && array.offsets().array_eq(other.offsets(), precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/varbin/vtable/canonical.rs b/vortex-array/src/arrays/varbin/vtable/canonical.rs
index 46507850d6e..726bbfd8dcd 100644
--- a/vortex-array/src/arrays/varbin/vtable/canonical.rs
+++ b/vortex-array/src/arrays/varbin/vtable/canonical.rs
@@ -3,42 +3,43 @@
 
 use std::sync::Arc;
 
+use num_traits::AsPrimitive;
 use vortex_error::VortexResult;
 
 use crate::ExecutionCtx;
+use crate::array::ArrayView;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::VarBin;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::build_views::MAX_BUFFER_LEN;
-use crate::arrays::build_views::build_views;
-use crate::arrays::build_views::offsets_to_lengths;
-use crate::arrays::varbin::VarBinArray;
+use crate::arrays::varbinview::build_views::MAX_BUFFER_LEN;
+use crate::arrays::varbinview::build_views::build_views;
+use crate::arrays::varbinview::build_views::offsets_to_lengths;
 use crate::match_each_integer_ptype;
 
 /// Converts a VarBinArray to its canonical form (VarBinViewArray).
 ///
 /// This is a shared helper used by both `canonicalize` and `execute`.
 pub(crate) fn varbin_to_canonical(
-    array: &VarBinArray,
+    array: ArrayView<'_, VarBin>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<VarBinViewArray> {
-    // Zero the offsets first to ensure the bytes buffer starts at 0
-    let array = array.clone().zero_offsets();
-    let (dtype, bytes, offsets, validity) = array.into_parts();
+    let parts = array.into_owned().into_data_parts();
 
-    // offsets_to_lengths
-    let offsets = offsets.execute::<PrimitiveArray>(ctx)?;
-    let bytes = bytes.unwrap_host().into_mut();
+    let offsets = parts.offsets.execute::<PrimitiveArray>(ctx)?;
 
     match_each_integer_ptype!(offsets.ptype(), |P| {
-        let lens = offsets_to_lengths(offsets.as_slice::<P>());
-        let (buffers, views) = build_views(0, MAX_BUFFER_LEN, bytes, lens.as_slice());
+        let offsets_slice = offsets.as_slice::<P>();
+        let first: usize = offsets_slice[0].as_();
+        let last: usize = offsets_slice[offsets_slice.len() - 1].as_();
+        let bytes = parts.bytes.unwrap_host().slice(first..last).into_mut();
 
-        let varbinview =
-            unsafe { VarBinViewArray::new_unchecked(views, Arc::from(buffers), dtype, validity) };
+        let lens = offsets_to_lengths(offsets_slice);
+        let (buffers, views) = build_views(0, MAX_BUFFER_LEN, bytes, lens.as_slice());
 
-        // Create VarBinViewArray with the original bytes buffer and computed views
         // SAFETY: views are correctly computed from valid offsets
-        Ok(varbinview)
+        Ok(unsafe {
+            VarBinViewArray::new_unchecked(views, Arc::from(buffers), parts.dtype, parts.validity)
+        })
     })
 }
 
@@ -46,7 +47,10 @@ pub(crate) fn varbin_to_canonical(
 mod tests {
     use rstest::rstest;
 
+    use crate::arrays::VarBinArray;
+    use crate::arrays::VarBinViewArray;
     use crate::arrays::varbin::builder::VarBinBuilder;
+    use crate::assert_arrays_eq;
     use crate::canonical::ToCanonical;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -54,7 +58,7 @@ mod tests {
     #[rstest]
     #[case(DType::Utf8(Nullability::Nullable))]
     #[case(DType::Binary(Nullability::Nullable))]
-    fn test_canonical_varbin(#[case] dtype: DType) {
+    fn test_canonical_varbin_sliced(#[case] dtype: DType) {
         let mut varbin = VarBinBuilder::<i32>::with_capacity(10);
         varbin.append_null();
         varbin.append_null();
@@ -79,4 +83,26 @@ mod tests {
         assert!(!canonical.views()[2].is_inlined());
         assert_eq!(canonical.bytes_at(2).as_slice(), "1234567890123".as_bytes());
     }
+
+    #[rstest]
+    #[case(DType::Utf8(Nullability::NonNullable))]
+    #[case(DType::Binary(Nullability::NonNullable))]
+    fn test_canonical_varbin_unsliced(#[case] dtype: DType) {
+        let varbin = VarBinArray::from_iter_nonnull(["foo", "bar", "baz"], dtype.clone());
+        let canonical = varbin.as_array().to_varbinview();
+        let expected = match dtype {
+            DType::Utf8(_) => VarBinViewArray::from_iter_str(["foo", "bar", "baz"]),
+            _ => VarBinViewArray::from_iter_bin(["foo", "bar", "baz"]),
+        };
+        assert_arrays_eq!(canonical, expected);
+    }
+
+    // Empty array: offsets has exactly one element; no elements to canonicalize.
+    #[test]
+    fn test_canonical_varbin_empty() {
+        let varbin =
+            VarBinArray::from_iter_nonnull([] as [&str; 0], DType::Utf8(Nullability::NonNullable));
+        let canonical = varbin.as_array().to_varbinview();
+        assert_eq!(canonical.len(), 0);
+    }
 }
diff --git a/vortex-array/src/arrays/varbin/vtable/kernel.rs b/vortex-array/src/arrays/varbin/vtable/kernel.rs
index 736c15462c9..8cb6a2ca377 100644
--- a/vortex-array/src/arrays/varbin/vtable/kernel.rs
+++ b/vortex-array/src/arrays/varbin/vtable/kernel.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::TakeExecuteAdaptor;
-use crate::arrays::VarBinVTable;
+use crate::arrays::VarBin;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::arrays::filter::FilterExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::binary::CompareExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<VarBinVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&CompareExecuteAdaptor(VarBinVTable)),
-    ParentKernelSet::lift(&FilterExecuteAdaptor(VarBinVTable)),
-    ParentKernelSet::lift(&TakeExecuteAdaptor(VarBinVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<VarBin> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CompareExecuteAdaptor(VarBin)),
+    ParentKernelSet::lift(&FilterExecuteAdaptor(VarBin)),
+    ParentKernelSet::lift(&TakeExecuteAdaptor(VarBin)),
 ]);
diff --git a/vortex-array/src/arrays/varbin/vtable/mod.rs b/vortex-array/src/arrays/varbin/vtable/mod.rs
index c466d496653..ffe44158c27 100644
--- a/vortex-array/src/arrays/varbin/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbin/vtable/mod.rs
@@ -1,43 +1,49 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
+
+use prost::Message;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
-use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
+use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::ProstMetadata;
-use crate::SerializeMetadata;
-use crate::arrays::varbin::VarBinArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::varbin::VarBinArrayExt;
+use crate::arrays::varbin::VarBinData;
+use crate::arrays::varbin::array::NUM_SLOTS;
+use crate::arrays::varbin::array::SLOT_NAMES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod canonical;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
 
 use canonical::varbin_to_canonical;
 use kernel::PARENT_KERNELS;
 use vortex_session::VortexSession;
 
+use crate::Precision;
 use crate::arrays::varbin::compute::rules::PARENT_RULES;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
 
-vtable!(VarBin);
+/// A [`VarBin`]-encoded Vortex array.
+pub type VarBinArray = Array<VarBin>;
 
 #[derive(Clone, prost::Message)]
 pub struct VarBinMetadata {
@@ -45,50 +51,98 @@ pub struct VarBinMetadata {
     pub(crate) offsets_ptype: i32,
 }
 
-impl VTable for VarBinVTable {
-    type Array = VarBinArray;
+impl ArrayHash for VarBinData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        self.bytes().array_hash(state, precision);
+    }
+}
+
+impl ArrayEq for VarBinData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+        self.bytes().array_eq(other.bytes(), precision)
+    }
+}
 
-    type Metadata = ProstMetadata<VarBinMetadata>;
+impl VTable for VarBin {
+    type ArrayData = VarBinData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(array: &VarBinArray) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(VarBinMetadata {
-            offsets_ptype: PType::try_from(array.offsets().dtype())
-                .vortex_expect("Must be a valid PType") as i32,
-        }))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        1
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn validate(
+        &self,
+        _data: &VarBinData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == NUM_SLOTS,
+            "VarBinArray expected {NUM_SLOTS} slots, found {}",
+            slots.len()
+        );
+        let offsets = slots[crate::arrays::varbin::array::OFFSETS_SLOT]
+            .as_ref()
+            .vortex_expect("VarBinArray offsets slot");
+        vortex_ensure!(
+            offsets.len().saturating_sub(1) == len,
+            "VarBinArray length {} does not match outer length {}",
+            offsets.len().saturating_sub(1),
+            len
+        );
+        vortex_ensure!(
+            matches!(dtype, DType::Binary(_) | DType::Utf8(_)),
+            "VarBinArray dtype must be binary or utf8, got {dtype}"
+        );
+        Ok(())
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        match idx {
+            0 => array.bytes_handle().clone(),
+            _ => vortex_panic!("VarBinArray buffer index {idx} out of bounds"),
+        }
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        match idx {
+            0 => Some("bytes".to_string()),
+            _ => vortex_panic!("VarBinArray buffer_name index {idx} out of bounds"),
+        }
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(ProstMetadata(ProstMetadata::<VarBinMetadata>::deserialize(
-            bytes,
-        )?))
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            VarBinMetadata {
+                offsets_ptype: PType::try_from(array.offsets().dtype())
+                    .vortex_expect("Must be a valid PType") as i32,
+            }
+            .encode_to_vec(),
+        ))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<VarBinArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        let metadata = VarBinMetadata::decode(metadata)?;
         let validity = if children.len() == 1 {
             Validity::from(dtype.nullability())
         } else if children.len() == 2 {
@@ -109,34 +163,17 @@ impl VTable for VarBinVTable {
         }
         let bytes = buffers[0].clone().try_to_host_sync()?;
 
-        VarBinArray::try_new(offsets, bytes, dtype.clone(), validity)
+        let data = VarBinData::try_build(offsets.clone(), bytes, dtype.clone(), validity.clone())?;
+        let slots = VarBinData::make_slots(offsets, &validity, len);
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        match children.len() {
-            1 => {
-                let [offsets]: [ArrayRef; 1] = children
-                    .try_into()
-                    .map_err(|_| vortex_err!("Failed to convert children to array"))?;
-                array.offsets = offsets;
-            }
-            2 => {
-                let [offsets, validity]: [ArrayRef; 2] = children
-                    .try_into()
-                    .map_err(|_| vortex_err!("Failed to convert children to array"))?;
-                array.offsets = offsets;
-                array.validity = Validity::Array(validity);
-            }
-            _ => vortex_bail!(
-                "VarBinArray expects 1 or 2 children (offsets, validity?), got {}",
-                children.len()
-            ),
-        }
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -144,7 +181,7 @@ impl VTable for VarBinVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -152,14 +189,16 @@ impl VTable for VarBinVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(varbin_to_canonical(array, ctx)?.into_array())
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            varbin_to_canonical(array.as_view(), ctx)?.into_array(),
+        ))
     }
 }
 
-#[derive(Debug)]
-pub struct VarBinVTable;
+#[derive(Clone, Debug)]
+pub struct VarBin;
 
-impl VarBinVTable {
+impl VarBin {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.varbin");
 }
diff --git a/vortex-array/src/arrays/varbin/vtable/operations.rs b/vortex-array/src/arrays/varbin/vtable/operations.rs
index 8c2820d6ed0..e11043e605a 100644
--- a/vortex-array/src/arrays/varbin/vtable/operations.rs
+++ b/vortex-array/src/arrays/varbin/vtable/operations.rs
@@ -3,14 +3,20 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
-use crate::arrays::varbin_scalar;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::VarBin;
+use crate::arrays::varbin::VarBinArrayExt;
+use crate::arrays::varbin::varbin_scalar;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<VarBinVTable> for VarBinVTable {
-    fn scalar_at(array: &VarBinArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<VarBin> for VarBin {
+    fn scalar_at(
+        array: ArrayView<'_, VarBin>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(varbin_scalar(array.bytes_at(index), array.dtype()))
     }
 }
diff --git a/vortex-array/src/arrays/varbin/vtable/validity.rs b/vortex-array/src/arrays/varbin/vtable/validity.rs
index cdcdf172d49..4af0a9a0b0e 100644
--- a/vortex-array/src/arrays/varbin/vtable/validity.rs
+++ b/vortex-array/src/arrays/varbin/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::varbin::VarBinArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::varbin::VarBinArrayExt;
+use crate::arrays::varbin::vtable::VarBin;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for VarBinArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<VarBin> for VarBin {
+    fn validity(array: ArrayView<'_, VarBin>) -> VortexResult<Validity> {
+        Ok(array.varbin_validity())
     }
 }
diff --git a/vortex-array/src/arrays/varbin/vtable/visitor.rs b/vortex-array/src/arrays/varbin/vtable/visitor.rs
deleted file mode 100644
index 80c08648545..00000000000
--- a/vortex-array/src/arrays/varbin/vtable/visitor.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<VarBinVTable> for VarBinVTable {
-    fn visit_buffers(array: &VarBinArray, visitor: &mut dyn ArrayBufferVisitor) {
-        // TODO(ngates): sliced bytes?
-        visitor.visit_buffer_handle("bytes", array.bytes_handle());
-    }
-
-    fn nbuffers(_array: &VarBinArray) -> usize {
-        1
-    }
-
-    fn visit_children(array: &VarBinArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_child("offsets", array.offsets());
-        visitor.visit_validity(array.validity(), array.len());
-    }
-
-    fn nchildren(array: &VarBinArray) -> usize {
-        1 + validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &VarBinArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => Some(array.offsets().clone()),
-            1 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/varbinview/accessor.rs b/vortex-array/src/arrays/varbinview/accessor.rs
index 285e6e006b2..ef1470a090d 100644
--- a/vortex-array/src/arrays/varbinview/accessor.rs
+++ b/vortex-array/src/arrays/varbinview/accessor.rs
@@ -3,24 +3,28 @@
 
 use std::iter;
 
+use vortex_error::VortexExpect;
+
 use crate::ToCanonical;
 use crate::accessor::ArrayAccessor;
-use crate::arrays::varbinview::VarBinViewArray;
+use crate::arrays::VarBinViewArray;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 impl ArrayAccessor<[u8]> for VarBinViewArray {
     fn with_iterator<F: for<'a> FnOnce(&mut dyn Iterator<Item = Option<&'a [u8]>>) -> R, R>(
         &self,
         f: F,
     ) -> R {
-        let bytes = (0..self.nbuffers())
+        let bytes = (0..self.data_buffers().len())
             .map(|i| self.buffer(i))
             .collect::<Vec<_>>();
 
         let views = self.views();
 
-        match self.validity() {
+        match self
+            .validity()
+            .vortex_expect("varbinview validity should be derivable")
+        {
             Validity::NonNullable | Validity::AllValid => {
                 let mut iter = views.iter().map(|view| {
                     if view.is_inlined() {
diff --git a/vortex-array/src/arrays/varbinview/array.rs b/vortex-array/src/arrays/varbinview/array.rs
index 97377fa972e..37d055107cf 100644
--- a/vortex-array/src/arrays/varbinview/array.rs
+++ b/vortex-array/src/arrays/varbinview/array.rs
@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::mem::size_of;
 use std::sync::Arc;
 
 use vortex_buffer::Alignment;
@@ -12,16 +15,28 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
-
-use crate::arrays::BinaryView;
+use vortex_mask::Mask;
+
+use crate::ArrayRef;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::TypedArrayRef;
+use crate::array::child_to_validity;
+use crate::array::validity_to_child;
+use crate::arrays::VarBinView;
+use crate::arrays::varbinview::BinaryView;
 use crate::buffer::BufferHandle;
 use crate::builders::ArrayBuilder;
 use crate::builders::VarBinViewBuilder;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
-use crate::stats::ArrayStats;
 use crate::validity::Validity;
 
+/// The validity bitmap indicating which elements are non-null.
+pub(super) const VALIDITY_SLOT: usize = 0;
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
+
 /// A variable-length binary view array that stores strings and binary data efficiently.
 ///
 /// This mirrors the Apache Arrow StringView/BinaryView array encoding and provides
@@ -82,28 +97,44 @@ use crate::validity::Validity;
 /// assert_eq!(second.as_slice(), b"this string is outlined"); // Long string
 /// ```
 #[derive(Clone, Debug)]
-pub struct VarBinViewArray {
-    pub(super) dtype: DType,
+pub struct VarBinViewData {
     pub(super) buffers: Arc<[BufferHandle]>,
     pub(super) views: BufferHandle,
-    pub(super) validity: Validity,
-    pub(super) stats_set: ArrayStats,
 }
 
-pub struct VarBinViewArrayParts {
+impl Display for VarBinViewData {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
+pub struct VarBinViewDataParts {
     pub dtype: DType,
     pub buffers: Arc<[BufferHandle]>,
     pub views: BufferHandle,
     pub validity: Validity,
 }
 
-impl VarBinViewArray {
-    /// Creates a new [`VarBinViewArray`].
+impl VarBinViewData {
+    fn dtype_parts(dtype: &DType) -> VortexResult<(bool, Nullability)> {
+        match dtype {
+            DType::Utf8(nullability) => Ok((true, *nullability)),
+            DType::Binary(nullability) => Ok((false, *nullability)),
+            _ => vortex_bail!(InvalidArgument: "invalid DType {dtype} for `VarBinViewArray`"),
+        }
+    }
+
+    /// Build the slots vector for this array.
+    pub(super) fn make_slots(validity: &Validity, len: usize) -> Vec<Option<ArrayRef>> {
+        vec![validity_to_child(validity, len)]
+    }
+
+    /// Creates a new `VarBinViewArray`.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`VarBinViewArray::new_unchecked`].
+    /// in `VarBinViewArray::new_unchecked`.
     pub fn new(
         views: Buffer<BinaryView>,
         buffers: Arc<[ByteBuffer]>,
@@ -114,12 +145,12 @@ impl VarBinViewArray {
             .vortex_expect("VarBinViewArray construction failed")
     }
 
-    /// Creates a new [`VarBinViewArray`] with device or host memory.
+    /// Creates a new `VarBinViewArray` with device or host memory.
     ///
     /// # Panics
     ///
     /// Panics if the provided components do not satisfy the invariants documented
-    /// in [`VarBinViewArray::new_unchecked`].
+    /// in `VarBinViewArray::new_unchecked`.
     pub fn new_handle(
         views: BufferHandle,
         buffers: Arc<[BufferHandle]>,
@@ -132,12 +163,12 @@ impl VarBinViewArray {
 
     /// Constructs a new `VarBinViewArray`.
     ///
-    /// See [`VarBinViewArray::new_unchecked`] for more information.
+    /// See `VarBinViewArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`VarBinViewArray::new_unchecked`].
+    /// `VarBinViewArray::new_unchecked`.
     pub fn try_new(
         views: Buffer<BinaryView>,
         buffers: Arc<[ByteBuffer]>,
@@ -152,12 +183,12 @@ impl VarBinViewArray {
 
     /// Constructs a new `VarBinViewArray`.
     ///
-    /// See [`VarBinViewArray::new_unchecked`] for more information.
+    /// See `VarBinViewArray::new_unchecked` for more information.
     ///
     /// # Errors
     ///
     /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// [`VarBinViewArray::new_unchecked`].
+    /// `VarBinViewArray::new_unchecked`.
     pub fn try_new_handle(
         views: BufferHandle,
         buffers: Arc<[BufferHandle]>,
@@ -183,7 +214,7 @@ impl VarBinViewArray {
         Ok(unsafe { Self::new_handle_unchecked(views, buffers, dtype, validity) })
     }
 
-    /// Creates a new [`VarBinViewArray`] without validation from these components:
+    /// Creates a new `VarBinViewArray` without validation from these components:
     ///
     /// * `views` is a buffer of 16-byte view entries (one per logical element).
     /// * `buffers` contains the backing storage for strings longer than 12 bytes.
@@ -242,20 +273,16 @@ impl VarBinViewArray {
         views: BufferHandle,
         buffers: Arc<[BufferHandle]>,
         dtype: DType,
-        validity: Validity,
+        _validity: Validity,
     ) -> Self {
-        Self {
-            views,
-            buffers,
-            dtype,
-            validity,
-            stats_set: Default::default(),
-        }
+        let _ =
+            Self::dtype_parts(&dtype).vortex_expect("VarBinViewArray dtype must be utf8 or binary");
+        Self { buffers, views }
     }
 
-    /// Validates the components that would be used to create a [`VarBinViewArray`].
+    /// Validates the components that would be used to create a `VarBinViewArray`.
     ///
-    /// This function checks all the invariants required by [`VarBinViewArray::new_unchecked`].
+    /// This function checks all the invariants required by `VarBinViewArray::new_unchecked`.
     pub fn validate(
         views: &Buffer<BinaryView>,
         buffers: &Arc<[ByteBuffer]>,
@@ -309,7 +336,7 @@ impl VarBinViewArray {
                 let end_offset = start_offset.saturating_add(view.size as usize);
 
                 let buf = buffers.get(buf_index).ok_or_else(||
-                    vortex_err!(InvalidArgument: "view at index {idx} references invalid buffer: {buf_index} out of bounds for VarBinViewArray with {} buffers",
+                    vortex_err!(InvalidArgument: "view at index {idx} references invalid buffer: {buf_index} out of bounds for VarBinViewData with {} buffers",
                         buffers.len()))?;
 
                 vortex_ensure!(
@@ -342,19 +369,14 @@ impl VarBinViewArray {
         Ok(())
     }
 
-    /// Splits the array into owned parts
-    pub fn into_parts(self) -> VarBinViewArrayParts {
-        VarBinViewArrayParts {
-            dtype: self.dtype,
-            buffers: self.buffers,
-            views: self.views,
-            validity: self.validity,
-        }
+    /// Returns the length of this array.
+    pub fn len(&self) -> usize {
+        self.views.len() / size_of::<BinaryView>()
     }
 
-    /// Number of raw string data buffers held by this array.
-    pub fn nbuffers(&self) -> usize {
-        self.buffers.len()
+    /// Returns `true` if this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     /// Access to the primitive views buffer.
@@ -406,18 +428,18 @@ impl VarBinViewArray {
     /// at construction time.
     #[inline]
     pub fn buffer(&self, idx: usize) -> &ByteBuffer {
-        if idx >= self.nbuffers() {
+        if idx >= self.data_buffers().len() {
             vortex_panic!(
                 "{idx} buffer index out of bounds, there are {} buffers",
-                self.nbuffers()
+                self.data_buffers().len()
             );
         }
         self.buffers[idx].as_host()
     }
 
-    /// Iterate over the underlying raw data buffers, not including the views buffer.
+    /// The underlying raw data buffers, not including the views buffer.
     #[inline]
-    pub fn buffers(&self) -> &Arc<[BufferHandle]> {
+    pub fn data_buffers(&self) -> &Arc<[BufferHandle]> {
         &self.buffers
     }
 
@@ -440,7 +462,7 @@ impl VarBinViewArray {
             }
         }
 
-        builder.finish_into_varbinview()
+        builder.finish_into_varbinview().into_data()
     }
 
     pub fn from_iter_str<T: AsRef<str>, I: IntoIterator<Item = T>>(iter: I) -> Self {
@@ -454,7 +476,7 @@ impl VarBinViewArray {
             builder.append_value(item.as_ref());
         }
 
-        builder.finish_into_varbinview()
+        builder.finish_into_varbinview().into_data()
     }
 
     pub fn from_iter_nullable_str<T: AsRef<str>, I: IntoIterator<Item = Option<T>>>(
@@ -473,7 +495,7 @@ impl VarBinViewArray {
             }
         }
 
-        builder.finish_into_varbinview()
+        builder.finish_into_varbinview().into_data()
     }
 
     pub fn from_iter_bin<T: AsRef<[u8]>, I: IntoIterator<Item = T>>(iter: I) -> Self {
@@ -487,7 +509,7 @@ impl VarBinViewArray {
             builder.append_value(item.as_ref());
         }
 
-        builder.finish_into_varbinview()
+        builder.finish_into_varbinview().into_data()
     }
 
     pub fn from_iter_nullable_bin<T: AsRef<[u8]>, I: IntoIterator<Item = Option<T>>>(
@@ -506,29 +528,240 @@ impl VarBinViewArray {
             }
         }
 
+        builder.finish_into_varbinview().into_data()
+    }
+}
+
+pub trait VarBinViewArrayExt: TypedArrayRef<VarBinView> {
+    fn dtype_parts(&self) -> (bool, Nullability) {
+        match self.as_ref().dtype() {
+            DType::Utf8(nullability) => (true, *nullability),
+            DType::Binary(nullability) => (false, *nullability),
+            _ => unreachable!("VarBinViewArrayExt requires a utf8 or binary dtype"),
+        }
+    }
+
+    fn varbinview_validity(&self) -> Validity {
+        child_to_validity(&self.as_ref().slots()[VALIDITY_SLOT], self.dtype_parts().1)
+    }
+
+    fn varbinview_validity_mask(&self) -> Mask {
+        self.varbinview_validity().to_mask(self.as_ref().len())
+    }
+}
+impl<T: TypedArrayRef<VarBinView>> VarBinViewArrayExt for T {}
+
+impl Array<VarBinView> {
+    #[inline]
+    fn from_prevalidated_data(
+        dtype: DType,
+        data: VarBinViewData,
+        slots: Vec<Option<ArrayRef>>,
+    ) -> Self {
+        let len = data.len();
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(VarBinView, dtype, len, data).with_slots(slots),
+            )
+        }
+    }
+
+    /// Construct a `VarBinViewArray` from an iterator of optional byte slices.
+    #[expect(
+        clippy::same_name_method,
+        reason = "intentionally named from_iter like Iterator::from_iter"
+    )]
+    pub fn from_iter<T: AsRef<[u8]>, I: IntoIterator<Item = Option<T>>>(
+        iter: I,
+        dtype: DType,
+    ) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = VarBinViewBuilder::with_capacity(dtype, iter.size_hint().0);
+        for value in iter {
+            match value {
+                Some(value) => builder.append_value(value),
+                None => builder.append_null(),
+            }
+        }
+        builder.finish_into_varbinview()
+    }
+
+    pub fn from_iter_str<T: AsRef<str>, I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = VarBinViewBuilder::with_capacity(
+            DType::Utf8(Nullability::NonNullable),
+            iter.size_hint().0,
+        );
+        for value in iter {
+            builder.append_value(value.as_ref());
+        }
         builder.finish_into_varbinview()
     }
+
+    pub fn from_iter_nullable_str<T: AsRef<str>, I: IntoIterator<Item = Option<T>>>(
+        iter: I,
+    ) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = VarBinViewBuilder::with_capacity(
+            DType::Utf8(Nullability::Nullable),
+            iter.size_hint().0,
+        );
+        for value in iter {
+            match value {
+                Some(value) => builder.append_value(value.as_ref()),
+                None => builder.append_null(),
+            }
+        }
+        builder.finish_into_varbinview()
+    }
+
+    pub fn from_iter_bin<T: AsRef<[u8]>, I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = VarBinViewBuilder::with_capacity(
+            DType::Binary(Nullability::NonNullable),
+            iter.size_hint().0,
+        );
+        for value in iter {
+            builder.append_value(value.as_ref());
+        }
+        builder.finish_into_varbinview()
+    }
+
+    pub fn from_iter_nullable_bin<T: AsRef<[u8]>, I: IntoIterator<Item = Option<T>>>(
+        iter: I,
+    ) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = VarBinViewBuilder::with_capacity(
+            DType::Binary(Nullability::Nullable),
+            iter.size_hint().0,
+        );
+        for value in iter {
+            match value {
+                Some(value) => builder.append_value(value.as_ref()),
+                None => builder.append_null(),
+            }
+        }
+        builder.finish_into_varbinview()
+    }
+
+    /// Creates a new `VarBinViewArray`.
+    pub fn try_new(
+        views: Buffer<BinaryView>,
+        buffers: Arc<[ByteBuffer]>,
+        dtype: DType,
+        validity: Validity,
+    ) -> VortexResult<Self> {
+        let data = VarBinViewData::try_new(views, buffers, dtype.clone(), validity.clone())?;
+        let slots = VarBinViewData::make_slots(&validity, data.len());
+        Ok(Self::from_prevalidated_data(dtype, data, slots))
+    }
+
+    /// Creates a new `VarBinViewArray` without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`VarBinViewData::new_unchecked`].
+    pub unsafe fn new_unchecked(
+        views: Buffer<BinaryView>,
+        buffers: Arc<[ByteBuffer]>,
+        dtype: DType,
+        validity: Validity,
+    ) -> Self {
+        let data = unsafe {
+            VarBinViewData::new_unchecked(views, buffers, dtype.clone(), validity.clone())
+        };
+        let slots = VarBinViewData::make_slots(&validity, data.len());
+        Self::from_prevalidated_data(dtype, data, slots)
+    }
+
+    /// Creates a new `VarBinViewArray` with device or host memory.
+    pub fn new_handle(
+        views: BufferHandle,
+        buffers: Arc<[BufferHandle]>,
+        dtype: DType,
+        validity: Validity,
+    ) -> Self {
+        let data = VarBinViewData::new_handle(views, buffers, dtype.clone(), validity.clone());
+        let slots = VarBinViewData::make_slots(&validity, data.len());
+        Self::from_prevalidated_data(dtype, data, slots)
+    }
+
+    /// Construct a new array from `BufferHandle`s without validation.
+    ///
+    /// # Safety
+    ///
+    /// See [`VarBinViewData::new_handle_unchecked`].
+    pub unsafe fn new_handle_unchecked(
+        views: BufferHandle,
+        buffers: Arc<[BufferHandle]>,
+        dtype: DType,
+        validity: Validity,
+    ) -> Self {
+        let data = unsafe {
+            VarBinViewData::new_handle_unchecked(views, buffers, dtype.clone(), validity.clone())
+        };
+        let slots = VarBinViewData::make_slots(&validity, data.len());
+        Self::from_prevalidated_data(dtype, data, slots)
+    }
+
+    pub fn into_data_parts(self) -> VarBinViewDataParts {
+        let dtype = self.dtype().clone();
+        let validity = self.varbinview_validity();
+        let data = self.into_data();
+        VarBinViewDataParts {
+            dtype,
+            buffers: data.buffers,
+            views: data.views,
+            validity,
+        }
+    }
 }
 
-impl<'a> FromIterator<Option<&'a [u8]>> for VarBinViewArray {
+impl<'a> FromIterator<Option<&'a [u8]>> for VarBinViewData {
     fn from_iter<T: IntoIterator<Item = Option<&'a [u8]>>>(iter: T) -> Self {
         Self::from_iter_nullable_bin(iter)
     }
 }
 
-impl FromIterator<Option<Vec<u8>>> for VarBinViewArray {
+impl FromIterator<Option<Vec<u8>>> for VarBinViewData {
     fn from_iter<T: IntoIterator<Item = Option<Vec<u8>>>>(iter: T) -> Self {
         Self::from_iter_nullable_bin(iter)
     }
 }
 
-impl FromIterator<Option<String>> for VarBinViewArray {
+impl FromIterator<Option<String>> for VarBinViewData {
+    fn from_iter<T: IntoIterator<Item = Option<String>>>(iter: T) -> Self {
+        Self::from_iter_nullable_str(iter)
+    }
+}
+
+impl<'a> FromIterator<Option<&'a str>> for VarBinViewData {
+    fn from_iter<T: IntoIterator<Item = Option<&'a str>>>(iter: T) -> Self {
+        Self::from_iter_nullable_str(iter)
+    }
+}
+
+// --- FromIterator forwarding for Array<VarBinView> ---
+
+impl<'a> FromIterator<Option<&'a [u8]>> for Array<VarBinView> {
+    fn from_iter<T: IntoIterator<Item = Option<&'a [u8]>>>(iter: T) -> Self {
+        Self::from_iter(iter, DType::Binary(Nullability::Nullable))
+    }
+}
+
+impl FromIterator<Option<Vec<u8>>> for Array<VarBinView> {
+    fn from_iter<T: IntoIterator<Item = Option<Vec<u8>>>>(iter: T) -> Self {
+        Self::from_iter(iter, DType::Binary(Nullability::Nullable))
+    }
+}
+
+impl FromIterator<Option<String>> for Array<VarBinView> {
     fn from_iter<T: IntoIterator<Item = Option<String>>>(iter: T) -> Self {
         Self::from_iter_nullable_str(iter)
     }
 }
 
-impl<'a> FromIterator<Option<&'a str>> for VarBinViewArray {
+impl<'a> FromIterator<Option<&'a str>> for Array<VarBinView> {
     fn from_iter<T: IntoIterator<Item = Option<&'a str>>>(iter: T) -> Self {
         Self::from_iter_nullable_str(iter)
     }
diff --git a/vortex-array/src/arrays/varbinview/build_views.rs b/vortex-array/src/arrays/varbinview/build_views.rs
index 0ce76fd2175..87f5c84706b 100644
--- a/vortex-array/src/arrays/varbinview/build_views.rs
+++ b/vortex-array/src/arrays/varbinview/build_views.rs
@@ -8,7 +8,7 @@ use vortex_buffer::BufferMut;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 
-pub use crate::arrays::BinaryView;
+pub use crate::arrays::varbinview::BinaryView;
 use crate::dtype::NativePType;
 
 /// Convert an offsets buffer to a buffer of element lengths.
@@ -69,8 +69,8 @@ mod tests {
     use vortex_buffer::ByteBuffer;
     use vortex_buffer::ByteBufferMut;
 
-    use crate::arrays::BinaryView;
-    use crate::arrays::build_views::build_views;
+    use crate::arrays::varbinview::BinaryView;
+    use crate::arrays::varbinview::build_views::build_views;
 
     #[test]
     fn test_to_canonical_large() {
diff --git a/vortex-array/src/arrays/varbinview/compact.rs b/vortex-array/src/arrays/varbinview/compact.rs
index b5d8223fd07..37bae3d9822 100644
--- a/vortex-array/src/arrays/varbinview/compact.rs
+++ b/vortex-array/src/arrays/varbinview/compact.rs
@@ -10,8 +10,9 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::arrays::Ref;
+use crate::IntoArray;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::varbinview::Ref;
 use crate::builders::ArrayBuilder;
 use crate::builders::VarBinViewBuilder;
 
@@ -35,7 +36,7 @@ impl VarBinViewArray {
     }
 
     fn should_compact(&self) -> VortexResult<bool> {
-        let nbuffers = self.nbuffers();
+        let nbuffers = self.data_buffers().len();
 
         // If the array is entirely inlined strings, do not attempt to compact.
         if nbuffers == 0 {
@@ -92,7 +93,7 @@ impl VarBinViewArray {
 
     pub(crate) fn buffer_utilizations(&self) -> VortexResult<Vec<BufferUtilization>> {
         let mut utilizations: Vec<BufferUtilization> = self
-            .buffers()
+            .data_buffers()
             .iter()
             .map(|buf| {
                 let len = u32::try_from(buf.len()).vortex_expect("buffer sizes must fit in u32");
@@ -130,7 +131,7 @@ impl VarBinViewArray {
             self.len(),
             buffer_utilization_threshold,
         );
-        builder.extend_from_array(self.as_ref());
+        builder.extend_from_array(&self.clone().into_array());
         Ok(builder.finish_into_varbinview())
     }
 }
@@ -206,17 +207,17 @@ mod tests {
         ]);
 
         // Verify it has buffers
-        assert!(original.nbuffers() > 0);
-        let original_buffers = original.nbuffers();
+        assert!(!original.data_buffers().is_empty());
+        let original_buffers = original.data_buffers().len();
 
         // Take only the first and last elements (indices 0 and 4)
         let indices = buffer![0u32, 4u32].into_array();
-        let taken = original.take(indices.to_array()).unwrap();
+        let taken = original.take(indices).unwrap();
         let taken = taken
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
         // The taken array should still have the same number of buffers
-        assert_eq!(taken.nbuffers(), original_buffers);
+        assert_eq!(taken.data_buffers().len(), original_buffers);
 
         // Now optimize the taken array
         let optimized_array = taken.compact_buffers().unwrap();
@@ -224,7 +225,7 @@ mod tests {
         // The optimized array should have compacted buffers
         // Since both remaining strings are short, they should be inlined
         // so we might have 0 buffers, or 1 buffer if any were not inlined
-        assert!(optimized_array.nbuffers() <= 1);
+        assert!(optimized_array.data_buffers().len() <= 1);
 
         // Verify the data is still correct
         assert_arrays_eq!(
@@ -250,7 +251,7 @@ mod tests {
 
         // Take only the first and third long strings (indices 0 and 2)
         let indices = buffer![0u32, 2u32].into_array();
-        let taken = original.take(indices.to_array()).unwrap();
+        let taken = original.take(indices).unwrap();
         let taken_array = taken
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
@@ -259,7 +260,7 @@ mod tests {
         let optimized_array = taken_array.compact_buffers().unwrap();
 
         // The optimized array should have exactly 1 buffer (consolidated)
-        assert_eq!(optimized_array.nbuffers(), 1);
+        assert_eq!(optimized_array.data_buffers().len(), 1);
 
         // Verify the data is still correct
         assert_arrays_eq!(
@@ -274,12 +275,12 @@ mod tests {
         let original = VarBinViewArray::from_iter_str(["a", "bb", "ccc", "dddd"]);
 
         // This should have no buffers
-        assert_eq!(original.nbuffers(), 0);
+        assert_eq!(original.data_buffers().len(), 0);
 
         // Optimize should return the same array
         let optimized_array = original.compact_buffers().unwrap();
 
-        assert_eq!(optimized_array.nbuffers(), 0);
+        assert_eq!(optimized_array.data_buffers().len(), 0);
 
         assert_arrays_eq!(optimized_array, original);
     }
@@ -292,13 +293,13 @@ mod tests {
         let original = VarBinViewArray::from_iter_str([str1, str2]);
 
         // Should have 1 compact buffer
-        assert_eq!(original.nbuffers(), 1);
+        assert_eq!(original.data_buffers().len(), 1);
         assert_eq!(original.buffer(0).len(), str1.len() + str2.len());
 
         // Optimize should return the same array (no change needed)
         let optimized_array = original.compact_buffers().unwrap();
 
-        assert_eq!(optimized_array.nbuffers(), 1);
+        assert_eq!(optimized_array.data_buffers().len(), 1);
 
         assert_arrays_eq!(optimized_array, original);
     }
@@ -311,12 +312,12 @@ mod tests {
             "another very long string that definitely needs a buffer to store it",
         ]);
 
-        let original_buffers = original.nbuffers();
+        let original_buffers = original.data_buffers().len();
         assert!(original_buffers > 0);
 
         // Take only first element
         let indices = buffer![0u32].into_array();
-        let taken = original.take(indices.to_array()).unwrap();
+        let taken = original.take(indices).unwrap();
         let taken = taken
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
@@ -324,7 +325,7 @@ mod tests {
         let compacted = taken.compact_with_threshold(0.0).unwrap();
 
         // Should still have the same number of buffers as the taken array
-        assert_eq!(compacted.nbuffers(), taken.nbuffers());
+        assert_eq!(compacted.data_buffers().len(), taken.data_buffers().len());
 
         // Verify correctness
         assert_arrays_eq!(compacted, taken);
@@ -341,19 +342,18 @@ mod tests {
 
         // Take only first and last elements
         let indices = buffer![0u32, 2u32].into_array();
-        let taken = original.take(indices.to_array()).unwrap();
+        let taken = original.take(indices).unwrap();
         let taken = taken
-            .clone()
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
 
-        let original_buffers = taken.nbuffers();
+        let original_buffers = taken.data_buffers().len();
 
         // Compact with threshold=1.0 (aggressive compaction)
         let compacted = taken.compact_with_threshold(1.0).unwrap();
 
         // Should have compacted buffers
-        assert!(compacted.nbuffers() <= original_buffers);
+        assert!(compacted.data_buffers().len() <= original_buffers);
 
         // Verify correctness
         assert_arrays_eq!(compacted, taken);
@@ -369,13 +369,13 @@ mod tests {
         let original = VarBinViewArray::from_iter_str([str1, str2, str3]);
 
         // All strings should be in one well-utilized buffer
-        assert_eq!(original.nbuffers(), 1);
+        assert_eq!(original.data_buffers().len(), 1);
 
         // Compact with high threshold
         let compacted = original.compact_with_threshold(0.8).unwrap();
 
         // Well-utilized buffer should be preserved
-        assert_eq!(compacted.nbuffers(), 1);
+        assert_eq!(compacted.data_buffers().len(), 1);
 
         // Verify all data is correct
         assert_arrays_eq!(compacted, original);
@@ -397,7 +397,7 @@ mod tests {
 
         // Take every other element to create mixed utilization
         let indices_array = buffer![0u32, 2u32, 4u32, 6u32, 8u32].into_array();
-        let taken = original.take(indices_array.to_array()).unwrap();
+        let taken = original.take(indices_array).unwrap();
         let taken = taken
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
@@ -423,13 +423,13 @@ mod tests {
 
         // Take only the first 5 elements - they should be in a contiguous range at the start
         let indices_array = buffer![0u32, 1u32, 2u32, 3u32, 4u32].into_array();
-        let taken = original.take(indices_array.to_array()).unwrap();
+        let taken = original.take(indices_array).unwrap();
         let taken = taken
             .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
             .unwrap();
         // Get buffer stats before compaction
         let utils_before = taken.buffer_utilizations().unwrap();
-        let original_buffer_count = taken.nbuffers();
+        let original_buffer_count = taken.data_buffers().len();
 
         // Compact with a threshold that should trigger slicing
         // The range utilization should be high even if overall utilization is low
@@ -437,7 +437,7 @@ mod tests {
 
         // After compaction, we should still have buffers (sliced, not rewritten)
         assert!(
-            compacted.nbuffers() > 0,
+            !compacted.data_buffers().is_empty(),
             "Should have buffers after slice compaction"
         );
 
@@ -448,7 +448,7 @@ mod tests {
         // (it was sliced, not rewritten into multiple buffers)
         if original_buffer_count == 1 && utils_before[0].range_utilization() >= 0.8 {
             assert_eq!(
-                compacted.nbuffers(),
+                compacted.data_buffers().len(),
                 1,
                 "Slice strategy should maintain single buffer"
             );
diff --git a/vortex-array/src/arrays/varbinview/compute/cast.rs b/vortex-array/src/arrays/varbinview/compute/cast.rs
index 210d4f3e99d..a8e649f52e4 100644
--- a/vortex-array/src/arrays/varbinview/compute/cast.rs
+++ b/vortex-array/src/arrays/varbinview/compute/cast.rs
@@ -1,26 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
 use crate::dtype::DType;
 use crate::scalar_fn::fns::cast::CastReduce;
-use crate::vtable::ValidityHelper;
 
-impl CastReduce for VarBinViewVTable {
-    fn cast(array: &VarBinViewArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+impl CastReduce for VarBinView {
+    fn cast(array: ArrayView<'_, VarBinView>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         if !array.dtype().eq_ignore_nullability(dtype) {
             return Ok(None);
         }
 
         let new_nullability = dtype.nullability();
         let new_validity = array
-            .validity()
-            .clone()
+            .validity()?
             .cast_nullability(new_nullability, array.len())?;
         let new_dtype = array.dtype().with_nullability(new_nullability);
 
@@ -29,7 +30,7 @@ impl CastReduce for VarBinViewVTable {
             Ok(Some(
                 VarBinViewArray::new_handle_unchecked(
                     array.views_handle().clone(),
-                    array.buffers().clone(),
+                    Arc::clone(array.data_buffers()),
                     new_dtype,
                     new_validity,
                 )
@@ -43,6 +44,7 @@ impl CastReduce for VarBinViewVTable {
 mod tests {
     use rstest::rstest;
 
+    use crate::IntoArray;
     use crate::arrays::VarBinViewArray;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -69,7 +71,7 @@ mod tests {
     fn try_cast_varbin_nullable(#[case] source: DType, #[case] target: DType) {
         let varbin = VarBinViewArray::from_iter(vec![Some("a"), Some("b"), Some("c")], source);
 
-        let res = varbin.to_array().cast(target.clone());
+        let res = varbin.into_array().cast(target.clone());
         assert_eq!(res.unwrap().dtype(), &target);
     }
 
@@ -81,7 +83,7 @@ mod tests {
     fn try_cast_varbin_fail(#[case] source: DType) {
         let non_nullable_source = source.as_nonnullable();
         let varbin = VarBinViewArray::from_iter(vec![Some("a"), Some("b"), None], source);
-        varbin.to_array().cast(non_nullable_source).unwrap();
+        varbin.into_array().cast(non_nullable_source).unwrap();
     }
 
     #[rstest]
@@ -92,6 +94,6 @@ mod tests {
     #[case(VarBinViewArray::from_iter(vec![Some("single")], DType::Utf8(Nullability::NonNullable)))]
     #[case(VarBinViewArray::from_iter(vec![Some("very long string that exceeds the inline size to test view functionality with multiple buffers")], DType::Utf8(Nullability::NonNullable)))]
     fn test_cast_varbinview_conformance(#[case] array: VarBinViewArray) {
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/is_constant.rs b/vortex-array/src/arrays/varbinview/compute/is_constant.rs
deleted file mode 100644
index 406cf57ed65..00000000000
--- a/vortex-array/src/arrays/varbinview/compute/is_constant.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-
-use crate::arrays::Ref;
-use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
-use crate::compute::IsConstantKernel;
-use crate::compute::IsConstantKernelAdapter;
-use crate::compute::IsConstantOpts;
-use crate::register_kernel;
-
-impl IsConstantKernel for VarBinViewVTable {
-    fn is_constant(
-        &self,
-        array: &VarBinViewArray,
-        _opts: &IsConstantOpts,
-    ) -> VortexResult<Option<bool>> {
-        let mut views_iter = array.views().iter();
-        let first_value = views_iter
-            .next()
-            .vortex_expect("Must have at least one value");
-
-        // For the array to be constant, all views must be of the same type
-        if first_value.is_inlined() {
-            let first_value = first_value.as_inlined();
-
-            for view in views_iter {
-                // Short circuit if the view is of the wrong type, then if both are inlined they must be equal.
-                if !view.is_inlined() || view.as_inlined() != first_value {
-                    return Ok(Some(false));
-                }
-            }
-        } else {
-            // Directly fetch the values for a `Ref`
-            let ref_bytes = |view_ref: &Ref| {
-                &array.buffer(view_ref.buffer_index as usize).as_slice()[view_ref.as_range()]
-            };
-
-            let first_view_ref = first_value.as_view();
-            let first_value_bytes = ref_bytes(first_view_ref);
-
-            for view in views_iter {
-                // Short circuit if the view is of the wrong type
-                if view.is_inlined() || view.len() != first_value.len() {
-                    return Ok(Some(false));
-                }
-
-                let view_ref = view.as_view();
-                let value = ref_bytes(view_ref);
-                if value != first_value_bytes {
-                    return Ok(Some(false));
-                }
-            }
-        }
-
-        Ok(Some(true))
-    }
-}
-
-register_kernel!(IsConstantKernelAdapter(VarBinViewVTable).lift());
diff --git a/vortex-array/src/arrays/varbinview/compute/is_sorted.rs b/vortex-array/src/arrays/varbinview/compute/is_sorted.rs
deleted file mode 100644
index 64c93d138f2..00000000000
--- a/vortex-array/src/arrays/varbinview/compute/is_sorted.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::accessor::ArrayAccessor;
-use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
-use crate::compute::IsSortedIteratorExt;
-use crate::compute::IsSortedKernel;
-use crate::compute::IsSortedKernelAdapter;
-use crate::register_kernel;
-
-impl IsSortedKernel for VarBinViewVTable {
-    fn is_sorted(&self, array: &VarBinViewArray) -> VortexResult<Option<bool>> {
-        Ok(Some(
-            array.with_iterator(|bytes_iter| bytes_iter.is_sorted()),
-        ))
-    }
-
-    fn is_strict_sorted(&self, array: &VarBinViewArray) -> VortexResult<Option<bool>> {
-        Ok(Some(
-            array.with_iterator(|bytes_iter| bytes_iter.is_strict_sorted()),
-        ))
-    }
-}
-
-register_kernel!(IsSortedKernelAdapter(VarBinViewVTable).lift());
diff --git a/vortex-array/src/arrays/varbinview/compute/mask.rs b/vortex-array/src/arrays/varbinview/compute/mask.rs
index eed87a03e90..6172c42ab7d 100644
--- a/vortex-array/src/arrays/varbinview/compute/mask.rs
+++ b/vortex-array/src/arrays/varbinview/compute/mask.rs
@@ -1,29 +1,28 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
 use crate::scalar_fn::fns::mask::MaskReduce;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl MaskReduce for VarBinViewVTable {
-    fn mask(array: &VarBinViewArray, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
+impl MaskReduce for VarBinView {
+    fn mask(array: ArrayView<'_, VarBinView>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         // SAFETY: masking the validity does not affect the invariants
         unsafe {
             Ok(Some(
                 VarBinViewArray::new_handle_unchecked(
                     array.views_handle().clone(),
-                    array.buffers().clone(),
+                    Arc::clone(array.data_buffers()),
                     array.dtype().as_nullable(),
-                    array
-                        .validity()
-                        .clone()
-                        .and(Validity::Array(mask.clone()))?,
+                    array.validity()?.and(Validity::Array(mask.clone()))?,
                 )
                 .into_array(),
             ))
@@ -33,24 +32,25 @@ impl MaskReduce for VarBinViewVTable {
 
 #[cfg(test)]
 mod tests {
+    use crate::IntoArray;
     use crate::arrays::VarBinViewArray;
     use crate::compute::conformance::mask::test_mask_conformance;
 
     #[test]
     fn take_mask_var_bin_view_array() {
         test_mask_conformance(
-            VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).as_ref(),
+            &VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]).into_array(),
         );
 
         test_mask_conformance(
-            VarBinViewArray::from_iter_nullable_str([
+            &VarBinViewArray::from_iter_nullable_str([
                 Some("one"),
                 None,
                 Some("three"),
                 Some("four"),
                 Some("five"),
             ])
-            .as_ref(),
+            .into_array(),
         );
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/min_max.rs b/vortex-array/src/arrays/varbinview/compute/min_max.rs
deleted file mode 100644
index dfa8bf086d3..00000000000
--- a/vortex-array/src/arrays/varbinview/compute/min_max.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
-use crate::arrays::varbin_compute_min_max;
-use crate::compute::MinMaxKernel;
-use crate::compute::MinMaxKernelAdapter;
-use crate::compute::MinMaxResult;
-use crate::register_kernel;
-
-impl MinMaxKernel for VarBinViewVTable {
-    fn min_max(&self, array: &VarBinViewArray) -> VortexResult<Option<MinMaxResult>> {
-        Ok(varbin_compute_min_max(array, array.dtype()))
-    }
-}
-
-register_kernel!(MinMaxKernelAdapter(VarBinViewVTable).lift());
diff --git a/vortex-array/src/arrays/varbinview/compute/mod.rs b/vortex-array/src/arrays/varbinview/compute/mod.rs
index dd6fa211976..772221f13ef 100644
--- a/vortex-array/src/arrays/varbinview/compute/mod.rs
+++ b/vortex-array/src/arrays/varbinview/compute/mod.rs
@@ -2,10 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod cast;
-mod is_constant;
-mod is_sorted;
 mod mask;
-mod min_max;
 pub(crate) mod rules;
 mod slice;
 mod take;
@@ -17,7 +14,6 @@ mod tests {
 
     use crate::IntoArray;
     use crate::accessor::ArrayAccessor;
-    use crate::array::Array;
     use crate::arrays::VarBinViewArray;
     use crate::canonical::ToCanonical;
     #[test]
@@ -82,6 +78,6 @@ mod tests {
         None::<&str>, None, None, None
     ]))]
     fn test_varbinview_consistency(#[case] array: VarBinViewArray) {
-        test_array_consistency(array.as_ref());
+        test_array_consistency(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/rules.rs b/vortex-array/src/arrays/varbinview/compute/rules.rs
index ec488571ca7..5ec24dca7de 100644
--- a/vortex-array/src/arrays/varbinview/compute/rules.rs
+++ b/vortex-array/src/arrays/varbinview/compute/rules.rs
@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
-use crate::arrays::SliceReduceAdaptor;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::VarBinView;
+use crate::arrays::slice::SliceReduceAdaptor;
 use crate::optimizer::rules::ParentRuleSet;
 use crate::scalar_fn::fns::cast::CastReduceAdaptor;
 use crate::scalar_fn::fns::mask::MaskReduceAdaptor;
 
-pub(crate) const PARENT_RULES: ParentRuleSet<VarBinViewVTable> = ParentRuleSet::new(&[
-    ParentRuleSet::lift(&CastReduceAdaptor(VarBinViewVTable)),
-    ParentRuleSet::lift(&MaskReduceAdaptor(VarBinViewVTable)),
-    ParentRuleSet::lift(&SliceReduceAdaptor(VarBinViewVTable)),
+pub(crate) const PARENT_RULES: ParentRuleSet<VarBinView> = ParentRuleSet::new(&[
+    ParentRuleSet::lift(&CastReduceAdaptor(VarBinView)),
+    ParentRuleSet::lift(&MaskReduceAdaptor(VarBinView)),
+    ParentRuleSet::lift(&SliceReduceAdaptor(VarBinView)),
 ]);
diff --git a/vortex-array/src/arrays/varbinview/compute/slice.rs b/vortex-array/src/arrays/varbinview/compute/slice.rs
index da3c5c007b9..19f5a0d41b0 100644
--- a/vortex-array/src/arrays/varbinview/compute/slice.rs
+++ b/vortex-array/src/arrays/varbinview/compute/slice.rs
@@ -8,19 +8,20 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::BinaryView;
-use crate::arrays::SliceReduce;
+use crate::array::ArrayView;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::slice::SliceReduce;
+use crate::arrays::varbinview::BinaryView;
 
-impl SliceReduce for VarBinViewVTable {
-    fn slice(array: &Self::Array, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
+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.buffers()),
+                Arc::clone(array.data_buffers()),
                 array.dtype().clone(),
                 array.validity()?.slice(range)?,
             )
diff --git a/vortex-array/src/arrays/varbinview/compute/take.rs b/vortex-array/src/arrays/varbinview/compute/take.rs
index 054306f68a9..644465ecac3 100644
--- a/vortex-array/src/arrays/varbinview/compute/take.rs
+++ b/vortex-array/src/arrays/varbinview/compute/take.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::iter;
+use std::sync::Arc;
 
 use num_traits::AsPrimitive;
 use vortex_buffer::Buffer;
@@ -9,28 +10,27 @@ use vortex_error::VortexResult;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::BinaryView;
-use crate::arrays::TakeExecute;
+use crate::array::ArrayView;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::dict::TakeExecute;
+use crate::arrays::varbinview::BinaryView;
 use crate::buffer::BufferHandle;
 use crate::executor::ExecutionCtx;
 use crate::match_each_integer_ptype;
-use crate::vtable::ValidityHelper;
 
-impl TakeExecute for VarBinViewVTable {
+impl TakeExecute for VarBinView {
     /// Take involves creating a new array that references the old array, just with the given set of views.
     fn take(
-        array: &VarBinViewArray,
-        indices: &dyn Array,
-        _ctx: &mut ExecutionCtx,
+        array: ArrayView<'_, VarBinView>,
+        indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let validity = array.validity().take(indices)?;
-        let indices = indices.to_primitive();
+        let validity = array.validity()?.take(indices)?;
+        let indices = indices.clone().execute::<PrimitiveArray>(ctx)?;
 
         let indices_mask = indices.validity_mask()?;
         let views_buffer = match_each_integer_ptype!(indices.ptype(), |I| {
@@ -42,7 +42,7 @@ impl TakeExecute for VarBinViewVTable {
             Ok(Some(
                 VarBinViewArray::new_handle_unchecked(
                     BufferHandle::new_host(views_buffer.into_byte_buffer()),
-                    array.buffers().clone(),
+                    Arc::clone(array.data_buffers()),
                     array
                         .dtype()
                         .union_nullability(indices.dtype().nullability()),
@@ -90,9 +90,8 @@ mod tests {
 
     use crate::IntoArray;
     use crate::accessor::ArrayAccessor;
-    use crate::array::Array;
-    use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinViewArray;
+    use crate::arrays::varbinview::compute::take::PrimitiveArray;
     use crate::canonical::ToCanonical;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::dtype::DType;
@@ -131,7 +130,7 @@ mod tests {
             Validity::from(BitBuffer::from(vec![true, false])),
         );
 
-        let taken = arr.take(indices.to_array()).unwrap();
+        let taken = arr.take(indices.into_array()).unwrap();
 
         assert!(taken.dtype().is_nullable());
         assert_eq!(
@@ -160,6 +159,6 @@ mod tests {
     ))]
     #[case(VarBinViewArray::from_iter(["single"].map(Some), DType::Utf8(NonNullable)))]
     fn test_take_varbinview_conformance(#[case] array: VarBinViewArray) {
-        test_take_conformance(array.as_ref());
+        test_take_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/zip.rs b/vortex-array/src/arrays/varbinview/compute/zip.rs
index e6df577432d..dfa2ae8e71c 100644
--- a/vortex-array/src/arrays/varbinview/compute/zip.rs
+++ b/vortex-array/src/arrays/varbinview/compute/zip.rs
@@ -9,26 +9,28 @@ use vortex_error::vortex_bail;
 use vortex_mask::AllOr;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::BinaryView;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::varbinview::BinaryView;
+use crate::arrays::varbinview::VarBinViewArrayExt;
 use crate::builders::DeduplicatedBuffers;
 use crate::builders::LazyBitBufferBuilder;
 use crate::scalar_fn::fns::zip::ZipKernel;
 
 // A dedicated VarBinView zip kernel that builds the result directly by adjusting views and validity,
 // instead of routing through the generic builder (which would redo buffer lookups per mask slice).
-impl ZipKernel for VarBinViewVTable {
+impl ZipKernel for VarBinView {
     fn zip(
-        if_true: &VarBinViewArray,
-        if_false: &dyn Array,
-        mask: &Mask,
-        _ctx: &mut ExecutionCtx,
+        if_true: ArrayView<'_, VarBinView>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
-        let Some(if_false) = if_false.as_opt::<VarBinViewVTable>() else {
+        let Some(if_false) = if_false.as_opt::<VarBinView>() else {
             return Ok(None);
         };
 
@@ -45,16 +47,18 @@ impl ZipKernel for VarBinViewVTable {
         // to the new buffer index in the result array
         let mut buffers = DeduplicatedBuffers::default();
         let true_lookup =
-            buffers.extend_from_iter(if_true.buffers().iter().map(|b| b.as_host().clone()));
+            buffers.extend_from_iter(if_true.data_buffers().iter().map(|b| b.as_host().clone()));
         let false_lookup =
-            buffers.extend_from_iter(if_false.buffers().iter().map(|b| b.as_host().clone()));
+            buffers.extend_from_iter(if_false.data_buffers().iter().map(|b| b.as_host().clone()));
 
         let mut views_builder = BufferMut::<BinaryView>::with_capacity(len);
         let mut validity_builder = LazyBitBufferBuilder::new(len);
 
-        let true_validity = if_true.validity_mask()?;
-        let false_validity = if_false.validity_mask()?;
+        let true_validity = if_true.varbinview_validity_mask();
+        let false_validity = if_false.varbinview_validity_mask();
 
+        let mask = mask.try_to_mask_fill_null_false(ctx)?;
+        let if_false_view = if_false;
         match mask.slices() {
             AllOr::All => push_range(
                 if_true,
@@ -65,7 +69,7 @@ impl ZipKernel for VarBinViewVTable {
                 &mut validity_builder,
             ),
             AllOr::None => push_range(
-                if_false,
+                if_false_view,
                 &false_lookup,
                 &false_validity,
                 0..len,
@@ -77,7 +81,7 @@ impl ZipKernel for VarBinViewVTable {
                 for (start, end) in slices {
                     if pos < *start {
                         push_range(
-                            if_false,
+                            if_false_view,
                             &false_lookup,
                             &false_validity,
                             pos..*start,
@@ -97,7 +101,7 @@ impl ZipKernel for VarBinViewVTable {
                 }
                 if pos < len {
                     push_range(
-                        if_false,
+                        if_false_view,
                         &false_lookup,
                         &false_validity,
                         pos..len,
@@ -121,12 +125,12 @@ impl ZipKernel for VarBinViewVTable {
             )
         };
 
-        Ok(Some(array.to_array()))
+        Ok(Some(array.into_array()))
     }
 }
 
 fn push_range(
-    array: &VarBinViewArray,
+    array: ArrayView<'_, VarBinView>,
     buffer_lookup: &[u32],
     validity: &Mask,
     range: Range<usize>,
@@ -173,7 +177,6 @@ fn push_range(
     }
 }
 
-#[inline]
 fn push_view(
     view: BinaryView,
     buffer_lookup: &[u32],
@@ -207,11 +210,11 @@ fn push_view(
 mod tests {
     use vortex_mask::Mask;
 
+    use crate::IntoArray;
     use crate::accessor::ArrayAccessor;
     use crate::arrays::VarBinViewArray;
+    use crate::builtins::ArrayBuiltins;
     use crate::canonical::ToCanonical;
-    #[expect(deprecated)]
-    use crate::compute::zip;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
 
@@ -243,8 +246,12 @@ mod tests {
 
         let mask = Mask::from_iter([true, false, true, false, false, true]);
 
-        #[expect(deprecated)]
-        let zipped = zip(a.as_ref(), b.as_ref(), &mask).unwrap().to_varbinview();
+        let zipped = mask
+            .clone()
+            .into_array()
+            .zip(a.into_array(), b.into_array())
+            .unwrap()
+            .to_varbinview();
 
         let values = zipped.with_iterator(|it| {
             it.map(|v| v.map(|bytes| String::from_utf8(bytes.to_vec()).unwrap()))
diff --git a/vortex-array/src/arrays/varbinview/mod.rs b/vortex-array/src/arrays/varbinview/mod.rs
index 977c6b89abd..be82b952f30 100644
--- a/vortex-array/src/arrays/varbinview/mod.rs
+++ b/vortex-array/src/arrays/varbinview/mod.rs
@@ -2,8 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod array;
-pub use array::VarBinViewArray;
-pub use array::VarBinViewArrayParts;
+pub use array::VarBinViewArrayExt;
+pub use array::VarBinViewData;
+pub use array::VarBinViewDataParts;
+pub use vtable::VarBinViewArray;
 
 mod accessor;
 pub(crate) mod compact;
@@ -11,7 +13,7 @@ pub(crate) mod compact;
 pub(crate) mod compute;
 
 mod vtable;
-pub use vtable::VarBinViewVTable;
+pub use vtable::VarBinView;
 
 pub mod build_views;
 
diff --git a/vortex-array/src/arrays/varbinview/tests.rs b/vortex-array/src/arrays/varbinview/tests.rs
index 9c9a975dad5..ab19e33dd59 100644
--- a/vortex-array/src/arrays/varbinview/tests.rs
+++ b/vortex-array/src/arrays/varbinview/tests.rs
@@ -2,8 +2,8 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use crate::ToCanonical;
-use crate::arrays::BinaryView;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::varbinview::BinaryView;
 use crate::assert_arrays_eq;
 
 #[test]
@@ -31,7 +31,7 @@ pub fn slice_array() {
 #[test]
 pub fn flatten_array() {
     let binary_arr = VarBinViewArray::from_iter_str(["string1", "string2"]);
-    let var_bin = binary_arr.to_varbinview();
+    let var_bin = binary_arr.as_array().to_varbinview();
     assert_arrays_eq!(
         var_bin,
         VarBinViewArray::from_iter_str(["string1", "string2"])
diff --git a/vortex-array/src/arrays/varbinview/view.rs b/vortex-array/src/arrays/varbinview/view.rs
index 068fbde6d4e..38cbd2798c6 100644
--- a/vortex-array/src/arrays/varbinview/view.rs
+++ b/vortex-array/src/arrays/varbinview/view.rs
@@ -47,7 +47,6 @@ pub struct Inlined {
 
 impl Inlined {
     /// Creates a new inlined representation from the provided value of constant size.
-    #[inline]
     fn new<const N: usize>(value: &[u8]) -> Self {
         debug_assert_eq!(value.len(), N);
         let mut inlined = Self {
diff --git a/vortex-array/src/arrays/varbinview/vtable/array.rs b/vortex-array/src/arrays/varbinview/vtable/array.rs
deleted file mode 100644
index e9d99e9a3e0..00000000000
--- a/vortex-array/src/arrays/varbinview/vtable/array.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-
-use crate::Precision;
-use crate::arrays::BinaryView;
-use crate::arrays::varbinview::VarBinViewArray;
-use crate::arrays::varbinview::VarBinViewVTable;
-use crate::dtype::DType;
-use crate::hash::ArrayEq;
-use crate::hash::ArrayHash;
-use crate::stats::StatsSetRef;
-use crate::vtable::BaseArrayVTable;
-
-impl BaseArrayVTable<VarBinViewVTable> for VarBinViewVTable {
-    fn len(array: &VarBinViewArray) -> usize {
-        array.views_handle().len() / size_of::<BinaryView>()
-    }
-
-    fn dtype(array: &VarBinViewArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &VarBinViewArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(
-        array: &VarBinViewArray,
-        state: &mut H,
-        precision: Precision,
-    ) {
-        array.dtype.hash(state);
-        for buffer in array.buffers.iter() {
-            buffer.array_hash(state, precision);
-        }
-        array.views.array_hash(state, precision);
-        array.validity.array_hash(state, precision);
-    }
-
-    fn array_eq(array: &VarBinViewArray, other: &VarBinViewArray, precision: Precision) -> bool {
-        array.dtype == other.dtype
-            && array.buffers.len() == other.buffers.len()
-            && array
-                .buffers
-                .iter()
-                .zip(other.buffers.iter())
-                .all(|(a, b)| a.array_eq(b, precision))
-            && array.views.array_eq(&other.views, precision)
-            && array.validity.array_eq(&other.validity, precision)
-    }
-}
diff --git a/vortex-array/src/arrays/varbinview/vtable/kernel.rs b/vortex-array/src/arrays/varbinview/vtable/kernel.rs
index d3d1286ca7f..8486f0959f7 100644
--- a/vortex-array/src/arrays/varbinview/vtable/kernel.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/kernel.rs
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::TakeExecuteAdaptor;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::VarBinView;
+use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<VarBinViewVTable> = ParentKernelSet::new(&[
-    ParentKernelSet::lift(&TakeExecuteAdaptor(VarBinViewVTable)),
-    ParentKernelSet::lift(&ZipExecuteAdaptor(VarBinViewVTable)),
+pub(super) const PARENT_KERNELS: ParentKernelSet<VarBinView> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&TakeExecuteAdaptor(VarBinView)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(VarBinView)),
 ]);
diff --git a/vortex-array/src/arrays/varbinview/vtable/mod.rs b/vortex-array/src/arrays/varbinview/vtable/mod.rs
index c9269798143..453cd7b61d4 100644
--- a/vortex-array/src/arrays/varbinview/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/mod.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::hash::Hasher;
 use std::mem::size_of;
 use std::sync::Arc;
 
@@ -8,78 +9,148 @@ use kernel::PARENT_KERNELS;
 use vortex_buffer::Buffer;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
-use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::arrays::BinaryView;
-use crate::arrays::varbinview::VarBinViewArray;
+use crate::ExecutionResult;
+use crate::Precision;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::varbinview::BinaryView;
+use crate::arrays::varbinview::VarBinViewData;
+use crate::arrays::varbinview::array::NUM_SLOTS;
+use crate::arrays::varbinview::array::SLOT_NAMES;
 use crate::arrays::varbinview::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
+use crate::hash::ArrayEq;
+use crate::hash::ArrayHash;
 use crate::serde::ArrayChildren;
 use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTableFromValidityHelper;
-
-mod array;
 mod kernel;
 mod operations;
 mod validity;
-mod visitor;
-
-vtable!(VarBinView);
+/// A [`VarBinView`]-encoded Vortex array.
+pub type VarBinViewArray = Array<VarBinView>;
 
-#[derive(Debug)]
-pub struct VarBinViewVTable;
+#[derive(Clone, Debug)]
+pub struct VarBinView;
 
-impl VarBinViewVTable {
+impl VarBinView {
     pub const ID: ArrayId = ArrayId::new_ref("vortex.varbinview");
 }
 
-impl VTable for VarBinViewVTable {
-    type Array = VarBinViewArray;
+impl ArrayHash for VarBinViewData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+        for buffer in self.buffers.iter() {
+            buffer.array_hash(state, precision);
+        }
+        self.views.array_hash(state, precision);
+    }
+}
+
+impl ArrayEq for VarBinViewData {
+    fn array_eq(&self, other: &Self, precision: Precision) -> 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)
+    }
+}
 
-    type Metadata = EmptyMetadata;
+impl VTable for VarBinView {
+    type ArrayData = VarBinViewData;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
-    type ValidityVTable = ValidityVTableFromValidityHelper;
-    type VisitorVTable = Self;
+    type ValidityVTable = Self;
 
-    fn id(_array: &Self::Array) -> ArrayId {
+    fn id(&self) -> ArrayId {
         Self::ID
     }
 
-    fn metadata(_array: &VarBinViewArray) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    fn nbuffers(array: ArrayView<'_, Self>) -> usize {
+        array.data_buffers().len() + 1
     }
 
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
+    fn validate(
+        &self,
+        data: &VarBinViewData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == NUM_SLOTS,
+            "VarBinViewArray expected {NUM_SLOTS} slots, found {}",
+            slots.len()
+        );
+        vortex_ensure!(
+            data.len() == len,
+            "VarBinViewArray length {} does not match outer length {}",
+            data.len(),
+            len
+        );
+        vortex_ensure!(
+            matches!(dtype, DType::Binary(_) | DType::Utf8(_)),
+            "VarBinViewArray dtype must be binary or utf8, got {dtype}"
+        );
+        Ok(())
     }
 
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
+    fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        let ndata = array.data_buffers().len();
+        if idx < ndata {
+            array.data_buffers()[idx].clone()
+        } else if idx == ndata {
+            array.views_handle().clone()
+        } else {
+            vortex_panic!("VarBinViewArray buffer index {idx} out of bounds")
+        }
+    }
+
+    fn buffer_name(array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
+        let ndata = array.data_buffers().len();
+        if idx < ndata {
+            Some(format!("buffer_{idx}"))
+        } else if idx == ndata {
+            Some("views".to_string())
+        } else {
+            vortex_panic!("VarBinViewArray buffer_name index {idx} out of bounds")
+        }
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
         _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
     }
 
-    fn build(
+    fn deserialize(
+        &self,
         dtype: &DType,
         len: usize,
-        _metadata: &Self::Metadata,
+        metadata: &[u8],
+
         buffers: &[BufferHandle],
         children: &dyn ArrayChildren,
-    ) -> VortexResult<VarBinViewArray> {
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        if !metadata.is_empty() {
+            vortex_bail!(
+                "VarBinViewArray expects empty metadata, got {} bytes",
+                metadata.len()
+            );
+        }
         let Some((views_handle, data_handles)) = buffers.split_last() else {
             vortex_bail!("Expected at least 1 buffer, got 0");
         };
@@ -107,11 +178,16 @@ impl VTable for VarBinViewVTable {
 
         // If any buffer is on device, skip host validation and use try_new_handle.
         if buffers.iter().any(|b| b.is_on_device()) {
-            return VarBinViewArray::try_new_handle(
+            let data = VarBinViewData::try_new_handle(
                 views_handle.clone(),
                 Arc::from(data_handles.to_vec()),
                 dtype.clone(),
-                validity,
+                validity.clone(),
+            )?;
+            let slots = VarBinViewData::make_slots(&validity, len);
+            return Ok(
+                crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data)
+                    .with_slots(slots),
             );
         }
 
@@ -121,28 +197,22 @@ impl VTable for VarBinViewVTable {
             .collect::<Vec<_>>();
         let views = Buffer::<BinaryView>::from_byte_buffer(views_handle.clone().as_host().clone());
 
-        VarBinViewArray::try_new(views, Arc::from(data_buffers), dtype.clone(), validity)
+        let data = VarBinViewData::try_new(
+            views,
+            Arc::from(data_buffers),
+            dtype.clone(),
+            validity.clone(),
+        )?;
+        let slots = VarBinViewData::make_slots(&validity, len);
+        Ok(crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        match children.len() {
-            0 => {}
-            1 => {
-                let [validity]: [ArrayRef; 1] = children
-                    .try_into()
-                    .map_err(|_| vortex_err!("Failed to convert children to array"))?;
-                array.validity = Validity::Array(validity);
-            }
-            _ => vortex_bail!(
-                "VarBinViewArray expects 0 or 1 children (validity?), got {}",
-                children.len()
-            ),
-        }
-        Ok(())
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        SLOT_NAMES[idx].to_string()
     }
 
     fn reduce_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -150,7 +220,7 @@ impl VTable for VarBinViewVTable {
     }
 
     fn execute_parent(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -158,7 +228,57 @@ impl VTable for VarBinViewVTable {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        Ok(array.to_array())
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::ByteBufferMut;
+    use vortex_session::registry::ReadContext;
+
+    use super::*;
+    use crate::ArrayContext;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::assert_arrays_eq;
+    use crate::serde::SerializeOptions;
+    use crate::serde::SerializedArray;
+
+    #[test]
+    fn test_nullable_varbinview_serde_roundtrip() {
+        let array = VarBinViewArray::from_iter_nullable_str([
+            Some("hello"),
+            None,
+            Some("world"),
+            None,
+            Some("a moderately long string for testing"),
+        ]);
+        let dtype = array.dtype().clone();
+        let len = array.len();
+
+        let ctx = ArrayContext::empty();
+        let serialized = array
+            .clone()
+            .into_array()
+            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .unwrap();
+
+        let mut concat = ByteBufferMut::empty();
+        for buf in serialized {
+            concat.extend_from_slice(buf.as_ref());
+        }
+        let parts = SerializedArray::try_from(concat.freeze()).unwrap();
+        let decoded = parts
+            .decode(
+                &dtype,
+                len,
+                &ReadContext::new(ctx.to_ids()),
+                &LEGACY_SESSION,
+            )
+            .unwrap();
+
+        assert_arrays_eq!(decoded, array);
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/vtable/operations.rs b/vortex-array/src/arrays/varbinview/vtable/operations.rs
index e0c309021b0..1a1f20a0dbe 100644
--- a/vortex-array/src/arrays/varbinview/vtable/operations.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/operations.rs
@@ -3,14 +3,19 @@
 
 use vortex_error::VortexResult;
 
-use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
-use crate::arrays::varbin_scalar;
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::VarBinView;
+use crate::arrays::varbin::varbin_scalar;
 use crate::scalar::Scalar;
-use crate::vtable::OperationsVTable;
 
-impl OperationsVTable<VarBinViewVTable> for VarBinViewVTable {
-    fn scalar_at(array: &VarBinViewArray, index: usize) -> VortexResult<Scalar> {
+impl OperationsVTable<VarBinView> for VarBinView {
+    fn scalar_at(
+        array: ArrayView<'_, VarBinView>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         Ok(varbin_scalar(array.bytes_at(index), array.dtype()))
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/vtable/validity.rs b/vortex-array/src/arrays/varbinview/vtable/validity.rs
index f15dd2f8696..f9dfbf64def 100644
--- a/vortex-array/src/arrays/varbinview/vtable/validity.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/validity.rs
@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::arrays::varbinview::VarBinViewArray;
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::varbinview::VarBinViewArrayExt;
+use crate::arrays::varbinview::vtable::VarBinView;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
-impl ValidityHelper for VarBinViewArray {
-    fn validity(&self) -> &Validity {
-        &self.validity
+impl ValidityVTable<VarBinView> for VarBinView {
+    fn validity(array: ArrayView<'_, VarBinView>) -> VortexResult<Validity> {
+        Ok(array.varbinview_validity())
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/vtable/visitor.rs b/vortex-array/src/arrays/varbinview/vtable/visitor.rs
deleted file mode 100644
index 7c82067436d..00000000000
--- a/vortex-array/src/arrays/varbinview/vtable/visitor.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use super::VarBinViewVTable;
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::arrays::VarBinViewArray;
-use crate::vtable::ValidityHelper;
-use crate::vtable::VisitorVTable;
-use crate::vtable::validity_nchildren;
-use crate::vtable::validity_to_child;
-
-impl VisitorVTable<VarBinViewVTable> for VarBinViewVTable {
-    fn visit_buffers(array: &VarBinViewArray, visitor: &mut dyn ArrayBufferVisitor) {
-        for (i, buffer) in array.buffers().iter().enumerate() {
-            visitor.visit_buffer_handle(&format!("buffer_{i}"), buffer);
-        }
-        visitor.visit_buffer_handle("views", array.views_handle());
-    }
-
-    fn nbuffers(array: &VarBinViewArray) -> usize {
-        array.buffers().len() + 1
-    }
-
-    fn visit_children(array: &VarBinViewArray, visitor: &mut dyn ArrayChildVisitor) {
-        visitor.visit_validity(array.validity(), array.len())
-    }
-
-    fn nchildren(array: &VarBinViewArray) -> usize {
-        validity_nchildren(array.validity())
-    }
-
-    fn nth_child(array: &VarBinViewArray, idx: usize) -> Option<ArrayRef> {
-        match idx {
-            0 => validity_to_child(array.validity(), array.len()),
-            _ => None,
-        }
-    }
-}
diff --git a/vortex-array/src/arrays/variant/mod.rs b/vortex-array/src/arrays/variant/mod.rs
new file mode 100644
index 00000000000..06b8a8437a8
--- /dev/null
+++ b/vortex-array/src/arrays/variant/mod.rs
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod vtable;
+
+use vortex_error::VortexExpect;
+
+pub use self::vtable::Variant;
+pub use self::vtable::VariantArray;
+use crate::ArrayRef;
+use crate::array::Array;
+use crate::array::ArrayParts;
+use crate::array::EmptyArrayData;
+use crate::array::TypedArrayRef;
+use crate::dtype::DType;
+
+pub(super) const NUM_SLOTS: usize = 1;
+pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["child"];
+
+pub trait VariantArrayExt: TypedArrayRef<Variant> {
+    fn child(&self) -> &ArrayRef {
+        self.as_ref().slots()[0]
+            .as_ref()
+            .vortex_expect("validated variant child slot")
+    }
+}
+impl<T: TypedArrayRef<Variant>> VariantArrayExt for T {}
+
+impl Array<Variant> {
+    /// Creates a new `VariantArray`.
+    pub fn new(child: ArrayRef) -> Self {
+        let dtype = DType::Variant(child.dtype().nullability());
+        let len = child.len();
+        let stats = child.statistics().to_owned();
+        unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Variant, dtype, len, EmptyArrayData).with_slots(vec![Some(child)]),
+            )
+        }
+        .with_stats_set(stats)
+    }
+}
diff --git a/vortex-array/src/arrays/variant/vtable/mod.rs b/vortex-array/src/arrays/variant/vtable/mod.rs
new file mode 100644
index 00000000000..2fdf200b98f
--- /dev/null
+++ b/vortex-array/src/arrays/variant/vtable/mod.rs
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod operations;
+mod validity;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::ExecutionResult;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayView;
+use crate::array::EmptyArrayData;
+use crate::array::VTable;
+use crate::arrays::variant::SLOT_NAMES;
+use crate::buffer::BufferHandle;
+use crate::dtype::DType;
+use crate::serde::ArrayChildren;
+
+/// A [`Variant`]-encoded Vortex array.
+pub type VariantArray = Array<Variant>;
+
+#[derive(Clone, Debug)]
+pub struct Variant;
+
+impl Variant {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.variant");
+}
+
+impl VTable for Variant {
+    type ArrayData = EmptyArrayData;
+
+    type OperationsVTable = Self;
+
+    type ValidityVTable = Self;
+
+    fn id(&self) -> ArrayId {
+        Self::ID
+    }
+
+    fn validate(
+        &self,
+        _data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots[0].is_some(),
+            "VariantArray child slot must be present"
+        );
+        let child = slots[0]
+            .as_ref()
+            .vortex_expect("validated child slot presence");
+        vortex_ensure!(
+            matches!(dtype, DType::Variant(_)),
+            "Expected Variant DType, got {dtype}"
+        );
+        vortex_ensure!(
+            child.dtype() == dtype,
+            "VariantArray child dtype {} does not match outer dtype {}",
+            child.dtype(),
+            dtype
+        );
+        vortex_ensure!(
+            child.len() == len,
+            "VariantArray length {} does not match outer length {}",
+            child.len(),
+            len
+        );
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("VariantArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+
+        _buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<crate::array::ArrayParts<Self>> {
+        vortex_ensure!(
+            metadata.is_empty(),
+            "VariantArray expects empty metadata, got {} bytes",
+            metadata.len()
+        );
+        vortex_ensure!(matches!(dtype, DType::Variant(_)), "Expected Variant DType");
+        vortex_ensure!(
+            children.len() == 1,
+            "Expected 1 child, got {}",
+            children.len()
+        );
+        // The child carries the nullability for the whole VariantArray.
+        let child = children.get(0, dtype, len)?;
+        Ok(
+            crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, EmptyArrayData)
+                .with_slots(vec![Some(child)]),
+        )
+    }
+
+    fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        match SLOT_NAMES.get(idx) {
+            Some(name) => (*name).to_string(),
+            None => vortex_panic!("VariantArray slot_name index {idx} out of bounds"),
+        }
+    }
+
+    fn execute(array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array))
+    }
+}
+
+#[cfg(test)]
+mod tests {}
diff --git a/vortex-array/src/arrays/variant/vtable/operations.rs b/vortex-array/src/arrays/variant/vtable/operations.rs
new file mode 100644
index 00000000000..fb6fc0eb499
--- /dev/null
+++ b/vortex-array/src/arrays/variant/vtable/operations.rs
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::arrays::Variant;
+use crate::arrays::variant::VariantArrayExt;
+use crate::scalar::Scalar;
+
+impl OperationsVTable<Variant> for Variant {
+    fn scalar_at(
+        array: ArrayView<'_, Variant>,
+        index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        array.child().scalar_at(index)
+    }
+}
diff --git a/vortex-array/src/arrays/variant/vtable/validity.rs b/vortex-array/src/arrays/variant/vtable/validity.rs
new file mode 100644
index 00000000000..42237c81977
--- /dev/null
+++ b/vortex-array/src/arrays/variant/vtable/validity.rs
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+
+use crate::array::ArrayView;
+use crate::array::ValidityVTable;
+use crate::arrays::Variant;
+use crate::arrays::variant::VariantArrayExt;
+use crate::validity::Validity;
+
+impl ValidityVTable<Variant> for Variant {
+    fn validity(array: ArrayView<'_, Variant>) -> VortexResult<Validity> {
+        array.child().validity()
+    }
+}
diff --git a/vortex-array/src/arrow/array.rs b/vortex-array/src/arrow/array.rs
deleted file mode 100644
index 20af04195fc..00000000000
--- a/vortex-array/src/arrow/array.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Debug;
-use std::hash::Hash;
-
-use arrow_array::ArrayRef as ArrowArrayRef;
-use vortex_buffer::BitBuffer;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_ensure;
-use vortex_session::VortexSession;
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayRef;
-use crate::EmptyMetadata;
-use crate::ExecutionCtx;
-use crate::IntoArray;
-use crate::Precision;
-use crate::arrays::BoolArray;
-use crate::arrow::FromArrowArray;
-use crate::buffer::BufferHandle;
-use crate::dtype::DType;
-use crate::dtype::Nullability;
-use crate::dtype::arrow::FromArrowType;
-use crate::scalar::Scalar;
-use crate::serde::ArrayChildren;
-use crate::stats::ArrayStats;
-use crate::stats::StatsSetRef;
-use crate::validity::Validity;
-use crate::vtable;
-use crate::vtable::ArrayId;
-use crate::vtable::BaseArrayVTable;
-use crate::vtable::OperationsVTable;
-use crate::vtable::VTable;
-use crate::vtable::ValidityVTable;
-use crate::vtable::VisitorVTable;
-
-vtable!(Arrow);
-
-impl VTable for ArrowVTable {
-    type Array = ArrowArray;
-
-    type Metadata = EmptyMetadata;
-
-    type ArrayVTable = Self;
-    type OperationsVTable = Self;
-    type ValidityVTable = Self;
-    type VisitorVTable = Self;
-
-    fn id(_array: &Self::Array) -> ArrayId {
-        ArrowVTable::ID
-    }
-
-    fn metadata(_array: &Self::Array) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
-    }
-
-    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(None)
-    }
-
-    fn deserialize(
-        _bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(EmptyMetadata)
-    }
-
-    fn build(
-        _dtype: &DType,
-        _len: usize,
-        _metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
-        _children: &dyn ArrayChildren,
-    ) -> VortexResult<Self::Array> {
-        vortex_bail!("ArrowArray cannot be deserialized")
-    }
-
-    fn with_children(_array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.is_empty(),
-            "ArrowArray has no children, got {}",
-            children.len()
-        );
-        Ok(())
-    }
-
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        ArrayRef::from_arrow(array.inner.as_ref(), array.dtype.is_nullable())
-    }
-}
-
-/// A Vortex array that wraps an in-memory Arrow array.
-// TODO(ngates): consider having each Arrow encoding be a separate encoding ID.
-#[derive(Debug)]
-pub struct ArrowVTable;
-
-impl ArrowVTable {
-    pub const ID: ArrayId = ArrayId::new_ref("vortex.arrow");
-}
-
-#[derive(Clone, Debug)]
-pub struct ArrowArray {
-    inner: ArrowArrayRef,
-    dtype: DType,
-    stats_set: ArrayStats,
-}
-
-impl ArrowArray {
-    pub fn new(arrow_array: ArrowArrayRef, nullability: Nullability) -> Self {
-        let dtype = DType::from_arrow((arrow_array.data_type(), nullability));
-        Self {
-            inner: arrow_array,
-            dtype,
-            stats_set: Default::default(),
-        }
-    }
-
-    pub fn inner(&self) -> &ArrowArrayRef {
-        &self.inner
-    }
-}
-
-impl BaseArrayVTable<ArrowVTable> for ArrowVTable {
-    fn len(array: &ArrowArray) -> usize {
-        array.inner.len()
-    }
-
-    fn dtype(array: &ArrowArray) -> &DType {
-        &array.dtype
-    }
-
-    fn stats(array: &ArrowArray) -> StatsSetRef<'_> {
-        array.stats_set.to_ref(array.as_ref())
-    }
-
-    fn array_hash<H: std::hash::Hasher>(array: &ArrowArray, state: &mut H, _precision: Precision) {
-        array.dtype.hash(state);
-        // Hash based on pointer to the inner Arrow array since Arrow doesn't support hashing.
-        std::sync::Arc::as_ptr(&array.inner).hash(state);
-    }
-
-    fn array_eq(array: &ArrowArray, other: &ArrowArray, _precision: Precision) -> bool {
-        array.dtype == other.dtype && std::sync::Arc::ptr_eq(&array.inner, &other.inner)
-    }
-}
-
-impl OperationsVTable<ArrowVTable> for ArrowVTable {
-    fn scalar_at(_array: &ArrowArray, _index: usize) -> VortexResult<Scalar> {
-        vortex_bail!("ArrowArray does not support scalar_at")
-    }
-}
-
-impl ValidityVTable<ArrowVTable> for ArrowVTable {
-    fn validity(array: &ArrowArray) -> VortexResult<Validity> {
-        Ok(match array.inner.logical_nulls() {
-            None => Validity::AllValid,
-            Some(null_buffer) => match null_buffer.null_count() {
-                0 => Validity::AllValid,
-                n if n == array.inner.len() => Validity::AllInvalid,
-                _ => Validity::Array(
-                    BoolArray::new(
-                        BitBuffer::from(null_buffer.inner().clone()),
-                        Validity::NonNullable,
-                    )
-                    .into_array(),
-                ),
-            },
-        })
-    }
-}
-
-impl VisitorVTable<ArrowVTable> for ArrowVTable {
-    fn visit_buffers(_array: &ArrowArray, _visitor: &mut dyn ArrayBufferVisitor) {}
-
-    fn visit_children(_array: &ArrowArray, _visitor: &mut dyn ArrayChildVisitor) {}
-
-    fn nchildren(_array: &ArrowArray) -> usize {
-        0
-    }
-
-    fn nth_child(_array: &ArrowArray, _idx: usize) -> Option<ArrayRef> {
-        None
-    }
-}
diff --git a/vortex-array/src/arrow/compute/to_arrow/mod.rs b/vortex-array/src/arrow/compute/to_arrow/mod.rs
deleted file mode 100644
index cd955f43060..00000000000
--- a/vortex-array/src/arrow/compute/to_arrow/mod.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::Any;
-
-use arrow_array::ArrayRef as ArrowArrayRef;
-use arrow_schema::DataType;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-use crate::Array;
-use crate::LEGACY_SESSION;
-use crate::VortexSessionExecute;
-use crate::arrow::ArrowArrayExecutor;
-use crate::compute::Options;
-
-/// Convert a Vortex array to an Arrow array with the encoding's preferred `DataType`.
-///
-/// For example, a `VarBinArray` will be converted to an Arrow `VarBin` array, instead of the
-/// canonical `VarBinViewArray`.
-///
-/// Warning: do not use this to convert a Vortex [`crate::stream::ArrayStream`] since each array
-/// may have a different preferred Arrow type. Use [`to_arrow`] instead.
-#[deprecated(note = "Use ArrowArrayExecutor::execute_arrow instead")]
-#[expect(deprecated)]
-pub fn to_arrow_preferred(array: &dyn Array) -> VortexResult<ArrowArrayRef> {
-    to_arrow_opts(array, &ToArrowOptions { arrow_type: None })
-}
-
-/// Convert a Vortex array to an Arrow array of the given type.
-#[deprecated(note = "Use ArrowArrayExecutor::execute_arrow instead")]
-pub fn to_arrow(array: &dyn Array, arrow_type: &DataType) -> VortexResult<ArrowArrayRef> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
-    array.to_array().execute_arrow(Some(arrow_type), &mut ctx)
-}
-
-#[deprecated(note = "Use ArrowArrayExecutor::execute_arrow instead")]
-#[expect(deprecated)]
-pub fn to_arrow_opts(array: &dyn Array, options: &ToArrowOptions) -> VortexResult<ArrowArrayRef> {
-    let data_type = if let Some(data_type) = &options.arrow_type {
-        data_type.clone()
-    } else {
-        array.dtype().to_arrow_dtype()?
-    };
-    let arrow = to_arrow(array, &data_type)?;
-
-    vortex_ensure!(
-        &data_type == arrow.data_type(),
-        "to arrow returned array with data_type {}, expected {}",
-        arrow.data_type(),
-        data_type
-    );
-
-    Ok(arrow)
-}
-
-pub struct ToArrowOptions {
-    /// The Arrow data type to convert to, if specified.
-    pub arrow_type: Option<DataType>,
-}
-
-impl Options for ToArrowOptions {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
diff --git a/vortex-array/src/arrow/convert.rs b/vortex-array/src/arrow/convert.rs
index 2de9b58aca8..da44e16a1b2 100644
--- a/vortex-array/src/arrow/convert.rs
+++ b/vortex-array/src/arrow/convert.rs
@@ -276,12 +276,15 @@ where
             DataType::Utf8 | DataType::LargeUtf8 => DType::Utf8(nullable.into()),
             dt => vortex_panic!("Invalid data type for ByteArray: {dt}"),
         };
-        Ok(VarBinArray::try_new(
-            value.offsets().clone().into_array(),
-            ByteBuffer::from_arrow_buffer(value.values().clone(), Alignment::of::<u8>()),
-            dtype,
-            nulls(value.nulls(), nullable),
-        )?
+        // SAFETY: Arrow arrays are already validated (valid UTF-8, valid offsets, correct validity).
+        Ok(unsafe {
+            VarBinArray::new_unchecked(
+                value.offsets().clone().into_array(),
+                ByteBuffer::from_arrow_buffer(value.values().clone(), Alignment::of::<u8>()),
+                dtype,
+                nulls(value.nulls(), nullable),
+            )
+        }
         .into_array())
     }
 }
@@ -695,16 +698,20 @@ mod tests {
     use crate::ArrayRef;
     use crate::IntoArray;
     use crate::VortexSessionExecute;
-    use crate::arrays::DecimalVTable;
-    use crate::arrays::FixedSizeListVTable;
-    use crate::arrays::ListVTable;
-    use crate::arrays::ListViewVTable;
-    use crate::arrays::PrimitiveVTable;
-    use crate::arrays::StructVTable;
-    use crate::arrays::TemporalArray;
-    use crate::arrays::VarBinVTable;
-    use crate::arrays::VarBinViewVTable;
+    use crate::arrays::Decimal;
+    use crate::arrays::FixedSizeList;
+    use crate::arrays::List;
+    use crate::arrays::ListView;
+    use crate::arrays::Primitive;
+    use crate::arrays::Struct;
+    use crate::arrays::VarBin;
+    use crate::arrays::VarBinView;
+    use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+    use crate::arrays::list::ListArrayExt;
+    use crate::arrays::listview::ListViewArrayExt;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::arrow::FromArrowArray as _;
+    use crate::arrow::convert::TemporalArray;
     use crate::arrow::executor::ArrowArrayExecutor as _;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -725,10 +732,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with I8 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::I8);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::I8);
     }
 
@@ -744,10 +751,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with I16 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::I16);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::I16);
     }
 
@@ -763,10 +770,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with I32 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::I32);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::I32);
     }
 
@@ -782,10 +789,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with I64 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::I64);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::I64);
     }
 
@@ -801,10 +808,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with U8 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::U8);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::U8);
     }
 
@@ -820,10 +827,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with U16 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::U16);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::U16);
     }
 
@@ -839,10 +846,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with U32 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::U32);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::U32);
     }
 
@@ -858,10 +865,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with U64 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::U64);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::U64);
     }
 
@@ -887,10 +894,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 2);
 
         // Verify metadata - should be PrimitiveArray with F16 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::F16);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::F16);
     }
 
@@ -906,10 +913,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with F32 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::F32);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::F32);
     }
 
@@ -925,10 +932,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be PrimitiveArray with F64 ptype
-        let primitive_array = vortex_array.as_::<PrimitiveVTable>();
+        let primitive_array = vortex_array.as_::<Primitive>();
         assert_eq!(primitive_array.ptype(), PType::F64);
 
-        let primitive_array_non_null = vortex_array_non_null.as_::<PrimitiveVTable>();
+        let primitive_array_non_null = vortex_array_non_null.as_::<Primitive>();
         assert_eq!(primitive_array_non_null.ptype(), PType::F64);
     }
 
@@ -958,11 +965,11 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 3);
 
         // Verify metadata - should be DecimalArray with correct precision and scale
-        let decimal_vortex_array = vortex_array.as_::<DecimalVTable>();
+        let decimal_vortex_array = vortex_array.as_::<Decimal>();
         assert_eq!(decimal_vortex_array.decimal_dtype().precision(), 10);
         assert_eq!(decimal_vortex_array.decimal_dtype().scale(), 2);
 
-        let decimal_vortex_array_non_null = vortex_array_non_null.as_::<DecimalVTable>();
+        let decimal_vortex_array_non_null = vortex_array_non_null.as_::<Decimal>();
         assert_eq!(
             decimal_vortex_array_non_null.decimal_dtype().precision(),
             10
@@ -995,11 +1002,11 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 3);
 
         // Verify metadata - should be DecimalArray with correct precision and scale
-        let decimal_vortex_array = vortex_array.as_::<DecimalVTable>();
+        let decimal_vortex_array = vortex_array.as_::<Decimal>();
         assert_eq!(decimal_vortex_array.decimal_dtype().precision(), 38);
         assert_eq!(decimal_vortex_array.decimal_dtype().scale(), 10);
 
-        let decimal_vortex_array_non_null = vortex_array_non_null.as_::<DecimalVTable>();
+        let decimal_vortex_array_non_null = vortex_array_non_null.as_::<Decimal>();
         assert_eq!(
             decimal_vortex_array_non_null.decimal_dtype().precision(),
             38
@@ -1021,14 +1028,13 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be TemporalArray with Second time unit
-        let temporal_array = TemporalArray::try_from(vortex_array.clone()).unwrap();
+        let temporal_array = TemporalArray::try_from(vortex_array).unwrap();
         assert_eq!(
             temporal_array.temporal_metadata().time_unit(),
             TimeUnit::Seconds
         );
 
-        let temporal_array_non_null =
-            TemporalArray::try_from(vortex_array_non_null.clone()).unwrap();
+        let temporal_array_non_null = TemporalArray::try_from(vortex_array_non_null).unwrap();
         assert_eq!(
             temporal_array_non_null.temporal_metadata().time_unit(),
             TimeUnit::Seconds
@@ -1125,14 +1131,13 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be TemporalArray with Second time unit
-        let temporal_array = TemporalArray::try_from(vortex_array.clone()).unwrap();
+        let temporal_array = TemporalArray::try_from(vortex_array).unwrap();
         assert_eq!(
             temporal_array.temporal_metadata().time_unit(),
             TimeUnit::Seconds
         );
 
-        let temporal_array_non_null =
-            TemporalArray::try_from(vortex_array_non_null.clone()).unwrap();
+        let temporal_array_non_null = TemporalArray::try_from(vortex_array_non_null).unwrap();
         assert_eq!(
             temporal_array_non_null.temporal_metadata().time_unit(),
             TimeUnit::Seconds
@@ -1225,10 +1230,10 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be VarBinArray with Utf8 dtype
-        let varbin_array = vortex_array.as_::<VarBinVTable>();
+        let varbin_array = vortex_array.as_::<VarBin>();
         assert_eq!(varbin_array.dtype(), &DType::Utf8(true.into()));
 
-        let varbin_array_non_null = vortex_array_non_null.as_::<VarBinVTable>();
+        let varbin_array_non_null = vortex_array_non_null.as_::<VarBin>();
         assert_eq!(varbin_array_non_null.dtype(), &DType::Utf8(false.into()));
     }
 
@@ -1311,16 +1316,16 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be VarBinViewArray with correct buffer count and dtype
-        let varbin_view_array = vortex_array.as_::<VarBinViewVTable>();
+        let varbin_view_array = vortex_array.as_::<VarBinView>();
         assert_eq!(
-            varbin_view_array.buffers().len(),
+            varbin_view_array.data_buffers().len(),
             arrow_array.data_buffers().len()
         );
         assert_eq!(varbin_view_array.dtype(), &DType::Utf8(true.into()));
 
-        let varbin_view_array_non_null = vortex_array_non_null.as_::<VarBinViewVTable>();
+        let varbin_view_array_non_null = vortex_array_non_null.as_::<VarBinView>();
         assert_eq!(
-            varbin_view_array_non_null.buffers().len(),
+            varbin_view_array_non_null.data_buffers().len(),
             arrow_array_non_null.data_buffers().len()
         );
         assert_eq!(
@@ -1351,16 +1356,16 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 4);
 
         // Verify metadata - should be VarBinViewArray with correct buffer count and dtype
-        let varbin_view_array = vortex_array.as_::<VarBinViewVTable>();
+        let varbin_view_array = vortex_array.as_::<VarBinView>();
         assert_eq!(
-            varbin_view_array.buffers().len(),
+            varbin_view_array.data_buffers().len(),
             arrow_array.data_buffers().len()
         );
         assert_eq!(varbin_view_array.dtype(), &DType::Binary(true.into()));
 
-        let varbin_view_array_non_null = vortex_array_non_null.as_::<VarBinViewVTable>();
+        let varbin_view_array_non_null = vortex_array_non_null.as_::<VarBinView>();
         assert_eq!(
-            varbin_view_array_non_null.buffers().len(),
+            varbin_view_array_non_null.data_buffers().len(),
             arrow_array_non_null.data_buffers().len()
         );
         assert_eq!(
@@ -1404,7 +1409,7 @@ mod tests {
         assert_eq!(vortex_array.len(), 3);
 
         // Verify metadata - should be StructArray with correct field names
-        let struct_vortex_array = vortex_array.as_::<StructVTable>();
+        let struct_vortex_array = vortex_array.as_::<Struct>();
         assert_eq!(struct_vortex_array.names().len(), 2);
         assert_eq!(struct_vortex_array.names()[0], "field1");
         assert_eq!(struct_vortex_array.names()[1], "field2");
@@ -1425,7 +1430,7 @@ mod tests {
         assert_eq!(vortex_nullable_array.len(), 3);
 
         // Verify metadata for nullable struct
-        let struct_vortex_nullable_array = vortex_nullable_array.as_::<StructVTable>();
+        let struct_vortex_nullable_array = vortex_nullable_array.as_::<Struct>();
         assert_eq!(struct_vortex_nullable_array.names().len(), 2);
         assert_eq!(struct_vortex_nullable_array.names()[0], "field1");
         assert_eq!(struct_vortex_nullable_array.names()[1], "field2");
@@ -1444,8 +1449,8 @@ mod tests {
         assert_eq!(vortex_array.len(), 3);
 
         // Verify metadata - should be ListArray with correct offsets
-        let list_vortex_array = vortex_array.as_::<ListVTable>();
-        let offsets_array = list_vortex_array.offsets().as_::<PrimitiveVTable>();
+        let list_vortex_array = vortex_array.as_::<List>();
+        let offsets_array = list_vortex_array.offsets().as_::<Primitive>();
         assert_eq!(offsets_array.len(), 4); // n+1 offsets for n lists
         assert_eq!(offsets_array.ptype(), PType::I32);
 
@@ -1459,10 +1464,8 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 2);
 
         // Verify metadata for non-nullable list
-        let list_vortex_array_non_null = vortex_array_non_null.as_::<ListVTable>();
-        let offsets_array_non_null = list_vortex_array_non_null
-            .offsets()
-            .as_::<PrimitiveVTable>();
+        let list_vortex_array_non_null = vortex_array_non_null.as_::<List>();
+        let offsets_array_non_null = list_vortex_array_non_null.offsets().as_::<Primitive>();
         assert_eq!(offsets_array_non_null.len(), 3); // n+1 offsets for n lists
         assert_eq!(offsets_array_non_null.ptype(), PType::I32);
     }
@@ -1479,8 +1482,8 @@ mod tests {
         assert_eq!(vortex_array.len(), 3);
 
         // Verify metadata - should be ListArray with correct offsets (I64 for large lists)
-        let list_vortex_array = vortex_array.as_::<ListVTable>();
-        let offsets_array = list_vortex_array.offsets().as_::<PrimitiveVTable>();
+        let list_vortex_array = vortex_array.as_::<List>();
+        let offsets_array = list_vortex_array.offsets().as_::<Primitive>();
         assert_eq!(offsets_array.len(), 4); // n+1 offsets for n lists
         assert_eq!(offsets_array.ptype(), PType::I64); // Large lists use I64 offsets
 
@@ -1494,10 +1497,8 @@ mod tests {
         assert_eq!(vortex_array_non_null.len(), 2);
 
         // Verify metadata for non-nullable large list
-        let list_vortex_array_non_null = vortex_array_non_null.as_::<ListVTable>();
-        let offsets_array_non_null = list_vortex_array_non_null
-            .offsets()
-            .as_::<PrimitiveVTable>();
+        let list_vortex_array_non_null = vortex_array_non_null.as_::<List>();
+        let offsets_array_non_null = list_vortex_array_non_null.offsets().as_::<Primitive>();
         assert_eq!(offsets_array_non_null.len(), 3); // n+1 offsets for n lists
         assert_eq!(offsets_array_non_null.ptype(), PType::I64); // Large lists use I64 offsets
     }
@@ -1523,13 +1524,14 @@ mod tests {
         // Create a FixedSizeListArray with list_size=3
         let field = Arc::new(Field::new("item", DataType::Int32, true));
         let arrow_array =
-            ArrowFixedSizeListArray::try_new(field.clone(), 3, Arc::new(values), None).unwrap();
+            ArrowFixedSizeListArray::try_new(Arc::clone(&field), 3, Arc::new(values), None)
+                .unwrap();
         let vortex_array = ArrayRef::from_arrow(&arrow_array, false).unwrap();
 
         assert_eq!(vortex_array.len(), 4);
 
         // Verify metadata - should be FixedSizeListArray with correct list size
-        let fsl_vortex_array = vortex_array.as_::<FixedSizeListVTable>();
+        let fsl_vortex_array = vortex_array.as_::<FixedSizeList>();
         assert_eq!(fsl_vortex_array.list_size(), 3);
         assert_eq!(fsl_vortex_array.elements().len(), 12); // 4 lists * 3 elements
 
@@ -1562,7 +1564,7 @@ mod tests {
         assert_eq!(vortex_array_nullable.len(), 3);
 
         // Verify metadata for nullable array
-        let fsl_vortex_array_nullable = vortex_array_nullable.as_::<FixedSizeListVTable>();
+        let fsl_vortex_array_nullable = vortex_array_nullable.as_::<FixedSizeList>();
         assert_eq!(fsl_vortex_array_nullable.list_size(), 3);
         assert_eq!(fsl_vortex_array_nullable.elements().len(), 9); // 3 lists * 3 elements
     }
@@ -1589,7 +1591,7 @@ mod tests {
 
         let field = Arc::new(Field::new("item", DataType::Int32, true));
         let arrow_array = GenericListViewArray::try_new(
-            field.clone(),
+            Arc::clone(&field),
             offsets.clone(),
             sizes.clone(),
             Arc::new(values.clone()),
@@ -1601,9 +1603,9 @@ mod tests {
         assert_eq!(vortex_array.len(), 4);
 
         // Verify metadata - should be ListViewArray with correct offsets and sizes
-        let list_view_vortex_array = vortex_array.as_::<ListViewVTable>();
-        let offsets_array = list_view_vortex_array.offsets().as_::<PrimitiveVTable>();
-        let sizes_array = list_view_vortex_array.sizes().as_::<PrimitiveVTable>();
+        let list_view_vortex_array = vortex_array.as_::<ListView>();
+        let offsets_array = list_view_vortex_array.offsets().as_::<Primitive>();
+        let sizes_array = list_view_vortex_array.sizes().as_::<Primitive>();
 
         assert_eq!(offsets_array.len(), 4);
         assert_eq!(offsets_array.ptype(), PType::I32);
@@ -1615,7 +1617,7 @@ mod tests {
             arrow_buffer::NullBuffer::new(BooleanBuffer::from(vec![true, false, true, true]));
 
         let arrow_array_nullable = GenericListViewArray::try_new(
-            field.clone(),
+            Arc::clone(&field),
             offsets,
             sizes,
             Arc::new(values.clone()),
@@ -1643,13 +1645,9 @@ mod tests {
         assert_eq!(large_vortex_array.len(), 4);
 
         // Verify metadata for large ListView
-        let large_list_view_vortex_array = large_vortex_array.as_::<ListViewVTable>();
-        let large_offsets_array = large_list_view_vortex_array
-            .offsets()
-            .as_::<PrimitiveVTable>();
-        let large_sizes_array = large_list_view_vortex_array
-            .sizes()
-            .as_::<PrimitiveVTable>();
+        let large_list_view_vortex_array = large_vortex_array.as_::<ListView>();
+        let large_offsets_array = large_list_view_vortex_array.offsets().as_::<Primitive>();
+        let large_sizes_array = large_list_view_vortex_array.sizes().as_::<Primitive>();
 
         assert_eq!(large_offsets_array.len(), 4);
         assert_eq!(large_offsets_array.ptype(), PType::I64); // Large ListView uses I64 offsets
@@ -1825,9 +1823,9 @@ mod tests {
         assert_eq!(vortex_array.len(), 3);
 
         // Verify it's stored as List<Struct<key, value>>
-        let list_array = vortex_array.as_::<ListVTable>();
+        let list_array = vortex_array.as_::<List>();
         assert_eq!(list_array.elements().len(), 3); // 3 total key-value pairs
-        let struct_elements = list_array.elements().as_::<StructVTable>();
+        let struct_elements = list_array.elements().as_::<Struct>();
         assert_eq!(struct_elements.names().len(), 2); // key and value fields
 
         // Convert back to Arrow as a MapArray
diff --git a/vortex-array/src/arrow/datum.rs b/vortex-array/src/arrow/datum.rs
index 5297f3c9790..ce77c3bb159 100644
--- a/vortex-array/src/arrow/datum.rs
+++ b/vortex-array/src/arrow/datum.rs
@@ -9,11 +9,10 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrow::FromArrowArray;
 use crate::arrow::IntoArrowArray;
 
@@ -26,41 +25,41 @@ pub struct Datum {
 
 impl Datum {
     /// Create a new [`Datum`] from an [`ArrayRef`], which can then be passed to Arrow compute.
-    pub fn try_new(array: &dyn Array) -> VortexResult<Self> {
-        if array.is::<ConstantVTable>() {
+    pub fn try_new(array: &ArrayRef) -> VortexResult<Self> {
+        if array.is::<Constant>() {
             Ok(Self {
                 array: array.slice(0..1)?.into_arrow_preferred()?,
                 is_scalar: true,
             })
         } else {
             Ok(Self {
-                array: array.to_array().into_arrow_preferred()?,
+                array: array.clone().into_arrow_preferred()?,
                 is_scalar: false,
             })
         }
     }
 
-    /// Create a new [`Datum`] from an [`Array`], which can then be passed to Arrow compute.
+    /// Create a new [`Datum`] from an `DynArray`, which can then be passed to Arrow compute.
     /// This not try and convert the array to a scalar if it is constant.
-    pub fn try_new_array(array: &dyn Array) -> VortexResult<Self> {
+    pub fn try_new_array(array: &ArrayRef) -> VortexResult<Self> {
         Ok(Self {
-            array: array.to_array().into_arrow_preferred()?,
+            array: array.clone().into_arrow_preferred()?,
             is_scalar: false,
         })
     }
 
     pub fn try_new_with_target_datatype(
-        array: &dyn Array,
+        array: &ArrayRef,
         target_datatype: &DataType,
     ) -> VortexResult<Self> {
-        if array.is::<ConstantVTable>() {
+        if array.is::<Constant>() {
             Ok(Self {
                 array: array.slice(0..1)?.into_arrow(target_datatype)?,
                 is_scalar: true,
             })
         } else {
             Ok(Self {
-                array: array.to_array().into_arrow(target_datatype)?,
+                array: array.clone().into_arrow(target_datatype)?,
                 is_scalar: false,
             })
         }
diff --git a/vortex-array/src/arrow/executor/bool.rs b/vortex-array/src/arrow/executor/bool.rs
index e47f85bf0bf..28862a150d0 100644
--- a/vortex-array/src/arrow/executor/bool.rs
+++ b/vortex-array/src/arrow/executor/bool.rs
@@ -10,6 +10,7 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::arrow::null_buffer::to_null_buffer;
 
 /// Convert a canonical BoolArray directly to Arrow.
diff --git a/vortex-array/src/arrow/executor/byte.rs b/vortex-array/src/arrow/executor/byte.rs
index 11be583e27f..bace6665bca 100644
--- a/vortex-array/src/arrow/executor/byte.rs
+++ b/vortex-array/src/arrow/executor/byte.rs
@@ -14,16 +14,16 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
-use crate::arrays::VarBinArray;
-use crate::arrays::VarBinVTable;
+use crate::array::ArrayView;
+use crate::arrays::VarBin;
 use crate::arrays::VarBinViewArray;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::arrow::byte_view::execute_varbinview_to_arrow;
 use crate::arrow::executor::validity::to_arrow_null_buffer;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
-use crate::vtable::ValidityHelper;
 
 /// Convert a Vortex array into an Arrow GenericBinaryArray.
 pub(super) fn to_arrow_byte_array<T: ByteArrayType>(
@@ -34,7 +34,7 @@ where
     T::Offset: NativePType,
 {
     // If the Vortex array is already in VarBin format, we can directly convert it.
-    if let Some(array) = array.as_opt::<VarBinVTable>() {
+    if let Some(array) = array.as_opt::<VarBin>() {
         return varbin_to_byte_array::<T>(array, ctx);
     }
 
@@ -51,7 +51,7 @@ where
 
 /// Convert a Vortex VarBinArray into an Arrow GenericBinaryArray.
 fn varbin_to_byte_array<T: ByteArrayType>(
-    array: &VarBinArray,
+    array: ArrayView<'_, VarBin>,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef>
 where
@@ -68,7 +68,7 @@ where
 
     let data = array.bytes().clone().into_arrow_buffer();
 
-    let null_buffer = to_arrow_null_buffer(array.validity().clone(), array.len(), ctx)?;
+    let null_buffer = to_arrow_null_buffer(array.validity()?, array.len(), ctx)?;
     Ok(Arc::new(unsafe {
         GenericByteArray::<T>::new_unchecked(offsets, data, null_buffer)
     }))
@@ -84,8 +84,8 @@ mod tests {
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
-    use crate::arrays::VarBinViewArray;
     use crate::arrow::ArrowArrayExecutor;
+    use crate::arrow::executor::byte::VarBinViewArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
 
diff --git a/vortex-array/src/arrow/executor/byte_view.rs b/vortex-array/src/arrow/executor/byte_view.rs
index 0e6b4923325..9b19ddcc722 100644
--- a/vortex-array/src/arrow/executor/byte_view.rs
+++ b/vortex-array/src/arrow/executor/byte_view.rs
@@ -18,7 +18,6 @@ use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::arrow::FromArrowType;
-use crate::vtable::ValidityHelper;
 
 /// Convert a canonical VarBinViewArray directly to Arrow.
 pub fn canonical_varbinview_to_arrow<T: ByteViewType>(
@@ -27,7 +26,7 @@ pub fn canonical_varbinview_to_arrow<T: ByteViewType>(
     let views =
         ScalarBuffer::<u128>::from(array.views_handle().as_host().clone().into_arrow_buffer());
     let buffers: Vec<_> = array
-        .buffers()
+        .data_buffers()
         .iter()
         .map(|buffer| buffer.as_host().clone().into_arrow_buffer())
         .collect();
@@ -46,11 +45,11 @@ pub fn execute_varbinview_to_arrow<T: ByteViewType>(
     let views =
         ScalarBuffer::<u128>::from(array.views_handle().as_host().clone().into_arrow_buffer());
     let buffers: Vec<_> = array
-        .buffers()
+        .data_buffers()
         .iter()
         .map(|buffer| buffer.as_host().clone().into_arrow_buffer())
         .collect();
-    let nulls = to_arrow_null_buffer(array.validity().clone(), array.len(), ctx)?;
+    let nulls = to_arrow_null_buffer(array.validity()?, array.len(), ctx)?;
 
     // SAFETY: our own VarBinView array is considered safe.
     Ok(Arc::new(unsafe {
diff --git a/vortex-array/src/arrow/executor/decimal.rs b/vortex-array/src/arrow/executor/decimal.rs
index b99d245e269..234b253f903 100644
--- a/vortex-array/src/arrow/executor/decimal.rs
+++ b/vortex-array/src/arrow/executor/decimal.rs
@@ -205,9 +205,9 @@ mod tests {
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array::IntoArray;
-    use crate::arrays::DecimalArray;
     use crate::arrow::ArrowArrayExecutor;
     use crate::arrow::IntoArrowArray;
+    use crate::arrow::executor::decimal::DecimalArray;
     use crate::builders::ArrayBuilder;
     use crate::builders::DecimalBuilder;
     use crate::dtype::DecimalDType;
diff --git a/vortex-array/src/arrow/executor/dictionary.rs b/vortex-array/src/arrow/executor/dictionary.rs
index 78e7f981824..f0808d88818 100644
--- a/vortex-array/src/arrow/executor/dictionary.rs
+++ b/vortex-array/src/arrow/executor/dictionary.rs
@@ -17,11 +17,11 @@ use vortex_error::vortex_bail;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
+use crate::arrays::Dict;
 use crate::arrays::DictArray;
-use crate::arrays::DictArrayParts;
-use crate::arrays::DictVTable;
+use crate::arrays::dict::DictArraySlotsExt;
 use crate::arrow::ArrowArrayExecutor;
 
 pub(super) fn to_arrow_dictionary(
@@ -30,11 +30,11 @@ pub(super) fn to_arrow_dictionary(
     values_type: &DataType,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef> {
-    let array = match array.try_into::<DictVTable>() {
+    let array = match array.try_downcast::<Dict>() {
         Ok(dict) => return dict_to_dict(dict, codes_type, values_type, ctx),
         Err(array) => array,
     };
-    let array = match array.try_into::<ConstantVTable>() {
+    let array = match array.try_downcast::<Constant>() {
         Ok(constant) => return constant_to_dict(constant, codes_type, values_type, ctx),
         Err(array) => array,
     };
@@ -78,9 +78,11 @@ fn dict_to_dict(
     values_type: &DataType,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef> {
-    let DictArrayParts { codes, values, .. } = array.into_parts();
-    let codes = codes.execute_arrow(Some(codes_type), ctx)?;
-    let values = values.execute_arrow(Some(values_type), ctx)?;
+    let codes = array.codes().clone().execute_arrow(Some(codes_type), ctx)?;
+    let values = array
+        .values()
+        .clone()
+        .execute_arrow(Some(values_type), ctx)?;
     make_dict_array(codes_type, codes, values)
 }
 
@@ -148,11 +150,11 @@ mod tests {
 
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
-    use crate::arrays::ConstantArray;
-    use crate::arrays::DictArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinViewArray;
     use crate::arrow::ArrowArrayExecutor;
+    use crate::arrow::executor::dictionary::ConstantArray;
+    use crate::arrow::executor::dictionary::DictArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::Nullable;
     use crate::executor::VortexSessionExecute;
diff --git a/vortex-array/src/arrow/executor/fixed_size_list.rs b/vortex-array/src/arrow/executor/fixed_size_list.rs
index 6da7c40aa58..7abea9aaa7a 100644
--- a/vortex-array/src/arrow/executor/fixed_size_list.rs
+++ b/vortex-array/src/arrow/executor/fixed_size_list.rs
@@ -9,11 +9,11 @@ use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::arrow::ArrowArrayExecutor;
 use crate::arrow::executor::validity::to_arrow_null_buffer;
-use crate::vtable::ValidityHelper;
 
 pub(super) fn to_arrow_fixed_list(
     array: ArrayRef,
@@ -22,8 +22,8 @@ pub(super) fn to_arrow_fixed_list(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<arrow_array::ArrayRef> {
     // Check for Vortex FixedSizeListArray and convert directly.
-    if let Some(array) = array.as_opt::<FixedSizeListVTable>() {
-        return list_to_list(array, elements_field, list_size, ctx);
+    if let Some(array) = array.as_opt::<FixedSizeList>() {
+        return list_to_list(&array.into_owned(), elements_field, list_size, ctx);
     }
 
     // Otherwise, we execute the array to become a FixedSizeListArray.
@@ -53,12 +53,15 @@ fn list_to_list(
         "Cannot convert FixedSizeListArray to non-nullable Arrow array when elements are nullable"
     );
 
-    let null_buffer = to_arrow_null_buffer(array.validity().clone(), array.len(), ctx)?;
+    let null_buffer = to_arrow_null_buffer(array.validity()?, array.len(), ctx)?;
 
-    Ok(Arc::new(arrow_array::FixedSizeListArray::new(
-        elements_field.clone(),
-        list_size,
-        elements,
-        null_buffer,
-    )))
+    Ok(Arc::new(
+        arrow_array::FixedSizeListArray::try_new_with_length(
+            Arc::clone(elements_field),
+            list_size,
+            elements,
+            null_buffer,
+            array.len(),
+        )?,
+    ))
 }
diff --git a/vortex-array/src/arrow/executor/list.rs b/vortex-array/src/arrow/executor/list.rs
index 4b18ba916b0..285ad733cfb 100644
--- a/vortex-array/src/arrow/executor/list.rs
+++ b/vortex-array/src/arrow/executor/list.rs
@@ -13,37 +13,50 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
+use crate::arrays::Chunked;
+use crate::arrays::List;
 use crate::arrays::ListArray;
-use crate::arrays::ListVTable;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewArrayParts;
-use crate::arrays::ListViewRebuildMode;
-use crate::arrays::ListViewVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewDataParts;
+use crate::arrays::listview::ListViewRebuildMode;
 use crate::arrow::ArrowArrayExecutor;
 use crate::arrow::executor::validity::to_arrow_null_buffer;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
-use crate::vtable::ValidityHelper;
 
-/// Convert a Vortex array into an Arrow GenericBinaryArray.
+/// Convert a Vortex VarBinArray into an Arrow [`GenericListArray`](arrow_array:array::GenericListArray).
 pub(super) fn to_arrow_list<O: OffsetSizeTrait + NativePType>(
     array: ArrayRef,
     elements_field: &FieldRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef> {
     // If the Vortex array is already in List format, we can directly convert it.
-    if let Some(array) = array.as_opt::<ListVTable>() {
-        return list_to_list::<O>(array, elements_field, ctx);
+    if let Some(array) = array.as_opt::<List>() {
+        return list_to_list::<O>(&array.into_owned(), elements_field, ctx);
+    }
+
+    // Converting each chunk individually, then using the fast concat logic from arrow
+    if let Some(chunked) = array.as_opt::<Chunked>() {
+        let mut arrow_chunks: Vec<ArrowArrayRef> = Vec::with_capacity(chunked.nchunks());
+        for chunk in chunked.chunks() {
+            arrow_chunks.push(to_arrow_list::<O>(chunk.clone(), elements_field, ctx)?);
+        }
+
+        let refs = arrow_chunks.iter().map(|a| a.as_ref()).collect::<Vec<_>>();
+        return Ok(arrow_select::concat::concat(&refs)?);
     }
 
     // If the Vortex array is a ListViewArray, rebuild to ZCTL if needed and convert.
-    let array = match array.try_into::<ListViewVTable>() {
+    let array = match array.try_downcast::<ListView>() {
         Ok(array) => {
             let zctl = if array.is_zero_copy_to_list() {
                 array
@@ -68,7 +81,7 @@ pub(super) fn to_arrow_list<O: OffsetSizeTrait + NativePType>(
     list_view_zctl::<O>(zctl, elements_field, ctx)
 }
 
-/// Convert a Vortex VarBinArray into an Arrow GenericBinaryArray.
+/// Convert a Vortex VarBinArray into an Arrow [`GenericListArray`](arrow_array:array::GenericListArray).
 fn list_to_list<O: OffsetSizeTrait + NativePType>(
     array: &ListArray,
     elements_field: &FieldRef,
@@ -92,11 +105,11 @@ fn list_to_list<O: OffsetSizeTrait + NativePType>(
         "Cannot convert to non-nullable Arrow array with null elements"
     );
 
-    let null_buffer = to_arrow_null_buffer(array.validity().clone(), array.len(), ctx)?;
+    let null_buffer = to_arrow_null_buffer(array.validity()?, array.len(), ctx)?;
 
     // TODO(ngates): use new_unchecked when it is added to arrow-rs.
     Ok(Arc::new(GenericListArray::<O>::new(
-        elements_field.clone(),
+        Arc::clone(elements_field),
         offsets,
         elements,
         null_buffer,
@@ -116,20 +129,20 @@ fn list_view_zctl<O: OffsetSizeTrait + NativePType>(
             .clone()
             .execute_arrow(Some(elements_field.data_type()), ctx)?;
         return Ok(Arc::new(GenericListArray::<O>::new(
-            elements_field.clone(),
+            Arc::clone(elements_field),
             OffsetBuffer::new_empty(),
             elements,
             None,
         )));
     }
 
-    let ListViewArrayParts {
+    let ListViewDataParts {
         elements,
         offsets,
         sizes,
         validity,
         ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     // For ZCTL, we know that we only care about the final size.
     assert!(!sizes.is_empty());
@@ -172,7 +185,7 @@ fn list_view_zctl<O: OffsetSizeTrait + NativePType>(
     let null_buffer = to_arrow_null_buffer(validity, sizes.len(), ctx)?;
 
     Ok(Arc::new(GenericListArray::<O>::new(
-        elements_field.clone(),
+        Arc::clone(elements_field),
         offsets.freeze().into_arrow_offset_buffer(),
         elements,
         null_buffer,
@@ -193,9 +206,9 @@ mod tests {
 
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrow::IntoArrowArray;
+    use crate::arrow::executor::list::ListViewArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::NonNullable;
     use crate::validity::Validity;
diff --git a/vortex-array/src/arrow/executor/list_view.rs b/vortex-array/src/arrow/executor/list_view.rs
index aeb6d663c08..bf6d0da0b8b 100644
--- a/vortex-array/src/arrow/executor/list_view.rs
+++ b/vortex-array/src/arrow/executor/list_view.rs
@@ -11,10 +11,10 @@ use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewArrayParts;
-use crate::arrays::ListViewVTable;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewDataParts;
 use crate::arrow::ArrowArrayExecutor;
 use crate::arrow::executor::validity::to_arrow_null_buffer;
 use crate::builtins::ArrayBuiltins;
@@ -28,7 +28,7 @@ pub(super) fn to_arrow_list_view<O: OffsetSizeTrait + IntegerPType>(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<arrow_array::ArrayRef> {
     // Check for Vortex ListViewArray and convert directly.
-    let array = match array.try_into::<ListViewVTable>() {
+    let array = match array.try_downcast::<ListView>() {
         Ok(array) => return list_view_to_list_view::<O>(array, elements_field, ctx),
         Err(array) => array,
     };
@@ -43,13 +43,13 @@ fn list_view_to_list_view<O: OffsetSizeTrait + IntegerPType>(
     elements_field: &FieldRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<arrow_array::ArrayRef> {
-    let ListViewArrayParts {
+    let ListViewDataParts {
         elements,
         offsets,
         sizes,
         validity,
         ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     let elements = elements.execute_arrow(Some(elements_field.data_type()), ctx)?;
     vortex_ensure!(
@@ -71,7 +71,7 @@ fn list_view_to_list_view<O: OffsetSizeTrait + IntegerPType>(
     let null_buffer = to_arrow_null_buffer(validity, offsets.len(), ctx)?;
 
     Ok(Arc::new(GenericListViewArray::<O>::new(
-        elements_field.clone(),
+        Arc::clone(elements_field),
         offsets,
         sizes,
         elements,
@@ -89,9 +89,9 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::arrays::ListViewArray;
-    use crate::arrays::PrimitiveArray;
     use crate::arrow::IntoArrowArray;
+    use crate::arrow::executor::list_view::ListViewArray;
+    use crate::arrow::executor::list_view::PrimitiveArray;
     use crate::validity::Validity;
 
     #[test]
diff --git a/vortex-array/src/arrow/executor/map.rs b/vortex-array/src/arrow/executor/map.rs
index a289fb34d91..9a84281e60d 100644
--- a/vortex-array/src/arrow/executor/map.rs
+++ b/vortex-array/src/arrow/executor/map.rs
@@ -43,7 +43,7 @@ pub(super) fn to_arrow_map(
 
     // Build the MapArray from the components.
     let map_array = ArrowMapArray::try_new(
-        entries_field.clone(),
+        Arc::clone(entries_field),
         offsets,
         entries_struct,
         nulls,
diff --git a/vortex-array/src/arrow/executor/mod.rs b/vortex-array/src/arrow/executor/mod.rs
index 47787d34116..30cc3a97d9f 100644
--- a/vortex-array/src/arrow/executor/mod.rs
+++ b/vortex-array/src/arrow/executor/mod.rs
@@ -31,8 +31,10 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
-use crate::arrays::ListVTable;
-use crate::arrays::VarBinVTable;
+use crate::arrays::List;
+use crate::arrays::VarBin;
+use crate::arrays::list::ListArrayExt;
+use crate::arrays::varbin::VarBinArrayExt;
 use crate::arrow::executor::bool::to_arrow_bool;
 use crate::arrow::executor::byte::to_arrow_byte_array;
 use crate::arrow::executor::byte_view::to_arrow_byte_view;
@@ -196,7 +198,7 @@ impl ArrowArrayExecutor for ArrayRef {
 /// - `ListArray`: Uses `List` instead of `ListView`
 fn preferred_arrow_type(array: &ArrayRef) -> VortexResult<DataType> {
     // VarBinArray: use offset-based Binary/Utf8 instead of View types
-    if let Some(varbin) = array.as_opt::<VarBinVTable>() {
+    if let Some(varbin) = array.as_opt::<VarBin>() {
         let offsets_ptype = PType::try_from(varbin.offsets().dtype())?;
         let use_large = matches!(offsets_ptype, PType::I64 | PType::U64);
 
@@ -210,7 +212,7 @@ fn preferred_arrow_type(array: &ArrayRef) -> VortexResult<DataType> {
     }
 
     // ListArray: use List with appropriate offset size
-    if let Some(list) = array.as_opt::<ListVTable>() {
+    if let Some(list) = array.as_opt::<List>() {
         let offsets_ptype = PType::try_from(list.offsets().dtype())?;
         let use_large = matches!(offsets_ptype, PType::I64 | PType::U64);
         // Recursively get the preferred type for elements
diff --git a/vortex-array/src/arrow/executor/run_end.rs b/vortex-array/src/arrow/executor/run_end.rs
index 560c75c0dce..69aca62a994 100644
--- a/vortex-array/src/arrow/executor/run_end.rs
+++ b/vortex-array/src/arrow/executor/run_end.rs
@@ -18,13 +18,11 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::array::ArrayVisitor;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrow::ArrowArrayExecutor;
 
 /// The encoding ID used by `vortex-runend`. We match on this string to avoid a crate dependency.
@@ -48,7 +46,7 @@ pub(super) fn to_arrow_run_end(
     values_type: &Field,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef> {
-    let array = match array.try_into::<ConstantVTable>() {
+    let array = match array.try_downcast::<Constant>() {
         Ok(constant) => {
             return constant_to_run_end(constant, ends_type, values_type, ctx);
         }
@@ -82,7 +80,7 @@ fn run_end_to_arrow(
 ) -> VortexResult<ArrowArrayRef> {
     let length = array.len();
     let metadata_bytes = array
-        .metadata()?
+        .metadata(ctx.session())?
         .ok_or_else(|| vortex_err!("RunEndArray missing metadata"))?;
     let metadata = RunEndMetadata::decode(&*metadata_bytes)
         .map_err(|e| vortex_err!("Failed to decode RunEndMetadata: {e}"))?;
@@ -118,22 +116,35 @@ fn build_run_array<R: RunEndIndexType>(
 where
     R::Native: std::ops::Sub<Output = R::Native> + Ord,
 {
-    if offset == 0 {
-        return Ok(
-            Arc::new(RunArray::<R>::try_new(ends.as_primitive::<R>(), values)?) as ArrowArrayRef,
-        );
-    }
-
     let offset_native = R::Native::from_usize(offset)
         .ok_or_else(|| vortex_err!("Offset {offset} exceeds run-end index capacity"))?;
     let length_native = R::Native::from_usize(length)
         .ok_or_else(|| vortex_err!("Length {length} exceeds run-end index capacity"))?;
 
-    let adjusted = ends
+    let ends_prim = ends.as_primitive::<R>();
+    if offset == 0 && ends_prim.values().last() == Some(&length_native) {
+        // Fast path: no trimming or adjustment needed.
+        return Ok(Arc::new(RunArray::<R>::try_new(ends_prim, values)?) as ArrowArrayRef);
+    }
+
+    // Trim to only include runs covering the [offset, offset+length) range.
+    // Runs beyond this would produce duplicate adjusted ends, violating
+    // Arrow's strict-ordering requirement for RunArray.
+    // Run ends are strictly increasing, so we can binary search.
+    let num_runs = (ends_prim
+        .values()
+        .partition_point(|&e| e - offset_native < length_native)
+        + 1)
+    .min(ends_prim.len());
+
+    let trimmed_ends = ends.slice(0, num_runs);
+    let trimmed_values = values.slice(0, num_runs);
+
+    let adjusted = trimmed_ends
         .as_primitive::<R>()
         .unary(|end| (end - offset_native).min(length_native));
 
-    Ok(Arc::new(RunArray::<R>::try_new(&adjusted, values)?) as ArrowArrayRef)
+    Ok(Arc::new(RunArray::<R>::try_new(&adjusted, &trimmed_values)?) as ArrowArrayRef)
 }
 
 /// Convert a constant array to a run-end encoded array with a single run.
@@ -195,9 +206,9 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrow::ArrowArrayExecutor;
+    use crate::arrow::executor::run_end::ConstantArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::Nullable;
     use crate::dtype::PType;
@@ -275,4 +286,34 @@ mod tests {
         assert_eq!(result.as_ref(), &expected);
         Ok(())
     }
+
+    /// Regression: build_run_array must trim excess trailing runs and
+    /// respect the `length` parameter. This happens when a vortex
+    /// RunEndArray is sliced to fewer rows than the physical run_ends cover.
+    #[rstest]
+    #[case::offset_zero(0, 5, &[3, 5], &[100, 200])]
+    #[case::nonzero_offset(2, 3, &[1, 3], &[100, 200])]
+    #[case::all_runs_needed_but_last_exceeds(0, 8, &[3, 5, 8], &[100, 200, 300])]
+    fn build_run_array_trims_excess_runs(
+        #[case] offset: usize,
+        #[case] length: usize,
+        #[case] expected_ends: &[i32],
+        #[case] expected_values: &[i64],
+    ) -> VortexResult<()> {
+        // 3 runs covering 10 rows: [0..3), [3..5), [5..10)
+        let ends: arrow_array::ArrayRef = Arc::new(Int32Array::from(vec![3i32, 5, 10]));
+        let values: arrow_array::ArrayRef = Arc::new(Int64Array::from(vec![100i64, 200, 300]));
+
+        let result = super::build_run_array::<Int32Type>(&ends, &values, offset, length)?;
+        assert_eq!(result.len(), length);
+
+        let ree = result
+            .as_any()
+            .downcast_ref::<RunArray<Int32Type>>()
+            .unwrap();
+        assert_eq!(ree.run_ends().values(), expected_ends);
+        let values = ree.values().as_any().downcast_ref::<Int64Array>().unwrap();
+        assert_eq!(values.values(), expected_values);
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/arrow/executor/struct_.rs b/vortex-array/src/arrow/executor/struct_.rs
index f1b79392f8a..a85005c0a20 100644
--- a/vortex-array/src/arrow/executor/struct_.rs
+++ b/vortex-array/src/arrow/executor/struct_.rs
@@ -12,16 +12,15 @@ use itertools::Itertools;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::Chunked;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructArrayParts;
-use crate::arrays::StructVTable;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::struct_::StructDataParts;
 use crate::arrow::ArrowArrayExecutor;
 use crate::arrow::executor::validity::to_arrow_null_buffer;
 use crate::builtins::ArrayBuiltins;
@@ -39,25 +38,24 @@ pub(super) fn to_arrow_struct(
     let len = array.len();
 
     // If the array is chunked, then we invert the chunk-of-struct to struct-of-chunk.
-    let array = match array.try_into::<ChunkedVTable>() {
+    let array = match array.try_downcast::<Chunked>() {
         Ok(array) => {
             // NOTE(ngates): this currently uses the old into_canonical code path, but we should
             //  just call directly into the swizzle-chunks function.
-            array.to_struct().into_array()
+            array.into_array().execute::<StructArray>(ctx)?.into_array()
         }
         Err(array) => array,
     };
 
-    // Attempt to short-circuit if the array is already a StructVTable:
-    let array = match array.try_into::<StructVTable>() {
+    // Attempt to short-circuit if the array is already a Struct:
+    let array = match array.try_downcast::<Struct>() {
         Ok(array) => {
-            let len = array.len();
-            let StructArrayParts {
+            let StructDataParts {
                 validity,
                 fields,
                 struct_fields,
                 ..
-            } = array.into_parts();
+            } = array.into_data_parts();
             let validity = to_arrow_null_buffer(validity, len, ctx)?;
             return create_from_fields(
                 target_fields.ok_or_else(|| struct_fields.names().clone()),
@@ -79,7 +77,7 @@ pub(super) fn to_arrow_struct(
         };
         return create_from_fields(
             target_fields.ok_or_else(|| struct_fields.names().clone()),
-            array.children(),
+            &array.children(),
             None, // Pack is never null,
             len,
             ctx,
@@ -99,13 +97,12 @@ pub(super) fn to_arrow_struct(
     };
 
     let struct_array = array.execute::<StructArray>(ctx)?;
-    let len = struct_array.len();
-    let StructArrayParts {
+    let StructDataParts {
         validity,
         fields,
         struct_fields,
         ..
-    } = struct_array.into_parts();
+    } = struct_array.into_data_parts();
 
     let validity = to_arrow_null_buffer(validity, len, ctx)?;
     create_from_fields(
@@ -289,7 +286,8 @@ mod tests {
                 ),
                 (
                     "b",
-                    arrays::VarBinViewArray::from_iter_str(vec!["a", "b", "c"]).into_array(),
+                    arrays::varbinview::VarBinViewArray::from_iter_str(vec!["a", "b", "c"])
+                        .into_array(),
                 ),
             ]
             .as_slice(),
@@ -332,7 +330,8 @@ mod tests {
                 ),
                 (
                     "b",
-                    arrays::VarBinViewArray::from_iter_str(vec!["a", "b", "c"]).into_array(),
+                    arrays::varbinview::VarBinViewArray::from_iter_str(vec!["a", "b", "c"])
+                        .into_array(),
                 ),
             ]
             .as_slice(),
diff --git a/vortex-array/src/arrow/executor/temporal.rs b/vortex-array/src/arrow/executor/temporal.rs
index 64fe4eb1466..29bcc15763e 100644
--- a/vortex-array/src/arrow/executor/temporal.rs
+++ b/vortex-array/src/arrow/executor/temporal.rs
@@ -25,11 +25,11 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::arrays::ExtensionArray;
 use crate::arrays::PrimitiveArray as VortexPrimitiveArray;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::arrow::null_buffer::to_null_buffer;
 use crate::dtype::NativePType;
 use crate::extension::datetime::AnyTemporal;
@@ -147,7 +147,7 @@ where
 
     let ext_array = array.execute::<ExtensionArray>(ctx)?;
     let primitive = ext_array
-        .storage()
+        .storage_array()
         .clone()
         .execute::<VortexPrimitiveArray>(ctx)?;
     vortex_ensure!(
diff --git a/vortex-array/src/arrow/executor/validity.rs b/vortex-array/src/arrow/executor/validity.rs
index 27a29a58783..fa848dfc79a 100644
--- a/vortex-array/src/arrow/executor/validity.rs
+++ b/vortex-array/src/arrow/executor/validity.rs
@@ -1,22 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use arrow_buffer::NullBuffer;
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::ExecutionCtx;
-use crate::arrow::null_buffer::to_null_buffer;
-use crate::validity::Validity;
-
-pub(super) fn to_arrow_null_buffer(
-    validity: Validity,
-    len: usize,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<Option<NullBuffer>> {
-    Ok(match validity {
-        Validity::NonNullable | Validity::AllValid => None,
-        Validity::AllInvalid => Some(NullBuffer::new_null(len)),
-        Validity::Array(array) => to_null_buffer(array.execute::<Mask>(ctx)?),
-    })
-}
+pub(super) use crate::arrow::null_buffer::to_arrow_null_buffer;
diff --git a/vortex-array/src/arrow/mod.rs b/vortex-array/src/arrow/mod.rs
index 1a19d19f318..bcc9e6094a1 100644
--- a/vortex-array/src/arrow/mod.rs
+++ b/vortex-array/src/arrow/mod.rs
@@ -7,8 +7,6 @@ use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_schema::DataType;
 use vortex_error::VortexResult;
 
-mod array;
-pub mod compute;
 mod convert;
 mod datum;
 mod executor;
@@ -16,11 +14,13 @@ mod iter;
 mod null_buffer;
 mod record_batch;
 
-pub use array::*;
 pub use datum::*;
 pub use executor::*;
 pub use iter::*;
+pub use null_buffer::to_arrow_null_buffer;
+pub use null_buffer::to_null_buffer;
 
+use crate::ArrayRef;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 
@@ -36,7 +36,7 @@ pub trait IntoArrowArray {
     fn into_arrow(self, data_type: &DataType) -> VortexResult<ArrowArrayRef>;
 }
 
-impl IntoArrowArray for crate::ArrayRef {
+impl IntoArrowArray for ArrayRef {
     /// Convert this [`crate::ArrayRef`] into an Arrow [`crate::ArrayRef`] by using the array's
     /// preferred (cheapest) Arrow [`DataType`].
     fn into_arrow_preferred(self) -> VortexResult<ArrowArrayRef> {
diff --git a/vortex-array/src/arrow/null_buffer.rs b/vortex-array/src/arrow/null_buffer.rs
index 4abbf5a9f48..484dd5e55bc 100644
--- a/vortex-array/src/arrow/null_buffer.rs
+++ b/vortex-array/src/arrow/null_buffer.rs
@@ -3,8 +3,25 @@
 
 use arrow_buffer::BooleanBuffer;
 use arrow_buffer::NullBuffer;
+use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
+use crate::ExecutionCtx;
+use crate::validity::Validity;
+
+/// Converts a [`Validity`] to an Arrow [`NullBuffer`], executing the validity array if needed.
+pub fn to_arrow_null_buffer(
+    validity: Validity,
+    len: usize,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Option<NullBuffer>> {
+    Ok(match validity {
+        Validity::NonNullable | Validity::AllValid => None,
+        Validity::AllInvalid => Some(NullBuffer::new_null(len)),
+        Validity::Array(array) => to_null_buffer(array.execute::<Mask>(ctx)?),
+    })
+}
+
 /// Converts a mask to a null buffer.
 pub fn to_null_buffer(mask: Mask) -> Option<NullBuffer> {
     match mask {
diff --git a/vortex-array/src/arrow/record_batch.rs b/vortex-array/src/arrow/record_batch.rs
index 3ccf65920a9..a7596169c15 100644
--- a/vortex-array/src/arrow/record_batch.rs
+++ b/vortex-array/src/arrow/record_batch.rs
@@ -10,7 +10,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
-use crate::Array;
+use crate::ArrayRef;
 use crate::Canonical;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
@@ -18,10 +18,10 @@ use crate::array::IntoArray;
 use crate::arrays::StructArray;
 use crate::arrow::ArrowArrayExecutor;
 
-impl TryFrom<&dyn Array> for RecordBatch {
+impl TryFrom<&ArrayRef> for RecordBatch {
     type Error = VortexError;
 
-    fn try_from(value: &dyn Array) -> VortexResult<Self> {
+    fn try_from(value: &ArrayRef) -> VortexResult<Self> {
         let Canonical::Struct(struct_array) = value.to_canonical()? else {
             vortex_bail!("RecordBatch can only be constructed from ")
         };
@@ -46,7 +46,7 @@ impl StructArray {
     ) -> VortexResult<RecordBatch> {
         let data_type = DataType::Struct(schema.as_ref().fields.clone());
         let array_ref = self
-            .to_array()
+            .into_array()
             .execute_arrow(Some(&data_type), &mut LEGACY_SESSION.create_execution_ctx())?;
         Ok(RecordBatch::from(array_ref.as_struct()))
     }
@@ -61,7 +61,7 @@ mod tests {
     use arrow_schema::FieldRef;
     use arrow_schema::Schema;
 
-    use crate::arrays::StructArray;
+    use crate::arrow::record_batch::StructArray;
     use crate::builders::ArrayBuilder;
     use crate::builders::ListBuilder;
     use crate::dtype::DType;
diff --git a/vortex-array/src/builders/bool.rs b/vortex-array/src/builders/bool.rs
index dd57fd737b0..4c5eb5d9a61 100644
--- a/vortex-array/src/builders/bool.rs
+++ b/vortex-array/src/builders/bool.rs
@@ -10,10 +10,10 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::LazyBitBufferBuilder;
@@ -112,15 +112,12 @@ impl ArrayBuilder for BoolBuilder {
         Ok(())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let bool_array = array.to_bool();
 
         self.inner.append_buffer(&bool_array.to_bit_buffer());
-        self.nulls.append_validity_mask(
-            bool_array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked"),
-        );
+        self.nulls
+            .append_validity_mask(bool_array.validity_mask().vortex_expect("validity_mask"));
     }
 
     fn reserve_exact(&mut self, additional: usize) {
@@ -144,7 +141,7 @@ impl ArrayBuilder for BoolBuilder {
 
 #[cfg(test)]
 mod tests {
-    use rand::Rng;
+    use rand::RngExt;
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_error::VortexResult;
@@ -153,18 +150,17 @@ mod tests {
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
-    use crate::array::Array;
-    use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::builders::BoolBuilder;
+    use crate::builders::bool::BoolArray;
     use crate::builders::builder_with_capacity;
     use crate::canonical::ToCanonical;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::scalar::Scalar;
-    use crate::vtable::ValidityHelper;
 
     fn make_opt_bool_chunks(len: usize, chunk_count: usize) -> ArrayRef {
         let mut rng = StdRng::seed_from_u64(0);
@@ -189,15 +185,20 @@ mod tests {
         let chunk_count = 10;
         let chunk = make_opt_bool_chunks(len, chunk_count);
 
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
         chunk
             .clone()
-            .append_to_builder(builder.as_mut(), &mut LEGACY_SESSION.create_execution_ctx())?;
+            .append_to_builder(builder.as_mut(), &mut ctx)?;
 
         let canon_into = builder.finish().to_bool();
         let into_canon = chunk.to_bool();
 
-        assert_eq!(canon_into.validity(), into_canon.validity());
+        assert!(
+            canon_into
+                .validity()?
+                .mask_eq(&into_canon.validity()?, &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 f3a2744e0e5..d3811314a04 100644
--- a/vortex-array/src/builders/decimal.rs
+++ b/vortex-array/src/builders/decimal.rs
@@ -11,7 +11,6 @@ use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
@@ -121,6 +120,12 @@ impl DecimalBuilder {
         self.nulls.append_non_null();
     }
 
+    /// Appends `n` copies of `value` as non-null entries, directly writing into the buffer.
+    pub fn append_n_values<V: NativeDecimalType>(&mut self, value: V, n: usize) {
+        self.values.push_n(value, n);
+        self.nulls.append_n_non_nulls(n);
+    }
+
     /// Finishes the builder directly into a [`DecimalArray`].
     pub fn finish_into_decimal(&mut self) -> DecimalArray {
         let validity = self.nulls.finish_with_nullability(self.dtype.nullability());
@@ -187,7 +192,7 @@ impl ArrayBuilder for DecimalBuilder {
         Ok(())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let decimal_array = array.to_decimal();
 
         match_each_decimal_value_type!(decimal_array.values_type(), |D| {
@@ -197,11 +202,8 @@ impl ArrayBuilder for DecimalBuilder {
                 .extend(decimal_array.buffer::<D>().iter().copied());
         });
 
-        self.nulls.append_validity_mask(
-            decimal_array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked"),
-        );
+        self.nulls
+            .append_validity_mask(decimal_array.validity_mask().vortex_expect("validity_mask"));
     }
 
     fn reserve_exact(&mut self, additional: usize) {
@@ -295,10 +297,10 @@ impl Default for DecimalBuffer {
 
 #[cfg(test)]
 mod tests {
-    use crate::arrays::DecimalArray;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::builders::DecimalBuilder;
+    use crate::builders::decimal::DecimalArray;
     use crate::dtype::DecimalDType;
 
     #[test]
diff --git a/vortex-array/src/builders/dict/bytes.rs b/vortex-array/src/builders/dict/bytes.rs
index 280b8586f2d..155d0b1db9a 100644
--- a/vortex-array/src/builders/dict/bytes.rs
+++ b/vortex-array/src/builders/dict/bytes.rs
@@ -17,15 +17,14 @@ use vortex_utils::aliases::hash_map::RandomState;
 
 use super::DictConstraints;
 use super::DictEncoder;
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::accessor::ArrayAccessor;
-use crate::arrays::BinaryView;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::VarBinVTable;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::varbinview::build_views::BinaryView;
 use crate::canonical::ToCanonical;
 use crate::dtype::DType;
 use crate::dtype::PType;
@@ -71,7 +70,6 @@ impl<Code: UnsignedPType> BytesDictBuilder<Code> {
         self.views.len() * size_of::<BinaryView>() + self.values.len()
     }
 
-    #[inline]
     fn lookup_bytes(&self, idx: usize) -> Option<&[u8]> {
         self.values_nulls.value(idx).then(|| {
             let bin_view = &self.views[idx];
@@ -83,7 +81,6 @@ impl<Code: UnsignedPType> BytesDictBuilder<Code> {
         })
     }
 
-    #[inline]
     fn encode_value(&mut self, lookup: &mut HashTable<Code>, val: Option<&[u8]>) -> Option<Code> {
         match lookup.entry(
             self.hasher.hash_one(val),
@@ -158,7 +155,7 @@ impl<Code: UnsignedPType> BytesDictBuilder<Code> {
 }
 
 impl<Code: UnsignedPType> DictEncoder for BytesDictBuilder<Code> {
-    fn encode(&mut self, array: &dyn Array) -> ArrayRef {
+    fn encode(&mut self, array: &ArrayRef) -> ArrayRef {
         debug_assert_eq!(
             &self.dtype,
             array.dtype(),
@@ -168,10 +165,10 @@ impl<Code: UnsignedPType> DictEncoder for BytesDictBuilder<Code> {
         );
 
         let len = array.len();
-        if let Some(varbinview) = array.as_opt::<VarBinViewVTable>() {
-            self.encode_bytes(varbinview, len)
-        } else if let Some(varbin) = array.as_opt::<VarBinVTable>() {
-            self.encode_bytes(varbin, len)
+        if let Some(varbinview) = array.as_opt::<VarBinView>() {
+            self.encode_bytes(&varbinview.into_owned(), len)
+        } else if let Some(varbin) = array.as_opt::<VarBin>() {
+            self.encode_bytes(&varbin.into_owned(), len)
         } else {
             // NOTE(aduffy): it is very rare that this path would be taken, only e.g.
             //  if we're performing dictionary encoding downstream of some other compression.
@@ -206,15 +203,17 @@ impl<Code: UnsignedPType> DictEncoder for BytesDictBuilder<Code> {
 mod test {
     use std::str;
 
+    use crate::IntoArray;
     use crate::ToCanonical;
     use crate::accessor::ArrayAccessor;
     use crate::arrays::VarBinArray;
+    use crate::arrays::dict::DictArraySlotsExt;
     use crate::builders::dict::dict_encode;
 
     #[test]
     fn encode_varbin() {
         let arr = VarBinArray::from(vec!["hello", "world", "hello", "again", "world"]);
-        let dict = dict_encode(arr.as_ref()).unwrap();
+        let dict = dict_encode(&arr.into_array()).unwrap();
         assert_eq!(
             dict.codes().to_primitive().as_slice::<u8>(),
             &[0, 1, 0, 2, 1]
@@ -243,7 +242,7 @@ mod test {
         ]
         .into_iter()
         .collect();
-        let dict = dict_encode(arr.as_ref()).unwrap();
+        let dict = dict_encode(&arr.into_array()).unwrap();
         assert_eq!(
             dict.codes().to_primitive().as_slice::<u8>(),
             &[0, 1, 2, 0, 1, 3, 2, 1]
@@ -260,7 +259,7 @@ mod test {
     #[test]
     fn repeated_values() {
         let arr = VarBinArray::from(vec!["a", "a", "b", "b", "a", "b", "a", "b"]);
-        let dict = dict_encode(arr.as_ref()).unwrap();
+        let dict = dict_encode(&arr.into_array()).unwrap();
         dict.values().to_varbinview().with_iterator(|iter| {
             assert_eq!(
                 iter.flatten()
diff --git a/vortex-array/src/builders/dict/mod.rs b/vortex-array/src/builders/dict/mod.rs
index f656fd905a7..aa24000ac20 100644
--- a/vortex-array/src/builders/dict/mod.rs
+++ b/vortex-array/src/builders/dict/mod.rs
@@ -7,14 +7,14 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
 use crate::arrays::DictArray;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::VarBinVTable;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::Primitive;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinView;
+use crate::arrays::primitive::PrimitiveArrayExt;
 use crate::dtype::PType;
 use crate::match_each_native_ptype;
 
@@ -34,7 +34,7 @@ pub const UNCONSTRAINED: DictConstraints = DictConstraints {
 
 pub trait DictEncoder: Send {
     /// Assign dictionary codes to the given input array.
-    fn encode(&mut self, array: &dyn Array) -> ArrayRef;
+    fn encode(&mut self, array: &ArrayRef) -> ArrayRef;
 
     /// Clear the encoder state to make it ready for a new round of decoding.
     fn reset(&mut self) -> ArrayRef;
@@ -43,14 +43,14 @@ pub trait DictEncoder: Send {
     fn codes_ptype(&self) -> PType;
 }
 
-pub fn dict_encoder(array: &dyn Array, constraints: &DictConstraints) -> Box<dyn DictEncoder> {
-    let dict_builder: Box<dyn DictEncoder> = if let Some(pa) = array.as_opt::<PrimitiveVTable>() {
+pub fn dict_encoder(array: &ArrayRef, constraints: &DictConstraints) -> Box<dyn DictEncoder> {
+    let dict_builder: Box<dyn DictEncoder> = if let Some(pa) = array.as_opt::<Primitive>() {
         match_each_native_ptype!(pa.ptype(), |P| {
             primitive_dict_builder::<P>(pa.dtype().nullability(), constraints)
         })
-    } else if let Some(vbv) = array.as_opt::<VarBinViewVTable>() {
+    } else if let Some(vbv) = array.as_opt::<VarBinView>() {
         bytes_dict_builder(vbv.dtype().clone(), constraints)
-    } else if let Some(vb) = array.as_opt::<VarBinVTable>() {
+    } else if let Some(vb) = array.as_opt::<VarBin>() {
         bytes_dict_builder(vb.dtype().clone(), constraints)
     } else {
         vortex_panic!("Can only encode primitive or varbin/view arrays")
@@ -62,7 +62,7 @@ pub fn dict_encoder(array: &dyn Array, constraints: &DictConstraints) -> Box<dyn
 ///
 /// Vortex encoders must always produce unsigned integer codes; signed codes are only accepted for external compatibility.
 pub fn dict_encode_with_constraints(
-    array: &dyn Array,
+    array: &ArrayRef,
     constraints: &DictConstraints,
 ) -> VortexResult<DictArray> {
     let mut encoder = dict_encoder(array, constraints);
@@ -78,7 +78,7 @@ pub fn dict_encode_with_constraints(
     }
 }
 
-pub fn dict_encode(array: &dyn Array) -> VortexResult<DictArray> {
+pub fn dict_encode(array: &ArrayRef) -> VortexResult<DictArray> {
     let dict_array = dict_encode_with_constraints(array, &UNCONSTRAINED)?;
     if dict_array.len() != array.len() {
         vortex_bail!(
diff --git a/vortex-array/src/builders/dict/primitive.rs b/vortex-array/src/builders/dict/primitive.rs
index 2d415b0bd0a..9f41e462734 100644
--- a/vortex-array/src/builders/dict/primitive.rs
+++ b/vortex-array/src/builders/dict/primitive.rs
@@ -13,13 +13,12 @@ use vortex_utils::aliases::hash_map::HashMap;
 
 use super::DictConstraints;
 use super::DictEncoder;
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::ToCanonical;
 use crate::accessor::ArrayAccessor;
-use crate::arrays::NativeValue;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::primitive::NativeValue;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
@@ -79,7 +78,6 @@ where
         }
     }
 
-    #[inline]
     fn encode_value(&mut self, v: Option<T>) -> Option<Code> {
         match self.lookup.entry(v.map(NativeValue)) {
             Entry::Occupied(o) => Some(*o.get()),
@@ -124,7 +122,7 @@ where
     NativeValue<T>: Hash + Eq,
     Code: UnsignedPType,
 {
-    fn encode(&mut self, array: &dyn Array) -> ArrayRef {
+    fn encode(&mut self, array: &ArrayRef) -> ArrayRef {
         let mut codes = BufferMut::<Code>::with_capacity(array.len());
 
         array.to_primitive().with_iterator(|it| {
@@ -158,16 +156,16 @@ mod test {
     use itertools::Itertools;
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray as _;
-    use crate::arrays::PrimitiveArray;
+    use crate::arrays::dict::DictArraySlotsExt;
     use crate::assert_arrays_eq;
     use crate::builders::dict::dict_encode;
+    use crate::builders::dict::primitive::PrimitiveArray;
 
     #[test]
     fn encode_primitive() {
         let arr = buffer![1, 1, 3, 3, 3].into_array();
-        let dict = dict_encode(arr.as_ref()).unwrap();
+        let dict = dict_encode(&arr).unwrap();
 
         let expected_codes = buffer![0u8, 0, 1, 1, 1].into_array();
         assert_arrays_eq!(dict.codes(), expected_codes);
@@ -188,7 +186,7 @@ mod test {
             Some(3),
             None,
         ]);
-        let dict = dict_encode(arr.as_ref()).unwrap();
+        let dict = dict_encode(&arr.into_array()).unwrap();
 
         let expected_codes = buffer![0u8, 0, 1, 2, 2, 1, 2, 1].into_array();
         assert_arrays_eq!(dict.codes(), expected_codes);
diff --git a/vortex-array/src/builders/extension.rs b/vortex-array/src/builders/extension.rs
index 6adbb00940a..ae540c1a6c2 100644
--- a/vortex-array/src/builders/extension.rs
+++ b/vortex-array/src/builders/extension.rs
@@ -7,10 +7,10 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::ExtensionArray;
+use crate::arrays::extension::ExtensionArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::builder_with_capacity;
@@ -98,9 +98,9 @@ impl ArrayBuilder for ExtensionBuilder {
         self.append_value(scalar.as_extension())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let ext_array = array.to_extension();
-        self.storage.extend_from_array(ext_array.storage())
+        self.storage.extend_from_array(ext_array.storage_array())
     }
 
     fn reserve_exact(&mut self, capacity: usize) {
diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs
index 70023d22655..f26281d5363 100644
--- a/vortex-array/src/builders/fixed_size_list.rs
+++ b/vortex-array/src/builders/fixed_size_list.rs
@@ -11,10 +11,10 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::FixedSizeListArray;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::LazyBitBufferBuilder;
@@ -80,7 +80,7 @@ impl FixedSizeListBuilder {
     ///
     /// Note that the list entry will be non-null but the elements themselves are allowed to be null
     /// (only if the elements [`DType`] is nullable, of course).
-    pub fn append_array_as_list(&mut self, array: &dyn Array) -> VortexResult<()> {
+    pub fn append_array_as_list(&mut self, array: &ArrayRef) -> VortexResult<()> {
         vortex_ensure!(
             array.dtype() == self.element_dtype(),
             "Array dtype {:?} does not match list element dtype {:?}",
@@ -234,7 +234,7 @@ impl ArrayBuilder for FixedSizeListBuilder {
 
     /// This will increase the capacity if extending with this `array` would go past the original
     /// capacity.
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let fsl = array.to_fixed_size_list();
         if fsl.is_empty() {
             return;
@@ -273,21 +273,21 @@ mod tests {
     use std::sync::Arc;
 
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
     use super::FixedSizeListBuilder;
     use crate::IntoArray as _;
     use crate::ToCanonical;
-    use crate::array::Array;
-    use crate::arrays::FixedSizeListArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
     use crate::builders::ArrayBuilder;
+    use crate::builders::fixed_size_list::FixedSizeListArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::NonNullable;
     use crate::dtype::Nullability::Nullable;
     use crate::dtype::PType::I32;
     use crate::scalar::Scalar;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_empty() {
@@ -301,12 +301,13 @@ mod tests {
     #[test]
     fn test_values() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0);
 
         builder
             .append_value(
                 Scalar::fixed_size_list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![1i32.into(), 2i32.into(), 3i32.into()],
                     NonNullable,
                 )
@@ -337,12 +338,14 @@ mod tests {
     fn test_degenerate_size_zero_non_nullable() {
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
-            FixedSizeListBuilder::with_capacity(dtype.clone(), 0, NonNullable, 10000000);
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 0, NonNullable, 10000000);
 
         // Append multiple "empty" lists.
         for _ in 0..100 {
             builder
-                .append_value(Scalar::fixed_size_list(dtype.clone(), vec![], NonNullable).as_list())
+                .append_value(
+                    Scalar::fixed_size_list(Arc::clone(&dtype), vec![], NonNullable).as_list(),
+                )
                 .unwrap();
         }
 
@@ -359,14 +362,15 @@ mod tests {
     fn test_degenerate_size_zero_nullable() {
         // 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(dtype.clone(), 0, Nullable, 10000000);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 0, Nullable, 10000000);
 
         // Mix of null and non-null empty lists.
         for i in 0..100 {
             if i % 2 == 0 {
                 builder
                     .append_value(
-                        Scalar::fixed_size_list(dtype.clone(), vec![], Nullable).as_list(),
+                        Scalar::fixed_size_list(Arc::clone(&dtype), vec![], Nullable).as_list(),
                     )
                     .unwrap();
             } else {
@@ -386,14 +390,15 @@ mod tests {
     fn test_capacity_growth() {
         let dtype: Arc<DType> = Arc::new(I32.into());
         // Start with capacity 0.
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, NonNullable, 0);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, NonNullable, 0);
 
         // Add more items than initial capacity.
         for i in 0..5 {
             builder
                 .append_value(
                     Scalar::fixed_size_list(
-                        dtype.clone(),
+                        Arc::clone(&dtype),
                         vec![(i * 2).into(), (i * 2 + 1).into()],
                         NonNullable,
                     )
@@ -426,12 +431,16 @@ mod tests {
     #[test]
     fn test_nullable_lists_non_nullable_elements() {
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, NonNullable));
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, Nullable, 0);
+        let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
 
         builder
             .append_value(
-                Scalar::fixed_size_list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable)
-                    .as_list(),
+                Scalar::fixed_size_list(
+                    Arc::clone(&dtype),
+                    vec![1i32.into(), 2i32.into()],
+                    Nullable,
+                )
+                .as_list(),
             )
             .unwrap();
 
@@ -447,20 +456,39 @@ mod tests {
         assert_eq!(fsl.len(), 3);
 
         let fsl_array = fsl.to_fixed_size_list();
-        assert!(fsl_array.validity().is_valid(0).unwrap());
-        assert!(!fsl_array.validity().is_valid(1).unwrap());
-        assert!(fsl_array.validity().is_valid(2).unwrap());
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
     }
 
     #[test]
     fn test_non_nullable_lists_nullable_elements() {
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0);
 
         builder
             .append_value(
                 Scalar::fixed_size_list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![
                         Scalar::primitive(1i32, Nullable),
                         Scalar::null(dtype.as_ref().clone()),
@@ -532,7 +560,13 @@ mod tests {
 
         // Check that all lists are null.
         for i in 0..3 {
-            assert!(!fsl_array.validity().is_valid(i).unwrap());
+            assert!(
+                !fsl_array
+                    .validity()
+                    .vortex_expect("fixed-size-list validity should be derivable")
+                    .is_valid(i)
+                    .unwrap()
+            );
         }
     }
 
@@ -555,7 +589,13 @@ mod tests {
         assert_eq!(fsl_array.list_size(), 2);
 
         // Check that all lists are null.
-        assert!(!fsl_array.validity().is_valid(0).unwrap());
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
     }
 
     #[test]
@@ -578,7 +618,8 @@ mod tests {
     #[test]
     fn test_invalid_size_error() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0);
 
         // Try to append a list with wrong size.
         let result = builder.append_value(
@@ -624,12 +665,48 @@ mod tests {
         assert_eq!(fsl_array.elements().len(), 12);
 
         // Check validity pattern is repeated.
-        assert!(fsl_array.validity().is_valid(0).unwrap());
-        assert!(!fsl_array.validity().is_valid(1).unwrap());
-        assert!(fsl_array.validity().is_valid(2).unwrap());
-        assert!(fsl_array.validity().is_valid(3).unwrap());
-        assert!(!fsl_array.validity().is_valid(4).unwrap());
-        assert!(fsl_array.validity().is_valid(5).unwrap());
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(3)
+                .unwrap()
+        );
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(4)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(5)
+                .unwrap()
+        );
     }
 
     #[test]
@@ -664,11 +741,41 @@ mod tests {
         assert_eq!(fsl_array.elements().len(), 0);
 
         // Check validity pattern.
-        assert!(fsl_array.validity().is_valid(0).unwrap());
-        assert!(!fsl_array.validity().is_valid(1).unwrap());
-        assert!(fsl_array.validity().is_valid(2).unwrap());
-        assert!(!fsl_array.validity().is_valid(3).unwrap());
-        assert!(fsl_array.validity().is_valid(4).unwrap());
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(3)
+                .unwrap()
+        );
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(4)
+                .unwrap()
+        );
     }
 
     #[test]
@@ -683,7 +790,8 @@ mod tests {
             0,
         );
 
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 0);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 0);
 
         // Add some initial data.
         builder
@@ -708,7 +816,7 @@ mod tests {
     fn test_mixed_operations() {
         // 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(dtype.clone(), 2, Nullable, 0);
+        let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
 
         // Mix of operations.
         builder
@@ -744,27 +852,63 @@ mod tests {
         assert_eq!(fsl_array.elements().len(), 12);
 
         // Check validity.
-        assert!(fsl_array.validity().is_valid(0).unwrap()); // append_value
-        assert!(!fsl_array.validity().is_valid(1).unwrap()); // append_null
-        assert!(fsl_array.validity().is_valid(2).unwrap()); // append_zeros
-        assert!(fsl_array.validity().is_valid(3).unwrap()); // append_zeros
-        assert!(!fsl_array.validity().is_valid(4).unwrap()); // append_nulls
-        assert!(fsl_array.validity().is_valid(5).unwrap()); // extend_from_array
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        ); // append_value
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        ); // append_null
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        ); // append_zeros
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(3)
+                .unwrap()
+        ); // append_zeros
+        assert!(
+            !fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(4)
+                .unwrap()
+        ); // append_nulls
+        assert!(
+            fsl_array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(5)
+                .unwrap()
+        ); // extend_from_array
     }
 
     #[test]
     fn test_append_scalar() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 2, Nullable, 10);
+        let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 10);
 
         // Test appending a valid fixed-size list.
         let list_scalar1 =
-            Scalar::fixed_size_list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable);
+            Scalar::fixed_size_list(Arc::clone(&dtype), vec![1i32.into(), 2i32.into()], Nullable);
         builder.append_scalar(&list_scalar1).unwrap();
 
         // Test appending another list.
         let list_scalar2 =
-            Scalar::fixed_size_list(dtype.clone(), vec![3i32.into(), 4i32.into()], Nullable);
+            Scalar::fixed_size_list(Arc::clone(&dtype), vec![3i32.into(), 4i32.into()], Nullable);
         builder.append_scalar(&list_scalar2).unwrap();
 
         // Test appending null via builder method (since fixed-size list null handling is special).
@@ -792,9 +936,27 @@ mod tests {
         }
 
         // Check validity - first two should be valid, third should be null.
-        assert!(array.validity().is_valid(0).unwrap());
-        assert!(array.validity().is_valid(1).unwrap());
-        assert!(!array.validity().is_valid(2).unwrap());
+        assert!(
+            array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            !array
+                .validity()
+                .vortex_expect("fixed-size-list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
 
         // Test wrong dtype error.
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, NonNullable, 10);
@@ -805,7 +967,8 @@ mod tests {
     #[test]
     fn test_append_array_as_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 10);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 10);
 
         // Append a primitive array as a single list entry.
         let arr1 = buffer![1i32, 2, 3].into_array();
@@ -815,7 +978,7 @@ mod tests {
         builder
             .append_value(
                 Scalar::fixed_size_list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![10i32.into(), 11i32.into(), 12i32.into()],
                     NonNullable,
                 )
@@ -831,7 +994,7 @@ mod tests {
         builder
             .append_value(
                 Scalar::fixed_size_list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![20i32.into(), 21i32.into(), 22i32.into()],
                     NonNullable,
                 )
@@ -851,7 +1014,8 @@ mod tests {
         );
 
         // Test dtype mismatch error.
-        let mut builder = FixedSizeListBuilder::with_capacity(dtype.clone(), 3, NonNullable, 10);
+        let mut builder =
+            FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 10);
         let wrong_dtype_arr = buffer![1i64, 2, 3].into_array();
         assert!(builder.append_array_as_list(&wrong_dtype_arr).is_err());
 
diff --git a/vortex-array/src/builders/lazy_null_builder.rs b/vortex-array/src/builders/lazy_null_builder.rs
index 63a092f5dc0..9ca4b28b484 100644
--- a/vortex-array/src/builders/lazy_null_builder.rs
+++ b/vortex-array/src/builders/lazy_null_builder.rs
@@ -134,7 +134,6 @@ impl LazyBitBufferBuilder {
         }
     }
 
-    #[inline]
     fn materialize_if_needed(&mut self) {
         if self.inner.is_none() {
             self.materialize()
diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs
index 56e48f7acef..5eb6d12223b 100644
--- a/vortex-array/src/builders/list.rs
+++ b/vortex-array/src/builders/list.rs
@@ -11,10 +11,11 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::Canonical;
 use crate::IntoArray;
 use crate::arrays::ListArray;
+use crate::arrays::listview::ListViewArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::LazyBitBufferBuilder;
@@ -91,7 +92,7 @@ impl<O: IntegerPType> ListBuilder<O> {
     ///
     /// Note that the list entry will be non-null but the elements themselves are allowed to be null
     /// (only if the elements [`DType`] in nullable, of course).
-    pub fn append_array_as_list(&mut self, array: &dyn Array) -> VortexResult<()> {
+    pub fn append_array_as_list(&mut self, array: &ArrayRef) -> VortexResult<()> {
         vortex_ensure!(
             array.dtype() == self.element_dtype(),
             "Array dtype {:?} does not match list element dtype {:?}",
@@ -213,7 +214,7 @@ impl<O: IntegerPType> ArrayBuilder for ListBuilder<O> {
         self.append_value(scalar.as_list())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let list = array.to_listview();
         if list.is_empty() {
             return;
@@ -298,6 +299,10 @@ impl<O: IntegerPType> ArrayBuilder for ListBuilder<O> {
     fn finish(&mut self) -> ArrayRef {
         self.finish_into_list().into_array()
     }
+
+    fn finish_into_canonical(&mut self) -> Canonical {
+        Canonical::List(self.finish_into_list().into_array().to_listview())
+    }
 }
 
 #[cfg(test)]
@@ -307,23 +312,26 @@ mod tests {
     use Nullability::NonNullable;
     use Nullability::Nullable;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
     use crate::ToCanonical;
-    use crate::array::Array;
     use crate::arrays::ChunkedArray;
-    use crate::arrays::ListArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::list::ListArrayExt;
+    use crate::arrays::listview::ListViewArrayExt;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
+    use crate::builders::list::ListArray;
     use crate::builders::list::ListBuilder;
     use crate::dtype::DType;
     use crate::dtype::IntegerPType;
     use crate::dtype::Nullability;
     use crate::dtype::PType::I32;
+    use crate::executor::VortexSessionExecute;
     use crate::scalar::Scalar;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_empty() {
@@ -337,12 +345,12 @@ mod tests {
     #[test]
     fn test_values() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListBuilder::<u32>::with_capacity(dtype.clone(), NonNullable, 0, 0);
+        let mut builder = ListBuilder::<u32>::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0);
 
         builder
             .append_value(
                 Scalar::list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![1i32.into(), 2i32.into(), 3i32.into()],
                     NonNullable,
                 )
@@ -373,7 +381,7 @@ mod tests {
     #[test]
     fn test_append_empty_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListBuilder::<u32>::with_capacity(dtype.clone(), NonNullable, 0, 0);
+        let mut builder = ListBuilder::<u32>::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0);
 
         assert!(
             builder
@@ -385,12 +393,12 @@ mod tests {
     #[test]
     fn test_nullable_values() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListBuilder::<u32>::with_capacity(dtype.clone(), Nullable, 0, 0);
+        let mut builder = ListBuilder::<u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
 
         builder
             .append_value(
                 Scalar::list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![1i32.into(), 2i32.into(), 3i32.into()],
                     NonNullable,
                 )
@@ -399,7 +407,7 @@ mod tests {
             .unwrap();
 
         builder
-            .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list())
+            .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list())
             .unwrap();
 
         builder
@@ -431,8 +439,9 @@ mod tests {
         .unwrap();
         assert_eq!(list.len(), 3);
 
-        let mut builder = ListBuilder::<O>::with_capacity(Arc::new(I32.into()), Nullable, 18, 9);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
 
+        let mut builder = ListBuilder::<O>::with_capacity(Arc::new(I32.into()), Nullable, 18, 9);
         builder.extend_from_array(&list);
         builder.extend_from_array(&list);
         builder.extend_from_array(&list.slice(0..0).unwrap());
@@ -460,7 +469,18 @@ mod tests {
 
         assert_arrays_eq!(actual.offsets(), expected.offsets());
 
-        assert_eq!(actual.validity(), expected.validity())
+        assert!(
+            actual
+                .validity()
+                .vortex_expect("list validity should be derivable")
+                .mask_eq(
+                    &expected
+                        .validity()
+                        .vortex_expect("list validity should be derivable"),
+                    &mut ctx,
+                )
+                .unwrap(),
+        );
     }
 
     #[test]
@@ -500,7 +520,7 @@ mod tests {
             DType::List(Arc::new(DType::Primitive(I32, NonNullable)), NonNullable),
         );
 
-        let canon_values = chunked_list.unwrap().to_listview();
+        let canon_values = chunked_list.unwrap().as_array().to_listview();
 
         assert_eq!(
             one_trailing_unused_element.scalar_at(0).unwrap(),
@@ -515,22 +535,23 @@ mod tests {
     #[test]
     fn test_append_scalar() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListBuilder::<u64>::with_capacity(dtype.clone(), Nullable, 20, 10);
+        let mut builder = ListBuilder::<u64>::with_capacity(Arc::clone(&dtype), Nullable, 20, 10);
 
         // Test appending a valid list.
-        let list_scalar1 = Scalar::list(dtype.clone(), vec![1i32.into(), 2i32.into()], Nullable);
+        let list_scalar1 =
+            Scalar::list(Arc::clone(&dtype), vec![1i32.into(), 2i32.into()], Nullable);
         builder.append_scalar(&list_scalar1).unwrap();
 
         // Test appending another list.
         let list_scalar2 = Scalar::list(
-            dtype.clone(),
+            Arc::clone(&dtype),
             vec![3i32.into(), 4i32.into(), 5i32.into()],
             Nullable,
         );
         builder.append_scalar(&list_scalar2).unwrap();
 
         // Test appending null value.
-        let null_scalar = Scalar::null(DType::List(dtype.clone(), Nullable));
+        let null_scalar = Scalar::null(DType::List(Arc::clone(&dtype), Nullable));
         builder.append_scalar(&null_scalar).unwrap();
 
         let array = builder.finish_into_list();
@@ -560,9 +581,27 @@ mod tests {
         assert!(list2.is_null()); // This should be null.
 
         // Check validity.
-        assert!(array.validity().is_valid(0).unwrap());
-        assert!(array.validity().is_valid(1).unwrap());
-        assert!(!array.validity().is_valid(2).unwrap());
+        assert!(
+            array
+                .validity()
+                .vortex_expect("list validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            array
+                .validity()
+                .vortex_expect("list validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            !array
+                .validity()
+                .vortex_expect("list validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
 
         // Test wrong dtype error.
         let mut builder = ListBuilder::<u64>::with_capacity(dtype, NonNullable, 20, 10);
@@ -573,7 +612,8 @@ mod tests {
     #[test]
     fn test_append_array_as_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListBuilder::<u32>::with_capacity(dtype.clone(), NonNullable, 20, 10);
+        let mut builder =
+            ListBuilder::<u32>::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10);
 
         // Append a primitive array as a single list entry.
         let arr1 = buffer![1i32, 2, 3].into_array();
@@ -582,8 +622,12 @@ mod tests {
         // Interleave with a list scalar.
         builder
             .append_value(
-                Scalar::list(dtype.clone(), vec![10i32.into(), 11i32.into()], NonNullable)
-                    .as_list(),
+                Scalar::list(
+                    Arc::clone(&dtype),
+                    vec![10i32.into(), 11i32.into()],
+                    NonNullable,
+                )
+                .as_list(),
             )
             .unwrap();
 
@@ -597,7 +641,7 @@ mod tests {
 
         // Interleave with another list scalar (empty list).
         builder
-            .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list())
+            .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list())
             .unwrap();
 
         let list = builder.finish_into_list();
diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs
index 89fc1e36ef7..b339dc430f7 100644
--- a/vortex-array/src/builders/listview.rs
+++ b/vortex-array/src/builders/listview.rs
@@ -18,14 +18,14 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
+use crate::ArrayRef;
 use crate::Canonical;
 use crate::ToCanonical;
-use crate::array::Array;
-use crate::array::ArrayRef;
 use crate::array::IntoArray;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewRebuildMode;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::listview::ListViewRebuildMode;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::PrimitiveBuilder;
@@ -116,7 +116,7 @@ impl<O: IntegerPType, S: IntegerPType> ListViewBuilder<O, S> {
     ///
     /// Note that the list entry will be non-null but the elements themselves are allowed to be null
     /// (only if the elements [`DType`] is nullable, of course).
-    pub fn append_array_as_list(&mut self, array: &dyn Array) -> VortexResult<()> {
+    pub fn append_array_as_list(&mut self, array: &ArrayRef) -> VortexResult<()> {
         vortex_ensure!(
             array.dtype() == self.element_dtype(),
             "Array dtype {:?} does not match list element dtype {:?}",
@@ -290,7 +290,7 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
         self.append_value(list_scalar)
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let listview = array.to_listview();
         if listview.is_empty() {
             return;
@@ -339,12 +339,12 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
         // The incoming sizes might have a different type than the builder, so we need to cast.
         let cast_sizes = listview
             .sizes()
-            .to_array()
+            .clone()
             .cast(self.sizes_builder.dtype().clone())
             .vortex_expect(
                 "was somehow unable to cast the new sizes to the type of the builder sizes",
             );
-        self.sizes_builder.extend_from_array(cast_sizes.as_ref());
+        self.sizes_builder.extend_from_array(&cast_sizes);
 
         // Now we need to adjust all of the offsets by adding the current number of elements in the
         // builder.
@@ -429,19 +429,20 @@ fn adjust_and_extend_offsets<'a, O: IntegerPType, A: IntegerPType>(
 mod tests {
     use std::sync::Arc;
 
+    use vortex_error::VortexExpect;
+
     use super::ListViewBuilder;
     use crate::IntoArray;
-    use crate::array::Array;
     use crate::arrays::ListArray;
-    use crate::arrays::PrimitiveArray;
+    use crate::arrays::listview::ListViewArrayExt;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
+    use crate::builders::listview::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::NonNullable;
     use crate::dtype::Nullability::Nullable;
     use crate::dtype::PType::I32;
     use crate::scalar::Scalar;
-    use crate::vtable::ValidityHelper;
 
     #[test]
     fn test_empty() {
@@ -455,13 +456,14 @@ mod tests {
     #[test]
     fn test_basic_append_and_nulls() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), Nullable, 0, 0);
+        let mut builder =
+            ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
 
         // Append a regular list.
         builder
             .append_value(
                 Scalar::list(
-                    dtype.clone(),
+                    Arc::clone(&dtype),
                     vec![1i32.into(), 2i32.into(), 3i32.into()],
                     NonNullable,
                 )
@@ -471,7 +473,7 @@ mod tests {
 
         // Append an empty list.
         builder
-            .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list())
+            .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list())
             .unwrap();
 
         // Append a null list.
@@ -497,7 +499,13 @@ mod tests {
         assert_eq!(listview.list_elements_at(1).unwrap().len(), 0);
 
         // Check null list.
-        assert!(!listview.validity().is_valid(2).unwrap());
+        assert!(
+            !listview
+                .validity()
+                .vortex_expect("listview validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
 
         // Check last list: [4, 5].
         assert_arrays_eq!(
@@ -511,11 +519,16 @@ mod tests {
         // Test u32 offsets with u8 sizes.
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
-            ListViewBuilder::<u32, u8>::with_capacity(dtype.clone(), NonNullable, 0, 0);
+            ListViewBuilder::<u32, u8>::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0);
 
         builder
             .append_value(
-                Scalar::list(dtype.clone(), vec![1i32.into(), 2i32.into()], NonNullable).as_list(),
+                Scalar::list(
+                    Arc::clone(&dtype),
+                    vec![1i32.into(), 2i32.into()],
+                    NonNullable,
+                )
+                .as_list(),
             )
             .unwrap();
 
@@ -548,12 +561,12 @@ mod tests {
         // Test u64 offsets with u16 sizes.
         let dtype2: Arc<DType> = Arc::new(I32.into());
         let mut builder2 =
-            ListViewBuilder::<u64, u16>::with_capacity(dtype2.clone(), NonNullable, 0, 0);
+            ListViewBuilder::<u64, u16>::with_capacity(Arc::clone(&dtype2), NonNullable, 0, 0);
 
         for i in 0..5 {
             builder2
                 .append_value(
-                    Scalar::list(dtype2.clone(), vec![(i * 10).into()], NonNullable).as_list(),
+                    Scalar::list(Arc::clone(&dtype2), vec![(i * 10).into()], NonNullable).as_list(),
                 )
                 .unwrap();
         }
@@ -573,7 +586,8 @@ mod tests {
     #[test]
     fn test_builder_trait_methods() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut builder = ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), Nullable, 0, 0);
+        let mut builder =
+            ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
 
         // Test append_zeros (creates empty lists).
         builder.append_zeros(2);
@@ -598,8 +612,20 @@ mod tests {
         assert_eq!(listview.list_elements_at(1).unwrap().len(), 0);
 
         // Next two are nulls.
-        assert!(!listview.validity().is_valid(2).unwrap());
-        assert!(!listview.validity().is_valid(3).unwrap());
+        assert!(
+            !listview
+                .validity()
+                .vortex_expect("listview validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
+        assert!(
+            !listview
+                .validity()
+                .vortex_expect("listview validity should be derivable")
+                .is_valid(3)
+                .unwrap()
+        );
 
         // Last is the regular list: [10, 20].
         assert_arrays_eq!(
@@ -619,7 +645,8 @@ mod tests {
         )
         .unwrap();
 
-        let mut builder = ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), Nullable, 0, 0);
+        let mut builder =
+            ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
 
         // Add initial data.
         builder
@@ -654,7 +681,13 @@ mod tests {
         );
 
         // Third list: null (from source).
-        assert!(!listview.validity().is_valid(2).unwrap());
+        assert!(
+            !listview
+                .validity()
+                .vortex_expect("listview validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
 
         // Fourth list: [4, 5] (from source).
         assert_arrays_eq!(
@@ -667,7 +700,7 @@ mod tests {
     fn test_error_append_null_to_non_nullable() {
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
-            ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), NonNullable, 0, 0);
+            ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), NonNullable, 0, 0);
 
         // Create a null list with nullable type (since Scalar::null requires nullable type).
         let null_scalar = Scalar::null(DType::List(dtype, Nullable));
@@ -690,7 +723,7 @@ mod tests {
 
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
-            ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), NonNullable, 20, 10);
+            ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10);
 
         // Append a primitive array as a single list entry.
         let arr1 = buffer![1i32, 2, 3].into_array();
@@ -699,8 +732,12 @@ mod tests {
         // Interleave with a list scalar.
         builder
             .append_value(
-                Scalar::list(dtype.clone(), vec![10i32.into(), 11i32.into()], NonNullable)
-                    .as_list(),
+                Scalar::list(
+                    Arc::clone(&dtype),
+                    vec![10i32.into(), 11i32.into()],
+                    NonNullable,
+                )
+                .as_list(),
             )
             .unwrap();
 
@@ -714,7 +751,7 @@ mod tests {
 
         // Interleave with another list scalar.
         builder
-            .append_value(Scalar::list_empty(dtype.clone(), NonNullable).as_list())
+            .append_value(Scalar::list_empty(Arc::clone(&dtype), NonNullable).as_list())
             .unwrap();
 
         let listview = builder.finish_into_listview();
diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs
index edfb0baff5a..72c6f286e42 100644
--- a/vortex-array/src/builders/mod.rs
+++ b/vortex-array/src/builders/mod.rs
@@ -29,18 +29,18 @@
 //! ```
 
 use std::any::Any;
+use std::sync::Arc;
 
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::canonical::Canonical;
 use crate::dtype::DType;
 use crate::match_each_decimal_value_type;
 use crate::match_each_native_ptype;
+use crate::memory::HostAllocatorRef;
 use crate::scalar::Scalar;
 
 mod lazy_null_builder;
@@ -157,12 +157,12 @@ pub trait ArrayBuilder: Send {
     ///
     /// The array that must have an equal [`DType`] to the array builder's `DType` (with nullability
     /// superset semantics).
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array);
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef);
 
     /// Extends the array with the provided array, canonicalizing if necessary.
     ///
-    /// Implementors must validate that the passed in [`Array`] has the correct [`DType`].
-    fn extend_from_array(&mut self, array: &dyn Array) {
+    /// Implementors must validate that the passed in [`ArrayRef`] has the correct [`DType`].
+    fn extend_from_array(&mut self, array: &ArrayRef) {
         if !self.dtype().eq_with_nullability_superset(array.dtype()) {
             vortex_panic!(
                 "tried to extend a builder with `DType` {} with an array with `DType {}",
@@ -211,12 +211,8 @@ pub trait ArrayBuilder: Send {
     ///
     /// This method provides a default implementation that creates an [`ArrayRef`] via `finish` and
     /// then converts it to canonical form. Specific builders can override this with optimized
-    /// implementations that avoid the intermediate [`Array`] creation.
-    fn finish_into_canonical(&mut self) -> Canonical {
-        self.finish()
-            .to_canonical()
-            .vortex_expect("finish_into_canonical failed")
-    }
+    /// implementations that avoid the intermediate [`ArrayRef`] creation.
+    fn finish_into_canonical(&mut self) -> Canonical;
 }
 
 /// Construct a new canonical builder for the given [`DType`].
@@ -275,16 +271,35 @@ pub fn builder_with_capacity(dtype: &DType, capacity: usize) -> Box<dyn ArrayBui
             capacity,
         )),
         DType::List(dtype, n) => Box::new(ListViewBuilder::<u64, u64>::with_capacity(
-            dtype.clone(),
+            Arc::clone(dtype),
             *n,
             2 * capacity, // Arbitrarily choose 2 times the `offsets` capacity here.
             capacity,
         )),
-        DType::FixedSizeList(elem_dtype, list_size, null) => Box::new(
-            FixedSizeListBuilder::with_capacity(elem_dtype.clone(), *list_size, *null, capacity),
-        ),
+        DType::FixedSizeList(elem_dtype, list_size, null) => {
+            Box::new(FixedSizeListBuilder::with_capacity(
+                Arc::clone(elem_dtype),
+                *list_size,
+                *null,
+                capacity,
+            ))
+        }
         DType::Extension(ext_dtype) => {
             Box::new(ExtensionBuilder::with_capacity(ext_dtype.clone(), capacity))
         }
+        DType::Variant(_) => {
+            unimplemented!()
+        }
     }
 }
+
+/// Construct a new canonical builder for the given [`DType`] using a host
+/// [`crate::memory::HostAllocator`].
+pub fn builder_with_capacity_in(
+    allocator: HostAllocatorRef,
+    dtype: &DType,
+    capacity: usize,
+) -> Box<dyn ArrayBuilder> {
+    let _allocator = allocator;
+    builder_with_capacity(dtype, capacity)
+}
diff --git a/vortex-array/src/builders/null.rs b/vortex-array/src/builders/null.rs
index 31c73189aa8..45b6e7ed974 100644
--- a/vortex-array/src/builders/null.rs
+++ b/vortex-array/src/builders/null.rs
@@ -7,7 +7,6 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::NullArray;
@@ -70,7 +69,7 @@ impl ArrayBuilder for NullBuilder {
         Ok(())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         self.append_nulls(array.len());
     }
 
diff --git a/vortex-array/src/builders/primitive.rs b/vortex-array/src/builders/primitive.rs
index 517fed04af9..8321c03500c 100644
--- a/vortex-array/src/builders/primitive.rs
+++ b/vortex-array/src/builders/primitive.rs
@@ -10,7 +10,6 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::PrimitiveArray;
@@ -52,11 +51,22 @@ impl<T: NativePType> PrimitiveBuilder<T> {
         self.nulls.append_non_null();
     }
 
+    /// Appends `n` copies of `value` as non-null entries, directly writing into the buffer.
+    pub fn append_n_values(&mut self, value: T, n: usize) {
+        self.values.push_n(value, n);
+        self.nulls.append_n_non_nulls(n);
+    }
+
     /// Returns the raw primitive values in this builder as a slice.
     pub fn values(&self) -> &[T] {
         self.values.as_ref()
     }
 
+    /// Returns the raw primitive values in this builder as a mutable slice.
+    pub fn values_mut(&mut self) -> &mut [T] {
+        self.values.as_mut()
+    }
+
     /// Create a new handle to the next `len` uninitialized values in the builder.
     ///
     /// All reads/writes through the handle to the values buffer or the validity buffer will operate
@@ -164,7 +174,7 @@ impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
         Ok(())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let array = array.to_primitive();
 
         // This should be checked in `extend_from_array` but we can check it again.
@@ -175,11 +185,8 @@ impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
         );
 
         self.values.extend_from_slice(array.as_slice::<T>());
-        self.nulls.append_validity_mask(
-            array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked"),
-        );
+        self.nulls
+            .append_validity_mask(array.validity_mask().vortex_expect("validity_mask"));
     }
 
     fn reserve_exact(&mut self, additional: usize) {
@@ -348,6 +355,8 @@ impl<T> UninitRange<'_, T> {
 
 #[cfg(test)]
 mod tests {
+    use vortex_error::VortexExpect;
+
     use super::*;
     use crate::assert_arrays_eq;
 
@@ -609,10 +618,27 @@ mod tests {
         // values[2] might be any value since it's null.
 
         // Check validity - first two should be valid, third should be null.
-        use crate::vtable::ValidityHelper;
-        assert!(array.validity().is_valid(0).unwrap());
-        assert!(array.validity().is_valid(1).unwrap());
-        assert!(!array.validity().is_valid(2).unwrap());
+        assert!(
+            array
+                .validity()
+                .vortex_expect("primitive validity should be derivable")
+                .is_valid(0)
+                .unwrap()
+        );
+        assert!(
+            array
+                .validity()
+                .vortex_expect("primitive validity should be derivable")
+                .is_valid(1)
+                .unwrap()
+        );
+        assert!(
+            !array
+                .validity()
+                .vortex_expect("primitive validity should be derivable")
+                .is_valid(2)
+                .unwrap()
+        );
 
         // Test wrong dtype error.
         let mut builder = PrimitiveBuilder::<i32>::with_capacity(Nullability::NonNullable, 10);
diff --git a/vortex-array/src/builders/struct_.rs b/vortex-array/src/builders/struct_.rs
index 91b24e95efc..87f7ecb5e88 100644
--- a/vortex-array/src/builders/struct_.rs
+++ b/vortex-array/src/builders/struct_.rs
@@ -11,10 +11,10 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::StructArray;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::DEFAULT_BUILDER_CAPACITY;
 use crate::builders::LazyBitBufferBuilder;
@@ -165,22 +165,18 @@ impl ArrayBuilder for StructBuilder {
         self.append_value(scalar.as_struct())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let array = array.to_struct();
 
         for (a, builder) in array
-            .unmasked_fields()
-            .iter()
+            .iter_unmasked_fields()
             .zip_eq(self.builders.iter_mut())
         {
-            builder.extend_from_array(a.as_ref());
+            builder.extend_from_array(a);
         }
 
-        self.nulls.append_validity_mask(
-            array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked"),
-        );
+        self.nulls
+            .append_validity_mask(array.validity_mask().vortex_expect("validity_mask"));
     }
 
     fn reserve_exact(&mut self, capacity: usize) {
@@ -208,10 +204,10 @@ impl ArrayBuilder for StructBuilder {
 mod tests {
     use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::StructArray;
     use crate::arrays::VarBinArray;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
+    use crate::builders::struct_::StructArray;
     use crate::builders::struct_::StructBuilder;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
diff --git a/vortex-array/src/builders/tests.rs b/vortex-array/src/builders/tests.rs
index ec46ca8879d..1a738954058 100644
--- a/vortex-array/src/builders/tests.rs
+++ b/vortex-array/src/builders/tests.rs
@@ -608,7 +608,7 @@ fn create_test_scalars_for_dtype(dtype: &DType, count: usize) -> Vec<Scalar> {
                         _ => Scalar::default_value(element_dtype.as_ref()),
                     })
                     .collect();
-                Scalar::list(element_dtype.clone(), elements, *n)
+                Scalar::list(Arc::clone(element_dtype), elements, *n)
             }
             DType::FixedSizeList(element_dtype, size, n) => {
                 // Create fixed-size list scalars.
@@ -620,7 +620,7 @@ fn create_test_scalars_for_dtype(dtype: &DType, count: usize) -> Vec<Scalar> {
                         _ => Scalar::default_value(element_dtype.as_ref()),
                     })
                     .collect();
-                Scalar::fixed_size_list(element_dtype.clone(), elements, *n)
+                Scalar::fixed_size_list(Arc::clone(element_dtype), elements, *n)
             }
             DType::Extension(ext_dtype) => {
                 // Create extension scalars with storage values.
@@ -630,6 +630,7 @@ fn create_test_scalars_for_dtype(dtype: &DType, count: usize) -> Vec<Scalar> {
                 };
                 Scalar::extension_ref(ext_dtype.clone(), storage_scalar)
             }
+            DType::Variant(_) => continue,
         };
         scalars.push(scalar);
     }
diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs
index 568635374ce..294ac5cd551 100644
--- a/vortex-array/src/builders/varbinview.rs
+++ b/vortex-array/src/builders/varbinview.rs
@@ -18,12 +18,11 @@ use vortex_mask::Mask;
 use vortex_utils::aliases::hash_map::Entry;
 use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::arrays::BinaryView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::compact::BufferUtilization;
+use crate::arrays::varbinview::build_views::BinaryView;
+use crate::arrays::varbinview::compact::BufferUtilization;
 use crate::builders::ArrayBuilder;
 use crate::builders::LazyBitBufferBuilder;
 use crate::canonical::Canonical;
@@ -108,6 +107,22 @@ impl VarBinViewBuilder {
         self.nulls.append_non_null();
     }
 
+    /// Appends `n` copies of `value` as non-null entries.
+    pub fn append_n_values<S: AsRef<[u8]>>(&mut self, value: S, n: usize) {
+        if n == 0 {
+            return;
+        }
+        let bytes = value.as_ref();
+        let view = if bytes.len() <= BinaryView::MAX_INLINED_SIZE {
+            BinaryView::make_view(bytes, 0, 0)
+        } else {
+            let (buffer_idx, offset) = self.append_value_to_buffer(bytes);
+            BinaryView::make_view(bytes, buffer_idx, offset)
+        };
+        self.views_builder.push_n(view, n);
+        self.nulls.append_n_non_nulls(n);
+    }
+
     fn flush_in_progress(&mut self) {
         if self.in_progress.is_empty() {
             return;
@@ -127,7 +142,10 @@ impl VarBinViewBuilder {
 
     /// append a non inlined value to self.in_progress.
     fn append_value_to_buffer(&mut self, value: &[u8]) -> (u32, u32) {
-        assert!(value.len() > 12, "must inline small strings");
+        assert!(
+            value.len() > BinaryView::MAX_INLINED_SIZE,
+            "must inline small strings"
+        );
         let required_cap = self.in_progress.len() + value.len();
         if self.in_progress.capacity() < required_cap {
             self.flush_in_progress();
@@ -147,6 +165,12 @@ impl VarBinViewBuilder {
         self.completed.len()
     }
 
+    /// Returns true if a non-empty in-progress buffer is staged (and would
+    /// become a completed buffer on the next flush), false otherwise.
+    pub fn in_progress(&self) -> bool {
+        !self.in_progress.is_empty()
+    }
+
     /// Pushes buffers and pre-adjusted views into the builder.
     ///
     /// The provided `buffers` contain sections of data from a `VarBinViewArray`, and the
@@ -267,15 +291,11 @@ impl ArrayBuilder for VarBinViewBuilder {
         Ok(())
     }
 
-    unsafe fn extend_from_array_unchecked(&mut self, array: &dyn Array) {
+    unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
         let array = array.to_varbinview();
         self.flush_in_progress();
 
-        self.push_only_validity_mask(
-            array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked"),
-        );
+        self.push_only_validity_mask(array.validity_mask().vortex_expect("validity_mask"));
 
         let view_adjustment =
             self.completed
@@ -291,33 +311,32 @@ impl ArrayBuilder for VarBinViewBuilder {
                     .iter()
                     .map(|view| adjustment.adjust_view(view)),
             ),
-            ViewAdjustment::Rewriting(adjustment) => match array
-                .validity_mask()
-                .vortex_expect("validity_mask in extend_from_array_unchecked")
-            {
-                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);
+            ViewAdjustment::Rewriting(adjustment) => {
+                match array.validity_mask().vortex_expect("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());
-                }
-                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);
+                        }
                     }
                 }
-            },
+            }
         }
     }
 
@@ -341,7 +360,6 @@ impl ArrayBuilder for VarBinViewBuilder {
 }
 
 impl VarBinViewBuilder {
-    #[inline]
     fn push_view(
         &mut self,
         view: BinaryView,
@@ -584,7 +602,7 @@ impl BuffersWithOffsets {
             return Self::AllKept {
                 buffers: Arc::from(
                     array
-                        .buffers()
+                        .data_buffers()
                         .to_vec()
                         .into_iter()
                         .map(|b| b.unwrap_host())
@@ -607,20 +625,19 @@ impl BuffersWithOffsets {
             }
         }
 
-        let buffers_with_offsets_iter =
-            buffer_utilizations
-                .iter()
-                .zip(array.buffers().iter())
-                .map(|(utilization, buffer)| {
-                    match compaction_strategy(utilization, compaction_threshold) {
-                        CompactionStrategy::KeepFull => (Some(buffer.as_host().clone()), 0),
-                        CompactionStrategy::Slice { start, end } => (
-                            Some(buffer.as_host().slice(start as usize..end as usize)),
-                            start,
-                        ),
-                        CompactionStrategy::Rewrite => (None, 0),
-                    }
-                });
+        let buffers_with_offsets_iter = buffer_utilizations
+            .iter()
+            .zip(array.data_buffers().iter())
+            .map(|(utilization, buffer)| {
+                match compaction_strategy(utilization, compaction_threshold) {
+                    CompactionStrategy::KeepFull => (Some(buffer.as_host().clone()), 0),
+                    CompactionStrategy::Slice { start, end } => (
+                        Some(buffer.as_host().slice(start as usize..end as usize)),
+                        start,
+                    ),
+                    CompactionStrategy::Rewrite => (None, 0),
+                }
+            });
 
         match (has_rewrite, has_nonzero_offset) {
             // keep all buffers
@@ -734,7 +751,6 @@ enum PrecomputedViewAdjustment {
 }
 
 impl PrecomputedViewAdjustment {
-    #[inline]
     fn adjust_view(&self, view: &BinaryView) -> BinaryView {
         if view.is_inlined() {
             return *view;
@@ -818,10 +834,10 @@ mod tests {
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
-    use crate::arrays::VarBinViewArray;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::builders::VarBinViewBuilder;
+    use crate::builders::varbinview::VarBinViewArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
 
@@ -890,7 +906,7 @@ mod tests {
             builder.finish_into_varbinview()
         };
 
-        assert_eq!(array.buffers().len(), 1);
+        assert_eq!(array.data_buffers().len(), 1);
         let mut builder =
             VarBinViewBuilder::with_buffer_deduplication(DType::Utf8(Nullability::Nullable), 10);
 
diff --git a/vortex-array/src/builtins.rs b/vortex-array/src/builtins.rs
index 0a6aef9a405..b4a3eb23984 100644
--- a/vortex-array/src/builtins.rs
+++ b/vortex-array/src/builtins.rs
@@ -10,14 +10,11 @@
 //! the equivalent Arrow compute function.
 
 use vortex_error::VortexResult;
-use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
 use crate::expr::Expression;
@@ -63,8 +60,8 @@ pub trait ExprBuiltins: Sized {
     /// Check if a list contains a value.
     fn list_contains(&self, value: Expression) -> VortexResult<Expression>;
 
-    /// Conditional selection: `result[i] = if mask[i] then self[i] else if_false[i]`.
-    fn zip(&self, if_false: Expression, mask: Expression) -> VortexResult<Expression>;
+    /// 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>;
 
     /// Apply a binary operator to this expression and another.
     fn binary(&self, rhs: Expression, op: Operator) -> VortexResult<Expression>;
@@ -99,8 +96,8 @@ impl ExprBuiltins for Expression {
         ListContains.try_new_expr(EmptyOptions, [self.clone(), value])
     }
 
-    fn zip(&self, if_false: Expression, mask: Expression) -> VortexResult<Expression> {
-        Zip.try_new_expr(EmptyOptions, [self.clone(), if_false, mask])
+    fn zip(&self, if_true: Expression, if_false: Expression) -> VortexResult<Expression> {
+        Zip.try_new_expr(EmptyOptions, [if_true, if_false, self.clone()])
     }
 
     fn binary(&self, rhs: Expression, op: Operator) -> VortexResult<Expression> {
@@ -129,8 +126,8 @@ pub trait ArrayBuiltins: Sized {
     /// Boolean negation.
     fn not(&self) -> VortexResult<ArrayRef>;
 
-    /// Conditional selection: `result[i] = if mask[i] then self[i] else if_false[i]`.
-    fn zip(&self, if_false: ArrayRef, mask: ArrayRef) -> VortexResult<ArrayRef>;
+    /// 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>;
 
     /// Check if a list contains a value.
     fn list_contains(&self, value: ArrayRef) -> VortexResult<ArrayRef>;
@@ -157,13 +154,17 @@ impl ArrayBuiltins for ArrayRef {
     }
 
     fn fill_null(&self, fill_value: impl Into<Scalar>) -> VortexResult<ArrayRef> {
+        let fill_value = fill_value.into();
+        if !self.dtype().is_nullable() {
+            return self.cast(fill_value.dtype().clone());
+        }
         FillNull
             .try_new_array(
                 self.len(),
                 EmptyOptions,
                 [
                     self.clone(),
-                    ConstantArray::new(fill_value.into(), self.len()).into_array(),
+                    ConstantArray::new(fill_value, self.len()).into_array(),
                 ],
             )?
             .optimize()
@@ -191,11 +192,8 @@ impl ArrayBuiltins for ArrayRef {
             .optimize()
     }
 
-    fn zip(&self, if_false: ArrayRef, mask: ArrayRef) -> VortexResult<ArrayRef> {
-        let scalar_fn =
-            Zip.try_new_array(self.len(), EmptyOptions, [self.clone(), if_false, mask])?;
-        let mut ctx = ExecutionCtx::new(VortexSession::empty());
-        scalar_fn.execute::<ArrayRef>(&mut ctx)
+    fn zip(&self, if_true: ArrayRef, if_false: ArrayRef) -> VortexResult<ArrayRef> {
+        Zip.try_new_array(self.len(), EmptyOptions, [if_true, if_false, self.clone()])
     }
 
     fn list_contains(&self, value: ArrayRef) -> VortexResult<ArrayRef> {
diff --git a/vortex-array/src/canonical.rs b/vortex-array/src/canonical.rs
index ce91ff2532c..ffae20f09c8 100644
--- a/vortex-array/src/canonical.rs
+++ b/vortex-array/src/canonical.rs
@@ -5,52 +5,61 @@
 
 use std::sync::Arc;
 
+use vortex_buffer::BitBuffer;
 use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::Columnar;
 use crate::Executable;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::child_to_validity;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolArrayParts;
-use crate::arrays::BoolVTable;
+use crate::arrays::Decimal;
 use crate::arrays::DecimalArray;
-use crate::arrays::DecimalArrayParts;
-use crate::arrays::DecimalVTable;
+use crate::arrays::Extension;
 use crate::arrays::ExtensionArray;
-use crate::arrays::ExtensionVTable;
+use crate::arrays::FixedSizeList;
 use crate::arrays::FixedSizeListArray;
-use crate::arrays::FixedSizeListVTable;
+use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
-use crate::arrays::ListViewArrayParts;
-use crate::arrays::ListViewRebuildMode;
-use crate::arrays::ListViewVTable;
+use crate::arrays::Null;
 use crate::arrays::NullArray;
-use crate::arrays::NullVTable;
+use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::PrimitiveArrayParts;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::Struct;
 use crate::arrays::StructArray;
-use crate::arrays::StructArrayParts;
-use crate::arrays::StructVTable;
+use crate::arrays::VarBinView;
 use crate::arrays::VarBinViewArray;
-use crate::arrays::VarBinViewArrayParts;
-use crate::arrays::VarBinViewVTable;
-use crate::arrays::constant_canonicalize;
-use crate::builders::builder_with_capacity;
+use crate::arrays::Variant;
+use crate::arrays::VariantArray;
+use crate::arrays::bool::BoolDataParts;
+use crate::arrays::decimal::DecimalDataParts;
+use crate::arrays::extension::ExtensionArrayExt;
+use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
+use crate::arrays::listview::ListViewDataParts;
+use crate::arrays::listview::ListViewRebuildMode;
+use crate::arrays::primitive::PrimitiveDataParts;
+use crate::arrays::struct_::StructDataParts;
+use crate::arrays::varbinview::VarBinViewDataParts;
+use crate::arrays::variant::VariantArrayExt;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::match_each_decimal_value_type;
+use crate::match_each_native_ptype;
 use crate::matcher::Matcher;
+use crate::validity::Validity;
 
 /// An enum capturing the default uncompressed encodings for each [Vortex type](DType).
 ///
-/// Any array can be decoded into canonical form via the [`to_canonical`](Array::to_canonical)
+/// Any array can be decoded into canonical form via the `to_canonical`
 /// trait method. This is the simplest encoding for a type, and will not be compressed but may
 /// contain compressed child arrays.
 ///
@@ -119,6 +128,7 @@ pub enum Canonical {
     FixedSizeList(FixedSizeListArray),
     Struct(StructArray),
     Extension(ExtensionArray),
+    Variant(VariantArray),
 }
 
 /// Match on every canonical variant and evaluate a code block on all variants
@@ -133,16 +143,96 @@ macro_rules! match_each_canonical {
             Canonical::List($ident) => $eval,
             Canonical::FixedSizeList($ident) => $eval,
             Canonical::Struct($ident) => $eval,
+            Canonical::Variant($ident) => $eval,
             Canonical::Extension($ident) => $eval,
         }
     }};
 }
 
 impl Canonical {
-    // TODO(connor): This can probably be specialized for each of the canonical arrays.
     /// Create an empty canonical array of the given dtype.
     pub fn empty(dtype: &DType) -> Canonical {
-        builder_with_capacity(dtype, 0).finish_into_canonical()
+        match dtype {
+            DType::Null => Canonical::Null(NullArray::new(0)),
+            DType::Bool(n) => Canonical::Bool(unsafe {
+                BoolArray::new_unchecked(BitBuffer::empty(), Validity::from(n))
+            }),
+            DType::Primitive(ptype, n) => {
+                match_each_native_ptype!(ptype, |P| {
+                    Canonical::Primitive(unsafe {
+                        PrimitiveArray::new_unchecked(Buffer::<P>::empty(), Validity::from(n))
+                    })
+                })
+            }
+            DType::Decimal(decimal_type, n) => {
+                match_each_decimal_value_type!(
+                    DecimalType::smallest_decimal_value_type(decimal_type),
+                    |D| {
+                        Canonical::Decimal(unsafe {
+                            DecimalArray::new_unchecked::<D>(
+                                Buffer::empty(),
+                                *decimal_type,
+                                Validity::from(n),
+                            )
+                        })
+                    }
+                )
+            }
+            DType::Utf8(n) => Canonical::VarBinView(unsafe {
+                VarBinViewArray::new_unchecked(
+                    Buffer::empty(),
+                    Arc::new([]),
+                    dtype.clone(),
+                    Validity::from(n),
+                )
+            }),
+            DType::Binary(n) => Canonical::VarBinView(unsafe {
+                VarBinViewArray::new_unchecked(
+                    Buffer::empty(),
+                    Arc::new([]),
+                    dtype.clone(),
+                    Validity::from(n),
+                )
+            }),
+            DType::Struct(struct_dtype, n) => Canonical::Struct(unsafe {
+                StructArray::new_unchecked(
+                    struct_dtype
+                        .fields()
+                        .map(|f| Canonical::empty(&f).into_array())
+                        .collect::<Arc<[_]>>(),
+                    struct_dtype.clone(),
+                    0,
+                    Validity::from(n),
+                )
+            }),
+            DType::List(dtype, n) => Canonical::List(unsafe {
+                ListViewArray::new_unchecked(
+                    Canonical::empty(dtype).into_array(),
+                    Canonical::empty(&DType::Primitive(PType::U8, Nullability::NonNullable))
+                        .into_array(),
+                    Canonical::empty(&DType::Primitive(PType::U8, Nullability::NonNullable))
+                        .into_array(),
+                    Validity::from(n),
+                )
+                // An empty list view is trivially copyable to a list.
+                .with_zero_copy_to_list(true)
+            }),
+            DType::FixedSizeList(elem_dtype, list_size, null) => Canonical::FixedSizeList(unsafe {
+                FixedSizeListArray::new_unchecked(
+                    Canonical::empty(elem_dtype).into_array(),
+                    *list_size,
+                    Validity::from(null),
+                    0,
+                )
+            }),
+            DType::Extension(ext_dtype) => Canonical::Extension(ExtensionArray::new(
+                ext_dtype.clone(),
+                Canonical::empty(ext_dtype.storage_dtype()).into_array(),
+            )),
+            DType::Variant(_) => {
+                vortex_panic!(InvalidArgument: "Canonical empty is not supported for Variant")
+            }
+        }
     }
 
     pub fn len(&self) -> usize {
@@ -324,12 +414,6 @@ impl Canonical {
     }
 }
 
-impl AsRef<dyn Array> for Canonical {
-    fn as_ref(&self) -> &(dyn Array + 'static) {
-        match_each_canonical!(self, |arr| arr.as_ref())
-    }
-}
-
 impl IntoArray for Canonical {
     fn into_array(self) -> ArrayRef {
         match_each_canonical!(self, |arr| arr.into_array())
@@ -376,7 +460,7 @@ pub trait ToCanonical {
 }
 
 // Blanket impl for all Array encodings.
-impl<A: Array + ?Sized> ToCanonical for A {
+impl ToCanonical for ArrayRef {
     fn to_null(&self) -> NullArray {
         self.to_canonical()
             .vortex_expect("to_canonical failed")
@@ -438,28 +522,18 @@ impl From<Canonical> for ArrayRef {
     }
 }
 
-/// Recursively execute the array until it reaches canonical form.
+/// Execute into [`Canonical`] by running `execute_until` with the [`AnyCanonical`] matcher.
 ///
-/// Callers should prefer to execute into `Columnar` if they are able to optimize their use for
-/// constant arrays.
+/// Unlike executing into [`crate::Columnar`], this will fully expand constant arrays into their
+/// canonical form. Callers should prefer to execute into `Columnar` if they are able to optimize
+/// their use for constant arrays.
 impl Executable for Canonical {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        if let Some(canonical) = array.as_opt::<AnyCanonical>() {
-            return Ok(canonical.into());
-        }
-
-        // Invoke execute directly to avoid logging the call in the execution context.
-        Ok(match Columnar::execute(array.clone(), ctx)? {
-            Columnar::Canonical(c) => c,
-            Columnar::Constant(s) => {
-                let canonical = constant_canonicalize(&s)?;
-                canonical
-                    .as_ref()
-                    .statistics()
-                    .inherit_from(array.statistics());
-                canonical
-            }
-        })
+        let result = array.execute_until::<AnyCanonical>(ctx)?;
+        Ok(result
+            .as_opt::<AnyCanonical>()
+            .map(Canonical::from)
+            .vortex_expect("execute_until::<AnyCanonical> must return a canonical array"))
     }
 }
 
@@ -474,33 +548,30 @@ impl Executable for CanonicalValidity {
         match array.execute::<Canonical>(ctx)? {
             n @ Canonical::Null(_) => Ok(CanonicalValidity(n)),
             Canonical::Bool(b) => {
-                let BoolArrayParts {
-                    bits,
-                    offset,
-                    len,
-                    validity,
-                } = b.into_parts();
+                let validity = child_to_validity(&b.slots()[0], b.dtype().nullability());
+                let len = b.len();
+                let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
                 Ok(CanonicalValidity(Canonical::Bool(
                     BoolArray::try_new_from_handle(bits, offset, len, validity.execute(ctx)?)?,
                 )))
             }
             Canonical::Primitive(p) => {
-                let PrimitiveArrayParts {
+                let PrimitiveDataParts {
                     ptype,
                     buffer,
                     validity,
-                } = p.into_parts();
+                } = p.into_data_parts();
                 Ok(CanonicalValidity(Canonical::Primitive(unsafe {
                     PrimitiveArray::new_unchecked_from_handle(buffer, ptype, validity.execute(ctx)?)
                 })))
             }
             Canonical::Decimal(d) => {
-                let DecimalArrayParts {
+                let DecimalDataParts {
                     decimal_dtype,
                     values,
                     values_type,
                     validity,
-                } = d.into_parts();
+                } = d.into_data_parts();
                 Ok(CanonicalValidity(Canonical::Decimal(unsafe {
                     DecimalArray::new_unchecked_handle(
                         values,
@@ -511,12 +582,12 @@ impl Executable for CanonicalValidity {
                 })))
             }
             Canonical::VarBinView(vbv) => {
-                let VarBinViewArrayParts {
+                let VarBinViewDataParts {
                     dtype,
                     buffers,
                     views,
                     validity,
-                } = vbv.into_parts();
+                } = vbv.into_data_parts();
                 Ok(CanonicalValidity(Canonical::VarBinView(unsafe {
                     VarBinViewArray::new_handle_unchecked(
                         views,
@@ -527,32 +598,36 @@ impl Executable for CanonicalValidity {
                 })))
             }
             Canonical::List(l) => {
-                let ListViewArrayParts {
+                let zctl = l.is_zero_copy_to_list();
+                let ListViewDataParts {
                     elements,
                     offsets,
                     sizes,
                     validity,
                     ..
-                } = l.into_parts();
+                } = l.into_data_parts();
                 Ok(CanonicalValidity(Canonical::List(unsafe {
                     ListViewArray::new_unchecked(elements, offsets, sizes, validity.execute(ctx)?)
+                        .with_zero_copy_to_list(zctl)
                 })))
             }
             Canonical::FixedSizeList(fsl) => {
                 let list_size = fsl.list_size();
                 let len = fsl.len();
-                let (elements, validity, _) = fsl.into_parts();
+                let parts = fsl.into_data_parts();
+                let elements = parts.elements;
+                let validity = parts.validity;
                 Ok(CanonicalValidity(Canonical::FixedSizeList(
                     FixedSizeListArray::new(elements, list_size, validity.execute(ctx)?, len),
                 )))
             }
             Canonical::Struct(st) => {
                 let len = st.len();
-                let StructArrayParts {
+                let StructDataParts {
                     struct_fields,
                     fields,
                     validity,
-                } = st.into_parts();
+                } = st.into_data_parts();
                 Ok(CanonicalValidity(Canonical::Struct(unsafe {
                     StructArray::new_unchecked(fields, struct_fields, len, validity.execute(ctx)?)
                 })))
@@ -560,13 +635,23 @@ impl Executable for CanonicalValidity {
             Canonical::Extension(ext) => Ok(CanonicalValidity(Canonical::Extension(
                 ExtensionArray::new(
                     ext.ext_dtype().clone(),
-                    ext.storage()
+                    ext.storage_array()
                         .clone()
                         .execute::<CanonicalValidity>(ctx)?
                         .0
                         .into_array(),
                 ),
             ))),
+            Canonical::Variant(variant) => {
+                Ok(CanonicalValidity(Canonical::Variant(VariantArray::new(
+                    variant
+                        .child()
+                        .clone()
+                        .execute::<CanonicalValidity>(ctx)?
+                        .0
+                        .into_array(),
+                ))))
+            }
         }
     }
 }
@@ -582,33 +667,30 @@ impl Executable for RecursiveCanonical {
         match array.execute::<Canonical>(ctx)? {
             n @ Canonical::Null(_) => Ok(RecursiveCanonical(n)),
             Canonical::Bool(b) => {
-                let BoolArrayParts {
-                    bits,
-                    offset,
-                    len,
-                    validity,
-                } = b.into_parts();
+                let validity = child_to_validity(&b.slots()[0], b.dtype().nullability());
+                let len = b.len();
+                let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
                 Ok(RecursiveCanonical(Canonical::Bool(
                     BoolArray::try_new_from_handle(bits, offset, len, validity.execute(ctx)?)?,
                 )))
             }
             Canonical::Primitive(p) => {
-                let PrimitiveArrayParts {
+                let PrimitiveDataParts {
                     ptype,
                     buffer,
                     validity,
-                } = p.into_parts();
+                } = p.into_data_parts();
                 Ok(RecursiveCanonical(Canonical::Primitive(unsafe {
                     PrimitiveArray::new_unchecked_from_handle(buffer, ptype, validity.execute(ctx)?)
                 })))
             }
             Canonical::Decimal(d) => {
-                let DecimalArrayParts {
+                let DecimalDataParts {
                     decimal_dtype,
                     values,
                     values_type,
                     validity,
-                } = d.into_parts();
+                } = d.into_data_parts();
                 Ok(RecursiveCanonical(Canonical::Decimal(unsafe {
                     DecimalArray::new_unchecked_handle(
                         values,
@@ -619,12 +701,12 @@ impl Executable for RecursiveCanonical {
                 })))
             }
             Canonical::VarBinView(vbv) => {
-                let VarBinViewArrayParts {
+                let VarBinViewDataParts {
                     dtype,
                     buffers,
                     views,
                     validity,
-                } = vbv.into_parts();
+                } = vbv.into_data_parts();
                 Ok(RecursiveCanonical(Canonical::VarBinView(unsafe {
                     VarBinViewArray::new_handle_unchecked(
                         views,
@@ -635,13 +717,14 @@ impl Executable for RecursiveCanonical {
                 })))
             }
             Canonical::List(l) => {
-                let ListViewArrayParts {
+                let zctl = l.is_zero_copy_to_list();
+                let ListViewDataParts {
                     elements,
                     offsets,
                     sizes,
                     validity,
                     ..
-                } = l.into_parts();
+                } = l.into_data_parts();
                 Ok(RecursiveCanonical(Canonical::List(unsafe {
                     ListViewArray::new_unchecked(
                         elements.execute::<RecursiveCanonical>(ctx)?.0.into_array(),
@@ -649,12 +732,15 @@ impl Executable for RecursiveCanonical {
                         sizes.execute::<RecursiveCanonical>(ctx)?.0.into_array(),
                         validity.execute(ctx)?,
                     )
+                    .with_zero_copy_to_list(zctl)
                 })))
             }
             Canonical::FixedSizeList(fsl) => {
                 let list_size = fsl.list_size();
                 let len = fsl.len();
-                let (elements, validity, _) = fsl.into_parts();
+                let parts = fsl.into_data_parts();
+                let elements = parts.elements;
+                let validity = parts.validity;
                 Ok(RecursiveCanonical(Canonical::FixedSizeList(
                     FixedSizeListArray::new(
                         elements.execute::<RecursiveCanonical>(ctx)?.0.into_array(),
@@ -666,11 +752,11 @@ impl Executable for RecursiveCanonical {
             }
             Canonical::Struct(st) => {
                 let len = st.len();
-                let StructArrayParts {
+                let StructDataParts {
                     struct_fields,
                     fields,
                     validity,
-                } = st.into_parts();
+                } = st.into_data_parts();
                 let executed_fields = fields
                     .iter()
                     .map(|f| Ok(f.clone().execute::<RecursiveCanonical>(ctx)?.0.into_array()))
@@ -688,13 +774,23 @@ impl Executable for RecursiveCanonical {
             Canonical::Extension(ext) => Ok(RecursiveCanonical(Canonical::Extension(
                 ExtensionArray::new(
                     ext.ext_dtype().clone(),
-                    ext.storage()
+                    ext.storage_array()
                         .clone()
                         .execute::<RecursiveCanonical>(ctx)?
                         .0
                         .into_array(),
                 ),
             ))),
+            Canonical::Variant(variant) => {
+                Ok(RecursiveCanonical(Canonical::Variant(VariantArray::new(
+                    variant
+                        .child()
+                        .clone()
+                        .execute::<RecursiveCanonical>(ctx)?
+                        .0
+                        .into_array(),
+                ))))
+            }
         }
     }
 }
@@ -708,7 +804,10 @@ impl<T: NativePType> Executable for Buffer<T> {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
         let array = PrimitiveArray::execute(array, ctx)?;
         vortex_ensure!(
-            array.all_valid()?,
+            matches!(
+                array.validity()?,
+                Validity::NonNullable | Validity::AllValid
+            ),
             "Cannot execute to native buffer: array is not all-valid."
         );
         Ok(array.into_buffer())
@@ -720,7 +819,7 @@ impl<T: NativePType> Executable for Buffer<T> {
 /// This will panic if the array's dtype is not primitive.
 impl Executable for PrimitiveArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<PrimitiveVTable>() {
+        match array.try_downcast::<Primitive>() {
             Ok(primitive) => Ok(primitive),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_primitive()),
         }
@@ -732,19 +831,33 @@ impl Executable for PrimitiveArray {
 /// This will panic if the array's dtype is not bool.
 impl Executable for BoolArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<BoolVTable>() {
+        match array.try_downcast::<Bool>() {
             Ok(bool_array) => Ok(bool_array),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_bool()),
         }
     }
 }
 
+/// Execute the array to a [`BitBuffer`], aka a non-nullable  [`BoolArray`].
+///
+/// This will panic if the array's dtype is not non-nullable bool.
+impl Executable for BitBuffer {
+    fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
+        let bool = BoolArray::execute(array, ctx)?;
+        assert!(
+            !bool.dtype().is_nullable(),
+            "bit buffer execute only works with non-nullable bool arrays"
+        );
+        Ok(bool.into_bit_buffer())
+    }
+}
+
 /// Execute the array to canonical form and unwrap as a [`NullArray`].
 ///
 /// This will panic if the array's dtype is not null.
 impl Executable for NullArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<NullVTable>() {
+        match array.try_downcast::<Null>() {
             Ok(null_array) => Ok(null_array),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_null()),
         }
@@ -756,7 +869,7 @@ impl Executable for NullArray {
 /// This will panic if the array's dtype is not utf8 or binary.
 impl Executable for VarBinViewArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<VarBinViewVTable>() {
+        match array.try_downcast::<VarBinView>() {
             Ok(varbinview) => Ok(varbinview),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_varbinview()),
         }
@@ -768,7 +881,7 @@ impl Executable for VarBinViewArray {
 /// This will panic if the array's dtype is not an extension type.
 impl Executable for ExtensionArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<ExtensionVTable>() {
+        match array.try_downcast::<Extension>() {
             Ok(ext_array) => Ok(ext_array),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_extension()),
         }
@@ -780,7 +893,7 @@ impl Executable for ExtensionArray {
 /// This will panic if the array's dtype is not decimal.
 impl Executable for DecimalArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<DecimalVTable>() {
+        match array.try_downcast::<Decimal>() {
             Ok(decimal) => Ok(decimal),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_decimal()),
         }
@@ -792,7 +905,7 @@ impl Executable for DecimalArray {
 /// This will panic if the array's dtype is not list.
 impl Executable for ListViewArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<ListViewVTable>() {
+        match array.try_downcast::<ListView>() {
             Ok(list) => Ok(list),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_listview()),
         }
@@ -804,7 +917,7 @@ impl Executable for ListViewArray {
 /// This will panic if the array's dtype is not fixed size list.
 impl Executable for FixedSizeListArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<FixedSizeListVTable>() {
+        match array.try_downcast::<FixedSizeList>() {
             Ok(fsl) => Ok(fsl),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_fixed_size_list()),
         }
@@ -816,7 +929,7 @@ impl Executable for FixedSizeListArray {
 /// This will panic if the array's dtype is not struct.
 impl Executable for StructArray {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        match array.try_into::<StructVTable>() {
+        match array.try_downcast::<Struct>() {
             Ok(struct_array) => Ok(struct_array),
             Err(array) => Ok(Canonical::execute(array, ctx)?.into_struct()),
         }
@@ -824,47 +937,54 @@ impl Executable for StructArray {
 }
 
 /// A view into a canonical array type.
-#[derive(Debug, Clone)]
+///
+/// Uses `ArrayView<V>` because these are obtained by
+/// downcasting through the `Matcher` trait which returns `ArrayView<V>`.
+#[derive(Debug, Clone, Copy)]
 pub enum CanonicalView<'a> {
-    Null(&'a NullArray),
-    Bool(&'a BoolArray),
-    Primitive(&'a PrimitiveArray),
-    Decimal(&'a DecimalArray),
-    VarBinView(&'a VarBinViewArray),
-    List(&'a ListViewArray),
-    FixedSizeList(&'a FixedSizeListArray),
-    Struct(&'a StructArray),
-    Extension(&'a ExtensionArray),
+    Null(ArrayView<'a, Null>),
+    Bool(ArrayView<'a, Bool>),
+    Primitive(ArrayView<'a, Primitive>),
+    Decimal(ArrayView<'a, Decimal>),
+    VarBinView(ArrayView<'a, VarBinView>),
+    List(ArrayView<'a, ListView>),
+    FixedSizeList(ArrayView<'a, FixedSizeList>),
+    Struct(ArrayView<'a, Struct>),
+    Extension(ArrayView<'a, Extension>),
+    Variant(ArrayView<'a, Variant>),
 }
 
 impl From<CanonicalView<'_>> for Canonical {
     fn from(value: CanonicalView<'_>) -> Self {
         match value {
-            CanonicalView::Null(a) => Canonical::Null(a.clone()),
-            CanonicalView::Bool(a) => Canonical::Bool(a.clone()),
-            CanonicalView::Primitive(a) => Canonical::Primitive(a.clone()),
-            CanonicalView::Decimal(a) => Canonical::Decimal(a.clone()),
-            CanonicalView::VarBinView(a) => Canonical::VarBinView(a.clone()),
-            CanonicalView::List(a) => Canonical::List(a.clone()),
-            CanonicalView::FixedSizeList(a) => Canonical::FixedSizeList(a.clone()),
-            CanonicalView::Struct(a) => Canonical::Struct(a.clone()),
-            CanonicalView::Extension(a) => Canonical::Extension(a.clone()),
+            CanonicalView::Null(a) => Canonical::Null(a.into_owned()),
+            CanonicalView::Bool(a) => Canonical::Bool(a.into_owned()),
+            CanonicalView::Primitive(a) => Canonical::Primitive(a.into_owned()),
+            CanonicalView::Decimal(a) => Canonical::Decimal(a.into_owned()),
+            CanonicalView::VarBinView(a) => Canonical::VarBinView(a.into_owned()),
+            CanonicalView::List(a) => Canonical::List(a.into_owned()),
+            CanonicalView::FixedSizeList(a) => Canonical::FixedSizeList(a.into_owned()),
+            CanonicalView::Struct(a) => Canonical::Struct(a.into_owned()),
+            CanonicalView::Extension(a) => Canonical::Extension(a.into_owned()),
+            CanonicalView::Variant(a) => Canonical::Variant(a.into_owned()),
         }
     }
 }
 
-impl AsRef<dyn Array> for CanonicalView<'_> {
-    fn as_ref(&self) -> &dyn Array {
+impl CanonicalView<'_> {
+    /// Convert to a type-erased [`ArrayRef`].
+    pub fn to_array_ref(&self) -> ArrayRef {
         match self {
-            CanonicalView::Null(a) => a.as_ref(),
-            CanonicalView::Bool(a) => a.as_ref(),
-            CanonicalView::Primitive(a) => a.as_ref(),
-            CanonicalView::Decimal(a) => a.as_ref(),
-            CanonicalView::VarBinView(a) => a.as_ref(),
-            CanonicalView::List(a) => a.as_ref(),
-            CanonicalView::FixedSizeList(a) => a.as_ref(),
-            CanonicalView::Struct(a) => a.as_ref(),
-            CanonicalView::Extension(a) => a.as_ref(),
+            CanonicalView::Null(a) => a.array().clone(),
+            CanonicalView::Bool(a) => a.array().clone(),
+            CanonicalView::Primitive(a) => a.array().clone(),
+            CanonicalView::Decimal(a) => a.array().clone(),
+            CanonicalView::VarBinView(a) => a.array().clone(),
+            CanonicalView::List(a) => a.array().clone(),
+            CanonicalView::FixedSizeList(a) => a.array().clone(),
+            CanonicalView::Struct(a) => a.array().clone(),
+            CanonicalView::Extension(a) => a.array().clone(),
+            CanonicalView::Variant(a) => a.array().clone(),
         }
     }
 }
@@ -874,39 +994,41 @@ pub struct AnyCanonical;
 impl Matcher for AnyCanonical {
     type Match<'a> = CanonicalView<'a>;
 
-    fn matches(array: &dyn Array) -> bool {
-        array.is::<NullVTable>()
-            || array.is::<BoolVTable>()
-            || array.is::<PrimitiveVTable>()
-            || array.is::<DecimalVTable>()
-            || array.is::<StructVTable>()
-            || array.is::<ListViewVTable>()
-            || array.is::<FixedSizeListVTable>()
-            || array.is::<VarBinViewVTable>()
-            || array.is::<ExtensionVTable>()
+    fn matches(array: &ArrayRef) -> bool {
+        array.is::<Null>()
+            || array.is::<Bool>()
+            || array.is::<Primitive>()
+            || array.is::<Decimal>()
+            || array.is::<Struct>()
+            || array.is::<ListView>()
+            || array.is::<FixedSizeList>()
+            || array.is::<VarBinView>()
+            || array.is::<Variant>()
+            || array.is::<Extension>()
+            || array.is::<Variant>()
     }
 
-    fn try_match<'a>(array: &'a dyn Array) -> Option<Self::Match<'a>> {
-        if let Some(a) = array.as_opt::<NullVTable>() {
+    fn try_match<'a>(array: &'a ArrayRef) -> Option<Self::Match<'a>> {
+        if let Some(a) = array.as_opt::<Null>() {
             Some(CanonicalView::Null(a))
-        } else if let Some(a) = array.as_opt::<BoolVTable>() {
+        } else if let Some(a) = array.as_opt::<Bool>() {
             Some(CanonicalView::Bool(a))
-        } else if let Some(a) = array.as_opt::<PrimitiveVTable>() {
+        } else if let Some(a) = array.as_opt::<Primitive>() {
             Some(CanonicalView::Primitive(a))
-        } else if let Some(a) = array.as_opt::<DecimalVTable>() {
+        } else if let Some(a) = array.as_opt::<Decimal>() {
             Some(CanonicalView::Decimal(a))
-        } else if let Some(a) = array.as_opt::<StructVTable>() {
+        } else if let Some(a) = array.as_opt::<Struct>() {
             Some(CanonicalView::Struct(a))
-        } else if let Some(a) = array.as_opt::<ListViewVTable>() {
+        } else if let Some(a) = array.as_opt::<ListView>() {
             Some(CanonicalView::List(a))
-        } else if let Some(a) = array.as_opt::<FixedSizeListVTable>() {
+        } else if let Some(a) = array.as_opt::<FixedSizeList>() {
             Some(CanonicalView::FixedSizeList(a))
-        } else if let Some(a) = array.as_opt::<VarBinViewVTable>() {
+        } else if let Some(a) = array.as_opt::<VarBinView>() {
             Some(CanonicalView::VarBinView(a))
+        } else if let Some(a) = array.as_opt::<Variant>() {
+            Some(CanonicalView::Variant(a))
         } else {
-            array
-                .as_opt::<ExtensionVTable>()
-                .map(CanonicalView::Extension)
+            array.as_opt::<Extension>().map(CanonicalView::Extension)
         }
     }
 }
@@ -935,9 +1057,9 @@ mod test {
     use crate::ArrayRef;
     use crate::IntoArray;
     use crate::arrays::ConstantArray;
-    use crate::arrays::StructArray;
     use crate::arrow::FromArrowArray;
     use crate::arrow::IntoArrowArray;
+    use crate::canonical::StructArray;
 
     #[test]
     fn test_canonicalize_nested_struct() {
@@ -977,9 +1099,7 @@ mod test {
                 .is_some()
         );
 
-        let inner_struct = arrow_struct
-            .column(1)
-            .clone()
+        let inner_struct = Arc::clone(arrow_struct.column(1))
             .as_any()
             .downcast_ref::<ArrowStructArray>()
             .cloned()
diff --git a/vortex-array/src/columnar.rs b/vortex-array/src/columnar.rs
index 09746a67032..0f6d65dae2b 100644
--- a/vortex-array/src/columnar.rs
+++ b/vortex-array/src/columnar.rs
@@ -1,23 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::env::VarError;
-use std::sync::LazyLock;
-
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_panic;
 
 use crate::AnyCanonical;
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::CanonicalView;
 use crate::Executable;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::dtype::DType;
 use crate::matcher::Matcher;
 use crate::scalar::Scalar;
@@ -71,65 +67,34 @@ impl IntoArray for Columnar {
     }
 }
 
-/// Executing into a [`Columnar`] is implemented by repeatedly executing the array until we
-/// converge on either a constant or canonical.
-///
-/// For safety, we will error when the number of execution iterations reaches 128. We may want this
-/// to be configurable in the future in case of highly complex array trees, but in practice we
-/// don't expect to ever reach this limit.
+/// Execute into [`Columnar`] by running `execute_until` with the [`AnyColumnar`] matcher.
 impl Executable for Columnar {
-    fn execute(mut array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
-        static MAX_ITERATIONS: LazyLock<usize> =
-            LazyLock::new(|| match std::env::var("VORTEX_MAX_ITERATIONS") {
-                Ok(val) => val.parse::<usize>().unwrap_or_else(|e| {
-                    vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid usize: {e}")
-                }),
-                Err(VarError::NotPresent) => 128,
-                Err(VarError::NotUnicode(_)) => {
-                    vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid unicode string")
-                }
-            });
-
-        for _ in 0..*MAX_ITERATIONS {
-            // Check for termination conditions
-            if let Some(constant) = array.as_opt::<ConstantVTable>() {
-                ctx.log(format_args!("-> constant({})", constant.scalar()));
-                return Ok(Columnar::Constant(constant.clone()));
-            }
-            if let Some(canonical) = array.as_opt::<AnyCanonical>() {
-                ctx.log(format_args!("-> canonical {}", array));
-                return Ok(Columnar::Canonical(canonical.into()));
-            }
-
-            // Otherwise execute the array one step
-            array = array.execute(ctx)?;
+    fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self> {
+        let result = array.execute_until::<AnyColumnar>(ctx)?;
+        if let Some(constant) = result.as_opt::<Constant>() {
+            Ok(Columnar::Constant(constant.into_owned()))
+        } else {
+            Ok(Columnar::Canonical(
+                result
+                    .as_opt::<AnyCanonical>()
+                    .map(Canonical::from)
+                    .vortex_expect("execute_until::<AnyColumnar> must return a columnar array"),
+            ))
         }
-
-        // If we reach here, we exceeded the maximum number of iterations, so error.
-        vortex_bail!("Exceeded maximum execution iterations while executing to Columnar")
     }
 }
 
 pub enum ColumnarView<'a> {
     Canonical(CanonicalView<'a>),
-    Constant(&'a ConstantArray),
-}
-
-impl<'a> AsRef<dyn Array> for ColumnarView<'a> {
-    fn as_ref(&self) -> &dyn Array {
-        match self {
-            ColumnarView::Canonical(canonical) => canonical.as_ref(),
-            ColumnarView::Constant(constant) => constant.as_ref(),
-        }
-    }
+    Constant(ArrayView<'a, Constant>),
 }
 
 pub struct AnyColumnar;
 impl Matcher for AnyColumnar {
     type Match<'a> = ColumnarView<'a>;
 
-    fn try_match<'a>(array: &'a dyn Array) -> Option<Self::Match<'a>> {
-        if let Some(constant) = array.as_opt::<ConstantVTable>() {
+    fn try_match<'a>(array: &'a ArrayRef) -> Option<Self::Match<'a>> {
+        if let Some(constant) = array.as_opt::<Constant>() {
             Some(ColumnarView::Constant(constant))
         } else {
             array.as_opt::<AnyCanonical>().map(ColumnarView::Canonical)
diff --git a/vortex-array/src/compute/arbitrary.rs b/vortex-array/src/compute/arbitrary.rs
deleted file mode 100644
index c8c8d99cb6d..00000000000
--- a/vortex-array/src/compute/arbitrary.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use arbitrary::Arbitrary;
-use arbitrary::Unstructured;
-
-use crate::scalar_fn::fns::operators::CompareOperator;
-
-impl<'a> Arbitrary<'a> for CompareOperator {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(match u.int_in_range(0..=5)? {
-            0 => CompareOperator::Eq,
-            1 => CompareOperator::NotEq,
-            2 => CompareOperator::Gt,
-            3 => CompareOperator::Gte,
-            4 => CompareOperator::Lt,
-            5 => CompareOperator::Lte,
-            _ => unreachable!(),
-        })
-    }
-}
diff --git a/vortex-array/src/compute/boolean.rs b/vortex-array/src/compute/boolean.rs
deleted file mode 100644
index 254bf3bbffc..00000000000
--- a/vortex-array/src/compute/boolean.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::builtins::ArrayBuiltins;
-use crate::scalar_fn::fns::operators::Operator;
-
-/// Point-wise Kleene logical _and_ between two Boolean arrays.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn and_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::And)
-}
-
-/// Point-wise Kleene logical _or_ between two Boolean arrays.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn or_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Or)
-}
diff --git a/vortex-array/src/compute/cast.rs b/vortex-array/src/compute/cast.rs
deleted file mode 100644
index 54966fb1c9f..00000000000
--- a/vortex-array/src/compute/cast.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::ArrayRef;
-use crate::dtype::DType;
-
-/// Cast an array to the given data type.
-///
-/// Use [`crate::builtins::ArrayBuiltins::cast`] instead.
-#[deprecated(note = "Use `array.cast(dtype)` via `ArrayBuiltins` trait instead")]
-pub fn cast(array: &dyn super::Array, dtype: &DType) -> VortexResult<ArrayRef> {
-    use crate::builtins::ArrayBuiltins as _;
-    array.to_array().cast(dtype.clone())
-}
diff --git a/vortex-array/src/compute/compare.rs b/vortex-array/src/compute/compare.rs
deleted file mode 100644
index b0ecdfa3914..00000000000
--- a/vortex-array/src/compute/compare.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::cmp::Ordering;
-
-use arrow_array::BooleanArray;
-use arrow_buffer::NullBuffer;
-use arrow_ord::ord::make_comparator;
-use arrow_schema::SortOptions;
-use vortex_buffer::BitBuffer;
-use vortex_error::VortexResult;
-
-use crate::dtype::IntegerPType;
-use crate::scalar_fn::fns::operators::CompareOperator;
-
-/// Helper function to compare empty values with arrays that have external value length information
-/// like `VarBin`.
-pub fn compare_lengths_to_empty<P, I>(lengths: I, op: CompareOperator) -> BitBuffer
-where
-    P: IntegerPType,
-    I: Iterator<Item = P>,
-{
-    // All comparison can be expressed in terms of equality. "" is the absolute min of possible value.
-    let cmp_fn = match op {
-        CompareOperator::Eq | CompareOperator::Lte => |v| v == P::zero(),
-        CompareOperator::NotEq | CompareOperator::Gt => |v| v != P::zero(),
-        CompareOperator::Gte => |_| true,
-        CompareOperator::Lt => |_| false,
-    };
-
-    lengths.map(cmp_fn).collect()
-}
-
-/// Compare two Arrow arrays element-wise using [`make_comparator`].
-///
-/// This function is required for nested types (Struct, List, FixedSizeList) because Arrow's
-/// vectorized comparison kernels ([`cmp::eq`], [`cmp::neq`], etc.) do not support them.
-///
-/// The vectorized kernels are faster but only work on primitive types, so for non-nested types,
-/// prefer using the vectorized kernels directly for better performance.
-pub(crate) fn compare_nested_arrow_arrays(
-    lhs: &dyn arrow_array::Array,
-    rhs: &dyn arrow_array::Array,
-    operator: CompareOperator,
-) -> VortexResult<BooleanArray> {
-    let compare_arrays_at = make_comparator(lhs, rhs, SortOptions::default())?;
-
-    let cmp_fn = match operator {
-        CompareOperator::Eq => Ordering::is_eq,
-        CompareOperator::NotEq => Ordering::is_ne,
-        CompareOperator::Gt => Ordering::is_gt,
-        CompareOperator::Gte => Ordering::is_ge,
-        CompareOperator::Lt => Ordering::is_lt,
-        CompareOperator::Lte => Ordering::is_le,
-    };
-
-    let values = (0..lhs.len())
-        .map(|i| cmp_fn(compare_arrays_at(i, i)))
-        .collect();
-    let nulls = NullBuffer::union(lhs.nulls(), rhs.nulls());
-
-    Ok(BooleanArray::new(values, nulls))
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-
-    use super::*;
-
-    #[rstest]
-    #[case(CompareOperator::Eq, vec![false, false, false, true])]
-    #[case(CompareOperator::NotEq, vec![true, true, true, false])]
-    #[case(CompareOperator::Gt, vec![true, true, true, false])]
-    #[case(CompareOperator::Gte, vec![true, true, true, true])]
-    #[case(CompareOperator::Lt, vec![false, false, false, false])]
-    #[case(CompareOperator::Lte, vec![false, false, false, true])]
-    fn test_cmp_to_empty(#[case] op: CompareOperator, #[case] expected: Vec<bool>) {
-        let lengths: Vec<i32> = vec![1, 5, 7, 0];
-
-        let output = compare_lengths_to_empty(lengths.iter().copied(), op);
-        assert_eq!(Vec::from_iter(output.iter()), expected);
-    }
-}
diff --git a/vortex-array/src/compute/conformance/binary_numeric.rs b/vortex-array/src/compute/conformance/binary_numeric.rs
index 1be9ffa7af9..c36367746e7 100644
--- a/vortex-array/src/compute/conformance/binary_numeric.rs
+++ b/vortex-array/src/compute/conformance/binary_numeric.rs
@@ -18,10 +18,8 @@
 //!
 //! - Addition (`+`)
 //! - Subtraction (`-`)
-//! - Reverse Subtraction (scalar - array)
 //! - Multiplication (`*`)
 //! - Division (`/`)
-//! - Reverse Division (scalar / array)
 
 use itertools::Itertools;
 use num_traits::Num;
@@ -29,7 +27,6 @@ use vortex_error::VortexExpect;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
@@ -45,7 +42,7 @@ use crate::scalar::NumericOperator;
 use crate::scalar::PrimitiveScalar;
 use crate::scalar::Scalar;
 
-fn to_vec_of_scalar(array: &dyn Array) -> Vec<Scalar> {
+fn to_vec_of_scalar(array: &ArrayRef) -> Vec<Scalar> {
     // Not fast, but obviously correct
     (0..array.len())
         .map(|index| {
@@ -113,12 +110,12 @@ where
     ];
 
     for operator in operators {
-        let op = operator.into();
+        let op = operator;
         let rhs_const = ConstantArray::new(scalar_one.clone(), array.len()).into_array();
 
         // Test array operator scalar (e.g., array + 1)
         let result = array
-            .binary(rhs_const.clone(), op)
+            .binary(rhs_const.clone(), op.into())
             .vortex_expect("apply shouldn't fail")
             .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
             .map(|c| c.0.into_array());
@@ -129,9 +126,6 @@ where
             continue;
         };
 
-        println!("result {}", result.display_tree());
-        println!("result {}", result.display_values());
-
         let actual_values = to_vec_of_scalar(&result);
 
         // Check each element for overflow/underflow
@@ -139,7 +133,7 @@ where
             .iter()
             .map(|x| {
                 x.as_primitive()
-                    .checked_binary_numeric(&scalar_one.as_primitive(), operator)
+                    .checked_binary_numeric(&scalar_one.as_primitive(), op)
                     .map(<Scalar as From<PrimitiveScalar<'_>>>::from)
             })
             .collect();
@@ -160,7 +154,7 @@ where
         }
 
         // Test scalar operator array (e.g., 1 + array)
-        let result = rhs_const.binary(array.clone(), op).and_then(|a| {
+        let result = rhs_const.binary(array.clone(), op.into()).and_then(|a| {
             a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
                 .map(|c| c.0.into_array())
         });
@@ -178,7 +172,7 @@ where
             .map(|x| {
                 scalar_one
                     .as_primitive()
-                    .checked_binary_numeric(&x.as_primitive(), operator)
+                    .checked_binary_numeric(&x.as_primitive(), op)
                     .map(<Scalar as From<PrimitiveScalar<'_>>>::from)
             })
             .collect();
@@ -359,12 +353,12 @@ where
     };
 
     for operator in operators {
-        let op = operator.into();
+        let op = operator;
         let rhs_const = ConstantArray::new(scalar.clone(), array.len()).into_array();
 
         // Test array operator scalar
         let result = array
-            .binary(rhs_const, op)
+            .binary(rhs_const, op.into())
             .vortex_expect("apply failed")
             .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
             .map(|x| x.0.into_array());
@@ -383,7 +377,7 @@ where
             .iter()
             .map(|x| {
                 x.as_primitive()
-                    .checked_binary_numeric(&scalar.as_primitive(), operator)
+                    .checked_binary_numeric(&scalar.as_primitive(), op)
                     .map(<Scalar as From<PrimitiveScalar<'_>>>::from)
             })
             .collect();
diff --git a/vortex-array/src/compute/conformance/cast.rs b/vortex-array/src/compute/conformance/cast.rs
index 512d722780d..cab73acc521 100644
--- a/vortex-array/src/compute/conformance/cast.rs
+++ b/vortex-array/src/compute/conformance/cast.rs
@@ -5,12 +5,14 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
+use crate::RecursiveCanonical;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::min_max::MinMaxResult;
+use crate::aggregate_fn::fns::min_max::min_max;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::MinMaxResult;
-use crate::compute::min_max;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
@@ -18,7 +20,11 @@ use crate::scalar::Scalar;
 
 /// Cast and force execution via `to_canonical`, returning the canonical array.
 fn cast_and_execute(array: &ArrayRef, dtype: DType) -> VortexResult<ArrayRef> {
-    array.cast(dtype)?.to_canonical().map(|c| c.into_array())
+    Ok(array
+        .cast(dtype)?
+        .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+        .0
+        .into_array())
 }
 
 /// Test conformance of the cast compute function for an array.
@@ -30,7 +36,7 @@ fn cast_and_execute(array: &ArrayRef, dtype: DType) -> VortexResult<ArrayRef> {
 /// - Casting with nullability changes
 /// - Casting between string types (Utf8/Binary)
 /// - Edge cases like overflow behavior
-pub fn test_cast_conformance(array: &dyn Array) {
+pub fn test_cast_conformance(array: &ArrayRef) {
     let dtype = array.dtype();
 
     // Always test identity cast and nullability changes
@@ -57,9 +63,9 @@ pub fn test_cast_conformance(array: &dyn Array) {
     }
 }
 
-fn test_cast_identity(array: &dyn Array) {
+fn test_cast_identity(array: &ArrayRef) {
     // Casting to the same type should be a no-op
-    let result = cast_and_execute(&array.to_array(), array.dtype().clone())
+    let result = cast_and_execute(&array.clone(), array.dtype().clone())
         .vortex_expect("cast should succeed in conformance test");
     assert_eq!(result.len(), array.len());
     assert_eq!(result.dtype(), array.dtype());
@@ -77,9 +83,9 @@ fn test_cast_identity(array: &dyn Array) {
     }
 }
 
-fn test_cast_from_null(array: &dyn Array) {
+fn test_cast_from_null(array: &ArrayRef) {
     // Null can be cast to itself
-    let result = cast_and_execute(&array.to_array(), DType::Null)
+    let result = cast_and_execute(&array.clone(), DType::Null)
         .vortex_expect("cast should succeed in conformance test");
     assert_eq!(result.len(), array.len());
     assert_eq!(result.dtype(), &DType::Null);
@@ -94,7 +100,7 @@ fn test_cast_from_null(array: &dyn Array) {
     ];
 
     for dtype in nullable_types {
-        let result = cast_and_execute(&array.to_array(), dtype.clone())
+        let result = cast_and_execute(&array.clone(), dtype.clone())
             .vortex_expect("cast should succeed in conformance test");
         assert_eq!(result.len(), array.len());
         assert_eq!(result.dtype(), &dtype);
@@ -117,17 +123,17 @@ fn test_cast_from_null(array: &dyn Array) {
     ];
 
     for dtype in non_nullable_types {
-        assert!(cast_and_execute(&array.to_array(), dtype.clone()).is_err());
+        assert!(cast_and_execute(&array.clone(), dtype.clone()).is_err());
     }
 }
 
-fn test_cast_to_non_nullable(array: &dyn Array) {
+fn test_cast_to_non_nullable(array: &ArrayRef) {
     if array
         .invalid_count()
         .vortex_expect("invalid_count should succeed in conformance test")
         == 0
     {
-        let non_nullable = cast_and_execute(&array.to_array(), array.dtype().as_nonnullable())
+        let non_nullable = cast_and_execute(&array.clone(), array.dtype().as_nonnullable())
             .vortex_expect("arrays without nulls can cast to non-nullable");
         assert_eq!(non_nullable.dtype(), &array.dtype().as_nonnullable());
         assert_eq!(non_nullable.len(), array.len());
@@ -164,7 +170,7 @@ fn test_cast_to_non_nullable(array: &dyn Array) {
             // array can be casted to DType::Null.
             return;
         }
-        cast_and_execute(&array.to_array(), array.dtype().as_nonnullable())
+        cast_and_execute(&array.clone(), array.dtype().as_nonnullable())
             .err()
             .unwrap_or_else(|| {
                 vortex_panic!(
@@ -175,8 +181,8 @@ fn test_cast_to_non_nullable(array: &dyn Array) {
     }
 }
 
-fn test_cast_to_nullable(array: &dyn Array) {
-    let nullable = cast_and_execute(&array.to_array(), array.dtype().as_nullable())
+fn test_cast_to_nullable(array: &ArrayRef) {
+    let nullable = cast_and_execute(&array.clone(), array.dtype().as_nullable())
         .vortex_expect("arrays without nulls can cast to nullable");
     assert_eq!(nullable.dtype(), &array.dtype().as_nullable());
     assert_eq!(nullable.len(), array.len());
@@ -208,7 +214,7 @@ fn test_cast_to_nullable(array: &dyn Array) {
     }
 }
 
-fn test_cast_from_floating_point_types(array: &dyn Array) {
+fn test_cast_from_floating_point_types(array: &ArrayRef) {
     let ptype = array.as_primitive_typed().ptype();
     test_cast_to_primitive(array, PType::I8, false);
     test_cast_to_primitive(array, PType::U8, false);
@@ -223,7 +229,7 @@ fn test_cast_from_floating_point_types(array: &dyn Array) {
     test_cast_to_primitive(array, PType::F64, true);
 }
 
-fn test_cast_to_integral_types(array: &dyn Array) {
+fn test_cast_to_integral_types(array: &ArrayRef) {
     test_cast_to_primitive(array, PType::I8, true);
     test_cast_to_primitive(array, PType::U8, true);
     test_cast_to_primitive(array, PType::I16, true);
@@ -240,14 +246,16 @@ fn fits(value: &Scalar, ptype: PType) -> bool {
     value.cast(&dtype).is_ok()
 }
 
-fn test_cast_to_primitive(array: &dyn Array, target_ptype: PType, test_round_trip: bool) {
-    let maybe_min_max = min_max(array).vortex_expect("cast should succeed in conformance test");
+fn test_cast_to_primitive(array: &ArrayRef, target_ptype: PType, test_round_trip: bool) {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let maybe_min_max =
+        min_max(array, &mut ctx).vortex_expect("cast should succeed in conformance test");
 
     if let Some(MinMaxResult { min, max }) = maybe_min_max
         && (!fits(&min, target_ptype) || !fits(&max, target_ptype))
     {
         cast_and_execute(
-            &array.to_array(),
+            &array.clone(),
             DType::Primitive(target_ptype, array.dtype().nullability()),
         )
         .err()
@@ -266,7 +274,7 @@ fn test_cast_to_primitive(array: &dyn Array, target_ptype: PType, test_round_tri
 
     // Otherwise, all values must fit.
     let casted = cast_and_execute(
-        &array.to_array(),
+        &array.clone(),
         DType::Primitive(target_ptype, array.dtype().nullability()),
     )
     .unwrap_or_else(|e| {
@@ -329,37 +337,37 @@ mod tests {
     #[test]
     fn test_cast_conformance_u32() {
         let array = buffer![0u32, 100, 200, 65535, 1000000].into_array();
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 
     #[test]
     fn test_cast_conformance_i32() {
         let array = buffer![-100i32, -1, 0, 1, 100].into_array();
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 
     #[test]
     fn test_cast_conformance_f32() {
         let array = buffer![0.0f32, 1.5, -2.5, 100.0, 1e6].into_array();
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array);
     }
 
     #[test]
     fn test_cast_conformance_nullable() {
         let array = PrimitiveArray::from_option_iter([Some(1u8), None, Some(255), Some(0), None]);
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
     fn test_cast_conformance_bool() {
         let array = BoolArray::from_iter(vec![true, false, true, false]);
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
     fn test_cast_conformance_null() {
         let array = NullArray::new(5);
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
@@ -368,7 +376,7 @@ mod tests {
             vec![Some("hello"), None, Some("world")],
             DType::Utf8(Nullability::Nullable),
         );
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
@@ -377,7 +385,7 @@ mod tests {
             vec![Some(b"data".as_slice()), None, Some(b"bytes".as_slice())],
             DType::Binary(Nullability::Nullable),
         );
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
@@ -394,7 +402,7 @@ mod tests {
         let array =
             StructArray::try_new(names, vec![a, b], 3, crate::validity::Validity::NonNullable)
                 .unwrap();
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 
     #[test]
@@ -404,6 +412,6 @@ mod tests {
 
         let array =
             ListArray::try_new(data, offsets, crate::validity::Validity::NonNullable).unwrap();
-        test_cast_conformance(array.as_ref());
+        test_cast_conformance(&array.into_array());
     }
 }
diff --git a/vortex-array/src/compute/conformance/consistency.rs b/vortex-array/src/compute/conformance/consistency.rs
index 63396babbb4..dec1f8d1d61 100644
--- a/vortex-array/src/compute/conformance/consistency.rs
+++ b/vortex-array/src/compute/conformance/consistency.rs
@@ -19,18 +19,20 @@
 //!   interact with null values.
 //! - **Edge Cases**: Tests empty arrays, single elements, and boundary conditions.
 
+use std::sync::Arc;
+
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::Array;
+use crate::ArrayRef;
 use crate::IntoArray;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
 use crate::arrays::BoolArray;
 use crate::arrays::PrimitiveArray;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::invert;
-use crate::compute::mask;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
@@ -47,7 +49,7 @@ use crate::scalar_fn::fns::operators::Operator;
 /// - Creates indices array containing positions where mask is true
 /// - Applies take with these indices
 /// - Verifies both results are identical
-fn test_filter_take_consistency(array: &dyn Array) {
+fn test_filter_take_consistency(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -72,7 +74,7 @@ fn test_filter_take_consistency(array: &dyn Array) {
 
     // Take using those indices
     let taken = array
-        .take(indices_array.to_array())
+        .take(indices_array)
         .vortex_expect("take should succeed in conformance test");
 
     // Results should be identical
@@ -115,7 +117,7 @@ fn test_filter_take_consistency(array: &dyn Array) {
 /// # Why This Matters
 /// This test ensures that mask operations compose correctly, which is critical for
 /// complex query operations that may apply multiple filters.
-fn test_double_mask_consistency(array: &dyn Array) {
+fn test_double_mask_consistency(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -126,9 +128,13 @@ fn test_double_mask_consistency(array: &dyn Array) {
     let mask2: Mask = (0..len).map(|i| i % 2 == 0).collect();
 
     // Apply masks sequentially
-    let first_masked = mask(array, &mask1).vortex_expect("mask should succeed in conformance test");
-    let double_masked =
-        mask(&first_masked, &mask2).vortex_expect("mask should succeed in conformance test");
+    let first_masked = array
+        .clone()
+        .mask((!&mask1).into_array())
+        .vortex_expect("mask should succeed in conformance test");
+    let double_masked = first_masked
+        .mask((!&mask2).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Create combined mask (OR operation - element is masked if EITHER mask is true)
     let combined_pattern: BitBuffer = mask1
@@ -140,8 +146,10 @@ fn test_double_mask_consistency(array: &dyn Array) {
     let combined_mask = Mask::from_buffer(combined_pattern);
 
     // Apply combined mask directly
-    let directly_masked =
-        mask(array, &combined_mask).vortex_expect("mask should succeed in conformance test");
+    let directly_masked = array
+        .clone()
+        .mask((!&combined_mask).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Results should be identical
     assert_eq!(
@@ -182,7 +190,7 @@ fn test_double_mask_consistency(array: &dyn Array) {
 /// # Why This Matters
 /// This is an identity operation that should be optimized in implementations
 /// to avoid unnecessary copying.
-fn test_filter_identity(array: &dyn Array) {
+fn test_filter_identity(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -231,15 +239,17 @@ fn test_filter_identity(array: &dyn Array) {
 /// # Why This Matters
 /// Masking always produces a nullable array, even when no values are actually masked.
 /// This test ensures the type system handles this correctly.
-fn test_mask_identity(array: &dyn Array) {
+fn test_mask_identity(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
     }
 
     let all_false_mask = Mask::new_false(len);
-    let masked =
-        mask(array, &all_false_mask).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&all_false_mask).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Masked array should have same values (just nullable)
     assert_eq!(
@@ -287,7 +297,7 @@ fn test_mask_identity(array: &dyn Array) {
 /// # Why This Matters
 /// When a filter mask represents a contiguous range, it should be equivalent to
 /// a slice operation. Some implementations may optimize this case.
-fn test_slice_filter_consistency(array: &dyn Array) {
+fn test_slice_filter_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 4 {
         return; // Need at least 4 elements for meaningful test
@@ -344,7 +354,7 @@ fn test_slice_filter_consistency(array: &dyn Array) {
 ///
 /// # Why This Matters
 /// Sequential takes are a common pattern that can be optimized to slice operations.
-fn test_take_slice_consistency(array: &dyn Array) {
+fn test_take_slice_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 3 {
         return; // Need at least 3 elements
@@ -354,7 +364,7 @@ fn test_take_slice_consistency(array: &dyn Array) {
     let end = 4.min(len);
     let indices = PrimitiveArray::from_iter((1..end).map(|i| i as u64)).into_array();
     let taken = array
-        .take(indices.to_array())
+        .take(indices)
         .vortex_expect("take should succeed in conformance test");
 
     // Slice from 1 to end
@@ -387,7 +397,7 @@ fn test_take_slice_consistency(array: &dyn Array) {
 }
 
 /// Tests that filter preserves relative ordering
-fn test_filter_preserves_order(array: &dyn Array) {
+fn test_filter_preserves_order(array: &ArrayRef) {
     let len = array.len();
     if len < 4 {
         return;
@@ -432,7 +442,7 @@ fn test_filter_preserves_order(array: &dyn Array) {
 }
 
 /// Tests that take with repeated indices works correctly
-fn test_take_repeated_indices(array: &dyn Array) {
+fn test_take_repeated_indices(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -441,7 +451,7 @@ fn test_take_repeated_indices(array: &dyn Array) {
     // Take the first element three times
     let indices = PrimitiveArray::from_iter([0u64, 0, 0]).into_array();
     let taken = array
-        .take(indices.to_array())
+        .take(indices)
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(taken.len(), 3);
@@ -458,7 +468,7 @@ fn test_take_repeated_indices(array: &dyn Array) {
 }
 
 /// Tests mask and filter interaction with nulls
-fn test_mask_filter_null_consistency(array: &dyn Array) {
+fn test_mask_filter_null_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 3 {
         return;
@@ -467,7 +477,10 @@ fn test_mask_filter_null_consistency(array: &dyn Array) {
     // First mask some elements
     let mask_pattern: Vec<bool> = (0..len).map(|i| i % 2 == 0).collect();
     let mask_array = Mask::from_iter(mask_pattern);
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Then filter to remove the nulls
     let filter_pattern: Vec<bool> = (0..len).map(|i| i % 2 != 0).collect();
@@ -495,7 +508,7 @@ fn test_mask_filter_null_consistency(array: &dyn Array) {
 }
 
 /// Tests that empty operations are consistent
-fn test_empty_operations_consistency(array: &dyn Array) {
+fn test_empty_operations_consistency(array: &ArrayRef) {
     let len = array.len();
 
     // Empty filter
@@ -508,7 +521,7 @@ fn test_empty_operations_consistency(array: &dyn Array) {
     // Empty take
     let empty_indices = PrimitiveArray::empty::<u64>(Nullability::NonNullable).into_array();
     let empty_take = array
-        .take(empty_indices.to_array())
+        .take(empty_indices)
         .vortex_expect("take should succeed in conformance test");
     assert_eq!(empty_take.len(), 0);
     assert_eq!(empty_take.dtype(), array.dtype());
@@ -524,7 +537,7 @@ fn test_empty_operations_consistency(array: &dyn Array) {
 }
 
 /// Tests that take preserves array properties
-fn test_take_preserves_properties(array: &dyn Array) {
+fn test_take_preserves_properties(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -533,7 +546,7 @@ fn test_take_preserves_properties(array: &dyn Array) {
     // Take all elements in original order
     let indices = PrimitiveArray::from_iter((0..len).map(|i| i as u64)).into_array();
     let taken = array
-        .take(indices.to_array())
+        .take(indices)
         .vortex_expect("take should succeed in conformance test");
 
     // Should be identical to original
@@ -568,7 +581,7 @@ fn test_take_preserves_properties(array: &dyn Array) {
 /// # Why This Matters
 /// Nullable indices are a powerful feature that allows introducing nulls during
 /// a take operation, which is useful for outer joins and similar operations.
-fn test_nullable_indices_consistency(array: &dyn Array) {
+fn test_nullable_indices_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 3 {
         return; // Need at least 3 elements to test indices 0 and 2
@@ -578,7 +591,7 @@ fn test_nullable_indices_consistency(array: &dyn Array) {
     let indices = PrimitiveArray::from_option_iter([Some(0u64), None, Some(2u64)]).into_array();
 
     let taken = array
-        .take(indices.to_array())
+        .take(indices)
         .vortex_expect("take should succeed in conformance test");
 
     // Result should have nulls where indices were null
@@ -634,7 +647,7 @@ fn test_nullable_indices_consistency(array: &dyn Array) {
 }
 
 /// Tests large array consistency
-fn test_large_array_consistency(array: &dyn Array) {
+fn test_large_array_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 1000 {
         return;
@@ -644,7 +657,7 @@ fn test_large_array_consistency(array: &dyn Array) {
     let indices: Vec<u64> = (0..len).step_by(10).map(|i| i as u64).collect();
     let indices_array = PrimitiveArray::from_iter(indices).into_array();
     let taken = array
-        .take(indices_array.to_array())
+        .take(indices_array)
         .vortex_expect("take should succeed in conformance test");
 
     // Create equivalent filter mask
@@ -684,8 +697,7 @@ fn test_large_array_consistency(array: &dyn Array) {
 /// Comparison operations must maintain logical consistency across encodings.
 /// This test catches bugs where an encoding might implement one comparison
 /// correctly but fail on its logical inverse.
-#[expect(deprecated)]
-fn test_comparison_inverse_consistency(array: &dyn Array) {
+fn test_comparison_inverse_consistency(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -710,14 +722,15 @@ fn test_comparison_inverse_consistency(array: &dyn Array) {
     let const_array = crate::arrays::ConstantArray::new(test_scalar, len);
     if let (Ok(eq_result), Ok(neq_result)) = (
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Eq),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Eq),
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::NotEq),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::NotEq),
     ) {
-        let inverted_eq =
-            invert(&eq_result).vortex_expect("invert should succeed in conformance test");
+        let inverted_eq = eq_result
+            .not()
+            .vortex_expect("not should succeed in conformance test");
 
         assert_eq!(
             inverted_eq.len(),
@@ -743,14 +756,15 @@ fn test_comparison_inverse_consistency(array: &dyn Array) {
     // Test Gt vs Lte
     if let (Ok(gt_result), Ok(lte_result)) = (
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Gt),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Gt),
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Lte),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Lte),
     ) {
-        let inverted_gt =
-            invert(&gt_result).vortex_expect("invert should succeed in conformance test");
+        let inverted_gt = gt_result
+            .not()
+            .vortex_expect("not should succeed in conformance test");
 
         for i in 0..inverted_gt.len() {
             let inv_val = inverted_gt
@@ -770,14 +784,15 @@ fn test_comparison_inverse_consistency(array: &dyn Array) {
     // Test Lt vs Gte
     if let (Ok(lt_result), Ok(gte_result)) = (
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Lt),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Lt),
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Gte),
+            .clone()
+            .binary(const_array.into_array(), Operator::Gte),
     ) {
-        let inverted_lt =
-            invert(&lt_result).vortex_expect("invert should succeed in conformance test");
+        let inverted_lt = lt_result
+            .not()
+            .vortex_expect("not should succeed in conformance test");
 
         for i in 0..inverted_lt.len() {
             let inv_val = inverted_lt
@@ -810,7 +825,7 @@ fn test_comparison_inverse_consistency(array: &dyn Array) {
 /// # Why This Matters
 /// Ensures that comparison operations maintain mathematical ordering properties
 /// regardless of operand order.
-fn test_comparison_symmetry_consistency(array: &dyn Array) {
+fn test_comparison_symmetry_consistency(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -837,11 +852,12 @@ fn test_comparison_symmetry_consistency(array: &dyn Array) {
     // Test Gt vs Lt symmetry
     if let (Ok(arr_gt_scalar), Ok(scalar_lt_arr)) = (
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Gt),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Gt),
         const_array
-            .to_array()
-            .binary(array.to_array(), Operator::Lt),
+            .clone()
+            .into_array()
+            .binary(array.clone(), Operator::Lt),
     ) {
         assert_eq!(
             arr_gt_scalar.len(),
@@ -867,11 +883,9 @@ fn test_comparison_symmetry_consistency(array: &dyn Array) {
     // Test Eq symmetry
     if let (Ok(arr_eq_scalar), Ok(scalar_eq_arr)) = (
         array
-            .to_array()
-            .binary(const_array.to_array(), Operator::Eq),
-        const_array
-            .to_array()
-            .binary(array.to_array(), Operator::Eq),
+            .clone()
+            .binary(const_array.clone().into_array(), Operator::Eq),
+        const_array.into_array().binary(array.clone(), Operator::Eq),
     ) {
         for i in 0..arr_eq_scalar.len() {
             let arr_eq = arr_eq_scalar
@@ -905,28 +919,28 @@ fn test_comparison_symmetry_consistency(array: &dyn Array) {
 /// Boolean operations must maintain logical consistency across encodings.
 /// This test catches bugs where encodings might optimize boolean operations
 /// incorrectly, breaking fundamental logical properties.
-#[expect(deprecated)]
-fn test_boolean_demorgan_consistency(array: &dyn Array) {
+fn test_boolean_demorgan_consistency(array: &ArrayRef) {
     if !matches!(array.dtype(), DType::Bool(_)) {
         return;
     }
 
-    let mask = {
+    let bool_mask = {
         let mask_pattern: Vec<bool> = (0..array.len()).map(|i| i % 3 == 0).collect();
         BoolArray::from_iter(mask_pattern)
     };
-    let mask = mask.as_ref();
+    let bool_mask = bool_mask.into_array();
 
     // Test first De Morgan's law: NOT(A AND B) = (NOT A) OR (NOT B)
     if let (Ok(a_and_b), Ok(not_a), Ok(not_b)) = (
-        array.to_array().binary(mask.to_array(), Operator::And),
-        invert(array),
-        invert(mask),
+        array.clone().binary(bool_mask.clone(), Operator::And),
+        array.not(),
+        bool_mask.not(),
     ) {
-        let not_a_and_b =
-            invert(&a_and_b).vortex_expect("invert should succeed in conformance test");
+        let not_a_and_b = a_and_b
+            .not()
+            .vortex_expect("not should succeed in conformance test");
         let not_a_or_not_b = not_a
-            .binary(not_b.clone(), Operator::Or)
+            .binary(not_b, Operator::Or)
             .vortex_expect("or should succeed in conformance test");
 
         assert_eq!(
@@ -952,13 +966,15 @@ fn test_boolean_demorgan_consistency(array: &dyn Array) {
 
     // Test second De Morgan's law: NOT(A OR B) = (NOT A) AND (NOT B)
     if let (Ok(a_or_b), Ok(not_a), Ok(not_b)) = (
-        array.to_array().binary(mask.to_array(), Operator::Or),
-        invert(array),
-        invert(mask),
+        array.clone().binary(bool_mask.clone(), Operator::Or),
+        array.not(),
+        bool_mask.not(),
     ) {
-        let not_a_or_b = invert(&a_or_b).vortex_expect("invert should succeed in conformance test");
+        let not_a_or_b = a_or_b
+            .not()
+            .vortex_expect("not should succeed in conformance test");
         let not_a_and_not_b = not_a
-            .binary(not_b.clone(), Operator::And)
+            .binary(not_b, Operator::And)
             .vortex_expect("and should succeed in conformance test");
 
         for i in 0..not_a_or_b.len() {
@@ -992,12 +1008,14 @@ fn test_boolean_demorgan_consistency(array: &dyn Array) {
 /// # Why This Matters
 /// Aggregate operations on sliced arrays must produce correct results
 /// regardless of the underlying encoding's offset handling.
-fn test_slice_aggregate_consistency(array: &dyn Array) {
-    use crate::compute::min_max;
-    use crate::compute::nan_count;
-    use crate::compute::sum;
+fn test_slice_aggregate_consistency(array: &ArrayRef) {
+    use crate::aggregate_fn::fns::min_max::min_max;
+    use crate::aggregate_fn::fns::nan_count::nan_count;
+    use crate::aggregate_fn::fns::sum::sum;
     use crate::dtype::DType;
 
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
     let len = array.len();
     if len < 5 {
         return; // Need enough elements for meaningful slice
@@ -1013,7 +1031,7 @@ fn test_slice_aggregate_consistency(array: &dyn Array) {
         .vortex_expect("slice should succeed in conformance test");
     let canonical = array.to_canonical().vortex_expect("to_canonical failed");
     let canonical_sliced = canonical
-        .as_ref()
+        .into_array()
         .slice(start..end)
         .vortex_expect("slice should succeed in conformance test");
 
@@ -1035,7 +1053,9 @@ fn test_slice_aggregate_consistency(array: &dyn Array) {
         return;
     }
 
-    if let (Ok(slice_sum), Ok(canonical_sum)) = (sum(&sliced), sum(&canonical_sliced)) {
+    if let (Ok(slice_sum), Ok(canonical_sum)) =
+        (sum(&sliced, &mut ctx), sum(&canonical_sliced, &mut ctx))
+    {
         // Compare sum scalars
         assert_eq!(
             slice_sum, canonical_sum,
@@ -1045,8 +1065,10 @@ fn test_slice_aggregate_consistency(array: &dyn Array) {
     }
 
     // Test min_max
-    if let (Ok(slice_minmax), Ok(canonical_minmax)) = (min_max(&sliced), min_max(&canonical_sliced))
-    {
+    if let (Ok(slice_minmax), Ok(canonical_minmax)) = (
+        min_max(&sliced, &mut ctx),
+        min_max(&canonical_sliced, &mut ctx),
+    ) {
         match (slice_minmax, canonical_minmax) {
             (Some(s_result), Some(c_result)) => {
                 assert_eq!(
@@ -1069,8 +1091,10 @@ fn test_slice_aggregate_consistency(array: &dyn Array) {
 
     // Test nan_count for floating point types
     if array.dtype().is_float()
-        && let (Ok(slice_nan_count), Ok(canonical_nan_count)) =
-            (nan_count(&sliced), nan_count(&canonical_sliced))
+        && let (Ok(slice_nan_count), Ok(canonical_nan_count)) = (
+            nan_count(&sliced, &mut ctx),
+            nan_count(&canonical_sliced, &mut ctx),
+        )
     {
         assert_eq!(
             slice_nan_count, canonical_nan_count,
@@ -1095,7 +1119,7 @@ fn test_slice_aggregate_consistency(array: &dyn Array) {
 /// This test specifically catches bugs where encodings (like RunEndArray) fail to preserve
 /// offset information during cast operations. Such bugs can lead to incorrect data being
 /// returned after casting a sliced array.
-fn test_cast_slice_consistency(array: &dyn Array) {
+fn test_cast_slice_consistency(array: &ArrayRef) {
     let len = array.len();
     if len < 5 {
         return; // Need at least 5 elements for meaningful slice
@@ -1205,7 +1229,7 @@ fn test_cast_slice_consistency(array: &dyn Array) {
                 Nullability::NonNullable => Nullability::Nullable,
                 Nullability::Nullable => Nullability::NonNullable,
             };
-            vec![DType::List(element_type.clone(), opposite)]
+            vec![DType::List(Arc::clone(element_type), opposite)]
         }
         DType::FixedSizeList(element_type, list_size, nullability) => {
             let opposite = match nullability {
@@ -1213,12 +1237,13 @@ fn test_cast_slice_consistency(array: &dyn Array) {
                 Nullability::Nullable => Nullability::NonNullable,
             };
             vec![DType::FixedSizeList(
-                element_type.clone(),
+                Arc::clone(element_type),
                 *list_size,
                 opposite,
             )]
         }
         DType::Extension(_) => vec![], // Extension types typically only cast to themselves
+        DType::Variant(_) => unimplemented!(),
     };
 
     // Test each target dtype
@@ -1254,7 +1279,8 @@ fn test_cast_slice_consistency(array: &dyn Array) {
 
             // Get the corresponding value from the canonical array (adjusted for slice offset)
             let canonical_val = canonical
-                .as_ref()
+                .clone()
+                .into_array()
                 .scalar_at(start + i)
                 .vortex_expect("scalar_at should succeed in conformance test");
 
@@ -1281,7 +1307,7 @@ fn test_cast_slice_consistency(array: &dyn Array) {
 
         // Also test the other way: cast then slice
         let casted = match array
-            .to_array()
+            .clone()
             .cast(target_dtype.clone())
             .and_then(|a| a.to_canonical().map(|c| c.into_array()))
         {
@@ -1356,7 +1382,7 @@ fn test_cast_slice_consistency(array: &dyn Array) {
 /// ## Large Arrays
 /// - **Performance**: Operations scale correctly to large arrays (1000+ elements)
 /// ```text
-pub fn test_array_consistency(array: &dyn Array) {
+pub fn test_array_consistency(array: &ArrayRef) {
     // Core operation consistency
     test_filter_take_consistency(array);
     test_double_mask_consistency(array);
diff --git a/vortex-array/src/compute/conformance/filter.rs b/vortex-array/src/compute/conformance/filter.rs
index befc7bef612..6be08dff69a 100644
--- a/vortex-array/src/compute/conformance/filter.rs
+++ b/vortex-array/src/compute/conformance/filter.rs
@@ -4,7 +4,7 @@
 use vortex_error::VortexExpect;
 use vortex_mask::Mask;
 
-use crate::Array;
+use crate::ArrayRef;
 use crate::IntoArray;
 use crate::assert_arrays_eq;
 use crate::dtype::DType;
@@ -16,7 +16,7 @@ pub const LARGE_SIZE: usize = 1024;
 
 /// Test filter compute function with various array sizes and patterns.
 /// The input array can be of any length.
-pub fn test_filter_conformance(array: &dyn Array) {
+pub fn test_filter_conformance(array: &ArrayRef) {
     let len = array.len();
 
     // Test with arrays of any size
@@ -59,7 +59,7 @@ pub fn create_runs_pattern(len: usize, run_length: usize) -> Vec<bool> {
 }
 
 /// Tests that filtering with an all-true mask returns all elements unchanged
-fn test_all_filter(array: &dyn Array) {
+fn test_all_filter(array: &ArrayRef) {
     let len = array.len();
     let mask = Mask::new_true(len);
     let filtered = array
@@ -69,7 +69,7 @@ fn test_all_filter(array: &dyn Array) {
 }
 
 /// Tests that filtering with an all-false mask returns an empty array with the same dtype
-fn test_none_filter(array: &dyn Array) {
+fn test_none_filter(array: &ArrayRef) {
     let len = array.len();
     let mask = Mask::new_false(len);
     let filtered = array
@@ -79,7 +79,7 @@ fn test_none_filter(array: &dyn Array) {
     assert_eq!(filtered.dtype(), array.dtype());
 }
 
-fn test_selective_filter(array: &dyn Array) {
+fn test_selective_filter(array: &ArrayRef) {
     let len = array.len();
     if len < 2 {
         return; // Skip for very small arrays
@@ -135,7 +135,7 @@ fn test_selective_filter(array: &dyn Array) {
     }
 }
 
-fn test_single_element_filter(array: &dyn Array) {
+fn test_single_element_filter(array: &ArrayRef) {
     let len = array.len();
     if len == 0 {
         return;
@@ -195,7 +195,7 @@ fn test_empty_array_filter(dtype: &DType) {
     assert_eq!(filtered.len(), 0);
 }
 
-fn test_mismatched_lengths(array: &dyn Array) {
+fn test_mismatched_lengths(array: &ArrayRef) {
     let len = array.len();
 
     // Test mask shorter than array
@@ -218,7 +218,7 @@ fn test_mismatched_lengths(array: &dyn Array) {
 }
 
 /// Tests filtering with alternating true/false pattern
-fn test_alternating_pattern_filter(array: &dyn Array) {
+fn test_alternating_pattern_filter(array: &ArrayRef) {
     let len = array.len();
     let pattern = create_alternating_pattern(len);
     let expected_count = pattern.iter().filter(|&&v| v).count();
@@ -247,7 +247,7 @@ fn test_alternating_pattern_filter(array: &dyn Array) {
 }
 
 /// Tests filtering with runs of true/false values
-fn test_runs_pattern_filter(array: &dyn Array) {
+fn test_runs_pattern_filter(array: &ArrayRef) {
     let len = array.len();
     if len < 4 {
         return; // Skip for very small arrays
@@ -265,7 +265,7 @@ fn test_runs_pattern_filter(array: &dyn Array) {
 }
 
 /// Tests filtering with sparse true values (mostly false)
-fn test_sparse_true_filter(array: &dyn Array) {
+fn test_sparse_true_filter(array: &ArrayRef) {
     let len = array.len();
     if len < 10 {
         return; // Skip for small arrays
@@ -283,7 +283,7 @@ fn test_sparse_true_filter(array: &dyn Array) {
 }
 
 /// Tests filtering with sparse false values (mostly true)
-fn test_sparse_false_filter(array: &dyn Array) {
+fn test_sparse_false_filter(array: &ArrayRef) {
     let len = array.len();
     if len < 10 {
         return; // Skip for small arrays
@@ -301,7 +301,7 @@ fn test_sparse_false_filter(array: &dyn Array) {
 }
 
 /// Tests filtering with random pattern
-fn test_random_pattern_filter(array: &dyn Array) {
+fn test_random_pattern_filter(array: &ArrayRef) {
     let len = array.len();
 
     // Create a pseudo-random pattern based on array length
diff --git a/vortex-array/src/compute/conformance/mask.rs b/vortex-array/src/compute/conformance/mask.rs
index 517707eacec..debdff9a806 100644
--- a/vortex-array/src/compute/conformance/mask.rs
+++ b/vortex-array/src/compute/conformance/mask.rs
@@ -4,13 +4,15 @@
 use vortex_error::VortexExpect;
 use vortex_mask::Mask;
 
-use crate::Array;
+use crate::ArrayRef;
+use crate::IntoArray;
 use crate::arrays::BoolArray;
-use crate::compute::mask;
+use crate::arrays::bool::BoolArrayExt;
+use crate::builtins::ArrayBuiltins;
 
 /// Test mask compute function with various array sizes and patterns.
 /// The mask operation sets elements to null where the mask is true.
-pub fn test_mask_conformance(array: &dyn Array) {
+pub fn test_mask_conformance(array: &ArrayRef) {
     let len = array.len();
 
     if len > 0 {
@@ -32,14 +34,17 @@ pub fn test_mask_conformance(array: &dyn Array) {
 }
 
 /// Tests masking with a heterogeneous pattern
-fn test_heterogenous_mask(array: &dyn Array) {
+fn test_heterogenous_mask(array: &ArrayRef) {
     let len = array.len();
 
     // Create a pattern where roughly half the values are masked
     let mask_pattern: Vec<bool> = (0..len).map(|i| i % 3 != 1).collect();
     let mask_array = Mask::from_iter(mask_pattern.clone());
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert_eq!(masked.len(), array.len());
 
     // Verify masked elements are null and unmasked elements are preserved
@@ -65,12 +70,15 @@ fn test_heterogenous_mask(array: &dyn Array) {
 }
 
 /// Tests that an empty mask (all false) preserves all elements
-fn test_empty_mask(array: &dyn Array) {
+fn test_empty_mask(array: &ArrayRef) {
     let len = array.len();
     let all_unmasked = vec![false; len];
     let mask_array = Mask::from_iter(all_unmasked);
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert_eq!(masked.len(), array.len());
 
     // All elements should be preserved
@@ -88,12 +96,15 @@ fn test_empty_mask(array: &dyn Array) {
 }
 
 /// Tests that a full mask (all true) makes all elements null
-fn test_full_mask(array: &dyn Array) {
+fn test_full_mask(array: &ArrayRef) {
     let len = array.len();
     let all_masked = vec![true; len];
     let mask_array = Mask::from_iter(all_masked);
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert_eq!(masked.len(), array.len());
 
     // All elements should be null
@@ -107,12 +118,15 @@ fn test_full_mask(array: &dyn Array) {
 }
 
 /// Tests alternating mask pattern
-fn test_alternating_mask(array: &dyn Array) {
+fn test_alternating_mask(array: &ArrayRef) {
     let len = array.len();
     let pattern: Vec<bool> = (0..len).map(|i| i % 2 == 0).collect();
     let mask_array = Mask::from_iter(pattern);
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert_eq!(masked.len(), array.len());
 
     for i in 0..len {
@@ -137,7 +151,7 @@ fn test_alternating_mask(array: &dyn Array) {
 }
 
 /// Tests sparse mask (only a few elements masked)
-fn test_sparse_mask(array: &dyn Array) {
+fn test_sparse_mask(array: &ArrayRef) {
     let len = array.len();
     if len < 10 {
         return; // Skip for small arrays
@@ -147,7 +161,10 @@ fn test_sparse_mask(array: &dyn Array) {
     let pattern: Vec<bool> = (0..len).map(|i| i % 10 == 0).collect();
     let mask_array = Mask::from_iter(pattern.clone());
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert_eq!(masked.len(), array.len());
 
     // Count how many elements are valid after masking
@@ -175,7 +192,7 @@ fn test_sparse_mask(array: &dyn Array) {
 }
 
 /// Tests masking a single element
-fn test_single_element_mask(array: &dyn Array) {
+fn test_single_element_mask(array: &ArrayRef) {
     let len = array.len();
 
     // Mask only the first element
@@ -183,7 +200,10 @@ fn test_single_element_mask(array: &dyn Array) {
     pattern[0] = true;
     let mask_array = Mask::from_iter(pattern);
 
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
     assert!(
         !masked
             .is_valid(0)
@@ -204,7 +224,7 @@ fn test_single_element_mask(array: &dyn Array) {
 }
 
 /// Tests double masking operations
-fn test_double_mask(array: &dyn Array) {
+fn test_double_mask(array: &ArrayRef) {
     let len = array.len();
 
     // Create two different mask patterns
@@ -214,9 +234,13 @@ fn test_double_mask(array: &dyn Array) {
     let mask1 = Mask::from_iter(mask1_pattern.clone());
     let mask2 = Mask::from_iter(mask2_pattern.clone());
 
-    let first_masked = mask(array, &mask1).vortex_expect("mask should succeed in conformance test");
-    let double_masked =
-        mask(&first_masked, &mask2).vortex_expect("mask should succeed in conformance test");
+    let first_masked = array
+        .clone()
+        .mask((!&mask1).into_array())
+        .vortex_expect("mask should succeed in conformance test");
+    let double_masked = first_masked
+        .mask((!&mask2).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Elements should be null if either mask is true
     for i in 0..len {
@@ -241,7 +265,7 @@ fn test_double_mask(array: &dyn Array) {
 }
 
 /// Tests masking with nullable mask (nulls treated as false)
-fn test_nullable_mask_input(array: &dyn Array) {
+fn test_nullable_mask_input(array: &ArrayRef) {
     let len = array.len();
     if len < 3 {
         return; // Skip for very small arrays
@@ -256,7 +280,10 @@ fn test_nullable_mask_input(array: &dyn Array) {
     let nullable_mask = BoolArray::new(bool_array.to_bit_buffer(), validity);
 
     let mask_array = nullable_mask.to_mask_fill_null_false();
-    let masked = mask(array, &mask_array).vortex_expect("mask should succeed in conformance test");
+    let masked = array
+        .clone()
+        .mask((!&mask_array).into_array())
+        .vortex_expect("mask should succeed in conformance test");
 
     // Elements are masked only if the mask is true AND valid
     for i in 0..len {
diff --git a/vortex-array/src/compute/conformance/mod.rs b/vortex-array/src/compute/conformance/mod.rs
index 806e146fcc8..68d80a0998e 100644
--- a/vortex-array/src/compute/conformance/mod.rs
+++ b/vortex-array/src/compute/conformance/mod.rs
@@ -3,10 +3,8 @@
 
 pub mod binary_numeric;
 pub mod cast;
-#[allow(deprecated)]
 pub mod consistency;
 pub mod filter;
-#[allow(deprecated)]
 pub mod mask;
 pub mod search_sorted;
 pub mod take;
diff --git a/vortex-array/src/compute/conformance/search_sorted.rs b/vortex-array/src/compute/conformance/search_sorted.rs
index e8e4db738ee..a112b7fe4d1 100644
--- a/vortex-array/src/compute/conformance/search_sorted.rs
+++ b/vortex-array/src/compute/conformance/search_sorted.rs
@@ -10,6 +10,8 @@ use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 
 use crate::ArrayRef;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
 use crate::array::IntoArray;
 use crate::arrays::PrimitiveArray;
 use crate::patches::Patches;
@@ -30,6 +32,7 @@ pub fn sparse_high_null_fill() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -46,6 +49,7 @@ pub fn sparse_high_non_null_fill() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -62,6 +66,7 @@ pub fn sparse_low() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -78,6 +83,7 @@ pub fn sparse_low_high() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -94,6 +100,7 @@ pub fn sparse_edge_patch_high() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -110,6 +117,7 @@ pub fn sparse_edge_patch_low() -> ArrayRef {
                 None,
             )
             .unwrap(),
+            &mut LEGACY_SESSION.create_execution_ctx(),
         )
         .unwrap()
         .into_array()
diff --git a/vortex-array/src/compute/conformance/take.rs b/vortex-array/src/compute/conformance/take.rs
index 5e8194698d6..214262e5572 100644
--- a/vortex-array/src/compute/conformance/take.rs
+++ b/vortex-array/src/compute/conformance/take.rs
@@ -4,7 +4,7 @@
 use vortex_buffer::buffer;
 use vortex_error::VortexExpect;
 
-use crate::Array;
+use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray as _;
 use crate::arrays::PrimitiveArray;
@@ -19,7 +19,7 @@ use crate::dtype::Nullability;
 /// - Taking with out-of-bounds indices (should panic)
 /// - Taking with nullable indices
 /// - Edge cases like empty arrays
-pub fn test_take_conformance(array: &dyn Array) {
+pub fn test_take_conformance(array: &ArrayRef) {
     let len = array.len();
 
     if len > 0 {
@@ -51,11 +51,11 @@ pub fn test_take_conformance(array: &dyn Array) {
     }
 }
 
-fn test_take_all(array: &dyn Array) {
+fn test_take_all(array: &ArrayRef) {
     let len = array.len();
     let indices = PrimitiveArray::from_iter(0..len as u64);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), len);
@@ -92,10 +92,10 @@ fn test_take_all(array: &dyn Array) {
     }
 }
 
-fn test_take_none(array: &dyn Array) {
+fn test_take_none(array: &ArrayRef) {
     let indices: PrimitiveArray = PrimitiveArray::from_iter::<[u64; 0]>([]);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), 0);
@@ -103,7 +103,7 @@ fn test_take_none(array: &dyn Array) {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn test_take_selective(array: &dyn Array) {
+fn test_take_selective(array: &ArrayRef) {
     let len = array.len();
 
     // Take every other element
@@ -112,7 +112,7 @@ fn test_take_selective(array: &dyn Array) {
     let indices_array = PrimitiveArray::from_iter(indices.clone());
 
     let result = array
-        .take(indices_array.to_array())
+        .take(indices_array.into_array())
         .vortex_expect("take should succeed in conformance test");
     assert_eq!(result.len(), expected_len);
 
@@ -129,11 +129,11 @@ fn test_take_selective(array: &dyn Array) {
     }
 }
 
-fn test_take_first_and_last(array: &dyn Array) {
+fn test_take_first_and_last(array: &ArrayRef) {
     let len = array.len();
     let indices = PrimitiveArray::from_iter([0u64, (len - 1) as u64]);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), 2);
@@ -156,7 +156,7 @@ fn test_take_first_and_last(array: &dyn Array) {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn test_take_with_nullable_indices(array: &dyn Array) {
+fn test_take_with_nullable_indices(array: &ArrayRef) {
     let len = array.len();
 
     // Create indices with some null values
@@ -170,7 +170,7 @@ fn test_take_with_nullable_indices(array: &dyn Array) {
 
     let indices = PrimitiveArray::from_option_iter(indices_vec.clone());
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), indices_vec.len());
@@ -203,7 +203,7 @@ fn test_take_with_nullable_indices(array: &dyn Array) {
     }
 }
 
-fn test_take_repeated_indices(array: &dyn Array) {
+fn test_take_repeated_indices(array: &ArrayRef) {
     if array.is_empty() {
         return;
     }
@@ -211,7 +211,7 @@ fn test_take_repeated_indices(array: &dyn Array) {
     // Take the first element multiple times
     let indices = buffer![0u64, 0, 0].into_array();
     let result = array
-        .take(indices.to_array())
+        .take(indices)
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), 3);
@@ -228,22 +228,22 @@ fn test_take_repeated_indices(array: &dyn Array) {
     }
 }
 
-fn test_empty_indices(array: &dyn Array) {
+fn test_empty_indices(array: &ArrayRef) {
     let indices = PrimitiveArray::empty::<u64>(Nullability::NonNullable);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), 0);
     assert_eq!(result.dtype(), array.dtype());
 }
 
-fn test_take_reverse(array: &dyn Array) {
+fn test_take_reverse(array: &ArrayRef) {
     let len = array.len();
     // Take elements in reverse order
     let indices = PrimitiveArray::from_iter((0..len as u64).rev());
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), len);
@@ -261,13 +261,13 @@ fn test_take_reverse(array: &dyn Array) {
     }
 }
 
-fn test_take_single_middle(array: &dyn Array) {
+fn test_take_single_middle(array: &ArrayRef) {
     let len = array.len();
     let middle_idx = len / 2;
 
     let indices = PrimitiveArray::from_iter([middle_idx as u64]);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), 1);
@@ -282,7 +282,7 @@ fn test_take_single_middle(array: &dyn Array) {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn test_take_random_unsorted(array: &dyn Array) {
+fn test_take_random_unsorted(array: &ArrayRef) {
     let len = array.len();
 
     // Create a pseudo-random but deterministic pattern
@@ -295,7 +295,7 @@ fn test_take_random_unsorted(array: &dyn Array) {
 
     let indices_array = PrimitiveArray::from_iter(indices.clone());
     let result = array
-        .take(indices_array.to_array())
+        .take(indices_array.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), indices.len());
@@ -313,7 +313,7 @@ fn test_take_random_unsorted(array: &dyn Array) {
     }
 }
 
-fn test_take_contiguous_range(array: &dyn Array) {
+fn test_take_contiguous_range(array: &ArrayRef) {
     let len = array.len();
     let start = len / 4;
     let end = len / 2;
@@ -321,7 +321,7 @@ fn test_take_contiguous_range(array: &dyn Array) {
     // Take a contiguous range from the middle
     let indices = PrimitiveArray::from_iter(start as u64..end as u64);
     let result = array
-        .take(indices.to_array())
+        .take(indices.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), end - start);
@@ -340,7 +340,7 @@ fn test_take_contiguous_range(array: &dyn Array) {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn test_take_mixed_repeated(array: &dyn Array) {
+fn test_take_mixed_repeated(array: &ArrayRef) {
     let len = array.len();
 
     // Create pattern with some repeated indices
@@ -357,7 +357,7 @@ fn test_take_mixed_repeated(array: &dyn Array) {
 
     let indices_array = PrimitiveArray::from_iter(indices.clone());
     let result = array
-        .take(indices_array.to_array())
+        .take(indices_array.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), indices.len());
@@ -376,7 +376,7 @@ fn test_take_mixed_repeated(array: &dyn Array) {
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn test_take_large_indices(array: &dyn Array) {
+fn test_take_large_indices(array: &ArrayRef) {
     // Test with a large number of indices to stress test performance
     let len = array.len();
     let num_indices = 10000.min(len * 3);
@@ -388,7 +388,7 @@ fn test_take_large_indices(array: &dyn Array) {
 
     let indices_array = PrimitiveArray::from_iter(indices.clone());
     let result = array
-        .take(indices_array.to_array())
+        .take(indices_array.into_array())
         .vortex_expect("take should succeed in conformance test");
 
     assert_eq!(result.len(), num_indices);
diff --git a/vortex-array/src/compute/fill_null.rs b/vortex-array/src/compute/fill_null.rs
deleted file mode 100644
index 47ba415f52f..00000000000
--- a/vortex-array/src/compute/fill_null.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::builtins::ArrayBuiltins;
-use crate::scalar::Scalar;
-
-/// Replace nulls in the array with another value.
-///
-/// # Examples
-///
-/// ```
-/// use vortex_array::arrays::{PrimitiveArray};
-/// use vortex_array::compute::{fill_null};
-/// use vortex_array::scalar::Scalar;
-///
-/// let array =
-///     PrimitiveArray::from_option_iter([Some(0i32), None, Some(1i32), None, Some(2i32)]);
-/// let array = fill_null(array.as_ref(), &Scalar::from(42i32)).unwrap();
-/// assert_eq!(array.display_values().to_string(), "[0i32, 42i32, 1i32, 42i32, 2i32]");
-/// ```
-#[deprecated(note = "use array.fill_null(scalar) via ArrayBuiltins instead")]
-pub fn fill_null(array: &dyn Array, fill_value: &Scalar) -> VortexResult<ArrayRef> {
-    vortex_ensure!(
-        !fill_value.is_null(),
-        "fill_null requires a non-null fill value"
-    );
-    let result = array.to_array().fill_null(fill_value.clone())?;
-    debug_assert!(
-        fill_value.dtype().is_nullable() || !result.dtype().is_nullable(),
-        "fill_null with non-nullable fill value must produce a non-nullable result"
-    );
-    Ok(result)
-}
diff --git a/vortex-array/src/compute/filter.rs b/vortex-array/src/compute/filter.rs
deleted file mode 100644
index 33ce392fc15..00000000000
--- a/vortex-array/src/compute/filter.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-// TODO(connor): REMOVE THIS FILE!
-
-use arrow_array::BooleanArray;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_mask::Mask;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::ToCanonical;
-use crate::arrow::FromArrowArray;
-use crate::arrow::IntoArrowArray;
-use crate::builtins::ArrayBuiltins;
-use crate::dtype::DType;
-use crate::scalar::Scalar;
-
-/// Keep only the elements for which the corresponding mask value is true.
-///
-/// # Examples
-///
-/// ```
-/// use vortex_array::{Array, IntoArray};
-/// use vortex_array::arrays::{BoolArray, PrimitiveArray};
-/// use vortex_array::compute::{ filter, mask};
-/// use vortex_error::VortexResult;
-/// use vortex_mask::Mask;
-/// use vortex_array::scalar::Scalar;
-///
-/// # fn main() -> VortexResult<()> {
-/// let array =
-///     PrimitiveArray::from_option_iter([Some(0i32), None, Some(1i32), None, Some(2i32)]);
-/// let mask = Mask::from_iter([true, false, false, false, true]);
-///
-/// let filtered = filter(array.as_ref(), &mask)?;
-/// assert_eq!(filtered.len(), 2);
-/// assert_eq!(filtered.scalar_at(0)?, Scalar::from(Some(0_i32)));
-/// assert_eq!(filtered.scalar_at(1)?, Scalar::from(Some(2_i32)));
-/// # Ok(())
-/// # }
-/// ```
-///
-/// # Panics
-///
-/// The `predicate` must receive an Array with type non-nullable bool, and will panic if this is
-/// not the case.
-pub fn filter(array: &dyn Array, mask: &Mask) -> VortexResult<ArrayRef> {
-    // TODO(connor): Remove this function completely!!!
-    Ok(array.filter(mask.clone())?.to_canonical()?.into_array())
-}
-
-impl dyn Array + '_ {
-    /// Converts from a possible nullable boolean array. Null values are treated as false.
-    pub fn try_to_mask_fill_null_false(&self) -> VortexResult<Mask> {
-        if !matches!(self.dtype(), DType::Bool(_)) {
-            vortex_bail!("mask must be bool array, has dtype {}", self.dtype());
-        }
-
-        // Convert nulls to false first in case this can be done cheaply by the encoding.
-        let array = self
-            .to_array()
-            .fill_null(Scalar::bool(false, self.dtype().nullability()))?;
-
-        Ok(array.to_bool().to_mask_fill_null_false())
-    }
-}
-
-pub fn arrow_filter_fn(array: &dyn Array, mask: &Mask) -> VortexResult<ArrayRef> {
-    let values = match &mask {
-        Mask::Values(values) => values,
-        Mask::AllTrue(_) | Mask::AllFalse(_) => unreachable!("check in filter invoke"),
-    };
-
-    let array_ref = array.to_array().into_arrow_preferred()?;
-    let mask_array = BooleanArray::new(values.bit_buffer().clone().into(), None);
-    let filtered = arrow_select::filter::filter(array_ref.as_ref(), &mask_array)?;
-
-    ArrayRef::from_arrow(filtered.as_ref(), array.dtype().is_nullable())
-}
diff --git a/vortex-array/src/compute/invert.rs b/vortex-array/src/compute/invert.rs
deleted file mode 100644
index 1e82b88ef7f..00000000000
--- a/vortex-array/src/compute/invert.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::builtins::ArrayBuiltins;
-
-/// Logically invert a boolean array, preserving its validity.
-#[deprecated(note = "use array.not() via ArrayBuiltins instead")]
-pub fn invert(array: &dyn Array) -> VortexResult<ArrayRef> {
-    array.to_array().not()
-}
diff --git a/vortex-array/src/compute/is_constant.rs b/vortex-array/src/compute/is_constant.rs
deleted file mode 100644
index e24c9e4dc69..00000000000
--- a/vortex-array/src/compute/is_constant.rs
+++ /dev/null
@@ -1,346 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::Any;
-use std::sync::LazyLock;
-
-use arcref::ArcRef;
-use vortex_error::VortexError;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-
-use crate::Array;
-use crate::arrays::ConstantVTable;
-use crate::arrays::NullVTable;
-use crate::compute::ComputeFn;
-use crate::compute::ComputeFnVTable;
-use crate::compute::InvocationArgs;
-use crate::compute::Kernel;
-use crate::compute::Options;
-use crate::compute::Output;
-use crate::dtype::DType;
-use crate::dtype::Nullability;
-use crate::expr::stats::Precision;
-use crate::expr::stats::Stat;
-use crate::expr::stats::StatsProvider;
-use crate::expr::stats::StatsProviderExt;
-use crate::scalar::Scalar;
-use crate::vtable::VTable;
-
-static IS_CONSTANT_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
-    let compute = ComputeFn::new("is_constant".into(), ArcRef::new_ref(&IsConstant));
-    for kernel in inventory::iter::<IsConstantKernelRef> {
-        compute.register_kernel(kernel.0.clone());
-    }
-    compute
-});
-
-pub(crate) fn warm_up_vtable() -> usize {
-    IS_CONSTANT_FN.kernels().len()
-}
-
-/// Computes whether an array has constant values. If the array's encoding doesn't implement the
-/// relevant VTable, it'll try and canonicalize in order to make a determination.
-///
-/// An array is constant IFF at least one of the following conditions apply:
-/// 1. It has at least one element (**Note** - an empty array isn't constant).
-/// 1. It's encoded as a [`crate::arrays::ConstantArray`] or [`crate::arrays::NullArray`]
-/// 1. Has an exact statistic attached to it, saying its constant.
-/// 1. Is all invalid.
-/// 1. Is all valid AND has minimum and maximum statistics that are equal.
-///
-/// If the array has some null values but is not all null, it'll never be constant.
-///
-/// Returns `Ok(None)` if we could not determine whether the array is constant, e.g. if
-/// canonicalization is disabled and the no kernel exists for the array's encoding.
-pub fn is_constant(array: &dyn Array) -> VortexResult<Option<bool>> {
-    let opts = IsConstantOpts::default();
-    is_constant_opts(array, &opts)
-}
-
-/// Computes whether an array has constant values. Configurable by [`IsConstantOpts`].
-///
-/// Please see [`is_constant`] for a more detailed explanation of its behavior.
-pub fn is_constant_opts(array: &dyn Array, options: &IsConstantOpts) -> VortexResult<Option<bool>> {
-    Ok(IS_CONSTANT_FN
-        .invoke(&InvocationArgs {
-            inputs: &[array.into()],
-            options,
-        })?
-        .unwrap_scalar()?
-        .as_bool()
-        .value())
-}
-
-struct IsConstant;
-
-impl ComputeFnVTable for IsConstant {
-    fn invoke(
-        &self,
-        args: &InvocationArgs,
-        kernels: &[ArcRef<dyn Kernel>],
-    ) -> VortexResult<Output> {
-        let IsConstantArgs { array, options } = IsConstantArgs::try_from(args)?;
-
-        // We try and rely on some easy-to-get stats
-        if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(Stat::IsConstant) {
-            let scalar: Scalar = Some(value).into();
-            return Ok(scalar.into());
-        }
-
-        let value = is_constant_impl(array, options, kernels)?;
-
-        if options.cost == Cost::Canonicalize {
-            // When we run linear canonicalize, there we must always return an exact answer.
-            assert!(
-                value.is_some(),
-                "is constant in array {array} canonicalize returned None"
-            );
-        }
-
-        // Only if we made a determination do we update the stats.
-        if let Some(value) = value {
-            array
-                .statistics()
-                .set(Stat::IsConstant, Precision::Exact(value.into()));
-        }
-
-        let scalar: Scalar = value.into();
-        Ok(scalar.into())
-    }
-
-    fn return_dtype(&self, _args: &InvocationArgs) -> VortexResult<DType> {
-        // We always return a nullable boolean where `null` indicates we couldn't determine
-        // whether the array is constant.
-        Ok(DType::Bool(Nullability::Nullable))
-    }
-
-    fn return_len(&self, _args: &InvocationArgs) -> VortexResult<usize> {
-        Ok(1)
-    }
-
-    fn is_elementwise(&self) -> bool {
-        false
-    }
-}
-
-fn is_constant_impl(
-    array: &dyn Array,
-    options: &IsConstantOpts,
-    kernels: &[ArcRef<dyn Kernel>],
-) -> VortexResult<Option<bool>> {
-    match array.len() {
-        // Our current semantics are that we can always get a value out of a constant array. We might want to change that in the future.
-        0 => return Ok(Some(false)),
-        // Array of length 1 is always constant.
-        1 => return Ok(Some(true)),
-        _ => {}
-    }
-
-    // Constant and null arrays are always constant
-    if array.is::<ConstantVTable>() || array.is::<NullVTable>() {
-        return Ok(Some(true));
-    }
-
-    let all_invalid = array.all_invalid()?;
-    if all_invalid {
-        return Ok(Some(true));
-    }
-
-    let all_valid = array.all_valid()?;
-
-    // If we have some nulls, array can't be constant
-    if !all_valid && !all_invalid {
-        return Ok(Some(false));
-    }
-
-    // We already know here that the array is all valid, so we check for min/max stats.
-    let min = array.statistics().get(Stat::Min);
-    let max = array.statistics().get(Stat::Max);
-
-    if let Some((min, max)) = min.zip(max) {
-        // min/max are equal and exact and there are no NaNs
-        if min.is_exact()
-            && min == max
-            && (Stat::NaNCount.dtype(array.dtype()).is_none()
-                || array.statistics().get_as::<u64>(Stat::NaNCount) == Some(Precision::exact(0u64)))
-        {
-            return Ok(Some(true));
-        }
-    }
-
-    assert!(
-        all_valid,
-        "All values must be valid as an invariant of the VTable."
-    );
-    let args = InvocationArgs {
-        inputs: &[array.into()],
-        options,
-    };
-    for kernel in kernels {
-        if let Some(output) = kernel.invoke(&args)? {
-            return Ok(output.unwrap_scalar()?.as_bool().value());
-        }
-    }
-
-    tracing::debug!(
-        "No is_constant implementation found for {}",
-        array.encoding_id()
-    );
-
-    if options.cost == Cost::Canonicalize && !array.is_canonical() {
-        let array = array.to_canonical()?;
-        let is_constant = is_constant_opts(array.as_ref(), options)?;
-        return Ok(is_constant);
-    }
-
-    // Otherwise, we cannot determine if the array is constant.
-    Ok(None)
-}
-
-pub struct IsConstantKernelRef(ArcRef<dyn Kernel>);
-inventory::collect!(IsConstantKernelRef);
-
-pub trait IsConstantKernel: VTable {
-    /// # Preconditions
-    ///
-    /// * All values are valid
-    /// * array.len() > 1
-    ///
-    /// Returns `Ok(None)` to signal we couldn't make an exact determination.
-    fn is_constant(&self, array: &Self::Array, opts: &IsConstantOpts)
-    -> VortexResult<Option<bool>>;
-}
-
-#[derive(Debug)]
-pub struct IsConstantKernelAdapter<V: VTable>(pub V);
-
-impl<V: VTable + IsConstantKernel> IsConstantKernelAdapter<V> {
-    pub const fn lift(&'static self) -> IsConstantKernelRef {
-        IsConstantKernelRef(ArcRef::new_ref(self))
-    }
-}
-
-impl<V: VTable + IsConstantKernel> Kernel for IsConstantKernelAdapter<V> {
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
-        let args = IsConstantArgs::try_from(args)?;
-        let Some(array) = args.array.as_opt::<V>() else {
-            return Ok(None);
-        };
-        let is_constant = V::is_constant(&self.0, array, args.options)?;
-        let scalar: Scalar = is_constant.into();
-        Ok(Some(scalar.into()))
-    }
-}
-
-struct IsConstantArgs<'a> {
-    array: &'a dyn Array,
-    options: &'a IsConstantOpts,
-}
-
-impl<'a> TryFrom<&InvocationArgs<'a>> for IsConstantArgs<'a> {
-    type Error = VortexError;
-
-    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
-        if value.inputs.len() != 1 {
-            vortex_bail!("Expected 1 input, found {}", value.inputs.len());
-        }
-        let array = value.inputs[0]
-            .array()
-            .ok_or_else(|| vortex_err!("Expected input 0 to be an array"))?;
-        let options = value
-            .options
-            .as_any()
-            .downcast_ref::<IsConstantOpts>()
-            .ok_or_else(|| vortex_err!("Expected options to be of type IsConstantOpts"))?;
-        Ok(Self { array, options })
-    }
-}
-
-/// When calling `is_constant` the children are all checked for constantness.
-/// This enum decide at each precision/cost level the constant check should run as.
-/// The cost increase as we move down the list.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Cost {
-    /// Only apply constant time computation to estimate constantness.
-    Negligible,
-    /// Allow the encoding to do a linear amount of work to determine is constant.
-    /// Each encoding should implement short-circuiting make the common case runtime well below
-    /// a linear scan.
-    Specialized,
-    /// Same as linear, but when necessary canonicalize the array and check is constant.
-    /// This *must* always return a known answer.
-    Canonicalize,
-}
-
-/// Configuration for [`is_constant_opts`] operations.
-#[derive(Clone, Debug)]
-pub struct IsConstantOpts {
-    /// What precision cost trade off should be used
-    pub cost: Cost,
-}
-
-impl Default for IsConstantOpts {
-    fn default() -> Self {
-        Self {
-            cost: Cost::Canonicalize,
-        }
-    }
-}
-
-impl Options for IsConstantOpts {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-impl IsConstantOpts {
-    pub fn is_negligible_cost(&self) -> bool {
-        self.cost == Cost::Negligible
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::IntoArray as _;
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::is_constant;
-    use crate::expr::stats::Stat;
-
-    #[test]
-    fn is_constant_min_max_no_nan() {
-        let arr = buffer![0, 1].into_array();
-        arr.statistics()
-            .compute_all(&[Stat::Min, Stat::Max])
-            .unwrap();
-        assert!(!is_constant(&arr).unwrap().unwrap_or_default());
-
-        let arr = buffer![0, 0].into_array();
-        arr.statistics()
-            .compute_all(&[Stat::Min, Stat::Max])
-            .unwrap();
-        assert!(is_constant(&arr).unwrap().unwrap_or_default());
-
-        let arr = PrimitiveArray::from_option_iter([Some(0), Some(0)]);
-        assert!(is_constant(arr.as_ref()).unwrap().unwrap_or_default());
-    }
-
-    #[test]
-    fn is_constant_min_max_with_nan() {
-        let arr = PrimitiveArray::from_iter([0.0, 0.0, f32::NAN]);
-        arr.statistics()
-            .compute_all(&[Stat::Min, Stat::Max])
-            .unwrap();
-        assert!(!is_constant(arr.as_ref()).unwrap().unwrap_or_default());
-
-        let arr =
-            PrimitiveArray::from_option_iter([Some(f32::NEG_INFINITY), Some(f32::NEG_INFINITY)]);
-        arr.statistics()
-            .compute_all(&[Stat::Min, Stat::Max])
-            .unwrap();
-        assert!(is_constant(arr.as_ref()).unwrap().unwrap_or_default());
-    }
-}
diff --git a/vortex-array/src/compute/is_sorted.rs b/vortex-array/src/compute/is_sorted.rs
deleted file mode 100644
index dd4151fd61f..00000000000
--- a/vortex-array/src/compute/is_sorted.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::Any;
-use std::sync::LazyLock;
-
-use arcref::ArcRef;
-use vortex_error::VortexError;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-
-use crate::Array;
-use crate::arrays::ConstantVTable;
-use crate::arrays::NullVTable;
-use crate::compute::ComputeFn;
-use crate::compute::ComputeFnVTable;
-use crate::compute::InvocationArgs;
-use crate::compute::Kernel;
-use crate::compute::Options;
-use crate::compute::Output;
-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::scalar::Scalar;
-use crate::vtable::VTable;
-
-static IS_SORTED_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
-    let compute = ComputeFn::new("is_sorted".into(), ArcRef::new_ref(&IsSorted));
-    for kernel in inventory::iter::<IsSortedKernelRef> {
-        compute.register_kernel(kernel.0.clone());
-    }
-    compute
-});
-
-pub(crate) fn warm_up_vtable() -> usize {
-    IS_SORTED_FN.kernels().len()
-}
-
-pub fn is_sorted(array: &dyn Array) -> VortexResult<Option<bool>> {
-    is_sorted_opts(array, false)
-}
-
-pub fn is_strict_sorted(array: &dyn Array) -> VortexResult<Option<bool>> {
-    is_sorted_opts(array, true)
-}
-
-pub fn is_sorted_opts(array: &dyn Array, strict: bool) -> VortexResult<Option<bool>> {
-    Ok(IS_SORTED_FN
-        .invoke(&InvocationArgs {
-            inputs: &[array.into()],
-            options: &IsSortedOptions { strict },
-        })?
-        .unwrap_scalar()?
-        .as_bool()
-        .value())
-}
-
-struct IsSorted;
-impl ComputeFnVTable for IsSorted {
-    fn invoke(
-        &self,
-        args: &InvocationArgs,
-        kernels: &[ArcRef<dyn Kernel>],
-    ) -> VortexResult<Output> {
-        let IsSortedArgs { array, strict } = IsSortedArgs::try_from(args)?;
-
-        // We currently don't support sorting struct arrays.
-        if array.dtype().is_struct() {
-            let scalar: Scalar = Some(false).into();
-            return Ok(scalar.into());
-        }
-
-        let is_sorted = if strict {
-            if let Some(Precision::Exact(value)) =
-                array.statistics().get_as::<bool>(Stat::IsStrictSorted)
-            {
-                let scalar: Scalar = Some(value).into();
-                return Ok(scalar.into());
-            }
-
-            let is_strict_sorted = is_sorted_impl(array, kernels, true)?;
-            let array_stats = array.statistics();
-
-            if is_strict_sorted.is_some() {
-                if is_strict_sorted.unwrap_or(false) {
-                    array_stats.set(Stat::IsSorted, Precision::Exact(true.into()));
-                    array_stats.set(Stat::IsStrictSorted, Precision::Exact(true.into()));
-                } else {
-                    array_stats.set(Stat::IsStrictSorted, Precision::Exact(false.into()));
-                }
-            }
-
-            is_strict_sorted
-        } else {
-            if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(Stat::IsSorted)
-            {
-                let scalar: Scalar = Some(value).into();
-                return Ok(scalar.into());
-            }
-
-            let is_sorted = is_sorted_impl(array, kernels, false)?;
-            let array_stats = array.statistics();
-
-            if is_sorted.is_some() {
-                if is_sorted.unwrap_or(false) {
-                    array_stats.set(Stat::IsSorted, Precision::Exact(true.into()));
-                } else {
-                    array_stats.set(Stat::IsSorted, Precision::Exact(false.into()));
-                    array_stats.set(Stat::IsStrictSorted, Precision::Exact(false.into()));
-                }
-            }
-
-            is_sorted
-        };
-
-        let scalar: Scalar = is_sorted.into();
-        Ok(scalar.into())
-    }
-
-    fn return_dtype(&self, _args: &InvocationArgs) -> VortexResult<DType> {
-        // We always return a nullable boolean where `null` indicates we couldn't determine
-        // whether the array is constant.
-        Ok(DType::Bool(Nullability::Nullable))
-    }
-
-    fn return_len(&self, _args: &InvocationArgs) -> VortexResult<usize> {
-        Ok(1)
-    }
-
-    fn is_elementwise(&self) -> bool {
-        true
-    }
-}
-
-struct IsSortedArgs<'a> {
-    array: &'a dyn Array,
-    strict: bool,
-}
-
-impl<'a> TryFrom<&InvocationArgs<'a>> for IsSortedArgs<'a> {
-    type Error = VortexError;
-
-    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
-        if value.inputs.len() != 1 {
-            vortex_bail!(
-                "IsSorted function requires exactly one argument, got {}",
-                value.inputs.len()
-            );
-        }
-        let array = value.inputs[0]
-            .array()
-            .ok_or_else(|| vortex_err!("Invalid argument type for is sorted function"))?;
-        let options = *value
-            .options
-            .as_any()
-            .downcast_ref::<IsSortedOptions>()
-            .ok_or_else(|| vortex_err!("Invalid options type for is sorted function"))?;
-
-        Ok(IsSortedArgs {
-            array,
-            strict: options.strict,
-        })
-    }
-}
-
-#[derive(Clone, Copy)]
-struct IsSortedOptions {
-    strict: bool,
-}
-
-impl Options for IsSortedOptions {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-pub struct IsSortedKernelRef(ArcRef<dyn Kernel>);
-inventory::collect!(IsSortedKernelRef);
-
-#[derive(Debug)]
-pub struct IsSortedKernelAdapter<V: VTable>(pub V);
-
-impl<V: VTable + IsSortedKernel> IsSortedKernelAdapter<V> {
-    pub const fn lift(&'static self) -> IsSortedKernelRef {
-        IsSortedKernelRef(ArcRef::new_ref(self))
-    }
-}
-
-impl<V: VTable + IsSortedKernel> Kernel for IsSortedKernelAdapter<V> {
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
-        let IsSortedArgs { array, strict } = IsSortedArgs::try_from(args)?;
-        let Some(array) = array.as_opt::<V>() else {
-            return Ok(None);
-        };
-
-        let is_sorted = if strict {
-            V::is_strict_sorted(&self.0, array)?
-        } else {
-            V::is_sorted(&self.0, array)?
-        };
-
-        let scalar: Scalar = is_sorted.into();
-        Ok(Some(scalar.into()))
-    }
-}
-
-pub trait IsSortedKernel: VTable {
-    /// # Preconditions
-    /// - The array's length is > 1.
-    /// - The array is not encoded as `NullArray` or `ConstantArray`.
-    /// - If doing a `strict` check, if the array is nullable, it'll have at most 1 null element
-    ///   as the first item in the array.
-    fn is_sorted(&self, array: &Self::Array) -> VortexResult<Option<bool>>;
-
-    fn is_strict_sorted(&self, array: &Self::Array) -> VortexResult<Option<bool>>;
-}
-
-#[expect(
-    clippy::wrong_self_convention,
-    reason = "is_* naming follows Iterator::is_sorted convention"
-)]
-/// Helper methods to check sortedness with strictness
-pub trait IsSortedIteratorExt: Iterator
-where
-    <Self as Iterator>::Item: PartialOrd,
-{
-    fn is_strict_sorted(self) -> bool
-    where
-        Self: Sized,
-        Self::Item: PartialOrd,
-    {
-        self.is_sorted_by(|a, b| a < b)
-    }
-}
-
-impl<T> IsSortedIteratorExt for T
-where
-    T: Iterator + ?Sized,
-    T::Item: PartialOrd,
-{
-}
-
-fn is_sorted_impl(
-    array: &dyn Array,
-    kernels: &[ArcRef<dyn Kernel>],
-    strict: bool,
-) -> VortexResult<Option<bool>> {
-    // Arrays with 0 or 1 elements are strict sorted.
-    if array.len() <= 1 {
-        return Ok(Some(true));
-    }
-
-    // Constant and null arrays are always sorted, but not strict sorted.
-    if array.is::<ConstantVTable>() || array.is::<NullVTable>() {
-        return Ok(Some(!strict));
-    }
-
-    // Enforce strictness before we even try to check if the array is sorted.
-    if strict {
-        let invalid_count = array.invalid_count()?;
-        match invalid_count {
-            // We can keep going
-            0 => {}
-            // If we have a potential null value - it has to be the first one.
-            1 => {
-                if !array.is_invalid(0)? {
-                    return Ok(Some(false));
-                }
-            }
-            _ => return Ok(Some(false)),
-        }
-    }
-
-    let args = InvocationArgs {
-        inputs: &[array.into()],
-        options: &IsSortedOptions { strict },
-    };
-
-    for kernel in kernels {
-        if let Some(output) = kernel.invoke(&args)? {
-            return Ok(output.unwrap_scalar()?.as_bool().value());
-        }
-    }
-
-    if !array.is_canonical() {
-        tracing::debug!(
-            "No is_sorted implementation found for {}",
-            array.encoding_id()
-        );
-
-        // Recurse to canonical implementation
-        let array = array.to_canonical()?;
-
-        return if strict {
-            is_strict_sorted(array.as_ref())
-        } else {
-            is_sorted(array.as_ref())
-        };
-    }
-
-    vortex_bail!(
-        "No is_sorted function for canonical array: {}",
-        array.encoding_id(),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::buffer;
-
-    use crate::IntoArray;
-    use crate::arrays::BoolArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::is_sorted;
-    use crate::compute::is_strict_sorted;
-    use crate::validity::Validity;
-    #[test]
-    fn test_is_sorted() {
-        assert!(
-            is_sorted(PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).as_ref())
-                .unwrap()
-                .unwrap()
-        );
-        assert!(
-            is_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 2, 3),
-                    Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array())
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-        assert!(
-            !is_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 2, 3),
-                    Validity::Array(BoolArray::from_iter([true, false, true, true]).into_array())
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-
-        assert!(
-            !is_sorted(PrimitiveArray::new(buffer!(0, 1, 3, 2), Validity::AllValid).as_ref())
-                .unwrap()
-                .unwrap()
-        );
-        assert!(
-            !is_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 3, 2),
-                    Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn test_is_strict_sorted() {
-        assert!(
-            is_strict_sorted(PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).as_ref())
-                .unwrap()
-                .unwrap()
-        );
-        assert!(
-            is_strict_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 2, 3),
-                    Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array())
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-        assert!(
-            !is_strict_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 2, 3),
-                    Validity::Array(BoolArray::from_iter([true, false, true, true]).into_array()),
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-
-        assert!(
-            !is_strict_sorted(
-                PrimitiveArray::new(
-                    buffer!(0, 1, 3, 2),
-                    Validity::Array(BoolArray::from_iter([false, true, true, true]).into_array()),
-                )
-                .as_ref()
-            )
-            .unwrap()
-            .unwrap()
-        );
-    }
-}
diff --git a/vortex-array/src/compute/list_contains.rs b/vortex-array/src/compute/list_contains.rs
deleted file mode 100644
index 6591c1611e5..00000000000
--- a/vortex-array/src/compute/list_contains.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::builtins::ArrayBuiltins;
-
-/// Compute a `Bool`-typed array the same length as `array` where elements is `true` if the list
-/// item contains the `value`, `false` otherwise.
-///
-/// **Deprecated**: Use `array.list_contains(value)` via [`crate::builtins::ArrayBuiltins`] instead.
-#[deprecated(note = "Use `array.list_contains(value)` via `ArrayBuiltins` instead")]
-pub fn list_contains(array: &dyn Array, value: &dyn Array) -> VortexResult<ArrayRef> {
-    array.to_array().list_contains(value.to_array())
-}
diff --git a/vortex-array/src/compute/mask.rs b/vortex-array/src/compute/mask.rs
deleted file mode 100644
index d3526daff61..00000000000
--- a/vortex-array/src/compute/mask.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::ops::Not;
-
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::arrays::ConstantArray;
-use crate::builtins::ArrayBuiltins;
-use crate::scalar::Scalar;
-
-/// Replace values with null where the mask is true.
-///
-/// The returned array is nullable but otherwise has the same dtype and length as `array`.
-///
-/// This function returns a lazy `ScalarFnArray` wrapping the [`Mask`](crate::scalar_fn::fns::mask::Mask)
-/// expression that defers the actual masking operation until execution time. The mask is inverted
-/// (true=mask-out becomes true=keep) and passed as a boolean child to the expression.
-#[deprecated(note = "use array.mask(mask_array) via ArrayBuiltins instead")]
-pub fn mask(array: &dyn Array, mask: &Mask) -> VortexResult<ArrayRef> {
-    let mask = mask.not();
-    match mask {
-        Mask::AllTrue(_) => array.to_array().cast(array.dtype().as_nullable()),
-        Mask::AllFalse(_) => Ok(ConstantArray::new(
-            Scalar::null(array.dtype().as_nullable()),
-            array.len(),
-        )
-        .into_array()),
-        Mask::Values(val) => array.to_array().mask(val.into_array()),
-    }
-}
diff --git a/vortex-array/src/compute/min_max.rs b/vortex-array/src/compute/min_max.rs
deleted file mode 100644
index 78fe3333423..00000000000
--- a/vortex-array/src/compute/min_max.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::sync::LazyLock;
-
-use arcref::ArcRef;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-
-use crate::Array;
-use crate::arrays::ConstantVTable;
-use crate::compute::ComputeFn;
-use crate::compute::ComputeFnVTable;
-use crate::compute::InvocationArgs;
-use crate::compute::Kernel;
-use crate::compute::Output;
-use crate::compute::UnaryArgs;
-use crate::dtype::DType;
-use crate::dtype::FieldNames;
-use crate::dtype::Nullability;
-use crate::dtype::StructFields;
-use crate::expr::stats::Precision;
-use crate::expr::stats::Stat;
-use crate::expr::stats::StatsProvider;
-use crate::scalar::Scalar;
-use crate::vtable::VTable;
-
-static NAMES: LazyLock<FieldNames> = LazyLock::new(|| FieldNames::from(["min", "max"]));
-
-static MIN_MAX_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
-    let compute = ComputeFn::new("min_max".into(), ArcRef::new_ref(&MinMax));
-    for kernel in inventory::iter::<MinMaxKernelRef> {
-        compute.register_kernel(kernel.0.clone());
-    }
-    compute
-});
-
-pub(crate) fn warm_up_vtable() -> usize {
-    MIN_MAX_FN.kernels().len()
-}
-
-/// The minimum and maximum non-null values of an array, or None if there are no non-null values.
-///
-/// The return value dtype is the non-nullable version of the array dtype.
-///
-/// This will update the stats set of this array (as a side effect).
-pub fn min_max(array: &dyn Array) -> VortexResult<Option<MinMaxResult>> {
-    let scalar = MIN_MAX_FN
-        .invoke(&InvocationArgs {
-            inputs: &[array.into()],
-            options: &(),
-        })?
-        .unwrap_scalar()?;
-    MinMaxResult::from_scalar(scalar)
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MinMaxResult {
-    pub min: Scalar,
-    pub max: Scalar,
-}
-
-impl MinMaxResult {
-    pub fn from_scalar(scalar: Scalar) -> VortexResult<Option<Self>> {
-        if scalar.is_null() {
-            Ok(None)
-        } else {
-            let min = scalar
-                .as_struct()
-                .field_by_idx(0)
-                .vortex_expect("missing min field");
-            let max = scalar
-                .as_struct()
-                .field_by_idx(1)
-                .vortex_expect("missing max field");
-            Ok(Some(MinMaxResult { min, max }))
-        }
-    }
-}
-
-pub struct MinMax;
-
-impl ComputeFnVTable for MinMax {
-    fn invoke(
-        &self,
-        args: &InvocationArgs,
-        kernels: &[ArcRef<dyn Kernel>],
-    ) -> VortexResult<Output> {
-        let UnaryArgs { array, .. } = UnaryArgs::<()>::try_from(args)?;
-
-        let return_dtype = self.return_dtype(args)?;
-
-        match min_max_impl(array, kernels)? {
-            None => Ok(Scalar::null(return_dtype).into()),
-            Some(MinMaxResult { min, max }) => {
-                assert!(
-                    min <= max,
-                    "min > max: min={} max={} encoding={}",
-                    min,
-                    max,
-                    array.encoding_id()
-                );
-
-                // Update the stats set with the computed min/max.
-                if let Some(min_value) = min.value() {
-                    array
-                        .statistics()
-                        .set(Stat::Min, Precision::Exact(min_value.clone()));
-                }
-                if let Some(max_value) = max.value() {
-                    array
-                        .statistics()
-                        .set(Stat::Max, Precision::Exact(max_value.clone()));
-                }
-
-                // Return the min/max as a struct scalar
-                Ok(Scalar::struct_(return_dtype, vec![min, max]).into())
-            }
-        }
-    }
-
-    fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {
-        let UnaryArgs { array, .. } = UnaryArgs::<()>::try_from(args)?;
-
-        // We return a min/max struct scalar, where the overall struct is nullable in the case
-        // that the array is all null or empty.
-        Ok(DType::Struct(
-            StructFields::new(
-                NAMES.clone(),
-                vec![
-                    array.dtype().as_nonnullable(),
-                    array.dtype().as_nonnullable(),
-                ],
-            ),
-            Nullability::Nullable,
-        ))
-    }
-
-    fn return_len(&self, _args: &InvocationArgs) -> VortexResult<usize> {
-        Ok(1)
-    }
-
-    fn is_elementwise(&self) -> bool {
-        false
-    }
-}
-
-fn min_max_impl(
-    array: &dyn Array,
-    kernels: &[ArcRef<dyn Kernel>],
-) -> VortexResult<Option<MinMaxResult>> {
-    if array.is_empty() || array.valid_count()? == 0 {
-        return Ok(None);
-    }
-
-    if let Some(array) = array.as_opt::<ConstantVTable>() {
-        return ConstantVTable.min_max(array);
-    }
-
-    let min = array
-        .statistics()
-        .get(Stat::Min)
-        .and_then(Precision::as_exact);
-    let max = array
-        .statistics()
-        .get(Stat::Max)
-        .and_then(Precision::as_exact);
-
-    if let Some((min, max)) = min.zip(max) {
-        let non_nullable_dtype = array.dtype().as_nonnullable();
-        return Ok(Some(MinMaxResult {
-            min: min.cast(&non_nullable_dtype)?,
-            max: max.cast(&non_nullable_dtype)?,
-        }));
-    }
-
-    let args = InvocationArgs {
-        inputs: &[array.into()],
-        options: &(),
-    };
-    for kernel in kernels {
-        if let Some(output) = kernel.invoke(&args)? {
-            return MinMaxResult::from_scalar(output.unwrap_scalar()?);
-        }
-    }
-
-    if !array.is_canonical() {
-        let array = array.to_canonical()?;
-        return min_max(array.as_ref());
-    }
-
-    vortex_bail!(NotImplemented: "min_max", array.encoding_id());
-}
-
-/// The minimum and maximum non-null values of an array, or None if there are no non-null/or non-nan
-/// values.
-pub trait MinMaxKernel: VTable {
-    fn min_max(&self, array: &Self::Array) -> VortexResult<Option<MinMaxResult>>;
-}
-
-pub struct MinMaxKernelRef(ArcRef<dyn Kernel>);
-inventory::collect!(MinMaxKernelRef);
-
-#[derive(Debug)]
-pub struct MinMaxKernelAdapter<V: VTable>(pub V);
-
-impl<V: VTable + MinMaxKernel> MinMaxKernelAdapter<V> {
-    pub const fn lift(&'static self) -> MinMaxKernelRef {
-        MinMaxKernelRef(ArcRef::new_ref(self))
-    }
-}
-
-impl<V: VTable + MinMaxKernel> Kernel for MinMaxKernelAdapter<V> {
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
-        let inputs = UnaryArgs::<()>::try_from(args)?;
-        let Some(array) = inputs.array.as_opt::<V>() else {
-            return Ok(None);
-        };
-        let non_nullable_dtype = array.dtype().as_nonnullable();
-        let dtype = DType::Struct(
-            StructFields::new(
-                NAMES.clone(),
-                vec![non_nullable_dtype.clone(), non_nullable_dtype],
-            ),
-            Nullability::Nullable,
-        );
-        Ok(Some(match V::min_max(&self.0, array)? {
-            None => Scalar::null(dtype).into(),
-            Some(MinMaxResult { min, max }) => Scalar::struct_(dtype, vec![min, max]).into(),
-        }))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_buffer::BitBuffer;
-    use vortex_buffer::buffer;
-
-    use crate::arrays::BoolArray;
-    use crate::arrays::NullArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::MinMaxResult;
-    use crate::compute::min_max;
-    use crate::validity::Validity;
-
-    #[test]
-    fn test_prim_max() {
-        let p = PrimitiveArray::new(buffer![1, 2, 3], Validity::NonNullable);
-        assert_eq!(
-            min_max(p.as_ref()).unwrap(),
-            Some(MinMaxResult {
-                min: 1.into(),
-                max: 3.into()
-            })
-        );
-    }
-
-    #[test]
-    fn test_bool_max() {
-        let p = BoolArray::new(
-            BitBuffer::from([true, true, true].as_slice()),
-            Validity::NonNullable,
-        );
-        assert_eq!(
-            min_max(p.as_ref()).unwrap(),
-            Some(MinMaxResult {
-                min: true.into(),
-                max: true.into()
-            })
-        );
-
-        let p = BoolArray::new(
-            BitBuffer::from([false, false, false].as_slice()),
-            Validity::NonNullable,
-        );
-        assert_eq!(
-            min_max(p.as_ref()).unwrap(),
-            Some(MinMaxResult {
-                min: false.into(),
-                max: false.into()
-            })
-        );
-
-        let p = BoolArray::new(
-            BitBuffer::from([false, true, false].as_slice()),
-            Validity::NonNullable,
-        );
-        assert_eq!(
-            min_max(p.as_ref()).unwrap(),
-            Some(MinMaxResult {
-                min: false.into(),
-                max: true.into()
-            })
-        );
-    }
-
-    #[test]
-    fn test_null() {
-        let p = NullArray::new(1);
-        assert_eq!(min_max(p.as_ref()).unwrap(), None);
-    }
-}
diff --git a/vortex-array/src/compute/mod.rs b/vortex-array/src/compute/mod.rs
index 67d58cfbcad..7cf2741bb03 100644
--- a/vortex-array/src/compute/mod.rs
+++ b/vortex-array/src/compute/mod.rs
@@ -1,444 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Compute kernels on top of Vortex Arrays.
-//!
-//! We aim to provide a basic set of compute kernels that can be used to efficiently index, slice,
-//! and filter Vortex Arrays in their encoded forms.
-//!
-//! Every array encoding has the ability to implement their own efficient implementations of these
-//! operators, else we will decode, and perform the equivalent operator from Arrow.
-
-use std::any::Any;
-use std::any::type_name;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-
-use arcref::ArcRef;
-pub use boolean::*;
-#[expect(deprecated)]
-pub use cast::cast;
-pub use compare::*;
-pub use fill_null::*;
-pub use filter::*;
-#[expect(deprecated)]
-pub use invert::invert;
-pub use is_constant::*;
-pub use is_sorted::*;
-use itertools::Itertools;
-#[expect(deprecated)]
-pub use list_contains::list_contains;
-pub use mask::*;
-pub use min_max::*;
-pub use nan_count::*;
-pub use numeric::*;
-use parking_lot::RwLock;
-pub use sum::*;
-use vortex_error::VortexError;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-use vortex_mask::Mask;
-pub use zip::*;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::builders::ArrayBuilder;
-use crate::dtype::DType;
-use crate::scalar::Scalar;
-
-#[cfg(feature = "arbitrary")]
-mod arbitrary;
-mod boolean;
-mod cast;
-mod compare;
 #[cfg(feature = "_test-harness")]
 pub mod conformance;
-mod fill_null;
-mod filter;
-mod invert;
-mod is_constant;
-mod is_sorted;
-mod list_contains;
-mod mask;
-mod min_max;
-mod nan_count;
-mod numeric;
-mod sum;
-mod zip;
-
-/// An instance of a compute function holding the implementation vtable and a set of registered
-/// compute kernels.
-pub struct ComputeFn {
-    id: ArcRef<str>,
-    vtable: ArcRef<dyn ComputeFnVTable>,
-    kernels: RwLock<Vec<ArcRef<dyn Kernel>>>,
-}
-
-/// Force all the default [`ComputeFn`] vtables to register all available compute kernels.
-///
-/// Mostly useful for small benchmarks where the overhead might cause noise depending on the order of benchmarks.
-pub fn warm_up_vtables() {
-    #[allow(unused_qualifications)]
-    is_constant::warm_up_vtable();
-    is_sorted::warm_up_vtable();
-    min_max::warm_up_vtable();
-    nan_count::warm_up_vtable();
-    sum::warm_up_vtable();
-}
-
-impl ComputeFn {
-    /// Create a new compute function from the given [`ComputeFnVTable`].
-    pub fn new(id: ArcRef<str>, vtable: ArcRef<dyn ComputeFnVTable>) -> Self {
-        Self {
-            id,
-            vtable,
-            kernels: Default::default(),
-        }
-    }
-
-    /// Returns the string identifier of the compute function.
-    pub fn id(&self) -> &ArcRef<str> {
-        &self.id
-    }
-
-    /// Register a kernel for the compute function.
-    pub fn register_kernel(&self, kernel: ArcRef<dyn Kernel>) {
-        self.kernels.write().push(kernel);
-    }
-
-    /// Invokes the compute function with the given arguments.
-    pub fn invoke(&self, args: &InvocationArgs) -> VortexResult<Output> {
-        // Perform some pre-condition checks against the arguments and the function properties.
-        if self.is_elementwise() {
-            // For element-wise functions, all input arrays must be the same length.
-            if !args
-                .inputs
-                .iter()
-                .filter_map(|input| input.array())
-                .map(|array| array.len())
-                .all_equal()
-            {
-                vortex_bail!(
-                    "Compute function {} is elementwise but input arrays have different lengths",
-                    self.id
-                );
-            }
-        }
-
-        let expected_dtype = self.vtable.return_dtype(args)?;
-        let expected_len = self.vtable.return_len(args)?;
-
-        let output = self.vtable.invoke(args, &self.kernels.read())?;
-
-        if output.dtype() != &expected_dtype {
-            vortex_bail!(
-                "Internal error: compute function {} returned a result of type {} but expected {}\n{}",
-                self.id,
-                output.dtype(),
-                &expected_dtype,
-                args.inputs
-                    .iter()
-                    .filter_map(|input| input.array())
-                    .format_with(",", |array, f| f(&array.encoding_id()))
-            );
-        }
-        if output.len() != expected_len {
-            vortex_bail!(
-                "Internal error: compute function {} returned a result of length {} but expected {}",
-                self.id,
-                output.len(),
-                expected_len
-            );
-        }
-
-        Ok(output)
-    }
-
-    /// Compute the return type of the function given the input arguments.
-    pub fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {
-        self.vtable.return_dtype(args)
-    }
-
-    /// Compute the return length of the function given the input arguments.
-    pub fn return_len(&self, args: &InvocationArgs) -> VortexResult<usize> {
-        self.vtable.return_len(args)
-    }
-
-    /// Returns whether the compute function is elementwise, i.e. the output is the same shape as
-    pub fn is_elementwise(&self) -> bool {
-        // TODO(ngates): should this just be a constant passed in the constructor?
-        self.vtable.is_elementwise()
-    }
-
-    /// Returns the compute function's kernels.
-    pub fn kernels(&self) -> Vec<ArcRef<dyn Kernel>> {
-        self.kernels.read().to_vec()
-    }
-}
-
-/// VTable for the implementation of a compute function.
-pub trait ComputeFnVTable: 'static + Send + Sync {
-    /// Invokes the compute function entry-point with the given input arguments and options.
-    ///
-    /// The entry-point logic can short-circuit compute using statistics, update result array
-    /// statistics, search for relevant compute kernels, and canonicalize the inputs in order
-    /// to successfully compute a result.
-    fn invoke(&self, args: &InvocationArgs, kernels: &[ArcRef<dyn Kernel>])
-    -> VortexResult<Output>;
-
-    /// Computes the return type of the function given the input arguments.
-    ///
-    /// All kernel implementations will be validated to return the [`DType`] as computed here.
-    fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType>;
-
-    /// Computes the return length of the function given the input arguments.
-    ///
-    /// All kernel implementations will be validated to return the len as computed here.
-    /// Scalars are considered to have length 1.
-    fn return_len(&self, args: &InvocationArgs) -> VortexResult<usize>;
-
-    /// Returns whether the function operates elementwise, i.e. the output is the same shape as the
-    /// input and no information is shared between elements.
-    ///
-    /// Examples include `add`, `subtract`, `and`, `cast`, `fill_null` etc.
-    /// Examples that are not elementwise include `sum`, `count`, `min`, `fill_forward` etc.
-    ///
-    /// All input arrays to an elementwise function *must* have the same length.
-    fn is_elementwise(&self) -> bool;
-}
-
-/// Arguments to a compute function invocation.
-#[derive(Clone)]
-pub struct InvocationArgs<'a> {
-    pub inputs: &'a [Input<'a>],
-    pub options: &'a dyn Options,
-}
-
-/// For unary compute functions, it's useful to just have this short-cut.
-pub struct UnaryArgs<'a, O: Options> {
-    pub array: &'a dyn Array,
-    pub options: &'a O,
-}
-
-impl<'a, O: Options> TryFrom<&InvocationArgs<'a>> for UnaryArgs<'a, O> {
-    type Error = VortexError;
-
-    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
-        if value.inputs.len() != 1 {
-            vortex_bail!("Expected 1 input, found {}", value.inputs.len());
-        }
-        let array = value.inputs[0]
-            .array()
-            .ok_or_else(|| vortex_err!("Expected input 0 to be an array"))?;
-        let options =
-            value.options.as_any().downcast_ref::<O>().ok_or_else(|| {
-                vortex_err!("Expected options to be of type {}", type_name::<O>())
-            })?;
-        Ok(UnaryArgs { array, options })
-    }
-}
-
-/// For binary compute functions, it's useful to just have this short-cut.
-pub struct BinaryArgs<'a, O: Options> {
-    pub lhs: &'a dyn Array,
-    pub rhs: &'a dyn Array,
-    pub options: &'a O,
-}
-
-impl<'a, O: Options> TryFrom<&InvocationArgs<'a>> for BinaryArgs<'a, O> {
-    type Error = VortexError;
-
-    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
-        if value.inputs.len() != 2 {
-            vortex_bail!("Expected 2 input, found {}", value.inputs.len());
-        }
-        let lhs = value.inputs[0]
-            .array()
-            .ok_or_else(|| vortex_err!("Expected input 0 to be an array"))?;
-        let rhs = value.inputs[1]
-            .array()
-            .ok_or_else(|| vortex_err!("Expected input 1 to be an array"))?;
-        let options =
-            value.options.as_any().downcast_ref::<O>().ok_or_else(|| {
-                vortex_err!("Expected options to be of type {}", type_name::<O>())
-            })?;
-        Ok(BinaryArgs { lhs, rhs, options })
-    }
-}
-
-/// Input to a compute function.
-pub enum Input<'a> {
-    Scalar(&'a Scalar),
-    Array(&'a dyn Array),
-    Mask(&'a Mask),
-    Builder(&'a mut dyn ArrayBuilder),
-    DType(&'a DType),
-}
-
-impl Debug for Input<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let mut f = f.debug_struct("Input");
-        match self {
-            Input::Scalar(scalar) => f.field("Scalar", scalar),
-            Input::Array(array) => f.field("Array", array),
-            Input::Mask(mask) => f.field("Mask", mask),
-            Input::Builder(builder) => f.field("Builder", &builder.len()),
-            Input::DType(dtype) => f.field("DType", dtype),
-        };
-        f.finish()
-    }
-}
-
-impl<'a> From<&'a dyn Array> for Input<'a> {
-    fn from(value: &'a dyn Array) -> Self {
-        Input::Array(value)
-    }
-}
-
-impl<'a> From<&'a Scalar> for Input<'a> {
-    fn from(value: &'a Scalar) -> Self {
-        Input::Scalar(value)
-    }
-}
-
-impl<'a> From<&'a Mask> for Input<'a> {
-    fn from(value: &'a Mask) -> Self {
-        Input::Mask(value)
-    }
-}
-
-impl<'a> From<&'a DType> for Input<'a> {
-    fn from(value: &'a DType) -> Self {
-        Input::DType(value)
-    }
-}
-
-impl<'a> Input<'a> {
-    pub fn scalar(&self) -> Option<&'a Scalar> {
-        if let Input::Scalar(scalar) = self {
-            Some(*scalar)
-        } else {
-            None
-        }
-    }
-
-    pub fn array(&self) -> Option<&'a dyn Array> {
-        if let Input::Array(array) = self {
-            Some(*array)
-        } else {
-            None
-        }
-    }
-
-    pub fn mask(&self) -> Option<&'a Mask> {
-        if let Input::Mask(mask) = self {
-            Some(*mask)
-        } else {
-            None
-        }
-    }
-
-    pub fn builder(&'a mut self) -> Option<&'a mut dyn ArrayBuilder> {
-        if let Input::Builder(builder) = self {
-            Some(*builder)
-        } else {
-            None
-        }
-    }
-
-    pub fn dtype(&self) -> Option<&'a DType> {
-        if let Input::DType(dtype) = self {
-            Some(*dtype)
-        } else {
-            None
-        }
-    }
-}
-
-/// Output from a compute function.
-#[derive(Debug)]
-pub enum Output {
-    Scalar(Scalar),
-    Array(ArrayRef),
-}
-
-#[expect(
-    clippy::len_without_is_empty,
-    reason = "Output is always non-empty (scalar has len 1)"
-)]
-impl Output {
-    pub fn dtype(&self) -> &DType {
-        match self {
-            Output::Scalar(scalar) => scalar.dtype(),
-            Output::Array(array) => array.dtype(),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        match self {
-            Output::Scalar(_) => 1,
-            Output::Array(array) => array.len(),
-        }
-    }
-
-    pub fn unwrap_scalar(self) -> VortexResult<Scalar> {
-        match self {
-            Output::Array(_) => vortex_bail!("Expected scalar output, got Array"),
-            Output::Scalar(scalar) => Ok(scalar),
-        }
-    }
-
-    pub fn unwrap_array(self) -> VortexResult<ArrayRef> {
-        match self {
-            Output::Array(array) => Ok(array),
-            Output::Scalar(_) => vortex_bail!("Expected array output, got Scalar"),
-        }
-    }
-}
-
-impl From<ArrayRef> for Output {
-    fn from(value: ArrayRef) -> Self {
-        Output::Array(value)
-    }
-}
-
-impl From<Scalar> for Output {
-    fn from(value: Scalar) -> Self {
-        Output::Scalar(value)
-    }
-}
-
-/// Options for a compute function invocation.
-pub trait Options: 'static {
-    fn as_any(&self) -> &dyn Any;
-}
-
-impl Options for () {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-/// Compute functions can ask arrays for compute kernels for a given invocation.
-///
-/// The kernel is invoked with the input arguments and options, and can return `None` if it is
-/// unable to compute the result for the given inputs due to missing implementation logic.
-/// For example, if kernel doesn't support the `LTE` operator. By returning `None`, the kernel
-/// is indicating that it cannot compute the result for the given inputs, and another kernel should
-/// be tried. *Not* that the given inputs are invalid for the compute function.
-///
-/// If the kernel fails to compute a result, it should return a `Some` with the error.
-pub trait Kernel: 'static + Send + Sync + Debug {
-    /// Invokes the kernel with the given input arguments and options.
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>>;
-}
-
-/// Register a kernel for a compute function.
-/// See each compute function for the correct type of kernel to register.
-#[macro_export]
-macro_rules! register_kernel {
-    ($T:expr) => {
-        $crate::aliases::inventory::submit!($T);
-    };
-}
diff --git a/vortex-array/src/compute/nan_count.rs b/vortex-array/src/compute/nan_count.rs
deleted file mode 100644
index b0cbb707a21..00000000000
--- a/vortex-array/src/compute/nan_count.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::sync::LazyLock;
-
-use arcref::ArcRef;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-
-use crate::Array;
-use crate::compute::ComputeFn;
-use crate::compute::ComputeFnVTable;
-use crate::compute::InvocationArgs;
-use crate::compute::Kernel;
-use crate::compute::Output;
-use crate::compute::UnaryArgs;
-use crate::dtype::DType;
-use crate::expr::stats::Precision;
-use crate::expr::stats::Stat;
-use crate::expr::stats::StatsProviderExt;
-use crate::scalar::Scalar;
-use crate::scalar::ScalarValue;
-use crate::vtable::VTable;
-
-static NAN_COUNT_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
-    let compute = ComputeFn::new("nan_count".into(), ArcRef::new_ref(&NaNCount));
-    for kernel in inventory::iter::<NaNCountKernelRef> {
-        compute.register_kernel(kernel.0.clone());
-    }
-    compute
-});
-
-pub(crate) fn warm_up_vtable() -> usize {
-    NAN_COUNT_FN.kernels().len()
-}
-
-/// Computes the number of NaN values in the array.
-pub fn nan_count(array: &dyn Array) -> VortexResult<usize> {
-    Ok(NAN_COUNT_FN
-        .invoke(&InvocationArgs {
-            inputs: &[array.into()],
-            options: &(),
-        })?
-        .unwrap_scalar()?
-        .as_primitive()
-        .as_::<usize>()
-        .vortex_expect("NaN count should not return null"))
-}
-
-struct NaNCount;
-
-impl ComputeFnVTable for NaNCount {
-    fn invoke(
-        &self,
-        args: &InvocationArgs,
-        kernels: &[ArcRef<dyn Kernel>],
-    ) -> VortexResult<Output> {
-        let UnaryArgs { array, .. } = UnaryArgs::<()>::try_from(args)?;
-
-        let nan_count = nan_count_impl(array, kernels)?;
-
-        // Update the stats set with the computed NaN count
-        array.statistics().set(
-            Stat::NaNCount,
-            Precision::Exact(ScalarValue::from(nan_count as u64)),
-        );
-
-        Ok(Scalar::from(nan_count as u64).into())
-    }
-
-    fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {
-        let UnaryArgs { array, .. } = UnaryArgs::<()>::try_from(args)?;
-        Stat::NaNCount
-            .dtype(array.dtype())
-            .ok_or_else(|| vortex_err!("Cannot compute NaN count for dtype {}", array.dtype()))
-    }
-
-    fn return_len(&self, _args: &InvocationArgs) -> VortexResult<usize> {
-        Ok(1)
-    }
-
-    fn is_elementwise(&self) -> bool {
-        false
-    }
-}
-
-/// Computes the min and max of an array, returning the (min, max) values
-pub trait NaNCountKernel: VTable {
-    fn nan_count(&self, array: &Self::Array) -> VortexResult<usize>;
-}
-
-pub struct NaNCountKernelRef(ArcRef<dyn Kernel>);
-inventory::collect!(NaNCountKernelRef);
-
-#[derive(Debug)]
-pub struct NaNCountKernelAdapter<V: VTable>(pub V);
-
-impl<V: VTable + NaNCountKernel> NaNCountKernelAdapter<V> {
-    pub const fn lift(&'static self) -> NaNCountKernelRef {
-        NaNCountKernelRef(ArcRef::new_ref(self))
-    }
-}
-
-impl<V: VTable + NaNCountKernel> Kernel for NaNCountKernelAdapter<V> {
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
-        let UnaryArgs { array, .. } = UnaryArgs::<()>::try_from(args)?;
-        let Some(array) = array.as_opt::<V>() else {
-            return Ok(None);
-        };
-        let nan_count = V::nan_count(&self.0, array)?;
-        Ok(Some(Scalar::from(nan_count as u64).into()))
-    }
-}
-
-fn nan_count_impl(array: &dyn Array, kernels: &[ArcRef<dyn Kernel>]) -> VortexResult<usize> {
-    if array.is_empty() || array.valid_count()? == 0 {
-        return Ok(0);
-    }
-
-    if let Some(nan_count) = array
-        .statistics()
-        .get_as::<usize>(Stat::NaNCount)
-        .and_then(Precision::as_exact)
-    {
-        // If the NaN count is already computed, return it
-        return Ok(nan_count);
-    }
-
-    let args = InvocationArgs {
-        inputs: &[array.into()],
-        options: &(),
-    };
-
-    for kernel in kernels {
-        if let Some(output) = kernel.invoke(&args)? {
-            return output
-                .unwrap_scalar()?
-                .as_primitive()
-                .as_::<usize>()
-                .ok_or_else(|| vortex_err!("NaN count should not return null"));
-        }
-    }
-
-    if !array.is_canonical() {
-        let canonical = array.to_canonical()?;
-        return nan_count(canonical.as_ref());
-    }
-
-    vortex_bail!(
-        "No NaN count kernel found for array type: {}",
-        array.dtype()
-    )
-}
diff --git a/vortex-array/src/compute/numeric.rs b/vortex-array/src/compute/numeric.rs
deleted file mode 100644
index e8d0e6a27b0..00000000000
--- a/vortex-array/src/compute/numeric.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::Any;
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::arrays::ConstantArray;
-use crate::arrow::Datum;
-use crate::arrow::from_arrow_array_with_len;
-use crate::builtins::ArrayBuiltins;
-use crate::compute::Options;
-use crate::scalar::NumericOperator;
-use crate::scalar::Scalar;
-use crate::scalar_fn::fns::operators::Operator;
-
-/// Point-wise add two numeric arrays.
-///
-/// Errs at runtime if the sum would overflow or underflow.
-///
-/// The result is null at any index that either input is null.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn add(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Add)
-}
-
-/// Point-wise add a scalar value to this array on the right-hand-side.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn add_scalar(lhs: &dyn Array, rhs: Scalar) -> VortexResult<ArrayRef> {
-    lhs.to_array()
-        .binary(ConstantArray::new(rhs, lhs.len()).to_array(), Operator::Add)
-}
-
-/// Point-wise subtract two numeric arrays.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn sub(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Sub)
-}
-
-/// Point-wise subtract a scalar value from this array on the right-hand-side.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn sub_scalar(lhs: &dyn Array, rhs: Scalar) -> VortexResult<ArrayRef> {
-    lhs.to_array()
-        .binary(ConstantArray::new(rhs, lhs.len()).to_array(), Operator::Sub)
-}
-
-/// Point-wise multiply two numeric arrays.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn mul(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Mul)
-}
-
-/// Point-wise multiply a scalar value into this array on the right-hand-side.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn mul_scalar(lhs: &dyn Array, rhs: Scalar) -> VortexResult<ArrayRef> {
-    lhs.to_array()
-        .binary(ConstantArray::new(rhs, lhs.len()).to_array(), Operator::Mul)
-}
-
-/// Point-wise divide two numeric arrays.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn div(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Div)
-}
-
-/// Point-wise divide a scalar value into this array on the right-hand-side.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn div_scalar(lhs: &dyn Array, rhs: Scalar) -> VortexResult<ArrayRef> {
-    lhs.to_array()
-        .binary(ConstantArray::new(rhs, lhs.len()).to_array(), Operator::Div)
-}
-
-/// Point-wise numeric operation between two arrays of the same type and length.
-#[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn numeric(lhs: &dyn Array, rhs: &dyn Array, op: NumericOperator) -> VortexResult<ArrayRef> {
-    arrow_numeric(lhs, rhs, op)
-}
-
-impl Options for NumericOperator {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-/// Implementation of numeric operations using the Arrow crate.
-pub(crate) fn arrow_numeric(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
-    operator: NumericOperator,
-) -> VortexResult<ArrayRef> {
-    let nullable = lhs.dtype().is_nullable() || rhs.dtype().is_nullable();
-    let len = lhs.len();
-
-    let left = Datum::try_new(lhs)?;
-    let right = Datum::try_new_with_target_datatype(rhs, left.data_type())?;
-
-    let array = match operator {
-        NumericOperator::Add => arrow_arith::numeric::add(&left, &right)?,
-        NumericOperator::Sub => arrow_arith::numeric::sub(&left, &right)?,
-        NumericOperator::Mul => arrow_arith::numeric::mul(&left, &right)?,
-        NumericOperator::Div => arrow_arith::numeric::div(&left, &right)?,
-    };
-
-    from_arrow_array_with_len(array.as_ref(), len, nullable)
-}
-
-#[cfg(test)]
-#[allow(deprecated)]
-mod test {
-    use vortex_buffer::buffer;
-
-    use crate::IntoArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::assert_arrays_eq;
-    use crate::compute::sub_scalar;
-
-    #[test]
-    fn test_scalar_subtract_unsigned() {
-        let values = buffer![1u16, 2, 3].into_array();
-        let result = sub_scalar(&values, 1u16.into()).unwrap();
-        assert_arrays_eq!(result, PrimitiveArray::from_iter([0u16, 1, 2]));
-    }
-
-    #[test]
-    fn test_scalar_subtract_signed() {
-        let values = buffer![1i64, 2, 3].into_array();
-        let result = sub_scalar(&values, (-1i64).into()).unwrap();
-        assert_arrays_eq!(result, PrimitiveArray::from_iter([2i64, 3, 4]));
-    }
-
-    #[test]
-    fn test_scalar_subtract_nullable() {
-        let values = PrimitiveArray::from_option_iter([Some(1u16), Some(2), None, Some(3)]);
-        let result = sub_scalar(values.as_ref(), Some(1u16).into()).unwrap();
-        assert_arrays_eq!(
-            result,
-            PrimitiveArray::from_option_iter([Some(0u16), Some(1), None, Some(2)])
-        );
-    }
-
-    #[test]
-    fn test_scalar_subtract_float() {
-        let values = buffer![1.0f64, 2.0, 3.0].into_array();
-        let to_subtract = -1f64;
-        let result = sub_scalar(&values, to_subtract.into()).unwrap();
-        assert_arrays_eq!(result, PrimitiveArray::from_iter([2.0f64, 3.0, 4.0]));
-    }
-
-    #[test]
-    fn test_scalar_subtract_float_underflow_is_ok() {
-        let values = buffer![f32::MIN, 2.0, 3.0].into_array();
-        let _results = sub_scalar(&values, 1.0f32.into()).unwrap();
-        let _results = sub_scalar(&values, f32::MAX.into()).unwrap();
-    }
-}
diff --git a/vortex-array/src/compute/sum.rs b/vortex-array/src/compute/sum.rs
deleted file mode 100644
index 1b1337d688e..00000000000
--- a/vortex-array/src/compute/sum.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::sync::LazyLock;
-
-use arcref::ArcRef;
-use num_traits::CheckedAdd;
-use num_traits::CheckedSub;
-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_error::vortex_panic;
-
-use crate::Array;
-use crate::compute::ComputeFn;
-use crate::compute::ComputeFnVTable;
-use crate::compute::InvocationArgs;
-use crate::compute::Kernel;
-use crate::compute::Output;
-use crate::dtype::DType;
-use crate::expr::stats::Precision;
-use crate::expr::stats::Stat;
-use crate::expr::stats::StatsProvider;
-use crate::scalar::NumericOperator;
-use crate::scalar::Scalar;
-use crate::vtable::VTable;
-
-static SUM_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
-    let compute = ComputeFn::new("sum".into(), ArcRef::new_ref(&Sum));
-    for kernel in inventory::iter::<SumKernelRef> {
-        compute.register_kernel(kernel.0.clone());
-    }
-    compute
-});
-
-pub(crate) fn warm_up_vtable() -> usize {
-    SUM_FN.kernels().len()
-}
-
-/// Sum an array with an initial value.
-///
-/// If the sum overflows, a null scalar will be returned.
-/// If the sum is not supported for the array's dtype, an error will be raised.
-/// If the array is all-invalid, the sum will be the accumulator.
-/// The accumulator must have a dtype compatible with the sum result dtype.
-pub(crate) fn sum_with_accumulator(
-    array: &dyn Array,
-    accumulator: &Scalar,
-) -> VortexResult<Scalar> {
-    SUM_FN
-        .invoke(&InvocationArgs {
-            inputs: &[array.into(), accumulator.into()],
-            options: &(),
-        })?
-        .unwrap_scalar()
-}
-
-/// Sum an array, starting from zero.
-///
-/// If the sum overflows, a null scalar will be returned.
-/// If the sum is not supported for the array's dtype, an error will be raised.
-/// If the array is all-invalid, the sum will be zero.
-pub fn sum(array: &dyn Array) -> VortexResult<Scalar> {
-    let sum_dtype = Stat::Sum
-        .dtype(array.dtype())
-        .ok_or_else(|| vortex_err!("Sum not supported for dtype: {}", array.dtype()))?;
-    let zero = Scalar::zero_value(&sum_dtype);
-    sum_with_accumulator(array, &zero)
-}
-
-/// For unary compute functions, it's useful to just have this short-cut.
-pub struct SumArgs<'a> {
-    pub array: &'a dyn Array,
-    pub accumulator: &'a Scalar,
-}
-
-impl<'a> TryFrom<&InvocationArgs<'a>> for SumArgs<'a> {
-    type Error = VortexError;
-
-    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
-        if value.inputs.len() != 2 {
-            vortex_bail!("Expected 2 inputs, found {}", value.inputs.len());
-        }
-        let array = value.inputs[0]
-            .array()
-            .ok_or_else(|| vortex_err!("Expected input 0 to be an array"))?;
-        let accumulator = value.inputs[1]
-            .scalar()
-            .ok_or_else(|| vortex_err!("Expected input 1 to be a scalar"))?;
-        Ok(SumArgs { array, accumulator })
-    }
-}
-
-struct Sum;
-
-impl ComputeFnVTable for Sum {
-    fn invoke(
-        &self,
-        args: &InvocationArgs,
-        kernels: &[ArcRef<dyn Kernel>],
-    ) -> VortexResult<Output> {
-        let SumArgs { array, accumulator } = args.try_into()?;
-
-        // Compute the expected dtype of the sum.
-        let sum_dtype = self.return_dtype(args)?;
-
-        vortex_ensure!(
-            &sum_dtype == accumulator.dtype(),
-            "sum_dtype {sum_dtype} must match accumulator dtype {}",
-            accumulator.dtype()
-        );
-
-        // Short-circuit using array statistics.
-        if let Some(Precision::Exact(sum_scalar)) = array.statistics().get(Stat::Sum) {
-            // For floats only use stats if accumulator is zero. otherwise we might have numerical
-            // stability issues.
-            match &sum_dtype {
-                DType::Primitive(p, _) => {
-                    if p.is_float() && accumulator.is_zero() == Some(true) {
-                        return Ok(sum_scalar.into());
-                    } else if p.is_int() {
-                        let sum_from_stat = accumulator
-                            .as_primitive()
-                            .checked_add(&sum_scalar.as_primitive())
-                            .map(Scalar::from);
-                        return Ok(sum_from_stat
-                            .unwrap_or_else(|| Scalar::null(sum_dtype))
-                            .into());
-                    }
-                }
-                DType::Decimal(..) => {
-                    let sum_from_stat = accumulator
-                        .as_decimal()
-                        .checked_binary_numeric(&sum_scalar.as_decimal(), NumericOperator::Add)
-                        .map(Scalar::from);
-                    return Ok(sum_from_stat
-                        .unwrap_or_else(|| Scalar::null(sum_dtype))
-                        .into());
-                }
-                _ => unreachable!("Sum will always be a decimal or a primitive dtype"),
-            }
-        }
-
-        let sum_scalar = sum_impl(array, accumulator, kernels)?;
-
-        // Update the statistics with the computed sum. Stored statistic shouldn't include the accumulator.
-        match sum_dtype {
-            DType::Primitive(p, _) => {
-                if p.is_float()
-                    && accumulator.is_zero() == Some(true)
-                    && let Some(sum_value) = sum_scalar.value().cloned()
-                {
-                    array
-                        .statistics()
-                        .set(Stat::Sum, Precision::Exact(sum_value));
-                } else if p.is_int()
-                    && let Some(less_accumulator) = sum_scalar
-                        .as_primitive()
-                        .checked_sub(&accumulator.as_primitive())
-                    && let Some(val) = Scalar::from(less_accumulator).into_value()
-                {
-                    array.statistics().set(Stat::Sum, Precision::Exact(val));
-                }
-            }
-            DType::Decimal(..) => {
-                if let Some(less_accumulator) = sum_scalar
-                    .as_decimal()
-                    .checked_binary_numeric(&accumulator.as_decimal(), NumericOperator::Sub)
-                    && let Some(val) = Scalar::from(less_accumulator).into_value()
-                {
-                    array.statistics().set(Stat::Sum, Precision::Exact(val));
-                }
-            }
-            _ => unreachable!("Sum will always be a decimal or a primitive dtype"),
-        }
-
-        Ok(sum_scalar.into())
-    }
-
-    fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {
-        let SumArgs { array, .. } = args.try_into()?;
-        Stat::Sum
-            .dtype(array.dtype())
-            .ok_or_else(|| vortex_err!("Sum not supported for dtype: {}", array.dtype()))
-    }
-
-    fn return_len(&self, _args: &InvocationArgs) -> VortexResult<usize> {
-        // The sum function always returns a single scalar value.
-        Ok(1)
-    }
-
-    fn is_elementwise(&self) -> bool {
-        false
-    }
-}
-
-pub struct SumKernelRef(ArcRef<dyn Kernel>);
-inventory::collect!(SumKernelRef);
-
-pub trait SumKernel: VTable {
-    /// # Preconditions
-    ///
-    /// * The array's DType is summable
-    /// * The array is not all-null
-    /// * The accumulator must have a dtype compatible with the sum result dtype
-    fn sum(&self, array: &Self::Array, accumulator: &Scalar) -> VortexResult<Scalar>;
-}
-
-#[derive(Debug)]
-pub struct SumKernelAdapter<V: VTable>(pub V);
-
-impl<V: VTable + SumKernel> SumKernelAdapter<V> {
-    pub const fn lift(&'static self) -> SumKernelRef {
-        SumKernelRef(ArcRef::new_ref(self))
-    }
-}
-
-impl<V: VTable + SumKernel> Kernel for SumKernelAdapter<V> {
-    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
-        let SumArgs { array, accumulator } = args.try_into()?;
-        let Some(array) = array.as_opt::<V>() else {
-            return Ok(None);
-        };
-        Ok(Some(V::sum(&self.0, array, accumulator)?.into()))
-    }
-}
-
-/// Sum an array.
-///
-/// If the sum overflows, a null scalar will be returned.
-/// If the sum is not supported for the array's dtype, an error will be raised.
-/// If the array is all-invalid, the sum will be the accumulator.
-pub fn sum_impl(
-    array: &dyn Array,
-    accumulator: &Scalar,
-    kernels: &[ArcRef<dyn Kernel>],
-) -> VortexResult<Scalar> {
-    if array.is_empty() || array.all_invalid()? || accumulator.is_null() {
-        return Ok(accumulator.clone());
-    }
-
-    // Try to find a sum kernel
-    let args = InvocationArgs {
-        inputs: &[array.into(), accumulator.into()],
-        options: &(),
-    };
-    for kernel in kernels {
-        if let Some(output) = kernel.invoke(&args)? {
-            return output.unwrap_scalar();
-        }
-    }
-
-    // Otherwise, canonicalize and try again.
-    tracing::debug!("No sum implementation found for {}", array.encoding_id());
-    if array.is_canonical() {
-        // Panic to avoid recursion, but it should never be hit.
-        vortex_panic!(
-            "No sum implementation found for canonical array: {}",
-            array.encoding_id()
-        );
-    }
-    sum_with_accumulator(array.to_canonical()?.as_ref(), accumulator)
-}
-
-#[cfg(test)]
-mod test {
-    use vortex_buffer::buffer;
-    use vortex_error::VortexExpect;
-
-    use crate::IntoArray as _;
-    use crate::arrays::BoolArray;
-    use crate::arrays::ChunkedArray;
-    use crate::arrays::PrimitiveArray;
-    use crate::compute::sum;
-    use crate::compute::sum_with_accumulator;
-    use crate::dtype::DType;
-    use crate::dtype::Nullability;
-    use crate::dtype::PType;
-    use crate::scalar::Scalar;
-
-    #[test]
-    fn sum_all_invalid() {
-        let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]);
-        let result = sum(array.as_ref()).unwrap();
-        assert_eq!(result, Scalar::primitive(0i64, Nullability::Nullable));
-    }
-
-    #[test]
-    fn sum_all_invalid_float() {
-        let array = PrimitiveArray::from_option_iter::<f32, _>([None, None, None]);
-        let result = sum(array.as_ref()).unwrap();
-        assert_eq!(result, Scalar::primitive(0f64, Nullability::Nullable));
-    }
-
-    #[test]
-    fn sum_constant() {
-        let array = buffer![1, 1, 1, 1].into_array();
-        let result = sum(array.as_ref()).unwrap();
-        assert_eq!(result.as_primitive().as_::<i32>(), Some(4));
-    }
-
-    #[test]
-    fn sum_constant_float() {
-        let array = buffer![1., 1., 1., 1.].into_array();
-        let result = sum(array.as_ref()).unwrap();
-        assert_eq!(result.as_primitive().as_::<f32>(), Some(4.));
-    }
-
-    #[test]
-    fn sum_boolean() {
-        let array = BoolArray::from_iter([true, false, false, true]);
-        let result = sum(array.as_ref()).unwrap();
-        assert_eq!(result.as_primitive().as_::<i32>(), Some(2));
-    }
-
-    #[test]
-    fn sum_stats() {
-        let array = ChunkedArray::try_new(
-            vec![
-                PrimitiveArray::from_iter([1, 1, 1]).into_array(),
-                PrimitiveArray::from_iter([2, 2, 2]).into_array(),
-            ],
-            DType::Primitive(PType::I32, Nullability::NonNullable),
-        )
-        .vortex_expect("operation should succeed in test");
-        // compute sum with accumulator to populate stats
-        sum_with_accumulator(
-            array.as_ref(),
-            &Scalar::primitive(2i64, Nullability::Nullable),
-        )
-        .unwrap();
-
-        let sum_without_acc = sum(array.as_ref()).unwrap();
-        assert_eq!(
-            sum_without_acc,
-            Scalar::primitive(9i64, Nullability::Nullable)
-        );
-    }
-}
diff --git a/vortex-array/src/compute/zip.rs b/vortex-array/src/compute/zip.rs
deleted file mode 100644
index a6c3267cd19..00000000000
--- a/vortex-array/src/compute/zip.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-use vortex_mask::Mask;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::builtins::ArrayBuiltins;
-
-/// Performs element-wise conditional selection between two arrays based on a mask.
-///
-/// Returns a new array where `result[i] = if_true[i]` when `mask[i]` is true,
-/// otherwise `result[i] = if_false[i]`.
-///
-/// Null values in the mask are treated as false (selecting `if_false`). This follows
-/// SQL semantics (DuckDB, Trino) where a null condition falls through to the ELSE branch,
-/// rather than Arrow's `if_else` which propagates null conditions to the output.
-#[deprecated(note = "use if_true.zip(if_false, mask) via ArrayBuiltins instead")]
-pub fn zip(if_true: &dyn Array, if_false: &dyn Array, mask: &Mask) -> VortexResult<ArrayRef> {
-    if_true
-        .to_array()
-        .zip(if_false.to_array(), mask.clone().into_array())
-}
diff --git a/vortex-array/src/context.rs b/vortex-array/src/context.rs
deleted file mode 100644
index 962a3dfb1ae..00000000000
--- a/vortex-array/src/context.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_session::registry::Context;
-
-use crate::vtable::DynVTable;
-
-pub type ArrayContext = Context<&'static dyn DynVTable>;
diff --git a/vortex-array/src/display/extractor.rs b/vortex-array/src/display/extractor.rs
new file mode 100644
index 00000000000..bbfc25a3666
--- /dev/null
+++ b/vortex-array/src/display/extractor.rs
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use crate::ArrayRef;
+
+/// Context threaded through tree traversal for percentage calculations etc.
+pub struct TreeContext {
+    /// Stack of ancestor nbytes values. `None` entries reset the percentage root
+    /// (e.g. for chunked arrays where each chunk is its own root).
+    pub(crate) ancestor_sizes: Vec<Option<u64>>,
+}
+
+impl TreeContext {
+    pub(crate) fn new() -> Self {
+        Self {
+            ancestor_sizes: Vec::new(),
+        }
+    }
+
+    /// The total size used as the denominator for percentage calculations.
+    /// Returns `None` if there is no ancestor (i.e., this node is the root or
+    /// a chunk boundary reset the percentage root).
+    pub fn parent_total_size(&self) -> Option<u64> {
+        self.ancestor_sizes.last().cloned().flatten()
+    }
+
+    pub(crate) fn push(&mut self, size: Option<u64>) {
+        self.ancestor_sizes.push(size);
+    }
+
+    pub(crate) fn pop(&mut self) {
+        self.ancestor_sizes.pop();
+    }
+}
+
+/// Wrapper providing access to a [`fmt::Formatter`] and the current indentation string.
+pub struct IndentedFormatter<'a, 'b> {
+    inner: &'a mut fmt::Formatter<'b>,
+    indent: &'a str,
+}
+
+impl<'a, 'b> IndentedFormatter<'a, 'b> {
+    pub(crate) fn new(f: &'a mut fmt::Formatter<'b>, indent: &'a str) -> Self {
+        Self { inner: f, indent }
+    }
+
+    /// Access the indent string and underlying [`fmt::Formatter`] together.
+    pub fn parts(&mut self) -> (&str, &mut fmt::Formatter<'b>) {
+        (self.indent, self.inner)
+    }
+
+    /// The current indentation string.
+    pub fn indent(&self) -> &str {
+        self.indent
+    }
+
+    /// Access the underlying [`fmt::Formatter`].
+    pub fn formatter(&mut self) -> &mut fmt::Formatter<'b> {
+        self.inner
+    }
+}
+
+/// Trait for contributing display information to tree nodes.
+///
+/// Each extractor represents one "dimension" of display (e.g., nbytes, stats, metadata, buffers).
+/// Extractors are composable: you can combine any number of them via [`TreeDisplay::with`].
+///
+/// [`TreeDisplay::with`]: super::TreeDisplay::with
+pub trait TreeExtractor: Send + Sync {
+    /// Write header annotations (space-prefixed) to the formatter.
+    fn write_header(
+        &self,
+        array: &ArrayRef,
+        ctx: &TreeContext,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        let _ = (array, ctx, f);
+        Ok(())
+    }
+
+    /// Write detail lines below the header.
+    ///
+    /// Content written through `f` is automatically indented. Use
+    /// [`f.formatter()`](IndentedFormatter::formatter) to access the underlying
+    /// [`fmt::Formatter`] for formatting flags.
+    fn write_details(
+        &self,
+        array: &ArrayRef,
+        ctx: &TreeContext,
+        f: &mut IndentedFormatter<'_, '_>,
+    ) -> fmt::Result {
+        let _ = (array, ctx, f);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/display/extractors/buffer.rs b/vortex-array/src/display/extractors/buffer.rs
new file mode 100644
index 00000000000..17861a654f7
--- /dev/null
+++ b/vortex-array/src/display/extractors/buffer.rs
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use humansize::DECIMAL;
+use humansize::format_size;
+
+use crate::ArrayRef;
+use crate::display::extractor::IndentedFormatter;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+
+/// Extractor that adds buffer detail lines.
+pub struct BufferExtractor {
+    /// Whether to show buffer-level percentage of parent nbytes.
+    pub show_percent: bool,
+}
+
+impl TreeExtractor for BufferExtractor {
+    fn write_details(
+        &self,
+        array: &ArrayRef,
+        _ctx: &TreeContext,
+        f: &mut IndentedFormatter<'_, '_>,
+    ) -> fmt::Result {
+        let (indent, f) = f.parts();
+        let nbytes = array.nbytes();
+        for (name, buffer) in array.named_buffers() {
+            let loc = if buffer.is_on_device() {
+                "device"
+            } else if buffer.is_on_host() {
+                "host"
+            } else {
+                "location-unknown"
+            };
+            let align = if buffer.is_on_host() {
+                buffer.as_host().alignment().to_string()
+            } else {
+                String::new()
+            };
+
+            if self.show_percent {
+                let buffer_percent = if nbytes == 0 {
+                    0.0
+                } else {
+                    100_f64 * buffer.len() as f64 / nbytes as f64
+                };
+                writeln!(
+                    f,
+                    "{indent}buffer: {} {loc} {} (align={}) ({:.2}%)",
+                    name,
+                    format_size(buffer.len(), DECIMAL),
+                    align,
+                    buffer_percent,
+                )?;
+            } else {
+                writeln!(
+                    f,
+                    "{indent}buffer: {} {loc} {} (align={})",
+                    name,
+                    format_size(buffer.len(), DECIMAL),
+                    align,
+                )?;
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/display/extractors/encoding_summary.rs b/vortex-array/src/display/extractors/encoding_summary.rs
new file mode 100644
index 00000000000..bc678643ecb
--- /dev/null
+++ b/vortex-array/src/display/extractors/encoding_summary.rs
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use crate::ArrayRef;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+
+/// Extractor that adds the encoding summary (e.g. `vortex.primitive(i16, len=5)`) to the header.
+pub struct EncodingSummaryExtractor;
+
+impl EncodingSummaryExtractor {
+    /// Write the encoding summary for an array directly to a formatter.
+    pub fn write(array: &ArrayRef, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}({}, len={})",
+            array.encoding_id(),
+            array.dtype(),
+            array.len()
+        )
+    }
+}
+
+impl TreeExtractor for EncodingSummaryExtractor {
+    fn write_header(
+        &self,
+        array: &ArrayRef,
+        _ctx: &TreeContext,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        write!(f, " ")?;
+        Self::write(array, f)
+    }
+}
diff --git a/vortex-array/src/display/extractors/metadata.rs b/vortex-array/src/display/extractors/metadata.rs
new file mode 100644
index 00000000000..a355bafe63c
--- /dev/null
+++ b/vortex-array/src/display/extractors/metadata.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use crate::ArrayRef;
+use crate::display::extractor::IndentedFormatter;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+
+/// Extractor that adds a `metadata: ...` detail line.
+pub struct MetadataExtractor;
+
+impl TreeExtractor for MetadataExtractor {
+    fn write_details(
+        &self,
+        array: &ArrayRef,
+        _ctx: &TreeContext,
+        f: &mut IndentedFormatter<'_, '_>,
+    ) -> fmt::Result {
+        let (indent, f) = f.parts();
+        write!(f, "{indent}metadata: ")?;
+        array.metadata_fmt(f)?;
+        writeln!(f)
+    }
+}
diff --git a/vortex-array/src/display/extractors/mod.rs b/vortex-array/src/display/extractors/mod.rs
new file mode 100644
index 00000000000..754ac16a57a
--- /dev/null
+++ b/vortex-array/src/display/extractors/mod.rs
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod buffer;
+mod encoding_summary;
+mod metadata;
+mod nbytes;
+mod stats;
+
+pub use buffer::BufferExtractor;
+pub use encoding_summary::EncodingSummaryExtractor;
+pub use metadata::MetadataExtractor;
+pub use nbytes::NbytesExtractor;
+pub use stats::StatsExtractor;
diff --git a/vortex-array/src/display/extractors/nbytes.rs b/vortex-array/src/display/extractors/nbytes.rs
new file mode 100644
index 00000000000..37e100279fc
--- /dev/null
+++ b/vortex-array/src/display/extractors/nbytes.rs
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use humansize::DECIMAL;
+use humansize::format_size;
+
+use crate::ArrayRef;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+
+/// Extractor that adds `nbytes=X (Y%)` to the header line.
+pub struct NbytesExtractor;
+
+impl TreeExtractor for NbytesExtractor {
+    fn write_header(
+        &self,
+        array: &ArrayRef,
+        ctx: &TreeContext,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        let nbytes = array.nbytes();
+        let total_size = ctx.parent_total_size().unwrap_or(nbytes);
+        let percent = if total_size == 0 {
+            0.0
+        } else {
+            100_f64 * nbytes as f64 / total_size as f64
+        };
+        write!(
+            f,
+            " nbytes={} ({:.2}%)",
+            format_size(nbytes, DECIMAL),
+            percent
+        )
+    }
+}
diff --git a/vortex-array/src/display/extractors/stats.rs b/vortex-array/src/display/extractors/stats.rs
new file mode 100644
index 00000000000..7f8fce7feb1
--- /dev/null
+++ b/vortex-array/src/display/extractors/stats.rs
@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Write;
+use std::fmt::{self};
+
+use crate::ArrayRef;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+use crate::validity::Validity;
+
+/// Display wrapper for array statistics in compact format.
+///
+/// Produces output like ` [nulls=3, min=5, max=100]` (with leading space).
+pub(crate) struct StatsDisplay<'a>(pub(crate) &'a ArrayRef);
+
+impl fmt::Display for StatsDisplay<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let stats = self.0.statistics();
+        let mut first = true;
+
+        let mut sep = |f: &mut fmt::Formatter<'_>| -> fmt::Result {
+            if first {
+                first = false;
+                f.write_str(" [")
+            } else {
+                f.write_str(", ")
+            }
+        };
+
+        // Null count or validity fallback
+        if let Some(nc) = stats.get(Stat::NullCount) {
+            if let Ok(n) = usize::try_from(&nc.clone().into_inner()) {
+                sep(f)?;
+                write!(f, "nulls={}", n)?;
+            } else {
+                sep(f)?;
+                write!(f, "nulls={}", nc)?;
+            }
+        } else if self.0.dtype().is_nullable() {
+            match self.0.validity() {
+                Ok(Validity::NonNullable | Validity::AllValid) => {
+                    sep(f)?;
+                    f.write_str("all_valid")?;
+                }
+                Ok(Validity::AllInvalid) => {
+                    sep(f)?;
+                    f.write_str("all_invalid")?;
+                }
+                Ok(Validity::Array(_)) => {
+                    // Avoid computing validity-array stats as a side effect of display.
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to check validity: {e}");
+                    sep(f)?;
+                    f.write_str("validity_failed")?;
+                }
+            }
+        }
+
+        // NaN count (only if > 0)
+        if let Some(nan) = stats.get(Stat::NaNCount)
+            && let Ok(n) = usize::try_from(&nan.into_inner())
+            && n > 0
+        {
+            sep(f)?;
+            write!(f, "nan={}", n)?;
+        }
+
+        // Min/Max
+        if let Some(min) = stats.get(Stat::Min) {
+            sep(f)?;
+            write!(f, "min={}", min)?;
+        }
+        if let Some(max) = stats.get(Stat::Max) {
+            sep(f)?;
+            write!(f, "max={}", max)?;
+        }
+
+        // Sum
+        if let Some(sum) = stats.get(Stat::Sum) {
+            sep(f)?;
+            write!(f, "sum={}", sum)?;
+        }
+
+        // Boolean flags (compact)
+        if let Some(c) = stats.get(Stat::IsConstant)
+            && bool::try_from(&c.into_inner()).unwrap_or(false)
+        {
+            sep(f)?;
+            f.write_str("const")?;
+        }
+        if let Some(s) = stats.get(Stat::IsStrictSorted) {
+            if bool::try_from(&s.into_inner()).unwrap_or(false) {
+                sep(f)?;
+                f.write_str("strict")?;
+            }
+        } else if let Some(s) = stats.get(Stat::IsSorted)
+            && bool::try_from(&s.into_inner()).unwrap_or(false)
+        {
+            sep(f)?;
+            f.write_str("sorted")?;
+        }
+
+        // Close bracket if we wrote anything
+        if !first {
+            f.write_char(']')?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Extractor that adds stats annotations (e.g. `[nulls=3, min=5]`) to the header line.
+pub struct StatsExtractor;
+
+impl TreeExtractor for StatsExtractor {
+    fn write_header(
+        &self,
+        array: &ArrayRef,
+        _ctx: &TreeContext,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        write!(f, "{}", StatsDisplay(array))
+    }
+}
diff --git a/vortex-array/src/display/mod.rs b/vortex-array/src/display/mod.rs
index bb8ca816393..f299bb7aeeb 100644
--- a/vortex-array/src/display/mod.rs
+++ b/vortex-array/src/display/mod.rs
@@ -1,14 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-mod tree;
+mod extractor;
+mod extractors;
+mod tree_display;
 
 use std::fmt::Display;
 
+pub use extractor::IndentedFormatter;
+pub use extractor::TreeContext;
+pub use extractor::TreeExtractor;
+pub use extractors::BufferExtractor;
+pub use extractors::EncodingSummaryExtractor;
+pub use extractors::MetadataExtractor;
+pub use extractors::NbytesExtractor;
+pub use extractors::StatsExtractor;
 use itertools::Itertools as _;
-use tree::TreeDisplayWrapper;
+pub use tree_display::TreeDisplay;
 
-use crate::Array;
+use crate::ArrayRef;
 
 /// Describe how to convert an array to a string.
 ///
@@ -56,7 +66,7 @@ pub enum DisplayOptions {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i16
     ///   buffer: values host 10 B (align=2) (100.00%)
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: true, metadata: true, stats: true })), expected);
@@ -67,12 +77,12 @@ pub enum DisplayOptions {
     ///     ("y", buffer![3, 4].into_array()),
     /// ]).unwrap().into_array();
     /// let expected = "root: vortex.struct({x=i32, y=i32}, len=2) nbytes=16 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata:\x20
     ///   x: vortex.primitive(i32, len=2) nbytes=8 B (50.00%)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///     buffer: values host 8 B (align=4) (100.00%)
     ///   y: vortex.primitive(i32, len=2) nbytes=8 B (50.00%)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///     buffer: values host 8 B (align=4) (100.00%)
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: true, metadata: true, stats: true })), expected);
@@ -86,7 +96,7 @@ pub enum DisplayOptions {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i16
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: false, metadata: true, stats: true })), expected);
     ///
@@ -96,11 +106,11 @@ pub enum DisplayOptions {
     ///     ("y", buffer![3, 4].into_array()),
     /// ]).unwrap().into_array();
     /// let expected = "root: vortex.struct({x=i32, y=i32}, len=2) nbytes=16 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata:\x20
     ///   x: vortex.primitive(i32, len=2) nbytes=8 B (50.00%)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///   y: vortex.primitive(i32, len=2) nbytes=8 B (50.00%)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: false, metadata: true, stats: true })), expected);
     /// ```
@@ -113,7 +123,7 @@ pub enum DisplayOptions {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// let expected = "root: vortex.primitive(i16, len=5)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i16
     ///   buffer: values host 10 B (align=2)
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: true, metadata: true, stats: false })), expected);
@@ -124,12 +134,12 @@ pub enum DisplayOptions {
     ///     ("y", buffer![3, 4].into_array()),
     /// ]).unwrap().into_array();
     /// let expected = "root: vortex.struct({x=i32, y=i32}, len=2)
-    ///   metadata: EmptyMetadata
+    ///   metadata:\x20
     ///   x: vortex.primitive(i32, len=2)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///     buffer: values host 8 B (align=4)
     ///   y: vortex.primitive(i32, len=2)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///     buffer: values host 8 B (align=4)
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: true, metadata: true, stats: false })), expected);
@@ -195,7 +205,7 @@ pub enum DisplayOptions {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// let expected = "root: vortex.primitive(i16, len=5)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i16
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: false, metadata: true, stats: false })), expected);
     ///
@@ -205,11 +215,11 @@ pub enum DisplayOptions {
     ///     ("y", buffer![3, 4].into_array()),
     /// ]).unwrap().into_array();
     /// let expected = "root: vortex.struct({x=i32, y=i32}, len=2)
-    ///   metadata: EmptyMetadata
+    ///   metadata:\x20
     ///   x: vortex.primitive(i32, len=2)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     ///   y: vortex.primitive(i32, len=2)
-    ///     metadata: EmptyMetadata
+    ///     metadata: ptype: i32
     /// ";
     /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay { buffers: false, metadata: true, stats: false })), expected);
     /// ```
@@ -304,7 +314,7 @@ impl Default for DisplayOptions {
 /// See also:
 /// [Array::display_as](../trait.Array.html#method.display_as)
 /// and [DisplayOptions].
-pub struct DisplayArrayAs<'a>(pub &'a dyn Array, pub DisplayOptions);
+pub struct DisplayArrayAs<'a>(pub &'a ArrayRef, pub DisplayOptions);
 
 impl Display for DisplayArrayAs<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -324,13 +334,14 @@ impl Display for DisplayArrayAs<'_> {
 ///     "vortex.primitive(i16, len=5)",
 /// );
 /// ```
-impl Display for dyn Array + '_ {
+impl Display for ArrayRef {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.fmt_as(f, &DisplayOptions::MetadataOnly)
     }
 }
 
-impl dyn Array + '_ {
+const DISPLAY_LIMIT: usize = 16;
+impl ArrayRef {
     /// Display logical values of the array
     ///
     /// For example, an `i16` typed array containing the first five non-negative integers is displayed
@@ -389,15 +400,8 @@ impl dyn Array + '_ {
     /// ";
     /// assert_eq!(format!("{}", array.display_tree_encodings_only()), expected);
     /// ```
-    pub fn display_tree_encodings_only(&self) -> impl Display {
-        DisplayArrayAs(
-            self,
-            DisplayOptions::TreeDisplay {
-                buffers: false,
-                metadata: false,
-                stats: false,
-            },
-        )
+    pub fn display_tree_encodings_only(&self) -> TreeDisplay {
+        self.tree_display_builder().with(EncodingSummaryExtractor)
     }
 
     /// Display the tree of encodings of this array as an indented lists.
@@ -414,20 +418,73 @@ impl dyn Array + '_ {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i16
     ///   buffer: values host 10 B (align=2) (100.00%)
     /// ";
     /// assert_eq!(format!("{}", array.display_tree()), expected);
     /// ```
-    pub fn display_tree(&self) -> impl Display {
-        DisplayArrayAs(
-            self,
-            DisplayOptions::TreeDisplay {
-                buffers: true,
-                metadata: true,
-                stats: true,
-            },
-        )
+    pub fn display_tree(&self) -> TreeDisplay {
+        TreeDisplay::default_display(self.clone())
+    }
+
+    /// Create a tree display with all built-in extractors (nbytes, stats, metadata, buffers).
+    ///
+    /// This is the default, fully-detailed tree display. Use
+    /// `tree_display_builder()` for a blank slate.
+    ///
+    /// # Examples
+    /// ```
+    /// # use vortex_array::IntoArray;
+    /// # use vortex_buffer::buffer;
+    /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
+    /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
+    ///   metadata: ptype: i16
+    ///   buffer: values host 10 B (align=2) (100.00%)
+    /// ";
+    /// assert_eq!(array.tree_display().to_string(), expected);
+    /// ```
+    pub fn tree_display(&self) -> TreeDisplay {
+        TreeDisplay::default_display(self.clone())
+    }
+
+    /// Create a composable tree display builder with no extractors.
+    ///
+    /// With no extractors, only the node names are shown.
+    /// Add extractors with [`.with()`][TreeDisplay::with] to include additional information.
+    /// Most builders should start with [`EncodingSummaryExtractor`] to include encoding headers.
+    ///
+    /// # Examples
+    /// ```
+    /// # use vortex_array::IntoArray;
+    /// # use vortex_buffer::buffer;
+    /// use vortex_array::display::{EncodingSummaryExtractor, NbytesExtractor, MetadataExtractor, BufferExtractor};
+    ///
+    /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
+    ///
+    /// // Encodings only
+    /// let encodings = array.tree_display_builder()
+    ///     .with(EncodingSummaryExtractor)
+    ///     .to_string();
+    /// assert_eq!(encodings, "root: vortex.primitive(i16, len=5)\n");
+    ///
+    /// // With encoding + nbytes
+    /// let with_nbytes = array.tree_display_builder()
+    ///     .with(EncodingSummaryExtractor)
+    ///     .with(NbytesExtractor)
+    ///     .to_string();
+    /// assert_eq!(with_nbytes, "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)\n");
+    ///
+    /// // With encoding, metadata, and buffers
+    /// let detailed = array.tree_display_builder()
+    ///     .with(EncodingSummaryExtractor)
+    ///     .with(MetadataExtractor)
+    ///     .with(BufferExtractor { show_percent: false })
+    ///     .to_string();
+    /// let expected = "root: vortex.primitive(i16, len=5)\n  metadata: ptype: i16\n  buffer: values host 10 B (align=2)\n";
+    /// assert_eq!(detailed, expected);
+    /// ```
+    pub fn tree_display_builder(&self) -> TreeDisplay {
+        TreeDisplay::new(self.clone())
     }
 
     /// Display the array as a formatted table.
@@ -464,46 +521,59 @@ impl dyn Array + '_ {
 
     fn fmt_as(&self, f: &mut std::fmt::Formatter, options: &DisplayOptions) -> std::fmt::Result {
         match options {
-            DisplayOptions::MetadataOnly => {
-                write!(
-                    f,
-                    "{}({}, len={})",
-                    self.encoding_id(),
-                    self.dtype(),
-                    self.len()
-                )
-            }
+            DisplayOptions::MetadataOnly => EncodingSummaryExtractor::write(self, f),
             DisplayOptions::CommaSeparatedScalars {
                 omit_comma_after_space,
             } => {
-                write!(f, "[")?;
+                let opening_brace = if f.alternate() { "[\n" } else { "[" };
+                let closing_brace = if f.alternate() { "\n]" } else { "]" };
+
                 let sep = if *omit_comma_after_space { "," } else { ", " };
+                let sep = if f.alternate() { ",\n" } else { sep };
+                let limit = self.len().min(f.precision().unwrap_or(DISPLAY_LIMIT));
+                let is_truncated = self.len() > limit;
+
+                let fmt_scalar = |i| {
+                    self.scalar_at(i)
+                        .map_or_else(|e| format!("<error: {e}>"), |s| s.to_string())
+                };
                 write!(
                     f,
-                    "{}",
-                    (0..self.len())
-                        .map(|i| self
-                            .scalar_at(i)
-                            .map_or_else(|e| format!("<error: {e}>"), |s| s.to_string()))
+                    "{opening_brace}{}{closing_brace}",
+                    (0..limit.saturating_sub(3))
+                        .map(fmt_scalar)
+                        .chain(std::iter::repeat_n(
+                            "...".to_string(),
+                            is_truncated as usize
+                        ))
+                        .chain((self.len().saturating_sub(3)..self.len()).map(fmt_scalar))
                         .format(sep)
-                )?;
-                write!(f, "]")
+                )
             }
             DisplayOptions::TreeDisplay {
                 buffers,
                 metadata,
                 stats,
             } => {
-                write!(
-                    f,
-                    "{}",
-                    TreeDisplayWrapper {
-                        array: self.to_array(),
-                        buffers: *buffers,
-                        metadata: *metadata,
-                        stats: *stats
+                let extractors: [(bool, Box<dyn TreeExtractor>); 5] = [
+                    (true, Box::new(EncodingSummaryExtractor)),
+                    (*stats, Box::new(NbytesExtractor)),
+                    (*stats, Box::new(StatsExtractor)),
+                    (*metadata, Box::new(MetadataExtractor)),
+                    (
+                        *buffers,
+                        Box::new(BufferExtractor {
+                            show_percent: *stats,
+                        }),
+                    ),
+                ];
+                let mut display = TreeDisplay::new(self.clone());
+                for (enabled, extractor) in extractors {
+                    if enabled {
+                        display = display.with_boxed(extractor);
                     }
-                )
+                }
+                write!(f, "{display}")
             }
             #[cfg(feature = "table-display")]
             DisplayOptions::TableDisplay => {
@@ -537,7 +607,9 @@ impl dyn Array + '_ {
                         builder.push_record(null_row);
                     } else {
                         let mut row = Vec::new();
-                        for field_array in struct_.unmasked_fields().iter() {
+                        for field_array in
+                            crate::arrays::struct_::StructArrayExt::iter_unmasked_fields(&struct_)
+                        {
                             let value = field_array
                                 .scalar_at(row_idx)
                                 .map_or_else(|e| format!("<error: {e}>"), |s| s.to_string());
@@ -579,7 +651,9 @@ mod test {
     use crate::IntoArray as _;
     use crate::arrays::BoolArray;
     use crate::arrays::ListArray;
+    use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
+    use crate::display::DISPLAY_LIMIT;
     use crate::dtype::FieldNames;
     use crate::validity::Validity;
 
@@ -593,6 +667,13 @@ mod test {
 
         let x = buffer![1, 2, 3, 4].into_array();
         assert_eq!(x.display_values().to_string(), "[1i32, 2i32, 3i32, 4i32]");
+
+        let x =
+            PrimitiveArray::from_iter(0i32..i32::try_from(DISPLAY_LIMIT).unwrap() + 1).into_array();
+        assert_eq!(
+            x.display_values().to_string(),
+            "[0i32, 1i32, 2i32, 3i32, 4i32, 5i32, 6i32, 7i32, 8i32, 9i32, 10i32, 11i32, 12i32, ..., 14i32, 15i32, 16i32]"
+        );
     }
 
     #[test]
@@ -637,6 +718,14 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_display_tree_nullable_primitive_validity_child() {
+        let array =
+            PrimitiveArray::from_option_iter([Some(1i64), Some(2), None, Some(3)]).into_array();
+        let expected = "root: vortex.primitive(i64?, len=4) nbytes=33 B (100.00%)\n  metadata: ptype: i64\n  buffer: values host 32 B (align=8) (96.97%)\n  validity: vortex.bool(bool, len=4) nbytes=1 B (3.03%)\n    metadata: offset: 0\n    buffer: bits host 1 B (align=1) (100.00%)\n";
+        assert_eq!(format!("{}", array.display_tree()), expected);
+    }
+
     #[test]
     fn test_table_display_primitive() {
         use crate::display::DisplayOptions;
@@ -663,13 +752,8 @@ mod test {
     fn test_table_display() {
         use crate::display::DisplayOptions;
 
-        let array = crate::arrays::PrimitiveArray::from_option_iter(vec![
-            Some(-1),
-            Some(-2),
-            Some(-3),
-            None,
-        ])
-        .into_array();
+        let array =
+            PrimitiveArray::from_option_iter(vec![Some(-1), Some(-2), Some(-3), None]).into_array();
 
         let struct_ = StructArray::try_from_iter_with_validity(
             [("x", buffer![1, 2, 3, 4].into_array()), ("y", array)],
diff --git a/vortex-array/src/display/tree.rs b/vortex-array/src/display/tree.rs
deleted file mode 100644
index 3f9426a9fea..00000000000
--- a/vortex-array/src/display/tree.rs
+++ /dev/null
@@ -1,285 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Write;
-use std::fmt::{self};
-
-use humansize::DECIMAL;
-use humansize::format_size;
-use vortex_error::VortexExpect as _;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::ArrayVisitor;
-use crate::arrays::ChunkedVTable;
-use crate::display::DisplayOptions;
-use crate::expr::stats::Stat;
-use crate::expr::stats::StatsProvider;
-
-/// Display wrapper for array statistics in compact format.
-struct StatsDisplay<'a>(&'a dyn Array);
-
-impl fmt::Display for StatsDisplay<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let stats = self.0.statistics();
-        let mut first = true;
-
-        // Helper to write separator
-        let mut sep = |f: &mut fmt::Formatter<'_>| -> fmt::Result {
-            if first {
-                first = false;
-                f.write_str(" [")
-            } else {
-                f.write_str(", ")
-            }
-        };
-
-        // Null count or validity fallback
-        if let Some(nc) = stats.get(Stat::NullCount) {
-            if let Ok(n) = usize::try_from(&nc.clone().into_inner()) {
-                sep(f)?;
-                write!(f, "nulls={}", n)?;
-            } else {
-                sep(f)?;
-                write!(f, "nulls={}", nc)?;
-            }
-        } else if self.0.dtype().is_nullable() {
-            match self.0.all_valid() {
-                Ok(true) => {
-                    sep(f)?;
-                    f.write_str("all_valid")?;
-                }
-                Ok(false) => {
-                    if self.0.all_invalid().unwrap_or(false) {
-                        sep(f)?;
-                        f.write_str("all_invalid")?;
-                    }
-                }
-                Err(e) => {
-                    tracing::warn!("Failed to check validity: {e}");
-                    sep(f)?;
-                    f.write_str("validity_failed")?;
-                }
-            }
-        }
-
-        // NaN count (only if > 0)
-        if let Some(nan) = stats.get(Stat::NaNCount)
-            && let Ok(n) = usize::try_from(&nan.into_inner())
-            && n > 0
-        {
-            sep(f)?;
-            write!(f, "nan={}", n)?;
-        }
-
-        // Min/Max
-        if let Some(min) = stats.get(Stat::Min) {
-            sep(f)?;
-            write!(f, "min={}", min)?;
-        }
-        if let Some(max) = stats.get(Stat::Max) {
-            sep(f)?;
-            write!(f, "max={}", max)?;
-        }
-
-        // Sum
-        if let Some(sum) = stats.get(Stat::Sum) {
-            sep(f)?;
-            write!(f, "sum={}", sum)?;
-        }
-
-        // Boolean flags (compact)
-        if let Some(c) = stats.get(Stat::IsConstant)
-            && bool::try_from(&c.into_inner()).unwrap_or(false)
-        {
-            sep(f)?;
-            f.write_str("const")?;
-        }
-        if let Some(s) = stats.get(Stat::IsStrictSorted) {
-            if bool::try_from(&s.into_inner()).unwrap_or(false) {
-                sep(f)?;
-                f.write_str("strict")?;
-            }
-        } else if let Some(s) = stats.get(Stat::IsSorted)
-            && bool::try_from(&s.into_inner()).unwrap_or(false)
-        {
-            sep(f)?;
-            f.write_str("sorted")?;
-        }
-
-        // Close bracket if we wrote anything
-        if !first {
-            f.write_char(']')?;
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct TreeDisplayWrapper {
-    pub(crate) array: ArrayRef,
-    pub(crate) buffers: bool,
-    pub(crate) metadata: bool,
-    pub(crate) stats: bool,
-}
-
-impl fmt::Display for TreeDisplayWrapper {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let TreeDisplayWrapper {
-            array,
-            buffers,
-            metadata,
-            stats,
-        } = self.clone();
-        let mut array_fmt = TreeFormatter {
-            fmt,
-            indent: "".to_string(),
-            ancestor_sizes: Vec::new(),
-            buffers,
-            metadata,
-            stats,
-        };
-        array_fmt.format("root", array)
-    }
-}
-
-pub struct TreeFormatter<'a, 'b: 'a> {
-    fmt: &'a mut fmt::Formatter<'b>,
-    indent: String,
-    ancestor_sizes: Vec<Option<u64>>,
-    buffers: bool,
-    metadata: bool,
-    stats: bool,
-}
-
-impl<'a, 'b: 'a> TreeFormatter<'a, 'b> {
-    fn format(&mut self, name: &str, array: ArrayRef) -> fmt::Result {
-        if self.stats {
-            let nbytes = array.nbytes();
-            let total_size = self
-                .ancestor_sizes
-                .last()
-                .cloned()
-                .flatten()
-                .unwrap_or(nbytes);
-
-            self.ancestor_sizes.push(if array.is::<ChunkedVTable>() {
-                // Treat each chunk as a new root
-                None
-            } else {
-                // Children will present themselves as a percentage of our size.
-                Some(nbytes)
-            });
-            let percent = if total_size == 0 {
-                0.0
-            } else {
-                100_f64 * nbytes as f64 / total_size as f64
-            };
-
-            writeln!(
-                self,
-                "{}: {} nbytes={} ({:.2}%){}",
-                name,
-                array.display_as(DisplayOptions::MetadataOnly),
-                format_size(nbytes, DECIMAL),
-                percent,
-                StatsDisplay(array.as_ref()),
-            )?;
-        } else {
-            writeln!(
-                self,
-                "{}: {}",
-                name,
-                array.display_as(DisplayOptions::MetadataOnly)
-            )?;
-        }
-
-        self.indent(|i| {
-            if i.metadata {
-                write!(i, "metadata: ")?;
-                array.metadata_fmt(i.fmt)?;
-                writeln!(i.fmt)?;
-            }
-
-            if i.buffers {
-                let nbytes = array.nbytes();
-                for (name, buffer) in array.named_buffers() {
-                    let loc = if buffer.is_on_device() {
-                        "device"
-                    } else if buffer.is_on_host() {
-                        "host"
-                    } else {
-                        "location-unknown"
-                    };
-                    let align = if buffer.is_on_host() {
-                        buffer.as_host().alignment().to_string()
-                    } else {
-                        "".to_string()
-                    };
-
-                    if i.stats {
-                        let buffer_percent = if nbytes == 0 {
-                            0.0
-                        } else {
-                            100_f64 * buffer.len() as f64 / nbytes as f64
-                        };
-                        writeln!(
-                            i,
-                            "buffer: {} {loc} {} (align={}) ({:.2}%)",
-                            name,
-                            format_size(buffer.len(), DECIMAL),
-                            align,
-                            buffer_percent
-                        )?;
-                    } else {
-                        writeln!(
-                            i,
-                            "buffer: {} {loc} {} (align={})",
-                            name,
-                            format_size(buffer.len(), DECIMAL),
-                            align,
-                        )?;
-                    }
-                }
-            }
-
-            Ok(())
-        })?;
-
-        self.indent(|i| {
-            for (name, child) in array
-                .children_names()
-                .into_iter()
-                .zip(array.children().into_iter())
-            {
-                i.format(&name, child)?;
-            }
-            Ok(())
-        })?;
-
-        if self.stats {
-            let _ = self
-                .ancestor_sizes
-                .pop()
-                .vortex_expect("pushes and pops are matched");
-        }
-
-        Ok(())
-    }
-
-    fn indent<F>(&mut self, indented: F) -> fmt::Result
-    where
-        F: FnOnce(&mut TreeFormatter) -> fmt::Result,
-    {
-        let original_ident = self.indent.clone();
-        self.indent += "  ";
-        let res = indented(self);
-        self.indent = original_ident;
-        res
-    }
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> fmt::Result {
-        write!(self.fmt, "{}{}", self.indent, fmt)
-    }
-}
diff --git a/vortex-array/src/display/tree_display.rs b/vortex-array/src/display/tree_display.rs
new file mode 100644
index 00000000000..5d0753ba354
--- /dev/null
+++ b/vortex-array/src/display/tree_display.rs
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use crate::ArrayRef;
+use crate::arrays::Chunked;
+use crate::display::extractor::IndentedFormatter;
+use crate::display::extractor::TreeContext;
+use crate::display::extractor::TreeExtractor;
+use crate::display::extractors::BufferExtractor;
+use crate::display::extractors::EncodingSummaryExtractor;
+use crate::display::extractors::MetadataExtractor;
+use crate::display::extractors::NbytesExtractor;
+use crate::display::extractors::StatsExtractor;
+
+/// Composable tree display builder.
+///
+/// Use `tree_display()` for the default display with all built-in extractors,
+/// or `tree_display_builder()` to start with a blank slate and compose your own:
+///
+/// ```
+/// # use vortex_array::IntoArray;
+/// # use vortex_buffer::buffer;
+/// use vortex_array::display::{EncodingSummaryExtractor, NbytesExtractor, MetadataExtractor, BufferExtractor};
+///
+/// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
+///
+/// // Default: all built-in extractors
+/// let full = array.tree_display();
+///
+/// // Custom: pick only what you need
+/// let custom = array.tree_display_builder()
+///     .with(EncodingSummaryExtractor)
+///     .with(NbytesExtractor)
+///     .with(MetadataExtractor);
+/// ```
+pub struct TreeDisplay {
+    array: ArrayRef,
+    extractors: Vec<Box<dyn TreeExtractor>>,
+}
+
+impl TreeDisplay {
+    /// Create a new tree display for the given array with no extractors.
+    ///
+    /// With no extractors, only node names and the tree structure are shown.
+    /// Use [`Self::default_display`] for the standard set of all built-in extractors.
+    pub fn new(array: ArrayRef) -> Self {
+        Self {
+            array,
+            extractors: Vec::new(),
+        }
+    }
+
+    /// Create a tree display with all built-in extractors: encoding summary, nbytes, stats,
+    /// metadata, and buffers.
+    pub fn default_display(array: ArrayRef) -> Self {
+        Self::new(array)
+            .with(EncodingSummaryExtractor)
+            .with(NbytesExtractor)
+            .with(StatsExtractor)
+            .with(MetadataExtractor)
+            .with(BufferExtractor { show_percent: true })
+    }
+
+    /// Add an extractor to the display pipeline.
+    pub fn with<E: TreeExtractor + 'static>(mut self, extractor: E) -> Self {
+        self.extractors.push(Box::new(extractor));
+        self
+    }
+
+    /// Add a pre-boxed extractor to the display pipeline.
+    pub fn with_boxed(mut self, extractor: Box<dyn TreeExtractor>) -> Self {
+        self.extractors.push(extractor);
+        self
+    }
+
+    /// Recursively write a node and all its descendants directly to the formatter.
+    fn write_node(
+        &self,
+        name: &str,
+        array: &ArrayRef,
+        ctx: &mut TreeContext,
+        indent: &str,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        // Header line: "{indent}{name}:{annotations...}\n"
+        write!(f, "{indent}{name}:")?;
+        for extractor in &self.extractors {
+            extractor.write_header(array, ctx, f)?;
+        }
+        writeln!(f)?;
+
+        // Detail lines
+        let child_indent = format!("{indent}  ");
+        {
+            let mut indented = IndentedFormatter::new(f, &child_indent);
+            for extractor in &self.extractors {
+                extractor.write_details(array, ctx, &mut indented)?;
+            }
+        }
+
+        // Push context for children: chunked arrays reset the percentage root
+        let child_size = if array.is::<Chunked>() {
+            None
+        } else {
+            Some(array.nbytes())
+        };
+        ctx.push(child_size);
+
+        // Recurse into children
+        for (child_name, child) in array.children_names().into_iter().zip(array.children()) {
+            self.write_node(&child_name, &child, ctx, &child_indent, f)?;
+        }
+
+        ctx.pop();
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for TreeDisplay {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut ctx = TreeContext::new();
+        self.write_node("root", &self.array, &mut ctx, "", f)
+    }
+}
diff --git a/vortex-array/src/dtype/arbitrary/mod.rs b/vortex-array/src/dtype/arbitrary/mod.rs
index 3711b904472..9b95074ff6f 100644
--- a/vortex-array/src/dtype/arbitrary/mod.rs
+++ b/vortex-array/src/dtype/arbitrary/mod.rs
@@ -6,6 +6,8 @@ use std::sync::Arc;
 use arbitrary::Arbitrary;
 use arbitrary::Result;
 use arbitrary::Unstructured;
+use itertools::Itertools;
+use vortex_error::VortexExpect;
 
 use crate::dtype::DType;
 use crate::dtype::DecimalDType;
@@ -34,8 +36,7 @@ impl<'a> Arbitrary<'a> for FieldName {
 
 fn random_dtype(u: &mut Unstructured<'_>, depth: u8) -> Result<DType> {
     const BASE_TYPE_COUNT: i32 = 5;
-    // TODO(joe): update to 3 once fsl works
-    const CONTAINER_TYPE_COUNT: i32 = 2;
+    const CONTAINER_TYPE_COUNT: i32 = 3;
     let max_dtype_kind = if depth == 0 {
         BASE_TYPE_COUNT
     } else {
@@ -52,12 +53,12 @@ fn random_dtype(u: &mut Unstructured<'_>, depth: u8) -> Result<DType> {
         // container types
         6 => DType::Struct(random_struct_dtype(u, depth - 1)?, u.arbitrary()?),
         7 => DType::List(Arc::new(random_dtype(u, depth - 1)?), u.arbitrary()?),
-        // 8 => DType::FixedSizeList(
-        //     Arc::new(random_dtype(u, depth - 1)?),
-        //     // We limit the list size to 3 rather (following random struct fields).
-        //     u.choose_index(3)?.try_into().vortex_expect("impossible"),
-        //     u.arbitrary()?,
-        // ),
+        8 => DType::FixedSizeList(
+            Arc::new(random_dtype(u, depth - 1)?),
+            // We limit the list size to 3 rather (following random struct fields).
+            u.choose_index(3)?.try_into().vortex_expect("impossible"),
+            u.arbitrary()?,
+        ),
         // Null,
         // Extension(ExtDType, Nullability),
         _ => unreachable!("Number out of range"),
@@ -108,11 +109,15 @@ impl<'a> Arbitrary<'a> for StructFields {
     }
 }
 
+// TODO(joe): enable duplicate field gen in the fuzzer.
+// we dont for now to unblock this to find more interesting things
 fn random_struct_dtype(u: &mut Unstructured<'_>, depth: u8) -> Result<StructFields> {
     let field_count = u.choose_index(3)?;
-    let names: FieldNames = (0..field_count)
+    let names: Vec<FieldName> = (0..field_count)
         .map(|_| FieldName::arbitrary(u))
-        .collect::<Result<FieldNames>>()?;
+        .collect::<Result<Vec<_>>>()?;
+    // Deduplicate field names, keeping only the first occurrence of each.
+    let names: FieldNames = names.into_iter().unique().collect();
     let dtypes = (0..names.len())
         .map(|_| random_dtype(u, depth))
         .collect::<Result<Vec<_>>>()?;
diff --git a/vortex-array/src/dtype/arrow.rs b/vortex-array/src/dtype/arrow.rs
index ca15189a5d5..8c57301dbdc 100644
--- a/vortex-array/src/dtype/arrow.rs
+++ b/vortex-array/src/dtype/arrow.rs
@@ -208,6 +208,9 @@ impl FromArrowType<(&DataType, Nullability)> for DType {
             DataType::Dictionary(_, value_type) => {
                 Self::from_arrow((value_type.as_ref(), nullability))
             }
+            DataType::RunEndEncoded(_, value_type) => {
+                Self::from_arrow((value_type.data_type(), nullability))
+            }
             _ => unimplemented!("Arrow data type not yet supported: {:?}", data_type),
         }
     }
@@ -215,6 +218,14 @@ impl FromArrowType<(&DataType, Nullability)> for DType {
 
 impl FromArrowType<&Field> for DType {
     fn from_arrow(field: &Field) -> Self {
+        if field
+            .metadata()
+            .get("ARROW:extension:name")
+            .map(|s| s.as_str())
+            == Some("arrow.parquet.variant")
+        {
+            return DType::Variant(field.is_nullable().into());
+        }
         Self::from_arrow((field.data_type(), field.is_nullable().into()))
     }
 }
@@ -232,11 +243,23 @@ impl DType {
 
         let mut builder = SchemaBuilder::with_capacity(struct_dtype.names().len());
         for (field_name, field_dtype) in struct_dtype.names().iter().zip(struct_dtype.fields()) {
-            builder.push(FieldRef::from(Field::new(
-                field_name.as_ref(),
-                field_dtype.to_arrow_dtype()?,
-                field_dtype.is_nullable(),
-            )));
+            let field = if field_dtype.is_variant() {
+                let storage = DataType::Struct(variant_storage_fields_minimal());
+                Field::new(field_name.as_ref(), storage, field_dtype.is_nullable()).with_metadata(
+                    [(
+                        "ARROW:extension:name".to_owned(),
+                        "arrow.parquet.variant".to_owned(),
+                    )]
+                    .into(),
+                )
+            } else {
+                Field::new(
+                    field_name.as_ref(),
+                    field_dtype.to_arrow_dtype()?,
+                    field_dtype.is_nullable(),
+                )
+            };
+            builder.push(field);
         }
 
         Ok(builder.finish())
@@ -305,6 +328,9 @@ impl DType {
 
                 DataType::Struct(Fields::from(fields))
             }
+            DType::Variant(_) => vortex_bail!(
+                "DType::Variant requires Arrow Field metadata; use to_arrow_schema or a Field helper"
+            ),
             DType::Extension(ext_dtype) => {
                 // Try and match against the known extension DTypes.
                 if let Some(temporal) = ext_dtype.metadata_opt::<AnyTemporal>() {
@@ -337,6 +363,13 @@ impl DType {
     }
 }
 
+fn variant_storage_fields_minimal() -> Fields {
+    Fields::from(vec![
+        Field::new("metadata", DataType::Binary, false),
+        Field::new("value", DataType::Binary, true),
+    ])
+}
+
 #[cfg(test)]
 mod test {
     use arrow_schema::DataType;
@@ -404,6 +437,15 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_variant_dtype_to_arrow_dtype_errors() {
+        let err = DType::Variant(Nullability::NonNullable)
+            .to_arrow_dtype()
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("Variant"));
+    }
+
     #[test]
     fn infer_nullable_list_element() {
         let list_non_nullable = DType::List(
@@ -460,6 +502,25 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_schema_variant_field_metadata() {
+        let dtype = DType::struct_(
+            [("v", DType::Variant(Nullability::NonNullable))],
+            Nullability::NonNullable,
+        );
+        let schema = dtype.to_arrow_schema().unwrap();
+        let field = schema.field(0);
+        assert_eq!(
+            field
+                .metadata()
+                .get("ARROW:extension:name")
+                .map(|s| s.as_str()),
+            Some("arrow.parquet.variant")
+        );
+        assert!(matches!(field.data_type(), DataType::Struct(_)));
+        assert!(!field.is_nullable());
+    }
+
     #[rstest]
     #[should_panic]
     fn test_schema_conversion_panics(the_struct: StructFields) {
diff --git a/vortex-array/src/dtype/bigint/bigcast.rs b/vortex-array/src/dtype/bigint/bigcast.rs
index 0abc55efefb..f9e5adcea18 100644
--- a/vortex-array/src/dtype/bigint/bigcast.rs
+++ b/vortex-array/src/dtype/bigint/bigcast.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use num_traits::AsPrimitive;
 use num_traits::ToPrimitive;
 
 use crate::dtype::i256;
@@ -51,6 +52,12 @@ impl ToI256 for i256 {
     }
 }
 
+impl AsPrimitive<i256> for bool {
+    fn as_(self) -> i256 {
+        i256::from_parts(self as u128, 0)
+    }
+}
+
 /// Checked numeric casts up to and including i256 support.
 ///
 /// This is meant as a more inclusive version of `NumCast` from the `num-traits` crate.
@@ -90,6 +97,15 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_bool_as_i256() {
+        let value: i256 = false.as_();
+        assert_eq!(value, i256::ZERO);
+
+        let value: i256 = true.as_();
+        assert_eq!(value, i256::ONE);
+    }
+
     // All BigCast types must losslessly round-trip themselves
     #[rstest]
     #[case(u8::MAX)]
diff --git a/vortex-array/src/dtype/coercion.rs b/vortex-array/src/dtype/coercion.rs
new file mode 100644
index 00000000000..528d9b673b2
--- /dev/null
+++ b/vortex-array/src/dtype/coercion.rs
@@ -0,0 +1,468 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Utilities for performing type coercion.
+
+use crate::dtype::DType;
+use crate::dtype::PType;
+use crate::dtype::decimal::DecimalDType;
+
+impl PType {
+    /// Returns the least supertype (widest common type) of two primitive types,
+    /// or `None` if no lossless promotion exists.
+    pub fn least_supertype(self, other: PType) -> Option<PType> {
+        if self == other {
+            return Some(self);
+        }
+
+        // Same family — pick the wider.
+        if self.is_unsigned_int() && other.is_unsigned_int() {
+            return Some(self.max_unsigned_ptype(other));
+        }
+        if self.is_signed_int() && other.is_signed_int() {
+            return Some(self.max_signed_ptype(other));
+        }
+        if self.is_float() && other.is_float() {
+            return if self.byte_width() >= other.byte_width() {
+                Some(self)
+            } else {
+                Some(other)
+            };
+        }
+
+        // Unsigned + Signed crossover — promote to signed one width-step wider.
+        if self.is_unsigned_int() && other.is_signed_int() {
+            return Self::unsigned_signed_supertype(self, other);
+        }
+        if self.is_signed_int() && other.is_unsigned_int() {
+            return Self::unsigned_signed_supertype(other, self);
+        }
+
+        // Int + Float — pick the smallest float that losslessly represents the integer.
+        let (int, float) = if self.is_float() {
+            (other, self)
+        } else {
+            (self, other)
+        };
+        Self::int_float_supertype(int, float)
+    }
+
+    fn unsigned_signed_supertype(unsigned: PType, signed: PType) -> Option<PType> {
+        use PType::*;
+        match unsigned.byte_width().max(signed.byte_width()) {
+            1 => Some(I16),
+            2 => Some(I32),
+            4 => Some(I64),
+            _ => None, // U64 + I64 — no lossless 128-bit integer type
+        }
+    }
+
+    fn int_float_supertype(int: PType, float: PType) -> Option<PType> {
+        use PType::*;
+        let min_float = match int.byte_width() {
+            1 => F16,         // f16 has 11-bit mantissa, enough for 8-bit ints
+            2 => F32,         // f32 has 24-bit mantissa, enough for 16-bit ints
+            4 => F64,         // f64 has 53-bit mantissa, enough for 32-bit ints
+            _ => return None, // no standard float for 64-bit ints
+        };
+        if float.byte_width() >= min_float.byte_width() {
+            Some(float)
+        } else {
+            Some(min_float)
+        }
+    }
+}
+
+impl DType {
+    /// The core primitive — what type can hold both `self` and `other`?
+    /// Returns `None` if no common supertype exists.
+    pub fn least_supertype(&self, other: &DType) -> Option<DType> {
+        // 1. Identity (ignoring nullability): return self with union nullability
+        if self.eq_ignore_nullability(other) {
+            return Some(self.with_nullability(self.nullability() | other.nullability()));
+        }
+
+        let union_null = self.nullability() | other.nullability();
+
+        // 2. Null + X: return X as nullable
+        if matches!(self, DType::Null) {
+            return Some(other.as_nullable());
+        }
+        if matches!(other, DType::Null) {
+            return Some(self.as_nullable());
+        }
+
+        // 3. Bool + numeric: return the numeric type (with union nullability)
+        if self.is_boolean() && other.is_numeric() {
+            return Some(other.with_nullability(union_null));
+        }
+        if other.is_boolean() && self.is_numeric() {
+            return Some(self.with_nullability(union_null));
+        }
+
+        // 4. Primitive + Primitive (different ptypes): delegate to PType::least_supertype
+        if let (DType::Primitive(lhs_p, _), DType::Primitive(rhs_p, _)) = (self, other) {
+            return lhs_p
+                .least_supertype(*rhs_p)
+                .map(|p| DType::Primitive(p, union_null));
+        }
+
+        // 5. Decimal + Decimal: compute wider decimal
+        if let (DType::Decimal(lhs_d, _), DType::Decimal(rhs_d, _)) = (self, other) {
+            return decimal_least_supertype(*lhs_d, *rhs_d).map(|d| DType::Decimal(d, union_null));
+        }
+
+        // 6. Decimal + integer Primitive: convert integer to Decimal, then widen
+        if let (DType::Decimal(dec, _), DType::Primitive(p, _)) = (self, other)
+            && p.is_int()
+        {
+            let int_dec = DecimalDType::new(integer_decimal_precision(*p), 0);
+            return decimal_least_supertype(*dec, int_dec).map(|d| DType::Decimal(d, union_null));
+        }
+        if let (DType::Primitive(p, _), DType::Decimal(dec, _)) = (self, other)
+            && p.is_int()
+        {
+            let int_dec = DecimalDType::new(integer_decimal_precision(*p), 0);
+            return decimal_least_supertype(int_dec, *dec).map(|d| DType::Decimal(d, union_null));
+        }
+
+        // 7. Extension + anything: delegate to vtable
+        if let DType::Extension(ext) = self {
+            return ext
+                .least_supertype(other)
+                .map(|dt| dt.with_nullability(union_null));
+        }
+        if let DType::Extension(ext) = other {
+            return ext
+                .least_supertype(self)
+                .map(|dt| dt.with_nullability(union_null));
+        }
+
+        // 8. Everything else: no common supertype
+        None
+    }
+
+    /// Fold over a slice — what type can hold all of these?
+    pub fn least_supertype_of(types: &[DType]) -> Option<DType> {
+        types
+            .iter()
+            .skip(1)
+            .try_fold(types[0].clone(), |acc, t| acc.least_supertype(t))
+    }
+
+    /// Is there any implicit coercion path from `other` to `self`?
+    pub fn can_coerce_from(&self, other: &DType) -> bool {
+        // 1. Same type (ignoring nullability): check nullability compatibility
+        if self.eq_ignore_nullability(other) {
+            return self.is_nullable() || !other.is_nullable();
+        }
+
+        // 2. Null → nullable target
+        if matches!(other, DType::Null) {
+            return self.is_nullable();
+        }
+
+        // 3. Bool → numeric
+        if other.is_boolean() && self.is_numeric() {
+            return self.is_nullable() || !other.is_nullable();
+        }
+
+        // 4. Primitive widening: true if least_supertype(source, target) == target
+        if let (DType::Primitive(..), DType::Primitive(..)) = (self, other) {
+            return other
+                .least_supertype(self)
+                .is_some_and(|st| st.eq_ignore_nullability(self))
+                && (self.is_nullable() || !other.is_nullable());
+        }
+
+        // 5. Decimal widening
+        if let (DType::Decimal(target, _), DType::Decimal(source, _)) = (self, other) {
+            let target_integral = target.precision() as i16 - target.scale() as i16;
+            let source_integral = source.precision() as i16 - source.scale() as i16;
+            return target_integral >= source_integral
+                && target.scale() >= source.scale()
+                && (self.is_nullable() || !other.is_nullable());
+        }
+
+        // 6. Integer → Decimal
+        if let (DType::Decimal(dec, _), DType::Primitive(p, _)) = (self, other)
+            && p.is_int()
+        {
+            let needed = integer_decimal_precision(*p);
+            let integral_digits = dec.precision() as i16 - dec.scale() as i16;
+            return integral_digits >= needed as i16
+                && (self.is_nullable() || !other.is_nullable());
+        }
+
+        // 7. Extension: delegate to vtable
+        if let DType::Extension(ext) = self {
+            return ext.can_coerce_from(other);
+        }
+
+        // 8. Everything else: false
+        false
+    }
+
+    /// Convenience — is there a path from `self` to `other`?
+    pub fn can_coerce_to(&self, other: &DType) -> bool {
+        other.can_coerce_from(self)
+    }
+
+    /// Are all types in the slice mutually coercible to a common type?
+    pub fn are_coercible(types: &[DType]) -> bool {
+        DType::least_supertype_of(types).is_some()
+    }
+
+    /// Can all types in the slice be coerced to a specific target?
+    pub fn all_coercible_to(types: &[DType], target: &DType) -> bool {
+        types.iter().all(|t| target.can_coerce_from(t))
+    }
+
+    /// Coerce a slice to a specific target — returns the vec of targets
+    /// if all are coercible, `None` if any are not.
+    pub fn coerce_all_to(types: &[DType], target: &DType) -> Option<Vec<DType>> {
+        types
+            .iter()
+            .all(|t| target.can_coerce_from(t))
+            .then(|| vec![target.clone(); types.len()])
+    }
+
+    /// Coerce a slice to their mutual least supertype.
+    pub fn coerce_to_supertype(types: &[DType]) -> Option<Vec<DType>> {
+        let supertype = DType::least_supertype_of(types)?;
+        Some(vec![supertype; types.len()])
+    }
+
+    /// Is this a numeric type (primitive int/float or decimal)?
+    pub fn is_numeric(&self) -> bool {
+        matches!(self, DType::Primitive(..) | DType::Decimal(..))
+    }
+
+    /// Is this a temporal type (date, time, timestamp, duration)?
+    pub fn is_temporal(&self) -> bool {
+        match self {
+            DType::Extension(ext) => {
+                use crate::dtype::extension::Matcher;
+                use crate::extension::datetime::AnyTemporal;
+                AnyTemporal::matches(ext)
+            }
+            _ => false,
+        }
+    }
+}
+
+/// Maps integer PType widths to the minimum decimal precision needed.
+fn integer_decimal_precision(ptype: PType) -> u8 {
+    match ptype {
+        PType::U8 | PType::I8 => 3,
+        PType::U16 | PType::I16 => 5,
+        PType::U32 | PType::I32 => 10,
+        PType::U64 | PType::I64 => 19,
+        _ => 19,
+    }
+}
+
+/// Compute the least supertype of two decimal types using SQL-standard rules.
+fn decimal_least_supertype(a: DecimalDType, b: DecimalDType) -> Option<DecimalDType> {
+    let a_integral = a.precision() as i16 - a.scale() as i16;
+    let b_integral = b.precision() as i16 - b.scale() as i16;
+    let max_integral = a_integral.max(b_integral);
+    let max_scale = a.scale().max(b.scale());
+    let precision = u8::try_from(max_integral + max_scale as i16).ok()?;
+    DecimalDType::try_new(precision, max_scale).ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::dtype::DType;
+    use crate::dtype::PType;
+    use crate::dtype::decimal::DecimalDType;
+    use crate::dtype::nullability::Nullability::NonNullable;
+    use crate::dtype::nullability::Nullability::Nullable;
+
+    #[test]
+    fn is_numeric() {
+        assert!(DType::Primitive(PType::I32, NonNullable).is_numeric());
+        assert!(DType::Primitive(PType::F64, NonNullable).is_numeric());
+        assert!(DType::Decimal(DecimalDType::new(10, 2), NonNullable).is_numeric());
+        assert!(!DType::Bool(NonNullable).is_numeric());
+        assert!(!DType::Utf8(NonNullable).is_numeric());
+        assert!(!DType::Null.is_numeric());
+    }
+
+    #[test]
+    fn least_supertype_identity() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        assert_eq!(i32_nn.least_supertype(&i32_nn).unwrap(), i32_nn);
+    }
+
+    #[test]
+    fn least_supertype_nullability_union() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let i32_n = DType::Primitive(PType::I32, Nullable);
+        assert_eq!(i32_nn.least_supertype(&i32_n).unwrap(), i32_n);
+        assert_eq!(i32_n.least_supertype(&i32_nn).unwrap(), i32_n);
+    }
+
+    #[test]
+    fn least_supertype_null_absorption() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        assert_eq!(
+            DType::Null.least_supertype(&i32_nn).unwrap(),
+            DType::Primitive(PType::I32, Nullable)
+        );
+        assert_eq!(
+            i32_nn.least_supertype(&DType::Null).unwrap(),
+            DType::Primitive(PType::I32, Nullable)
+        );
+    }
+
+    #[test]
+    fn least_supertype_unsigned_widening() {
+        let u8_nn = DType::Primitive(PType::U8, NonNullable);
+        let u32_nn = DType::Primitive(PType::U32, NonNullable);
+        assert_eq!(u8_nn.least_supertype(&u32_nn).unwrap(), u32_nn);
+    }
+
+    #[test]
+    fn least_supertype_signed_widening() {
+        let i16_nn = DType::Primitive(PType::I16, NonNullable);
+        let i64_nn = DType::Primitive(PType::I64, NonNullable);
+        assert_eq!(i16_nn.least_supertype(&i64_nn).unwrap(), i64_nn);
+    }
+
+    #[test]
+    fn least_supertype_cross_family() {
+        let u8_nn = DType::Primitive(PType::U8, NonNullable);
+        let i8_nn = DType::Primitive(PType::I8, NonNullable);
+        assert_eq!(
+            u8_nn.least_supertype(&i8_nn).unwrap(),
+            DType::Primitive(PType::I16, NonNullable)
+        );
+    }
+
+    #[test]
+    fn least_supertype_u64_i64_none() {
+        let u64_nn = DType::Primitive(PType::U64, NonNullable);
+        let i64_nn = DType::Primitive(PType::I64, NonNullable);
+        assert!(u64_nn.least_supertype(&i64_nn).is_none());
+    }
+
+    #[test]
+    fn least_supertype_int_float_promotion() {
+        let u8_nn = DType::Primitive(PType::U8, NonNullable);
+        let f32_nn = DType::Primitive(PType::F32, NonNullable);
+        assert_eq!(u8_nn.least_supertype(&f32_nn).unwrap(), f32_nn);
+    }
+
+    #[test]
+    fn least_supertype_i32_f32_to_f64() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let f32_nn = DType::Primitive(PType::F32, NonNullable);
+        assert_eq!(
+            i32_nn.least_supertype(&f32_nn).unwrap(),
+            DType::Primitive(PType::F64, NonNullable)
+        );
+    }
+
+    #[test]
+    fn least_supertype_bool_numeric() {
+        let bool_nn = DType::Bool(NonNullable);
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        assert_eq!(bool_nn.least_supertype(&i32_nn).unwrap(), i32_nn);
+        assert_eq!(i32_nn.least_supertype(&bool_nn).unwrap(), i32_nn);
+    }
+
+    #[test]
+    fn least_supertype_decimal_widening() {
+        let d1 = DType::Decimal(DecimalDType::new(10, 2), NonNullable);
+        let d2 = DType::Decimal(DecimalDType::new(15, 5), NonNullable);
+        let result = d1.least_supertype(&d2).unwrap();
+        // integral digits: max(8, 10) = 10, max scale = 5, precision = 15
+        assert_eq!(
+            result,
+            DType::Decimal(DecimalDType::new(15, 5), NonNullable)
+        );
+    }
+
+    #[test]
+    fn least_supertype_incompatible_none() {
+        let utf8 = DType::Utf8(NonNullable);
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        assert!(utf8.least_supertype(&i32_nn).is_none());
+    }
+
+    #[test]
+    fn can_coerce_from_widening() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let i64_nn = DType::Primitive(PType::I64, NonNullable);
+        assert!(i64_nn.can_coerce_from(&i32_nn));
+    }
+
+    #[test]
+    fn can_coerce_from_narrowing_rejected() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let i64_nn = DType::Primitive(PType::I64, NonNullable);
+        assert!(!i32_nn.can_coerce_from(&i64_nn));
+    }
+
+    #[test]
+    fn can_coerce_from_nullability_constraints() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let i32_n = DType::Primitive(PType::I32, Nullable);
+        assert!(i32_n.can_coerce_from(&i32_nn));
+        assert!(!i32_nn.can_coerce_from(&i32_n));
+    }
+
+    #[test]
+    fn can_coerce_from_null() {
+        let i32_n = DType::Primitive(PType::I32, Nullable);
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        assert!(i32_n.can_coerce_from(&DType::Null));
+        assert!(!i32_nn.can_coerce_from(&DType::Null));
+    }
+
+    #[test]
+    fn are_coercible_mixed() {
+        let types = [
+            DType::Primitive(PType::I32, NonNullable),
+            DType::Primitive(PType::I64, NonNullable),
+        ];
+        assert!(DType::are_coercible(&types));
+    }
+
+    #[test]
+    fn all_coercible_to_target() {
+        let types = [
+            DType::Primitive(PType::I32, NonNullable),
+            DType::Primitive(PType::I16, NonNullable),
+        ];
+        let target = DType::Primitive(PType::I64, NonNullable);
+        assert!(DType::all_coercible_to(&types, &target));
+    }
+
+    #[test]
+    fn coerce_to_supertype_works() {
+        let types = [
+            DType::Primitive(PType::U8, NonNullable),
+            DType::Primitive(PType::I16, NonNullable),
+        ];
+        let result = DType::coerce_to_supertype(&types).unwrap();
+        // U8 + I16: unsigned_signed_supertype max_width=max(1,2)=2 => I32
+        assert_eq!(result, vec![DType::Primitive(PType::I32, NonNullable); 2]);
+    }
+
+    #[test]
+    fn least_supertype_integer_decimal() {
+        let i32_nn = DType::Primitive(PType::I32, NonNullable);
+        let dec = DType::Decimal(DecimalDType::new(15, 5), NonNullable);
+        let result = i32_nn.least_supertype(&dec).unwrap();
+        // int_dec for I32 = Decimal(10, 0). integral digits = 10.
+        // dec integral = 15 - 5 = 10.
+        // max_integral = 10, max_scale = 5, precision = 15
+        assert_eq!(
+            result,
+            DType::Decimal(DecimalDType::new(15, 5), NonNullable)
+        );
+    }
+}
diff --git a/vortex-array/src/dtype/dtype_impl.rs b/vortex-array/src/dtype/dtype_impl.rs
index 36476d6f620..464dea36b09 100644
--- a/vortex-array/src/dtype/dtype_impl.rs
+++ b/vortex-array/src/dtype/dtype_impl.rs
@@ -63,7 +63,8 @@ impl DType {
             | Binary(null)
             | Struct(_, null)
             | List(_, null)
-            | FixedSizeList(_, _, null) => matches!(null, Nullability::Nullable),
+            | FixedSizeList(_, _, null)
+            | Variant(null) => matches!(null, Nullability::Nullable),
         }
     }
 
@@ -87,9 +88,10 @@ impl DType {
             Utf8(_) => Utf8(nullability),
             Binary(_) => Binary(nullability),
             Struct(sf, _) => Struct(sf.clone(), nullability),
-            List(edt, _) => List(edt.clone(), nullability),
-            FixedSizeList(edt, size, _) => FixedSizeList(edt.clone(), *size, nullability),
+            List(edt, _) => List(Arc::clone(edt), nullability),
+            FixedSizeList(edt, size, _) => FixedSizeList(Arc::clone(edt), *size, nullability),
             Extension(ext) => Extension(ext.with_nullability(nullability)),
+            Variant(_) => Variant(nullability),
         }
     }
 
@@ -122,6 +124,7 @@ impl DType {
             (Extension(lhs_extdtype), Extension(rhs_extdtype)) => {
                 lhs_extdtype.eq_ignore_nullability(rhs_extdtype)
             }
+            (Variant(_), Variant(_)) => true,
             _ => false,
         }
     }
@@ -246,11 +249,16 @@ impl DType {
         matches!(self, Extension(_))
     }
 
+    /// Check if `self` is a [`DType::Variant`] type
+    pub fn is_variant(&self) -> bool {
+        matches!(self, Variant(_))
+    }
+
     /// Check if `self` is a nested type, i.e. list, fixed size list, struct, or extension of a
     /// recursive type.
     pub fn is_nested(&self) -> bool {
         match self {
-            List(..) | FixedSizeList(..) | Struct(..) => true,
+            List(..) | FixedSizeList(..) | Struct(..) | Variant(..) => true,
             Extension(ext) => ext.storage_dtype().is_nested(),
             _ => false,
         }
@@ -284,6 +292,7 @@ impl DType {
                 Some(sum)
             }
             Extension(ext) => ext.storage_dtype().element_size(),
+            Variant(_) => None,
         }
     }
 
@@ -459,6 +468,7 @@ impl Display for DType {
             List(edt, null) => write!(f, "list({edt}){null}"),
             FixedSizeList(edt, size, null) => write!(f, "fixed_size_list({edt})[{size}]{null}"),
             Extension(ext) => write!(f, "{}", ext),
+            Variant(null) => write!(f, "variant{null}"),
         }
     }
 }
@@ -529,7 +539,7 @@ mod tests {
     fn element_size_fixed_size_list() {
         let elem = Arc::new(DType::Primitive(PType::F64, NonNullable));
         assert_eq!(
-            DType::FixedSizeList(elem.clone(), 1000, NonNullable).element_size(),
+            DType::FixedSizeList(Arc::clone(&elem), 1000, NonNullable).element_size(),
             Some(8000)
         );
 
diff --git a/vortex-array/src/dtype/extension/erased.rs b/vortex-array/src/dtype/extension/erased.rs
index 5a9c00c0c5a..c84b198516c 100644
--- a/vortex-array/src/dtype/extension/erased.rs
+++ b/vortex-array/src/dtype/extension/erased.rs
@@ -4,9 +4,7 @@
 //! Type-erased extension dtype ([`ExtDTypeRef`]).
 
 use std::any::type_name;
-use std::fmt::Debug;
-use std::fmt::Display;
-use std::fmt::Formatter;
+use std::fmt;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::sync::Arc;
@@ -22,7 +20,7 @@ use crate::dtype::extension::ExtId;
 use crate::dtype::extension::ExtVTable;
 use crate::dtype::extension::Matcher;
 use crate::dtype::extension::typed::DynExtDType;
-use crate::dtype::extension::typed::ExtDTypeInner;
+use crate::scalar::ScalarValue;
 
 /// A type-erased extension dtype.
 ///
@@ -68,23 +66,53 @@ impl ExtDTypeRef {
         }
     }
 
+    /// Compute equality ignoring nullability.
+    pub fn eq_ignore_nullability(&self, other: &Self) -> bool {
+        self.id() == other.id()
+            && self.0.metadata_eq(other.0.metadata_any())
+            && self
+                .storage_dtype()
+                .eq_ignore_nullability(other.storage_dtype())
+    }
+
+    // TODO(connor): We should add a different type that returns something that can be serialized.
     /// Serialize the metadata into a byte vector.
     pub fn serialize_metadata(&self) -> VortexResult<Vec<u8>> {
-        self.0.metadata_serialize()
+        self.0.serialize_metadata()
     }
 
     /// Returns a `Display`-able view of just the metadata.
-    pub fn display_metadata(&self) -> impl Display + '_ {
+    pub fn display_metadata(&self) -> impl fmt::Display + '_ {
         MetadataDisplay(&*self.0)
     }
 
-    /// Compute equality ignoring nullability.
-    pub fn eq_ignore_nullability(&self, other: &Self) -> bool {
-        self.id() == other.id()
-            && self.0.metadata_eq(other.0.metadata_any())
-            && self
-                .storage_dtype()
-                .eq_ignore_nullability(other.storage_dtype())
+    /// Formats an extension scalar value using the current dtype for metadata context.
+    pub(crate) fn fmt_storage_value<'a>(
+        &'a self,
+        f: &mut fmt::Formatter<'_>,
+        storage_value: &'a ScalarValue,
+    ) -> fmt::Result {
+        self.0.value_display(f, storage_value)
+    }
+
+    /// Validates that the given storage scalar value is valid for this dtype.
+    pub(crate) fn validate_storage_value(&self, storage_value: &ScalarValue) -> VortexResult<()> {
+        self.0.validate_scalar_value(storage_value)
+    }
+
+    /// Can a value of `other` be implicitly coerced into this extension type?
+    pub fn can_coerce_from(&self, other: &DType) -> bool {
+        self.0.can_coerce_from(other)
+    }
+
+    /// Can this extension type be implicitly coerced into `other`?
+    pub fn can_coerce_to(&self, other: &DType) -> bool {
+        self.0.can_coerce_to(other)
+    }
+
+    /// Compute the least supertype of this extension type and another type.
+    pub fn least_supertype(&self, other: &DType) -> Option<DType> {
+        self.0.least_supertype(other)
     }
 }
 
@@ -113,12 +141,10 @@ impl ExtDTypeRef {
     /// Downcast to the concrete [`ExtDType`].
     ///
     /// Returns `Err(self)` if the downcast fails.
-    pub fn try_downcast<V: ExtVTable>(self) -> Result<ExtDType<V>, ExtDTypeRef> {
-        if self.0.as_any().is::<ExtDTypeInner<V>>() {
-            // SAFETY: type matches and ExtDTypeInner<V> is the only implementor
-            let ptr = Arc::into_raw(self.0) as *const ExtDTypeInner<V>;
-            let inner = unsafe { Arc::from_raw(ptr) };
-            Ok(ExtDType(inner))
+    pub fn try_downcast<V: ExtVTable>(self) -> Result<Arc<ExtDType<V>>, ExtDTypeRef> {
+        if self.0.as_any().is::<ExtDType<V>>() {
+            let ptr = Arc::into_raw(self.0) as *const ExtDType<V>;
+            Ok(unsafe { Arc::from_raw(ptr) })
         } else {
             Err(self)
         }
@@ -129,7 +155,7 @@ impl ExtDTypeRef {
     /// # Panics
     ///
     /// Panics if the downcast fails.
-    pub fn downcast<V: ExtVTable>(self) -> ExtDType<V> {
+    pub fn downcast<V: ExtVTable>(self) -> Arc<ExtDType<V>> {
         self.try_downcast::<V>()
             .map_err(|this| {
                 vortex_err!(
@@ -142,28 +168,6 @@ impl ExtDTypeRef {
     }
 }
 
-impl Display for ExtDTypeRef {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let metadata = self.display_metadata().to_string();
-        if metadata.is_empty() {
-            write!(f, "{}", self.id())?;
-        } else {
-            write!(f, "{}[{}]", self.id(), metadata)?;
-        }
-        write!(f, "({})", self.storage_dtype())
-    }
-}
-
-impl Debug for ExtDTypeRef {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ExtDType")
-            .field("id", &self.id())
-            .field("metadata", &MetadataDebug(&*self.0))
-            .field("storage_dtype", &self.storage_dtype())
-            .finish()
-    }
-}
-
 impl PartialEq for ExtDTypeRef {
     fn eq(&self, other: &Self) -> bool {
         self.id() == other.id()
@@ -181,20 +185,54 @@ impl Hash for ExtDTypeRef {
     }
 }
 
-// Private formatting helpers for Display and Debug impls.
+impl fmt::Debug for ExtDTypeRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let metadata = self.0.metadata_debug(f);
 
-struct MetadataDisplay<'a>(&'a dyn DynExtDType);
+        f.debug_struct("ExtDType")
+            .field("id", &self.id())
+            .field("metadata", &metadata)
+            .field("storage_dtype", &self.storage_dtype())
+            .finish()
+    }
+}
 
-impl Display for MetadataDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.0.metadata_display(f)
+impl fmt::Display for ExtDTypeRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let metadata = MetadataDisplay(&*self.0).to_string();
+
+        if metadata.is_empty() {
+            write!(f, "{}", self.id())?;
+        } else {
+            write!(f, "{}[{}]", self.id(), metadata)?;
+        }
+
+        write!(f, "({})", self.storage_dtype())
     }
 }
 
-struct MetadataDebug<'a>(&'a dyn DynExtDType);
+// Private formatting helpers for Display and Debug impls.
 
-impl Debug for MetadataDebug<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.0.metadata_debug(f)
+struct MetadataDisplay<'a>(&'a dyn DynExtDType);
+impl fmt::Display for MetadataDisplay<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.metadata_display(f)
     }
 }
+
+// struct PythonDisplay<'a>(&'a dyn DynExtDType);
+// impl fmt::Display for PythonDisplay<'_> {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         let metadata = MetadataDisplay(self.0).to_string();
+
+//         let id = self.0.id();
+//         let escaped_id = id.as_ref().escape_default();
+//         if metadata.is_empty() {
+//             write!(f, "\"{escaped_id}\"",)?;
+//         } else {
+//             write!(f, "\"{escaped_id}\"[{}]", metadata)?;
+//         }
+
+//         write!(f, "({})", self.0.storage_dtype())
+//     }
+// }
diff --git a/vortex-array/src/dtype/extension/foreign.rs b/vortex-array/src/dtype/extension/foreign.rs
new file mode 100644
index 00000000000..7753a5b6b86
--- /dev/null
+++ b/vortex-array/src/dtype/extension/foreign.rs
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexResult;
+
+use crate::dtype::DType;
+use crate::dtype::extension::ExtDType;
+use crate::dtype::extension::ExtDTypeRef;
+use crate::dtype::extension::ExtId;
+use crate::dtype::extension::ExtVTable;
+use crate::scalar::ScalarValue;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ForeignExtMetadata(pub Vec<u8>);
+
+impl Display for ForeignExtMetadata {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}B", self.0.len())
+    }
+}
+
+/// Placeholder extension dtype used when deserializing an unknown extension ID.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ForeignExtDType {
+    id: ExtId,
+}
+
+impl ForeignExtDType {
+    pub fn new(id: ExtId) -> Self {
+        Self { id }
+    }
+
+    pub fn from_parts(
+        id: ExtId,
+        metadata: Vec<u8>,
+        storage_dtype: DType,
+    ) -> VortexResult<ExtDTypeRef> {
+        Ok(
+            ExtDType::try_with_vtable(Self::new(id), ForeignExtMetadata(metadata), storage_dtype)?
+                .erased(),
+        )
+    }
+}
+
+impl ExtVTable for ForeignExtDType {
+    type Metadata = ForeignExtMetadata;
+    type NativeValue<'a> = &'a ScalarValue;
+
+    fn id(&self) -> ExtId {
+        self.id.clone()
+    }
+
+    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(metadata.0.clone())
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        Ok(ForeignExtMetadata(metadata.to_vec()))
+    }
+
+    fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        _ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        Ok(storage_value)
+    }
+}
diff --git a/vortex-array/src/dtype/extension/matcher.rs b/vortex-array/src/dtype/extension/matcher.rs
index 121f62d7aee..279ad955431 100644
--- a/vortex-array/src/dtype/extension/matcher.rs
+++ b/vortex-array/src/dtype/extension/matcher.rs
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use crate::dtype::extension::ExtDType;
 use crate::dtype::extension::ExtDTypeRef;
 use crate::dtype::extension::ExtVTable;
-use crate::dtype::extension::typed::ExtDTypeInner;
 
 /// A trait for matching extension dtypes.
 pub trait Matcher {
@@ -22,14 +22,15 @@ pub trait Matcher {
 impl<V: ExtVTable> Matcher for V {
     type Match<'a> = &'a V::Metadata;
 
-    fn matches(item: &ExtDTypeRef) -> bool {
-        item.0.as_any().is::<ExtDTypeInner<V>>()
+    fn matches(ext_dtype: &ExtDTypeRef) -> bool {
+        ext_dtype.0.as_any().is::<ExtDType<V>>()
     }
 
-    fn try_match<'a>(item: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
-        item.0
+    fn try_match<'a>(ext_dtype: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
+        ext_dtype
+            .0
             .as_any()
-            .downcast_ref::<ExtDTypeInner<V>>()
-            .map(|inner| &inner.metadata)
+            .downcast_ref::<ExtDType<V>>()
+            .map(|inner| inner.metadata())
     }
 }
diff --git a/vortex-array/src/dtype/extension/mod.rs b/vortex-array/src/dtype/extension/mod.rs
index 65eb0ea13a6..0eae1587b40 100644
--- a/vortex-array/src/dtype/extension/mod.rs
+++ b/vortex-array/src/dtype/extension/mod.rs
@@ -14,19 +14,22 @@
 //! - `matcher.rs` — `Matcher` trait + blanket impl for `V: FooVTable`
 
 mod vtable;
-pub use vtable::ExtVTable;
+pub use vtable::*;
 
 mod plugin;
-pub use plugin::ExtDTypePlugin;
+pub use plugin::*;
+
+mod foreign;
+pub(crate) use foreign::*;
 
 mod typed;
-pub use typed::ExtDType;
+pub use typed::*;
 
 mod erased;
-pub use erased::ExtDTypeRef;
+pub use erased::*;
 
 mod matcher;
-pub use matcher::Matcher;
+pub use matcher::*;
 
 /// A unique identifier for an extension type
 pub type ExtId = arcref::ArcRef<str>;
@@ -34,11 +37,11 @@ pub type ExtId = arcref::ArcRef<str>;
 /// Private module to seal [`typed::DynExtDType`].
 mod sealed {
     use crate::dtype::extension::ExtVTable;
-    use crate::dtype::extension::typed::ExtDTypeInner;
+    use crate::dtype::extension::typed::ExtDType;
 
     /// Marker trait to prevent external implementations of [`super::typed::DynExtDType`].
     pub(crate) trait Sealed {}
 
     /// This can be the **only** implementor for [`super::typed::DynExtDType`].
-    impl<V: ExtVTable> Sealed for ExtDTypeInner<V> {}
+    impl<V: ExtVTable> Sealed for ExtDType<V> {}
 }
diff --git a/vortex-array/src/dtype/extension/plugin.rs b/vortex-array/src/dtype/extension/plugin.rs
index abde9c45dac..7d242d85274 100644
--- a/vortex-array/src/dtype/extension/plugin.rs
+++ b/vortex-array/src/dtype/extension/plugin.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
+use std::sync::Arc;
 
 use vortex_error::VortexResult;
 
@@ -11,6 +12,9 @@ use crate::dtype::extension::ExtDTypeRef;
 use crate::dtype::extension::ExtId;
 use crate::dtype::extension::ExtVTable;
 
+/// Reference-counted pointer to an extension dtype plugin.
+pub type ExtDTypePluginRef = Arc<dyn ExtDTypePlugin>;
+
 /// Registry trait for ID-based deserialization of extension dtypes.
 ///
 /// Plugins are registered in the session by their [`ExtId`]. When a serialized extension dtype
diff --git a/vortex-array/src/dtype/extension/typed.rs b/vortex-array/src/dtype/extension/typed.rs
index ab61309e0dd..747b813afad 100644
--- a/vortex-array/src/dtype/extension/typed.rs
+++ b/vortex-array/src/dtype/extension/typed.rs
@@ -4,13 +4,10 @@
 //! Typed and inner representations of extension dtypes.
 //!
 //! - [`ExtDType<V>`]: The public typed wrapper, parameterized by a concrete [`ExtVTable`].
-//! - [`ExtDTypeInner<V>`]: The private inner struct that holds the vtable + data.
 //! - [`DynExtDType`]: The private sealed trait for type-erased dispatch.
 
 use std::any::Any;
-use std::fmt::Debug;
-use std::fmt::Display;
-use std::fmt::Formatter;
+use std::fmt;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::sync::Arc;
@@ -23,6 +20,7 @@ use crate::dtype::Nullability;
 use crate::dtype::extension::ExtDTypeRef;
 use crate::dtype::extension::ExtId;
 use crate::dtype::extension::ExtVTable;
+use crate::scalar::ScalarValue;
 
 /// A typed extension data type, parameterized by a concrete [`ExtVTable`].
 ///
@@ -33,7 +31,14 @@ use crate::dtype::extension::ExtVTable;
 /// [`try_with_vtable()`]: ExtDType::try_with_vtable
 /// [`erased()`]: ExtDType::erased
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExtDType<V: ExtVTable>(pub(super) Arc<ExtDTypeInner<V>>);
+pub struct ExtDType<V: ExtVTable> {
+    /// The extension dtype vtable.
+    vtable: V,
+    /// The extension dtype metadata.
+    metadata: V::Metadata,
+    /// The underlying storage dtype.
+    storage_dtype: DType,
+}
 
 /// Convenience implementation for zero-sized VTables (or VTables that implement `Default`).
 impl<V: ExtVTable + Default> ExtDType<V> {
@@ -43,6 +48,7 @@ impl<V: ExtVTable + Default> ExtDType<V> {
     }
 }
 
+#[allow(clippy::same_name_method)]
 impl<V: ExtVTable> ExtDType<V> {
     /// Creates a new extension dtype with the given metadata and storage dtype.
     pub fn try_with_vtable(
@@ -50,110 +56,130 @@ impl<V: ExtVTable> ExtDType<V> {
         metadata: V::Metadata,
         storage_dtype: DType,
     ) -> VortexResult<Self> {
-        vtable.validate_dtype(&metadata, &storage_dtype)?;
-
-        Ok(Self(Arc::new(ExtDTypeInner::<V> {
+        let this = Self {
             vtable,
             metadata,
             storage_dtype,
-        })))
+        };
+
+        V::validate_dtype(&this)?;
+
+        Ok(this)
     }
 
     /// Returns the identifier of the extension type.
     pub fn id(&self) -> ExtId {
-        self.0.vtable.id()
+        self.vtable.id()
     }
 
     /// Returns the vtable of the extension type.
     pub fn vtable(&self) -> &V {
-        &self.0.vtable
+        &self.vtable
     }
 
     /// Returns the metadata of the extension type.
     pub fn metadata(&self) -> &V::Metadata {
-        &self.0.metadata
+        &self.metadata
     }
 
     /// Returns the storage dtype of the extension type.
     pub fn storage_dtype(&self) -> &DType {
-        &self.0.storage_dtype
+        &self.storage_dtype
     }
 
-    /// Erase the concrete type information, returning a type-erased extension dtype.
-    pub fn erased(self) -> ExtDTypeRef {
-        ExtDTypeRef(self.0)
+    /// Returns a new [`ExtDTypeRef`] with the given nullability.
+    pub fn with_nullability(&self, nullability: Nullability) -> ExtDTypeRef {
+        let storage_dtype = self.storage_dtype.with_nullability(nullability);
+        ExtDType::<V>::try_with_vtable(self.vtable.clone(), self.metadata.clone(), storage_dtype)
+            .vortex_expect(
+                "Extension DType should not fail validation with the same storage type \
+                 but different nullability",
+            )
+            .erased()
+    }
+
+    /// Serializes the metadata into a byte vector.
+    pub fn serialize_metadata(&self) -> VortexResult<Vec<u8>> {
+        V::serialize_metadata(&self.vtable, &self.metadata)
     }
-}
 
-// ---------------------------------------------------------------------------
-// Private inner struct + sealed trait
-// ---------------------------------------------------------------------------
+    /// Validates that the given storage scalar value is valid for this dtype.
+    pub fn validate_scalar_value(&self, storage_value: &ScalarValue) -> VortexResult<()> {
+        V::validate_scalar_value(self, storage_value)
+    }
 
-/// The private inner representation of an extension dtype, pairing a vtable with its metadata
-/// and storage dtype.
-///
-/// This is the sole implementor of [`DynExtDType`], enabling [`ExtDTypeRef`] to safely downcast
-/// back to the concrete vtable type via [`Any`].
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub(super) struct ExtDTypeInner<V: ExtVTable> {
-    /// The extension dtype vtable.
-    pub(super) vtable: V,
-    /// The extension dtype metadata.
-    pub(super) metadata: V::Metadata,
-    /// The underlying storage dtype.
-    pub(super) storage_dtype: DType,
+    /// Can a value of `other` be implicitly coerced into this extension type?
+    pub fn can_coerce_from(&self, other: &DType) -> bool {
+        V::can_coerce_from(self, other)
+    }
+
+    /// Can this extension type be implicitly coerced into `other`?
+    pub fn can_coerce_to(&self, other: &DType) -> bool {
+        V::can_coerce_to(self, other)
+    }
+
+    /// Compute the least supertype of this extension type and another type.
+    pub fn least_supertype(&self, other: &DType) -> Option<DType> {
+        V::least_supertype(self, other)
+    }
+
+    /// Erase the concrete type information, returning a type-erased extension dtype.
+    pub fn erased(self) -> ExtDTypeRef {
+        ExtDTypeRef(Arc::new(self))
+    }
 }
 
-/// An object-safe, sealed trait encapsulating the behavior for extension dtypes.
+/// An object-safe, sealed trait for type-erased extension dtype dispatch.
 ///
-/// This provides type-erased access to the extension dtype's identity, storage dtype, and
-/// metadata. The only implementor is [`ExtDTypeInner`].
+/// Methods that have a corresponding inherent method on [`ExtDType<V>`] are thin forwarders
+/// (e.g. `id`, `storage_dtype`). Methods that exist only for erased dispatch have no
+/// inherent counterpart (e.g. `as_any`, `metadata_any`, `metadata_eq`).
 pub(super) trait DynExtDType: 'static + Send + Sync + super::sealed::Sealed {
-    /// Returns `self` as a trait object for downcasting.
     fn as_any(&self) -> &dyn Any;
-    /// Returns the [`ExtId`] identifying this extension type.
     fn id(&self) -> ExtId;
-    /// Returns a reference to the storage [`DType`].
     fn storage_dtype(&self) -> &DType;
-    /// Returns the metadata as a trait object for downcasting.
     fn metadata_any(&self) -> &dyn Any;
-    /// Formats the metadata using [`Debug`].
-    fn metadata_debug(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
-    /// Formats the metadata using [`Display`].
-    fn metadata_display(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
-    /// Checks equality of the metadata against a type-erased value.
+    fn metadata_debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
+    fn metadata_display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
     fn metadata_eq(&self, other: &dyn Any) -> bool;
-    /// Hashes the metadata into the given [`Hasher`].
     fn metadata_hash(&self, state: &mut dyn Hasher);
-    /// Serializes the metadata into a byte vector.
-    fn metadata_serialize(&self) -> VortexResult<Vec<u8>>;
-    /// Returns a new [`ExtDTypeRef`] with the given nullability.
+    fn serialize_metadata(&self) -> VortexResult<Vec<u8>>;
     fn with_nullability(&self, nullability: Nullability) -> ExtDTypeRef;
+    fn validate_scalar_value(&self, storage_value: &ScalarValue) -> VortexResult<()>;
+    fn value_display(&self, f: &mut fmt::Formatter<'_>, storage_value: &ScalarValue)
+    -> fmt::Result;
+    fn can_coerce_from(&self, other: &DType) -> bool;
+    fn can_coerce_to(&self, other: &DType) -> bool;
+    fn least_supertype(&self, other: &DType) -> Option<DType>;
 }
 
-impl<V: ExtVTable> DynExtDType for ExtDTypeInner<V> {
+/// Blanket impl: thin forwarder to `ExtDType<V>` inherent methods.
+///
+/// Rust's method resolution picks inherent methods over trait methods, so `self.id()` etc.
+/// call the inherent impl, not this trait impl (no infinite recursion).
+impl<V: ExtVTable> DynExtDType for ExtDType<V> {
     fn as_any(&self) -> &dyn Any {
         self
     }
 
     fn id(&self) -> ExtId {
-        self.vtable.id()
+        self.id()
     }
 
     fn storage_dtype(&self) -> &DType {
-        &self.storage_dtype
+        self.storage_dtype()
     }
 
     fn metadata_any(&self) -> &dyn Any {
         &self.metadata
     }
 
-    fn metadata_debug(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        <V::Metadata as Debug>::fmt(&self.metadata, f)
+    fn metadata_debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <V::Metadata as fmt::Debug>::fmt(&self.metadata, f)
     }
 
-    fn metadata_display(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        <V::Metadata as Display>::fmt(&self.metadata, f)
+    fn metadata_display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <V::Metadata as fmt::Display>::fmt(&self.metadata, f)
     }
 
     fn metadata_eq(&self, other: &dyn Any) -> bool {
@@ -167,17 +193,43 @@ impl<V: ExtVTable> DynExtDType for ExtDTypeInner<V> {
         <V::Metadata as Hash>::hash(&self.metadata, &mut state);
     }
 
-    fn metadata_serialize(&self) -> VortexResult<Vec<u8>> {
-        V::serialize_metadata(&self.vtable, &self.metadata)
+    fn serialize_metadata(&self) -> VortexResult<Vec<u8>> {
+        self.serialize_metadata()
     }
 
     fn with_nullability(&self, nullability: Nullability) -> ExtDTypeRef {
-        let storage_dtype = self.storage_dtype.with_nullability(nullability);
-        ExtDType::<V>::try_with_vtable(self.vtable.clone(), self.metadata.clone(), storage_dtype)
-            .vortex_expect(
-                "Extension DType should not fail validation with the same storage type \
-                 but different nullability",
-            )
-            .erased()
+        self.with_nullability(nullability)
+    }
+
+    fn validate_scalar_value(&self, storage_value: &ScalarValue) -> VortexResult<()> {
+        self.validate_scalar_value(storage_value)
+    }
+
+    fn value_display(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        storage_value: &ScalarValue,
+    ) -> fmt::Result {
+        match V::unpack_native(self, storage_value) {
+            Ok(native) => fmt::Display::fmt(&native, f),
+            Err(_) => write!(
+                f,
+                "<error unpacking native storage value {} for extension type {}>",
+                storage_value,
+                self.id()
+            ),
+        }
+    }
+
+    fn can_coerce_from(&self, other: &DType) -> bool {
+        self.can_coerce_from(other)
+    }
+
+    fn can_coerce_to(&self, other: &DType) -> bool {
+        self.can_coerce_to(other)
+    }
+
+    fn least_supertype(&self, other: &DType) -> Option<DType> {
+        self.least_supertype(other)
     }
 }
diff --git a/vortex-array/src/dtype/extension/vtable.rs b/vortex-array/src/dtype/extension/vtable.rs
index 84f530ea06f..1b763f53635 100644
--- a/vortex-array/src/dtype/extension/vtable.rs
+++ b/vortex-array/src/dtype/extension/vtable.rs
@@ -8,6 +8,7 @@ use std::hash::Hash;
 use vortex_error::VortexResult;
 
 use crate::dtype::DType;
+use crate::dtype::extension::ExtDType;
 use crate::dtype::extension::ExtId;
 use crate::scalar::ScalarValue;
 
@@ -36,7 +37,33 @@ pub trait ExtVTable: 'static + Sized + Send + Sync + Clone + Debug + Eq + Hash {
     fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata>;
 
     /// Validate that the given storage type is compatible with this extension type.
-    fn validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &DType) -> VortexResult<()>;
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()>;
+
+    /// Can a value of `other` be implicitly widened into this type?
+    /// e.g. GeographyType might accept Point, LineString, etc.
+    ///
+    /// Implementors only need to override one of `can_coerce_from` or `can_coerce_to` — both
+    /// exist so that either side of the coercion can provide the logic.
+    fn can_coerce_from(ext_dtype: &ExtDType<Self>, other: &DType) -> bool {
+        let _ = (ext_dtype, other);
+        false
+    }
+
+    /// Can this type be implicitly widened into `other`?
+    ///
+    /// Implementors only need to override one of `can_coerce_from` or `can_coerce_to` — both
+    /// exist so that either side of the coercion can provide the logic.
+    fn can_coerce_to(ext_dtype: &ExtDType<Self>, other: &DType) -> bool {
+        let _ = (ext_dtype, other);
+        false
+    }
+
+    /// Given two types in a Uniform context, what is their least supertype?
+    /// Return None if no supertype exists.
+    fn least_supertype(ext_dtype: &ExtDType<Self>, other: &DType) -> Option<DType> {
+        let _ = (ext_dtype, other);
+        None
+    }
 
     // Methods related to the extension scalar values.
 
@@ -48,28 +75,23 @@ pub trait ExtVTable: 'static + Sized + Send + Sync + Clone + Debug + Eq + Hash {
     ///
     /// Returns an error if the storage [`ScalarValue`] is not compatible with the extension type.
     fn validate_scalar_value(
-        &self,
-        metadata: &Self::Metadata,
-        storage_dtype: &DType,
+        ext_dtype: &ExtDType<Self>,
         storage_value: &ScalarValue,
     ) -> VortexResult<()> {
-        self.unpack_native(metadata, storage_dtype, storage_value)
-            .map(|_| ())
+        Self::unpack_native(ext_dtype, storage_value).map(|_| ())
     }
 
     /// Validate and unpack a native value from the storage [`ScalarValue`].
     ///
     /// Note that [`ExtVTable::validate_dtype()`] is always called first to validate the storage
-    /// [`DType`], and the [`Scalar`](crate::scalar::Scalar) implementation will verify that the
-    /// storage value is compatible with the storage dtype on construction.
+    /// [`crate::dtype::DType`], and the [`Scalar`](crate::scalar::Scalar) implementation will
+    /// verify that the storage value is compatible with the storage dtype on construction.
     ///
     /// # Errors
     ///
     /// Returns an error if the storage [`ScalarValue`] is not compatible with the extension type.
     fn unpack_native<'a>(
-        &self,
-        metadata: &'a Self::Metadata,
-        storage_dtype: &'a DType,
+        ext_dtype: &'a ExtDType<Self>,
         storage_value: &'a ScalarValue,
     ) -> VortexResult<Self::NativeValue<'a>>;
 }
diff --git a/vortex-array/src/dtype/mod.rs b/vortex-array/src/dtype/mod.rs
index 6c5f58b966e..8041faae414 100644
--- a/vortex-array/src/dtype/mod.rs
+++ b/vortex-array/src/dtype/mod.rs
@@ -10,6 +10,7 @@
 mod arbitrary;
 pub mod arrow;
 mod bigint;
+mod coercion;
 mod decimal;
 mod dtype_impl;
 pub mod extension;
@@ -100,6 +101,9 @@ pub enum DType {
     ///
     /// See [`ExtDTypeRef`] for more information.
     Extension(ExtDTypeRef),
+
+    /// Variant type.
+    Variant(Nullability),
 }
 
 pub use bigint::*;
diff --git a/vortex-array/src/dtype/serde/flatbuffers.rs b/vortex-array/src/dtype/serde/flatbuffers.rs
index 2cd12f5dc77..af7ed7b8af3 100644
--- a/vortex-array/src/dtype/serde/flatbuffers.rs
+++ b/vortex-array/src/dtype/serde/flatbuffers.rs
@@ -24,6 +24,7 @@ use crate::dtype::FieldDType;
 use crate::dtype::PType;
 use crate::dtype::StructFields;
 use crate::dtype::extension::ExtId;
+use crate::dtype::extension::ForeignExtDType;
 use crate::dtype::flatbuffers as fb;
 use crate::dtype::session::DTypeSessionExt;
 
@@ -213,27 +214,28 @@ impl TryFrom<ViewedDType> for DType {
                 let storage_dtype = DType::try_from(storage_view)
                     .map_err(|e| vortex_err!("failed to create DType from fbs message: {e}"))?;
 
-                let vtable = vfdt
-                    .session
-                    .dtypes()
-                    .registry()
-                    .find(&id)
-                    .ok_or_else(|| vortex_err!("No such DType extension ID: {}", id))?;
-                let ext_dtype = vtable.deserialize(
-                    fb_ext
-                        .metadata()
-                        .ok_or_else(|| {
-                            vortex_err!("failed to parse extension metadata from flatbuffer")
-                        })?
-                        .bytes(),
-                    storage_dtype,
-                )?;
+                let metadata = fb_ext
+                    .metadata()
+                    .ok_or_else(|| {
+                        vortex_err!("failed to parse extension metadata from flatbuffer")
+                    })?
+                    .bytes();
+                let ext_dtype = if let Some(vtable) = vfdt.session.dtypes().registry().find(&id) {
+                    vtable.deserialize(metadata, storage_dtype)?
+                } else if vfdt.session.allows_unknown() {
+                    ForeignExtDType::from_parts(id, metadata.to_vec(), storage_dtype)?
+                } else {
+                    return Err(vortex_err!("No such DType extension ID: {}", id));
+                };
 
                 Ok(Self::Extension(ext_dtype))
             }
-            // This is here to fail to compile if another variant is included.
-            #[allow(clippy::wildcard_in_or_patterns)]
-            fb::Type(11) => Err(vortex_err!("Unknown DType variant")),
+            fb::Type::Variant => {
+                let fb_variant = fb
+                    .type__as_variant()
+                    .ok_or_else(|| vortex_err!("failed to parse variant from flatbuffer"))?;
+                Ok(Self::Variant(fb_variant.nullable().into()))
+            }
             _ => Err(vortex_err!("Unknown DType variant")),
         }
     }
@@ -349,6 +351,13 @@ impl WriteFlatBuffer for DType {
                 )
                 .as_union_value()
             }
+            Self::Variant(n) => fb::Variant::create(
+                fbb,
+                &fb::VariantArgs {
+                    nullable: (*n).into(),
+                },
+            )
+            .as_union_value(),
         };
 
         let dtype_type = match self {
@@ -362,6 +371,7 @@ impl WriteFlatBuffer for DType {
             Self::List(..) => fb::Type::List,
             Self::FixedSizeList(..) => fb::Type::FixedSizeList,
             Self::Extension { .. } => fb::Type::Extension,
+            Self::Variant(_) => fb::Type::Variant,
         };
 
         Ok(fb::DType::create(
@@ -477,6 +487,7 @@ mod test {
                 ],
             ),
             Nullability::NonNullable,
-        ))
+        ));
+        roundtrip_dtype(DType::Variant(Nullability::Nullable));
     }
 }
diff --git a/vortex-array/src/dtype/serde/mod.rs b/vortex-array/src/dtype/serde/mod.rs
index ca8e06dd863..1dbeeb6cf8b 100644
--- a/vortex-array/src/dtype/serde/mod.rs
+++ b/vortex-array/src/dtype/serde/mod.rs
@@ -69,6 +69,22 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_serde_variant_dtype() {
+        use serde_test::assert_ser_tokens;
+
+        assert_ser_tokens(
+            &DType::Variant(Nullability::NonNullable),
+            &[
+                Token::NewtypeVariant {
+                    name: "DType",
+                    variant: "Variant",
+                },
+                Token::Bool(false),
+            ],
+        );
+    }
+
     #[test]
     fn test_serde_nullability() {
         assert_tokens(&Nullability::NonNullable, &[Token::Bool(false)]);
@@ -153,4 +169,16 @@ mod test {
             .unwrap();
         assert_eq!(fields, from_value);
     }
+
+    #[test]
+    fn test_serde_variant_dtype_json_roundtrip() {
+        let json = serde_json::to_string(&DType::Variant(Nullability::Nullable)).unwrap();
+        assert_eq!(json, "{\"Variant\":true}");
+
+        let mut deserializer = serde_json::Deserializer::from_str(&json);
+        let deserialized: DType = DTypeSerde::<DType>::new(&SESSION)
+            .deserialize(&mut deserializer)
+            .unwrap();
+        assert_eq!(DType::Variant(Nullability::Nullable), deserialized);
+    }
 }
diff --git a/vortex-array/src/dtype/serde/proto.rs b/vortex-array/src/dtype/serde/proto.rs
index 98c1453da02..4ca8642120b 100644
--- a/vortex-array/src/dtype/serde/proto.rs
+++ b/vortex-array/src/dtype/serde/proto.rs
@@ -13,6 +13,7 @@ use crate::dtype::DecimalDType;
 use crate::dtype::PType;
 use crate::dtype::StructFields;
 use crate::dtype::extension::ExtId;
+use crate::dtype::extension::ForeignExtDType;
 use crate::dtype::field::Field;
 use crate::dtype::field::FieldPath;
 use crate::dtype::proto::dtype as pb;
@@ -87,18 +88,22 @@ impl DType {
             }
             DtypeType::Extension(e) => {
                 let id = ExtId::new_arc(e.id.as_str().to_string().into());
-                let vtable = session.dtypes().registry().find(&id).ok_or_else(
-                    || vortex_err!(Serde: "Unregistered extension type ID: {}", e.id),
-                )?;
                 let storage_dtype = DType::from_proto(
                     e.storage_dtype
                         .as_ref()
                         .ok_or_else(|| vortex_err!("Extension DType missing storage proto"))?,
                     session,
                 )?;
-                let ext_dtype = vtable.deserialize(e.metadata(), storage_dtype)?;
+                let ext_dtype = if let Some(vtable) = session.dtypes().registry().find(&id) {
+                    vtable.deserialize(e.metadata(), storage_dtype)?
+                } else if session.allows_unknown() {
+                    ForeignExtDType::from_parts(id, e.metadata().to_vec(), storage_dtype)?
+                } else {
+                    return Err(vortex_err!(Serde: "Unregistered extension type ID: {}", e.id));
+                };
                 Ok(Self::Extension(ext_dtype))
             }
+            DtypeType::Variant(v) => Ok(Self::Variant(v.nullable.into())),
         }
     }
 }
@@ -152,6 +157,9 @@ impl TryFrom<&DType> for pb::DType {
                     storage_dtype: Some(Box::new(e.storage_dtype().try_into()?)),
                     metadata: Some(e.serialize_metadata()?),
                 })),
+                DType::Variant(null) => DtypeType::Variant(pb::Variant {
+                    nullable: (*null).into(),
+                }),
             }),
         })
     }
@@ -217,6 +225,8 @@ impl TryFrom<&pb::FieldPath> for FieldPath {
 mod tests {
     use std::sync::Arc;
 
+    use vortex_session::VortexSession;
+
     use super::*;
     use crate::dtype::DType;
     use crate::dtype::DecimalDType;
@@ -361,6 +371,12 @@ mod tests {
         assert_eq!(ext_dtype, converted);
     }
 
+    #[test]
+    fn test_variant_round_trip() {
+        let converted = round_trip_dtype(&DType::Variant(Nullability::Nullable));
+        assert_eq!(DType::Variant(Nullability::Nullable), converted);
+    }
+
     #[test]
     fn test_field_path_round_trip() {
         let test_paths = vec![
@@ -480,4 +496,35 @@ mod tests {
                 .contains("Extension DType missing storage proto")
         );
     }
+
+    #[test]
+    fn test_unknown_extension_allow_unknown() {
+        let session = VortexSession::empty().allow_unknown();
+        let proto = pb::DType {
+            dtype_type: Some(DtypeType::Extension(Box::new(pb::Extension {
+                id: "vortex.test.foreign_ext".to_string(),
+                storage_dtype: Some(Box::new(pb::DType {
+                    dtype_type: Some(DtypeType::Primitive(pb::Primitive {
+                        r#type: pb::PType::I32.into(),
+                        nullable: false,
+                    })),
+                })),
+                metadata: Some(vec![1, 2, 3]),
+            }))),
+        };
+
+        let dtype = DType::from_proto(&proto, &session).unwrap();
+        let DType::Extension(ext) = &dtype else {
+            panic!("Expected extension dtype");
+        };
+        assert_eq!(ext.id().as_ref(), "vortex.test.foreign_ext");
+        assert_eq!(ext.serialize_metadata().unwrap(), vec![1, 2, 3]);
+
+        let roundtrip = pb::DType::try_from(&dtype).unwrap();
+        let DtypeType::Extension(roundtrip_ext) = roundtrip.dtype_type.unwrap() else {
+            panic!("Expected extension dtype");
+        };
+        assert_eq!(roundtrip_ext.id, "vortex.test.foreign_ext");
+        assert_eq!(roundtrip_ext.metadata(), &[1, 2, 3]);
+    }
 }
diff --git a/vortex-array/src/dtype/serde/serde.rs b/vortex-array/src/dtype/serde/serde.rs
index a14f9c47321..e89a1a98658 100644
--- a/vortex-array/src/dtype/serde/serde.rs
+++ b/vortex-array/src/dtype/serde/serde.rs
@@ -30,6 +30,7 @@ use crate::dtype::StructFields;
 use crate::dtype::decimal::DecimalDType;
 use crate::dtype::extension::ExtDTypeRef;
 use crate::dtype::extension::ExtId;
+use crate::dtype::extension::ForeignExtDType;
 use crate::dtype::session::DTypeSessionExt;
 
 /// Serialize Nullability as a boolean
@@ -117,6 +118,7 @@ impl Serialize for DType {
             DType::Extension(ext) => {
                 serializer.serialize_newtype_variant("DType", 9, "Extension", ext)
             }
+            DType::Variant(n) => serializer.serialize_newtype_variant("DType", 10, "Variant", n),
         }
     }
 }
@@ -156,6 +158,7 @@ impl<'de> DeserializeSeed<'de> for DTypeSerde<'_, DType> {
             "FixedSizeList",
             "Struct",
             "Extension",
+            "Variant",
         ];
 
         struct DTypeVisitor<'a> {
@@ -217,6 +220,10 @@ impl<'de> DeserializeSeed<'de> for DTypeSerde<'_, DType> {
                             .newtype_variant_seed(DTypeSerde::<ExtDTypeRef>::new(self.session))?;
                         Ok(DType::Extension(ext))
                     }
+                    "Variant" => {
+                        let n = access.newtype_variant()?;
+                        Ok(DType::Variant(n))
+                    }
                     _ => Err(de::Error::unknown_variant(&variant, VARIANTS)),
                 }
             }
@@ -565,20 +572,30 @@ impl<'de> DeserializeSeed<'de> for DTypeSerde<'_, ExtDTypeRef> {
 
                 let id = id.ok_or_else(|| de::Error::missing_field("id"))?;
                 let id = ExtId::new_arc(id);
-                let vtable = self.session.dtypes().registry().find(&id).ok_or_else(|| {
-                    de::Error::custom(format!("unknown extension dtype id: {}", id))
-                })?;
-
                 let storage_dtype =
                     storage_dtype.ok_or_else(|| de::Error::missing_field("storage_dtype"))?;
                 let metadata = metadata.ok_or_else(|| de::Error::missing_field("metadata"))?;
 
-                vtable.deserialize(&metadata, storage_dtype).map_err(|e| {
-                    de::Error::custom(format!(
-                        "failed to deserialize extension dtype {}: {}",
-                        id, e
-                    ))
-                })
+                if let Some(vtable) = self.session.dtypes().registry().find(&id) {
+                    vtable.deserialize(&metadata, storage_dtype).map_err(|e| {
+                        de::Error::custom(format!(
+                            "failed to deserialize extension dtype {}: {}",
+                            id, e
+                        ))
+                    })
+                } else if self.session.allows_unknown() {
+                    ForeignExtDType::from_parts(id, metadata, storage_dtype).map_err(|e| {
+                        de::Error::custom(format!(
+                            "failed to deserialize unknown extension dtype: {}",
+                            e
+                        ))
+                    })
+                } else {
+                    Err(de::Error::custom(format!(
+                        "unknown extension dtype id: {}",
+                        id
+                    )))
+                }
             }
         }
 
diff --git a/vortex-array/src/dtype/session.rs b/vortex-array/src/dtype/session.rs
index eda91bd1a11..669aab68165 100644
--- a/vortex-array/src/dtype/session.rs
+++ b/vortex-array/src/dtype/session.rs
@@ -9,14 +9,14 @@ use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::registry::Registry;
 
-use crate::dtype::extension::ExtDTypePlugin;
+use crate::dtype::extension::ExtDTypePluginRef;
 use crate::dtype::extension::ExtVTable;
 use crate::extension::datetime::Date;
 use crate::extension::datetime::Time;
 use crate::extension::datetime::Timestamp;
 
 /// Registry for extension dtypes.
-pub type ExtDTypeRegistry = Registry<Arc<dyn ExtDTypePlugin>>;
+pub type ExtDTypeRegistry = Registry<ExtDTypePluginRef>;
 
 /// Session for managing extension dtypes.
 #[derive(Debug)]
@@ -43,7 +43,7 @@ impl DTypeSession {
     /// Register an extension DType with the Vortex session.
     pub fn register<V: ExtVTable>(&self, vtable: V) {
         self.registry
-            .register(vtable.id(), Arc::new(vtable) as Arc<dyn ExtDTypePlugin>);
+            .register(vtable.id(), Arc::new(vtable) as ExtDTypePluginRef);
     }
 
     /// Return the registry of extension dtypes.
diff --git a/vortex-array/src/dtype/struct_.rs b/vortex-array/src/dtype/struct_.rs
index f88492b5945..b824caf22dd 100644
--- a/vortex-array/src/dtype/struct_.rs
+++ b/vortex-array/src/dtype/struct_.rs
@@ -106,7 +106,6 @@ impl FieldDType {
 }
 
 impl FieldDTypeInner {
-    #[inline]
     fn value(&self) -> VortexResult<DType> {
         match &self {
             FieldDTypeInner::Owned(owned) => Ok(owned.clone()),
diff --git a/vortex-array/src/executor.rs b/vortex-array/src/executor.rs
index 58e128d253f..be47f178467 100644
--- a/vortex-array/src/executor.rs
+++ b/vortex-array/src/executor.rs
@@ -1,20 +1,55 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! The execution engine: iteratively transforms arrays toward canonical form.
+//!
+//! Execution proceeds through four layers tried in order on each iteration:
+//!
+//! 1. **`reduce`** -- metadata-only self-rewrite (cheapest).
+//! 2. **`reduce_parent`** -- metadata-only child-driven parent rewrite.
+//! 3. **`execute_parent`** -- child-driven fused execution (may read buffers).
+//! 4. **`execute`** -- the encoding's own decode step (most expensive).
+//!
+//! The main entry point is [`DynArray::execute_until`], which uses an explicit work stack
+//! to drive execution iteratively without recursion. Between steps, the optimizer runs
+//! reduce/reduce_parent rules to fixpoint.
+//!
+//! See <https://docs.vortex.dev/developer-guide/internals/execution> for a full description
+//! of the model.
+
+use std::env::VarError;
 use std::fmt;
 use std::fmt::Display;
-use std::sync::Arc;
+use std::sync::LazyLock;
 use std::sync::atomic::AtomicUsize;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
 use crate::AnyCanonical;
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray;
+use crate::matcher::Matcher;
+use crate::memory::HostAllocatorRef;
+use crate::memory::MemorySessionExt;
+use crate::optimizer::ArrayOptimizer;
+
+/// Maximum number of iterations to attempt when executing an array before giving up and returning
+/// an error.
+pub(crate) static MAX_ITERATIONS: LazyLock<usize> =
+    LazyLock::new(|| match std::env::var("VORTEX_MAX_ITERATIONS") {
+        Ok(val) => val
+            .parse::<usize>()
+            .unwrap_or_else(|e| vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid usize: {e}")),
+        Err(VarError::NotPresent) => 128,
+        Err(VarError::NotUnicode(_)) => {
+            vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid unicode string")
+        }
+    });
 
 /// Marker trait for types that an [`ArrayRef`] can be executed into.
 ///
@@ -27,28 +62,133 @@ pub trait Executable: Sized {
     fn execute(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Self>;
 }
 
-impl dyn Array + '_ {
+#[allow(clippy::same_name_method)]
+impl ArrayRef {
     /// Execute this array to produce an instance of `E`.
     ///
     /// See the [`Executable`] implementation for details on how this execution is performed.
-    pub fn execute<E: Executable>(self: Arc<Self>, ctx: &mut ExecutionCtx) -> VortexResult<E> {
+    pub fn execute<E: Executable>(self, ctx: &mut ExecutionCtx) -> VortexResult<E> {
         E::execute(self, ctx)
     }
 
     /// Execute this array, labeling the execution step with a name for tracing.
     pub fn execute_as<E: Executable>(
-        self: Arc<Self>,
+        self,
         _name: &'static str,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<E> {
         E::execute(self, ctx)
     }
+
+    /// Iteratively execute this array until the [`Matcher`] matches, using an explicit work
+    /// stack.
+    ///
+    /// The scheduler repeatedly:
+    /// 1. Checks if the current array matches `M` — if so, pops the stack or returns.
+    /// 2. Runs `execute_parent` on each child for child-driven optimizations.
+    /// 3. Calls `execute` which returns an [`ExecutionStep`].
+    ///
+    /// Note: the returned array may not match `M`. If execution converges to a canonical form
+    /// that does not match `M`, the canonical array is returned since no further execution
+    /// progress is possible.
+    ///
+    /// For safety, we will error when the number of execution iterations reaches a configurable
+    /// maximum (default 128, override with `VORTEX_MAX_ITERATIONS`).
+    pub fn execute_until<M: Matcher>(self, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+        static MAX_ITERATIONS: LazyLock<usize> =
+            LazyLock::new(|| match std::env::var("VORTEX_MAX_ITERATIONS") {
+                Ok(val) => val.parse::<usize>().unwrap_or_else(|e| {
+                    vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid usize: {e}")
+                }),
+                Err(VarError::NotPresent) => 128,
+                Err(VarError::NotUnicode(_)) => {
+                    vortex_panic!("VORTEX_MAX_ITERATIONS is not a valid unicode string")
+                }
+            });
+
+        let mut current = self.optimize()?;
+        // Stack frames: (parent, slot_idx, done_predicate_for_slot)
+        let mut stack: Vec<(ArrayRef, usize, DonePredicate)> = Vec::new();
+
+        for _ in 0..*MAX_ITERATIONS {
+            // Check for termination: use the stack frame's done predicate, or the root matcher.
+            let is_done = stack
+                .last()
+                .map_or(M::matches as DonePredicate, |frame| frame.2);
+            if is_done(&current) {
+                match stack.pop() {
+                    None => {
+                        ctx.log(format_args!("-> {}", current));
+                        return Ok(current);
+                    }
+                    Some((parent, slot_idx, _)) => {
+                        current = parent.with_slot(slot_idx, current)?;
+                        current = current.optimize()?;
+                        continue;
+                    }
+                }
+            }
+
+            // If we've reached canonical form, we can't execute any further regardless
+            // of whether the matcher matched.
+            if AnyCanonical::matches(&current) {
+                match stack.pop() {
+                    None => {
+                        ctx.log(format_args!("-> canonical (unmatched) {}", current));
+                        return Ok(current);
+                    }
+                    Some((parent, slot_idx, _)) => {
+                        current = parent.with_slot(slot_idx, current)?;
+                        current = current.optimize()?;
+                        continue;
+                    }
+                }
+            }
+
+            // Try execute_parent (child-driven optimized execution)
+            if let Some(rewritten) = try_execute_parent(&current, ctx)? {
+                ctx.log(format_args!(
+                    "execute_parent rewrote {} -> {}",
+                    current, rewritten
+                ));
+                current = rewritten.optimize()?;
+                continue;
+            }
+
+            // Execute the array itself.
+            let result = execute_step(current, ctx)?;
+            let (array, step) = result.into_parts();
+            match step {
+                ExecutionStep::ExecuteSlot(i, done) => {
+                    let child = array.slots()[i]
+                        .clone()
+                        .vortex_expect("ExecuteSlot index in bounds");
+                    ctx.log(format_args!(
+                        "ExecuteSlot({i}): pushing {}, focusing on {}",
+                        array, child
+                    ));
+                    stack.push((array, i, done));
+                    current = child.optimize()?;
+                }
+                ExecutionStep::Done => {
+                    ctx.log(format_args!("Done: {}", array));
+                    current = array;
+                }
+            }
+        }
+
+        vortex_bail!(
+            "Exceeded maximum execution iterations ({}) while executing array",
+            *MAX_ITERATIONS,
+        )
+    }
 }
 
 /// Execution context for batch CPU compute.
 ///
 /// Accumulates a trace of execution steps. Individual steps are logged at TRACE level for
 /// real-time following, and the full trace is dumped at DEBUG level when the context is dropped.
+#[derive(Debug, Clone)]
 pub struct ExecutionCtx {
     id: usize,
     session: VortexSession,
@@ -72,6 +212,11 @@ impl ExecutionCtx {
         &self.session
     }
 
+    /// Get the session-scoped host allocator for this execution context.
+    pub fn allocator(&self) -> HostAllocatorRef {
+        self.session.allocator()
+    }
+
     /// Log an execution step at the current depth.
     ///
     /// Steps are accumulated and dumped as a single trace on Drop at DEBUG level.
@@ -122,10 +267,10 @@ impl Drop for ExecutionCtx {
 ///
 /// The execution steps are as follows:
 /// 0. Check for canonical.
-/// 1. Attempt to call `reduce_parent` on each child.
-/// 2. Attempt to `reduce` the array with metadata-only optimizations.
+/// 1. Attempt to `reduce` the array with metadata-only optimizations.
+/// 2. Attempt to call `reduce_parent` on each child.
 /// 3. Attempt to call `execute_parent` on each child.
-/// 4. Call `execute` on the array itself.
+/// 4. Call `execute` on the array itself (which returns an [`ExecutionStep`]).
 ///
 /// Most users will not call this method directly, instead preferring to specify an executable
 /// target such as [`crate::Columnar`], [`Canonical`], or any of the canonical array types (such as
@@ -139,19 +284,21 @@ impl Executable for ArrayRef {
         }
 
         // 1. reduce (metadata-only rewrites)
-        if let Some(reduced) = array.vtable().reduce(&array)? {
+        if let Some(reduced) = array.reduce()? {
             ctx.log(format_args!("reduce: rewrote {} -> {}", array, reduced));
             reduced.statistics().inherit_from(array.statistics());
             return Ok(reduced);
         }
 
         // 2. reduce_parent (child-driven metadata-only rewrites)
-        for child_idx in 0..array.nchildren() {
-            let child = array.nth_child(child_idx).vortex_expect("checked length");
-            if let Some(reduced_parent) = child.vtable().reduce_parent(&child, &array, child_idx)? {
+        for (slot_idx, slot) in array.slots().iter().enumerate() {
+            let Some(child) = slot else {
+                continue;
+            };
+            if let Some(reduced_parent) = child.reduce_parent(&array, slot_idx)? {
                 ctx.log(format_args!(
-                    "reduce_parent: child[{}]({}) rewrote {} -> {}",
-                    child_idx,
+                    "reduce_parent: slot[{}]({}) rewrote {} -> {}",
+                    slot_idx,
                     child.encoding_id(),
                     array,
                     reduced_parent
@@ -162,15 +309,14 @@ impl Executable for ArrayRef {
         }
 
         // 3. execute_parent (child-driven optimized execution)
-        for child_idx in 0..array.nchildren() {
-            let child = array.nth_child(child_idx).vortex_expect("checked length");
-            if let Some(executed_parent) = child
-                .vtable()
-                .execute_parent(&child, &array, child_idx, ctx)?
-            {
+        for (slot_idx, slot) in array.slots().iter().enumerate() {
+            let Some(child) = slot else {
+                continue;
+            };
+            if let Some(executed_parent) = child.execute_parent(&array, slot_idx, ctx)? {
                 ctx.log(format_args!(
-                    "execute_parent: child[{}]({}) rewrote {} -> {}",
-                    child_idx,
+                    "execute_parent: slot[{}]({}) rewrote {} -> {}",
+                    slot_idx,
                     child.encoding_id(),
                     array,
                     executed_parent
@@ -182,17 +328,220 @@ impl Executable for ArrayRef {
             }
         }
 
-        // 4. execute (optimized execution)
+        // 4. execute (returns an ExecutionResult)
         ctx.log(format_args!("executing {}", array));
-        let array = array
-            .vtable()
-            .execute(&array, ctx)
-            .map(|c| c.into_array())?;
-        array.statistics().inherit_from(array.statistics());
-        ctx.log(format_args!("-> {}", array.as_ref()));
+        let result = execute_step(array, ctx)?;
+        let (array, step) = result.into_parts();
+        match step {
+            ExecutionStep::Done => {
+                ctx.log(format_args!("-> {}", array));
+                Ok(array)
+            }
+            ExecutionStep::ExecuteSlot(i, _) => {
+                // For single-step execution, handle ExecuteSlot by executing the slot,
+                // replacing it, and returning the updated array.
+                let child = array.slots()[i].clone().vortex_expect("valid slot index");
+                let executed_child = child.execute::<ArrayRef>(ctx)?;
+                array.with_slot(i, executed_child)
+            }
+        }
+    }
+}
+
+/// Execute a single step on an array, consuming it.
+///
+/// Extracts the vtable before consuming the array to avoid borrow conflicts.
+fn execute_step(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+    array.execute_encoding(ctx)
+}
 
-        Ok(array)
+/// Try execute_parent on each occupied slot of the array.
+fn try_execute_parent(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Option<ArrayRef>> {
+    for (slot_idx, slot) in array.slots().iter().enumerate() {
+        let Some(child) = slot else {
+            continue;
+        };
+        if let Some(result) = child.execute_parent(array, slot_idx, ctx)? {
+            result.statistics().inherit_from(array.statistics());
+            return Ok(Some(result));
+        }
     }
+    Ok(None)
+}
+
+/// A predicate that determines when an array has reached a desired form during execution.
+pub type DonePredicate = fn(&ArrayRef) -> bool;
+
+/// Metadata-only step indicator returned alongside an array in [`ExecutionResult`].
+///
+/// Instead of recursively executing children, encodings return an `ExecutionStep` that tells the
+/// scheduler what to do next. This enables the scheduler to manage execution iteratively using
+/// an explicit work stack, run cross-step optimizations, and cache shared sub-expressions.
+pub enum ExecutionStep {
+    /// Request that the scheduler execute the slot at the given index, using the provided
+    /// [`DonePredicate`] to determine when the slot is "done", then replace the slot in this
+    /// array and re-enter execution.
+    ///
+    /// Between steps, the scheduler runs reduce/reduce_parent rules to fixpoint, enabling
+    /// cross-step optimization (e.g., pushing scalar functions through newly-decoded children).
+    ///
+    /// Use [`ExecutionResult::execute_slot`] instead of constructing this variant directly.
+    ExecuteSlot(usize, DonePredicate),
+
+    /// Execution is complete. The array in the accompanying [`ExecutionResult`] is the result.
+    /// The scheduler will continue executing if it has not yet reached the target form.
+    Done,
+}
+
+impl fmt::Debug for ExecutionStep {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExecutionStep::ExecuteSlot(idx, _) => f.debug_tuple("ExecuteSlot").field(idx).finish(),
+            ExecutionStep::Done => write!(f, "Done"),
+        }
+    }
+}
+
+/// The result of a single execution step on an array encoding.
+///
+/// Combines an [`ArrayRef`] with an [`ExecutionStep`] to tell the scheduler both what to do next
+/// and what array to work with.
+pub struct ExecutionResult {
+    array: ArrayRef,
+    step: ExecutionStep,
+}
+
+impl ExecutionResult {
+    /// Signal that execution is complete with the given result array.
+    pub fn done(result: impl IntoArray) -> Self {
+        Self {
+            array: result.into_array(),
+            step: ExecutionStep::Done,
+        }
+    }
+
+    /// Request execution of slot at `slot_idx` until it matches the given [`Matcher`].
+    ///
+    /// The provided array is the (possibly modified) parent that still needs its slot executed.
+    pub fn execute_slot<M: Matcher>(array: impl IntoArray, slot_idx: usize) -> Self {
+        Self {
+            array: array.into_array(),
+            step: ExecutionStep::ExecuteSlot(slot_idx, M::matches),
+        }
+    }
+
+    /// Returns a reference to the array.
+    pub fn array(&self) -> &ArrayRef {
+        &self.array
+    }
+
+    /// Returns a reference to the step.
+    pub fn step(&self) -> &ExecutionStep {
+        &self.step
+    }
+
+    /// Decompose into parts.
+    pub fn into_parts(self) -> (ArrayRef, ExecutionStep) {
+        (self.array, self.step)
+    }
+}
+
+impl fmt::Debug for ExecutionResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ExecutionResult")
+            .field("array", &self.array)
+            .field("step", &self.step)
+            .finish()
+    }
+}
+
+/// Require that a child array matches `$M`. If the child already matches, returns the same
+/// array unchanged. Otherwise, early-returns an [`ExecutionResult`] requesting execution of
+/// child `$idx` until it matches `$M`.
+///
+/// ```ignore
+/// let array = require_child!(array, array.codes(), 0 => Primitive);
+/// let array = require_child!(array, array.values(), 1 => AnyCanonical);
+/// ```
+#[macro_export]
+macro_rules! require_child {
+    ($parent:expr, $child:expr, $idx:expr => $M:ty) => {{
+        if !$child.is::<$M>() {
+            return Ok($crate::ExecutionResult::execute_slot::<$M>(
+                $parent.clone(),
+                $idx,
+            ));
+        }
+        $parent
+    }};
+}
+
+/// Like [`require_child!`], but for optional children. If the child is `None`, this is a no-op.
+/// If the child is `Some` but does not match `$M`, early-returns an [`ExecutionResult`] requesting
+/// execution of child `$idx`.
+///
+/// Unlike `require_child!`, this is a statement macro (no value produced) and does not clone
+/// `$parent` — it is moved into the early-return path.
+///
+/// ```ignore
+/// require_opt_child!(array, array.patches().map(|p| p.indices()), 1 => Primitive);
+/// ```
+#[macro_export]
+macro_rules! require_opt_child {
+    ($parent:expr, $child_opt:expr, $idx:expr => $M:ty) => {
+        if $child_opt.is_some_and(|child| !child.is::<$M>()) {
+            return Ok($crate::ExecutionResult::execute_slot::<$M>($parent, $idx));
+        }
+    };
+}
+
+/// Require that patch slots (indices, values, and optionally chunk_offsets) are `Primitive`.
+/// If no patches are present (slots are `None`), this is a no-op.
+///
+/// Like [`require_opt_child!`], `$parent` is moved (not cloned) into the early-return path.
+///
+/// ```ignore
+/// require_patches!(array, PATCH_INDICES_SLOT, PATCH_VALUES_SLOT, PATCH_CHUNK_OFFSETS_SLOT);
+/// ```
+#[macro_export]
+macro_rules! require_patches {
+    ($parent:expr, $indices_slot:expr, $values_slot:expr, $chunk_offsets_slot:expr) => {
+        $crate::require_opt_child!(
+            $parent,
+            $parent.slots()[$indices_slot].as_ref(),
+            $indices_slot => $crate::arrays::Primitive
+        );
+        $crate::require_opt_child!(
+            $parent,
+            $parent.slots()[$values_slot].as_ref(),
+            $values_slot => $crate::arrays::Primitive
+        );
+        $crate::require_opt_child!(
+            $parent,
+            $parent.slots()[$chunk_offsets_slot].as_ref(),
+            $chunk_offsets_slot => $crate::arrays::Primitive
+        );
+    };
+}
+
+/// Require that the validity slot is a [`Bool`](crate::arrays::Bool) array. If validity is not
+/// array-backed (e.g. `NonNullable` or `AllValid`), this is a no-op. If it is array-backed but
+/// not `Bool`, early-returns an [`ExecutionResult`] requesting execution of the validity slot.
+///
+/// Like [`require_opt_child!`], `$parent` is moved (not cloned) into the early-return path.
+///
+/// ```ignore
+/// require_validity!(array, VALIDITY_SLOT);
+/// ```
+#[macro_export]
+macro_rules! require_validity {
+    ($parent:expr, $idx:expr) => {
+        $crate::require_opt_child!(
+            $parent,
+            $parent.slots()[$idx].as_ref(),
+            $idx => $crate::arrays::Bool
+        );
+    };
 }
 
 /// Extension trait for creating an execution context from a session.
diff --git a/vortex-array/src/expr/exprs.rs b/vortex-array/src/expr/exprs.rs
index 94e5f54e4d0..cbf34cdb3c2 100644
--- a/vortex-array/src/expr/exprs.rs
+++ b/vortex-array/src/expr/exprs.rs
@@ -6,6 +6,8 @@
 use std::sync::Arc;
 
 use vortex_error::VortexExpect;
+use vortex_error::vortex_panic;
+use vortex_utils::iter::ReduceBalancedIterExt;
 
 use crate::dtype::DType;
 use crate::dtype::FieldName;
@@ -19,6 +21,8 @@ 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::case_when::CaseWhen;
+use crate::scalar_fn::fns::case_when::CaseWhenOptions;
 use crate::scalar_fn::fns::cast::Cast;
 use crate::scalar_fn::fns::dynamic::DynamicComparison;
 use crate::scalar_fn::fns::dynamic::DynamicComparisonExpr;
@@ -108,6 +112,60 @@ pub fn get_item(field: impl Into<FieldName>, child: Expression) -> Expression {
     GetItem.new_expr(field.into(), vec![child])
 }
 
+// ---- CaseWhen ----
+
+/// Creates a CASE WHEN expression with one WHEN/THEN pair and an ELSE value.
+pub fn case_when(
+    condition: Expression,
+    then_value: Expression,
+    else_value: Expression,
+) -> Expression {
+    let options = CaseWhenOptions {
+        num_when_then_pairs: 1,
+        has_else: true,
+    };
+    CaseWhen.new_expr(options, [condition, then_value, else_value])
+}
+
+/// Creates a CASE WHEN expression with one WHEN/THEN pair and no ELSE value.
+pub fn case_when_no_else(condition: Expression, then_value: Expression) -> Expression {
+    let options = CaseWhenOptions {
+        num_when_then_pairs: 1,
+        has_else: false,
+    };
+    CaseWhen.new_expr(options, [condition, then_value])
+}
+
+/// Creates an n-ary CASE WHEN expression from WHEN/THEN pairs and an optional ELSE value.
+pub fn nested_case_when(
+    when_then_pairs: Vec<(Expression, Expression)>,
+    else_value: Option<Expression>,
+) -> Expression {
+    assert!(
+        !when_then_pairs.is_empty(),
+        "nested_case_when requires at least one when/then pair"
+    );
+
+    let has_else = else_value.is_some();
+    let mut children = Vec::with_capacity(when_then_pairs.len() * 2 + usize::from(has_else));
+    for (condition, then_value) in &when_then_pairs {
+        children.push(condition.clone());
+        children.push(then_value.clone());
+    }
+    if let Some(else_expr) = else_value {
+        children.push(else_expr);
+    }
+
+    let Ok(num_when_then_pairs) = u32::try_from(when_then_pairs.len()) else {
+        vortex_panic!("nested_case_when has too many when/then pairs");
+    };
+    let options = CaseWhenOptions {
+        num_when_then_pairs,
+        has_else,
+    };
+    CaseWhen.new_expr(options, children)
+}
+
 // ---- Binary operators ----
 
 /// Create a new [`Binary`] using the [`Eq`](Operator::Eq) operator.
@@ -116,12 +174,13 @@ pub fn get_item(field: impl Into<FieldName>, child: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray};
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{eq, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&eq(root(), lit(3))).unwrap();
+/// let result = xs.into_array().apply(&eq(root(), lit(3))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -140,12 +199,13 @@ pub fn eq(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray};
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{ IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{root, lit, not_eq};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&not_eq(root(), lit(3))).unwrap();
+/// let result = xs.into_array().apply(&not_eq(root(), lit(3))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -164,12 +224,13 @@ pub fn not_eq(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{gt_eq, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&gt_eq(root(), lit(3))).unwrap();
+/// let result = xs.into_array().apply(&gt_eq(root(), lit(3))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -188,12 +249,13 @@ pub fn gt_eq(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{gt, root, lit};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&gt(root(), lit(2))).unwrap();
+/// let result = xs.into_array().apply(&gt(root(), lit(2))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -212,12 +274,13 @@ pub fn gt(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{root, lit, lt_eq};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&lt_eq(root(), lit(2))).unwrap();
+/// let result = xs.into_array().apply(&lt_eq(root(), lit(2))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -236,12 +299,13 @@ pub fn lt_eq(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::{BoolArray, PrimitiveArray };
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::validity::Validity;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{root, lit, lt};
 /// let xs = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-/// let result = xs.to_array().apply(&lt(root(), lit(3))).unwrap();
+/// let result = xs.into_array().apply(&lt(root(), lit(3))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -260,10 +324,11 @@ pub fn lt(lhs: Expression, rhs: Expression) -> Expression {
 ///
 /// ```
 /// # use vortex_array::arrays::BoolArray;
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::expr::{root, lit, or};
 /// let xs = BoolArray::from_iter(vec![true, false, true]);
-/// let result = xs.to_array().apply(&or(root(), lit(false))).unwrap();
+/// let result = xs.into_array().apply(&or(root(), lit(false))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -286,8 +351,7 @@ pub fn or_collect<I>(iter: I) -> Option<Expression>
 where
     I: IntoIterator<Item = Expression>,
 {
-    let exprs: Vec<_> = iter.into_iter().collect();
-    balanced_reduce(exprs, or)
+    iter.into_iter().reduce_balanced(or)
 }
 
 /// Create a new [`Binary`] using the [`And`](Operator::And) operator.
@@ -296,10 +360,11 @@ where
 ///
 /// ```
 /// # use vortex_array::arrays::BoolArray;
-/// # use vortex_array::{Array, IntoArray, ToCanonical};
+/// # use vortex_array::arrays::bool::BoolArrayExt;
+/// # use vortex_array::{IntoArray, ToCanonical};
 /// # use vortex_array::expr::{and, root, lit};
-/// let xs = BoolArray::from_iter(vec![true, false, true]);
-/// let result = xs.to_array().apply(&and(root(), lit(true))).unwrap();
+/// let xs = BoolArray::from_iter(vec![true, false, true]).into_array();
+/// let result = xs.apply(&and(root(), lit(true))).unwrap();
 ///
 /// assert_eq!(
 ///     result.to_bool().to_bit_buffer(),
@@ -322,42 +387,7 @@ pub fn and_collect<I>(iter: I) -> Option<Expression>
 where
     I: IntoIterator<Item = Expression>,
 {
-    let exprs: Vec<_> = iter.into_iter().collect();
-    balanced_reduce(exprs, and)
-}
-
-/// Helper function to reduce a list of expressions into a balanced binary tree.
-fn balanced_reduce<F>(mut exprs: Vec<Expression>, combine: F) -> Option<Expression>
-where
-    F: Fn(Expression, Expression) -> Expression + Copy,
-{
-    if exprs.is_empty() {
-        return None;
-    }
-    if exprs.len() == 1 {
-        return exprs.pop();
-    }
-
-    while exprs.len() > 1 {
-        let exprs_len = exprs.len();
-
-        for target_idx in 0..(exprs.len() / 2) {
-            let item_idx = target_idx * 2;
-            let new = combine(exprs[item_idx].clone(), exprs[item_idx + 1].clone());
-            exprs[target_idx] = new;
-        }
-
-        if !exprs.len().is_multiple_of(2) {
-            // We want the odd nodes to be inside the tree and not at root
-            let lhs = exprs[(exprs.len() / 2) - 1].clone();
-            let rhs = exprs[exprs.len() - 1].clone();
-            exprs[exprs_len / 2 - 1] = combine(lhs, rhs);
-        }
-
-        exprs.truncate(exprs_len / 2);
-    }
-
-    exprs.pop()
+    iter.into_iter().reduce_balanced(and)
 }
 
 /// Create a new [`Binary`] using the [`Add`](Operator::Add) operator.
@@ -365,7 +395,7 @@ where
 /// ## Example usage
 ///
 /// ```
-/// # use vortex_array::{Array, IntoArray};
+/// # use vortex_array::IntoArray;
 /// # use vortex_array::arrow::IntoArrowArray as _;
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{checked_add, lit, root};
@@ -612,9 +642,9 @@ pub fn merge_opts(
 ///
 /// ```rust
 /// # use vortex_array::expr::{zip_expr, root, lit};
-/// let expr = zip_expr(root(), lit(0i32), lit(true));
+/// let expr = zip_expr(lit(true), root(), lit(0i32));
 /// ```
-pub fn zip_expr(if_true: Expression, if_false: Expression, mask: Expression) -> Expression {
+pub fn zip_expr(mask: Expression, if_true: Expression, if_false: Expression) -> Expression {
     Zip.new_expr(EmptyOptions, [if_true, if_false, mask])
 }
 
diff --git a/vortex-array/src/expr/proto.rs b/vortex-array/src/expr/proto.rs
index 16b063ac831..22c5aa8b467 100644
--- a/vortex-array/src/expr/proto.rs
+++ b/vortex-array/src/expr/proto.rs
@@ -10,6 +10,7 @@ use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
 use crate::expr::Expression;
+use crate::scalar_fn::ForeignScalarFnVTable;
 use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::session::ScalarFnSessionExt;
 
@@ -41,19 +42,21 @@ impl ExprSerializeProtoExt for Expression {
 impl Expression {
     pub fn from_proto(expr: &pb::Expr, session: &VortexSession) -> VortexResult<Expression> {
         let expr_id = ScalarFnId::new_arc(Arc::from(expr.id.to_string()));
-        let vtable = session
-            .scalar_fns()
-            .registry()
-            .find(&expr_id)
-            .ok_or_else(|| vortex_err!("unknown expression id: {}", expr_id))?;
-
         let children = expr
             .children
             .iter()
             .map(|e| Expression::from_proto(e, session))
             .collect::<VortexResult<Vec<_>>>()?;
 
-        Expression::try_new(vtable.deserialize(expr.metadata(), session)?, children)
+        let scalar_fn = if let Some(vtable) = session.scalar_fns().registry().find(&expr_id) {
+            vtable.deserialize(expr.metadata(), session)?
+        } else if session.allows_unknown() {
+            ForeignScalarFnVTable::make_scalar_fn(expr_id, expr.metadata().to_vec(), children.len())
+        } else {
+            return Err(vortex_err!("unknown expression id: {}", expr_id));
+        };
+
+        Expression::try_new(scalar_fn, children)
     }
 }
 
@@ -70,6 +73,7 @@ pub fn deserialize_expr_proto(
 mod tests {
     use prost::Message;
     use vortex_proto::expr as pb;
+    use vortex_session::VortexSession;
 
     use super::ExprSerializeProtoExt;
     use crate::LEGACY_SESSION;
@@ -83,6 +87,7 @@ mod tests {
     use crate::expr::root;
     use crate::scalar_fn::fns::between::BetweenOptions;
     use crate::scalar_fn::fns::between::StrictComparison;
+    use crate::scalar_fn::session::ScalarFnSession;
 
     #[test]
     fn expression_serde() {
@@ -109,4 +114,25 @@ mod tests {
 
         assert_eq!(&deser_expr, &expr);
     }
+
+    #[test]
+    fn unknown_expression_id_allow_unknown() {
+        let session = VortexSession::empty()
+            .with::<ScalarFnSession>()
+            .allow_unknown();
+
+        let expr_proto = pb::Expr {
+            id: "vortex.test.foreign_scalar_fn".to_string(),
+            metadata: Some(vec![1, 2, 3, 4]),
+            children: vec![root().serialize_proto().unwrap()],
+        };
+
+        let expr = Expression::from_proto(&expr_proto, &session).unwrap();
+        assert_eq!(expr.id().as_ref(), "vortex.test.foreign_scalar_fn");
+
+        let roundtrip = expr.serialize_proto().unwrap();
+        assert_eq!(roundtrip.id, expr_proto.id);
+        assert_eq!(roundtrip.metadata(), expr_proto.metadata());
+        assert_eq!(roundtrip.children.len(), 1);
+    }
 }
diff --git a/vortex-array/src/expr/stats/mod.rs b/vortex-array/src/expr/stats/mod.rs
index 842d049537c..5f998041dea 100644
--- a/vortex-array/src/expr/stats/mod.rs
+++ b/vortex-array/src/expr/stats/mod.rs
@@ -11,10 +11,7 @@ use num_enum::IntoPrimitive;
 use num_enum::TryFromPrimitive;
 
 use crate::dtype::DType;
-use crate::dtype::DecimalDType;
-use crate::dtype::MAX_PRECISION;
 use crate::dtype::Nullability::NonNullable;
-use crate::dtype::Nullability::Nullable;
 use crate::dtype::PType;
 
 mod bound;
@@ -27,6 +24,10 @@ pub use precision::*;
 pub use provider::*;
 pub use stat_bound::*;
 
+use crate::aggregate_fn;
+use crate::aggregate_fn::AggregateFnVTable;
+use crate::aggregate_fn::EmptyOptions;
+
 #[derive(
     Debug,
     Clone,
@@ -174,47 +175,11 @@ impl Stat {
             Self::NullCount => DType::Primitive(PType::U64, NonNullable),
             Self::UncompressedSizeInBytes => DType::Primitive(PType::U64, NonNullable),
             Self::NaNCount => {
-                // Only floating points support NaN counts.
-                if let DType::Primitive(ptype, ..) = data_type
-                    && ptype.is_float()
-                {
-                    DType::Primitive(PType::U64, NonNullable)
-                } else {
-                    return None;
-                }
+                return aggregate_fn::fns::nan_count::NanCount
+                    .return_dtype(&EmptyOptions, data_type);
             }
             Self::Sum => {
-                // Any array that cannot be summed has a sum DType of null.
-                // Any array that can be summed, but overflows, has a sum _value_ of null.
-                // Therefore, we make integer sum stats nullable.
-                match data_type {
-                    DType::Bool(_) => DType::Primitive(PType::U64, Nullable),
-                    DType::Primitive(ptype, _) => match ptype {
-                        PType::U8 | PType::U16 | PType::U32 | PType::U64 => {
-                            DType::Primitive(PType::U64, Nullable)
-                        }
-                        PType::I8 | PType::I16 | PType::I32 | PType::I64 => {
-                            DType::Primitive(PType::I64, Nullable)
-                        }
-                        PType::F16 | PType::F32 | PType::F64 => {
-                            // Float sums cannot overflow, but all null floats still end up as null
-                            DType::Primitive(PType::F64, Nullable)
-                        }
-                    },
-                    DType::Extension(ext_dtype) => self.dtype(ext_dtype.storage_dtype())?,
-                    DType::Decimal(decimal_dtype, _) => {
-                        // Both Spark and DataFusion use this heuristic.
-                        // - https://github.com/apache/spark/blob/fcf636d9eb8d645c24be3db2d599aba2d7e2955a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Sum.scala#L66
-                        // - https://github.com/apache/datafusion/blob/4153adf2c0f6e317ef476febfdc834208bd46622/datafusion/functions-aggregate/src/sum.rs#L188
-                        let precision = u8::min(MAX_PRECISION, decimal_dtype.precision() + 10);
-                        DType::Decimal(
-                            DecimalDType::new(precision, decimal_dtype.scale()),
-                            Nullable,
-                        )
-                    }
-                    // Unsupported types
-                    _ => return None,
-                }
+                return aggregate_fn::fns::sum::Sum.return_dtype(&EmptyOptions, data_type);
             }
         })
     }
diff --git a/vortex-array/src/expr/transform/coerce.rs b/vortex-array/src/expr/transform/coerce.rs
new file mode 100644
index 00000000000..1b6e9acd661
--- /dev/null
+++ b/vortex-array/src/expr/transform/coerce.rs
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Expression-level type coercion pass.
+
+use vortex_error::VortexResult;
+
+use crate::dtype::DType;
+use crate::expr::Expression;
+use crate::expr::cast;
+use crate::expr::traversal::NodeExt;
+use crate::expr::traversal::Transformed;
+use crate::scalar_fn::fns::literal::Literal;
+use crate::scalar_fn::fns::root::Root;
+
+/// Rewrite an expression tree to insert casts where a scalar function's `coerce_args` demands
+/// a different type than what the child currently produces.
+///
+/// The rewrite is bottom-up: children are coerced first, then each parent node checks whether
+/// its children match the coerced argument types.
+pub fn coerce_expression(expr: Expression, scope: &DType) -> VortexResult<Expression> {
+    // We capture scope by reference for the closure.
+    let scope = scope.clone();
+    expr.transform_up(|node| {
+        // Leaf nodes (Root, Literal) have no children to coerce.
+        if node.is::<Root>() || node.is::<Literal>() || node.children().is_empty() {
+            return Ok(Transformed::no(node));
+        }
+
+        // Compute the current child return types.
+        let child_dtypes: Vec<DType> = node
+            .children()
+            .iter()
+            .map(|c| c.return_dtype(&scope))
+            .collect::<VortexResult<_>>()?;
+
+        // Ask the scalar function what types it wants.
+        let coerced_dtypes = node.scalar_fn().coerce_args(&child_dtypes)?;
+
+        // If nothing changed, skip.
+        if child_dtypes == coerced_dtypes {
+            return Ok(Transformed::no(node));
+        }
+
+        // Build new children, inserting casts where needed.
+        let new_children: Vec<Expression> = node
+            .children()
+            .iter()
+            .zip(coerced_dtypes.iter())
+            .map(|(child, target)| {
+                let child_dtype = child.return_dtype(&scope)?;
+                if child_dtype.eq_ignore_nullability(target)
+                    && child_dtype.nullability() == target.nullability()
+                {
+                    Ok(child.clone())
+                } else {
+                    Ok(cast(child.clone(), target.clone()))
+                }
+            })
+            .collect::<VortexResult<_>>()?;
+
+        let new_expr = node.with_children(new_children)?;
+        Ok(Transformed::yes(new_expr))
+    })
+    .map(|t| t.into_inner())
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::NonNullable;
+    use crate::dtype::PType;
+    use crate::dtype::StructFields;
+    use crate::expr::col;
+    use crate::expr::lit;
+    use crate::expr::transform::coerce::coerce_expression;
+    use crate::scalar::Scalar;
+    use crate::scalar_fn::ScalarFnVTableExt;
+    use crate::scalar_fn::fns::binary::Binary;
+    use crate::scalar_fn::fns::cast::Cast;
+    use crate::scalar_fn::fns::operators::Operator;
+
+    fn test_scope() -> DType {
+        DType::Struct(
+            StructFields::new(
+                ["x", "y"].into(),
+                vec![
+                    DType::Primitive(PType::I32, NonNullable),
+                    DType::Primitive(PType::I64, NonNullable),
+                ],
+            ),
+            NonNullable,
+        )
+    }
+
+    #[test]
+    fn mixed_type_comparison_inserts_cast() -> VortexResult<()> {
+        let scope = test_scope();
+        // x (I32) < y (I64) => should cast x to I64
+        let expr = Binary.new_expr(Operator::Lt, [col("x"), col("y")]);
+        let coerced = coerce_expression(expr, &scope)?;
+
+        // The LHS child should now be a cast expression
+        assert!(coerced.child(0).is::<Cast>());
+        // The coerced LHS should return I64
+        assert_eq!(
+            coerced.child(0).return_dtype(&scope)?,
+            DType::Primitive(PType::I64, NonNullable)
+        );
+        // The RHS should be unchanged
+        assert!(!coerced.child(1).is::<Cast>());
+        Ok(())
+    }
+
+    #[test]
+    fn same_type_comparison_no_cast() -> VortexResult<()> {
+        let scope = test_scope();
+        // x (I32) < x (I32) => no cast needed
+        let expr = Binary.new_expr(Operator::Lt, [col("x"), col("x")]);
+        let coerced = coerce_expression(expr, &scope)?;
+
+        // Neither child should be a cast
+        assert!(!coerced.child(0).is::<Cast>());
+        assert!(!coerced.child(1).is::<Cast>());
+        Ok(())
+    }
+
+    #[test]
+    fn mixed_type_arithmetic_coerces_both() -> VortexResult<()> {
+        let scope = DType::Struct(
+            StructFields::new(
+                ["a", "b"].into(),
+                vec![
+                    DType::Primitive(PType::U8, NonNullable),
+                    DType::Primitive(PType::I32, NonNullable),
+                ],
+            ),
+            NonNullable,
+        );
+        // a (U8) + b (I32) => both should be coerced to I32
+        // U8 + I32: unsigned_signed_supertype(U8, I32) => max(1,4)=4 => I64
+        let expr = Binary.new_expr(Operator::Add, [col("a"), col("b")]);
+        let coerced = coerce_expression(expr, &scope)?;
+
+        // LHS (U8) should be cast
+        assert!(coerced.child(0).is::<Cast>());
+        // Both should return the same supertype
+        let lhs_dt = coerced.child(0).return_dtype(&scope)?;
+        let rhs_dt = coerced.child(1).return_dtype(&scope)?;
+        assert_eq!(lhs_dt, rhs_dt);
+        Ok(())
+    }
+
+    #[test]
+    fn boolean_operators_no_coercion() -> VortexResult<()> {
+        let scope = DType::Struct(
+            StructFields::new(
+                ["p", "q"].into(),
+                vec![DType::Bool(NonNullable), DType::Bool(NonNullable)],
+            ),
+            NonNullable,
+        );
+        let expr = Binary.new_expr(Operator::And, [col("p"), col("q")]);
+        let coerced = coerce_expression(expr, &scope)?;
+
+        assert!(!coerced.child(0).is::<Cast>());
+        assert!(!coerced.child(1).is::<Cast>());
+        Ok(())
+    }
+
+    #[test]
+    fn literal_coercion() -> VortexResult<()> {
+        let scope = DType::Struct(
+            StructFields::new(
+                ["x"].into(),
+                vec![DType::Primitive(PType::I64, NonNullable)],
+            ),
+            NonNullable,
+        );
+        // x (I64) + 1i32 => literal should be cast to I64
+        let expr = Binary.new_expr(Operator::Add, [col("x"), lit(Scalar::from(1i32))]);
+        let coerced = coerce_expression(expr, &scope)?;
+
+        // The RHS (literal) should be cast to I64
+        assert!(coerced.child(1).is::<Cast>());
+        assert_eq!(
+            coerced.child(1).return_dtype(&scope)?,
+            DType::Primitive(PType::I64, NonNullable)
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/expr/transform/mod.rs b/vortex-array/src/expr/transform/mod.rs
index b1081ad5ca3..6013241d971 100644
--- a/vortex-array/src/expr/transform/mod.rs
+++ b/vortex-array/src/expr/transform/mod.rs
@@ -2,9 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 //! A collection of transformations that can be applied to a [`crate::expr::Expression`].
+mod coerce;
 pub(crate) mod match_between;
 mod partition;
 mod replace;
 
+pub use coerce::*;
 pub use partition::*;
 pub use replace::*;
diff --git a/vortex-array/src/expression.rs b/vortex-array/src/expression.rs
index 93e15b5d9e2..780bfcf9db1 100644
--- a/vortex-array/src/expression.rs
+++ b/vortex-array/src/expression.rs
@@ -4,7 +4,6 @@
 use itertools::Itertools;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
@@ -14,12 +13,12 @@ use crate::optimizer::ArrayOptimizer;
 use crate::scalar_fn::fns::literal::Literal;
 use crate::scalar_fn::fns::root::Root;
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Apply the expression to this array, producing a new array in constant time.
-    pub fn apply(&self, expr: &Expression) -> VortexResult<ArrayRef> {
+    pub fn apply(self, expr: &Expression) -> VortexResult<ArrayRef> {
         // If the expression is a root, return self.
         if expr.is::<Root>() {
-            return Ok(self.to_array());
+            return Ok(self);
         }
 
         // Manually convert literals to ConstantArray.
@@ -31,7 +30,7 @@ impl dyn Array + '_ {
         let children: Vec<_> = expr
             .children()
             .iter()
-            .map(|e| self.apply(e))
+            .map(|e| self.clone().apply(e))
             .try_collect()?;
 
         // And wrap the scalar function up in an array.
diff --git a/vortex-array/src/extension/datetime/date.rs b/vortex-array/src/extension/datetime/date.rs
index c31a2b2f058..a0434b3ebc5 100644
--- a/vortex-array/src/extension/datetime/date.rs
+++ b/vortex-array/src/extension/datetime/date.rs
@@ -91,12 +91,13 @@ impl ExtVTable for Date {
         TimeUnit::try_from(tag)
     }
 
-    fn validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &DType) -> VortexResult<()> {
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        let metadata = ext_dtype.metadata();
         let ptype = date_ptype(metadata)
             .ok_or_else(|| vortex_err!("Date type does not support time unit {}", metadata))?;
 
         vortex_ensure!(
-            storage_dtype.as_ptype() == ptype,
+            ext_dtype.storage_dtype().as_ptype() == ptype,
             "Date storage dtype for {} must be {}",
             metadata,
             ptype
@@ -105,12 +106,34 @@ impl ExtVTable for Date {
         Ok(())
     }
 
-    fn unpack_native(
-        &self,
-        metadata: &Self::Metadata,
-        _storage_dtype: &DType,
-        storage_value: &ScalarValue,
-    ) -> VortexResult<Self::NativeValue<'_>> {
+    fn can_coerce_from(ext_dtype: &ExtDType<Self>, other: &DType) -> bool {
+        let DType::Extension(other_ext) = other else {
+            return false;
+        };
+        let Some(other_unit) = other_ext.metadata_opt::<Date>() else {
+            return false;
+        };
+        let our_unit = ext_dtype.metadata();
+        // We can coerce from other if our unit is finer (<=) and nullability is compatible.
+        our_unit <= other_unit && (ext_dtype.storage_dtype().is_nullable() || !other.is_nullable())
+    }
+
+    fn least_supertype(ext_dtype: &ExtDType<Self>, other: &DType) -> Option<DType> {
+        let DType::Extension(other_ext) = other else {
+            return None;
+        };
+        let other_unit = other_ext.metadata_opt::<Date>()?;
+        let our_unit = ext_dtype.metadata();
+        let finest = (*our_unit).min(*other_unit);
+        let union_null = ext_dtype.storage_dtype().nullability() | other.nullability();
+        Some(DType::Extension(Date::new(finest, union_null).erased()))
+    }
+
+    fn unpack_native<'a>(
+        ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        let metadata = ext_dtype.metadata();
         match metadata {
             TimeUnit::Milliseconds => Ok(DateValue::Milliseconds(
                 storage_value.as_primitive().cast::<i64>()?,
@@ -120,3 +143,70 @@ impl ExtVTable for Date {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::Nullable;
+    use crate::extension::datetime::Date;
+    use crate::extension::datetime::TimeUnit;
+    use crate::scalar::PValue;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+
+    #[test]
+    fn validate_date_scalar() -> VortexResult<()> {
+        let days_dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
+        Scalar::try_new(days_dtype, Some(ScalarValue::Primitive(PValue::I32(0))))?;
+
+        let ms_dtype = DType::Extension(Date::new(TimeUnit::Milliseconds, Nullable).erased());
+        Scalar::try_new(
+            ms_dtype,
+            Some(ScalarValue::Primitive(PValue::I64(86_400_000))),
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn reject_date_with_overflowing_value() {
+        // Days storage is `I32`, so an `I64` value that overflows `i32` should fail the cast.
+        let dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
+        let result = Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(i64::MAX))));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn display_date_scalar() {
+        let dtype = DType::Extension(Date::new(TimeUnit::Days, Nullable).erased());
+
+        let scalar = Scalar::new(dtype.clone(), Some(ScalarValue::Primitive(PValue::I32(0))));
+        assert_eq!(format!("{}", scalar.as_extension()), "1970-01-01");
+
+        let scalar = Scalar::new(dtype, Some(ScalarValue::Primitive(PValue::I32(365))));
+        assert_eq!(format!("{}", scalar.as_extension()), "1971-01-01");
+    }
+
+    #[test]
+    fn least_supertype_date_units() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let days = DType::Extension(Date::new(TimeUnit::Days, NonNullable).erased());
+        let ms = DType::Extension(Date::new(TimeUnit::Milliseconds, NonNullable).erased());
+        let expected = DType::Extension(Date::new(TimeUnit::Milliseconds, NonNullable).erased());
+        assert_eq!(days.least_supertype(&ms).unwrap(), expected);
+        assert_eq!(ms.least_supertype(&days).unwrap(), expected);
+    }
+
+    #[test]
+    fn can_coerce_from_date() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let days = DType::Extension(Date::new(TimeUnit::Days, NonNullable).erased());
+        let ms = DType::Extension(Date::new(TimeUnit::Milliseconds, NonNullable).erased());
+        assert!(ms.can_coerce_from(&days));
+        assert!(!days.can_coerce_from(&ms));
+    }
+}
diff --git a/vortex-array/src/extension/datetime/time.rs b/vortex-array/src/extension/datetime/time.rs
index a13352afe92..08c43e9e20c 100644
--- a/vortex-array/src/extension/datetime/time.rs
+++ b/vortex-array/src/extension/datetime/time.rs
@@ -92,12 +92,13 @@ impl ExtVTable for Time {
         TimeUnit::try_from(tag)
     }
 
-    fn validate_dtype(&self, metadata: &Self::Metadata, storage_dtype: &DType) -> VortexResult<()> {
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        let metadata = ext_dtype.metadata();
         let ptype = time_ptype(metadata)
             .ok_or_else(|| vortex_err!("Time type does not support time unit {}", metadata))?;
 
         vortex_ensure!(
-            storage_dtype.as_ptype() == ptype,
+            ext_dtype.storage_dtype().as_ptype() == ptype,
             "Time storage dtype for {} must be {}",
             metadata,
             ptype
@@ -106,15 +107,35 @@ impl ExtVTable for Time {
         Ok(())
     }
 
-    fn unpack_native(
-        &self,
-        metadata: &Self::Metadata,
-        _storage_dtype: &DType,
-        storage_value: &ScalarValue,
-    ) -> VortexResult<Self::NativeValue<'_>> {
+    fn can_coerce_from(ext_dtype: &ExtDType<Self>, other: &DType) -> bool {
+        let DType::Extension(other_ext) = other else {
+            return false;
+        };
+        let Some(other_unit) = other_ext.metadata_opt::<Time>() else {
+            return false;
+        };
+        let our_unit = ext_dtype.metadata();
+        our_unit <= other_unit && (ext_dtype.storage_dtype().is_nullable() || !other.is_nullable())
+    }
+
+    fn least_supertype(ext_dtype: &ExtDType<Self>, other: &DType) -> Option<DType> {
+        let DType::Extension(other_ext) = other else {
+            return None;
+        };
+        let other_unit = other_ext.metadata_opt::<Time>()?;
+        let our_unit = ext_dtype.metadata();
+        let finest = (*our_unit).min(*other_unit);
+        let union_null = ext_dtype.storage_dtype().nullability() | other.nullability();
+        Some(DType::Extension(Time::new(finest, union_null).erased()))
+    }
+
+    fn unpack_native<'a>(
+        ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
         let length_of_time = storage_value.as_primitive().cast::<i64>()?;
 
-        let (span, value) = match *metadata {
+        let (span, value) = match *ext_dtype.metadata() {
             TimeUnit::Seconds => {
                 let v = i32::try_from(length_of_time)
                     .map_err(|e| vortex_err!("Time seconds value out of i32 range: {e}"))?;
@@ -144,3 +165,58 @@ impl ExtVTable for Time {
         Ok(value)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::Nullable;
+    use crate::extension::datetime::Time;
+    use crate::extension::datetime::TimeUnit;
+    use crate::scalar::PValue;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+
+    #[test]
+    fn validate_time_scalar() -> VortexResult<()> {
+        // 3661 seconds = 1 hour, 1 minute, 1 second.
+        let dtype = DType::Extension(Time::new(TimeUnit::Seconds, Nullable).erased());
+        Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I32(3661))))?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn reject_time_out_of_range() {
+        // 86400 seconds = exactly 24 hours, which exceeds the valid `jiff::civil::Time` range.
+        let dtype = DType::Extension(Time::new(TimeUnit::Seconds, Nullable).erased());
+        let result = Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I32(86400))));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn display_time_scalar() {
+        let dtype = DType::Extension(Time::new(TimeUnit::Seconds, Nullable).erased());
+
+        let scalar = Scalar::new(
+            dtype.clone(),
+            Some(ScalarValue::Primitive(PValue::I32(3661))),
+        );
+        assert_eq!(format!("{}", scalar.as_extension()), "01:01:01");
+
+        let scalar = Scalar::new(dtype, Some(ScalarValue::Primitive(PValue::I32(0))));
+        assert_eq!(format!("{}", scalar.as_extension()), "00:00:00");
+    }
+
+    #[test]
+    fn least_supertype_time_units() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let secs = DType::Extension(Time::new(TimeUnit::Seconds, NonNullable).erased());
+        let ns = DType::Extension(Time::new(TimeUnit::Nanoseconds, NonNullable).erased());
+        let expected = DType::Extension(Time::new(TimeUnit::Nanoseconds, NonNullable).erased());
+        assert_eq!(secs.least_supertype(&ns).unwrap(), expected);
+        assert_eq!(ns.least_supertype(&secs).unwrap(), expected);
+    }
+}
diff --git a/vortex-array/src/extension/datetime/timestamp.rs b/vortex-array/src/extension/datetime/timestamp.rs
index fd3636d9066..b33571ed40e 100644
--- a/vortex-array/src/extension/datetime/timestamp.rs
+++ b/vortex-array/src/extension/datetime/timestamp.rs
@@ -169,24 +169,48 @@ impl ExtVTable for Timestamp {
         })
     }
 
-    fn validate_dtype(
-        &self,
-        _metadata: &Self::Metadata,
-        storage_dtype: &DType,
-    ) -> VortexResult<()> {
+    fn can_coerce_from(ext_dtype: &ExtDType<Self>, other: &DType) -> bool {
+        let DType::Extension(other_ext) = other else {
+            return false;
+        };
+        let Some(other_opts) = other_ext.metadata_opt::<Timestamp>() else {
+            return false;
+        };
+        let our_opts = ext_dtype.metadata();
+        our_opts.tz == other_opts.tz
+            && our_opts.unit <= other_opts.unit
+            && (ext_dtype.storage_dtype().is_nullable() || !other.is_nullable())
+    }
+
+    fn least_supertype(ext_dtype: &ExtDType<Self>, other: &DType) -> Option<DType> {
+        let DType::Extension(other_ext) = other else {
+            return None;
+        };
+        let other_opts = other_ext.metadata_opt::<Timestamp>()?;
+        let our_opts = ext_dtype.metadata();
+        if our_opts.tz != other_opts.tz {
+            return None;
+        }
+        let finest = our_opts.unit.min(other_opts.unit);
+        let union_null = ext_dtype.storage_dtype().nullability() | other.nullability();
+        Some(DType::Extension(
+            Timestamp::new_with_tz(finest, our_opts.tz.clone(), union_null).erased(),
+        ))
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
         vortex_ensure!(
-            matches!(storage_dtype, DType::Primitive(PType::I64, _)),
+            matches!(ext_dtype.storage_dtype(), DType::Primitive(PType::I64, _)),
             "Timestamp storage dtype must be i64"
         );
         Ok(())
     }
 
     fn unpack_native<'a>(
-        &self,
-        metadata: &'a Self::Metadata,
-        _storage_dtype: &'a DType,
+        ext_dtype: &'a ExtDType<Self>,
         storage_value: &'a ScalarValue,
     ) -> VortexResult<Self::NativeValue<'a>> {
+        let metadata = ext_dtype.metadata();
         let ts_value = storage_value.as_primitive().cast::<i64>()?;
         let tz = metadata.tz.as_ref();
 
@@ -223,3 +247,122 @@ impl ExtVTable for Timestamp {
         Ok(value)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use vortex_error::VortexResult;
+
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::Nullable;
+    use crate::extension::datetime::TimeUnit;
+    use crate::extension::datetime::Timestamp;
+    use crate::scalar::PValue;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+
+    #[test]
+    fn validate_timestamp_scalar() -> VortexResult<()> {
+        let dtype = DType::Extension(Timestamp::new(TimeUnit::Seconds, Nullable).erased());
+        Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(0))))?;
+
+        Ok(())
+    }
+
+    #[cfg_attr(miri, ignore)]
+    #[test]
+    fn reject_timestamp_with_invalid_timezone() {
+        let dtype = DType::Extension(
+            Timestamp::new_with_tz(
+                TimeUnit::Seconds,
+                Some(Arc::from("Not/A/Timezone")),
+                Nullable,
+            )
+            .erased(),
+        );
+        let result = Scalar::try_new(dtype, Some(ScalarValue::Primitive(PValue::I64(0))));
+        assert!(result.is_err());
+    }
+
+    #[cfg_attr(miri, ignore)]
+    #[test]
+    fn display_timestamp_scalar() {
+        // Local (no timezone) timestamp.
+        let local_dtype = DType::Extension(Timestamp::new(TimeUnit::Seconds, Nullable).erased());
+        let scalar = Scalar::new(local_dtype, Some(ScalarValue::Primitive(PValue::I64(0))));
+        assert_eq!(format!("{}", scalar.as_extension()), "1970-01-01T00:00:00Z");
+
+        // Zoned timestamp.
+        let zoned_dtype = DType::Extension(
+            Timestamp::new_with_tz(
+                TimeUnit::Seconds,
+                Some(Arc::from("America/New_York")),
+                Nullable,
+            )
+            .erased(),
+        );
+        let scalar = Scalar::new(zoned_dtype, Some(ScalarValue::Primitive(PValue::I64(0))));
+        assert_eq!(
+            format!("{}", scalar.as_extension()),
+            "1969-12-31T19:00:00-05:00[America/New_York]"
+        );
+    }
+
+    #[test]
+    fn least_supertype_timestamp_units() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let secs = DType::Extension(Timestamp::new(TimeUnit::Seconds, NonNullable).erased());
+        let ns = DType::Extension(Timestamp::new(TimeUnit::Nanoseconds, NonNullable).erased());
+        let expected =
+            DType::Extension(Timestamp::new(TimeUnit::Nanoseconds, NonNullable).erased());
+        assert_eq!(secs.least_supertype(&ns).unwrap(), expected);
+        assert_eq!(ns.least_supertype(&secs).unwrap(), expected);
+    }
+
+    #[test]
+    fn least_supertype_timestamp_tz_mismatch() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let utc = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Seconds, Some(Arc::from("UTC")), NonNullable).erased(),
+        );
+        let none = DType::Extension(Timestamp::new(TimeUnit::Seconds, NonNullable).erased());
+        assert!(utc.least_supertype(&none).is_none());
+    }
+
+    #[test]
+    fn least_supertype_timestamp_same_tz() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let utc_s = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Seconds, Some(Arc::from("UTC")), NonNullable).erased(),
+        );
+        let utc_ns = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Nanoseconds, Some(Arc::from("UTC")), NonNullable)
+                .erased(),
+        );
+        let expected = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Nanoseconds, Some(Arc::from("UTC")), NonNullable)
+                .erased(),
+        );
+        assert_eq!(utc_s.least_supertype(&utc_ns).unwrap(), expected);
+    }
+
+    #[test]
+    fn can_coerce_from_timestamp_tz() {
+        use crate::dtype::Nullability::NonNullable;
+
+        let utc = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Nanoseconds, Some(Arc::from("UTC")), NonNullable)
+                .erased(),
+        );
+        let utc_s = DType::Extension(
+            Timestamp::new_with_tz(TimeUnit::Seconds, Some(Arc::from("UTC")), NonNullable).erased(),
+        );
+        let none = DType::Extension(Timestamp::new(TimeUnit::Nanoseconds, NonNullable).erased());
+        assert!(utc.can_coerce_from(&utc_s));
+        assert!(!utc.can_coerce_from(&none));
+    }
+}
diff --git a/vortex-array/src/extension/mod.rs b/vortex-array/src/extension/mod.rs
index 5c29154ded0..9f81e7fb310 100644
--- a/vortex-array/src/extension/mod.rs
+++ b/vortex-array/src/extension/mod.rs
@@ -6,6 +6,7 @@
 use std::fmt;
 
 pub mod datetime;
+pub mod uuid;
 
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/extension/tests/divisible_int.rs b/vortex-array/src/extension/tests/divisible_int.rs
index e946dbdda51..8b9612e9438 100644
--- a/vortex-array/src/extension/tests/divisible_int.rs
+++ b/vortex-array/src/extension/tests/divisible_int.rs
@@ -5,13 +5,11 @@
 
 use std::fmt;
 
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
 use crate::dtype::DType;
-use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::dtype::extension::ExtDType;
 use crate::dtype::extension::ExtId;
@@ -19,7 +17,7 @@ use crate::dtype::extension::ExtVTable;
 use crate::scalar::ScalarValue;
 
 /// The divisor stored as extension metadata.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Divisor(pub u64);
 
 impl fmt::Display for Divisor {
@@ -32,14 +30,6 @@ impl fmt::Display for Divisor {
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 pub struct DivisibleInt;
 
-impl DivisibleInt {
-    /// Creates a new divisible integer extension dtype.
-    pub fn new(divisor: u64, nullability: Nullability) -> ExtDType<Self> {
-        ExtDType::try_new(Divisor(divisor), DType::Primitive(PType::U64, nullability))
-            .vortex_expect("valid divisible int dtype")
-    }
-}
-
 impl ExtVTable for DivisibleInt {
     type Metadata = Divisor;
     type NativeValue<'a> = u64;
@@ -62,25 +52,20 @@ impl ExtVTable for DivisibleInt {
         Ok(Divisor(n))
     }
 
-    fn validate_dtype(
-        &self,
-        _metadata: &Self::Metadata,
-        storage_dtype: &DType,
-    ) -> VortexResult<()> {
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
         vortex_ensure!(
-            matches!(storage_dtype, DType::Primitive(PType::U64, _)),
+            matches!(ext_dtype.storage_dtype(), DType::Primitive(PType::U64, _)),
             "divisible int storage dtype must be u64"
         );
         Ok(())
     }
 
-    fn unpack_native(
-        &self,
-        metadata: &Self::Metadata,
-        _storage_dtype: &DType,
-        storage_value: &ScalarValue,
-    ) -> VortexResult<Self::NativeValue<'_>> {
+    fn unpack_native<'a>(
+        ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
         let value = storage_value.as_primitive().cast::<u64>()?;
+        let metadata = ext_dtype.metadata();
         if value % metadata.0 != 0 {
             vortex_bail!("{} is not divisible by {}", value, metadata.0);
         }
@@ -97,46 +82,8 @@ mod tests {
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
+    use crate::dtype::extension::ExtDType;
     use crate::dtype::extension::ExtVTable;
-    use crate::scalar::PValue;
-    use crate::scalar::ScalarValue;
-    use crate::scalar::extension::ExtScalarValue;
-
-    #[test]
-    fn accepts_divisible_values() -> VortexResult<()> {
-        let div7 = DivisibleInt::new(7, Nullability::NonNullable);
-
-        for multiple in [0, 7, 14, 21, 7000] {
-            let sv = ExtScalarValue::<DivisibleInt>::try_new(
-                &div7,
-                ScalarValue::Primitive(PValue::U64(multiple)),
-            )?;
-            assert_eq!(
-                sv.storage_value(),
-                &ScalarValue::Primitive(PValue::U64(multiple))
-            );
-        }
-
-        Ok(())
-    }
-
-    #[test]
-    fn rejects_non_divisible_values() -> VortexResult<()> {
-        let div7 = DivisibleInt::new(7, Nullability::NonNullable);
-
-        for bad in [1, 2, 6, 8, 13, 15] {
-            assert!(
-                ExtScalarValue::<DivisibleInt>::try_new(
-                    &div7,
-                    ScalarValue::Primitive(PValue::U64(bad)),
-                )
-                .is_err(),
-                "{bad} should not be accepted as divisible by 7"
-            );
-        }
-
-        Ok(())
-    }
 
     #[test]
     fn metadata_roundtrip() -> VortexResult<()> {
@@ -159,29 +106,25 @@ mod tests {
 
     #[test]
     fn rejects_wrong_storage_dtype() {
-        let vtable = DivisibleInt;
         let divisor = Divisor(10);
 
         assert!(
-            vtable
-                .validate_dtype(
-                    &divisor,
-                    &DType::Primitive(PType::I32, Nullability::NonNullable)
-                )
-                .is_err()
+            ExtDType::<DivisibleInt>::try_new(
+                divisor,
+                DType::Primitive(PType::I32, Nullability::NonNullable)
+            )
+            .is_err()
         );
         assert!(
-            vtable
-                .validate_dtype(&divisor, &DType::Utf8(Nullability::NonNullable))
+            ExtDType::<DivisibleInt>::try_new(divisor, DType::Utf8(Nullability::NonNullable))
                 .is_err()
         );
         assert!(
-            vtable
-                .validate_dtype(
-                    &divisor,
-                    &DType::Primitive(PType::U64, Nullability::NonNullable)
-                )
-                .is_ok()
+            ExtDType::<DivisibleInt>::try_new(
+                divisor,
+                DType::Primitive(PType::U64, Nullability::NonNullable)
+            )
+            .is_ok()
         );
     }
 }
diff --git a/vortex-array/src/extension/uuid/metadata.rs b/vortex-array/src/extension/uuid/metadata.rs
new file mode 100644
index 00000000000..7e7dd8b16d8
--- /dev/null
+++ b/vortex-array/src/extension/uuid/metadata.rs
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use uuid::Version;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+/// Converts a `u8` discriminant back to a [`uuid::Version`].
+pub(crate) fn u8_to_version(b: u8) -> VortexResult<Version> {
+    match b {
+        0 => Ok(Version::Nil),
+        1 => Ok(Version::Mac),
+        2 => Ok(Version::Dce),
+        3 => Ok(Version::Md5),
+        4 => Ok(Version::Random),
+        5 => Ok(Version::Sha1),
+        6 => Ok(Version::SortMac),
+        7 => Ok(Version::SortRand),
+        8 => Ok(Version::Custom),
+        0xff => Ok(Version::Max),
+        _ => vortex_bail!("unknown UUID version discriminant: {b}"),
+    }
+}
+
+/// Metadata for the UUID extension type.
+///
+/// Optionally records which UUID version the column contains (e.g. v4 random, v7
+/// sort-random). When `None`, the column may contain any mix of versions.
+#[derive(Clone, Debug, Default)]
+pub struct UuidMetadata {
+    /// The UUID version, if known.
+    pub version: Option<Version>,
+}
+
+impl fmt::Display for UuidMetadata {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.version {
+            None => write!(f, ""),
+            Some(v) => write!(f, "v{}", v as u8),
+        }
+    }
+}
+
+// `uuid::Version` derives `PartialEq` but not `Eq` or `Hash`, so we implement these
+// manually using the `#[repr(u8)]` discriminant.
+
+impl PartialEq for UuidMetadata {
+    fn eq(&self, other: &Self) -> bool {
+        self.version.map(|v| v as u8) == other.version.map(|v| v as u8)
+    }
+}
+
+impl Eq for UuidMetadata {}
+
+impl Hash for UuidMetadata {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.version.map(|v| v as u8).hash(state);
+    }
+}
diff --git a/vortex-array/src/extension/uuid/mod.rs b/vortex-array/src/extension/uuid/mod.rs
new file mode 100644
index 00000000000..e4347c2513c
--- /dev/null
+++ b/vortex-array/src/extension/uuid/mod.rs
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! UUID extension type for Vortex.
+//!
+//! Provides a UUID extension type backed by `FixedSizeList(Primitive(U8), 16)` storage. Each UUID
+//! is stored as 16 bytes in big-endian (network) byte order, matching [RFC 4122] and Arrow's
+//! [canonical UUID extension].
+//!
+//! [RFC 4122]: https://www.rfc-editor.org/rfc/rfc4122
+//! [canonical UUID extension]: https://arrow.apache.org/docs/format/CanonicalExtensions.html#uuid
+
+mod metadata;
+pub use metadata::UuidMetadata;
+
+pub(crate) mod vtable;
+
+/// The VTable for the UUID extension type.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct Uuid;
diff --git a/vortex-array/src/extension/uuid/vtable.rs b/vortex-array/src/extension/uuid/vtable.rs
new file mode 100644
index 00000000000..c76c7352942
--- /dev/null
+++ b/vortex-array/src/extension/uuid/vtable.rs
@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use uuid;
+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::dtype::DType;
+use crate::dtype::PType;
+use crate::dtype::extension::ExtDType;
+use crate::dtype::extension::ExtId;
+use crate::dtype::extension::ExtVTable;
+use crate::extension::uuid::Uuid;
+use crate::extension::uuid::UuidMetadata;
+use crate::extension::uuid::metadata::u8_to_version;
+use crate::scalar::PValue;
+use crate::scalar::ScalarValue;
+
+/// The number of bytes in a UUID.
+pub(crate) const UUID_BYTE_LEN: usize = 16;
+
+impl ExtVTable for Uuid {
+    type Metadata = UuidMetadata;
+    type NativeValue<'a> = uuid::Uuid;
+
+    fn id(&self) -> ExtId {
+        ExtId::new_ref("vortex.uuid")
+    }
+
+    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        match metadata.version {
+            None => Ok(Vec::new()),
+            Some(v) => Ok(vec![v as u8]),
+        }
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        let version = match metadata.len() {
+            0 => None,
+            1 => Some(u8_to_version(metadata[0])?),
+            other => vortex_bail!("UUID metadata must be 0 or 1 bytes, got {other}"),
+        };
+
+        Ok(UuidMetadata { version })
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        let storage_dtype = ext_dtype.storage_dtype();
+        let DType::FixedSizeList(element_dtype, list_size, _nullability) = storage_dtype else {
+            vortex_bail!("UUID storage dtype must be a FixedSizeList, got {storage_dtype}");
+        };
+
+        vortex_ensure_eq!(
+            *list_size as usize,
+            UUID_BYTE_LEN,
+            "UUID storage FixedSizeList must have size {UUID_BYTE_LEN}, got {list_size}"
+        );
+
+        let DType::Primitive(ptype, elem_nullability) = element_dtype.as_ref() else {
+            vortex_bail!("UUID element dtype must be Primitive(U8), got {element_dtype}");
+        };
+
+        vortex_ensure_eq!(
+            *ptype,
+            PType::U8,
+            "UUID element dtype must be U8, got {ptype}"
+        );
+        vortex_ensure!(
+            !elem_nullability.is_nullable(),
+            "UUID element dtype must be non-nullable"
+        );
+
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        ext_dtype: &ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        let elements = storage_value.as_list();
+        vortex_ensure_eq!(
+            elements.len(),
+            UUID_BYTE_LEN,
+            "UUID scalar must have exactly {UUID_BYTE_LEN} bytes, got {}",
+            elements.len()
+        );
+
+        let mut bytes = [0u8; UUID_BYTE_LEN];
+        for (i, elem) in elements.iter().enumerate() {
+            let Some(scalar_value) = elem else {
+                vortex_bail!("UUID byte at index {i} must not be null");
+            };
+            let PValue::U8(b) = scalar_value.as_primitive() else {
+                vortex_bail!("UUID byte at index {i} must be U8");
+            };
+            bytes[i] = *b;
+        }
+
+        let parsed = uuid::Uuid::from_bytes(bytes);
+
+        // Verify the parsed UUID matches the expected version, if one is set.
+        if let Some(expected) = ext_dtype.metadata().version {
+            let expected = expected as u8;
+            let actual = parsed
+                .get_version()
+                .ok_or_else(|| vortex_err!("UUID has unrecognized version nibble"))?
+                as u8;
+
+            vortex_ensure_eq!(
+                expected,
+                actual,
+                "UUID version mismatch: expected v{expected}, got v{actual}",
+            );
+        }
+
+        Ok(parsed)
+    }
+}
+
+#[expect(
+    clippy::cast_possible_truncation,
+    reason = "UUID_BYTE_LEN always fits both usize and u32"
+)]
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use rstest::rstest;
+    use uuid::Version;
+    use vortex_error::VortexResult;
+
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::dtype::extension::ExtDType;
+    use crate::dtype::extension::ExtVTable;
+    use crate::extension::uuid::Uuid;
+    use crate::extension::uuid::UuidMetadata;
+    use crate::extension::uuid::vtable::UUID_BYTE_LEN;
+    use crate::scalar::Scalar;
+    use crate::scalar::ScalarValue;
+
+    #[rstest]
+    #[case::no_version(None)]
+    #[case::v4_random(Some(Version::Random))]
+    #[case::v7_sort_rand(Some(Version::SortRand))]
+    #[case::nil(Some(Version::Nil))]
+    #[case::max(Some(Version::Max))]
+    fn roundtrip_metadata(#[case] version: Option<Version>) -> VortexResult<()> {
+        let metadata = UuidMetadata { version };
+        let bytes = Uuid.serialize_metadata(&metadata)?;
+        let expected_len = if version.is_none() { 0 } else { 1 };
+        assert_eq!(bytes.len(), expected_len);
+        let deserialized = Uuid.deserialize_metadata(&bytes)?;
+        assert_eq!(deserialized, metadata);
+        Ok(())
+    }
+
+    #[test]
+    fn metadata_display_no_version() {
+        let metadata = UuidMetadata { version: None };
+        assert_eq!(metadata.to_string(), "");
+    }
+
+    #[test]
+    fn metadata_display_with_version() {
+        let metadata = UuidMetadata {
+            version: Some(Version::Random),
+        };
+        assert_eq!(metadata.to_string(), "v4");
+
+        let metadata = UuidMetadata {
+            version: Some(Version::SortRand),
+        };
+        assert_eq!(metadata.to_string(), "v7");
+    }
+
+    #[rstest]
+    #[case::non_nullable(Nullability::NonNullable)]
+    #[case::nullable(Nullability::Nullable)]
+    fn validate_correct_storage_dtype(#[case] nullability: Nullability) -> VortexResult<()> {
+        let metadata = UuidMetadata::default();
+        let storage_dtype = uuid_storage_dtype(nullability);
+        ExtDType::try_with_vtable(Uuid, metadata, storage_dtype)?;
+        Ok(())
+    }
+
+    #[test]
+    fn validate_rejects_wrong_list_size() {
+        let storage_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            8,
+            Nullability::NonNullable,
+        );
+        assert!(ExtDType::try_with_vtable(Uuid, UuidMetadata::default(), storage_dtype).is_err());
+    }
+
+    #[test]
+    fn validate_rejects_wrong_element_type() {
+        let storage_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U64, Nullability::NonNullable)),
+            UUID_BYTE_LEN as u32,
+            Nullability::NonNullable,
+        );
+        assert!(ExtDType::try_with_vtable(Uuid, UuidMetadata::default(), storage_dtype).is_err());
+    }
+
+    #[test]
+    fn validate_rejects_nullable_elements() {
+        let storage_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::Nullable)),
+            UUID_BYTE_LEN as u32,
+            Nullability::NonNullable,
+        );
+        assert!(ExtDType::try_with_vtable(Uuid, UuidMetadata::default(), storage_dtype).is_err());
+    }
+
+    #[test]
+    fn validate_rejects_non_fsl() {
+        let storage_dtype = DType::Primitive(PType::U8, Nullability::NonNullable);
+        assert!(ExtDType::try_with_vtable(Uuid, UuidMetadata::default(), storage_dtype).is_err());
+    }
+
+    #[test]
+    fn unpack_native_uuid() -> VortexResult<()> {
+        let expected = uuid::Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
+            .map_err(|e| vortex_error::vortex_err!("{e}"))?;
+
+        let ext_dtype = ExtDType::try_new(
+            UuidMetadata::default(),
+            uuid_storage_dtype(Nullability::NonNullable),
+        )?;
+        let children: Vec<Scalar> = expected
+            .as_bytes()
+            .iter()
+            .map(|&b| Scalar::primitive(b, Nullability::NonNullable))
+            .collect();
+        let storage_scalar = Scalar::fixed_size_list(
+            DType::Primitive(PType::U8, Nullability::NonNullable),
+            children,
+            Nullability::NonNullable,
+        );
+
+        let storage_value = storage_scalar
+            .value()
+            .ok_or_else(|| vortex_error::vortex_err!("expected non-null scalar"))?;
+        let result = Uuid::unpack_native(&ext_dtype, storage_value)?;
+        assert_eq!(result, expected);
+        assert_eq!(result.to_string(), "550e8400-e29b-41d4-a716-446655440000");
+        Ok(())
+    }
+
+    #[test]
+    fn unpack_native_rejects_version_mismatch() -> VortexResult<()> {
+        // This is a v4 UUID.
+        let v4_uuid = uuid::Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
+            .map_err(|e| vortex_error::vortex_err!("{e}"))?;
+        assert_eq!(v4_uuid.get_version(), Some(Version::Random));
+
+        // Metadata says v7, but the UUID is v4.
+        let ext_dtype = ExtDType::try_with_vtable(
+            Uuid,
+            UuidMetadata {
+                version: Some(Version::SortRand),
+            },
+            uuid_storage_dtype(Nullability::NonNullable),
+        )?;
+        let children: Vec<Scalar> = v4_uuid
+            .as_bytes()
+            .iter()
+            .map(|&b| Scalar::primitive(b, Nullability::NonNullable))
+            .collect();
+        let storage_scalar = Scalar::fixed_size_list(
+            DType::Primitive(PType::U8, Nullability::NonNullable),
+            children,
+            Nullability::NonNullable,
+        );
+
+        let storage_value = storage_scalar
+            .value()
+            .ok_or_else(|| vortex_error::vortex_err!("expected non-null scalar"))?;
+        assert!(Uuid::unpack_native(&ext_dtype, storage_value).is_err());
+        Ok(())
+    }
+
+    /// Builds a [`ScalarValue`] for a UUID's 16 bytes, suitable for passing to `unpack_native`.
+    fn uuid_storage_scalar(uuid: &uuid::Uuid) -> ScalarValue {
+        let children: Vec<Scalar> = uuid
+            .as_bytes()
+            .iter()
+            .map(|&b| Scalar::primitive(b, Nullability::NonNullable))
+            .collect();
+        let scalar = Scalar::fixed_size_list(
+            DType::Primitive(PType::U8, Nullability::NonNullable),
+            children,
+            Nullability::NonNullable,
+        );
+        scalar.value().unwrap().clone()
+    }
+
+    #[test]
+    fn unpack_native_accepts_matching_version() -> VortexResult<()> {
+        // This is a v4 UUID.
+        let v4_uuid = uuid::Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
+            .map_err(|e| vortex_error::vortex_err!("{e}"))?;
+
+        let ext_dtype = ExtDType::try_new(
+            UuidMetadata {
+                version: Some(Version::Random),
+            },
+            uuid_storage_dtype(Nullability::NonNullable),
+        )
+        .unwrap();
+        let storage_value = uuid_storage_scalar(&v4_uuid);
+
+        let result = Uuid::unpack_native(&ext_dtype, &storage_value)?;
+        assert_eq!(result, v4_uuid);
+        Ok(())
+    }
+
+    #[test]
+    fn unpack_native_any_version_accepts_all() -> VortexResult<()> {
+        // A v4 UUID should be accepted when metadata has no version constraint.
+        let v4_uuid = uuid::Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
+            .map_err(|e| vortex_error::vortex_err!("{e}"))?;
+
+        let ext_dtype = ExtDType::try_new(
+            UuidMetadata::default(),
+            uuid_storage_dtype(Nullability::NonNullable),
+        )
+        .unwrap();
+        let storage_value = uuid_storage_scalar(&v4_uuid);
+
+        let result = Uuid::unpack_native(&ext_dtype, &storage_value)?;
+        assert_eq!(result, v4_uuid);
+        Ok(())
+    }
+
+    fn uuid_storage_dtype(nullability: Nullability) -> DType {
+        DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            UUID_BYTE_LEN as u32,
+            nullability,
+        )
+    }
+}
diff --git a/vortex-array/src/hash.rs b/vortex-array/src/hash.rs
index 5733bdcc54e..f28739109e3 100644
--- a/vortex-array/src/hash.rs
+++ b/vortex-array/src/hash.rs
@@ -9,8 +9,6 @@ use vortex_buffer::BitBuffer;
 use vortex_buffer::Buffer;
 use vortex_mask::Mask;
 
-use crate::Array;
-use crate::ArrayRef;
 use crate::patches::Patches;
 use crate::validity::Validity;
 
@@ -86,30 +84,6 @@ mod private {
     impl<T: ArrayEq + ?Sized> SealedEq for T {}
 }
 
-impl ArrayHash for dyn Array + '_ {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.dyn_array_hash(state, precision);
-    }
-}
-
-impl ArrayEq for dyn Array + '_ {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.dyn_array_eq(Array::as_any(other), precision)
-    }
-}
-
-impl ArrayHash for ArrayRef {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.as_ref().array_hash(state, precision);
-    }
-}
-
-impl ArrayEq for ArrayRef {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.as_ref().array_eq(other.as_ref(), precision)
-    }
-}
-
 impl<T: Hash> ArrayHash for Buffer<T> {
     fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
         match precision {
diff --git a/vortex-array/src/iter.rs b/vortex-array/src/iter.rs
index 9bbcc1a4e3c..b4cd01d875d 100644
--- a/vortex-array/src/iter.rs
+++ b/vortex-array/src/iter.rs
@@ -8,11 +8,11 @@ use std::sync::Arc;
 use itertools::Itertools;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
+use crate::arrays::chunked::ChunkedArrayExt;
 use crate::dtype::DType;
 use crate::stream::ArrayStream;
 use crate::stream::ArrayStreamAdapter;
@@ -92,14 +92,14 @@ pub trait ArrayIteratorExt: ArrayIterator {
 
 impl<I: ArrayIterator> ArrayIteratorExt for I {}
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Create an [`ArrayIterator`] over the array.
     pub fn to_array_iterator(&self) -> impl ArrayIterator + 'static {
         let dtype = self.dtype().clone();
-        let iter = if let Some(chunked) = self.as_opt::<ChunkedVTable>() {
-            ArrayChunkIterator::Chunked(Arc::new(chunked.clone()), 0)
+        let iter = if let Some(chunked) = self.as_opt::<Chunked>() {
+            ArrayChunkIterator::Chunked(Arc::new(chunked.into_owned()), 0)
         } else {
-            ArrayChunkIterator::Single(Some(self.to_array()))
+            ArrayChunkIterator::Single(Some(self.clone()))
         };
         ArrayIteratorAdapter::new(dtype, iter)
     }
diff --git a/vortex-array/src/kernel.rs b/vortex-array/src/kernel.rs
index 3e2a5269b55..f5b75471437 100644
--- a/vortex-array/src/kernel.rs
+++ b/vortex-array/src/kernel.rs
@@ -1,6 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Parent kernels: child-driven fused execution of parent arrays.
+//!
+//! A parent kernel allows a child encoding to provide a specialized execution path for its
+//! parent array. This is Layer 3 of the [execution model](https://docs.vortex.dev/developer-guide/internals/execution).
+//!
+//! For example, a `RunEndArray` child of a `SliceArray` can perform a binary search on its
+//! run ends rather than decoding the entire array and slicing the result.
+//!
+//! Encodings declare their parent kernels by implementing [`ExecuteParentKernel`] and
+//! registering them in a [`ParentKernelSet`]. Each kernel specifies which parent types it
+//! handles via a [`Matcher`].
+
 use std::any::type_name;
 use std::fmt::Debug;
 use std::marker::PhantomData;
@@ -9,9 +21,15 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::matcher::Matcher;
-use crate::vtable::VTable;
 
+/// A collection of [`ExecuteParentKernel`]s registered for a specific child encoding.
+///
+/// During execution, the scheduler iterates over each child's `ParentKernelSet` looking for
+/// a kernel whose [`Matcher`] matches the parent array type. The first matching kernel that
+/// returns `Some` wins.
 pub struct ParentKernelSet<V: VTable> {
     kernels: &'static [&'static dyn DynParentKernel<V>],
 }
@@ -41,7 +59,7 @@ impl<V: VTable> ParentKernelSet<V> {
     /// Evaluate the parent kernels on the given child and parent arrays.
     pub fn execute(
         &self,
-        child: &V::Array,
+        child: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -58,31 +76,48 @@ impl<V: VTable> ParentKernelSet<V> {
     }
 }
 
+/// A kernel that allows a child encoding `V` to execute its parent array in a fused manner.
+///
+/// This is the typed trait that encoding authors implement. The associated `Parent` type
+/// specifies which parent array types this kernel can handle. When the parent matches,
+/// [`execute_parent`](Self::execute_parent) is called with the strongly-typed child and parent views.
+///
+/// Unlike reduce rules, parent kernels may read buffers and perform real computation.
+///
+/// Return `Ok(None)` to decline handling (the scheduler will try the next kernel or fall
+/// through to the encoding's own `execute`).
 pub trait ExecuteParentKernel<V: VTable>: Debug + Send + Sync + 'static {
+    /// The parent array type this kernel handles.
     type Parent: Matcher;
 
     /// Attempt to execute the parent array fused with the child array.
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
+/// Type-erased version of [`ExecuteParentKernel`] used for dynamic dispatch within
+/// [`ParentKernelSet`].
 pub trait DynParentKernel<V: VTable>: Send + Sync {
+    /// Returns `true` if this kernel's parent [`Matcher`] matches the given parent array.
     fn matches(&self, parent: &ArrayRef) -> bool;
 
+    /// Attempt to execute the parent array fused with the child array.
     fn execute_parent(
         &self,
-        child: &V::Array,
+        child: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
+/// Bridges a concrete [`ExecuteParentKernel<V, K>`] to the type-erased [`DynParentKernel<V>`]
+/// trait. Created by [`ParentKernelSet::lift`].
 pub struct ParentKernelAdapter<V, K> {
     kernel: K,
     _phantom: PhantomData<V>,
@@ -104,7 +139,7 @@ impl<V: VTable, K: ExecuteParentKernel<V>> DynParentKernel<V> for ParentKernelAd
 
     fn execute_parent(
         &self,
-        child: &V::Array,
+        child: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
diff --git a/vortex-array/src/lib.rs b/vortex-array/src/lib.rs
index d85569c046f..463cb75a162 100644
--- a/vortex-array/src/lib.rs
+++ b/vortex-array/src/lib.rs
@@ -13,21 +13,25 @@
 //! Every data type recognized by Vortex also has a canonical physical encoding format, which
 //! arrays can be [canonicalized](Canonical) into for ease of access in compute functions.
 
+extern crate self as vortex_array;
+
 use std::sync::LazyLock;
 
 pub use array::*;
 pub use canonical::*;
 pub use columnar::*;
-pub use context::*;
 pub use executor::*;
 pub use hash::*;
 pub use mask_future::*;
 pub use metadata::*;
+pub use vortex_array_macros::array_slots;
 use vortex_session::VortexSession;
+use vortex_session::registry::Context;
 
 use crate::session::ArraySession;
 
 pub mod accessor;
+pub mod aggregate_fn;
 #[doc(hidden)]
 pub mod aliases;
 mod array;
@@ -39,7 +43,6 @@ pub mod builtins;
 mod canonical;
 mod columnar;
 pub mod compute;
-mod context;
 pub mod display;
 pub mod dtype;
 mod executor;
@@ -52,6 +55,7 @@ pub mod kernel;
 pub mod mask;
 mod mask_future;
 pub mod matcher;
+pub mod memory;
 mod metadata;
 pub mod normalize;
 pub mod optimizer;
@@ -68,7 +72,6 @@ pub mod stream;
 pub mod test_harness;
 pub mod validity;
 pub mod variants;
-pub mod vtable;
 
 pub mod flatbuffers {
     //! Re-exported autogenerated code from the core Vortex flatbuffer definitions.
@@ -80,3 +83,5 @@ pub mod flatbuffers {
 //  here...
 pub static LEGACY_SESSION: LazyLock<VortexSession> =
     LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+pub type ArrayContext = Context<ArrayPluginRef>;
diff --git a/vortex-array/src/mask.rs b/vortex-array/src/mask.rs
index e8256a13f80..c23a6f79652 100644
--- a/vortex-array/src/mask.rs
+++ b/vortex-array/src/mask.rs
@@ -7,13 +7,12 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Executable;
 use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
-use crate::arrays::ConstantVTable;
+use crate::arrays::Constant;
 use crate::columnar::Columnar;
 use crate::dtype::DType;
 
@@ -23,7 +22,7 @@ impl Executable for Mask {
             vortex_bail!("Mask array must have boolean dtype, not {}", array.dtype());
         }
 
-        if let Some(constant) = array.as_opt::<ConstantVTable>() {
+        if let Some(constant) = array.as_opt::<Constant>() {
             let mask_value = constant.scalar().as_bool().value().unwrap_or(false);
             return Ok(Mask::new(array.len(), mask_value));
         }
diff --git a/vortex-array/src/matcher.rs b/vortex-array/src/matcher.rs
index b00afe00fb2..b7d82fa3866 100644
--- a/vortex-array/src/matcher.rs
+++ b/vortex-array/src/matcher.rs
@@ -1,19 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::Array;
+use crate::ArrayRef;
 
 /// Trait for matching array types.
 pub trait Matcher {
     type Match<'a>;
 
     /// Check if the given array matches this matcher type
-    fn matches(array: &dyn Array) -> bool {
+    fn matches(array: &ArrayRef) -> bool {
         Self::try_match(array).is_some()
     }
 
     /// Try to match the given array, returning the matched view type if successful.
-    fn try_match<'a>(array: &'a dyn Array) -> Option<Self::Match<'a>>;
+    fn try_match<'a>(array: &'a ArrayRef) -> Option<Self::Match<'a>>;
 }
 
 /// Matches any array type (wildcard matcher)
@@ -21,15 +21,15 @@ pub trait Matcher {
 pub struct AnyArray;
 
 impl Matcher for AnyArray {
-    type Match<'a> = &'a dyn Array;
+    type Match<'a> = &'a ArrayRef;
 
     #[inline(always)]
-    fn matches(_array: &dyn Array) -> bool {
+    fn matches(_array: &ArrayRef) -> bool {
         true
     }
 
     #[inline(always)]
-    fn try_match(array: &dyn Array) -> Option<Self::Match<'_>> {
+    fn try_match(array: &ArrayRef) -> Option<Self::Match<'_>> {
         Some(array)
     }
 }
diff --git a/vortex-array/src/memory.rs b/vortex-array/src/memory.rs
new file mode 100644
index 00000000000..47030b18131
--- /dev/null
+++ b/vortex-array/src/memory.rs
@@ -0,0 +1,375 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Session-scoped memory allocation for host-side buffers.
+
+use std::fmt::Debug;
+use std::mem::size_of;
+use std::sync::Arc;
+
+use bytes::Bytes;
+use vortex_buffer::Alignment;
+use vortex_buffer::Buffer;
+use vortex_buffer::ByteBuffer;
+use vortex_buffer::ByteBufferMut;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+use vortex_session::Ref;
+use vortex_session::RefMut;
+use vortex_session::SessionExt;
+
+/// Mutable host buffer contract used by [`WritableHostBuffer`].
+pub trait HostBufferMut: Send + 'static {
+    /// Returns the logical byte length of the buffer.
+    fn len(&self) -> usize;
+
+    /// Whether the buffer is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the alignment of the buffer.
+    fn alignment(&self) -> Alignment;
+
+    /// Returns mutable access to the writable byte range.
+    fn as_mut_slice(&mut self) -> &mut [u8];
+
+    /// Freeze the buffer into an immutable [`ByteBuffer`].
+    fn freeze(self: Box<Self>) -> ByteBuffer;
+}
+
+/// Exact-size writable host buffer returned by a [`HostAllocator`].
+pub struct WritableHostBuffer {
+    inner: Box<dyn HostBufferMut>,
+}
+
+impl WritableHostBuffer {
+    /// Create a writable host buffer from an implementation of [`HostBufferMut`].
+    pub fn new(inner: Box<dyn HostBufferMut>) -> Self {
+        Self { inner }
+    }
+
+    /// Returns the logical byte length of the buffer.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true when the buffer has zero bytes.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the alignment of the buffer.
+    pub fn alignment(&self) -> Alignment {
+        self.inner.alignment()
+    }
+
+    /// Returns mutable access to the writable byte range.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.inner.as_mut_slice()
+    }
+
+    /// Returns mutable access to the buffer as a typed slice.
+    pub fn as_mut_slice_typed<T>(&mut self) -> VortexResult<&mut [T]> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot create typed mutable slice for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            self.alignment().is_aligned_to(Alignment::of::<T>()),
+            InvalidArgument: "Buffer is not sufficiently aligned for type {}",
+            std::any::type_name::<T>()
+        );
+
+        let bytes = self.as_mut_slice();
+        let byte_len = bytes.len();
+        let ptr = bytes.as_mut_ptr();
+        let type_size = size_of::<T>();
+
+        vortex_ensure!(
+            byte_len.is_multiple_of(type_size),
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+
+        // SAFETY: We checked size divisibility and pointer alignment for `T`,
+        // and we have exclusive mutable access to the underlying bytes.
+        Ok(unsafe { std::slice::from_raw_parts_mut(ptr.cast::<T>(), byte_len / type_size) })
+    }
+
+    /// Freeze the writable buffer into an immutable [`ByteBuffer`].
+    pub fn freeze(self) -> ByteBuffer {
+        self.inner.freeze()
+    }
+
+    /// Freeze the writable buffer into a typed immutable [`Buffer<T>`].
+    pub fn freeze_typed<T>(self) -> VortexResult<Buffer<T>> {
+        vortex_ensure!(
+            size_of::<T>() != 0,
+            InvalidArgument: "Cannot freeze typed buffer for zero-sized type {}",
+            std::any::type_name::<T>()
+        );
+
+        let buffer = self.freeze();
+        let byte_len = buffer.len();
+        let type_size = size_of::<T>();
+        let type_align = Alignment::of::<T>();
+
+        vortex_ensure!(
+            byte_len.is_multiple_of(type_size),
+            InvalidArgument: "Buffer length {byte_len} is not a multiple of {} for {}",
+            type_size,
+            std::any::type_name::<T>()
+        );
+        vortex_ensure!(
+            buffer.is_aligned(type_align),
+            InvalidArgument: "Buffer pointer is not aligned to {} for {}",
+            type_align,
+            std::any::type_name::<T>()
+        );
+
+        Ok(Buffer::from_byte_buffer(buffer))
+    }
+}
+
+impl Debug for WritableHostBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WritableHostBuffer")
+            .field("len", &self.len())
+            .field("alignment", &self.alignment())
+            .finish()
+    }
+}
+
+/// Allocator for exact-size writable host buffers.
+pub trait HostAllocator: Debug + Send + Sync + 'static {
+    /// Allocate a writable host buffer with the requested byte length and alignment.
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer>;
+}
+
+/// Shared allocator reference used throughout session-scoped memory APIs.
+pub type HostAllocatorRef = Arc<dyn HostAllocator>;
+
+/// Extension methods for [`HostAllocator`]s.
+pub trait HostAllocatorExt: HostAllocator {
+    /// Allocate host memory for `len` elements of `T` using `Alignment::of::<T>()`.
+    fn allocate_typed<T>(&self, len: usize) -> VortexResult<WritableHostBuffer> {
+        let bytes = len.checked_mul(size_of::<T>()).ok_or_else(|| {
+            vortex_err!(
+                "Typed host allocation overflow for type {} and len {}",
+                std::any::type_name::<T>(),
+                len
+            )
+        })?;
+        self.allocate(bytes, Alignment::of::<T>())
+    }
+}
+
+impl<A: HostAllocator + ?Sized> HostAllocatorExt for A {}
+
+/// Session-scoped memory configuration for Vortex arrays.
+#[derive(Debug)]
+pub struct MemorySession {
+    allocator: HostAllocatorRef,
+}
+
+impl MemorySession {
+    /// Creates a new session memory configuration using the provided allocator.
+    pub fn new(allocator: HostAllocatorRef) -> Self {
+        Self { allocator }
+    }
+
+    /// Returns the configured allocator.
+    pub fn allocator(&self) -> HostAllocatorRef {
+        Arc::clone(&self.allocator)
+    }
+
+    /// Updates the configured allocator.
+    pub fn set_allocator(&mut self, allocator: HostAllocatorRef) {
+        self.allocator = allocator;
+    }
+}
+
+impl Default for MemorySession {
+    fn default() -> Self {
+        Self::new(Arc::new(DefaultHostAllocator))
+    }
+}
+
+/// Extension trait for accessing session-scoped memory configuration.
+pub trait MemorySessionExt: SessionExt {
+    /// Returns the memory session for this execution/session context.
+    fn memory(&self) -> Ref<'_, MemorySession> {
+        self.get::<MemorySession>()
+    }
+
+    /// Returns the configured host allocator for this execution/session context.
+    fn allocator(&self) -> HostAllocatorRef {
+        self.memory().allocator()
+    }
+
+    /// Returns mutable access to the memory session.
+    fn memory_mut(&self) -> RefMut<'_, MemorySession> {
+        self.get_mut::<MemorySession>()
+    }
+}
+
+impl<S: SessionExt> MemorySessionExt for S {}
+
+/// Default host allocator.
+#[derive(Debug, Default)]
+pub struct DefaultHostAllocator;
+
+impl HostAllocator for DefaultHostAllocator {
+    fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+        let mut buffer = ByteBufferMut::with_capacity_aligned(len, alignment);
+        // SAFETY: We fully initialize this slice before freezing it.
+        unsafe { buffer.set_len(len) };
+        Ok(WritableHostBuffer::new(Box::new(
+            DefaultWritableHostBuffer { buffer, alignment },
+        )))
+    }
+}
+
+#[derive(Debug)]
+struct DefaultWritableHostBuffer {
+    buffer: ByteBufferMut,
+    alignment: Alignment,
+}
+
+#[derive(Debug)]
+struct HostBufferOwner {
+    buffer: ByteBufferMut,
+}
+
+impl AsRef<[u8]> for HostBufferOwner {
+    fn as_ref(&self) -> &[u8] {
+        self.buffer.as_slice()
+    }
+}
+
+impl HostBufferMut for DefaultWritableHostBuffer {
+    fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    fn alignment(&self) -> Alignment {
+        self.alignment
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer.as_mut_slice()
+    }
+
+    fn freeze(self: Box<Self>) -> ByteBuffer {
+        let Self { buffer, alignment } = *self;
+        let bytes = Bytes::from_owner(HostBufferOwner { buffer });
+        ByteBuffer::from_bytes_aligned(bytes, alignment)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
+
+    use super::*;
+
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl HostAllocator for CountingAllocator {
+        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultHostAllocator.allocate(len, alignment)
+        }
+    }
+
+    #[test]
+    fn writable_host_buffer_freeze_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate(16, Alignment::new(8)).unwrap();
+        for (idx, byte) in writable.as_mut_slice().iter_mut().enumerate() {
+            *byte = u8::try_from(idx).unwrap();
+        }
+
+        let host = writable.freeze();
+        assert_eq!(host.len(), 16);
+        assert!(host.is_aligned(Alignment::new(8)));
+        assert_eq!(host.as_slice(), (0u8..16).collect::<Vec<_>>().as_slice());
+    }
+
+    #[test]
+    fn memory_session_replaces_allocator() {
+        let allocations = Arc::new(AtomicUsize::new(0));
+        let allocator = Arc::new(CountingAllocator {
+            allocations: Arc::clone(&allocations),
+        });
+        let mut session = MemorySession::default();
+        session.set_allocator(allocator);
+        drop(session.allocator().allocate(4, Alignment::none()).unwrap());
+        assert_eq!(allocations.load(Ordering::Relaxed), 1);
+    }
+
+    #[test]
+    fn typed_allocation_uses_type_alignment() {
+        let allocator = DefaultHostAllocator;
+        let writable = allocator.allocate_typed::<u64>(4).unwrap();
+        assert_eq!(writable.len(), 4 * size_of::<u64>());
+        assert_eq!(writable.alignment(), Alignment::of::<u64>());
+    }
+
+    #[test]
+    fn typed_mut_slice_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[10, 20, 30, 40]);
+
+        let frozen = writable.freeze();
+        let values = unsafe {
+            std::slice::from_raw_parts(
+                frozen.as_slice().as_ptr().cast::<u64>(),
+                frozen.len() / size_of::<u64>(),
+            )
+        };
+        assert_eq!(values, [10, 20, 30, 40]);
+    }
+
+    #[test]
+    fn typed_mut_slice_rejects_length_mismatch() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate(7, Alignment::none()).unwrap();
+        assert!(writable.as_mut_slice_typed::<u32>().is_err());
+    }
+
+    #[test]
+    fn freeze_typed_round_trip() {
+        let allocator = DefaultHostAllocator;
+        let mut writable = allocator.allocate_typed::<u64>(4).unwrap();
+        writable
+            .as_mut_slice_typed::<u64>()
+            .unwrap()
+            .copy_from_slice(&[1, 3, 5, 7]);
+
+        let frozen = writable.freeze_typed::<u64>().unwrap();
+        assert_eq!(frozen.as_slice(), [1, 3, 5, 7]);
+    }
+
+    #[test]
+    fn freeze_typed_rejects_length_mismatch() {
+        let allocator = DefaultHostAllocator;
+        let writable = allocator.allocate(7, Alignment::none()).unwrap();
+        let err = writable.freeze_typed::<u32>().unwrap_err();
+        let msg = format!("{err}");
+        assert!(msg.contains("not a multiple of"));
+    }
+}
diff --git a/vortex-array/src/normalize.rs b/vortex-array/src/normalize.rs
index c69919e9342..3235a480809 100644
--- a/vortex-array/src/normalize.rs
+++ b/vortex-array/src/normalize.rs
@@ -1,52 +1,232 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use itertools::Itertools;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::registry::Id;
+use vortex_utils::aliases::hash_set::HashSet;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ArrayVisitor;
-use crate::session::ArrayRegistry;
+use crate::ExecutionCtx;
 
 /// Options for normalizing an array.
 pub struct NormalizeOptions<'a> {
     /// The set of allowed array encodings (in addition to the canonical ones) that are permitted
     /// in the normalized array.
-    pub allowed: &'a ArrayRegistry,
+    pub allowed: &'a HashSet<Id>,
     /// The operation to perform when a non-allowed encoding is encountered.
-    pub operation: Operation,
+    pub operation: Operation<'a>,
 }
 
 /// The operation to perform when a non-allowed encoding is encountered.
-pub enum Operation {
+pub enum Operation<'a> {
     Error,
-    // TODO(joe): add into canonical variant
+    Execute(&'a mut ExecutionCtx),
 }
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Normalize the array according to given options.
     ///
     /// This operation performs a recursive traversal of the array. Any non-allowed encoding is
     /// normalized per the configured operation.
-    pub fn normalize(self: ArrayRef, options: &mut NormalizeOptions) -> VortexResult<ArrayRef> {
-        let array_ids = options.allowed.ids().collect_vec();
-        self.normalize_with_error(&array_ids)?;
-        // Note this takes ownership so we can at a later date remove non-allowed encodings.
-        Ok(self)
+    pub fn normalize(self, options: &mut NormalizeOptions) -> VortexResult<ArrayRef> {
+        match &mut options.operation {
+            Operation::Error => {
+                self.normalize_with_error(options.allowed)?;
+                // Note this takes ownership so we can at a later date remove non-allowed encodings.
+                Ok(self)
+            }
+            Operation::Execute(ctx) => self.normalize_with_execution(options.allowed, ctx),
+        }
     }
 
-    fn normalize_with_error(self: &ArrayRef, allowed: &[Id]) -> VortexResult<()> {
-        if !allowed.contains(&self.encoding_id()) {
+    fn normalize_with_error(&self, allowed: &HashSet<Id>) -> VortexResult<()> {
+        if !self.is_allowed_encoding(allowed) {
             vortex_bail!(AssertionFailed: "normalize forbids encoding ({})", self.encoding_id())
         }
 
-        for child in ArrayVisitor::children(self) {
-            let child: ArrayRef = child;
+        for child in self.children() {
             child.normalize_with_error(allowed)?
         }
         Ok(())
     }
+
+    fn normalize_with_execution(
+        self,
+        allowed: &HashSet<Id>,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let mut normalized = self;
+
+        // Top-first execute the array tree while we hit non-allowed encodings.
+        while !normalized.is_allowed_encoding(allowed) {
+            normalized = normalized.execute(ctx)?;
+        }
+
+        // Now we've normalized the root, we need to ensure the children are normalized also.
+        let slots = normalized.slots();
+        let mut normalized_slots = Vec::with_capacity(slots.len());
+        let mut any_slot_changed = false;
+
+        for slot in slots {
+            match slot {
+                Some(child) => {
+                    let normalized_child = child.clone().normalize(&mut NormalizeOptions {
+                        allowed,
+                        operation: Operation::Execute(ctx),
+                    })?;
+                    any_slot_changed |= !ArrayRef::ptr_eq(child, &normalized_child);
+                    normalized_slots.push(Some(normalized_child));
+                }
+                None => normalized_slots.push(None),
+            }
+        }
+
+        if any_slot_changed {
+            normalized = normalized.with_slots(normalized_slots)?;
+        }
+
+        Ok(normalized)
+    }
+
+    fn is_allowed_encoding(&self, allowed: &HashSet<Id>) -> bool {
+        allowed.contains(&self.encoding_id()) || self.is_canonical()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+    use vortex_utils::aliases::hash_set::HashSet;
+
+    use super::NormalizeOptions;
+    use super::Operation;
+    use crate::ArrayRef;
+    use crate::ExecutionCtx;
+    use crate::IntoArray;
+    use crate::arrays::Dict;
+    use crate::arrays::DictArray;
+    use crate::arrays::Primitive;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::Slice;
+    use crate::arrays::SliceArray;
+    use crate::arrays::StructArray;
+    use crate::assert_arrays_eq;
+    use crate::validity::Validity;
+
+    #[test]
+    fn normalize_with_execution_keeps_parent_when_children_are_unchanged() -> VortexResult<()> {
+        let field = PrimitiveArray::from_iter(0i32..4).into_array();
+        let array = StructArray::try_new(
+            ["field"].into(),
+            vec![field.clone()],
+            field.len(),
+            Validity::NonNullable,
+        )?
+        .into_array();
+        let allowed = HashSet::from_iter([array.encoding_id(), field.encoding_id()]);
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+
+        let normalized = array.clone().normalize(&mut NormalizeOptions {
+            allowed: &allowed,
+            operation: Operation::Execute(&mut ctx),
+        })?;
+
+        assert!(ArrayRef::ptr_eq(&array, &normalized));
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_with_error_allows_canonical_arrays() -> VortexResult<()> {
+        let field = PrimitiveArray::from_iter(0i32..4).into_array();
+        let array = StructArray::try_new(
+            ["field"].into(),
+            vec![field.clone()],
+            field.len(),
+            Validity::NonNullable,
+        )?
+        .into_array();
+        let allowed = HashSet::default();
+
+        let normalized = array.clone().normalize(&mut NormalizeOptions {
+            allowed: &allowed,
+            operation: Operation::Error,
+        })?;
+
+        assert!(ArrayRef::ptr_eq(&array, &normalized));
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_with_execution_rebuilds_parent_when_a_child_changes() -> VortexResult<()> {
+        let unchanged = PrimitiveArray::from_iter(0i32..4).into_array();
+        let sliced =
+            SliceArray::new(PrimitiveArray::from_iter(10i32..20).into_array(), 2..6).into_array();
+        let array = StructArray::try_new(
+            ["lhs", "rhs"].into(),
+            vec![unchanged.clone(), sliced],
+            unchanged.len(),
+            Validity::NonNullable,
+        )?
+        .into_array();
+        let allowed = HashSet::from_iter([array.encoding_id(), unchanged.encoding_id()]);
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+
+        let normalized = array.clone().normalize(&mut NormalizeOptions {
+            allowed: &allowed,
+            operation: Operation::Execute(&mut ctx),
+        })?;
+
+        assert!(!ArrayRef::ptr_eq(&array, &normalized));
+
+        let original_children = array.children();
+        let normalized_children = normalized.children();
+        assert!(ArrayRef::ptr_eq(
+            &original_children[0],
+            &normalized_children[0]
+        ));
+        assert!(!ArrayRef::ptr_eq(
+            &original_children[1],
+            &normalized_children[1]
+        ));
+        assert_arrays_eq!(normalized_children[1], PrimitiveArray::from_iter(12i32..16));
+
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_slice_of_dict_returns_dict() -> VortexResult<()> {
+        let codes = PrimitiveArray::from_iter(vec![0u32, 1, 0, 1, 2]).into_array();
+        let values = PrimitiveArray::from_iter(vec![10i32, 20, 30]).into_array();
+        let dict = DictArray::try_new(codes, values)?.into_array();
+
+        // Slice the dict array to get a SliceArray wrapping a DictArray.
+        let sliced = SliceArray::new(dict, 1..4).into_array();
+        assert_eq!(sliced.encoding_id(), Slice::ID);
+
+        let allowed = HashSet::from_iter([Dict::ID, Primitive::ID]);
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+
+        println!("sliced {}", sliced.display_tree());
+
+        let normalized = sliced.normalize(&mut NormalizeOptions {
+            allowed: &allowed,
+            operation: Operation::Execute(&mut ctx),
+        })?;
+
+        println!("after {}", normalized.display_tree());
+
+        // The normalized result should be a DictArray, not a SliceArray.
+        assert_eq!(normalized.encoding_id(), Dict::ID);
+        assert_eq!(normalized.len(), 3);
+
+        // Verify the data: codes [1,0,1] -> values [20, 10, 20]
+        assert_arrays_eq!(
+            normalized.to_canonical()?,
+            PrimitiveArray::from_iter(vec![20i32, 10, 20])
+        );
+
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/optimizer/mod.rs b/vortex-array/src/optimizer/mod.rs
index 71d5f1f0df2..0401e69cb9a 100644
--- a/vortex-array/src/optimizer/mod.rs
+++ b/vortex-array/src/optimizer/mod.rs
@@ -1,19 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! The optimizer applies metadata-only rewrite rules (`reduce` and `reduce_parent`) in a
+//! fixpoint loop until no more transformations are possible.
+//!
+//! Optimization runs between execution steps, which is what enables cross-step optimizations:
+//! after a child is decoded, new `reduce_parent` rules may match that were previously blocked.
+
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
-use crate::array::ArrayRef;
+use crate::ArrayRef;
 
 pub mod rules;
 
+/// Extension trait for optimizing array trees using reduce/reduce_parent rules.
 pub trait ArrayOptimizer {
-    /// Optimize the root array node only.
+    /// Optimize the root array node only by running reduce and reduce_parent rules to fixpoint.
     fn optimize(&self) -> VortexResult<ArrayRef>;
 
-    /// Optimize the entire array tree recursively.
+    /// Optimize the entire array tree recursively (root and all descendants).
     fn optimize_recursive(&self) -> VortexResult<ArrayRef>;
 }
 
@@ -39,16 +45,17 @@ fn try_optimize(array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         }
         loop_counter += 1;
 
-        if let Some(new_array) = current_array.vtable().reduce(&current_array)? {
+        if let Some(new_array) = current_array.reduce()? {
             current_array = new_array;
             any_optimizations = true;
             continue;
         }
 
-        // Apply parent reduction rules to each child in the context of the current array.
-        // Its important to take all children here, as `current_array` can change inside the loop.
-        for (idx, child) in current_array.children().iter().enumerate() {
-            if let Some(new_array) = child.vtable().reduce_parent(child, &current_array, idx)? {
+        // Apply parent reduction rules to each slot in the context of the current array.
+        // Its important to take all slots here, as `current_array` can change inside the loop.
+        for (slot_idx, slot) in current_array.slots().iter().enumerate() {
+            let Some(child) = slot else { continue };
+            if let Some(new_array) = child.reduce_parent(&current_array, slot_idx)? {
                 // If the parent was replaced, then we attempt to reduce it again.
                 current_array = new_array;
                 any_optimizations = true;
@@ -78,19 +85,24 @@ fn try_optimize_recursive(array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
         any_optimizations = true;
     }
 
-    let mut new_children = Vec::with_capacity(current_array.nchildren());
-    let mut any_child_optimized = false;
-    for child in current_array.children() {
-        if let Some(new_child) = try_optimize_recursive(&child)? {
-            new_children.push(new_child);
-            any_child_optimized = true;
-        } else {
-            new_children.push(child.clone());
+    let mut new_slots = Vec::with_capacity(current_array.slots().len());
+    let mut any_slot_optimized = false;
+    for slot in current_array.slots() {
+        match slot {
+            Some(child) => {
+                if let Some(new_child) = try_optimize_recursive(child)? {
+                    new_slots.push(Some(new_child));
+                    any_slot_optimized = true;
+                } else {
+                    new_slots.push(Some(child.clone()));
+                }
+            }
+            None => new_slots.push(None),
         }
     }
 
-    if any_child_optimized {
-        current_array = current_array.with_children(new_children)?;
+    if any_slot_optimized {
+        current_array = current_array.with_slots(new_slots)?;
         any_optimizations = true;
     }
 
diff --git a/vortex-array/src/optimizer/rules.rs b/vortex-array/src/optimizer/rules.rs
index 3ff3ba8beea..e505b21a199 100644
--- a/vortex-array/src/optimizer/rules.rs
+++ b/vortex-array/src/optimizer/rules.rs
@@ -1,17 +1,38 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Metadata-only rewrite rules for the optimizer (Layers 1 and 2 of the execution model).
+//!
+//! Reduce rules are the cheapest transformations in the execution pipeline: they operate
+//! purely on array structure and metadata without reading any data buffers.
+//!
+//! There are two kinds of reduce rules:
+//!
+//! - [`ArrayReduceRule`] (Layer 1) -- a self-rewrite where an array simplifies itself.
+//!   Example: a `FilterArray` with an all-true mask removes the filter wrapper.
+//!
+//! - [`ArrayParentReduceRule`] (Layer 2) -- a child-driven rewrite where a child rewrites
+//!   its parent. Example: a `DictArray` child of a `ScalarFnArray` pushes the scalar function
+//!   into the dictionary values.
+//!
+//! Rules are collected into [`ReduceRuleSet`] and [`ParentRuleSet`] respectively, and
+//! evaluated by the optimizer in a fixpoint loop until no more rules apply.
+
 use std::any::type_name;
 use std::fmt::Debug;
 use std::marker::PhantomData;
 
 use vortex_error::VortexResult;
 
-use crate::array::ArrayRef;
+use crate::ArrayRef;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::matcher::Matcher;
-use crate::vtable::VTable;
 
-/// A rewrite rule that transforms arrays based on their own content
+/// A metadata-only rewrite rule that transforms an array based on its own structure (Layer 1).
+///
+/// These rules look only at the array's metadata and children types (not buffer contents)
+/// and return a structurally simpler replacement, or `None` if the rule doesn't apply.
 pub trait ArrayReduceRule<V: VTable>: Debug + Send + Sync + 'static {
     /// Attempt to rewrite this array.
     ///
@@ -19,11 +40,16 @@ pub trait ArrayReduceRule<V: VTable>: Debug + Send + Sync + 'static {
     /// - `Ok(Some(new_array))` if the rule applied successfully
     /// - `Ok(None)` if the rule doesn't apply
     /// - `Err(e)` if an error occurred
-    fn reduce(&self, array: &V::Array) -> VortexResult<Option<ArrayRef>>;
+    fn reduce(&self, array: ArrayView<'_, V>) -> VortexResult<Option<ArrayRef>>;
 }
 
-/// A rewrite rule that transforms arrays based on parent context
+/// A metadata-only rewrite rule where a child encoding rewrites its parent (Layer 2).
+///
+/// The child sees the parent's type via the associated `Parent` [`Matcher`] and can return
+/// a replacement for the parent. This enables optimizations like pushing operations through
+/// compression layers (e.g., pushing a scalar function into dictionary values).
 pub trait ArrayParentReduceRule<V: VTable>: Debug + Send + Sync + 'static {
+    /// The parent array type this rule matches against.
     type Parent: Matcher;
 
     /// Attempt to rewrite this child array given information about its parent.
@@ -34,25 +60,27 @@ pub trait ArrayParentReduceRule<V: VTable>: Debug + Send + Sync + 'static {
     /// - `Err(e)` if an error occurred
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
-/// Dynamic trait for array parent reduce rules
+/// Type-erased version of [`ArrayParentReduceRule`] used for dynamic dispatch within
+/// [`ParentRuleSet`].
 pub trait DynArrayParentReduceRule<V: VTable>: Debug + Send + Sync {
     fn matches(&self, parent: &ArrayRef) -> bool;
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
-/// Adapter for ArrayParentReduceRule
+/// Bridges a concrete [`ArrayParentReduceRule<V, R>`] to the type-erased
+/// [`DynArrayParentReduceRule<V>`] trait. Created by [`ParentRuleSet::lift`].
 pub struct ParentReduceRuleAdapter<V, R> {
     rule: R,
     _phantom: PhantomData<V>,
@@ -76,7 +104,7 @@ impl<V: VTable, K: ArrayParentReduceRule<V>> DynArrayParentReduceRule<V>
 
     fn reduce_parent(
         &self,
-        child: &V::Array,
+        child: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -87,6 +115,10 @@ impl<V: VTable, K: ArrayParentReduceRule<V>> DynArrayParentReduceRule<V>
     }
 }
 
+/// A collection of [`ArrayReduceRule`]s registered for a specific encoding.
+///
+/// During optimization, the optimizer calls [`evaluate`](Self::evaluate) which tries each rule
+/// in order. The first rule that returns `Some` wins.
 pub struct ReduceRuleSet<V: VTable> {
     rules: &'static [&'static dyn ArrayReduceRule<V>],
 }
@@ -98,7 +130,7 @@ impl<V: VTable> ReduceRuleSet<V> {
     }
 
     /// Evaluate the reduction rules on the given array.
-    pub fn evaluate(&self, array: &V::Array) -> VortexResult<Option<ArrayRef>> {
+    pub fn evaluate(&self, array: ArrayView<'_, V>) -> VortexResult<Option<ArrayRef>> {
         for rule in self.rules.iter() {
             if let Some(reduced) = rule.reduce(array)? {
                 return Ok(Some(reduced));
@@ -138,7 +170,7 @@ impl<V: VTable> ParentRuleSet<V> {
     /// Evaluate the parent reduction rules on the given child and parent arrays.
     pub fn evaluate(
         &self,
-        child: &V::Array,
+        child: ArrayView<'_, V>,
         parent: &ArrayRef,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
diff --git a/vortex-array/src/patches.rs b/vortex-array/src/patches.rs
index 98ac5081e27..1a614ceacf8 100644
--- a/vortex-array/src/patches.rs
+++ b/vortex-array/src/patches.rs
@@ -11,6 +11,7 @@ use num_traits::NumCast;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexError;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
@@ -20,18 +21,18 @@ use vortex_mask::Mask;
 use vortex_mask::MaskMut;
 use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::Array;
 use crate::ArrayRef;
-use crate::ArrayVisitor;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::ToCanonical;
+use crate::arrays::BoolArray;
 use crate::arrays::PrimitiveArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::filter;
-use crate::compute::is_sorted;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::dtype::NativePType;
+use crate::dtype::Nullability;
 use crate::dtype::Nullability::NonNullable;
 use crate::dtype::PType;
 use crate::dtype::UnsignedPType;
@@ -43,7 +44,6 @@ use crate::search_sorted::SearchResult;
 use crate::search_sorted::SearchSorted;
 use crate::search_sorted::SearchSortedSide;
 use crate::validity::Validity;
-use crate::vtable::ValidityHelper;
 
 /// One patch index offset is stored for each chunk.
 /// This allows for constant time patch index lookups.
@@ -184,12 +184,16 @@ impl Patches {
                 "Patch indices {max:?}, offset {offset} are longer than the array length {array_len}"
             );
 
-            debug_assert!(
-                is_sorted(indices.as_ref())
-                    .unwrap_or(Some(false))
-                    .unwrap_or(false),
-                "Patch indices must be sorted"
-            );
+            #[cfg(debug_assertions)]
+            {
+                use crate::VortexSessionExecute;
+                let mut ctx = crate::LEGACY_SESSION.create_execution_ctx();
+                assert!(
+                    crate::aggregate_fn::fns::is_sorted::is_sorted(&indices, &mut ctx)
+                        .unwrap_or(false),
+                    "Patch indices must be sorted"
+                );
+            }
         }
 
         Ok(Self {
@@ -398,10 +402,7 @@ impl Patches {
     /// # Returns
     /// [`SearchResult::Found`] with the position if needle exists, or [`SearchResult::NotFound`]
     /// with the insertion point if not found.
-    fn search_index_binary_search(
-        indices: &dyn Array,
-        needle: usize,
-    ) -> VortexResult<SearchResult> {
+    fn search_index_binary_search(indices: &ArrayRef, needle: usize) -> VortexResult<SearchResult> {
         if indices.is_canonical() {
             let primitive = indices.to_primitive();
             match_each_integer_ptype!(primitive.ptype(), |T| {
@@ -459,7 +460,9 @@ impl Patches {
             .saturating_sub(offset_within_chunk);
 
         let patches_end_idx = if chunk_idx < chunk_offsets.len() - 1 {
-            self.chunk_offset_at(chunk_idx + 1)? - base_offset - offset_within_chunk
+            (self.chunk_offset_at(chunk_idx + 1)? - base_offset)
+                .saturating_sub(offset_within_chunk)
+                .min(self.indices.len())
         } else {
             self.indices.len()
         };
@@ -521,13 +524,10 @@ impl Patches {
             .saturating_sub(offset_within_chunk);
 
         let patches_end_idx = if chunk_idx < chunk_offsets.len() - 1 {
-            let base_offset_end = chunk_offsets[chunk_idx + 1];
-
-            let offset_within_chunk = O::from(offset_within_chunk)
-                .ok_or_else(|| vortex_err!("offset_within_chunk failed to convert to O"))?;
-
-            usize::try_from(base_offset_end - chunk_offsets[0] - offset_within_chunk)
+            usize::try_from(chunk_offsets[chunk_idx + 1] - chunk_offsets[0])
                 .map_err(|_| vortex_err!("patches_end_idx failed to convert to usize"))?
+                .saturating_sub(offset_within_chunk)
+                .min(indices.len())
         } else {
             self.indices.len()
         };
@@ -569,7 +569,7 @@ impl Patches {
     }
 
     /// Filter the patches by a mask, resulting in new patches for the filtered array.
-    pub fn filter(&self, mask: &Mask) -> VortexResult<Option<Self>> {
+    pub fn filter(&self, mask: &Mask, ctx: &mut ExecutionCtx) -> VortexResult<Option<Self>> {
         if mask.len() != self.array_len {
             vortex_bail!(
                 "Filter mask length {} does not match array length {}",
@@ -582,7 +582,7 @@ impl Patches {
             AllOr::All => Ok(Some(self.clone())),
             AllOr::None => Ok(None),
             AllOr::Some(mask_indices) => {
-                let flat_indices = self.indices().to_primitive();
+                let flat_indices = self.indices().clone().execute::<PrimitiveArray>(ctx)?;
                 match_each_unsigned_integer_ptype!(flat_indices.ptype(), |I| {
                     filter_patches_with_mask(
                         flat_indices.as_slice::<I>(),
@@ -598,7 +598,8 @@ impl Patches {
     /// Mask the patches, REMOVING the patches where the mask is true.
     /// Unlike filter, this preserves the patch indices.
     /// Unlike mask on a single array, this does not set masked values to null.
-    pub fn mask(&self, mask: &Mask) -> VortexResult<Option<Self>> {
+    // TODO(joe): make this lazy and remove the ctx.
+    pub fn mask(&self, mask: &Mask, ctx: &mut ExecutionCtx) -> VortexResult<Option<Self>> {
         if mask.len() != self.array_len {
             vortex_bail!(
                 "Filter mask length {} does not match array length {}",
@@ -611,7 +612,7 @@ impl Patches {
             AllOr::All => return Ok(None),
             AllOr::None => return Ok(Some(self.clone())),
             AllOr::Some(masked) => {
-                let patch_indices = self.indices().to_primitive();
+                let patch_indices = self.indices().clone().execute::<PrimitiveArray>(ctx)?;
                 match_each_unsigned_integer_ptype!(patch_indices.ptype(), |P| {
                     let patch_indices = patch_indices.as_slice::<P>();
                     Mask::from_buffer(BitBuffer::collect_bool(patch_indices.len(), |i| {
@@ -628,8 +629,8 @@ impl Patches {
         }
 
         // SAFETY: filtering indices/values with same mask maintains their 1:1 relationship
-        let filtered_indices = filter(&self.indices, &filter_mask)?;
-        let filtered_values = filter(&self.values, &filter_mask)?;
+        let filtered_indices = self.indices.filter(filter_mask.clone())?;
+        let filtered_values = self.values.filter(filter_mask)?;
 
         Ok(Some(Self {
             array_len: self.array_len,
@@ -654,7 +655,7 @@ impl Patches {
         let values = self.values().slice(slice_start_idx..slice_end_idx)?;
         let indices = self.indices().slice(slice_start_idx..slice_end_idx)?;
 
-        let chunk_offsets = self
+        let new_chunk_offsets = self
             .chunk_offsets
             .as_ref()
             .map(|chunk_offsets| -> VortexResult<ArrayRef> {
@@ -665,15 +666,17 @@ impl Patches {
             })
             .transpose()?;
 
-        let offset_within_chunk = chunk_offsets
+        let offset_within_chunk = new_chunk_offsets
             .as_ref()
-            .map(|chunk_offsets| -> VortexResult<usize> {
-                let base_offset = chunk_offsets
+            .map(|new_chunk_offsets| -> VortexResult<usize> {
+                let new_chunk_base = new_chunk_offsets
                     .scalar_at(0)?
                     .as_primitive()
                     .as_::<usize>()
                     .ok_or_else(|| vortex_err!("chunk offset does not fit in usize"))?;
-                Ok(slice_start_idx - base_offset)
+                let parent_chunk_base = self.chunk_offset_at(0)?;
+                let parent_within = self.offset_within_chunk.unwrap_or(0);
+                Ok(parent_chunk_base + parent_within + slice_start_idx - new_chunk_base)
             })
             .transpose()?;
 
@@ -682,7 +685,7 @@ impl Patches {
             offset: range.start + self.offset(),
             indices,
             values,
-            chunk_offsets,
+            chunk_offsets: new_chunk_offsets,
             offset_within_chunk,
         }))
     }
@@ -698,32 +701,40 @@ impl Patches {
     /// Take the indices from the patches
     ///
     /// Any nulls in take_indices are added to the resulting patches.
-    pub fn take_with_nulls(&self, take_indices: &dyn Array) -> VortexResult<Option<Self>> {
+    pub fn take_with_nulls(
+        &self,
+        take_indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Self>> {
         if take_indices.is_empty() {
             return Ok(None);
         }
 
-        let take_indices = take_indices.to_primitive();
+        let take_indices = take_indices.clone().execute::<PrimitiveArray>(ctx)?;
         if self.is_map_faster_than_search(&take_indices) {
-            self.take_map(take_indices, true)
+            self.take_map(take_indices, true, ctx)
         } else {
-            self.take_search(take_indices, true)
+            self.take_search(take_indices, true, ctx)
         }
     }
 
     /// Take the indices from the patches.
     ///
     /// Any nulls in take_indices are ignored.
-    pub fn take(&self, take_indices: &dyn Array) -> VortexResult<Option<Self>> {
+    pub fn take(
+        &self,
+        take_indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Self>> {
         if take_indices.is_empty() {
             return Ok(None);
         }
 
-        let take_indices = take_indices.to_primitive();
+        let take_indices = take_indices.clone().execute::<PrimitiveArray>(ctx)?;
         if self.is_map_faster_than_search(&take_indices) {
-            self.take_map(take_indices, false)
+            self.take_map(take_indices, false, ctx)
         } else {
-            self.take_search(take_indices, false)
+            self.take_search(take_indices, false, ctx)
         }
     }
 
@@ -735,10 +746,15 @@ impl Patches {
         &self,
         take_indices: PrimitiveArray,
         include_nulls: bool,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<Self>> {
-        let take_indices_validity = take_indices.validity();
-        let patch_indices = self.indices.to_primitive();
-        let chunk_offsets = self.chunk_offsets().as_ref().map(|co| co.to_primitive());
+        let take_indices_validity = take_indices.validity()?;
+        let patch_indices = self.indices.clone().execute::<PrimitiveArray>(ctx)?;
+        let chunk_offsets = self
+            .chunk_offsets()
+            .as_ref()
+            .map(|co| co.clone().execute::<PrimitiveArray>(ctx))
+            .transpose()?;
 
         let (values_indices, new_indices): (BufferMut<u64>, BufferMut<u64>) =
             match_each_unsigned_integer_ptype!(patch_indices.ptype(), |PatchT| {
@@ -794,7 +810,7 @@ impl Patches {
         Ok(Some(Self {
             array_len: new_array_len,
             offset: 0,
-            indices: new_indices.clone(),
+            indices: new_indices,
             values: self
                 .values()
                 .take(PrimitiveArray::new(values_indices, values_validity).into_array())?,
@@ -807,8 +823,9 @@ impl Patches {
         &self,
         take_indices: PrimitiveArray,
         include_nulls: bool,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<Self>> {
-        let indices = self.indices.to_primitive();
+        let indices = self.indices.clone().execute::<PrimitiveArray>(ctx)?;
         let new_length = take_indices.len();
 
         let min_index = self.min_index()?;
@@ -817,9 +834,16 @@ impl Patches {
         let Some((new_sparse_indices, value_indices)) =
             match_each_unsigned_integer_ptype!(indices.ptype(), |Indices| {
                 match_each_integer_ptype!(take_indices.ptype(), |TakeIndices| {
+                    let take_validity = take_indices
+                        .validity()?
+                        .execute_mask(take_indices.len(), ctx)?;
+                    let take_nullability = take_indices.validity()?.nullability();
+                    let take_slice = take_indices.as_slice::<TakeIndices>();
                     take_map::<_, TakeIndices>(
                         indices.as_slice::<Indices>(),
-                        take_indices,
+                        take_slice,
+                        take_validity,
+                        take_nullability,
                         self.offset(),
                         min_index,
                         max_index,
@@ -854,10 +878,25 @@ impl Patches {
     ///
     /// - All patch indices after offset adjustment must be valid indices into the buffer.
     /// - The buffer and validity mask must have the same length.
-    pub unsafe fn apply_to_buffer<P: NativePType>(&self, buffer: &mut [P], validity: &mut MaskMut) {
-        let patch_indices = self.indices.to_primitive();
-        let patch_values = self.values.to_primitive();
-        let patches_validity = patch_values.validity();
+    pub unsafe fn apply_to_buffer<P: NativePType>(
+        &self,
+        buffer: &mut [P],
+        validity: &mut MaskMut,
+        ctx: &mut ExecutionCtx,
+    ) {
+        let patch_indices = self
+            .indices
+            .clone()
+            .execute::<PrimitiveArray>(ctx)
+            .vortex_expect("patch indices must be convertible to PrimitiveArray");
+        let patch_values = self
+            .values
+            .clone()
+            .execute::<PrimitiveArray>(ctx)
+            .vortex_expect("patch values must be convertible to PrimitiveArray");
+        let patches_validity = patch_values
+            .validity()
+            .vortex_expect("patch values validity should be derivable");
 
         let patch_values_slice = patch_values.as_slice::<P>();
         match_each_unsigned_integer_ptype!(patch_indices.ptype(), |I| {
@@ -875,7 +914,8 @@ impl Patches {
                     patch_indices_slice,
                     self.offset,
                     patch_values_slice,
-                    patches_validity,
+                    &patches_validity,
+                    ctx,
                 );
             }
         });
@@ -921,6 +961,7 @@ unsafe fn apply_patches_to_buffer_inner<P, I>(
     patch_offset: usize,
     patch_values: &[P],
     patches_validity: &Validity,
+    ctx: &mut ExecutionCtx,
 ) where
     P: NativePType,
     I: UnsignedPType,
@@ -957,7 +998,10 @@ unsafe fn apply_patches_to_buffer_inner<P, I>(
         }
         Validity::Array(array) => {
             // Some patch values may be null, check each one.
-            let bool_array = array.to_bool();
+            let bool_array = array
+                .clone()
+                .execute::<BoolArray>(ctx)
+                .vortex_expect("validity array must be convertible to BoolArray");
             let mask = bool_array.to_bit_buffer();
             for (patch_idx, (&i, &value)) in patch_indices.iter().zip_eq(patch_values).enumerate() {
                 let index = i.as_() - patch_offset;
@@ -977,9 +1021,12 @@ unsafe fn apply_patches_to_buffer_inner<P, I>(
     }
 }
 
+#[allow(clippy::too_many_arguments)] // private function, can clean up one day
 fn take_map<I: NativePType + Hash + Eq + TryFrom<usize>, T: NativePType>(
     indices: &[I],
-    take_indices: PrimitiveArray,
+    take_indices: &[T],
+    take_validity: Mask,
+    take_nullability: Nullability,
     indices_offset: usize,
     min_index: usize,
     max_index: usize,
@@ -989,10 +1036,6 @@ where
     usize: TryFrom<T>,
     VortexError: From<<I as TryFrom<usize>>::Error>,
 {
-    let take_indices_len = take_indices.len();
-    let take_indices_validity = take_indices.validity();
-    let take_indices_validity_mask = take_indices_validity.to_mask(take_indices_len);
-    let take_indices = take_indices.as_slice::<T>();
     let offset_i = I::try_from(indices_offset)?;
 
     let sparse_index_to_value_index: HashMap<I, usize> = indices
@@ -1011,7 +1054,7 @@ where
             .map_err(|_| vortex_err!("Failed to convert index to usize"))?;
 
         // If we have to take nulls the take index doesn't matter, make it 0 for consistency
-        let is_null = match take_indices_validity_mask.bit_buffer() {
+        let is_null = match take_validity.bit_buffer() {
             AllOr::All => false,
             AllOr::None => true,
             AllOr::Some(buf) => !buf.value(idx_in_take),
@@ -1036,7 +1079,8 @@ where
     }
 
     let new_sparse_indices = new_sparse_indices.into_array();
-    let values_validity = take_indices_validity.take(&new_sparse_indices)?;
+    let values_validity =
+        Validity::from_mask(take_validity, take_nullability).take(&new_sparse_indices)?;
     Ok(Some((
         new_sparse_indices,
         PrimitiveArray::new(value_indices, values_validity).into_array(),
@@ -1051,7 +1095,7 @@ where
 fn filter_patches_with_mask<T: IntegerPType>(
     patch_indices: &[T],
     offset: usize,
-    patch_values: &dyn Array,
+    patch_values: &ArrayRef,
     mask_indices: &[usize],
 ) -> VortexResult<Option<Patches>> {
     let true_count = mask_indices.len();
@@ -1129,10 +1173,8 @@ fn filter_patches_with_mask<T: IntegerPType>(
     }
 
     let new_patch_indices = new_patch_indices.into_array();
-    let new_patch_values = filter(
-        patch_values,
-        &Mask::from_indices(patch_values.len(), new_mask_indices),
-    )?;
+    let new_patch_values =
+        patch_values.filter(Mask::from_indices(patch_values.len(), new_mask_indices))?;
 
     Ok(Some(Patches::new(
         true_count,
@@ -1189,10 +1231,12 @@ mod test {
     use vortex_mask::Mask;
 
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
     use crate::ToCanonical;
-    use crate::arrays::PrimitiveArray;
+    use crate::VortexSessionExecute;
     use crate::assert_arrays_eq;
     use crate::patches::Patches;
+    use crate::patches::PrimitiveArray;
     use crate::search_sorted::SearchResult;
     use crate::validity::Validity;
 
@@ -1208,7 +1252,10 @@ mod test {
         .unwrap();
 
         let filtered = patches
-            .filter(&Mask::from_indices(100, vec![10, 20, 30]))
+            .filter(
+                &Mask::from_indices(100, vec![10, 20, 30]),
+                &mut LEGACY_SESSION.create_execution_ctx(),
+            )
             .unwrap()
             .unwrap();
 
@@ -1231,6 +1278,7 @@ mod test {
             .take(
                 &PrimitiveArray::new(buffer![9, 0], Validity::from_iter(vec![true, false]))
                     .into_array(),
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap()
             .unwrap();
@@ -1263,6 +1311,7 @@ mod test {
             .take_search(
                 PrimitiveArray::new(buffer![9, 0], Validity::from_iter([true, false])),
                 true,
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap()
             .unwrap();
@@ -1296,6 +1345,7 @@ mod test {
             .take_search(
                 PrimitiveArray::new(buffer![500, 1200, 999], Validity::AllValid),
                 true,
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap()
             .unwrap();
@@ -1322,6 +1372,7 @@ mod test {
             .take_search(
                 PrimitiveArray::new(buffer![3, 4, 5], Validity::AllValid),
                 true,
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap();
 
@@ -1343,6 +1394,7 @@ mod test {
             .take_search(
                 PrimitiveArray::new(buffer![10, 15, 20, 99], Validity::AllValid),
                 true,
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap()
             .unwrap();
@@ -1369,6 +1421,7 @@ mod test {
             .take_search(
                 PrimitiveArray::new(BufferMut::from_iter(0..1500u64), Validity::AllValid),
                 false,
+                &mut LEGACY_SESSION.create_execution_ctx(),
             )
             .unwrap()
             .unwrap();
@@ -1418,7 +1471,9 @@ mod test {
         .unwrap();
 
         let mask = Mask::new_true(10);
-        let masked = patches.mask(&mask).unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         assert!(masked.is_none());
     }
 
@@ -1434,7 +1489,10 @@ mod test {
         .unwrap();
 
         let mask = Mask::new_false(10);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         // No patch values should be masked
         assert_arrays_eq!(
@@ -1464,7 +1522,10 @@ mod test {
         let mask = Mask::from_iter([
             false, false, true, false, false, false, false, false, true, false,
         ]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         // Only the patch at index 5 should remain
         assert_eq!(masked.values().len(), 1);
@@ -1490,7 +1551,10 @@ mod test {
             false, false, true, false, false, false, false, false, false, false,
         ]);
 
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
         assert_eq!(masked.array_len(), 10);
         assert_eq!(masked.offset(), 5);
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([10u64, 13]));
@@ -1512,7 +1576,10 @@ mod test {
         let mask = Mask::from_iter([
             false, false, true, false, false, false, false, false, false, false,
         ]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         // Patches at indices 5 and 8 should remain
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([5u64, 8]));
@@ -1541,7 +1608,10 @@ mod test {
 
         // Keep all indices (mask with indices 0-9)
         let mask = Mask::from_indices(10, (0..10).collect());
-        let filtered = patches.filter(&mask).unwrap().unwrap();
+        let filtered = patches
+            .filter(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         assert_arrays_eq!(filtered.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
         assert_arrays_eq!(
@@ -1563,7 +1633,9 @@ mod test {
 
         // Filter out all (empty mask means keep nothing)
         let mask = Mask::from_indices(10, vec![]);
-        let filtered = patches.filter(&mask).unwrap();
+        let filtered = patches
+            .filter(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         assert!(filtered.is_none());
     }
 
@@ -1580,7 +1652,10 @@ mod test {
 
         // Keep indices 2, 5, 9 (so patches at 2 and 5 remain)
         let mask = Mask::from_indices(10, vec![2, 5, 9]);
-        let filtered = patches.filter(&mask).unwrap().unwrap();
+        let filtered = patches
+            .filter(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         assert_arrays_eq!(filtered.indices(), PrimitiveArray::from_iter([0u64, 1])); // Adjusted indices
         assert_arrays_eq!(filtered.values(), PrimitiveArray::from_iter([100i32, 200]));
@@ -1740,7 +1815,9 @@ mod test {
         let mask = Mask::from_iter([
             true, false, false, false, false, false, false, false, false, false,
         ]);
-        let masked = patches.mask(&mask).unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         assert!(masked.is_some());
         let masked = masked.unwrap();
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([9u64]));
@@ -1763,7 +1840,9 @@ mod test {
         let mask = Mask::from_iter([
             false, false, true, false, false, true, false, false, true, false,
         ]);
-        let masked = patches.mask(&mask).unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         assert!(masked.is_none());
     }
 
@@ -1783,7 +1862,10 @@ mod test {
         let mask = Mask::from_iter([
             true, false, false, true, false, false, true, false, false, true,
         ]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
         assert_arrays_eq!(
@@ -1806,12 +1888,17 @@ mod test {
 
         // Mask that removes the single patch
         let mask = Mask::from_iter([false, false, true, false, false]);
-        let masked = patches.mask(&mask).unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
         assert!(masked.is_none());
 
         // Mask that keeps the single patch
         let mask = Mask::from_iter([true, false, false, true, false]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([2u64]));
     }
 
@@ -1831,7 +1918,10 @@ mod test {
         let mask = Mask::from_iter([
             false, false, false, false, true, true, false, false, false, false,
         ]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([3u64, 6]));
         assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([100i32, 400]));
@@ -1854,7 +1944,10 @@ mod test {
             false, false, true, false, false, false, false, false, false, false, false, false,
             false, false, false, false, false, false, false, false,
         ]);
-        let masked = patches.mask(&mask).unwrap().unwrap();
+        let masked = patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap()
+            .unwrap();
 
         assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([16u64, 19]));
         assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([100i32, 300]));
@@ -1874,7 +1967,9 @@ mod test {
 
         // Mask with wrong length
         let mask = Mask::from_iter([false, false, true, false, false]);
-        patches.mask(&mask).unwrap();
+        patches
+            .mask(&mask, &mut LEGACY_SESSION.create_execution_ctx())
+            .unwrap();
     }
 
     #[test]
@@ -2057,6 +2152,20 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_nested_slice_with_dropped_first_chunk() {
+        // PATCH_CHUNK_SIZE = 1024, so the two patches land in different chunks.
+        let indices = buffer![0u64, 1024].into_array();
+        let values = buffer![1i32, 2].into_array();
+        let chunk_offsets = buffer![0u64, 1].into_array();
+        let patches = Patches::new(2048, 0, indices, values, Some(chunk_offsets)).unwrap();
+
+        // Drop chunk 0, then re-slice the result.
+        let dropped_first = patches.slice(1024..2048).unwrap().unwrap();
+        let resliced = dropped_first.slice(0..1024).unwrap().unwrap();
+        assert_eq!(resliced.num_patches(), 1);
+    }
+
     #[test]
     fn test_index_larger_than_length() {
         let chunk_offsets = buffer![0u64].into_array();
diff --git a/vortex-array/src/scalar/arbitrary.rs b/vortex-array/src/scalar/arbitrary.rs
index 342d4fa59b0..6abf02ffbc3 100644
--- a/vortex-array/src/scalar/arbitrary.rs
+++ b/vortex-array/src/scalar/arbitrary.rs
@@ -98,6 +98,7 @@ pub fn random_scalar(u: &mut Unstructured, dtype: &DType) -> Result<Scalar> {
         DType::Extension(..) => {
             unreachable!("Can't yet generate arbitrary scalars for ext dtype")
         }
+        DType::Variant(_) => todo!(),
     })
 }
 
diff --git a/vortex-array/src/scalar/arrow.rs b/vortex-array/src/scalar/arrow.rs
index e94dac46551..73142281b0d 100644
--- a/vortex-array/src/scalar/arrow.rs
+++ b/vortex-array/src/scalar/arrow.rs
@@ -65,6 +65,7 @@ impl TryFrom<&Scalar> for Arc<dyn Datum> {
             DType::List(..) => unimplemented!("list scalar conversion"),
             DType::FixedSizeList(..) => unimplemented!("fixed-size list scalar conversion"),
             DType::Extension(..) => extension_to_arrow(value.as_extension()),
+            DType::Variant(_) => unimplemented!("Variant scalar conversion"),
         }
     }
 }
@@ -202,6 +203,7 @@ mod tests {
     use crate::dtype::Nullability;
     use crate::dtype::PType;
     use crate::dtype::StructFields;
+    use crate::dtype::extension::ExtDType;
     use crate::dtype::extension::ExtId;
     use crate::dtype::extension::ExtVTable;
     use crate::dtype::i256;
@@ -464,18 +466,12 @@ mod tests {
                 vortex_bail!("not implemented")
             }
 
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
+            fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
                 Ok(())
             }
 
             fn unpack_native<'a>(
-                &self,
-                _metadata: &'a Self::Metadata,
-                _storage_dtype: &'a DType,
+                _ext_dtype: &'a ExtDType<Self>,
                 _storage_value: &'a ScalarValue,
             ) -> VortexResult<Self::NativeValue<'a>> {
                 Ok("")
@@ -561,8 +557,10 @@ mod tests {
     #[rstest]
     #[case(TimeUnit::Nanoseconds, "UTC", 1234567890000000000i64)]
     #[case(TimeUnit::Microseconds, "EST", 1234567890000000i64)]
-    #[case(TimeUnit::Milliseconds, "ABC", 1234567890000i64)]
-    #[case(TimeUnit::Seconds, "UTC", 1234567890i64)]
+    #[case(TimeUnit::Microseconds, "Asia/Qatar", 1234567890000000i64)]
+    #[case(TimeUnit::Microseconds, "Australia/Sydney", 1234567890000000i64)]
+    #[case(TimeUnit::Milliseconds, "HST", 1234567890000i64)]
+    #[case(TimeUnit::Seconds, "GMT", 1234567890i64)]
     fn test_temporal_timestamp_tz_to_arrow(
         #[case] time_unit: TimeUnit,
         #[case] tz: &str,
diff --git a/vortex-array/src/scalar/cast.rs b/vortex-array/src/scalar/cast.rs
index 47b684a8c10..a153b93373e 100644
--- a/vortex-array/src/scalar/cast.rs
+++ b/vortex-array/src/scalar/cast.rs
@@ -5,6 +5,7 @@
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
 use crate::dtype::DType;
@@ -41,7 +42,7 @@ impl Scalar {
             return Scalar::try_new(target_dtype.clone(), self.value().cloned());
         }
 
-        // TODO(connor): This isn't really correct but this will get fixed soon.
+        // TODO(connor): This isn't really correct for extension types.
         // If the target is an extension type, then we want to cast to its storage type.
         if let Some(ext_dtype) = target_dtype.as_extension_opt() {
             let cast_storage_scalar_value = self.cast(ext_dtype.storage_dtype())?.into_value();
@@ -58,6 +59,7 @@ impl Scalar {
             DType::Struct(..) => self.as_struct().cast(target_dtype),
             DType::List(..) | DType::FixedSizeList(..) => self.as_list().cast(target_dtype),
             DType::Extension(..) => self.as_extension().cast(target_dtype),
+            DType::Variant(_) => vortex_bail!("Variant scalars can't be cast to {target_dtype}"),
         }
     }
 
diff --git a/vortex-array/src/scalar/constructor.rs b/vortex-array/src/scalar/constructor.rs
index 3477dcffb9e..faaddc1dcef 100644
--- a/vortex-array/src/scalar/constructor.rs
+++ b/vortex-array/src/scalar/constructor.rs
@@ -171,11 +171,11 @@ impl Scalar {
     }
 
     /// Creates a new extension scalar wrapping the given storage value.
-    pub fn extension<V: ExtVTable + Default>(options: V::Metadata, value: Scalar) -> Self {
-        let ext_dtype = ExtDType::<V>::try_new(options, value.dtype().clone())
+    pub fn extension<V: ExtVTable + Default>(options: V::Metadata, storage_scalar: Scalar) -> Self {
+        let ext_dtype = ExtDType::<V>::try_new(options, storage_scalar.dtype().clone())
             .vortex_expect("Failed to create extension dtype");
-        Self::try_new(DType::Extension(ext_dtype.erased()), value.into_value())
-            .vortex_expect("unable to construct an extension `Scalar`")
+
+        Self::extension_ref(ext_dtype.erased(), storage_scalar)
     }
 
     /// Creates a new extension scalar wrapping the given storage value.
@@ -183,11 +183,25 @@ impl Scalar {
     /// # Panics
     ///
     /// Panics if the storage dtype of `ext_dtype` does not match `value`'s dtype.
-    pub fn extension_ref(ext_dtype: ExtDTypeRef, value: Scalar) -> Self {
-        assert_eq!(ext_dtype.storage_dtype(), value.dtype());
-        Self::try_new(DType::Extension(ext_dtype), value.into_value())
+    pub fn extension_ref(ext_dtype: ExtDTypeRef, storage_scalar: Scalar) -> Self {
+        assert_eq!(ext_dtype.storage_dtype(), storage_scalar.dtype());
+
+        Self::try_new(DType::Extension(ext_dtype), storage_scalar.into_value())
             .vortex_expect("unable to construct an extension `Scalar`")
     }
+
+    /// Creates a new variant scalar from a row-specific nested scalar.
+    ///
+    /// Use [`Scalar::null(DType::Variant(Nullability::Nullable))`][Scalar::null] for a top-level
+    /// null variant value, and
+    /// `Scalar::variant(Scalar::null(DType::Null))` for a defined variant-null.
+    pub fn variant(value: Scalar) -> Self {
+        Self::try_new(
+            DType::Variant(Nullability::NonNullable),
+            Some(ScalarValue::Variant(Box::new(value))),
+        )
+        .vortex_expect("unable to construct a variant `Scalar`")
+    }
 }
 
 /// A helper enum for creating a [`ListScalar`].
diff --git a/vortex-array/src/scalar/convert/from_scalar.rs b/vortex-array/src/scalar/convert/from_scalar.rs
index 4f5dbc98b98..32753dea1dc 100644
--- a/vortex-array/src/scalar/convert/from_scalar.rs
+++ b/vortex-array/src/scalar/convert/from_scalar.rs
@@ -113,7 +113,10 @@ impl TryFrom<&Scalar> for bool {
     type Error = VortexError;
 
     fn try_from(value: &Scalar) -> VortexResult<Self> {
-        <Option<bool>>::try_from(value)?
+        value
+            .as_bool_opt()
+            .ok_or_else(|| vortex_err!("Expected bool scalar, found {}", value.dtype()))?
+            .value()
             .ok_or_else(|| vortex_err!("Can't extract present value from null scalar"))
     }
 }
diff --git a/vortex-array/src/scalar/convert/primitive.rs b/vortex-array/src/scalar/convert/primitive.rs
index 145c7154d27..8b27b5fbd3b 100644
--- a/vortex-array/src/scalar/convert/primitive.rs
+++ b/vortex-array/src/scalar/convert/primitive.rs
@@ -64,8 +64,14 @@ macro_rules! primitive_scalar {
             type Error = VortexError;
 
             fn try_from(value: &Scalar) -> VortexResult<Self> {
-                <Option<$T>>::try_from(value)?
-                    .ok_or_else(|| vortex_err!("Can't extract present value from null scalar"))
+                match value.value() {
+                    Some(ScalarValue::Primitive(pv)) => pv.cast::<$T>(),
+                    Some(_) => Err(vortex_err!(
+                        "Expected primitive scalar, found {}",
+                        value.dtype()
+                    )),
+                    None => Err(vortex_err!("Can't extract present value from null scalar")),
+                }
             }
         }
 
diff --git a/vortex-array/src/scalar/display.rs b/vortex-array/src/scalar/display.rs
index b51fa03cdd9..dfbb2acb6aa 100644
--- a/vortex-array/src/scalar/display.rs
+++ b/vortex-array/src/scalar/display.rs
@@ -20,10 +20,8 @@ impl Display for Scalar {
             DType::Binary(_) => write!(f, "{}", self.as_binary()),
             DType::Struct(..) => write!(f, "{}", self.as_struct()),
             DType::List(..) | DType::FixedSizeList(..) => write!(f, "{}", self.as_list()),
-            DType::Extension(_) => {
-                // TODO(connor): This might need to change soon...
-                write!(f, "{}", self.as_extension())
-            }
+            DType::Extension(_) => write!(f, "{}", self.as_extension()),
+            DType::Variant(_) => write!(f, "{}", self.as_variant()),
         }
     }
 }
@@ -243,6 +241,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn display_variant_values() {
+        assert_eq!(
+            format!("{}", Scalar::null(DType::Variant(Nullable))),
+            "null"
+        );
+        assert_eq!(
+            format!("{}", Scalar::variant(Scalar::null(DType::Null))),
+            "variant(null)"
+        );
+        assert_eq!(
+            format!("{}", Scalar::variant(Scalar::from(42_u32))),
+            "variant(42u32)"
+        );
+    }
+
     #[test]
     fn display_local_timestamp() {
         fn dtype() -> DType {
@@ -261,7 +275,7 @@ mod tests {
                     )))
                 )
             ),
-            "1970-01-04T02:05:10"
+            "1970-01-04T02:05:10Z"
         );
     }
 
diff --git a/vortex-array/src/scalar/downcast.rs b/vortex-array/src/scalar/downcast.rs
index 16807aee008..ce9996514e3 100644
--- a/vortex-array/src/scalar/downcast.rs
+++ b/vortex-array/src/scalar/downcast.rs
@@ -20,6 +20,7 @@ use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 use crate::scalar::StructScalar;
 use crate::scalar::Utf8Scalar;
+use crate::scalar::VariantScalar;
 
 impl Scalar {
     /// Returns a view of the scalar as a boolean scalar.
@@ -145,7 +146,28 @@ impl Scalar {
 
     /// Returns a view of the scalar as an extension scalar if it has an extension type.
     pub fn as_extension_opt(&self) -> Option<ExtScalar<'_>> {
-        ExtScalar::try_new(self.dtype(), self.value()).ok()
+        if !self.dtype().is_extension() {
+            return None;
+        }
+
+        // SAFETY: Because we are a valid Scalar, we have already validated that the value is valid
+        // for this extension type.
+        Some(ExtScalar::new_unchecked(self.dtype(), self.value()))
+    }
+
+    /// Returns a view of the scalar as a variant scalar.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the scalar does not have a [`Variant`](crate::dtype::DType::Variant) type.
+    pub fn as_variant(&self) -> VariantScalar<'_> {
+        self.as_variant_opt()
+            .vortex_expect("Failed to convert scalar to variant")
+    }
+
+    /// Returns a view of the scalar as a variant scalar if it has a variant type.
+    pub fn as_variant_opt(&self) -> Option<VariantScalar<'_>> {
+        VariantScalar::try_new(self.dtype(), self.value()).ok()
     }
 }
 
@@ -249,4 +271,22 @@ impl ScalarValue {
             _ => vortex_panic!("ScalarValue is not a List"),
         }
     }
+
+    /// Returns the row-specific scalar wrapped by a variant, panicking if the value is not a
+    /// variant.
+    pub fn as_variant(&self) -> &Scalar {
+        match self {
+            ScalarValue::Variant(value) => value,
+            _ => vortex_panic!("ScalarValue is not a Variant"),
+        }
+    }
+
+    /// Returns the row-specific scalar wrapped by a variant, panicking if the value is not a
+    /// variant.
+    pub fn into_variant(self) -> Scalar {
+        match self {
+            ScalarValue::Variant(value) => *value,
+            _ => vortex_panic!("ScalarValue is not a Variant"),
+        }
+    }
 }
diff --git a/vortex-array/src/scalar/extension/erased.rs b/vortex-array/src/scalar/extension/erased.rs
deleted file mode 100644
index 69bad510789..00000000000
--- a/vortex-array/src/scalar/extension/erased.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::type_name;
-use std::cmp::Ordering;
-use std::fmt;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::sync::Arc;
-
-use vortex_error::VortexExpect;
-use vortex_error::vortex_err;
-
-use crate::dtype::extension::ExtId;
-use crate::dtype::extension::ExtVTable;
-use crate::scalar::ScalarValue;
-use crate::scalar::extension::ExtScalarValue;
-use crate::scalar::extension::typed::DynExtScalarValue;
-use crate::scalar::extension::typed::ExtScalarValueInner;
-
-/// A type-erased extension scalar value.
-///
-/// This is the extension scalar analog of [`ExtDTypeRef`]: it stores an [`ExtVTable`]
-/// and a storage [`ScalarValue`] behind a trait object, allowing heterogeneous storage inside
-/// `ScalarValue::Extension` (so that we do not need a generic parameter).
-///
-/// You can use [`try_downcast()`] or [`downcast()`] to recover the concrete vtable type as an
-/// [`ExtScalarValue<V>`].
-///
-/// [`ExtDTypeRef`]: crate::dtype::extension::ExtDTypeRef
-/// [`try_downcast()`]: ExtScalarValueRef::try_downcast
-/// [`downcast()`]: ExtScalarValueRef::downcast
-#[derive(Clone)]
-pub struct ExtScalarValueRef(pub(super) Arc<dyn DynExtScalarValue>);
-
-// NB: If you need access to the vtable, you probably want to add a method and implementation to
-// `ExtScalarValueInnerImpl` and `ExtScalarValueInner`.
-/// Methods for downcasting type-erased extension scalars.
-impl ExtScalarValueRef {
-    /// Returns the [`ExtId`] identifying this extension scalar's type.
-    pub fn id(&self) -> ExtId {
-        self.0.id()
-    }
-
-    /// Returns a reference to the underlying storage [`ScalarValue`].
-    pub fn storage_value(&self) -> &ScalarValue {
-        self.0.storage_value()
-    }
-
-    /// Attempts to downcast to a concrete [`ExtScalarValue<V>`].
-    ///
-    /// # Errors
-    ///
-    /// Returns `Err(self)` if the underlying vtable type does not match `V`.
-    pub fn try_downcast<V: ExtVTable>(self) -> Result<ExtScalarValue<V>, ExtScalarValueRef> {
-        // `ExtScalarValueInner<V>` is the only implementor of `ExtScalarValueInnerImpl` (due to
-        // the sealed implementation below), so if the vtable is correct, we know the type can be
-        // downcasted and reinterpreted safely.
-        if !self.0.as_any().is::<ExtScalarValueInner<V>>() {
-            return Err(self);
-        }
-
-        let ptr = Arc::into_raw(self.0) as *const ExtScalarValueInner<V>;
-        // SAFETY: We verified the type matches above, so the size and alignment are correct.
-        let inner = unsafe { Arc::from_raw(ptr) };
-
-        Ok(ExtScalarValue(inner))
-    }
-
-    /// Downcasts to a concrete [`ExtScalarValue<V>`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if the underlying vtable type does not match `V`.
-    pub fn downcast<V: ExtVTable>(self) -> ExtScalarValue<V> {
-        self.try_downcast::<V>()
-            .map_err(|this| {
-                vortex_err!(
-                    "Failed to downcast ExtScalar {} to {}",
-                    this.0.id(),
-                    type_name::<V>(),
-                )
-            })
-            .vortex_expect("Failed to downcast ExtScalar")
-    }
-}
-
-impl fmt::Display for ExtScalarValueRef {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}({})", self.0.id(), self.0.storage_value())
-    }
-}
-
-impl fmt::Debug for ExtScalarValueRef {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ExtScalar")
-            .field("id", &self.0.id())
-            .field("storage_value", self.0.storage_value())
-            .finish()
-    }
-}
-
-// TODO(connor): In the future we may want to allow implementors to customize this behavior.
-
-impl PartialEq for ExtScalarValueRef {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.id() == other.0.id() && self.0.storage_value() == other.0.storage_value()
-    }
-}
-impl Eq for ExtScalarValueRef {}
-
-impl PartialOrd for ExtScalarValueRef {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        // TODO(connor): Should this check if the IDs are equal before ordering?
-        self.0.storage_value().partial_cmp(other.0.storage_value())
-    }
-}
-
-impl Hash for ExtScalarValueRef {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.id().hash(state);
-        self.0.storage_value().hash(state);
-    }
-}
diff --git a/vortex-array/src/scalar/extension/mod.rs b/vortex-array/src/scalar/extension/mod.rs
deleted file mode 100644
index c3e2608b37a..00000000000
--- a/vortex-array/src/scalar/extension/mod.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Extension Scalar Values, and interfaces for working with them.
-//!
-//! We define normal [`Scalar`]s as the combination of a [`ScalarValue`] and a [`DType`].
-//!
-//! Similarly, we define an extension [`Scalar`] as the combination of an [`ExtScalarValueRef`] and
-//! an [`ExtDTypeRef`].
-//!
-//! [`Scalar`]: crate::scalar::Scalar
-//! [`ScalarValue`]: crate::scalar::ScalarValue
-//! [`DType`]: crate::dtype::DType
-//! [`ExtDTypeRef`]: crate::dtype::extension::ExtDTypeRef
-
-mod typed;
-pub use typed::ExtScalarValue;
-
-mod erased;
-pub use erased::ExtScalarValueRef;
-
-/// Private module to seal [`DynExtScalarValue`].
-mod sealed {
-    use crate::dtype::extension::ExtVTable;
-    use crate::scalar::extension::typed::ExtScalarValueInner;
-
-    /// Marker trait to prevent external implementations of [`DynExtScalarValue`].
-    pub(super) trait Sealed {}
-
-    /// This can be the **only** implementor for [`super::typed::DynExtScalarValue`].
-    impl<V: ExtVTable> Sealed for ExtScalarValueInner<V> {}
-}
-
-#[cfg(test)]
-mod tests;
diff --git a/vortex-array/src/scalar/extension/tests.rs b/vortex-array/src/scalar/extension/tests.rs
deleted file mode 100644
index feadd2f319d..00000000000
--- a/vortex-array/src/scalar/extension/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::sync::Arc;
-
-use vortex_error::VortexResult;
-
-use crate::dtype::Nullability;
-use crate::extension::datetime::Date;
-use crate::extension::datetime::Time;
-use crate::extension::datetime::TimeUnit;
-use crate::extension::datetime::Timestamp;
-use crate::scalar::PValue;
-use crate::scalar::ScalarValue;
-use crate::scalar::extension::ExtScalarValue;
-use crate::scalar::extension::ExtScalarValueRef;
-
-#[test]
-fn try_new_date_valid() -> VortexResult<()> {
-    let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable);
-    let storage = ScalarValue::Primitive(PValue::I32(100));
-
-    let sv = ExtScalarValue::<Date>::try_new(&ext_dtype, storage.clone())?;
-
-    assert_eq!(sv.id().as_ref(), "vortex.date");
-    assert_eq!(sv.storage_value(), &storage);
-    assert_eq!(sv.vtable(), &Date);
-    Ok(())
-}
-
-#[test]
-fn try_new_time_rejects_out_of_range() -> VortexResult<()> {
-    let ext_dtype = Time::new(TimeUnit::Seconds, Nullability::NonNullable);
-
-    // 25 hours in seconds exceeds valid time-of-day range.
-    let too_large = ScalarValue::Primitive(PValue::I32(90_000));
-    assert!(ExtScalarValue::<Time>::try_new(&ext_dtype, too_large).is_err());
-
-    // Negative time is invalid.
-    let negative = ScalarValue::Primitive(PValue::I32(-1));
-    assert!(ExtScalarValue::<Time>::try_new(&ext_dtype, negative).is_err());
-
-    // Just under 24h should succeed.
-    let just_valid = ScalarValue::Primitive(PValue::I32(86_399));
-    assert!(ExtScalarValue::<Time>::try_new(&ext_dtype, just_valid).is_ok());
-
-    Ok(())
-}
-
-#[cfg_attr(miri, ignore)]
-#[test]
-fn try_new_timestamp_rejects_invalid_tz() -> VortexResult<()> {
-    let ext_dtype = Timestamp::new_with_tz(
-        TimeUnit::Seconds,
-        Some(Arc::from("Not/A/Timezone")),
-        Nullability::NonNullable,
-    );
-
-    let storage = ScalarValue::Primitive(PValue::I64(0));
-    assert!(ExtScalarValue::<Timestamp>::try_new(&ext_dtype, storage).is_err());
-
-    Ok(())
-}
-
-#[test]
-fn typed_erased_downcast_roundtrip() -> VortexResult<()> {
-    let ext_dtype = Timestamp::new(TimeUnit::Microseconds, Nullability::NonNullable);
-    let storage = ScalarValue::Primitive(PValue::I64(1_000_000));
-
-    let typed = ExtScalarValue::<Timestamp>::try_new(&ext_dtype, storage)?;
-    let erased: ExtScalarValueRef = typed.clone().erased();
-
-    assert_eq!(erased.id().as_ref(), "vortex.timestamp");
-    assert_eq!(erased.storage_value(), typed.storage_value());
-
-    let roundtripped = erased.downcast::<Timestamp>();
-    assert_eq!(typed, roundtripped);
-    Ok(())
-}
-
-#[test]
-fn downcast_wrong_type_fails() -> VortexResult<()> {
-    let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable);
-    let storage = ScalarValue::Primitive(PValue::I32(42));
-
-    let erased = ExtScalarValue::<Date>::try_new(&ext_dtype, storage)?.erased();
-
-    // Wrong types return Err, preserving the value for retry.
-    let erased = erased.try_downcast::<Time>().unwrap_err();
-    let erased = erased.try_downcast::<Timestamp>().unwrap_err();
-
-    // Correct type succeeds after failed attempts.
-    let typed = erased.downcast::<Date>();
-    assert_eq!(typed.vtable(), &Date);
-    assert_eq!(
-        typed.storage_value(),
-        &ScalarValue::Primitive(PValue::I32(42))
-    );
-
-    Ok(())
-}
-
-#[test]
-fn try_new_rejects_unsupported_unit_and_overflow() -> VortexResult<()> {
-    // Timestamp rejects Days time unit.
-    let ts_days = Timestamp::new(TimeUnit::Days, Nullability::NonNullable);
-    assert!(
-        ExtScalarValue::<Timestamp>::try_new(&ts_days, ScalarValue::Primitive(PValue::I64(0)))
-            .is_err()
-    );
-
-    // Time in milliseconds rejects values exceeding 24h (86_400_000ms).
-    let time_ms = Time::new(TimeUnit::Milliseconds, Nullability::NonNullable);
-    assert!(
-        ExtScalarValue::<Time>::try_new(&time_ms, ScalarValue::Primitive(PValue::I32(86_400_001)))
-            .is_err()
-    );
-
-    // Time in nanoseconds rejects values exceeding 24h.
-    let time_ns = Time::new(TimeUnit::Nanoseconds, Nullability::NonNullable);
-    let nanos_25h = 25 * 3600 * 1_000_000_000i64;
-    assert!(
-        ExtScalarValue::<Time>::try_new(&time_ns, ScalarValue::Primitive(PValue::I64(nanos_25h)))
-            .is_err()
-    );
-
-    Ok(())
-}
-
-#[test]
-fn erased_display() -> VortexResult<()> {
-    let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable);
-    let storage = ScalarValue::Primitive(PValue::I32(365));
-
-    let erased = ExtScalarValue::<Date>::try_new(&ext_dtype, storage)?.erased();
-    let display = format!("{erased}");
-
-    assert!(display.contains("vortex.date"));
-    assert!(display.contains("365"));
-
-    Ok(())
-}
diff --git a/vortex-array/src/scalar/extension/typed.rs b/vortex-array/src/scalar/extension/typed.rs
deleted file mode 100644
index 953581ad8c7..00000000000
--- a/vortex-array/src/scalar/extension/typed.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::Any;
-use std::fmt;
-use std::sync::Arc;
-
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-
-use crate::dtype::extension::ExtDType;
-use crate::dtype::extension::ExtDTypeRef;
-use crate::dtype::extension::ExtId;
-use crate::dtype::extension::ExtVTable;
-use crate::scalar::ScalarValue;
-use crate::scalar::extension::ExtScalarValueRef;
-
-/// A typed extension scalar value, parameterized by a concrete [`ExtVTable`].
-///
-/// This is the extension scalar analog of [`ExtDType<V>`]: it retains full type information
-/// about the vtable, providing direct access to the vtable and storage value without
-/// downcasting.
-///
-/// You can construct one of these via [`try_new()`] from an [`ExtDType<V>`] and a storage
-/// [`ScalarValue`], and erase the type with [`erased()`] to obtain an [`ExtScalarValueRef`].
-///
-/// [`try_new()`]: ExtScalarValue::try_new
-/// [`erased()`]: ExtScalarValue::erased
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExtScalarValue<V: ExtVTable>(pub(super) Arc<ExtScalarValueInner<V>>);
-
-/// The concrete inner representation of an extension scalar, pairing a vtable with its storage
-/// value.
-///
-/// This is the sole implementor of [`DynExtScalarValue`], enabling [`ExtScalarValueRef`] to
-/// downcast back to the concrete vtable type via [`Any`].
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub(super) struct ExtScalarValueInner<V: ExtVTable> {
-    /// The extension scalar vtable.
-    vtable: V,
-    /// The underlying storage value.
-    storage: ScalarValue,
-}
-
-impl<V: ExtVTable> DynExtScalarValue for ExtScalarValueInner<V> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn id(&self) -> ExtId {
-        self.vtable.id()
-    }
-
-    fn vtable_any(&self) -> &dyn Any {
-        &self.vtable
-    }
-
-    fn storage_value(&self) -> &ScalarValue {
-        &self.storage
-    }
-
-    fn validate(&self, ext_dtype: &ExtDTypeRef) -> VortexResult<()> {
-        // Downcasting the metadata implicitly verifies the vtable types match, but we still want to
-        // validate the actual scalar value.
-        let Some(metadata) = ext_dtype.metadata_opt::<V>() else {
-            vortex_bail!("extension scalar is not compatible with type {ext_dtype}");
-        };
-
-        self.vtable
-            .validate_scalar_value(metadata, ext_dtype.storage_dtype(), &self.storage)
-    }
-
-    fn fmt_ext_scalar_value(
-        &self,
-        ext_dtype: &ExtDTypeRef,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        let value = V::unpack_native(
-            &self.vtable,
-            ext_dtype.metadata::<V>(),
-            ext_dtype.storage_dtype(),
-            &self.storage,
-        )
-        .vortex_expect("invalid extension dtype for this extension scalar value");
-
-        write!(f, "{value}")
-    }
-}
-
-#[expect(
-    dead_code,
-    reason = "TODO(connor): Use this for the `ExtScalar` typed view into Scalar"
-)]
-/// An object-safe, sealed trait encapsulating the behavior for extension scalar values.
-///
-/// This mirrors [`DynExtDType`] in `vortex-dtype`: it provides type-erased access to the
-/// extension scalar's identity, storage value, and display formatting. The only implementor is
-/// [`ExtScalarValueInner`].
-///
-/// [`DynExtDType`]: crate::dtype::extension::DynExtDType
-pub(super) trait DynExtScalarValue: super::sealed::Sealed + 'static + Send + Sync {
-    /// Returns `self` as a trait object for downcasting.
-    fn as_any(&self) -> &dyn Any;
-    /// Returns the [`ExtId`] identifying this extension type.
-    fn id(&self) -> ExtId;
-    /// Returns the vtable as a trait object for downcasting.
-    fn vtable_any(&self) -> &dyn Any;
-    /// Returns a reference to the underlying storage [`ScalarValue`].
-    fn storage_value(&self) -> &ScalarValue;
-    /// Checks whether this extension scalar value is compatible with the given [`ExtDTypeRef`].
-    fn validate(&self, ext_dtype: &ExtDTypeRef) -> VortexResult<()>;
-    /// Formats the extension scalar using the provided [`ExtDTypeRef`] for metadata context.
-    fn fmt_ext_scalar_value(
-        &self,
-        ext_dtype: &ExtDTypeRef,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result;
-}
-
-impl<V: ExtVTable> ExtScalarValue<V> {
-    /// Creates a new extension scalar from a storage [`ScalarValue`], validating it against the
-    /// given [`ExtDType`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if [`ExtVTable::validate_scalar_value`] fails for the given
-    /// storage value and extension dtype.
-    pub fn try_new(ext_dtype: &ExtDType<V>, storage: ScalarValue) -> VortexResult<Self> {
-        ext_dtype.vtable().validate_scalar_value(
-            ext_dtype.metadata(),
-            ext_dtype.storage_dtype(),
-            &storage,
-        )?;
-
-        Ok(Self(Arc::new(ExtScalarValueInner::<V> {
-            vtable: ext_dtype.vtable().clone(),
-            storage,
-        })))
-    }
-
-    /// Erases the concrete type information, returning a type-erased [`ExtScalarValueRef`].
-    pub fn erased(self) -> ExtScalarValueRef {
-        ExtScalarValueRef(self.0)
-    }
-
-    /// Returns the [`ExtId`] identifying this extension scalar's type.
-    pub fn id(&self) -> ExtId {
-        self.0.vtable.id()
-    }
-
-    /// Returns a reference to the [`ExtVTable`] for this extension scalar.
-    pub fn vtable(&self) -> &V {
-        &self.0.vtable
-    }
-
-    /// Returns a reference to the underlying storage [`ScalarValue`].
-    pub fn storage_value(&self) -> &ScalarValue {
-        self.0.storage_value()
-    }
-}
diff --git a/vortex-array/src/scalar/mod.rs b/vortex-array/src/scalar/mod.rs
index 767f5723df3..8496037ea20 100644
--- a/vortex-array/src/scalar/mod.rs
+++ b/vortex-array/src/scalar/mod.rs
@@ -19,6 +19,15 @@ mod convert;
 mod display;
 mod downcast;
 mod proto;
+mod scalar_impl;
+mod scalar_value;
+mod truncation;
+mod typed_view;
+mod validate;
+
+pub use scalar_value::*;
+pub use truncation::*;
+pub use typed_view::*;
 
 use crate::dtype::DType;
 
@@ -37,17 +46,5 @@ pub struct Scalar {
     value: Option<ScalarValue>,
 }
 
-mod scalar_impl;
-mod scalar_value;
-mod typed_view;
-
-pub use scalar_value::*;
-pub use typed_view::*;
-
-pub mod extension;
-
 #[cfg(test)]
 mod tests;
-mod truncation;
-
-pub use truncation::*;
diff --git a/vortex-array/src/scalar/proto.rs b/vortex-array/src/scalar/proto.rs
index 3f4ffe43313..2c45a450bfa 100644
--- a/vortex-array/src/scalar/proto.rs
+++ b/vortex-array/src/scalar/proto.rs
@@ -39,7 +39,7 @@ impl From<&Scalar> for pb::Scalar {
                     .try_into()
                     .vortex_expect("Failed to convert DType to proto"),
             ),
-            value: Some(ScalarValue::to_proto(value.value())),
+            value: Some(Box::new(ScalarValue::to_proto(value.value()))),
         }
     }
 }
@@ -110,6 +110,9 @@ impl From<&ScalarValue> for pb::ScalarValue {
                     kind: Some(Kind::ListValue(ListValue { values })),
                 }
             }
+            ScalarValue::Variant(v) => pb::ScalarValue {
+                kind: Some(Kind::VariantValue(Box::new(pb::Scalar::from(v.as_ref())))),
+            },
         }
     }
 }
@@ -167,8 +170,12 @@ impl Scalar {
     /// # Errors
     ///
     /// Returns an error if type validation fails.
-    pub fn from_proto_value(value: &pb::ScalarValue, dtype: &DType) -> VortexResult<Self> {
-        let scalar_value = ScalarValue::from_proto(value, dtype)?;
+    pub fn from_proto_value(
+        value: &pb::ScalarValue,
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Self> {
+        let scalar_value = ScalarValue::from_proto(value, dtype, session)?;
 
         Scalar::try_new(dtype.clone(), scalar_value)
     }
@@ -192,7 +199,7 @@ impl Scalar {
             .as_ref()
             .ok_or_else(|| vortex_err!(Serde: "Scalar missing value"))?;
 
-        let value: Option<ScalarValue> = ScalarValue::from_proto(pb_scalar_value, &dtype)?;
+        let value: Option<ScalarValue> = ScalarValue::from_proto(pb_scalar_value, &dtype, session)?;
 
         Scalar::try_new(dtype, value)
     }
@@ -207,9 +214,13 @@ impl ScalarValue {
     /// # Errors
     ///
     /// Returns an error if decoding or type validation fails.
-    pub fn from_proto_bytes(bytes: &[u8], dtype: &DType) -> VortexResult<Option<Self>> {
+    pub fn from_proto_bytes(
+        bytes: &[u8],
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Self>> {
         let proto = pb::ScalarValue::decode(bytes)?;
-        Self::from_proto(&proto, dtype)
+        Self::from_proto(&proto, dtype, session)
     }
 
     /// Creates a [`ScalarValue`] from its [protobuf](pb::ScalarValue) representation.
@@ -220,7 +231,11 @@ impl ScalarValue {
     /// # Errors
     ///
     /// Returns an error if the protobuf value cannot be converted to the given [`DType`].
-    pub fn from_proto(value: &pb::ScalarValue, dtype: &DType) -> VortexResult<Option<Self>> {
+    pub fn from_proto(
+        value: &pb::ScalarValue,
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Self>> {
         let kind = value
             .kind
             .as_ref()
@@ -232,18 +247,24 @@ impl ScalarValue {
             _ => dtype,
         };
 
-        Ok(Some(match kind {
-            Kind::NullValue(_) => return Ok(None),
-            Kind::BoolValue(v) => bool_from_proto(*v, dtype)?,
-            Kind::Int64Value(v) => int64_from_proto(*v, dtype)?,
-            Kind::Uint64Value(v) => uint64_from_proto(*v, dtype)?,
-            Kind::F16Value(v) => f16_from_proto(*v, dtype)?,
-            Kind::F32Value(v) => f32_from_proto(*v, dtype)?,
-            Kind::F64Value(v) => f64_from_proto(*v, dtype)?,
-            Kind::StringValue(s) => string_from_proto(s, dtype)?,
-            Kind::BytesValue(b) => bytes_from_proto(b, dtype)?,
-            Kind::ListValue(v) => list_from_proto(v, dtype)?,
-        }))
+        Ok(match kind {
+            Kind::NullValue(_) => None,
+            Kind::BoolValue(v) => Some(bool_from_proto(*v, dtype)?),
+            Kind::Int64Value(v) => Some(int64_from_proto(*v, dtype)?),
+            Kind::Uint64Value(v) => Some(uint64_from_proto(*v, dtype)?),
+            Kind::F16Value(v) => Some(f16_from_proto(*v, dtype)?),
+            Kind::F32Value(v) => Some(f32_from_proto(*v, dtype)?),
+            Kind::F64Value(v) => Some(f64_from_proto(*v, dtype)?),
+            Kind::StringValue(s) => Some(string_from_proto(s, dtype)?),
+            Kind::BytesValue(b) => Some(bytes_from_proto(b, dtype)?),
+            Kind::ListValue(v) => Some(list_from_proto(v, dtype, session)?),
+            Kind::VariantValue(v) => match dtype {
+                DType::Variant(_) => Some(ScalarValue::Variant(Box::new(Scalar::from_proto(
+                    v, session,
+                )?))),
+                _ => vortex_bail!(Serde: "expected non-Variant scalar proto for dtype {dtype}"),
+            },
+        })
     }
 }
 
@@ -373,7 +394,7 @@ fn bytes_from_proto(bytes: &[u8], dtype: &DType) -> VortexResult<ScalarValue> {
     match dtype {
         DType::Utf8(_) => Ok(ScalarValue::Utf8(BufferString::try_from(bytes)?)),
         DType::Binary(_) => Ok(ScalarValue::Binary(ByteBuffer::copy_from(bytes))),
-        // TODO(connor): This is incorrect, we need to verify this matches the `dtype`.
+        // TODO(connor): This is incorrect, we need to verify this matches the inner decimal_dtype.
         DType::Decimal(..) => Ok(ScalarValue::Decimal(match bytes.len() {
             1 => DecimalValue::I8(bytes[0] as i8),
             2 => DecimalValue::I16(i16::from_le_bytes(
@@ -415,14 +436,22 @@ fn bytes_from_proto(bytes: &[u8], dtype: &DType) -> VortexResult<ScalarValue> {
 }
 
 /// Deserialize a [`ScalarValue::List`] from a protobuf `ListValue`.
-fn list_from_proto(v: &ListValue, dtype: &DType) -> VortexResult<ScalarValue> {
+fn list_from_proto(
+    v: &ListValue,
+    dtype: &DType,
+    session: &VortexSession,
+) -> VortexResult<ScalarValue> {
     let element_dtype = dtype
         .as_list_element_opt()
         .ok_or_else(|| vortex_err!(Serde: "expected List dtype for ListValue, got {dtype}"))?;
 
     let mut values = Vec::with_capacity(v.values.len());
     for elem in v.values.iter() {
-        values.push(ScalarValue::from_proto(elem, element_dtype.as_ref())?);
+        values.push(ScalarValue::from_proto(
+            elem,
+            element_dtype.as_ref(),
+            session,
+        )?);
     }
 
     Ok(ScalarValue::List(values))
@@ -576,6 +605,58 @@ mod tests {
         round_trip(Scalar::utf8("hello", Nullability::NonNullable));
     }
 
+    #[test]
+    fn test_variant_scalar_roundtrip() {
+        let nums = Scalar::list(
+            Arc::new(DType::Variant(Nullability::NonNullable)),
+            vec![
+                Scalar::variant(Scalar::primitive(-7_i16, Nullability::NonNullable)),
+                Scalar::variant(Scalar::primitive(42_u32, Nullability::NonNullable)),
+                Scalar::variant(Scalar::decimal(
+                    DecimalValue::I128(123_456_789),
+                    DecimalDType::new(18, 0),
+                    Nullability::NonNullable,
+                )),
+            ],
+            Nullability::NonNullable,
+        );
+
+        let nested = Scalar::list(
+            Arc::new(DType::Variant(Nullability::NonNullable)),
+            vec![
+                Scalar::variant(Scalar::from(true)),
+                Scalar::variant(nums),
+                Scalar::variant(Scalar::binary(
+                    ByteBuffer::copy_from(b"abc"),
+                    Nullability::NonNullable,
+                )),
+                Scalar::variant(Scalar::null(DType::Null)),
+            ],
+            Nullability::NonNullable,
+        );
+
+        round_trip(Scalar::variant(nested));
+    }
+
+    #[test]
+    fn test_variant_scalar_proto_preserves_scalar_null_vs_variant_null() {
+        let scalar_null = Scalar::null(DType::Variant(Nullability::Nullable));
+        let variant_null = Scalar::variant(Scalar::null(DType::Null));
+
+        let scalar_null_pb = pb::Scalar::from(&scalar_null);
+        let variant_null_pb = pb::Scalar::from(&variant_null);
+
+        assert_ne!(scalar_null_pb, variant_null_pb);
+        assert_eq!(
+            Scalar::from_proto(&scalar_null_pb, &session()).unwrap(),
+            scalar_null,
+        );
+        assert_eq!(
+            Scalar::from_proto(&variant_null_pb, &session()).unwrap(),
+            variant_null,
+        );
+    }
+
     #[test]
     fn test_backcompat_f16_serialized_as_u64() {
         // Backwards compatibility test for the legacy f16 serialization format.
@@ -604,6 +685,7 @@ mod tests {
         let scalar_value = ScalarValue::from_proto(
             &pb_scalar_value,
             &DType::Primitive(PType::U64, Nullability::NonNullable),
+            &session(),
         )
         .unwrap();
         assert_eq!(
@@ -615,6 +697,7 @@ mod tests {
         let scalar_value_f16 = ScalarValue::from_proto(
             &pb_scalar_value,
             &DType::Primitive(PType::F16, Nullability::Nullable),
+            &session(),
         )
         .unwrap();
 
@@ -651,6 +734,7 @@ mod tests {
             let read_back = ScalarValue::from_proto(
                 &pb_value,
                 &DType::Primitive(PType::F16, Nullability::NonNullable),
+                &session(),
             )
             .unwrap();
 
@@ -729,7 +813,7 @@ mod tests {
 
         for (name, value, dtype) in exact_roundtrip_cases {
             let pb_value = ScalarValue::to_proto(value.as_ref());
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
+            let read_back = ScalarValue::from_proto(&pb_value, &dtype, &session()).unwrap();
 
             let original_debug = format!("{value:?}");
             let roundtrip_debug = format!("{read_back:?}");
@@ -764,7 +848,7 @@ mod tests {
 
         for (name, value, dtype, expected) in unsigned_cases {
             let pb_value = ScalarValue::to_proto(Some(&value));
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
+            let read_back = ScalarValue::from_proto(&pb_value, &dtype, &session()).unwrap();
 
             match read_back.as_ref() {
                 Some(ScalarValue::Primitive(pv)) => {
@@ -808,7 +892,7 @@ mod tests {
 
         for (name, value, dtype, expected) in signed_cases {
             let pb_value = ScalarValue::to_proto(Some(&value));
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
+            let read_back = ScalarValue::from_proto(&pb_value, &dtype, &session()).unwrap();
 
             match read_back.as_ref() {
                 Some(ScalarValue::Primitive(pv)) => {
@@ -837,7 +921,8 @@ mod tests {
         assert_eq!(
             Scalar::from_proto_value(
                 &pb::ScalarValue::from(&v),
-                &DType::Primitive(PType::U64, Nullability::Nullable)
+                &DType::Primitive(PType::U64, Nullability::Nullable),
+                &session()
             )
             .unwrap(),
             Scalar::primitive(0u64, Nullability::Nullable)
@@ -852,7 +937,8 @@ mod tests {
         assert_eq!(
             Scalar::from_proto_value(
                 &pb::ScalarValue::from(&v),
-                &DType::Primitive(PType::I64, Nullability::Nullable)
+                &DType::Primitive(PType::I64, Nullability::Nullable),
+                &session()
             )
             .unwrap(),
             Scalar::primitive(0i64, Nullability::Nullable)
diff --git a/vortex-array/src/scalar/scalar_impl.rs b/vortex-array/src/scalar/scalar_impl.rs
index 962ad10ad30..edb102fe384 100644
--- a/vortex-array/src/scalar/scalar_impl.rs
+++ b/vortex-array/src/scalar/scalar_impl.rs
@@ -8,35 +8,15 @@ use std::hash::Hash;
 use std::hash::Hasher;
 
 use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
 use vortex_error::vortex_ensure_eq;
 use vortex_error::vortex_panic;
 
 use crate::dtype::DType;
 use crate::dtype::NativeDType;
 use crate::dtype::PType;
-use crate::scalar::PValue;
 use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 
-/// We implement `PartialEq` manually because we want to ignore nullability when comparing scalars.
-/// Two scalars with the same value but different nullability should be considered equal.
-impl PartialEq for Scalar {
-    fn eq(&self, other: &Self) -> bool {
-        self.dtype.eq_ignore_nullability(&other.dtype) && self.value == other.value
-    }
-}
-
-/// We implement `Hash` manually to be consistent with `PartialEq`. Since we ignore nullability
-/// in equality comparisons, we must also ignore it when hashing to maintain the invariant that
-/// equal values have equal hashes.
-impl Hash for Scalar {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.dtype.as_nonnullable().hash(state);
-        self.value.hash(state);
-    }
-}
-
 impl Scalar {
     // Constructors for null scalars.
 
@@ -88,11 +68,7 @@ impl Scalar {
     ///
     /// Returns an error if the given [`DType`] and [`ScalarValue`] are incompatible.
     pub fn try_new(dtype: DType, value: Option<ScalarValue>) -> VortexResult<Self> {
-        vortex_ensure!(
-            Self::is_compatible(&dtype, value.as_ref()),
-            "Incompatible dtype {dtype} with value {}",
-            value.map(|v| format!("{}", v)).unwrap_or_default()
-        );
+        Self::validate(&dtype, value.as_ref())?;
 
         Ok(Self { dtype, value })
     }
@@ -103,13 +79,15 @@ impl Scalar {
     /// # Safety
     ///
     /// The caller must ensure that the given [`DType`] and [`ScalarValue`] are compatible per the
-    /// rules defined in [`Self::is_compatible`].
+    /// rules defined in [`Self::validate`].
     pub unsafe fn new_unchecked(dtype: DType, value: Option<ScalarValue>) -> Self {
-        debug_assert!(
-            Self::is_compatible(&dtype, value.as_ref()),
-            "Incompatible dtype {dtype} with value {}",
-            value.map(|v| format!("{}", v)).unwrap_or_default()
-        );
+        #[cfg(debug_assertions)]
+        {
+            use vortex_error::VortexExpect;
+
+            Self::validate(&dtype, value.as_ref())
+                .vortex_expect("Scalar::new_unchecked called with incompatible dtype and value");
+        }
 
         Self { dtype, value }
     }
@@ -119,104 +97,45 @@ impl Scalar {
     /// For nullable types, this returns a null scalar. For non-nullable and non-nested types, this
     /// returns the zero value for the type.
     ///
+    /// See [`Scalar::zero_value`] for more details about "zero" values.
+    ///
     /// For non-nullable and nested types that may need null values in their children (as of right
     /// now, that is _only_ `FixedSizeList` and `Struct`), this function will provide null default
     /// children.
-    ///
-    /// See [`ScalarValue::zero_value`] for more details about "zero" values.
     pub fn default_value(dtype: &DType) -> Self {
         let value = ScalarValue::default_value(dtype);
+
         // SAFETY: We assume that `default_value` creates a valid `ScalarValue` for the `DType`.
         unsafe { Self::new_unchecked(dtype.clone(), value) }
     }
 
     /// Returns a non-null zero / identity value for the given [`DType`].
     ///
-    /// See [`ScalarValue::zero_value`] for more details about "zero" values.
+    /// # Zero Values
+    ///
+    /// Here is the list of zero values for each [`DType`] (when the [`DType`] is non-nullable):
+    ///
+    /// - `Null`: Does not have a "zero" value
+    /// - `Bool`: `false`
+    /// - `Primitive`: `0`
+    /// - `Decimal`: `0`
+    /// - `Utf8`: `""`
+    /// - `Binary`: An empty buffer
+    /// - `List`: An empty list
+    /// - `FixedSizeList`: A list (with correct size) of zero values, which is determined by the
+    ///   element [`DType`]
+    /// - `Struct`: A struct where each field has a zero value, which is determined by the field
+    ///   [`DType`]
+    /// - `Extension`: The zero value of the storage [`DType`]
     pub fn zero_value(dtype: &DType) -> Self {
         let value = ScalarValue::zero_value(dtype);
+
         // SAFETY: We assume that `zero_value` creates a valid `ScalarValue` for the `DType`.
         unsafe { Self::new_unchecked(dtype.clone(), Some(value)) }
     }
 
     // Other methods.
 
-    /// Check if the given [`ScalarValue`] is compatible with the given [`DType`].
-    pub fn is_compatible(dtype: &DType, value: Option<&ScalarValue>) -> bool {
-        let Some(value) = value else {
-            return dtype.is_nullable();
-        };
-        // From here on, we know that the value is not null.
-
-        match dtype {
-            DType::Null => false,
-            DType::Bool(_) => matches!(value, ScalarValue::Bool(_)),
-            DType::Primitive(ptype, _) => {
-                if let ScalarValue::Primitive(pvalue) = value {
-                    // Note that this is a backwards compatibility check for poor design in the
-                    // previous implementation. `f16` `ScalarValue`s used to be serialized as
-                    // `pb::ScalarValue::Uint64Value(v.to_bits() as u64)`, so we need to ensure that
-                    // we can still represent them as such.
-                    let f16_backcompat_still_works =
-                        matches!(ptype, &PType::F16) && matches!(pvalue, PValue::U64(_));
-
-                    f16_backcompat_still_works || pvalue.ptype() == *ptype
-                } else {
-                    false
-                }
-            }
-            DType::Decimal(dec_dtype, _) => {
-                if let ScalarValue::Decimal(dvalue) = value {
-                    dvalue.fits_in_precision(*dec_dtype)
-                } else {
-                    false
-                }
-            }
-            DType::Utf8(_) => matches!(value, ScalarValue::Utf8(_)),
-            DType::Binary(_) => matches!(value, ScalarValue::Binary(_)),
-            DType::List(elem_dtype, _) => {
-                if let ScalarValue::List(elements) = value {
-                    elements
-                        .iter()
-                        .all(|element| Self::is_compatible(elem_dtype.as_ref(), element.as_ref()))
-                } else {
-                    false
-                }
-            }
-            DType::FixedSizeList(elem_dtype, size, _) => {
-                if let ScalarValue::List(elements) = value {
-                    if elements.len() != *size as usize {
-                        return false;
-                    }
-                    elements
-                        .iter()
-                        .all(|element| Self::is_compatible(elem_dtype.as_ref(), element.as_ref()))
-                } else {
-                    false
-                }
-            }
-            DType::Struct(fields, _) => {
-                if let ScalarValue::List(values) = value {
-                    if values.len() != fields.nfields() {
-                        return false;
-                    }
-                    for (field, field_value) in fields.fields().zip(values.iter()) {
-                        if !Self::is_compatible(&field, field_value.as_ref()) {
-                            return false;
-                        }
-                    }
-                    true
-                } else {
-                    false
-                }
-            }
-            DType::Extension(ext_dtype) => {
-                // TODO(connor): Fix this when adding the correct extension scalars!
-                Self::is_compatible(ext_dtype.storage_dtype(), Some(value))
-            }
-        }
-    }
-
     /// Check if two scalars are equal, ignoring nullability of the [`DType`].
     pub fn eq_ignore_nullability(&self, other: &Self) -> bool {
         self.dtype.eq_ignore_nullability(&other.dtype) && self.value == other.value
@@ -271,6 +190,7 @@ impl Scalar {
             DType::FixedSizeList(_, list_size, _) => value.as_list().len() == *list_size as usize,
             DType::Struct(struct_fields, _) => value.as_list().len() == struct_fields.nfields(),
             DType::Extension(_) => self.as_extension().to_storage_scalar().is_zero()?,
+            DType::Variant(_) => self.as_variant().is_zero()?,
         };
 
         Some(is_zero)
@@ -306,7 +226,7 @@ impl Scalar {
     ///
     /// Note that the protobuf serialization of scalars will likely have a different (but roughly
     /// similar) length.
-    pub fn nbytes(&self) -> usize {
+    pub fn approx_nbytes(&self) -> usize {
         use crate::dtype::NativeDecimalType;
         use crate::dtype::i256;
 
@@ -330,18 +250,31 @@ impl Scalar {
             DType::Struct(..) => self
                 .as_struct()
                 .fields_iter()
-                .map(|fields| fields.into_iter().map(|f| f.nbytes()).sum::<usize>())
+                .map(|fields| fields.into_iter().map(|f| f.approx_nbytes()).sum::<usize>())
                 .unwrap_or_default(),
             DType::List(..) | DType::FixedSizeList(..) => self
                 .as_list()
                 .elements()
-                .map(|fields| fields.into_iter().map(|f| f.nbytes()).sum::<usize>())
+                .map(|fields| fields.into_iter().map(|f| f.approx_nbytes()).sum::<usize>())
                 .unwrap_or_default(),
-            DType::Extension(_) => self.as_extension().to_storage_scalar().nbytes(),
+            DType::Extension(_) => self.as_extension().to_storage_scalar().approx_nbytes(),
+            DType::Variant(_) => self.as_variant().value().map_or(0, Scalar::approx_nbytes),
         }
     }
 }
 
+/// We implement `PartialEq` manually because we want to ignore nullability when comparing scalars.
+/// Two scalars with the same value but different nullability should be considered equal.
+///
+/// Note that this has **different** behavior than the [`PartialOrd`] implementation since the
+/// [`PartialOrd`] returns `None` if the types are different, whereas this `PartialEq`
+/// implementation simply returns `false`.
+impl PartialEq for Scalar {
+    fn eq(&self, other: &Self) -> bool {
+        self.dtype.eq_ignore_nullability(&other.dtype) && self.value == other.value
+    }
+}
+
 impl PartialOrd for Scalar {
     /// Compares two scalar values for ordering.
     ///
@@ -378,3 +311,13 @@ impl PartialOrd for Scalar {
         self.value().partial_cmp(&other.value())
     }
 }
+
+/// We implement `Hash` manually to be consistent with `PartialEq`. Since we ignore nullability
+/// in equality comparisons, we must also ignore it when hashing to maintain the invariant that
+/// equal values have equal hashes.
+impl Hash for Scalar {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.dtype.as_nonnullable().hash(state);
+        self.value.hash(state);
+    }
+}
diff --git a/vortex-array/src/scalar/scalar_value.rs b/vortex-array/src/scalar/scalar_value.rs
index 606a5f29cab..da32bafa947 100644
--- a/vortex-array/src/scalar/scalar_value.rs
+++ b/vortex-array/src/scalar/scalar_value.rs
@@ -14,8 +14,8 @@ use vortex_error::vortex_panic;
 
 use crate::dtype::DType;
 use crate::scalar::DecimalValue;
-// use crate::scalar::ExtScalarValueRef;
 use crate::scalar::PValue;
+use crate::scalar::Scalar;
 
 /// The value stored in a [`Scalar`][crate::scalar::Scalar].
 ///
@@ -35,35 +35,13 @@ pub enum ScalarValue {
     Binary(ByteBuffer),
     /// A list of potentially null scalar values.
     List(Vec<Option<ScalarValue>>),
-    // /// An extension value reference.
-    // ///
-    // /// This internally contains a `ScalarValue` and an vtable that implements
-    // /// [`ExtScalarVTable`](crate::scalar::ExtScalarVTable)
-    // Extension(ExtScalarValueRef),
+    /// A row-specific scalar wrapped by `DType::Variant`.
+    Variant(Box<Scalar>),
 }
 
 impl ScalarValue {
     /// Returns the zero / identity value for the given [`DType`].
-    ///
-    /// # Zero Values
-    ///
-    /// Here is the list of zero values for each [`DType`] (when the [`DType`] is non-nullable):
-    ///
-    /// - `Null`: Does not have a "zero" value
-    /// - `Bool`: `false`
-    /// - `Primitive`: `0`
-    /// - `Decimal`: `0`
-    /// - `Utf8`: `""`
-    /// - `Binary`: An empty buffer
-    /// - `List`: An empty list
-    /// - `FixedSizeList`: A list (with correct size) of zero values, which is determined by the
-    ///   element [`DType`]
-    /// - `Struct`: A struct where each field has a zero value, which is determined by the field
-    ///   [`DType`]
-    ///
-    /// - `Extension`: TODO(connor): Is this right?
-    ///   The zero value of the storage [`DType`]
-    pub fn zero_value(dtype: &DType) -> Self {
+    pub(super) fn zero_value(dtype: &DType) -> Self {
         match dtype {
             DType::Null => vortex_panic!("Null dtype has no zero value"),
             DType::Bool(_) => Self::Bool(false),
@@ -83,7 +61,13 @@ impl ScalarValue {
                     .collect();
                 Self::List(field_values)
             }
-            DType::Extension(ext_dtype) => Self::zero_value(ext_dtype.storage_dtype()), // TODO(connor): Fix this!
+            DType::Extension(ext_dtype) => {
+                // Since we have no way to define a "zero" extension value (since we have no idea
+                // what the semantics of the extension is), a best effort attempt is to just use the
+                // zero storage value and try to make an extension scalar from that.
+                Self::zero_value(ext_dtype.storage_dtype())
+            }
+            DType::Variant(_) => Self::Variant(Box::new(Scalar::null(DType::Null))),
         }
     }
 
@@ -93,7 +77,7 @@ impl ScalarValue {
     /// For non-nullable and nested types that may need null values in their children (as of right
     /// now, that is _only_ `FixedSizeList` and `Struct`), this function will provide `None` as the
     /// default child values (whereas [`ScalarValue::zero_value`] would provide `Some(_)`).
-    pub fn default_value(dtype: &DType) -> Option<Self> {
+    pub(super) fn default_value(dtype: &DType) -> Option<Self> {
         if dtype.is_nullable() {
             return None;
         }
@@ -114,7 +98,13 @@ impl ScalarValue {
                 let field_values = fields.fields().map(|f| Self::default_value(&f)).collect();
                 Self::List(field_values)
             }
-            DType::Extension(ext_dtype) => Self::default_value(ext_dtype.storage_dtype())?, // TODO(connor): Fix this!
+            DType::Extension(ext_dtype) => {
+                // Since we have no way to define a "default" extension value (since we have no idea
+                // what the semantics of the extension is), a best effort attempt is to just use the
+                // default storage value and try to make an extension scalar from that.
+                Self::default_value(ext_dtype.storage_dtype())?
+            }
+            DType::Variant(_) => Self::Variant(Box::new(Scalar::null(DType::Null))),
         })
     }
 }
@@ -128,6 +118,7 @@ impl PartialOrd for ScalarValue {
             (ScalarValue::Utf8(a), ScalarValue::Utf8(b)) => a.partial_cmp(b),
             (ScalarValue::Binary(a), ScalarValue::Binary(b)) => a.partial_cmp(b),
             (ScalarValue::List(a), ScalarValue::List(b)) => a.partial_cmp(b),
+            (ScalarValue::Variant(a), ScalarValue::Variant(b)) => a.partial_cmp(b),
             // (ScalarValue::Extension(a), ScalarValue::Extension(b)) => a.partial_cmp(b),
             _ => None,
         }
@@ -137,9 +128,9 @@ impl PartialOrd for ScalarValue {
 impl Display for ScalarValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ScalarValue::Bool(b) => write!(f, "{}", b),
-            ScalarValue::Primitive(p) => write!(f, "{}", p),
-            ScalarValue::Decimal(d) => write!(f, "{}", d),
+            ScalarValue::Bool(b) => write!(f, "{b}"),
+            ScalarValue::Primitive(p) => write!(f, "{p}"),
+            ScalarValue::Decimal(d) => write!(f, "{d}"),
             ScalarValue::Utf8(s) => {
                 let bufstr = s.as_str();
                 let str_len = bufstr.chars().count();
@@ -177,8 +168,8 @@ impl Display for ScalarValue {
                     }
                 }
                 write!(f, "]")
-            } //
-              // ScalarValue::Extension(e) => write!(f, "{}", e),
+            }
+            ScalarValue::Variant(value) => write!(f, "{value}"),
         }
     }
 }
diff --git a/vortex-array/src/scalar/tests/casting.rs b/vortex-array/src/scalar/tests/casting.rs
index 72b44a5ed55..4e6ecdd60b9 100644
--- a/vortex-array/src/scalar/tests/casting.rs
+++ b/vortex-array/src/scalar/tests/casting.rs
@@ -43,18 +43,12 @@ mod tests {
             Ok(0)
         }
 
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
+        fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
             Ok(())
         }
 
         fn unpack_native<'a>(
-            &self,
-            _metadata: &'a Self::Metadata,
-            _storage_dtype: &'a DType,
+            _ext_dtype: &'a ExtDType<Self>,
             _storage_value: &'a ScalarValue,
         ) -> VortexResult<Self::NativeValue<'a>> {
             Ok("")
@@ -264,18 +258,12 @@ mod tests {
                 vortex_bail!("not implemented")
             }
 
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
+            fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
                 Ok(())
             }
 
             fn unpack_native<'a>(
-                &self,
-                _metadata: &'a Self::Metadata,
-                _storage_dtype: &'a DType,
+                _ext_dtype: &'a ExtDType<Self>,
                 _storage_value: &'a ScalarValue,
             ) -> VortexResult<Self::NativeValue<'a>> {
                 Ok("")
@@ -327,18 +315,12 @@ mod tests {
                 vortex_bail!("not implemented")
             }
 
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
+            fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
                 Ok(())
             }
 
             fn unpack_native<'a>(
-                &self,
-                _metadata: &'a Self::Metadata,
-                _storage_dtype: &'a DType,
+                _ext_dtype: &'a ExtDType<Self>,
                 _storage_value: &'a ScalarValue,
             ) -> VortexResult<Self::NativeValue<'a>> {
                 Ok("")
diff --git a/vortex-array/src/scalar/tests/nested.rs b/vortex-array/src/scalar/tests/nested.rs
index 8116d2ad075..0aadd4ce2c9 100644
--- a/vortex-array/src/scalar/tests/nested.rs
+++ b/vortex-array/src/scalar/tests/nested.rs
@@ -19,14 +19,14 @@ mod tests {
         // Create FixedSizeList[2] of FixedSizeList[3] of I32.
         let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let inner_dtype = Arc::new(DType::FixedSizeList(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             3,
             Nullability::NonNullable,
         ));
 
         // Create inner FixedSizeLists.
         let inner_list1 = Scalar::fixed_size_list(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -87,12 +87,12 @@ mod tests {
         // Create FixedSizeList[2] of variable List of I32.
         let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let inner_dtype = Arc::new(DType::List(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             Nullability::NonNullable,
         ));
 
         let inner_list1 = Scalar::list(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             vec![
                 Scalar::primitive(10i32, Nullability::NonNullable),
                 Scalar::primitive(20i32, Nullability::NonNullable),
@@ -133,13 +133,13 @@ mod tests {
         // Create variable List of FixedSizeList[3] of I32.
         let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let inner_dtype = Arc::new(DType::FixedSizeList(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             3,
             Nullability::NonNullable,
         ));
 
         let fixed_list1 = Scalar::fixed_size_list(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -639,7 +639,7 @@ mod tests {
         ));
 
         let middle_fixed_list_dtype = Arc::new(DType::FixedSizeList(
-            struct_dtype.clone(),
+            Arc::clone(&struct_dtype),
             2,
             Nullability::NonNullable,
         ));
@@ -799,7 +799,7 @@ mod tests {
         ));
 
         let middle_dtype = Arc::new(DType::List(
-            innermost_dtype.clone(),
+            Arc::clone(&innermost_dtype),
             Nullability::NonNullable,
         ));
 
@@ -824,7 +824,7 @@ mod tests {
 
         // Create middle Lists.
         let middle_list1 = Scalar::list(
-            innermost_dtype.clone(),
+            Arc::clone(&innermost_dtype),
             vec![inner_fixed1.clone()],
             Nullability::NonNullable,
         );
@@ -886,7 +886,7 @@ mod tests {
         );
 
         // 2 outer elements * 2 inner elements * 4 bytes (i32) = 16 bytes.
-        assert_eq!(outer.nbytes(), 16);
+        assert_eq!(outer.approx_nbytes(), 16);
     }
 
     // Tests merged from fixed_size_list.rs
@@ -927,7 +927,7 @@ mod tests {
         // Test FixedSizeList[0] behavior.
         let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let empty_fixed_list =
-            Scalar::fixed_size_list(element_dtype.clone(), vec![], Nullability::NonNullable);
+            Scalar::fixed_size_list(Arc::clone(&element_dtype), vec![], Nullability::NonNullable);
 
         assert!(matches!(
             empty_fixed_list.dtype(),
@@ -949,7 +949,7 @@ mod tests {
     fn test_fixed_size_list_cast_to_list() {
         let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let fixed_list = Scalar::fixed_size_list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -985,7 +985,7 @@ mod tests {
     fn test_list_cast_to_fixed_size_list() {
         let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let list = Scalar::list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(10i32, Nullability::NonNullable),
                 Scalar::primitive(20i32, Nullability::NonNullable),
@@ -1022,7 +1022,7 @@ mod tests {
     fn test_fixed_size_list_size_validation() {
         let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let list = Scalar::list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -1032,7 +1032,7 @@ mod tests {
 
         // Try to cast to wrong size - should fail.
         let wrong_size_target =
-            DType::FixedSizeList(element_dtype.clone(), 3, Nullability::NonNullable);
+            DType::FixedSizeList(Arc::clone(&element_dtype), 3, Nullability::NonNullable);
         let result = list.cast(&wrong_size_target);
         assert!(result.is_err());
         assert!(
@@ -1072,7 +1072,7 @@ mod tests {
 
         // Create two equal fixed size lists.
         let list1 = Scalar::fixed_size_list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -1081,7 +1081,7 @@ mod tests {
         );
 
         let list2 = Scalar::fixed_size_list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -1113,7 +1113,7 @@ mod tests {
         // Test FixedSizeList[1].
         let element_dtype = Arc::new(DType::Primitive(PType::I64, Nullability::NonNullable));
         let single_element = Scalar::fixed_size_list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![Scalar::primitive(42i64, Nullability::NonNullable)],
             Nullability::NonNullable,
         );
@@ -1172,7 +1172,7 @@ mod tests {
 
         // FixedSizeList[3] of i32 = 3 * 4 bytes = 12 bytes.
         let fixed_list = Scalar::fixed_size_list(
-            element_dtype.clone(),
+            Arc::clone(&element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
@@ -1180,11 +1180,11 @@ mod tests {
             ],
             Nullability::NonNullable,
         );
-        assert_eq!(fixed_list.nbytes(), 12);
+        assert_eq!(fixed_list.approx_nbytes(), 12);
 
         // Empty FixedSizeList[0] = 0 bytes.
         let empty_list = Scalar::fixed_size_list(element_dtype, vec![], Nullability::NonNullable);
-        assert_eq!(empty_list.nbytes(), 0);
+        assert_eq!(empty_list.approx_nbytes(), 0);
 
         // FixedSizeList with strings.
         let string_list = Scalar::fixed_size_list(
@@ -1195,7 +1195,7 @@ mod tests {
             ],
             Nullability::NonNullable,
         );
-        assert_eq!(string_list.nbytes(), 5);
+        assert_eq!(string_list.approx_nbytes(), 5);
     }
 
     #[test]
diff --git a/vortex-array/src/scalar/tests/nullability.rs b/vortex-array/src/scalar/tests/nullability.rs
index 1f0069436a9..4d2bff418a5 100644
--- a/vortex-array/src/scalar/tests/nullability.rs
+++ b/vortex-array/src/scalar/tests/nullability.rs
@@ -130,11 +130,11 @@ mod tests {
     fn test_scalar_nbytes_with_nulls() {
         // Test null string
         let null_utf8 = Scalar::null(DType::Utf8(Nullability::Nullable));
-        assert_eq!(null_utf8.nbytes(), 0);
+        assert_eq!(null_utf8.approx_nbytes(), 0);
 
         // Test null binary
         let null_binary = Scalar::null(DType::Binary(Nullability::Nullable));
-        assert_eq!(null_binary.nbytes(), 0);
+        assert_eq!(null_binary.approx_nbytes(), 0);
 
         // Test struct with null fields
         let struct_with_null = Scalar::struct_(
@@ -151,7 +151,7 @@ mod tests {
             ],
         );
         // Primitive null fields still count their byte width
-        assert_eq!(struct_with_null.nbytes(), 4 + 8);
+        assert_eq!(struct_with_null.approx_nbytes(), 4 + 8);
 
         // Test list with null elements
         let list_with_null = Scalar::list(
@@ -164,7 +164,7 @@ mod tests {
             Nullability::NonNullable,
         );
         // Primitive null elements still count their byte width
-        assert_eq!(list_with_null.nbytes(), 3 * 4); // 3 i32 values (including null)
+        assert_eq!(list_with_null.approx_nbytes(), 3 * 4); // 3 i32 values (including null)
     }
 
     #[test]
@@ -589,7 +589,10 @@ mod tests {
             Nullability::Nullable,
         ));
 
-        let middle_dtype = Arc::new(DType::List(innermost_dtype.clone(), Nullability::Nullable));
+        let middle_dtype = Arc::new(DType::List(
+            Arc::clone(&innermost_dtype),
+            Nullability::Nullable,
+        ));
 
         // Create innermost FixedSizeLists with different null patterns.
         let inner1 = Scalar::fixed_size_list(
@@ -618,7 +621,7 @@ mod tests {
 
         // Create middle Lists.
         let middle1 = Scalar::list(
-            innermost_dtype.clone(),
+            Arc::clone(&innermost_dtype),
             vec![inner1, inner2],
             Nullability::Nullable,
         );
diff --git a/vortex-array/src/scalar/tests/primitives.rs b/vortex-array/src/scalar/tests/primitives.rs
index fe7278a6b2f..d2e32ce6ef0 100644
--- a/vortex-array/src/scalar/tests/primitives.rs
+++ b/vortex-array/src/scalar/tests/primitives.rs
@@ -60,44 +60,44 @@ mod tests {
     fn test_scalar_nbytes() {
         // Test null scalar - should be 0 bytes
         let null_scalar = Scalar::null(DType::Null);
-        assert_eq!(null_scalar.nbytes(), 0);
+        assert_eq!(null_scalar.approx_nbytes(), 0);
 
         // Test bool scalar - should be 1 byte
         let bool_scalar = Scalar::bool(true, Nullability::NonNullable);
-        assert_eq!(bool_scalar.nbytes(), 1);
+        assert_eq!(bool_scalar.approx_nbytes(), 1);
 
         // Test primitive scalars
         let u8_scalar = Scalar::primitive(42u8, Nullability::NonNullable);
-        assert_eq!(u8_scalar.nbytes(), 1);
+        assert_eq!(u8_scalar.approx_nbytes(), 1);
 
         let u16_scalar = Scalar::primitive(1000u16, Nullability::NonNullable);
-        assert_eq!(u16_scalar.nbytes(), 2);
+        assert_eq!(u16_scalar.approx_nbytes(), 2);
 
         let u32_scalar = Scalar::primitive(100000u32, Nullability::NonNullable);
-        assert_eq!(u32_scalar.nbytes(), 4);
+        assert_eq!(u32_scalar.approx_nbytes(), 4);
 
         let u64_scalar = Scalar::primitive(10000000000u64, Nullability::NonNullable);
-        assert_eq!(u64_scalar.nbytes(), 8);
+        assert_eq!(u64_scalar.approx_nbytes(), 8);
 
         let f32_scalar = Scalar::primitive(3.5f32, Nullability::NonNullable);
-        assert_eq!(f32_scalar.nbytes(), 4);
+        assert_eq!(f32_scalar.approx_nbytes(), 4);
 
         let f64_scalar = Scalar::primitive(3.5f64, Nullability::NonNullable);
-        assert_eq!(f64_scalar.nbytes(), 8);
+        assert_eq!(f64_scalar.approx_nbytes(), 8);
 
         // Test UTF-8 scalar
         let utf8_scalar = Scalar::utf8("hello", Nullability::NonNullable);
-        assert_eq!(utf8_scalar.nbytes(), 5);
+        assert_eq!(utf8_scalar.approx_nbytes(), 5);
 
         let empty_utf8 = Scalar::utf8("", Nullability::NonNullable);
-        assert_eq!(empty_utf8.nbytes(), 0);
+        assert_eq!(empty_utf8.approx_nbytes(), 0);
 
         // Test binary scalar
         let binary_scalar = Scalar::binary(
             ByteBuffer::from(vec![1u8, 2, 3, 4]),
             Nullability::NonNullable,
         );
-        assert_eq!(binary_scalar.nbytes(), 4);
+        assert_eq!(binary_scalar.approx_nbytes(), 4);
 
         // Test struct scalar
         let struct_scalar = Scalar::struct_(
@@ -113,7 +113,7 @@ mod tests {
                 Scalar::primitive(100i64, Nullability::NonNullable),
             ],
         );
-        assert_eq!(struct_scalar.nbytes(), 4 + 8); // i32 + i64
+        assert_eq!(struct_scalar.approx_nbytes(), 4 + 8); // i32 + i64
 
         // Test list scalar
         let list_scalar = Scalar::list(
@@ -125,14 +125,14 @@ mod tests {
             ],
             Nullability::NonNullable,
         );
-        assert_eq!(list_scalar.nbytes(), 3 * 4); // 3 * i32
+        assert_eq!(list_scalar.approx_nbytes(), 3 * 4); // 3 * i32
 
         // Test extension scalar
         let ext_scalar = Scalar::extension::<Date>(
             TimeUnit::Days,
             Scalar::primitive(42i32, Nullability::NonNullable),
         );
-        assert_eq!(ext_scalar.nbytes(), 4); // i32 storage
+        assert_eq!(ext_scalar.approx_nbytes(), 4); // i32 storage
     }
 
     #[test]
@@ -144,7 +144,7 @@ mod tests {
             Nullability::NonNullable,
         );
         assert_eq!(
-            decimal_low_precision.nbytes(),
+            decimal_low_precision.approx_nbytes(),
             16,
             "Decimals with precision <= 38 should be 16 bytes (i128)"
         );
@@ -156,7 +156,7 @@ mod tests {
             Nullability::NonNullable,
         );
         assert_eq!(
-            decimal_high_precision.nbytes(),
+            decimal_high_precision.approx_nbytes(),
             32,
             "Decimals with precision > 38 should be 32 bytes (i256)"
         );
@@ -168,7 +168,7 @@ mod tests {
             Nullability::NonNullable,
         );
         assert_eq!(
-            decimal_p10.nbytes(),
+            decimal_p10.approx_nbytes(),
             16,
             "Decimal with precision 10 should be 16 bytes"
         );
@@ -179,7 +179,7 @@ mod tests {
             Nullability::NonNullable,
         );
         assert_eq!(
-            decimal_p38.nbytes(),
+            decimal_p38.approx_nbytes(),
             16,
             "Decimal with precision 38 should be 16 bytes"
         );
@@ -190,7 +190,7 @@ mod tests {
             Nullability::NonNullable,
         );
         assert_eq!(
-            decimal_p50.nbytes(),
+            decimal_p50.approx_nbytes(),
             32,
             "Decimal with precision 50 should be 32 bytes"
         );
@@ -201,7 +201,7 @@ mod tests {
             Nullability::Nullable,
         ));
         assert_eq!(
-            null_decimal_low.nbytes(),
+            null_decimal_low.approx_nbytes(),
             16,
             "Null decimal with low precision should still report 16 bytes"
         );
@@ -211,7 +211,7 @@ mod tests {
             Nullability::Nullable,
         ));
         assert_eq!(
-            null_decimal_high.nbytes(),
+            null_decimal_high.approx_nbytes(),
             32,
             "Null decimal with high precision should still report 32 bytes"
         );
@@ -221,11 +221,11 @@ mod tests {
     fn test_scalar_nbytes_with_nulls() {
         // Test null string
         let null_utf8 = Scalar::null(DType::Utf8(Nullability::Nullable));
-        assert_eq!(null_utf8.nbytes(), 0);
+        assert_eq!(null_utf8.approx_nbytes(), 0);
 
         // Test null binary
         let null_binary = Scalar::null(DType::Binary(Nullability::Nullable));
-        assert_eq!(null_binary.nbytes(), 0);
+        assert_eq!(null_binary.approx_nbytes(), 0);
 
         // Test struct with null fields
         let struct_with_null = Scalar::struct_(
@@ -242,7 +242,7 @@ mod tests {
             ],
         );
         // Primitive null fields still count their byte width
-        assert_eq!(struct_with_null.nbytes(), 4 + 8);
+        assert_eq!(struct_with_null.approx_nbytes(), 4 + 8);
 
         // Test list with null elements
         let list_with_null = Scalar::list(
@@ -255,7 +255,7 @@ mod tests {
             Nullability::NonNullable,
         );
         // Primitive null elements still count their byte width
-        assert_eq!(list_with_null.nbytes(), 3 * 4); // 3 i32 values (including null)
+        assert_eq!(list_with_null.approx_nbytes(), 3 * 4); // 3 i32 values (including null)
     }
 
     #[test]
diff --git a/vortex-array/src/scalar/tests/round_trip.rs b/vortex-array/src/scalar/tests/round_trip.rs
index 638e29ee909..b3c09248687 100644
--- a/vortex-array/src/scalar/tests/round_trip.rs
+++ b/vortex-array/src/scalar/tests/round_trip.rs
@@ -220,7 +220,10 @@ mod tests {
 
         // Test nested lists
         let inner_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
-        let outer_dtype = Arc::new(DType::List(inner_dtype.clone(), Nullability::NonNullable));
+        let outer_dtype = Arc::new(DType::List(
+            Arc::clone(&inner_dtype),
+            Nullability::NonNullable,
+        ));
 
         let inner_list1 = Scalar::list(
             inner_dtype,
@@ -317,14 +320,14 @@ mod tests {
     #[case::binary_short(Scalar::binary(vec![1u8, 2, 3], Nullability::NonNullable))]
     fn test_nbytes_approx_eq_to_proto_bytes(#[case] scalar: Scalar) {
         let proto_bytes: Vec<u8> = ScalarValue::to_proto_bytes(scalar.value());
-        let diff = (scalar.nbytes() as isize - proto_bytes.len() as isize).abs();
+        let diff = (scalar.approx_nbytes() as isize - proto_bytes.len() as isize).abs();
 
         // NOTE: THE 4 HERE IS COMPLETELY ARBITRARY!!!
         assert!(
             diff <= 4,
             "nbytes() should be within 4 of proto-serialized length for {:?}, got {} vs {}",
             scalar,
-            scalar.nbytes(),
+            scalar.approx_nbytes(),
             proto_bytes.len(),
         );
     }
diff --git a/vortex-array/src/scalar/typed_view/decimal/scalar.rs b/vortex-array/src/scalar/typed_view/decimal/scalar.rs
index 2edf696e509..b0890177f21 100644
--- a/vortex-array/src/scalar/typed_view/decimal/scalar.rs
+++ b/vortex-array/src/scalar/typed_view/decimal/scalar.rs
@@ -78,9 +78,9 @@ impl<'a> DecimalScalar<'a> {
                     );
                 }
 
+                // TODO(connor): Implement proper decimal scaling logic - whatever that means???
                 // Different precision/scale - need to implement scaling logic
                 // For now, we'll do a simple value preservation without scaling
-                // TODO: Implement proper decimal scaling logic
                 if let Some(value) = &self.decimal_value {
                     Ok(Scalar::decimal(*value, *target_dtype, *target_nullability))
                 } else {
diff --git a/vortex-array/src/scalar/typed_view/decimal/tests.rs b/vortex-array/src/scalar/typed_view/decimal/tests.rs
index a0486b254f3..fa6ccfad96b 100644
--- a/vortex-array/src/scalar/typed_view/decimal/tests.rs
+++ b/vortex-array/src/scalar/typed_view/decimal/tests.rs
@@ -125,7 +125,7 @@ fn test_decimal_cast_between_decimal_types() {
         ))
         .unwrap();
 
-    // Value should be preserved (TODO: proper scaling logic)
+    // Value should be preserved (TODO(connor): proper scaling logic - whatever that means???)
     let decimal_value: Option<DecimalValue> = result.try_into().unwrap();
     assert_eq!(decimal_value, Some(DecimalValue::I32(12345)));
 }
diff --git a/vortex-array/src/scalar/typed_view/extension/mod.rs b/vortex-array/src/scalar/typed_view/extension/mod.rs
index bf64f710067..dfbc25f936d 100644
--- a/vortex-array/src/scalar/typed_view/extension/mod.rs
+++ b/vortex-array/src/scalar/typed_view/extension/mod.rs
@@ -3,17 +3,16 @@
 
 //! [`ExtScalar`] typed view implementation.
 
-use std::fmt::Display;
-use std::fmt::Formatter;
+use std::fmt;
 use std::hash::Hash;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_error::vortex_panic;
 
 use crate::dtype::DType;
 use crate::dtype::extension::ExtDTypeRef;
-use crate::extension::datetime::AnyTemporal;
 use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 
@@ -22,89 +21,46 @@ use crate::scalar::ScalarValue;
 /// Extension types allow wrapping a storage type with custom semantics.
 #[derive(Debug, Clone)]
 pub struct ExtScalar<'a> {
-    /// A reference to the `DType` of the extension type. This **must** be the [`DType::Extension`
+    /// A reference to the `DType` of the extension type. This **must** be the [`DType::Extension`]
     /// variant.
     dtype: &'a DType,
 
     /// The extension data type reference.
+    ///
+    /// We store this here as a convenience so that we do not need to unwrap the dtype every time.
     ext_dtype: &'a ExtDTypeRef,
 
     /// The underlying scalar value, or [`None`] if null.
     value: Option<&'a ScalarValue>,
 }
 
-impl Display for ExtScalar<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        // Specialized handling for date/time/timestamp builtin extension types.
-        if let Some(temporal) = self.ext_dtype.metadata_opt::<AnyTemporal>() {
-            let maybe_timestamp = self
-                .to_storage_scalar()
-                .as_primitive()
-                .as_::<i64>()
-                .map(|maybe_timestamp| temporal.to_jiff(maybe_timestamp))
-                .transpose()
-                .map_err(|_| std::fmt::Error)?;
-
-            match maybe_timestamp {
-                None => write!(f, "null"),
-                Some(v) => write!(f, "{v}"),
-            }
-        } else {
-            write!(f, "{}({})", self.ext_dtype().id(), self.to_storage_scalar())
-        }
-    }
-}
-
-impl PartialEq for ExtScalar<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        self.ext_dtype.eq_ignore_nullability(other.ext_dtype)
-            && self.to_storage_scalar() == other.to_storage_scalar()
-    }
-}
-
-impl Eq for ExtScalar<'_> {}
-
-// Ord is not implemented since it's undefined for different Extension DTypes
-impl PartialOrd for ExtScalar<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        if !self.ext_dtype.eq_ignore_nullability(other.ext_dtype) {
-            return None;
-        }
-        self.to_storage_scalar()
-            .partial_cmp(&other.to_storage_scalar())
-    }
-}
+impl fmt::Display for ExtScalar<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Some(value) = self.value else {
+            return write!(f, "null");
+        };
 
-impl Hash for ExtScalar<'_> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.ext_dtype.hash(state);
-        self.to_storage_scalar().hash(state);
+        self.ext_dtype.fmt_storage_value(f, value)
     }
 }
 
 impl<'a> ExtScalar<'a> {
-    // TODO(connor): This should really be validating the data on construction!!!
     /// Creates a new extension scalar from a data type and scalar value.
     ///
-    /// # Errors
+    /// # Safety
     ///
-    /// Returns an error if the data type is not an extension type.
-    pub fn try_new(dtype: &'a DType, value: Option<&'a ScalarValue>) -> VortexResult<Self> {
+    /// The caller must ensure that the dtype is an extension type and that the scalar value has
+    /// been verified to be valid for the extension type.
+    pub(crate) fn new_unchecked(dtype: &'a DType, value: Option<&'a ScalarValue>) -> Self {
         let DType::Extension(ext_dtype) = dtype else {
-            vortex_bail!("Expected extension scalar, found {}", dtype)
+            vortex_panic!("Expected extension scalar, found {}", dtype)
         };
 
-        Ok(Self {
+        Self {
             dtype,
             ext_dtype,
             value,
-        })
-    }
-
-    /// Returns the storage scalar of the extension scalar.
-    pub fn to_storage_scalar(&self) -> Scalar {
-        Scalar::try_new(self.ext_dtype.storage_dtype().clone(), self.value.cloned())
-            .vortex_expect("ExtScalar is invalid")
+        }
     }
 
     /// Return the [`DType`] of the extension scalar.
@@ -117,36 +73,76 @@ impl<'a> ExtScalar<'a> {
         self.ext_dtype
     }
 
+    /// Returns the storage scalar of the extension scalar.
+    pub fn to_storage_scalar(&self) -> Scalar {
+        Scalar::try_new(self.ext_dtype.storage_dtype().clone(), self.value.cloned())
+            .vortex_expect("ExtScalar is invalid")
+    }
+
     /// Casts this scalar to the given `dtype`.
-    pub(crate) fn cast(&self, dtype: &DType) -> VortexResult<Scalar> {
-        if self.value.is_none() && !dtype.is_nullable() {
+    pub(crate) fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        if self.value.is_none() && !target_dtype.is_nullable() {
             vortex_bail!(
                 "cannot cast extension dtype with id {} and storage type {} to {}",
                 self.ext_dtype.id(),
                 self.ext_dtype.storage_dtype(),
-                dtype
+                target_dtype
             );
         }
 
-        if self.ext_dtype.storage_dtype().eq_ignore_nullability(dtype) {
+        if self
+            .ext_dtype
+            .storage_dtype()
+            .eq_ignore_nullability(target_dtype)
+        {
             // Casting from an extension type to the underlying storage type is OK.
-            return Scalar::try_new(dtype.clone(), self.value.cloned());
+            return Scalar::try_new(target_dtype.clone(), self.value.cloned());
         }
 
-        if let DType::Extension(ext_dtype) = dtype
+        // We only allow casting to the same extension dtype for now.
+        if let DType::Extension(ext_dtype) = target_dtype
             && self.ext_dtype.eq_ignore_nullability(ext_dtype)
         {
-            return Scalar::try_new(dtype.clone(), self.value.cloned());
+            return Scalar::try_new(target_dtype.clone(), self.value.cloned());
         }
 
         vortex_bail!(
             "cannot cast extension dtype with id {} and storage type {} to {}",
             self.ext_dtype.id(),
             self.ext_dtype.storage_dtype(),
-            dtype
+            target_dtype
         );
     }
 }
 
+// TODO(connor): In the future we may want to allow implementors to customize this behavior.
+
+impl PartialEq for ExtScalar<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.ext_dtype.eq_ignore_nullability(other.ext_dtype)
+            && self.to_storage_scalar() == other.to_storage_scalar()
+    }
+}
+
+impl Eq for ExtScalar<'_> {}
+
+// Ord is not implemented since it's undefined for different Extension DTypes
+impl PartialOrd for ExtScalar<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        if !self.ext_dtype.eq_ignore_nullability(other.ext_dtype) {
+            return None;
+        }
+        self.to_storage_scalar()
+            .partial_cmp(&other.to_storage_scalar())
+    }
+}
+
+impl Hash for ExtScalar<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ext_dtype.hash(state);
+        self.to_storage_scalar().hash(state);
+    }
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/vortex-array/src/scalar/typed_view/extension/tests.rs b/vortex-array/src/scalar/typed_view/extension/tests.rs
index bff884671a7..5faa9550402 100644
--- a/vortex-array/src/scalar/typed_view/extension/tests.rs
+++ b/vortex-array/src/scalar/typed_view/extension/tests.rs
@@ -11,8 +11,6 @@ use crate::dtype::extension::ExtDType;
 use crate::dtype::extension::ExtId;
 use crate::dtype::extension::ExtVTable;
 use crate::extension::EmptyMetadata;
-use crate::scalar::ExtScalar;
-use crate::scalar::PValue;
 use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 
@@ -34,18 +32,12 @@ impl ExtVTable for TestI32Ext {
         Ok(EmptyMetadata)
     }
 
-    fn validate_dtype(
-        &self,
-        _options: &Self::Metadata,
-        _storage_dtype: &DType,
-    ) -> VortexResult<()> {
+    fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
         Ok(())
     }
 
     fn unpack_native<'a>(
-        &self,
-        _metadata: &'a Self::Metadata,
-        _storage_dtype: &'a DType,
+        _ext_dtype: &'a ExtDType<Self>,
         _storage_value: &'a ScalarValue,
     ) -> VortexResult<Self::NativeValue<'a>> {
         Ok("")
@@ -123,18 +115,12 @@ fn test_ext_scalar_partial_ord_different_types() {
             Ok(EmptyMetadata)
         }
 
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
+        fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
             Ok(())
         }
 
         fn unpack_native<'a>(
-            &self,
-            _metadata: &'a Self::Metadata,
-            _storage_dtype: &'a DType,
+            _ext_dtype: &'a ExtDType<Self>,
             _storage_value: &'a ScalarValue,
         ) -> VortexResult<Self::NativeValue<'a>> {
             Ok("")
@@ -291,15 +277,6 @@ fn test_ext_scalar_cast_null_to_non_nullable() {
     assert!(result.is_err());
 }
 
-#[test]
-fn test_ext_scalar_try_new_non_extension() {
-    let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-    let value = ScalarValue::Primitive(PValue::I32(42));
-
-    let result = ExtScalar::try_new(&dtype, Some(&value));
-    assert!(result.is_err());
-}
-
 #[test]
 fn test_ext_scalar_with_metadata() {
     #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
@@ -320,18 +297,12 @@ fn test_ext_scalar_with_metadata() {
             vortex_bail!("not implemented")
         }
 
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
+        fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
             Ok(())
         }
 
         fn unpack_native<'a>(
-            &self,
-            _metadata: &'a Self::Metadata,
-            _storage_dtype: &'a DType,
+            _ext_dtype: &'a ExtDType<Self>,
             _storage_value: &'a ScalarValue,
         ) -> VortexResult<Self::NativeValue<'a>> {
             Ok("")
diff --git a/vortex-array/src/scalar/typed_view/list.rs b/vortex-array/src/scalar/typed_view/list.rs
index 6c4206f2a0e..3a158dd59ca 100644
--- a/vortex-array/src/scalar/typed_view/list.rs
+++ b/vortex-array/src/scalar/typed_view/list.rs
@@ -340,7 +340,11 @@ mod tests {
             Scalar::primitive(1i32, Nullability::NonNullable),
             Scalar::primitive(2i32, Nullability::NonNullable),
         ];
-        let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable);
+        let list_scalar1 = Scalar::list(
+            Arc::clone(&element_dtype),
+            children1,
+            Nullability::NonNullable,
+        );
 
         let children2 = vec![
             Scalar::primitive(1i32, Nullability::NonNullable),
@@ -361,7 +365,11 @@ mod tests {
             Scalar::primitive(1i32, Nullability::NonNullable),
             Scalar::primitive(2i32, Nullability::NonNullable),
         ];
-        let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable);
+        let list_scalar1 = Scalar::list(
+            Arc::clone(&element_dtype),
+            children1,
+            Nullability::NonNullable,
+        );
 
         let children2 = vec![
             Scalar::primitive(1i32, Nullability::NonNullable),
@@ -380,7 +388,11 @@ mod tests {
         let element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
 
         let children1 = vec![Scalar::primitive(1i32, Nullability::NonNullable)];
-        let list_scalar1 = Scalar::list(element_dtype.clone(), children1, Nullability::NonNullable);
+        let list_scalar1 = Scalar::list(
+            Arc::clone(&element_dtype),
+            children1,
+            Nullability::NonNullable,
+        );
 
         let children2 = vec![Scalar::primitive(2i32, Nullability::NonNullable)];
         let list_scalar2 = Scalar::list(element_dtype, children2, Nullability::NonNullable);
@@ -521,12 +533,12 @@ mod tests {
     fn test_nested_lists() {
         let inner_element_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable));
         let inner_list_dtype = Arc::new(DType::List(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             Nullability::NonNullable,
         ));
 
         let inner_list1 = Scalar::list(
-            inner_element_dtype.clone(),
+            Arc::clone(&inner_element_dtype),
             vec![
                 Scalar::primitive(1i32, Nullability::NonNullable),
                 Scalar::primitive(2i32, Nullability::NonNullable),
diff --git a/vortex-array/src/scalar/typed_view/mod.rs b/vortex-array/src/scalar/typed_view/mod.rs
index 36d3985d63e..639288bd8fc 100644
--- a/vortex-array/src/scalar/typed_view/mod.rs
+++ b/vortex-array/src/scalar/typed_view/mod.rs
@@ -23,6 +23,7 @@ mod list;
 mod primitive;
 mod struct_;
 mod utf8;
+mod variant;
 
 pub use binary::*;
 pub use bool::*;
@@ -32,3 +33,4 @@ pub use list::*;
 pub use primitive::*;
 pub use struct_::*;
 pub use utf8::*;
+pub use variant::*;
diff --git a/vortex-array/src/scalar/typed_view/primitive/numeric_operator.rs b/vortex-array/src/scalar/typed_view/primitive/numeric_operator.rs
index 7150cacfad9..387d6a71cce 100644
--- a/vortex-array/src/scalar/typed_view/primitive/numeric_operator.rs
+++ b/vortex-array/src/scalar/typed_view/primitive/numeric_operator.rs
@@ -6,7 +6,7 @@
 use std::fmt;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-/// Binary element-wise operations on two arrays or two scalars.
+/// Binary element-wise operations.
 pub enum NumericOperator {
     /// Binary element-wise addition of two arrays or of two scalars.
     ///
diff --git a/vortex-array/src/scalar/typed_view/primitive/pvalue.rs b/vortex-array/src/scalar/typed_view/primitive/pvalue.rs
index 333f829eae3..02640d2e416 100644
--- a/vortex-array/src/scalar/typed_view/primitive/pvalue.rs
+++ b/vortex-array/src/scalar/typed_view/primitive/pvalue.rs
@@ -221,6 +221,7 @@ impl PValue {
     }
 
     /// Creates a zero value for the given primitive type.
+    // TODO(joe): use PType
     pub fn zero(ptype: &PType) -> PValue {
         match ptype {
             PType::U8 => PValue::U8(0),
diff --git a/vortex-array/src/scalar/typed_view/struct_.rs b/vortex-array/src/scalar/typed_view/struct_.rs
index acc56e195c4..93b796f055f 100644
--- a/vortex-array/src/scalar/typed_view/struct_.rs
+++ b/vortex-array/src/scalar/typed_view/struct_.rs
@@ -114,7 +114,6 @@ impl Hash for StructScalar<'_> {
 
 impl<'a> StructScalar<'a> {
     /// Creates a new [`StructScalar`] from a [`DType`] and optional [`ScalarValue`].
-    #[inline]
     pub(crate) fn try_new(dtype: &'a DType, value: Option<&'a ScalarValue>) -> VortexResult<Self> {
         if !matches!(dtype, DType::Struct(..)) {
             vortex_bail!("Expected struct scalar, found {}", dtype)
@@ -279,12 +278,13 @@ impl<'a> StructScalar<'a> {
 }
 
 impl Scalar {
-    /// Creates a new struct scalar with the given fields.
-    pub fn struct_(dtype: DType, children: Vec<Scalar>) -> Self {
+    /// Creates a new struct scalar with the given fields, checking dtypes at runtime.
+    pub fn struct_(dtype: DType, children: impl IntoIterator<Item = Scalar>) -> Self {
         let DType::Struct(struct_fields, _) = &dtype else {
             vortex_panic!("Expected struct dtype, found {}", dtype);
         };
 
+        let children: Vec<Scalar> = children.into_iter().collect();
         let field_dtypes = struct_fields.fields();
         if children.len() != field_dtypes.len() {
             vortex_panic!(
@@ -305,12 +305,26 @@ impl Scalar {
             }
         }
 
-        let mut value_children = Vec::with_capacity(children.len());
-        value_children.extend(children.into_iter().map(|x| x.into_value()));
-
+        let value_children: Vec<_> = children.into_iter().map(|x| x.into_value()).collect();
         Self::try_new(dtype, Some(ScalarValue::List(value_children)))
             .vortex_expect("unable to construct a struct `Scalar`")
     }
+
+    /// Creates a new struct scalar from an iterator of field scalars, skipping dtype checks.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure:
+    /// - `dtype` is `DType::Struct`
+    /// - The iterator yields exactly as many scalars as `dtype` has fields
+    /// - Each scalar's dtype matches the corresponding field dtype in `dtype`
+    pub unsafe fn struct_unchecked(
+        dtype: DType,
+        children: impl IntoIterator<Item = Scalar>,
+    ) -> Self {
+        let value_children: Vec<_> = children.into_iter().map(|s| s.into_value()).collect();
+        unsafe { Self::new_unchecked(dtype, Some(ScalarValue::List(value_children))) }
+    }
 }
 
 #[cfg(test)]
diff --git a/vortex-array/src/scalar/typed_view/variant.rs b/vortex-array/src/scalar/typed_view/variant.rs
new file mode 100644
index 00000000000..ced2461e0cf
--- /dev/null
+++ b/vortex-array/src/scalar/typed_view/variant.rs
@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`VariantScalar`] typed view implementation.
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use crate::dtype::DType;
+use crate::scalar::Scalar;
+use crate::scalar::ScalarValue;
+
+/// A typed view into a [`DType::Variant`] scalar.
+#[derive(Debug, Clone, Copy)]
+pub struct VariantScalar<'a> {
+    dtype: &'a DType,
+    value: Option<&'a Scalar>,
+}
+
+impl Display for VariantScalar<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self.value {
+            None => write!(f, "null"),
+            Some(value) => write!(f, "variant({value})"),
+        }
+    }
+}
+
+impl<'a> VariantScalar<'a> {
+    /// Creates a new [`VariantScalar`] from a [`DType`] and optional [`ScalarValue`].
+    #[inline]
+    pub(crate) fn try_new(dtype: &'a DType, value: Option<&'a ScalarValue>) -> VortexResult<Self> {
+        if !matches!(dtype, DType::Variant(_)) {
+            vortex_bail!("Expected variant scalar, found {}", dtype)
+        }
+
+        Ok(Self {
+            dtype,
+            value: value.map(ScalarValue::as_variant),
+        })
+    }
+
+    /// Returns the data type of this variant scalar.
+    #[inline]
+    pub fn dtype(&self) -> &'a DType {
+        self.dtype
+    }
+
+    /// Returns `true` if the outer variant scalar is null.
+    pub fn is_null(&self) -> bool {
+        self.value.is_none()
+    }
+
+    /// Returns the nested row-specific scalar if the outer variant is present.
+    pub fn value(&self) -> Option<&'a Scalar> {
+        self.value
+    }
+
+    /// Returns whether the present variant payload is the variant-null value.
+    ///
+    /// Returns `None` if the outer variant is null.
+    pub fn is_variant_null(&self) -> Option<bool> {
+        Some(self.value?.is_null())
+    }
+
+    /// Returns `Some(true)` if the inner [`Scalar`] is variant-null or has a zero value.
+    pub fn is_zero(&self) -> Option<bool> {
+        let inner = self.value?;
+        if inner.is_null() {
+            Some(true)
+        } else {
+            inner.is_zero()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::scalar::Scalar;
+
+    #[test]
+    fn outer_null_variant_view() {
+        let scalar = Scalar::null(DType::Variant(Nullability::Nullable));
+        let variant = scalar.as_variant();
+
+        assert!(variant.is_null());
+        assert_eq!(variant.is_variant_null(), None);
+        assert!(variant.value().is_none());
+        assert_eq!(scalar.is_zero(), None);
+    }
+
+    #[test]
+    fn present_variant_null_view() {
+        let scalar = Scalar::variant(Scalar::null(DType::Null));
+        let variant = scalar.as_variant();
+
+        assert!(!variant.is_null());
+        assert_eq!(variant.is_variant_null(), Some(true));
+        assert!(variant.value().is_some_and(Scalar::is_null));
+        assert_eq!(scalar.is_zero(), Some(true));
+    }
+
+    #[test]
+    fn present_variant_value_view() {
+        let scalar = Scalar::variant(Scalar::from(42_u32));
+        let variant = scalar.as_variant();
+
+        assert!(!variant.is_null());
+        assert_eq!(variant.is_variant_null(), Some(false));
+        assert_eq!(
+            variant.value().map(ToString::to_string).as_deref(),
+            Some("42u32")
+        );
+        assert_eq!(scalar.is_zero(), Some(false));
+    }
+}
diff --git a/vortex-array/src/scalar/validate.rs b/vortex-array/src/scalar/validate.rs
new file mode 100644
index 00000000000..2696dc1f804
--- /dev/null
+++ b/vortex-array/src/scalar/validate.rs
@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+use crate::dtype::DType;
+use crate::dtype::PType;
+use crate::scalar::PValue;
+use crate::scalar::Scalar;
+use crate::scalar::ScalarValue;
+
+impl Scalar {
+    /// Validate that the given [`ScalarValue`] is compatible with the given [`DType`].
+    pub fn validate(dtype: &DType, value: Option<&ScalarValue>) -> VortexResult<()> {
+        let Some(value) = value else {
+            vortex_ensure!(
+                dtype.is_nullable(),
+                "non-nullable dtype {dtype} cannot hold a null value",
+            );
+            return Ok(());
+        };
+
+        // From here onwards, we know that the value is not null.
+        match dtype {
+            DType::Null => {
+                vortex_bail!("null dtype cannot hold a non-null value {value}");
+            }
+            DType::Bool(_) => {
+                vortex_ensure!(
+                    matches!(value, ScalarValue::Bool(_)),
+                    "bool dtype expected Bool value, got {value}",
+                );
+            }
+            DType::Primitive(ptype, _) => {
+                let ScalarValue::Primitive(pvalue) = value else {
+                    vortex_bail!("primitive dtype {ptype} expected Primitive value, got {value}",);
+                };
+
+                // Note that this is a backwards compatibility check for poor design in the
+                // previous implementation. `f16` `ScalarValue`s used to be serialized as
+                // `pb::ScalarValue::Uint64Value(v.to_bits() as u64)`, so we need to ensure
+                // that we can still represent them as such.
+                let f16_backcompat_still_works =
+                    matches!(ptype, &PType::F16) && matches!(pvalue, PValue::U64(_));
+
+                vortex_ensure!(
+                    f16_backcompat_still_works || pvalue.ptype() == *ptype,
+                    "primitive dtype {ptype} is not compatible with value {pvalue}",
+                );
+            }
+            DType::Decimal(dec_dtype, _) => {
+                let ScalarValue::Decimal(dvalue) = value else {
+                    vortex_bail!("decimal dtype expected Decimal value, got {value}");
+                };
+
+                vortex_ensure!(
+                    dvalue.fits_in_precision(*dec_dtype),
+                    "decimal value {dvalue} does not fit in precision of {dec_dtype}",
+                );
+            }
+            DType::Utf8(_) => {
+                vortex_ensure!(
+                    matches!(value, ScalarValue::Utf8(_)),
+                    "utf8 dtype expected Utf8 value, got {value}",
+                );
+            }
+            DType::Binary(_) => {
+                vortex_ensure!(
+                    matches!(value, ScalarValue::Binary(_)),
+                    "binary dtype expected Binary value, got {value}",
+                );
+            }
+            DType::List(elem_dtype, _) => {
+                let ScalarValue::List(elements) = value else {
+                    vortex_bail!("list dtype expected List value, got {value}");
+                };
+
+                for (i, element) in elements.iter().enumerate() {
+                    Self::validate(elem_dtype.as_ref(), element.as_ref())
+                        .map_err(|e| vortex_error::vortex_err!("list element at index {i}: {e}"))?;
+                }
+            }
+            DType::FixedSizeList(elem_dtype, size, _) => {
+                let ScalarValue::List(elements) = value else {
+                    vortex_bail!("fixed-size list dtype expected List value, got {value}",);
+                };
+
+                let len = elements.len();
+                vortex_ensure_eq!(
+                    len,
+                    *size as usize,
+                    "fixed-size list dtype expected {size} elements, got {len}",
+                );
+
+                for (i, element) in elements.iter().enumerate() {
+                    Self::validate(elem_dtype.as_ref(), element.as_ref()).map_err(|e| {
+                        vortex_error::vortex_err!("fixed-size list element at index {i}: {e}",)
+                    })?;
+                }
+            }
+            DType::Struct(fields, _) => {
+                let ScalarValue::List(values) = value else {
+                    vortex_bail!("struct dtype expected List value, got {value}");
+                };
+
+                let nfields = fields.nfields();
+                let nvalues = values.len();
+                vortex_ensure_eq!(
+                    nvalues,
+                    nfields,
+                    "struct dtype expected {nfields} fields, got {nvalues}",
+                );
+
+                for (field, field_value) in fields.fields().zip(values.iter()) {
+                    Self::validate(&field, field_value.as_ref())?;
+                }
+            }
+            DType::Extension(ext_dtype) => ext_dtype.validate_storage_value(value)?,
+            DType::Variant(_) => {
+                let ScalarValue::Variant(inner) = value else {
+                    vortex_bail!("variant dtype expected Variant value, got {value}");
+                };
+
+                Self::validate(inner.dtype(), inner.value())?;
+                vortex_ensure!(
+                    !inner.is_null() || matches!(inner.dtype(), DType::Null),
+                    "variant nulls must use a nested null scalar, got {}",
+                    inner.dtype(),
+                );
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/scalar_fn/erased.rs b/vortex-array/src/scalar_fn/erased.rs
index 4852475b7f9..154ad13bace 100644
--- a/vortex-array/src/scalar_fn/erased.rs
+++ b/vortex-array/src/scalar_fn/erased.rs
@@ -3,6 +3,7 @@
 
 //! Type-erased scalar function ([`ScalarFnRef`]).
 
+use std::any::type_name;
 use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -12,9 +13,11 @@ use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_err;
 use vortex_utils::debug_with::DebugWith;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::Expression;
 use crate::expr::StatsCatalog;
@@ -33,7 +36,7 @@ use crate::scalar_fn::fns::not::Not;
 use crate::scalar_fn::options::ScalarFnOptions;
 use crate::scalar_fn::signature::ScalarFnSignature;
 use crate::scalar_fn::typed::DynScalarFn;
-use crate::scalar_fn::typed::ScalarFnInner;
+use crate::scalar_fn::typed::ScalarFn;
 
 /// A type-erased scalar function, pairing a vtable with bound options behind a trait object.
 ///
@@ -43,7 +46,7 @@ use crate::scalar_fn::typed::ScalarFnInner;
 /// Use [`super::ScalarFn::new()`] to construct, and [`super::ScalarFn::erased()`] to obtain a
 /// [`ScalarFnRef`].
 #[derive(Clone)]
-pub struct ScalarFnRef(pub(crate) Arc<dyn DynScalarFn>);
+pub struct ScalarFnRef(pub(super) Arc<dyn DynScalarFn>);
 
 impl ScalarFnRef {
     /// Returns the ID of this scalar function.
@@ -53,22 +56,15 @@ impl ScalarFnRef {
 
     /// Returns whether the scalar function is of the given vtable type.
     pub fn is<V: ScalarFnVTable>(&self) -> bool {
-        self.0.as_any().is::<ScalarFnInner<V>>()
+        self.0.as_any().is::<ScalarFn<V>>()
     }
 
     /// Returns the typed options for this scalar function if it matches the given vtable type.
     pub fn as_opt<V: ScalarFnVTable>(&self) -> Option<&V::Options> {
-        self.downcast_inner::<V>().map(|inner| &inner.options)
-    }
-
-    /// Returns a reference to the typed vtable if it matches the given vtable type.
-    pub fn vtable_ref<V: ScalarFnVTable>(&self) -> Option<&V> {
-        self.downcast_inner::<V>().map(|inner| &inner.vtable)
-    }
-
-    /// Downcast the inner to the concrete `ScalarFnInner<V>`.
-    fn downcast_inner<V: ScalarFnVTable>(&self) -> Option<&ScalarFnInner<V>> {
-        self.0.as_any().downcast_ref::<ScalarFnInner<V>>()
+        self.0
+            .as_any()
+            .downcast_ref::<ScalarFn<V>>()
+            .map(|sf| sf.options())
     }
 
     /// Returns the typed options for this scalar function if it matches the given vtable type.
@@ -81,6 +77,40 @@ impl ScalarFnRef {
             .vortex_expect("Expression options type mismatch")
     }
 
+    /// Downcast to the concrete [`ScalarFn`].
+    ///
+    /// Returns `Err(self)` if the downcast fails.
+    pub fn try_downcast<V: ScalarFnVTable>(self) -> Result<Arc<ScalarFn<V>>, ScalarFnRef> {
+        if self.0.as_any().is::<ScalarFn<V>>() {
+            let ptr = Arc::into_raw(self.0) as *const ScalarFn<V>;
+            Ok(unsafe { Arc::from_raw(ptr) })
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Downcast to the concrete [`ScalarFn`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the downcast fails.
+    pub fn downcast<V: ScalarFnVTable>(self) -> Arc<ScalarFn<V>> {
+        self.try_downcast::<V>()
+            .map_err(|this| {
+                vortex_err!(
+                    "Failed to downcast ScalarFnRef {} to {}",
+                    this.0.id(),
+                    type_name::<V>(),
+                )
+            })
+            .vortex_expect("Failed to downcast ScalarFnRef")
+    }
+
+    /// Try to downcast into a typed [`ScalarFn`].
+    pub fn downcast_ref<V: ScalarFnVTable>(&self) -> Option<&ScalarFn<V>> {
+        self.0.as_any().downcast_ref::<ScalarFn<V>>()
+    }
+
     /// The type-erased options for this scalar function.
     pub fn options(&self) -> ScalarFnOptions<'_> {
         ScalarFnOptions { inner: &*self.0 }
@@ -96,6 +126,11 @@ impl ScalarFnRef {
         self.0.return_dtype(arg_types)
     }
 
+    /// Coerce the argument types for this scalar function.
+    pub fn coerce_args(&self, arg_types: &[DType]) -> VortexResult<Vec<DType>> {
+        self.0.coerce_args(arg_types)
+    }
+
     /// Transforms the expression into one representing the validity of this expression.
     pub fn validity(&self, expr: &Expression) -> VortexResult<Expression> {
         Ok(self.0.validity(expr)?.unwrap_or_else(|| {
@@ -109,8 +144,12 @@ impl ScalarFnRef {
     }
 
     /// Execute the expression given the input arguments.
-    pub fn execute(&self, ctx: ExecutionArgs) -> VortexResult<ArrayRef> {
-        self.0.execute(ctx)
+    pub fn execute(
+        &self,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        self.0.execute(args, ctx)
     }
 
     /// Perform abstract reduction on this scalar function node.
diff --git a/vortex-array/src/scalar_fn/fns/between/kernel.rs b/vortex-array/src/scalar_fn/fns/between/kernel.rs
index 55689bfb622..3bf543940c4 100644
--- a/vortex-array/src/scalar_fn/fns/between/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/between/kernel.rs
@@ -7,24 +7,25 @@ use vortex_error::VortexResult;
 use super::Between;
 use super::BetweenOptions;
 use super::precondition;
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
-use crate::vtable::VTable;
 
 /// Reduce rule for between: restructure the array without reading buffers.
 ///
 /// Returns `Ok(None)` if the rule doesn't apply or buffer access is needed.
 pub trait BetweenReduce: VTable {
     fn between(
-        array: &Self::Array,
-        lower: &dyn Array,
-        upper: &dyn Array,
+        array: ArrayView<'_, Self>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
         options: &BetweenOptions,
     ) -> VortexResult<Option<ArrayRef>>;
 }
@@ -34,9 +35,9 @@ pub trait BetweenReduce: VTable {
 /// Returns `Ok(None)` if this kernel cannot handle the given inputs.
 pub trait BetweenKernel: VTable {
     fn between(
-        array: &Self::Array,
-        lower: &dyn Array,
-        upper: &dyn Array,
+        array: ArrayView<'_, Self>,
+        lower: &ArrayRef,
+        upper: &ArrayRef,
         options: &BetweenOptions,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -54,7 +55,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, Between>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -66,9 +67,10 @@ where
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
         let children = scalar_fn_array.children();
-        let lower = children[1].as_ref();
-        let upper = children[2].as_ref();
-        if let Some(result) = precondition(&**array, lower, upper)? {
+        let lower = &children[1];
+        let upper = &children[2];
+        let arr = array.array().clone();
+        if let Some(result) = precondition(&arr, lower, upper)? {
             return Ok(Some(result));
         }
         <V as BetweenReduce>::between(array, lower, upper, parent.options)
@@ -87,7 +89,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, Between>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -100,9 +102,10 @@ where
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
         let children = scalar_fn_array.children();
-        let lower = children[1].as_ref();
-        let upper = children[2].as_ref();
-        if let Some(result) = precondition(&**array, lower, upper)? {
+        let lower = &children[1];
+        let upper = &children[2];
+        let arr = array.array().clone();
+        if let Some(result) = precondition(&arr, lower, upper)? {
             return Ok(Some(result));
         }
         <V as BetweenKernel>::between(array, lower, upper, parent.options, ctx)
diff --git a/vortex-array/src/scalar_fn/fns/between/mod.rs b/vortex-array/src/scalar_fn/fns/between/mod.rs
index 4bb3a6ae49b..aaec8108808 100644
--- a/vortex-array/src/scalar_fn/fns/between/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/between/mod.rs
@@ -3,7 +3,6 @@
 
 mod kernel;
 
-use std::any::Any;
 use std::fmt::Display;
 use std::fmt::Formatter;
 
@@ -11,20 +10,17 @@ pub use kernel::*;
 use prost::Message;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
-use crate::arrays::DecimalVTable;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::Decimal;
+use crate::arrays::Primitive;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::Options;
 use crate::dtype::DType;
 use crate::dtype::DType::Bool;
 use crate::expr::StatsCatalog;
@@ -63,12 +59,6 @@ impl Display for BetweenOptions {
     }
 }
 
-impl Options for BetweenOptions {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
 /// Strictness of the comparison.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum StrictComparison {
@@ -104,9 +94,9 @@ impl StrictComparison {
 /// (empty array, null bounds), or `None` if between should proceed with the
 /// encoding-specific implementation.
 pub(super) fn precondition(
-    arr: &dyn Array,
-    lower: &dyn Array,
-    upper: &dyn Array,
+    arr: &ArrayRef,
+    lower: &ArrayRef,
+    upper: &ArrayRef,
 ) -> VortexResult<Option<ArrayRef>> {
     let return_dtype =
         Bool(arr.dtype().nullability() | lower.dtype().nullability() | upper.dtype().nullability());
@@ -141,9 +131,9 @@ pub(super) fn precondition(
 ///
 /// Falls back to compare + boolean and if no kernel handles the input.
 fn between_canonical(
-    arr: &dyn Array,
-    lower: &dyn Array,
-    upper: &dyn Array,
+    arr: &ArrayRef,
+    lower: &ArrayRef,
+    upper: &ArrayRef,
     options: &BetweenOptions,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
@@ -152,27 +142,26 @@ fn between_canonical(
     }
 
     // Try type-specific kernels
-    if let Some(prim) = arr.as_opt::<PrimitiveVTable>()
+    if let Some(prim) = arr.as_opt::<Primitive>()
         && let Some(result) =
-            <PrimitiveVTable as BetweenKernel>::between(prim, lower, upper, options, ctx)?
+            <Primitive as BetweenKernel>::between(prim, lower, upper, options, ctx)?
     {
         return Ok(result);
     }
-    if let Some(dec) = arr.as_opt::<DecimalVTable>()
-        && let Some(result) =
-            <DecimalVTable as BetweenKernel>::between(dec, lower, upper, options, ctx)?
+    if let Some(dec) = arr.as_opt::<Decimal>()
+        && let Some(result) = <Decimal as BetweenKernel>::between(dec, lower, upper, options, ctx)?
     {
         return Ok(result);
     }
 
     // TODO(joe): return lazy compare once the executor supports this
     // Fall back to compare + boolean and
-    let lower_cmp = lower.to_array().binary(
-        arr.to_array(),
+    let lower_cmp = lower.clone().binary(
+        arr.clone(),
         Operator::from(options.lower_strict.to_compare_operator()),
     )?;
-    let upper_cmp = arr.to_array().binary(
-        upper.to_array(),
+    let upper_cmp = arr.clone().binary(
+        upper.clone(),
         Operator::from(options.upper_strict.to_compare_operator()),
     )?;
     execute_boolean(&lower_cmp, &upper_cmp, Operator::And)
@@ -294,28 +283,26 @@ impl ScalarFnVTable for Between {
         ))
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [arr, lower, upper]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Expected 3 arguments for Between expression",))?;
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let arr = args.get(0)?;
+        let lower = args.get(1)?;
+        let upper = args.get(2)?;
 
         // canonicalize the arr and we might be able to run a between kernels over that.
         if !arr.is_canonical() {
-            return arr.execute::<Canonical>(args.ctx)?.into_array().between(
+            return arr.execute::<Canonical>(ctx)?.into_array().between(
                 lower,
                 upper,
                 options.clone(),
             );
         }
 
-        between_canonical(
-            arr.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
-            options,
-            args.ctx,
-        )
+        between_canonical(&arr, &lower, &upper, options, ctx)
     }
 
     fn stat_falsification(
@@ -411,9 +398,9 @@ mod tests {
         let upper = buffer![2, 1, 1, 0, 0].into_array();
 
         let matches = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict,
                 upper_strict,
@@ -436,12 +423,13 @@ mod tests {
         let upper = ConstantArray::new(
             Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)),
             5,
-        );
+        )
+        .into_array();
 
         let matches = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
@@ -455,11 +443,11 @@ mod tests {
         assert!(indices.is_empty());
 
         // upper is a fixed constant
-        let upper = ConstantArray::new(Scalar::from(2), 5);
+        let upper = ConstantArray::new(Scalar::from(2), 5).into_array();
         let matches = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
@@ -472,12 +460,12 @@ mod tests {
         assert_eq!(indices, vec![0, 1, 3]);
 
         // lower is also a constant
-        let lower = ConstantArray::new(Scalar::from(0), 5);
+        let lower = ConstantArray::new(Scalar::from(0), 5).into_array();
 
         let matches = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
@@ -494,7 +482,7 @@ mod tests {
     fn test_between_decimal() {
         let values = buffer![100i128, 200i128, 300i128, 400i128];
         let decimal_type = DecimalDType::new(3, 2);
-        let array = DecimalArray::new(values, decimal_type, Validity::NonNullable);
+        let array = DecimalArray::new(values, decimal_type, Validity::NonNullable).into_array();
 
         let lower = ConstantArray::new(
             Scalar::decimal(
@@ -503,7 +491,8 @@ mod tests {
                 Nullability::NonNullable,
             ),
             array.len(),
-        );
+        )
+        .into_array();
         let upper = ConstantArray::new(
             Scalar::decimal(
                 DecimalValue::I128(400i128),
@@ -511,13 +500,14 @@ mod tests {
                 Nullability::NonNullable,
             ),
             array.len(),
-        );
+        )
+        .into_array();
 
         // Strict lower bound, non-strict upper bound
         let between_strict = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict: StrictComparison::Strict,
                 upper_strict: StrictComparison::NonStrict,
@@ -532,9 +522,9 @@ mod tests {
 
         // Non-strict lower bound, strict upper bound
         let between_strict = between_canonical(
-            array.as_ref(),
-            lower.as_ref(),
-            upper.as_ref(),
+            &array,
+            &lower,
+            &upper,
             &BetweenOptions {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::Strict,
diff --git a/vortex-array/src/scalar_fn/fns/binary/boolean.rs b/vortex-array/src/scalar_fn/fns/binary/boolean.rs
index 81b7624e77b..57face819e8 100644
--- a/vortex-array/src/scalar_fn/fns/binary/boolean.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/boolean.rs
@@ -6,10 +6,10 @@ use arrow_schema::DataType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::IntoArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrow::FromArrowArray;
 use crate::arrow::IntoArrowArray;
 use crate::builtins::ArrayBuiltins;
@@ -19,14 +19,14 @@ use crate::scalar_fn::fns::operators::Operator;
 
 /// Point-wise Kleene logical _and_ between two Boolean arrays.
 #[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn and_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::And)
+pub fn and_kleene(lhs: &ArrayRef, rhs: &ArrayRef) -> VortexResult<ArrayRef> {
+    lhs.clone().binary(rhs.clone(), Operator::And)
 }
 
 /// Point-wise Kleene logical _or_ between two Boolean arrays.
 #[deprecated(note = "Use `ArrayBuiltins::binary` instead")]
-pub fn or_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
-    lhs.to_array().binary(rhs.to_array(), Operator::Or)
+pub fn or_kleene(lhs: &ArrayRef, rhs: &ArrayRef) -> VortexResult<ArrayRef> {
+    lhs.clone().binary(rhs.clone(), Operator::Or)
 }
 
 /// Execute a Kleene boolean operation between two arrays.
@@ -34,14 +34,14 @@ pub fn or_kleene(lhs: &dyn Array, rhs: &dyn Array) -> VortexResult<ArrayRef> {
 /// This is the entry point for boolean operations from the binary expression.
 /// Handles constant-constant directly, otherwise falls back to Arrow.
 pub(crate) fn execute_boolean(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
     op: Operator,
 ) -> VortexResult<ArrayRef> {
     if let Some(result) = constant_boolean(lhs, rhs, op)? {
         return Ok(result);
     }
-    arrow_execute_boolean(lhs.to_array(), rhs.to_array(), op)
+    arrow_execute_boolean(lhs.clone(), rhs.clone(), op)
 }
 
 /// Arrow implementation for Kleene boolean operations using [`Operator`].
@@ -62,14 +62,11 @@ fn arrow_execute_boolean(lhs: ArrayRef, rhs: ArrayRef, op: Operator) -> VortexRe
 
 /// Constant-folds a boolean operation between two constant arrays.
 fn constant_boolean(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
     op: Operator,
 ) -> VortexResult<Option<ArrayRef>> {
-    let (Some(lhs), Some(rhs)) = (
-        lhs.as_opt::<ConstantVTable>(),
-        rhs.as_opt::<ConstantVTable>(),
-    ) else {
+    let (Some(lhs), Some(rhs)) = (lhs.as_opt::<Constant>(), rhs.as_opt::<Constant>()) else {
         return Ok(None);
     };
 
@@ -100,7 +97,7 @@ fn constant_boolean(
         .map(|b| Scalar::bool(b, nullable.into()))
         .unwrap_or_else(|| Scalar::null(DType::Bool(nullable.into())));
 
-    Ok(Some(ConstantArray::new(scalar, length).to_array()))
+    Ok(Some(ConstantArray::new(scalar, length).into_array()))
 }
 
 #[cfg(test)]
diff --git a/vortex-array/src/scalar_fn/fns/binary/compare.rs b/vortex-array/src/scalar_fn/fns/binary/compare.rs
index 24e29af2935..0108aac6509 100644
--- a/vortex-array/src/scalar_fn/fns/binary/compare.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/compare.rs
@@ -1,31 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::cmp::Ordering;
+
 use arrow_array::BooleanArray;
+use arrow_buffer::NullBuffer;
 use arrow_ord::cmp;
+use arrow_ord::ord::make_comparator;
+use arrow_schema::SortOptions;
 use vortex_error::VortexResult;
+use vortex_error::vortex_err;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::arrow::Datum;
 use crate::arrow::IntoArrowArray;
 use crate::arrow::from_arrow_array_with_len;
-use crate::compute::compare_nested_arrow_arrays;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::kernel::ExecuteParentKernel;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::binary::Binary;
 use crate::scalar_fn::fns::operators::CompareOperator;
-use crate::vtable::VTable;
 
 /// Trait for encoding-specific comparison kernels that operate in encoded space.
 ///
@@ -34,8 +40,8 @@ use crate::vtable::VTable;
 /// the left-hand side, swapping the operator when necessary.
 pub trait CompareKernel: VTable {
     fn compare(
-        lhs: &Self::Array,
-        rhs: &dyn Array,
+        lhs: ArrayView<'_, Self>,
+        rhs: &ArrayRef,
         operator: CompareOperator,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -57,7 +63,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, Binary>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -71,13 +77,11 @@ where
         let Some(scalar_fn_array) = parent.as_opt::<ScalarFnVTable>() else {
             return Ok(None);
         };
-        let children = scalar_fn_array.children();
-
         // Normalize so `array` is always LHS, swapping the operator if needed
         // TODO(joe): should be go this here or in the Rule/Kernel
         let (cmp_op, other) = match child_idx {
-            0 => (cmp_op, &children[1]),
-            1 => (cmp_op.swap(), &children[0]),
+            0 => (cmp_op, scalar_fn_array.get_child(1)),
+            1 => (cmp_op.swap(), scalar_fn_array.get_child(0)),
             _ => return Ok(None),
         };
 
@@ -98,7 +102,7 @@ where
             ));
         }
 
-        V::compare(array, other.as_ref(), cmp_op, ctx)
+        V::compare(array, other, cmp_op, ctx)
     }
 }
 
@@ -107,8 +111,8 @@ where
 /// This is the entry point for compare operations from the binary expression.
 /// Handles empty, constant-null, and constant-constant directly, otherwise falls back to Arrow.
 pub(crate) fn execute_compare(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
     op: CompareOperator,
 ) -> VortexResult<ArrayRef> {
     let nullable = lhs.dtype().is_nullable() || rhs.dtype().is_nullable();
@@ -126,11 +130,9 @@ pub(crate) fn execute_compare(
     }
 
     // Constant-constant fast path
-    if let (Some(lhs_const), Some(rhs_const)) = (
-        lhs.as_opt::<ConstantVTable>(),
-        rhs.as_opt::<ConstantVTable>(),
-    ) {
-        let result = scalar_cmp(lhs_const.scalar(), rhs_const.scalar(), op);
+    if let (Some(lhs_const), Some(rhs_const)) = (lhs.as_opt::<Constant>(), rhs.as_opt::<Constant>())
+    {
+        let result = scalar_cmp(lhs_const.scalar(), rhs_const.scalar(), op)?;
         return Ok(ConstantArray::new(result, lhs.len()).into_array());
     }
 
@@ -139,8 +141,8 @@ pub(crate) fn execute_compare(
 
 /// Fall back to Arrow for comparison.
 fn arrow_compare_arrays(
-    left: &dyn Array,
-    right: &dyn Array,
+    left: &ArrayRef,
+    right: &ArrayRef,
     operator: CompareOperator,
 ) -> VortexResult<ArrayRef> {
     assert_eq!(left.len(), right.len());
@@ -149,9 +151,9 @@ fn arrow_compare_arrays(
 
     // Arrow's vectorized comparison kernels don't support nested types.
     // For nested types, fall back to `make_comparator` which does element-wise comparison.
-    let array: BooleanArray = if left.dtype().is_nested() || right.dtype().is_nested() {
-        let rhs = right.to_array().into_arrow_preferred()?;
-        let lhs = left.to_array().into_arrow(rhs.data_type())?;
+    let arrow_array: BooleanArray = if left.dtype().is_nested() || right.dtype().is_nested() {
+        let rhs = right.clone().into_arrow_preferred()?;
+        let lhs = left.clone().into_arrow(rhs.data_type())?;
 
         assert!(
             lhs.data_type().equals_datatype(rhs.data_type()),
@@ -175,24 +177,67 @@ fn arrow_compare_arrays(
             CompareOperator::Lte => cmp::lt_eq(&lhs, &rhs)?,
         }
     };
-    from_arrow_array_with_len(&array, left.len(), nullable)
+
+    from_arrow_array_with_len(&arrow_array, left.len(), nullable)
 }
 
-pub fn scalar_cmp(lhs: &Scalar, rhs: &Scalar, operator: CompareOperator) -> Scalar {
+pub fn scalar_cmp(lhs: &Scalar, rhs: &Scalar, operator: CompareOperator) -> VortexResult<Scalar> {
     if lhs.is_null() | rhs.is_null() {
-        Scalar::null(DType::Bool(Nullability::Nullable))
-    } else {
-        let b = match operator {
-            CompareOperator::Eq => lhs == rhs,
-            CompareOperator::NotEq => lhs != rhs,
-            CompareOperator::Gt => lhs > rhs,
-            CompareOperator::Gte => lhs >= rhs,
-            CompareOperator::Lt => lhs < rhs,
-            CompareOperator::Lte => lhs <= rhs,
-        };
-
-        Scalar::bool(b, lhs.dtype().nullability() | rhs.dtype().nullability())
+        return Ok(Scalar::null(DType::Bool(Nullability::Nullable)));
     }
+
+    let nullability = lhs.dtype().nullability() | rhs.dtype().nullability();
+
+    // We use `partial_cmp` to ensure we do not lose a type mismatch error.
+    let ordering = lhs.partial_cmp(rhs).ok_or_else(|| {
+        vortex_err!(
+            "Cannot compare scalars with incompatible types: {} and {}",
+            lhs.dtype(),
+            rhs.dtype()
+        )
+    })?;
+
+    let b = match operator {
+        CompareOperator::Eq => ordering.is_eq(),
+        CompareOperator::NotEq => ordering.is_ne(),
+        CompareOperator::Gt => ordering.is_gt(),
+        CompareOperator::Gte => ordering.is_ge(),
+        CompareOperator::Lt => ordering.is_lt(),
+        CompareOperator::Lte => ordering.is_le(),
+    };
+
+    Ok(Scalar::bool(b, nullability))
+}
+
+/// Compare two Arrow arrays element-wise using [`make_comparator`].
+///
+/// This function is required for nested types (Struct, List, FixedSizeList) because Arrow's
+/// vectorized comparison kernels ([`cmp::eq`], [`cmp::neq`], etc.) do not support them.
+///
+/// The vectorized kernels are faster but only work on primitive types, so for non-nested types,
+/// prefer using the vectorized kernels directly for better performance.
+pub fn compare_nested_arrow_arrays(
+    lhs: &dyn arrow_array::Array,
+    rhs: &dyn arrow_array::Array,
+    operator: CompareOperator,
+) -> VortexResult<BooleanArray> {
+    let compare_arrays_at = make_comparator(lhs, rhs, SortOptions::default())?;
+
+    let cmp_fn = match operator {
+        CompareOperator::Eq => Ordering::is_eq,
+        CompareOperator::NotEq => Ordering::is_ne,
+        CompareOperator::Gt => Ordering::is_gt,
+        CompareOperator::Gte => Ordering::is_ge,
+        CompareOperator::Lt => Ordering::is_lt,
+        CompareOperator::Lte => Ordering::is_le,
+    };
+
+    let values = (0..lhs.len())
+        .map(|i| cmp_fn(compare_arrays_at(i, i)))
+        .collect();
+    let nulls = NullBuffer::union(lhs.nulls(), rhs.nulls());
+
+    Ok(BooleanArray::new(values, nulls))
 }
 
 #[cfg(test)]
@@ -206,7 +251,6 @@ mod tests {
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::BoolArray;
-    use crate::arrays::ConstantArray;
     use crate::arrays::ListArray;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
@@ -220,7 +264,13 @@ mod tests {
     use crate::dtype::FieldNames;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
+    use crate::extension::datetime::TimeUnit;
+    use crate::extension::datetime::Timestamp;
+    use crate::extension::datetime::TimestampOptions;
     use crate::scalar::Scalar;
+    use crate::scalar_fn::fns::binary::compare::ConstantArray;
+    use crate::scalar_fn::fns::binary::scalar_cmp;
+    use crate::scalar_fn::fns::operators::CompareOperator;
     use crate::scalar_fn::fns::operators::Operator;
     use crate::test_harness::to_int_indices;
     use crate::validity::Validity;
@@ -235,15 +285,17 @@ mod tests {
         );
 
         let matches = arr
-            .to_array()
-            .binary(arr.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(arr.clone().into_array(), Operator::Eq)
             .unwrap()
             .to_bool();
         assert_eq!(to_int_indices(matches).unwrap(), [1u64, 2, 3, 4]);
 
         let matches = arr
-            .to_array()
-            .binary(arr.to_array(), Operator::NotEq)
+            .clone()
+            .into_array()
+            .binary(arr.clone().into_array(), Operator::NotEq)
             .unwrap()
             .to_bool();
         let empty: [u64; 0] = [];
@@ -255,29 +307,32 @@ mod tests {
         );
 
         let matches = arr
-            .to_array()
-            .binary(other.to_array(), Operator::Lte)
+            .clone()
+            .into_array()
+            .binary(other.clone().into_array(), Operator::Lte)
             .unwrap()
             .to_bool();
         assert_eq!(to_int_indices(matches).unwrap(), [2u64, 3, 4]);
 
         let matches = arr
-            .to_array()
-            .binary(other.to_array(), Operator::Lt)
+            .clone()
+            .into_array()
+            .binary(other.clone().into_array(), Operator::Lt)
             .unwrap()
             .to_bool();
         assert_eq!(to_int_indices(matches).unwrap(), [4u64]);
 
         let matches = other
-            .to_array()
-            .binary(arr.to_array(), Operator::Gte)
+            .clone()
+            .into_array()
+            .binary(arr.clone().into_array(), Operator::Gte)
             .unwrap()
             .to_bool();
         assert_eq!(to_int_indices(matches).unwrap(), [2u64, 3, 4]);
 
         let matches = other
-            .to_array()
-            .binary(arr.to_array(), Operator::Gt)
+            .into_array()
+            .binary(arr.into_array(), Operator::Gt)
             .unwrap()
             .to_bool();
         assert_eq!(to_int_indices(matches).unwrap(), [4u64]);
@@ -289,8 +344,8 @@ mod tests {
         let right = ConstantArray::new(Scalar::from(10u32), 10);
 
         let result = left
-            .to_array()
-            .binary(right.to_array(), Operator::Gt)
+            .into_array()
+            .binary(right.into_array(), Operator::Gt)
             .unwrap();
         assert_eq!(result.len(), 10);
         let scalar = result.scalar_at(0).unwrap();
@@ -330,22 +385,24 @@ mod tests {
         .unwrap();
 
         let result = list1
-            .to_array()
-            .binary(list2.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(list2.clone().into_array(), Operator::Eq)
             .unwrap();
         let expected = BoolArray::from_iter([true, true, false]);
         assert_arrays_eq!(result, expected);
 
         let result = list1
-            .to_array()
-            .binary(list2.to_array(), Operator::NotEq)
+            .clone()
+            .into_array()
+            .binary(list2.clone().into_array(), Operator::NotEq)
             .unwrap();
         let expected = BoolArray::from_iter([false, false, true]);
         assert_arrays_eq!(result, expected);
 
         let result = list1
-            .to_array()
-            .binary(list2.to_array(), Operator::Lt)
+            .into_array()
+            .binary(list2.into_array(), Operator::Lt)
             .unwrap();
         let expected = BoolArray::from_iter([false, false, true]);
         assert_arrays_eq!(result, expected);
@@ -371,8 +428,8 @@ mod tests {
         let constant = ConstantArray::new(list_scalar, 3);
 
         let result = list
-            .to_array()
-            .binary(constant.to_array(), Operator::Eq)
+            .into_array()
+            .binary(constant.into_array(), Operator::Eq)
             .unwrap();
         let expected = BoolArray::from_iter([false, true, false]);
         assert_arrays_eq!(result, expected);
@@ -399,15 +456,16 @@ mod tests {
         .unwrap();
 
         let result = struct1
-            .to_array()
-            .binary(struct2.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(struct2.clone().into_array(), Operator::Eq)
             .unwrap();
         let expected = BoolArray::from_iter([true, true, false]);
         assert_arrays_eq!(result, expected);
 
         let result = struct1
-            .to_array()
-            .binary(struct2.to_array(), Operator::Gt)
+            .into_array()
+            .binary(struct2.into_array(), Operator::Gt)
             .unwrap();
         let expected = BoolArray::from_iter([false, false, true]);
         assert_arrays_eq!(result, expected);
@@ -432,13 +490,42 @@ mod tests {
         .unwrap();
 
         let result = empty1
-            .to_array()
-            .binary(empty2.to_array(), Operator::Eq)
+            .into_array()
+            .binary(empty2.into_array(), Operator::Eq)
             .unwrap();
         let expected = BoolArray::from_iter([true, true, true, true, true]);
         assert_arrays_eq!(result, expected);
     }
 
+    /// Regression test: `scalar_cmp` must error when comparing scalars with incompatible
+    /// extension types (e.g., timestamps with different time units) rather than silently
+    /// returning a wrong result.
+    #[test]
+    fn scalar_cmp_incompatible_extension_types_errors() {
+        let ms_scalar = Scalar::extension::<Timestamp>(
+            TimestampOptions {
+                unit: TimeUnit::Milliseconds,
+                tz: None,
+            },
+            Scalar::from(1704067200000i64),
+        );
+        let s_scalar = Scalar::extension::<Timestamp>(
+            TimestampOptions {
+                unit: TimeUnit::Seconds,
+                tz: None,
+            },
+            Scalar::from(1704067200i64),
+        );
+
+        // Ordering comparisons must error on incompatible types.
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::Gt).is_err());
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::Lt).is_err());
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::Gte).is_err());
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::Lte).is_err());
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::Eq).is_err());
+        assert!(scalar_cmp(&ms_scalar, &s_scalar, CompareOperator::NotEq).is_err());
+    }
+
     #[test]
     fn test_empty_list() {
         let list = ListViewArray::new(
@@ -449,8 +536,9 @@ mod tests {
         );
 
         let result = list
-            .to_array()
-            .binary(list.to_array(), Operator::Eq)
+            .clone()
+            .into_array()
+            .binary(list.into_array(), Operator::Eq)
             .unwrap();
         assert!(result.scalar_at(0).unwrap().is_valid());
         assert!(result.scalar_at(1).unwrap().is_valid());
diff --git a/vortex-array/src/scalar_fn/fns/binary/mod.rs b/vortex-array/src/scalar_fn/fns/binary/mod.rs
index caee06631e6..83385268397 100644
--- a/vortex-array/src/scalar_fn/fns/binary/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/mod.rs
@@ -14,6 +14,7 @@ use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::StatsCatalog;
 use crate::expr::and;
@@ -42,6 +43,8 @@ pub use compare::*;
 mod numeric;
 pub(crate) use numeric::*;
 
+use crate::scalar::NumericOperator;
+
 #[derive(Clone)]
 pub struct Binary;
 
@@ -95,6 +98,20 @@ impl ScalarFnVTable for Binary {
         write!(f, ")")
     }
 
+    fn coerce_args(&self, operator: &Self::Options, args: &[DType]) -> VortexResult<Vec<DType>> {
+        let lhs = &args[0];
+        let rhs = &args[1];
+        if operator.is_arithmetic() || operator.is_comparison() {
+            let supertype = lhs.least_supertype(rhs).ok_or_else(|| {
+                vortex_error::vortex_err!("No common supertype for {} and {}", lhs, rhs)
+            })?;
+            Ok(vec![supertype.clone(), supertype])
+        } else {
+            // Boolean And/Or: no coercion
+            Ok(args.to_vec())
+        }
+    }
+
     fn return_dtype(&self, operator: &Operator, arg_dtypes: &[DType]) -> VortexResult<DType> {
         let lhs = &arg_dtypes[0];
         let rhs = &arg_dtypes[1];
@@ -121,24 +138,28 @@ impl ScalarFnVTable for Binary {
         Ok(DType::Bool((lhs.is_nullable() || rhs.is_nullable()).into()))
     }
 
-    fn execute(&self, op: &Operator, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [lhs, rhs] = &args.inputs[..] else {
-            vortex_bail!("Wrong arg count")
-        };
+    fn execute(
+        &self,
+        op: &Operator,
+        args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let lhs = args.get(0)?;
+        let rhs = args.get(1)?;
 
         match op {
-            Operator::Eq => execute_compare(lhs, rhs, CompareOperator::Eq),
-            Operator::NotEq => execute_compare(lhs, rhs, CompareOperator::NotEq),
-            Operator::Lt => execute_compare(lhs, rhs, CompareOperator::Lt),
-            Operator::Lte => execute_compare(lhs, rhs, CompareOperator::Lte),
-            Operator::Gt => execute_compare(lhs, rhs, CompareOperator::Gt),
-            Operator::Gte => execute_compare(lhs, rhs, CompareOperator::Gte),
-            Operator::And => execute_boolean(lhs, rhs, Operator::And),
-            Operator::Or => execute_boolean(lhs, rhs, Operator::Or),
-            Operator::Add => execute_numeric(lhs, rhs, crate::scalar::NumericOperator::Add),
-            Operator::Sub => execute_numeric(lhs, rhs, crate::scalar::NumericOperator::Sub),
-            Operator::Mul => execute_numeric(lhs, rhs, crate::scalar::NumericOperator::Mul),
-            Operator::Div => execute_numeric(lhs, rhs, crate::scalar::NumericOperator::Div),
+            Operator::Eq => execute_compare(&lhs, &rhs, CompareOperator::Eq),
+            Operator::NotEq => execute_compare(&lhs, &rhs, CompareOperator::NotEq),
+            Operator::Lt => execute_compare(&lhs, &rhs, CompareOperator::Lt),
+            Operator::Lte => execute_compare(&lhs, &rhs, CompareOperator::Lte),
+            Operator::Gt => execute_compare(&lhs, &rhs, CompareOperator::Gt),
+            Operator::Gte => execute_compare(&lhs, &rhs, CompareOperator::Gte),
+            Operator::And => execute_boolean(&lhs, &rhs, Operator::And),
+            Operator::Or => execute_boolean(&lhs, &rhs, Operator::Or),
+            Operator::Add => execute_numeric(&lhs, &rhs, NumericOperator::Add),
+            Operator::Sub => execute_numeric(&lhs, &rhs, NumericOperator::Sub),
+            Operator::Mul => execute_numeric(&lhs, &rhs, NumericOperator::Mul),
+            Operator::Div => execute_numeric(&lhs, &rhs, NumericOperator::Div),
         }
     }
 
@@ -161,7 +182,6 @@ impl ScalarFnVTable for Binary {
         //
         // Non-floating point column and literal expressions should be unaffected as they do not
         // have a nan_count statistic defined.
-        #[inline]
         fn with_nan_predicate(
             lhs: &Expression,
             rhs: &Expression,
@@ -511,4 +531,76 @@ mod tests {
 
         assert_arrays_eq!(result, BoolArray::from_iter([Some(true)]).into_array())
     }
+
+    #[test]
+    fn test_scalar_subtract_unsigned() {
+        use vortex_buffer::buffer;
+
+        use crate::IntoArray;
+        use crate::arrays::ConstantArray;
+        use crate::arrays::PrimitiveArray;
+
+        let values = buffer![1u16, 2, 3].into_array();
+        let rhs = ConstantArray::new(Scalar::from(1u16), 3).into_array();
+        let result = values.binary(rhs, Operator::Sub).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([0u16, 1, 2]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_signed() {
+        use vortex_buffer::buffer;
+
+        use crate::IntoArray;
+        use crate::arrays::ConstantArray;
+        use crate::arrays::PrimitiveArray;
+
+        let values = buffer![1i64, 2, 3].into_array();
+        let rhs = ConstantArray::new(Scalar::from(-1i64), 3).into_array();
+        let result = values.binary(rhs, Operator::Sub).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([2i64, 3, 4]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_nullable() {
+        use crate::IntoArray;
+        use crate::arrays::ConstantArray;
+        use crate::arrays::PrimitiveArray;
+
+        let values = PrimitiveArray::from_option_iter([Some(1u16), Some(2), None, Some(3)]);
+        let rhs = ConstantArray::new(Scalar::from(Some(1u16)), 4).into_array();
+        let result = values.into_array().binary(rhs, Operator::Sub).unwrap();
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(0u16), Some(1), None, Some(2)])
+        );
+    }
+
+    #[test]
+    fn test_scalar_subtract_float() {
+        use vortex_buffer::buffer;
+
+        use crate::IntoArray;
+        use crate::arrays::ConstantArray;
+        use crate::arrays::PrimitiveArray;
+
+        let values = buffer![1.0f64, 2.0, 3.0].into_array();
+        let rhs = ConstantArray::new(Scalar::from(-1f64), 3).into_array();
+        let result = values.binary(rhs, Operator::Sub).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([2.0f64, 3.0, 4.0]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_float_underflow_is_ok() {
+        use vortex_buffer::buffer;
+
+        use crate::IntoArray;
+        use crate::arrays::ConstantArray;
+
+        let values = buffer![f32::MIN, 2.0, 3.0].into_array();
+        let rhs1 = ConstantArray::new(Scalar::from(1.0f32), 3).into_array();
+        let _results = values.binary(rhs1, Operator::Sub).unwrap();
+        let values = buffer![f32::MIN, 2.0, 3.0].into_array();
+        let rhs2 = ConstantArray::new(Scalar::from(f32::MAX), 3).into_array();
+        let _results = values.binary(rhs2, Operator::Sub).unwrap();
+    }
 }
diff --git a/vortex-array/src/scalar_fn/fns/binary/numeric.rs b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
index 6452930c035..360c65ef6a3 100644
--- a/vortex-array/src/scalar_fn/fns/binary/numeric.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
@@ -3,12 +3,12 @@
 
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::IntoArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::compute::arrow_numeric;
+use crate::arrow::Datum;
+use crate::arrow::from_arrow_array_with_len;
 use crate::scalar::NumericOperator;
 
 /// Execute a numeric operation between two arrays.
@@ -16,8 +16,8 @@ use crate::scalar::NumericOperator;
 /// This is the entry point for numeric operations from the binary expression.
 /// Handles constant-constant directly, otherwise falls back to Arrow.
 pub(crate) fn execute_numeric(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
     op: NumericOperator,
 ) -> VortexResult<ArrayRef> {
     if let Some(result) = constant_numeric(lhs, rhs, op)? {
@@ -26,15 +26,34 @@ pub(crate) fn execute_numeric(
     arrow_numeric(lhs, rhs, op)
 }
 
+/// Implementation of numeric operations using the Arrow crate.
+pub(crate) fn arrow_numeric(
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
+    operator: NumericOperator,
+) -> VortexResult<ArrayRef> {
+    let nullable = lhs.dtype().is_nullable() || rhs.dtype().is_nullable();
+    let len = lhs.len();
+
+    let left = Datum::try_new(lhs)?;
+    let right = Datum::try_new_with_target_datatype(rhs, left.data_type())?;
+
+    let array = match operator {
+        NumericOperator::Add => arrow_arith::numeric::add(&left, &right)?,
+        NumericOperator::Sub => arrow_arith::numeric::sub(&left, &right)?,
+        NumericOperator::Mul => arrow_arith::numeric::mul(&left, &right)?,
+        NumericOperator::Div => arrow_arith::numeric::div(&left, &right)?,
+    };
+
+    from_arrow_array_with_len(array.as_ref(), len, nullable)
+}
+
 fn constant_numeric(
-    lhs: &dyn Array,
-    rhs: &dyn Array,
+    lhs: &ArrayRef,
+    rhs: &ArrayRef,
     op: NumericOperator,
 ) -> VortexResult<Option<ArrayRef>> {
-    let (Some(lhs), Some(rhs)) = (
-        lhs.as_opt::<ConstantVTable>(),
-        rhs.as_opt::<ConstantVTable>(),
-    ) else {
+    let (Some(lhs), Some(rhs)) = (lhs.as_opt::<Constant>(), rhs.as_opt::<Constant>()) else {
         return Ok(None);
     };
 
@@ -49,3 +68,72 @@ fn constant_numeric(
 
     Ok(Some(ConstantArray::new(result, lhs.len()).into_array()))
 }
+
+#[cfg(test)]
+#[allow(deprecated)]
+mod test {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::RecursiveCanonical;
+    use crate::VortexSessionExecute;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::builtins::ArrayBuiltins;
+    use crate::scalar::Scalar;
+    use crate::scalar_fn::fns::binary::numeric::ConstantArray;
+    use crate::scalar_fn::fns::operators::Operator;
+
+    fn sub_scalar(array: &ArrayRef, scalar: impl Into<Scalar>) -> VortexResult<ArrayRef> {
+        array
+            .binary(
+                ConstantArray::new(scalar, array.len()).into_array(),
+                Operator::Sub,
+            )
+            .and_then(|a| {
+                a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            })
+            .map(|a| a.0.into_array())
+    }
+
+    #[test]
+    fn test_scalar_subtract_unsigned() {
+        let values = buffer![1u16, 2, 3].into_array();
+        let result = sub_scalar(&values, 1u16).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([0u16, 1, 2]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_signed() {
+        let values = buffer![1i64, 2, 3].into_array();
+        let result = sub_scalar(&values, -1i64).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([2i64, 3, 4]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_nullable() {
+        let values = PrimitiveArray::from_option_iter([Some(1u16), Some(2), None, Some(3)]);
+        let result = sub_scalar(&values.into_array(), Some(1u16)).unwrap();
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(0u16), Some(1), None, Some(2)])
+        );
+    }
+
+    #[test]
+    fn test_scalar_subtract_float() {
+        let values = buffer![1.0f64, 2.0, 3.0].into_array();
+        let result = sub_scalar(&values, -1f64).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([2.0f64, 3.0, 4.0]));
+    }
+
+    #[test]
+    fn test_scalar_subtract_float_underflow_is_ok() {
+        let values = buffer![f32::MIN, 2.0, 3.0].into_array();
+        let _results = sub_scalar(&values, 1.0f32).unwrap();
+        let _results = sub_scalar(&values, f32::MAX).unwrap();
+    }
+}
diff --git a/vortex-array/src/scalar_fn/fns/case_when.rs b/vortex-array/src/scalar_fn/fns/case_when.rs
index 164dba0e174..f30a17ee580 100644
--- a/vortex-array/src/scalar_fn/fns/case_when.rs
+++ b/vortex-array/src/scalar_fn/fns/case_when.rs
@@ -1,20 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! CASE WHEN expression for conditional value selection.
+//! SQL-style CASE WHEN: evaluates `(condition, value)` pairs in order and returns
+//! the value from the first matching condition (first-match-wins). NULL conditions
+//! are treated as false. If no ELSE clause is provided, unmatched rows produce NULL;
+//! otherwise they get the ELSE value.
 //!
-//! This expression evaluates a series of WHEN conditions and returns the corresponding
-//! THEN value for the first condition that evaluates to true. If no conditions match
-//! and an ELSE clause is provided, the ELSE value is returned; otherwise, NULL is returned.
-//!
-//! # Structure
-//!
-//! The expression has children in the following order:
-//! - pairs of (condition, value) for each WHEN/THEN clause
-//! - optionally, a final ELSE value
-//!
-//! For example, `CASE WHEN a THEN 1 WHEN b THEN 2 ELSE 3 END` has children:
-//! `[a, 1, b, 2, 3]`
+//! Unlike SQL which coerces all branches to a common supertype, all THEN/ELSE
+//! branches must share the same base dtype (ignoring nullability). The result
+//! nullability is the union of all branches (forced nullable if no ELSE).
 
 use std::fmt;
 use std::fmt::Formatter;
@@ -22,38 +16,49 @@ use std::hash::Hash;
 use std::sync::Arc;
 
 use prost::Message;
-use vortex_dtype::DType;
-use vortex_dtype::Nullability;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_mask::AllOr;
+use vortex_mask::Mask;
 use vortex_proto::expr as pb;
-use vortex_scalar::Scalar;
-use vortex_vector::Datum;
-use vortex_vector::VectorOps;
+use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
 use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
-use crate::compute::zip;
-use crate::expr::Arity;
-use crate::expr::ChildName;
-use crate::expr::ExecutionArgs;
-use crate::expr::ExprId;
-use crate::expr::VTable;
-use crate::expr::VTableExt;
-use crate::expr::expression::Expression;
-
-/// Options for the CaseWhen expression.
+use crate::arrays::bool::BoolArrayExt;
+use crate::builders::ArrayBuilder;
+use crate::builders::builder_with_capacity;
+use crate::builtins::ArrayBuiltins;
+use crate::dtype::DType;
+use crate::expr::Expression;
+use crate::scalar::Scalar;
+use crate::scalar_fn::Arity;
+use crate::scalar_fn::ChildName;
+use crate::scalar_fn::ExecutionArgs;
+use crate::scalar_fn::ScalarFnId;
+use crate::scalar_fn::ScalarFnVTable;
+use crate::scalar_fn::fns::zip::zip_impl;
+
+/// Options for the n-ary CaseWhen expression.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct CaseWhenOptions {
-    /// Number of WHEN/THEN pairs (each pair contributes 2 children)
+    /// Number of WHEN/THEN pairs.
     pub num_when_then_pairs: u32,
-    /// Whether an ELSE clause is present (contributes 1 child at the end)
+    /// Whether an ELSE clause is present.
+    /// If false, unmatched rows return NULL.
     pub has_else: bool,
 }
 
+impl CaseWhenOptions {
+    /// Total number of child expressions: 2 per WHEN/THEN pair, plus 1 if ELSE is present.
+    pub fn num_children(&self) -> usize {
+        self.num_when_then_pairs as usize * 2 + usize::from(self.has_else)
+    }
+}
+
 impl fmt::Display for CaseWhenOptions {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
@@ -64,61 +69,61 @@ impl fmt::Display for CaseWhenOptions {
     }
 }
 
-/// A CASE WHEN expression.
+/// An n-ary CASE WHEN expression.
 ///
-/// Evaluates conditions in order and returns the value corresponding to the
-/// first matching condition.
+/// Children are in order: `[when_0, then_0, when_1, then_1, ..., else?]`.
+#[derive(Clone)]
 pub struct CaseWhen;
 
-impl VTable for CaseWhen {
+impl ScalarFnVTable for CaseWhen {
     type Options = CaseWhenOptions;
 
-    fn id(&self) -> ExprId {
-        ExprId::from("vortex.case_when")
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.case_when")
     }
 
-    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(
-            pb::CaseWhenOpts {
-                num_when_then_pairs: options.num_when_then_pairs,
-                has_else: options.has_else,
-            }
-            .encode_to_vec(),
-        ))
+    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        // let num_children = options.num_when_then_pairs * 2 + u32::from(options.has_else);
+        // Ok(Some(pb::CaseWhenOpts { num_children }.encode_to_vec()))
+        // stabilize the expr
+        vortex_bail!("cannot serialize")
     }
 
-    fn deserialize(&self, metadata: &[u8]) -> VortexResult<Self::Options> {
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
         let opts = pb::CaseWhenOpts::decode(metadata)?;
+        if opts.num_children < 2 {
+            vortex_bail!(
+                "CaseWhen expects at least 2 children, got {}",
+                opts.num_children
+            );
+        }
         Ok(CaseWhenOptions {
-            num_when_then_pairs: opts.num_when_then_pairs,
-            has_else: opts.has_else,
+            num_when_then_pairs: opts.num_children / 2,
+            has_else: opts.num_children % 2 == 1,
         })
     }
 
     fn arity(&self, options: &Self::Options) -> Arity {
-        let num_children =
-            options.num_when_then_pairs as usize * 2 + if options.has_else { 1 } else { 0 };
-        Arity::Exact(num_children)
+        Arity::Exact(options.num_children())
     }
 
     fn child_name(&self, options: &Self::Options, child_idx: usize) -> ChildName {
-        let pair_count = options.num_when_then_pairs as usize;
-        let num_when_then_children = pair_count * 2;
-
-        if child_idx < num_when_then_children {
+        let num_pair_children = options.num_when_then_pairs as usize * 2;
+        if child_idx < num_pair_children {
             let pair_idx = child_idx / 2;
-            if child_idx % 2 == 0 {
-                ChildName::from(Arc::from(format!("when_{}", pair_idx)))
+            if child_idx.is_multiple_of(2) {
+                ChildName::from(Arc::from(format!("when_{pair_idx}")))
             } else {
-                ChildName::from(Arc::from(format!("then_{}", pair_idx)))
+                ChildName::from(Arc::from(format!("then_{pair_idx}")))
             }
-        } else if options.has_else && child_idx == num_when_then_children {
+        } else if options.has_else && child_idx == num_pair_children {
             ChildName::from("else")
         } else {
-            unreachable!(
-                "Invalid child index {} for CaseWhen expression with {} pairs",
-                child_idx, pair_count
-            )
+            unreachable!("Invalid child index {} for CaseWhen", child_idx)
         }
     }
 
@@ -145,316 +150,219 @@ impl VTable for CaseWhen {
     }
 
     fn return_dtype(&self, options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
-        // The return dtype is based on the THEN expressions
         if options.num_when_then_pairs == 0 {
             vortex_bail!("CaseWhen must have at least one WHEN/THEN pair");
         }
 
-        // Get the first THEN expression's dtype (index 1)
-        let first_then_dtype = &arg_dtypes[1];
+        let expected_len = options.num_children();
+        if arg_dtypes.len() != expected_len {
+            vortex_bail!(
+                "CaseWhen expects {expected_len} argument dtypes, got {}",
+                arg_dtypes.len()
+            );
+        }
 
-        // If there's no ELSE, the result is always nullable (unmatched rows are NULL)
-        if !options.has_else {
-            Ok(first_then_dtype.as_nullable())
+        // Unlike SQL which coerces all branches to a common supertype, we require
+        // all THEN/ELSE branches to have the same base dtype (ignoring nullability).
+        // The result nullability is the union of all branches.
+        let first_then = &arg_dtypes[1];
+        let mut result_dtype = first_then.clone();
+
+        for i in 1..options.num_when_then_pairs as usize {
+            let then_i = &arg_dtypes[i * 2 + 1];
+            if !first_then.eq_ignore_nullability(then_i) {
+                vortex_bail!(
+                    "CaseWhen THEN dtypes must match (ignoring nullability), got {} and {}",
+                    first_then,
+                    then_i
+                );
+            }
+            result_dtype = result_dtype.union_nullability(then_i.nullability());
+        }
+
+        if options.has_else {
+            let else_dtype = &arg_dtypes[options.num_when_then_pairs as usize * 2];
+            if !result_dtype.eq_ignore_nullability(else_dtype) {
+                vortex_bail!(
+                    "CaseWhen THEN and ELSE dtypes must match (ignoring nullability), got {} and {}",
+                    first_then,
+                    else_dtype
+                );
+            }
+            result_dtype = result_dtype.union_nullability(else_dtype.nullability());
         } else {
-            Ok(first_then_dtype.clone())
+            // No ELSE means unmatched rows are NULL
+            result_dtype = result_dtype.as_nullable();
         }
+
+        Ok(result_dtype)
     }
 
-    fn evaluate(
+    fn execute(
         &self,
         options: &Self::Options,
-        expr: &Expression,
-        scope: &ArrayRef,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<ArrayRef> {
-        use vortex_buffer::BitBuffer;
-        use vortex_mask::Mask;
-
-        use crate::compute::filter;
-
-        let len = scope.len();
-
-        // Determine output dtype from first THEN expression
-        let output_dtype = expr.child(1).return_dtype(scope.dtype())?;
-        let else_idx = options.num_when_then_pairs as usize * 2;
-
-        // Track which rows have matched a condition (using BitBuffer for boolean ops)
-        let mut matched_bits = BitBuffer::new_unset(len);
-
-        // Start with null result - we'll fill in values as conditions match
-        let mut result: ArrayRef =
-            ConstantArray::new(Scalar::null(output_dtype.as_nullable()), len).into_array();
+        // Inspired by https://datafusion.apache.org/blog/2026/02/02/datafusion_case/
+        //
+        // TODO: shrink input to `remaining` rows between WHEN iterations (batch reduction).
+        // TODO: project to only referenced columns before batch reduction (column projection).
+        // TODO: evaluate THEN/ELSE on compact matching/non-matching rows and scatter-merge the results.
+        // TODO: for constant WHEN/THEN values, compile to a hash table for a single-pass lookup.
+        let row_count = args.row_count();
+        let num_pairs = options.num_when_then_pairs as usize;
+
+        let mut remaining = Mask::new_true(row_count);
+        let mut branches: Vec<(Mask, ArrayRef)> = Vec::with_capacity(num_pairs);
+
+        for i in 0..num_pairs {
+            if remaining.all_false() {
+                break;
+            }
 
-        // Process when/then pairs in order (first match wins)
-        for i in 0..options.num_when_then_pairs as usize {
-            // Evaluate condition
-            let cond = expr.child(i * 2).evaluate(scope)?;
-            let cond_bool = cond.to_bool();
+            let condition = args.get(i * 2)?;
+            let cond_bool = condition.execute::<BoolArray>(ctx)?;
             let cond_mask = cond_bool.to_mask_fill_null_false();
-            let cond_bits = cond_mask.to_bit_buffer();
+            let effective_mask = &remaining & &cond_mask;
 
-            // Compute which rows match THIS condition AND haven't matched a previous one
-            // effective_cond = cond AND NOT(already_matched)
-            let effective_bits = &cond_bits & &(!&matched_bits);
-            let effective_mask = Mask::from_buffer(effective_bits.clone());
-
-            // Short-circuit: skip THEN evaluation if no rows match this condition
             if effective_mask.all_false() {
                 continue;
             }
 
-            // Evaluate THEN expression
-            let then_val = if effective_mask.all_true() {
-                // All rows match - safe to evaluate on full scope
-                expr.child(i * 2 + 1).evaluate(scope)?
-            } else {
-                // Filter scope to only matching rows, evaluate, then scatter back
-                let filtered_scope = filter(scope, &effective_mask)?;
-                let filtered_result = expr.child(i * 2 + 1).evaluate(&filtered_scope)?;
-
-                // Scatter the filtered result back using builder
-                scatter_with_mask(&filtered_result, &effective_mask, &output_dtype, len)?
-            };
-
-            // Merge into result: use zip to overlay then_val where effective_mask is true
-            result = zip(&then_val, &result, &effective_mask)?;
-
-            // Update matched_bits
-            matched_bits = &matched_bits | &effective_bits;
-
-            // Short-circuit: if all rows have matched, we're done
-            if matched_bits.true_count() == len {
-                break;
-            }
+            let then_value = args.get(i * 2 + 1)?;
+            remaining = remaining.bitand_not(&cond_mask);
+            branches.push((effective_mask, then_value));
         }
 
-        // Handle ELSE clause for unmatched rows
-        let unmatched_bits = !&matched_bits;
-        let unmatched_mask = Mask::from_buffer(unmatched_bits);
-
-        if !unmatched_mask.all_false() {
-            let else_val = if options.has_else {
-                // Evaluate ELSE for unmatched rows
-                if unmatched_mask.all_true() {
-                    expr.child(else_idx).evaluate(scope)?
-                } else {
-                    let filtered_scope = filter(scope, &unmatched_mask)?;
-                    let filtered_else = expr.child(else_idx).evaluate(&filtered_scope)?;
-                    scatter_with_mask(&filtered_else, &unmatched_mask, &output_dtype, len)?
-                }
-            } else {
-                // No ELSE - unmatched rows stay null (already set in result)
-                return Ok(result);
-            };
+        let else_value: ArrayRef = if options.has_else {
+            args.get(num_pairs * 2)?
+        } else {
+            let then_dtype = args.get(1)?.dtype().as_nullable();
+            ConstantArray::new(Scalar::null(then_dtype), row_count).into_array()
+        };
 
-            result = zip(&else_val, &result, &unmatched_mask)?;
+        if branches.is_empty() {
+            return Ok(else_value);
         }
 
-        Ok(result)
+        merge_case_branches(branches, else_value)
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<Datum> {
-        let row_count = args.row_count;
-        let mut datums = args.datums;
-
-        // Check if all inputs are scalars (for returning scalar result)
-        let all_scalars = datums.iter().all(|d| matches!(d, Datum::Scalar(_)));
-
-        // Collect when/then pairs from datums
-        let mut when_then_pairs = Vec::with_capacity(options.num_when_then_pairs as usize);
-        for i in 0..options.num_when_then_pairs as usize {
-            let cond = datums[i * 2].clone();
-            let then_val = datums[i * 2 + 1].clone();
-            when_then_pairs.push((cond, then_val));
-        }
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        true
+    }
 
-        // Get the else value if present
-        let else_value = options.has_else.then(|| {
-            let else_idx = options.num_when_then_pairs as usize * 2;
-            datums.remove(else_idx)
-        });
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
 
-        // Determine output dtype from return_dtype
-        let output_dtype = args.return_dtype;
+/// Average run length at which slicing + `extend_from_array` becomes cheaper than `scalar_at`.
+/// Measured empirically via benchmarks.
+const SLICE_CROSSOVER_RUN_LEN: usize = 4;
 
-        // Create the result by starting from the else value or null
-        let mut result: Datum = if let Some(else_val) = else_value {
-            else_val
-        } else {
-            // Create a null scalar of the output dtype, which will be repeated as needed
-            use vortex_vector::Scalar as VScalar;
-            Datum::Scalar(VScalar::null(&output_dtype))
-        };
+/// Merges disjoint `(mask, then_value)` branch pairs with an `else_value` into a single array.
+///
+/// Branch masks are guaranteed disjoint by the remaining-row tracking in [`CaseWhen::execute`].
+fn merge_case_branches(
+    branches: Vec<(Mask, ArrayRef)>,
+    else_value: ArrayRef,
+) -> VortexResult<ArrayRef> {
+    if branches.len() == 1 {
+        let (mask, then_value) = &branches[0];
+        return zip_impl(then_value, &else_value, mask);
+    }
 
-        // Process when/then pairs in reverse order
-        // For each (condition, then_value), we select from then_value where condition is true
-        for (cond, then_val) in when_then_pairs.into_iter().rev() {
-            result = execute_zip(then_val, result, cond, row_count, &output_dtype)?;
+    let output_nullability = branches
+        .iter()
+        .fold(else_value.dtype().nullability(), |acc, (_, arr)| {
+            acc | arr.dtype().nullability()
+        });
+    let output_dtype = else_value.dtype().with_nullability(output_nullability);
+    let branch_arrays: Vec<&ArrayRef> = branches.iter().map(|(_, arr)| arr).collect();
+
+    let mut spans: Vec<(usize, usize, usize)> = Vec::new();
+    for (branch_idx, (mask, _)) in branches.iter().enumerate() {
+        match mask.slices() {
+            AllOr::All => return branch_arrays[branch_idx].cast(output_dtype),
+            AllOr::None => {}
+            AllOr::Some(slices) => {
+                for &(start, end) in slices {
+                    spans.push((start, end, branch_idx));
+                }
+            }
         }
+    }
+    spans.sort_unstable_by_key(|&(start, ..)| start);
 
-        // If all inputs were scalars and result is still length 1, return as scalar
-        if all_scalars
-            && let Datum::Vector(v) = &result
-            && v.len() == 1
-        {
-            return Ok(Datum::Scalar(v.scalar_at(0)));
-        }
+    if spans.is_empty() {
+        return else_value.cast(output_dtype);
+    }
 
-        Ok(result)
+    let builder = builder_with_capacity(&output_dtype, else_value.len());
+
+    let fragmented = spans.len() > else_value.len() / SLICE_CROSSOVER_RUN_LEN;
+    if fragmented {
+        merge_row_by_row(&branch_arrays, &else_value, &spans, &output_dtype, builder)
+    } else {
+        merge_run_by_run(&branch_arrays, &else_value, &spans, &output_dtype, builder)
     }
 }
 
-/// Helper function to perform zip operation on Datum values.
-/// Selects from `if_true` where `condition` is true, otherwise from `if_false`.
-fn execute_zip(
-    if_true: Datum,
-    if_false: Datum,
-    condition: Datum,
-    row_count: usize,
+/// Iterates spans directly, emitting one `scalar_at` per row.
+/// Zero per-run allocations; preferred for fragmented masks (avg run < [`SLICE_CROSSOVER_RUN_LEN`]).
+fn merge_row_by_row(
+    branch_arrays: &[&ArrayRef],
+    else_value: &ArrayRef,
+    spans: &[(usize, usize, usize)],
     output_dtype: &DType,
-) -> VortexResult<Datum> {
-    use vortex_mask::Mask;
-    use vortex_vector::BoolDatum;
-
-    use crate::LEGACY_SESSION;
-    use crate::VectorExecutor;
-    use crate::vectors::VectorIntoArray;
-
-    let cond_bool = condition.into_bool();
-
-    // Convert condition to Mask using the same pattern as evaluate()
-    let mask = match cond_bool {
-        BoolDatum::Scalar(s) => {
-            let value = s.value().unwrap_or(false); // NULL treated as false
-            Mask::new(row_count, value)
+    mut builder: Box<dyn ArrayBuilder>,
+) -> VortexResult<ArrayRef> {
+    let mut pos = 0;
+    for &(start, end, branch_idx) in spans {
+        for row in pos..start {
+            let scalar = else_value.scalar_at(row)?;
+            builder.append_scalar(&scalar.cast(output_dtype)?)?;
         }
-        BoolDatum::Vector(v) => {
-            // Convert to BoolArray and use to_mask_fill_null_false() for DRY
-            let bool_dtype = DType::Bool(Nullability::Nullable);
-            let bool_array: BoolArray = v.into_array(&bool_dtype);
-            bool_array.to_mask_fill_null_false()
+        for row in start..end {
+            let scalar = branch_arrays[branch_idx].scalar_at(row)?;
+            builder.append_scalar(&scalar.cast(output_dtype)?)?;
         }
-    };
-
-    // Short-circuit: if mask is all true, return if_true; if all false, return if_false
-    if mask.all_true() {
-        return Ok(if_true);
+        pos = end;
     }
-    if mask.all_false() {
-        return Ok(if_false);
+    for row in pos..else_value.len() {
+        let scalar = else_value.scalar_at(row)?;
+        builder.append_scalar(&scalar.cast(output_dtype)?)?;
     }
 
-    // Convert datums to vectors for zip
-    let true_vector = if_true.unwrap_into_vector(row_count);
-    let false_vector = if_false.unwrap_into_vector(row_count);
-
-    // Convert vectors to arrays for zip operation
-    let true_array = true_vector.into_array(output_dtype);
-    let false_array = false_vector.into_array(output_dtype);
-
-    // Perform zip
-    let result_array = zip(&true_array, &false_array, &mask)?;
-
-    // Convert back to vector
-    let result_vector = result_array.execute_vector(&LEGACY_SESSION)?;
-
-    Ok(Datum::Vector(result_vector))
-}
-
-/// Creates a CASE WHEN expression with an ELSE clause.
-///
-/// The children should be provided as: condition1, then1, condition2, then2, ..., else_value
-///
-/// # Example
-/// ```ignore
-/// // CASE WHEN x > 0 THEN 'positive' WHEN x < 0 THEN 'negative' ELSE 'zero' END
-/// case_when(vec![
-///     gt(col("x"), lit(0)), lit("positive"),
-///     lt(col("x"), lit(0)), lit("negative"),
-///     lit("zero"),
-/// ])
-/// ```
-pub fn case_when<I: IntoIterator<Item = Expression>>(children: I) -> Expression {
-    let children: Vec<_> = children.into_iter().collect();
-    let num_children = children.len();
-
-    // Must have odd number of children (pairs + else)
-    assert!(
-        num_children >= 3 && num_children % 2 == 1,
-        "case_when requires at least one when/then pair and an else: got {} children",
-        num_children
-    );
-
-    #[allow(clippy::cast_possible_truncation)]
-    let num_when_then_pairs = ((num_children - 1) / 2) as u32;
-    let options = CaseWhenOptions {
-        num_when_then_pairs,
-        has_else: true,
-    };
-
-    CaseWhen.new_expr(options, children)
-}
-
-/// Creates a CASE WHEN expression without an ELSE clause (returns NULL when no conditions match).
-///
-/// The children should be provided as: condition1, then1, condition2, then2, ...
-///
-/// # Example
-/// ```ignore
-/// // CASE WHEN x > 0 THEN 'positive' WHEN x < 0 THEN 'negative' END
-/// // (returns NULL when x = 0)
-/// case_when_no_else(vec![
-///     gt(col("x"), lit(0)), lit("positive"),
-///     lt(col("x"), lit(0)), lit("negative"),
-/// ])
-/// ```
-pub fn case_when_no_else<I: IntoIterator<Item = Expression>>(children: I) -> Expression {
-    let children: Vec<_> = children.into_iter().collect();
-    let num_children = children.len();
-
-    // Must have even number of children (pairs only)
-    assert!(
-        num_children >= 2 && num_children % 2 == 0,
-        "case_when_no_else requires at least one when/then pair: got {} children",
-        num_children
-    );
-
-    #[allow(clippy::cast_possible_truncation)]
-    let num_when_then_pairs = (num_children / 2) as u32;
-    let options = CaseWhenOptions {
-        num_when_then_pairs,
-        has_else: false,
-    };
-
-    CaseWhen.new_expr(options, children)
+    Ok(builder.finish())
 }
 
-/// Scatter values from a filtered (shorter) array back to their original positions.
-/// The mask indicates which positions in the output should receive values from the source.
-/// Positions where mask is false will be null.
-fn scatter_with_mask(
-    source: &ArrayRef,
-    mask: &vortex_mask::Mask,
-    dtype: &DType,
-    output_len: usize,
+/// Bulk-copies each span via `slice()` + `extend_from_array`.
+/// Preferred when runs are long enough that memcpy dominates over per-slice allocation cost.
+/// Lazy cast via `arr.cast(output_dtype)` is executed once per span as a block.
+fn merge_run_by_run(
+    branch_arrays: &[&ArrayRef],
+    else_value: &ArrayRef,
+    spans: &[(usize, usize, usize)],
+    output_dtype: &DType,
+    mut builder: Box<dyn ArrayBuilder>,
 ) -> VortexResult<ArrayRef> {
-    use crate::builders::builder_with_capacity;
-
-    let nullable_dtype = dtype.as_nullable();
-    let mut builder = builder_with_capacity(&nullable_dtype, output_len);
-    let mut source_idx = 0;
-
-    for i in 0..output_len {
-        if mask.value(i) {
-            // Copy value from source, casting to nullable if needed
-            let scalar = source.scalar_at(source_idx);
-            let nullable_scalar = scalar.cast(&nullable_dtype)?;
-            builder.append_scalar(&nullable_scalar)?;
-            source_idx += 1;
-        } else {
-            // Insert null
-            builder.append_null();
+    let else_value = else_value.cast(output_dtype.clone())?;
+    let len = else_value.len();
+    for (start, end, branch_idx) in spans {
+        if builder.len() < *start {
+            builder.extend_from_array(&else_value.slice(builder.len()..*start)?);
         }
+        builder.extend_from_array(
+            &branch_arrays[*branch_idx]
+                .cast(output_dtype.clone())?
+                .slice(*start..*end)?,
+        );
+    }
+    if builder.len() < len {
+        builder.extend_from_array(&else_value.slice(builder.len()..len)?);
     }
 
     Ok(builder.finish())
@@ -462,52 +370,78 @@ fn scatter_with_mask(
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use vortex_buffer::buffer;
-    use vortex_dtype::DType;
-    use vortex_dtype::Nullability;
-    use vortex_dtype::PType;
     use vortex_error::VortexExpect as _;
-    use vortex_scalar::Scalar;
+    use vortex_session::VortexSession;
 
     use super::*;
+    use crate::Canonical;
     use crate::IntoArray;
-    use crate::ToCanonical;
+    use crate::VortexSessionExecute as _;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
-    use crate::expr::exprs::binary::eq;
-    use crate::expr::exprs::binary::gt;
-    use crate::expr::exprs::get_item::col;
-    use crate::expr::exprs::get_item::get_item;
-    use crate::expr::exprs::literal::lit;
-    use crate::expr::exprs::root::root;
+    use crate::assert_arrays_eq;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    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::lit;
+    use crate::expr::nested_case_when;
+    use crate::expr::root;
     use crate::expr::test_harness;
+    use crate::scalar::Scalar;
+    use crate::session::ArraySession;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    /// Helper to evaluate an expression using the apply+execute pattern
+    fn evaluate_expr(expr: &Expression, array: &ArrayRef) -> ArrayRef {
+        let mut ctx = SESSION.create_execution_ctx();
+        array
+            .clone()
+            .apply(expr)
+            .unwrap()
+            .execute::<Canonical>(&mut ctx)
+            .unwrap()
+            .into_array()
+    }
 
     // ==================== Serialization Tests ====================
 
     #[test]
+    #[should_panic(expected = "cannot serialize")]
     fn test_serialization_roundtrip() {
         let options = CaseWhenOptions {
-            num_when_then_pairs: 2,
+            num_when_then_pairs: 1,
             has_else: true,
         };
-
         let serialized = CaseWhen.serialize(&options).unwrap().unwrap();
-        let deserialized = CaseWhen.deserialize(&serialized).unwrap();
-
+        let deserialized = CaseWhen
+            .deserialize(&serialized, &VortexSession::empty())
+            .unwrap();
         assert_eq!(options, deserialized);
     }
 
     #[test]
+    #[should_panic(expected = "cannot serialize")]
     fn test_serialization_no_else() {
         let options = CaseWhenOptions {
-            num_when_then_pairs: 3,
+            num_when_then_pairs: 1,
             has_else: false,
         };
-
         let serialized = CaseWhen.serialize(&options).unwrap().unwrap();
-        let deserialized = CaseWhen.deserialize(&serialized).unwrap();
-
+        let deserialized = CaseWhen
+            .deserialize(&serialized, &VortexSession::empty())
+            .unwrap();
         assert_eq!(options, deserialized);
     }
 
@@ -515,12 +449,7 @@ mod tests {
 
     #[test]
     fn test_display_with_else() {
-        // CASE WHEN col > 0 THEN 100 ELSE 0 END
-        let condition = gt(col("value"), lit(0i32));
-        let then_val = lit(100i32);
-        let else_val = lit(0i32);
-
-        let expr = case_when([condition, then_val, else_val]);
+        let expr = case_when(gt(col("value"), lit(0i32)), lit(100i32), lit(0i32));
         let display = format!("{}", expr);
         assert!(display.contains("CASE"));
         assert!(display.contains("WHEN"));
@@ -531,11 +460,7 @@ mod tests {
 
     #[test]
     fn test_display_no_else() {
-        // CASE WHEN col > 0 THEN 100 END
-        let condition = gt(col("value"), lit(0i32));
-        let then_val = lit(100i32);
-
-        let expr = case_when_no_else([condition, then_val]);
+        let expr = case_when_no_else(gt(col("value"), lit(0i32)), lit(100i32));
         let display = format!("{}", expr);
         assert!(display.contains("CASE"));
         assert!(display.contains("WHEN"));
@@ -545,16 +470,17 @@ mod tests {
     }
 
     #[test]
-    fn test_display_multiple_conditions() {
-        let expr = case_when([
-            gt(col("x"), lit(10i32)),
-            lit("high"),
-            gt(col("x"), lit(5i32)),
-            lit("medium"),
-            lit("low"),
-        ]);
+    fn test_display_nested_nary() {
+        // CASE WHEN x > 10 THEN 'high' WHEN x > 5 THEN 'medium' ELSE 'low' END
+        let expr = nested_case_when(
+            vec![
+                (gt(col("x"), lit(10i32)), lit("high")),
+                (gt(col("x"), lit(5i32)), lit("medium")),
+            ],
+            Some(lit("low")),
+        );
         let display = format!("{}", expr);
-        // Should contain two WHEN clauses
+        assert_eq!(display.matches("CASE").count(), 1);
         assert_eq!(display.matches("WHEN").count(), 2);
         assert_eq!(display.matches("THEN").count(), 2);
     }
@@ -563,14 +489,9 @@ mod tests {
 
     #[test]
     fn test_return_dtype_with_else() {
-        let condition = lit(true);
-        let then_val = lit(100i32);
-        let else_val = lit(0i32);
-
-        let expr = case_when([condition, then_val, else_val]);
+        let expr = case_when(lit(true), lit(100i32), lit(0i32));
         let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let result_dtype = expr.return_dtype(&input_dtype).unwrap();
-        // With else, result dtype matches the then expression
         assert_eq!(
             result_dtype,
             DType::Primitive(PType::I32, Nullability::NonNullable)
@@ -578,14 +499,28 @@ mod tests {
     }
 
     #[test]
-    fn test_return_dtype_without_else_is_nullable() {
-        let condition = lit(true);
-        let then_val = lit(100i32);
+    fn test_return_dtype_with_nullable_else() {
+        let expr = case_when(
+            lit(true),
+            lit(100i32),
+            lit(Scalar::null(DType::Primitive(
+                PType::I32,
+                Nullability::Nullable,
+            ))),
+        );
+        let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result_dtype = expr.return_dtype(&input_dtype).unwrap();
+        assert_eq!(
+            result_dtype,
+            DType::Primitive(PType::I32, Nullability::Nullable)
+        );
+    }
 
-        let expr = case_when_no_else([condition, then_val]);
+    #[test]
+    fn test_return_dtype_without_else_is_nullable() {
+        let expr = case_when_no_else(lit(true), lit(100i32));
         let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let result_dtype = expr.return_dtype(&input_dtype).unwrap();
-        // Without else, result is always nullable
         assert_eq!(
             result_dtype,
             DType::Primitive(PType::I32, Nullability::Nullable)
@@ -595,14 +530,11 @@ mod tests {
     #[test]
     fn test_return_dtype_with_struct_input() {
         let dtype = test_harness::struct_dtype();
-
-        // CASE WHEN $.col1 > 10 THEN 100 ELSE 0 END
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("col1", root()), lit(10u16)),
             lit(100i32),
             lit(0i32),
-        ]);
-
+        );
         let result_dtype = expr.return_dtype(&dtype).unwrap();
         assert_eq!(
             result_dtype,
@@ -610,59 +542,166 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_return_dtype_mismatched_then_else_errors() {
+        let expr = case_when(lit(true), lit(100i32), lit("zero"));
+        let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let err = expr.return_dtype(&input_dtype).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("THEN and ELSE dtypes must match (ignoring nullability)")
+        );
+    }
+
     // ==================== Arity Tests ====================
 
     #[test]
     fn test_arity_with_else() {
         let options = CaseWhenOptions {
-            num_when_then_pairs: 2,
+            num_when_then_pairs: 1,
             has_else: true,
         };
-        // 2 pairs (4 children) + 1 else = 5 children
-        assert_eq!(CaseWhen.arity(&options), Arity::Exact(5));
+        assert_eq!(CaseWhen.arity(&options), Arity::Exact(3));
     }
 
     #[test]
     fn test_arity_without_else() {
         let options = CaseWhenOptions {
-            num_when_then_pairs: 2,
+            num_when_then_pairs: 1,
             has_else: false,
         };
-        // 2 pairs (4 children) = 4 children
-        assert_eq!(CaseWhen.arity(&options), Arity::Exact(4));
+        assert_eq!(CaseWhen.arity(&options), Arity::Exact(2));
     }
 
+    // ==================== Child Name Tests ====================
+
     #[test]
-    fn test_arity_single_condition() {
+    fn test_child_names() {
         let options = CaseWhenOptions {
             num_when_then_pairs: 1,
             has_else: true,
         };
-        // 1 pair (2 children) + 1 else = 3 children
-        assert_eq!(CaseWhen.arity(&options), Arity::Exact(3));
+        assert_eq!(CaseWhen.child_name(&options, 0).to_string(), "when_0");
+        assert_eq!(CaseWhen.child_name(&options, 1).to_string(), "then_0");
+        assert_eq!(CaseWhen.child_name(&options, 2).to_string(), "else");
     }
 
-    // ==================== Child Name Tests ====================
+    // ==================== N-ary Serialization Tests ====================
 
     #[test]
-    fn test_child_names() {
+    #[should_panic(expected = "cannot serialize")]
+    fn test_serialization_roundtrip_nary() {
         let options = CaseWhenOptions {
-            num_when_then_pairs: 2,
+            num_when_then_pairs: 3,
             has_else: true,
         };
+        let serialized = CaseWhen.serialize(&options).unwrap().unwrap();
+        let deserialized = CaseWhen
+            .deserialize(&serialized, &VortexSession::empty())
+            .unwrap();
+        assert_eq!(options, deserialized);
+    }
 
+    #[test]
+    #[should_panic(expected = "cannot serialize")]
+    fn test_serialization_roundtrip_nary_no_else() {
+        let options = CaseWhenOptions {
+            num_when_then_pairs: 4,
+            has_else: false,
+        };
+        let serialized = CaseWhen.serialize(&options).unwrap().unwrap();
+        let deserialized = CaseWhen
+            .deserialize(&serialized, &VortexSession::empty())
+            .unwrap();
+        assert_eq!(options, deserialized);
+    }
+
+    // ==================== N-ary Arity Tests ====================
+
+    #[test]
+    fn test_arity_nary_with_else() {
+        let options = CaseWhenOptions {
+            num_when_then_pairs: 3,
+            has_else: true,
+        };
+        // 3 pairs * 2 children + 1 else = 7
+        assert_eq!(CaseWhen.arity(&options), Arity::Exact(7));
+    }
+
+    #[test]
+    fn test_arity_nary_without_else() {
+        let options = CaseWhenOptions {
+            num_when_then_pairs: 3,
+            has_else: false,
+        };
+        // 3 pairs * 2 children = 6
+        assert_eq!(CaseWhen.arity(&options), Arity::Exact(6));
+    }
+
+    // ==================== N-ary Child Name Tests ====================
+
+    #[test]
+    fn test_child_names_nary() {
+        let options = CaseWhenOptions {
+            num_when_then_pairs: 3,
+            has_else: true,
+        };
         assert_eq!(CaseWhen.child_name(&options, 0).to_string(), "when_0");
         assert_eq!(CaseWhen.child_name(&options, 1).to_string(), "then_0");
         assert_eq!(CaseWhen.child_name(&options, 2).to_string(), "when_1");
         assert_eq!(CaseWhen.child_name(&options, 3).to_string(), "then_1");
-        assert_eq!(CaseWhen.child_name(&options, 4).to_string(), "else");
+        assert_eq!(CaseWhen.child_name(&options, 4).to_string(), "when_2");
+        assert_eq!(CaseWhen.child_name(&options, 5).to_string(), "then_2");
+        assert_eq!(CaseWhen.child_name(&options, 6).to_string(), "else");
+    }
+
+    // ==================== N-ary DType Tests ====================
+
+    #[test]
+    fn test_return_dtype_nary_mismatched_then_types_errors() {
+        let expr = nested_case_when(
+            vec![(lit(true), lit(100i32)), (lit(false), lit("oops"))],
+            Some(lit(0i32)),
+        );
+        let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let err = expr.return_dtype(&input_dtype).unwrap_err();
+        assert!(err.to_string().contains("THEN dtypes must match"));
+    }
+
+    #[test]
+    fn test_return_dtype_nary_mixed_nullability() {
+        // When some THEN branches are nullable and others are not,
+        // the result should be nullable (union of nullabilities).
+        let non_null_then = lit(100i32);
+        let nullable_then = lit(Scalar::null(DType::Primitive(
+            PType::I32,
+            Nullability::Nullable,
+        )));
+        let expr = nested_case_when(
+            vec![(lit(true), non_null_then), (lit(false), nullable_then)],
+            Some(lit(0i32)),
+        );
+        let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result = expr.return_dtype(&input_dtype).unwrap();
+        assert_eq!(result, DType::Primitive(PType::I32, Nullability::Nullable));
+    }
+
+    #[test]
+    fn test_return_dtype_nary_no_else_is_nullable() {
+        let expr = nested_case_when(
+            vec![(lit(true), lit(10i32)), (lit(false), lit(20i32))],
+            None,
+        );
+        let input_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result = expr.return_dtype(&input_dtype).unwrap();
+        assert_eq!(result, DType::Primitive(PType::I32, Nullability::Nullable));
     }
 
     // ==================== Expression Manipulation Tests ====================
 
     #[test]
     fn test_replace_children() {
-        let expr = case_when([lit(true), lit(1i32), lit(0i32)]);
+        let expr = case_when(lit(true), lit(1i32), lit(0i32));
         expr.with_children([lit(false), lit(2i32), lit(3i32)])
             .vortex_expect("operation should succeed in test");
     }
@@ -671,182 +710,203 @@ mod tests {
 
     #[test]
     fn test_evaluate_simple_condition() {
-        // Test: CASE WHEN value > 2 THEN 100 ELSE 0 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [0, 0, 100, 100, 100]
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("value", root()), lit(2i32)),
             lit(100i32),
             lit(0i32),
-        ]);
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        assert_eq!(result.as_slice::<i32>(), &[0, 0, 100, 100, 100]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![0i32, 0, 100, 100, 100].into_array());
     }
 
     #[test]
-    fn test_evaluate_multiple_conditions() {
-        // Test: CASE WHEN value == 1 THEN 10 WHEN value == 3 THEN 30 ELSE 0 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [10, 0, 30, 0, 0]
+    fn test_evaluate_nary_multiple_conditions() {
+        // Test n-ary via nested_case_when
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
-            eq(get_item("value", root()), lit(1i32)),
-            lit(10i32),
-            eq(get_item("value", root()), lit(3i32)),
-            lit(30i32),
-            lit(0i32),
-        ]);
+        let expr = nested_case_when(
+            vec![
+                (eq(get_item("value", root()), lit(1i32)), lit(10i32)),
+                (eq(get_item("value", root()), lit(3i32)), lit(30i32)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        assert_eq!(result.as_slice::<i32>(), &[10, 0, 30, 0, 0]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![10i32, 0, 30, 0, 0].into_array());
     }
 
     #[test]
-    fn test_evaluate_first_match_wins() {
-        // Test: CASE WHEN value > 2 THEN 100 WHEN value > 3 THEN 200 ELSE 0 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [0, 0, 100, 100, 100] - first condition wins for values 3, 4, 5
+    fn test_evaluate_nary_first_match_wins() {
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
-            gt(get_item("value", root()), lit(2i32)),
-            lit(100i32),
-            gt(get_item("value", root()), lit(3i32)),
-            lit(200i32),
-            lit(0i32),
-        ]);
+        // Both conditions match for values > 3, but first one wins
+        let expr = nested_case_when(
+            vec![
+                (gt(get_item("value", root()), lit(2i32)), lit(100i32)),
+                (gt(get_item("value", root()), lit(3i32)), lit(200i32)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        // First match wins: 3, 4, 5 all get 100 (from first condition)
-        assert_eq!(result.as_slice::<i32>(), &[0, 0, 100, 100, 100]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![0i32, 0, 100, 100, 100].into_array());
     }
 
     #[test]
     fn test_evaluate_no_else_returns_null() {
-        // Test: CASE WHEN value > 3 THEN 100 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [null, null, null, 100, 100]
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when_no_else([gt(get_item("value", root()), lit(3i32)), lit(100i32)]);
-
-        let result = expr.evaluate(&test_array).unwrap();
+        let expr = case_when_no_else(gt(get_item("value", root()), lit(3i32)), lit(100i32));
 
-        // Check the dtype is nullable
+        let result = evaluate_expr(&expr, &test_array);
         assert!(result.dtype().is_nullable());
-
-        // Positions 0, 1, 2 should be null, 3, 4 should be 100
-        assert_eq!(result.scalar_at(0), Scalar::null(result.dtype().clone()));
-        assert_eq!(result.scalar_at(1), Scalar::null(result.dtype().clone()));
-        assert_eq!(result.scalar_at(2), Scalar::null(result.dtype().clone()));
-        assert_eq!(
-            result.scalar_at(3),
-            Scalar::from(100i32).cast(result.dtype()).unwrap()
-        );
-        assert_eq!(
-            result.scalar_at(4),
-            Scalar::from(100i32).cast(result.dtype()).unwrap()
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([None::<i32>, None, None, Some(100), Some(100)])
+                .into_array()
         );
     }
 
     #[test]
     fn test_evaluate_all_conditions_false() {
-        // Test: CASE WHEN value > 100 THEN 1 ELSE 0 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [0, 0, 0, 0, 0] - no conditions match
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("value", root()), lit(100i32)),
             lit(1i32),
             lit(0i32),
-        ]);
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        assert_eq!(result.as_slice::<i32>(), &[0, 0, 0, 0, 0]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![0i32, 0, 0, 0, 0].into_array());
     }
 
     #[test]
     fn test_evaluate_all_conditions_true() {
-        // Test: CASE WHEN value > 0 THEN 100 ELSE 0 END
-        // Input: [1, 2, 3, 4, 5]
-        // Expected: [100, 100, 100, 100, 100] - all match
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("value", root()), lit(0i32)),
             lit(100i32),
             lit(0i32),
-        ]);
+        );
+
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![100i32, 100, 100, 100, 100].into_array());
+    }
+
+    #[test]
+    fn test_evaluate_all_true_no_else_returns_correct_dtype() {
+        // CASE WHEN value > 0 THEN 100 END — condition is always true, no ELSE.
+        // Result must be Nullable because the implicit ELSE is NULL.
+        let test_array = StructArray::from_fields(&[("value", buffer![1i32, 2, 3].into_array())])
+            .unwrap()
+            .into_array();
+
+        let expr = case_when_no_else(gt(get_item("value", root()), lit(0i32)), lit(100i32));
+
+        let result = evaluate_expr(&expr, &test_array);
+        assert!(
+            result.dtype().is_nullable(),
+            "result dtype must be Nullable, got {:?}",
+            result.dtype()
+        );
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(100i32), Some(100), Some(100)]).into_array()
+        );
+    }
+
+    #[test]
+    fn test_merge_case_branches_widens_nullability_of_later_branch() -> VortexResult<()> {
+        // When a later THEN branch is Nullable and branches[0] and ELSE are NonNullable,
+        // the result dtype must still be Nullable.
+        //
+        // CASE WHEN value = 0 THEN 10          -- NonNullable
+        //      WHEN value = 1 THEN nullable(20) -- Nullable
+        //      ELSE 0                           -- NonNullable
+        // → result must be Nullable(i32)
+        let test_array = StructArray::from_fields(&[("value", buffer![0i32, 1, 2].into_array())])
+            .unwrap()
+            .into_array();
+
+        let nullable_20 =
+            Scalar::from(20i32).cast(&DType::Primitive(PType::I32, Nullability::Nullable))?;
+
+        let expr = nested_case_when(
+            vec![
+                (eq(get_item("value", root()), lit(0i32)), lit(10i32)),
+                (eq(get_item("value", root()), lit(1i32)), lit(nullable_20)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        assert_eq!(result.as_slice::<i32>(), &[100, 100, 100, 100, 100]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert!(
+            result.dtype().is_nullable(),
+            "result dtype must be Nullable, got {:?}",
+            result.dtype()
+        );
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(10), Some(20), Some(0)]).into_array()
+        );
+        Ok(())
     }
 
     #[test]
     fn test_evaluate_with_literal_condition() {
-        // Test: CASE WHEN true THEN 100 ELSE 0 END (constant true condition)
         let test_array = buffer![1i32, 2, 3].into_array();
+        let expr = case_when(lit(true), lit(100i32), lit(0i32));
+        let result = evaluate_expr(&expr, &test_array);
 
-        let expr = case_when([lit(true), lit(100i32), lit(0i32)]);
-
-        let result = expr.evaluate(&test_array).unwrap();
-        // Constant folding should produce a constant array
-        if let Some(constant) = result.as_constant() {
-            assert_eq!(constant, Scalar::from(100i32));
-        } else {
-            let prim = result.to_primitive();
-            assert_eq!(prim.as_slice::<i32>(), &[100, 100, 100]);
-        }
+        assert_arrays_eq!(result, buffer![100i32, 100, 100].into_array());
     }
 
     #[test]
     fn test_evaluate_with_bool_column_result() {
-        // Test: CASE WHEN value > 2 THEN true ELSE false END
         let test_array =
             StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
                 .unwrap()
                 .into_array();
 
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("value", root()), lit(2i32)),
             lit(true),
             lit(false),
-        ]);
+        );
 
-        let result = expr.evaluate(&test_array).unwrap().to_bool();
-        assert_eq!(
-            result.bit_buffer().iter().collect::<Vec<_>>(),
-            vec![false, false, true, true, true]
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(
+            result,
+            BoolArray::from_iter([false, false, true, true, true]).into_array()
         );
     }
 
     #[test]
     fn test_evaluate_with_nullable_condition() {
-        // Test: CASE WHEN nullable_bool THEN 100 ELSE 0 END
-        // Where the condition has null values - nulls should be treated as false
         let test_array = StructArray::from_fields(&[(
             "cond",
             BoolArray::from_iter([Some(true), None, Some(false), None, Some(true)]).into_array(),
@@ -854,16 +914,14 @@ mod tests {
         .unwrap()
         .into_array();
 
-        let expr = case_when([get_item("cond", root()), lit(100i32), lit(0i32)]);
+        let expr = case_when(get_item("cond", root()), lit(100i32), lit(0i32));
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        // true -> 100, null -> 0 (treated as false), false -> 0
-        assert_eq!(result.as_slice::<i32>(), &[100, 0, 0, 0, 100]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![100i32, 0, 0, 0, 100].into_array());
     }
 
     #[test]
     fn test_evaluate_with_nullable_result_values() {
-        // Test: CASE WHEN value > 2 THEN nullable_value ELSE 0 END
         let test_array = StructArray::from_fields(&[
             ("value", buffer![1i32, 2, 3, 4, 5].into_array()),
             (
@@ -875,26 +933,22 @@ mod tests {
         .unwrap()
         .into_array();
 
-        let expr = case_when([
+        let expr = case_when(
             gt(get_item("value", root()), lit(2i32)),
             get_item("result", root()),
             lit(0i32),
-        ]);
-
-        let result = expr.evaluate(&test_array).unwrap();
-        let prim = result.to_primitive();
+        );
 
-        // Values 1, 2 don't match -> 0
-        // Value 3 matches -> 30 (from result column)
-        // Value 4 matches -> 40
-        // Value 5 matches -> 50
-        assert_eq!(prim.as_slice::<i32>(), &[0, 0, 30, 40, 50]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(0i32), Some(0), Some(30), Some(40), Some(50)])
+                .into_array()
+        );
     }
 
     #[test]
     fn test_evaluate_with_all_null_condition() {
-        // Test: CASE WHEN all_nulls THEN 100 ELSE 0 END
-        // All null conditions should be treated as false
         let test_array = StructArray::from_fields(&[(
             "cond",
             BoolArray::from_iter([None, None, None]).into_array(),
@@ -902,516 +956,254 @@ mod tests {
         .unwrap()
         .into_array();
 
-        let expr = case_when([get_item("cond", root()), lit(100i32), lit(0i32)]);
+        let expr = case_when(get_item("cond", root()), lit(100i32), lit(0i32));
 
-        let result = expr.evaluate(&test_array).unwrap().to_primitive();
-        // All null -> treated as false -> else value
-        assert_eq!(result.as_slice::<i32>(), &[0, 0, 0]);
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![0i32, 0, 0].into_array());
     }
 
-    // ==================== Execute Tests ====================
+    // ==================== N-ary Evaluate Tests ====================
 
     #[test]
-    fn test_execute_with_scalar_inputs() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolScalar;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN true THEN 100 ELSE 0 END with all scalars
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let datums = vec![
-            Datum::Scalar(VScalar::from(BoolScalar::new(Some(true)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(0i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 1,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
-
-        // Should return scalar since all inputs were scalars
-        match result {
-            Datum::Scalar(s) => {
-                let prim = s.into_primitive().into_i32();
-                assert_eq!(prim.value(), Some(100));
-            }
-            Datum::Vector(v) => {
-                // Also acceptable: a length-1 vector
-                assert_eq!(v.len(), 1);
-            }
-        }
-    }
-
-    #[test]
-    fn test_execute_with_scalar_false_condition() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolScalar;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN false THEN 100 ELSE 42 END
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let datums = vec![
-            Datum::Scalar(VScalar::from(BoolScalar::new(Some(false)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(42i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 1,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
-
-        match result {
-            Datum::Scalar(s) => {
-                let prim = s.into_primitive().into_i32();
-                assert_eq!(prim.value(), Some(42));
-            }
-            Datum::Vector(v) => {
-                assert_eq!(v.len(), 1);
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(42));
-            }
-        }
-    }
-
-    #[test]
-    fn test_execute_with_vector_condition() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [true, false, true] THEN 100 ELSE 0 END
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let cond_vector = BoolVector::from_iter([true, false, true]);
-        let datums = vec![
-            Datum::Vector(cond_vector.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(0i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 3,
-            return_dtype,
-        };
+    fn test_evaluate_nary_no_else_returns_null() {
+        let test_array =
+            StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
+                .unwrap()
+                .into_array();
 
-        let result = CaseWhen.execute(&options, args).unwrap();
+        // Two conditions, no ELSE — unmatched rows should be NULL
+        let expr = nested_case_when(
+            vec![
+                (eq(get_item("value", root()), lit(1i32)), lit(10i32)),
+                (eq(get_item("value", root()), lit(3i32)), lit(30i32)),
+            ],
+            None,
+        );
 
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(100));
-                assert_eq!(prim.get(1).copied(), Some(0));
-                assert_eq!(prim.get(2).copied(), Some(100));
-            }
-            Datum::Scalar(_) => panic!("Expected vector result"),
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert!(result.dtype().is_nullable());
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(10i32), None, Some(30), None, None])
+                .into_array()
+        );
     }
 
     #[test]
-    fn test_execute_with_nullable_condition() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_mask::Mask;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [true, NULL, false, NULL] THEN 100 ELSE 0 END
-        // NULL should be treated as false
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::Nullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let bits = vortex_buffer::BitBuffer::from_iter([true, true, false, false]);
-        let validity = Mask::from_iter([true, false, true, false]); // positions 1, 3 are NULL
-        let cond_vector = BoolVector::new(bits, validity);
-
-        let datums = vec![
-            Datum::Vector(cond_vector.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(0i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 4,
-            return_dtype,
-        };
+    fn test_evaluate_nary_many_conditions() {
+        let test_array =
+            StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4, 5].into_array())])
+                .unwrap()
+                .into_array();
 
-        let result = CaseWhen.execute(&options, args).unwrap();
+        // 5 WHEN/THEN pairs: each value maps to its value * 10
+        let expr = nested_case_when(
+            vec![
+                (eq(get_item("value", root()), lit(1i32)), lit(10i32)),
+                (eq(get_item("value", root()), lit(2i32)), lit(20i32)),
+                (eq(get_item("value", root()), lit(3i32)), lit(30i32)),
+                (eq(get_item("value", root()), lit(4i32)), lit(40i32)),
+                (eq(get_item("value", root()), lit(5i32)), lit(50i32)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(100)); // true -> 100
-                assert_eq!(prim.get(1).copied(), Some(0)); // NULL -> 0 (treated as false)
-                assert_eq!(prim.get(2).copied(), Some(0)); // false -> 0
-                assert_eq!(prim.get(3).copied(), Some(0)); // NULL -> 0 (treated as false)
-            }
-            Datum::Scalar(_) => panic!("Expected vector result"),
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![10i32, 20, 30, 40, 50].into_array());
     }
 
     #[test]
-    fn test_execute_without_else() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [true, false, true] THEN 100 END (no else)
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: false,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::Nullable);
-
-        let cond_vector = BoolVector::from_iter([true, false, true]);
-        let datums = vec![
-            Datum::Vector(cond_vector.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype],
-            row_count: 3,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
+    fn test_evaluate_nary_all_false_no_else() {
+        let test_array = StructArray::from_fields(&[("value", buffer![1i32, 2, 3].into_array())])
+            .unwrap()
+            .into_array();
+
+        // All conditions are false, no ELSE — everything should be NULL
+        let expr = nested_case_when(
+            vec![
+                (gt(get_item("value", root()), lit(100i32)), lit(10i32)),
+                (gt(get_item("value", root()), lit(200i32)), lit(20i32)),
+            ],
+            None,
+        );
 
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(100)); // true -> 100
-                assert_eq!(prim.get(1), None); // false -> NULL
-                assert_eq!(prim.get(2).copied(), Some(100)); // true -> 100
-            }
-            Datum::Scalar(_) => panic!("Expected vector result"),
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert!(result.dtype().is_nullable());
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([None::<i32>, None, None]).into_array()
+        );
     }
 
     #[test]
-    fn test_execute_multiple_conditions() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [true, false, false] THEN 10
-        //      WHEN [false, true, false] THEN 20
-        //      ELSE 0 END
-        // Expected: [10, 20, 0]
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 2,
-            has_else: true,
-        };
+    fn test_evaluate_nary_overlapping_conditions_first_wins() {
+        let test_array =
+            StructArray::from_fields(&[("value", buffer![10i32, 20, 30].into_array())])
+                .unwrap()
+                .into_array();
 
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let cond1 = BoolVector::from_iter([true, false, false]);
-        let cond2 = BoolVector::from_iter([false, true, false]);
-
-        let datums = vec![
-            Datum::Vector(cond1.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(10i32)))),
-            Datum::Vector(cond2.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(20i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(0i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![
-                cond_dtype.clone(),
-                then_dtype.clone(),
-                cond_dtype,
-                then_dtype.clone(),
-                then_dtype,
+        // value=10: matches cond1 (>5) and cond2 (>0), first should win
+        // value=20: matches all three, first should win
+        // value=30: matches all three, first should win
+        let expr = nested_case_when(
+            vec![
+                (gt(get_item("value", root()), lit(5i32)), lit(1i32)),
+                (gt(get_item("value", root()), lit(0i32)), lit(2i32)),
+                (gt(get_item("value", root()), lit(15i32)), lit(3i32)),
             ],
-            row_count: 3,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
+            Some(lit(0i32)),
+        );
 
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(10));
-                assert_eq!(prim.get(1).copied(), Some(20));
-                assert_eq!(prim.get(2).copied(), Some(0));
-            }
-            Datum::Scalar(_) => panic!("Expected vector result"),
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        // First matching condition always wins
+        assert_arrays_eq!(result, buffer![1i32, 1, 1].into_array());
     }
 
     #[test]
-    fn test_execute_all_true_short_circuit() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [true, true, true] THEN 100 ELSE 0 END
-        // Should short-circuit and return the then value
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let cond_vector = BoolVector::from_iter([true, true, true]);
-        let datums = vec![
-            Datum::Vector(cond_vector.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(0i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 3,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
+    fn test_evaluate_nary_early_exit_when_remaining_empty() {
+        // After branch 0 claims all rows, remaining becomes all_false.
+        // The loop breaks before evaluating branch 1's condition.
+        let test_array = StructArray::from_fields(&[("value", buffer![1i32, 2, 3].into_array())])
+            .unwrap()
+            .into_array();
+
+        let expr = nested_case_when(
+            vec![
+                (gt(get_item("value", root()), lit(0i32)), lit(100i32)),
+                // Never evaluated due to early exit; 999 must never appear in output.
+                (gt(get_item("value", root()), lit(0i32)), lit(999i32)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        // Could be scalar (from short-circuit) or vector
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(100));
-                assert_eq!(prim.get(1).copied(), Some(100));
-                assert_eq!(prim.get(2).copied(), Some(100));
-            }
-            Datum::Scalar(s) => {
-                let prim = s.into_primitive().into_i32();
-                assert_eq!(prim.value(), Some(100));
-            }
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![100i32, 100, 100].into_array());
     }
 
     #[test]
-    fn test_execute_all_false_short_circuit() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolVector;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN [false, false, false] THEN 100 ELSE 42 END
-        // Should short-circuit and return the else value
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::NonNullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let cond_vector = BoolVector::from_iter([false, false, false]);
-        let datums = vec![
-            Datum::Vector(cond_vector.into()),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(42i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 3,
-            return_dtype,
-        };
-
-        let result = CaseWhen.execute(&options, args).unwrap();
+    fn test_evaluate_nary_skips_branch_with_empty_effective_mask() {
+        // Branch 0 claims value=1. Branch 1 targets the same rows but they are already
+        // matched → effective_mask is all_false → branch 1 is skipped (THEN not used).
+        let test_array = StructArray::from_fields(&[("value", buffer![1i32, 2, 3].into_array())])
+            .unwrap()
+            .into_array();
+
+        let expr = nested_case_when(
+            vec![
+                (eq(get_item("value", root()), lit(1i32)), lit(10i32)),
+                // Same condition as branch 0 — all matching rows already claimed → skipped.
+                // 999 must never appear in output.
+                (eq(get_item("value", root()), lit(1i32)), lit(999i32)),
+                (eq(get_item("value", root()), lit(2i32)), lit(20i32)),
+            ],
+            Some(lit(0i32)),
+        );
 
-        // Could be scalar (from short-circuit) or vector
-        match result {
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(42));
-                assert_eq!(prim.get(1).copied(), Some(42));
-                assert_eq!(prim.get(2).copied(), Some(42));
-            }
-            Datum::Scalar(s) => {
-                let prim = s.into_primitive().into_i32();
-                assert_eq!(prim.value(), Some(42));
-            }
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert_arrays_eq!(result, buffer![10i32, 20, 0].into_array());
     }
 
     #[test]
-    fn test_execute_with_null_scalar_condition() {
-        use vortex_dtype::PTypeDowncast;
-        use vortex_vector::Scalar as VScalar;
-        use vortex_vector::bool::BoolScalar;
-        use vortex_vector::primitive::PScalar;
-
-        // CASE WHEN NULL THEN 100 ELSE 42 END
-        // NULL condition should be treated as false
-        let options = CaseWhenOptions {
-            num_when_then_pairs: 1,
-            has_else: true,
-        };
-
-        let cond_dtype = DType::Bool(Nullability::Nullable);
-        let then_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let else_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let return_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-
-        let null_bool = BoolScalar::null();
-        let datums = vec![
-            Datum::Scalar(VScalar::from(null_bool)),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(100i32)))),
-            Datum::Scalar(VScalar::from(PScalar::new(Some(42i32)))),
-        ];
-
-        let args = ExecutionArgs {
-            datums,
-            dtypes: vec![cond_dtype, then_dtype, else_dtype],
-            row_count: 1,
-            return_dtype,
-        };
+    fn test_evaluate_nary_string_output() -> VortexResult<()> {
+        // Exercises merge_case_branches with a non-primitive (Utf8) builder.
+        let test_array =
+            StructArray::from_fields(&[("value", buffer![1i32, 2, 3, 4].into_array())])
+                .unwrap()
+                .into_array();
 
-        let result = CaseWhen.execute(&options, args).unwrap();
+        // CASE WHEN value > 2 THEN 'high' WHEN value > 0 THEN 'low' ELSE 'none' END
+        // value=1,2 → 'low' (branch 1 after branch 0 claims 3,4)
+        // value=3,4 → 'high' (branch 0)
+        let expr = nested_case_when(
+            vec![
+                (gt(get_item("value", root()), lit(2i32)), lit("high")),
+                (gt(get_item("value", root()), lit(0i32)), lit("low")),
+            ],
+            Some(lit("none")),
+        );
 
-        // NULL condition -> treated as false -> else value
-        match result {
-            Datum::Scalar(s) => {
-                let prim = s.into_primitive().into_i32();
-                assert_eq!(prim.value(), Some(42));
-            }
-            Datum::Vector(v) => {
-                let prim = v.into_primitive().into_i32();
-                assert_eq!(prim.get(0).copied(), Some(42));
-            }
-        }
+        let result = evaluate_expr(&expr, &test_array);
+        assert_eq!(
+            result.scalar_at(0)?,
+            Scalar::utf8("low", Nullability::NonNullable)
+        );
+        assert_eq!(
+            result.scalar_at(1)?,
+            Scalar::utf8("low", Nullability::NonNullable)
+        );
+        assert_eq!(
+            result.scalar_at(2)?,
+            Scalar::utf8("high", Nullability::NonNullable)
+        );
+        assert_eq!(
+            result.scalar_at(3)?,
+            Scalar::utf8("high", Nullability::NonNullable)
+        );
+        Ok(())
     }
 
     #[test]
-    fn test_evaluate_divide_by_zero_protected_by_case_when() {
-        // This test verifies that CASE WHEN properly short-circuits evaluation
-        // to avoid divide-by-zero errors.
-        // Pattern: CASE WHEN denominator > 0 THEN numerator/denominator ELSE NULL END
-        // With input where some denominators are 0, the division should NOT be evaluated
-        // for those rows.
-
-        use vortex_buffer::buffer;
-        use vortex_dtype::PType;
-
-        use crate::arrays::StructArray;
-        use crate::expr::VTableExt;
-        use crate::expr::exprs::binary::Binary;
-        use crate::expr::exprs::operators::Operator;
-        use crate::expr::get_item;
-        use crate::expr::gt;
-        use crate::expr::lit;
-        use crate::expr::root;
-
-        // Create test data: numerator=[10, 20, 30], denominator=[2, 0, 5]
-        // Expected: CASE WHEN denominator > 0 THEN numerator/denominator ELSE NULL END
-        //         = [5, NULL, 6]
+    fn test_evaluate_nary_with_nullable_conditions() {
         let test_array = StructArray::from_fields(&[
-            ("numerator", buffer![10i32, 20, 30].into_array()),
-            ("denominator", buffer![2i32, 0, 5].into_array()),
+            (
+                "cond1",
+                BoolArray::from_iter([Some(true), None, Some(false)]).into_array(),
+            ),
+            (
+                "cond2",
+                BoolArray::from_iter([Some(false), Some(true), None]).into_array(),
+            ),
         ])
         .unwrap()
         .into_array();
 
-        // Build: CASE WHEN $.denominator > 0 THEN $.numerator / $.denominator ELSE null END
-        let condition = gt(get_item("denominator", root()), lit(0i32));
-        let division = Binary
-            .try_new_expr(
-                Operator::Div,
-                [
-                    get_item("numerator", root()),
-                    get_item("denominator", root()),
-                ],
-            )
-            .unwrap();
-        let null_dtype = DType::Primitive(PType::I32, Nullability::Nullable);
-        let null_val = lit(Scalar::null(null_dtype));
-
-        let expr = case_when([condition, division, null_val]);
-
-        // This should NOT panic with divide-by-zero
-        let result = expr.evaluate(&test_array).unwrap();
-
-        // Verify results
-        assert_eq!(result.len(), 3);
-
-        // Row 0: 10/2 = 5
-        assert_eq!(
-            result.scalar_at(0),
-            Scalar::from(5i32).cast(result.dtype()).unwrap()
+        let expr = nested_case_when(
+            vec![
+                (get_item("cond1", root()), lit(10i32)),
+                (get_item("cond2", root()), lit(20i32)),
+            ],
+            Some(lit(0i32)),
         );
 
-        // Row 1: denominator=0, so result is NULL (division was NOT evaluated)
-        assert_eq!(result.scalar_at(1), Scalar::null(result.dtype().clone()));
+        let result = evaluate_expr(&expr, &test_array);
+        // row 0: cond1=true → 10
+        // row 1: cond1=NULL(→false), cond2=true → 20
+        // row 2: cond1=false, cond2=NULL(→false) → else=0
+        assert_arrays_eq!(result, buffer![10i32, 20, 0].into_array());
+    }
 
-        // Row 2: 30/5 = 6
-        assert_eq!(
-            result.scalar_at(2),
-            Scalar::from(6i32).cast(result.dtype()).unwrap()
+    #[test]
+    fn test_merge_case_branches_alternating_mask() -> VortexResult<()> {
+        // Exercises the scalar path: alternating rows produce one slice per row (no runs),
+        // triggering the per-row cursor path in merge_case_branches.
+        let n = 100usize;
+
+        // Branch 0: even rows → 0, Branch 1: odd rows → 1, Else: never reached.
+        let branch0_mask = Mask::from_indices(n, (0..n).step_by(2).collect());
+        let branch1_mask = Mask::from_indices(n, (1..n).step_by(2).collect());
+
+        let result = merge_case_branches(
+            vec![
+                (
+                    branch0_mask,
+                    PrimitiveArray::from_option_iter(vec![Some(0i32); n]).into_array(),
+                ),
+                (
+                    branch1_mask,
+                    PrimitiveArray::from_option_iter(vec![Some(1i32); n]).into_array(),
+                ),
+            ],
+            PrimitiveArray::from_option_iter(vec![Some(99i32); n]).into_array(),
+        )?;
+
+        // Even rows → 0, odd rows → 1.
+        let expected: Vec<Option<i32>> = (0..n)
+            .map(|v| if v % 2 == 0 { Some(0) } else { Some(1) })
+            .collect();
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter(expected).into_array()
         );
+        Ok(())
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/cast/kernel.rs b/vortex-array/src/scalar_fn/fns/cast/kernel.rs
index 2a8af241b27..ca9783cc22e 100644
--- a/vortex-array/src/scalar_fn/fns/cast/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/cast/kernel.rs
@@ -5,14 +5,15 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::dtype::DType;
 use crate::kernel::ExecuteParentKernel;
 use crate::matcher::Matcher;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::cast::Cast;
-use crate::vtable::VTable;
 
 /// Reduce rule for cast: restructure the array without reading buffers.
 ///
@@ -22,7 +23,7 @@ use crate::vtable::VTable;
 ///
 /// Returns `Ok(None)` if the rule doesn't apply to this array/dtype combination.
 pub trait CastReduce: VTable {
-    fn cast(array: &Self::Array, dtype: &DType) -> VortexResult<Option<ArrayRef>>;
+    fn cast(array: ArrayView<'_, Self>, dtype: &DType) -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Execute kernel for cast: perform the actual value conversion, potentially reading buffers.
@@ -33,7 +34,7 @@ pub trait CastReduce: VTable {
 /// Returns `Ok(None)` if this kernel cannot handle the given dtype conversion.
 pub trait CastKernel: VTable {
     fn cast(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         dtype: &DType,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -51,13 +52,13 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, Cast>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
         let dtype = parent.options;
         if array.dtype() == dtype {
-            return Ok(Some(array.to_array()));
+            return Ok(Some(array.array().clone()));
         }
         <V as CastReduce>::cast(array, dtype)
     }
@@ -75,14 +76,14 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: <Self::Parent as Matcher>::Match<'_>,
         _child_idx: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         let dtype = parent.options;
         if array.dtype() == dtype {
-            return Ok(Some(array.to_array()));
+            return Ok(Some(array.array().clone()));
         }
         <V as CastKernel>::cast(array, dtype, ctx)
     }
diff --git a/vortex-array/src/scalar_fn/fns/cast/mod.rs b/vortex-array/src/scalar_fn/fns/cast/mod.rs
index a8e1eade76f..66a257d340b 100644
--- a/vortex-array/src/scalar_fn/fns/cast/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/cast/mod.rs
@@ -7,7 +7,6 @@ use std::fmt::Formatter;
 
 pub use kernel::*;
 use prost::Message;
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
@@ -16,20 +15,20 @@ use vortex_session::VortexSession;
 
 use crate::AnyColumnar;
 use crate::ArrayRef;
+use crate::ArrayView;
 use crate::CanonicalView;
 use crate::ColumnarView;
 use crate::ExecutionCtx;
-use crate::arrays::BoolVTable;
-use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::DecimalVTable;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::FixedSizeListVTable;
-use crate::arrays::ListViewVTable;
-use crate::arrays::NullVTable;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::StructVTable;
-use crate::arrays::VarBinViewVTable;
+use crate::arrays::Bool;
+use crate::arrays::Constant;
+use crate::arrays::Decimal;
+use crate::arrays::Extension;
+use crate::arrays::FixedSizeList;
+use crate::arrays::ListView;
+use crate::arrays::Null;
+use crate::arrays::Primitive;
+use crate::arrays::Struct;
+use crate::arrays::VarBinView;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::expr::StatsCatalog;
@@ -102,26 +101,26 @@ impl ScalarFnVTable for Cast {
         Ok(dtype.clone())
     }
 
-    fn execute(&self, target_dtype: &DType, mut args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let input = args
-            .inputs
-            .pop()
-            .vortex_expect("missing input for Cast expression");
+    fn execute(
+        &self,
+        target_dtype: &DType,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input = args.get(0)?;
 
         let Some(columnar) = input.as_opt::<AnyColumnar>() else {
-            return input
-                .execute::<ArrayRef>(args.ctx)?
-                .cast(target_dtype.clone());
+            return input.execute::<ArrayRef>(ctx)?.cast(target_dtype.clone());
         };
 
         match columnar {
             ColumnarView::Canonical(canonical) => {
-                match cast_canonical(canonical.clone(), target_dtype, args.ctx)? {
+                match cast_canonical(canonical, target_dtype, ctx)? {
                     Some(result) => Ok(result),
                     None => vortex_bail!(
                         "No CastKernel to cast canonical array {} from {} to {}",
-                        canonical.as_ref().encoding_id(),
-                        canonical.as_ref().dtype(),
+                        canonical.to_array_ref().encoding_id(),
+                        canonical.to_array_ref().dtype(),
                         target_dtype,
                     ),
                 }
@@ -206,21 +205,24 @@ fn cast_canonical(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<ArrayRef>> {
     match canonical {
-        CanonicalView::Null(a) => <NullVTable as CastReduce>::cast(a, dtype),
-        CanonicalView::Bool(a) => <BoolVTable as CastReduce>::cast(a, dtype),
-        CanonicalView::Primitive(a) => <PrimitiveVTable as CastKernel>::cast(a, dtype, ctx),
-        CanonicalView::Decimal(a) => <DecimalVTable as CastKernel>::cast(a, dtype, ctx),
-        CanonicalView::VarBinView(a) => <VarBinViewVTable as CastReduce>::cast(a, dtype),
-        CanonicalView::List(a) => <ListViewVTable as CastReduce>::cast(a, dtype),
-        CanonicalView::FixedSizeList(a) => <FixedSizeListVTable as CastReduce>::cast(a, dtype),
-        CanonicalView::Struct(a) => <StructVTable as CastKernel>::cast(a, dtype, ctx),
-        CanonicalView::Extension(a) => <ExtensionVTable as CastReduce>::cast(a, dtype),
+        CanonicalView::Null(a) => <Null as CastReduce>::cast(a, dtype),
+        CanonicalView::Bool(a) => <Bool as CastReduce>::cast(a, dtype),
+        CanonicalView::Primitive(a) => <Primitive as CastKernel>::cast(a, dtype, ctx),
+        CanonicalView::Decimal(a) => <Decimal as CastKernel>::cast(a, dtype, ctx),
+        CanonicalView::VarBinView(a) => <VarBinView as CastReduce>::cast(a, dtype),
+        CanonicalView::List(a) => <ListView as CastReduce>::cast(a, dtype),
+        CanonicalView::FixedSizeList(a) => <FixedSizeList as CastReduce>::cast(a, dtype),
+        CanonicalView::Struct(a) => <Struct as CastKernel>::cast(a, dtype, ctx),
+        CanonicalView::Extension(a) => <Extension as CastReduce>::cast(a, dtype),
+        CanonicalView::Variant(_) => {
+            vortex_bail!("Variant arrays don't support casting")
+        }
     }
 }
 
 /// Cast a constant array by dispatching to its [`CastReduce`] implementation.
-fn cast_constant(array: &ConstantArray, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
-    <ConstantVTable as CastReduce>::cast(array, dtype)
+fn cast_constant(array: ArrayView<Constant>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+    <Constant as CastReduce>::cast(array, dtype)
 }
 
 #[cfg(test)]
diff --git a/vortex-array/src/scalar_fn/fns/dynamic.rs b/vortex-array/src/scalar_fn/fns/dynamic.rs
index 7f16c35adfd..39b97aa5549 100644
--- a/vortex-array/src/scalar_fn/fns/dynamic.rs
+++ b/vortex-array/src/scalar_fn/fns/dynamic.rs
@@ -13,8 +13,8 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
 use crate::dtype::DType;
@@ -31,6 +31,7 @@ use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::ScalarFnVTable;
 use crate::scalar_fn::ScalarFnVTableExt;
+use crate::scalar_fn::VecExecutionArgs;
 use crate::scalar_fn::fns::binary::Binary;
 use crate::scalar_fn::fns::operators::CompareOperator;
 use crate::scalar_fn::fns::operators::Operator;
@@ -45,7 +46,7 @@ impl ScalarFnVTable for DynamicComparison {
     type Options = DynamicComparisonExpr;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("vortex.dynamic")
+        ScalarFnId::from("vortex.dynamic")
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
@@ -92,28 +93,27 @@ impl ScalarFnVTable for DynamicComparison {
         ))
     }
 
-    fn execute(&self, data: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
+    fn execute(
+        &self,
+        data: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
         if let Some(scalar) = data.rhs.scalar() {
-            let [lhs]: [ArrayRef; _] = args
-                .inputs
-                .try_into()
-                .map_err(|_| vortex_error::vortex_err!("Wrong arg count for DynamicComparison"))?;
-            let rhs = ConstantArray::new(scalar, args.row_count).into_array();
+            let lhs = args.get(0)?;
+            let rhs = ConstantArray::new(scalar, args.row_count()).into_array();
 
+            let delegate_args = VecExecutionArgs::new(vec![lhs, rhs], args.row_count());
             return Binary
                 .bind(Operator::from(data.operator))
-                .execute(ExecutionArgs {
-                    inputs: vec![lhs, rhs],
-                    row_count: args.row_count,
-                    ctx: args.ctx,
-                });
+                .execute(&delegate_args, ctx);
         }
         let ret_dtype =
-            DType::Bool(args.inputs[0].dtype().nullability() | data.rhs.dtype.nullability());
+            DType::Bool(args.get(0)?.dtype().nullability() | data.rhs.dtype.nullability());
 
         Ok(ConstantArray::new(
             Scalar::try_new(ret_dtype, Some(data.default.into()))?,
-            args.row_count,
+            args.row_count(),
         )
         .into_array())
     }
@@ -130,7 +130,7 @@ impl ScalarFnVTable for DynamicComparison {
             CompareOperator::Gt => Some(DynamicComparison.new_expr(
                 DynamicComparisonExpr {
                     operator: CompareOperator::Lte,
-                    rhs: dynamic.rhs.clone(),
+                    rhs: Arc::clone(&dynamic.rhs),
                     default: !dynamic.default,
                 },
                 vec![lhs.stat_max(catalog)?],
@@ -138,7 +138,7 @@ impl ScalarFnVTable for DynamicComparison {
             CompareOperator::Gte => Some(DynamicComparison.new_expr(
                 DynamicComparisonExpr {
                     operator: CompareOperator::Lt,
-                    rhs: dynamic.rhs.clone(),
+                    rhs: Arc::clone(&dynamic.rhs),
                     default: !dynamic.default,
                 },
                 vec![lhs.stat_max(catalog)?],
@@ -146,7 +146,7 @@ impl ScalarFnVTable for DynamicComparison {
             CompareOperator::Lt => Some(DynamicComparison.new_expr(
                 DynamicComparisonExpr {
                     operator: CompareOperator::Gte,
-                    rhs: dynamic.rhs.clone(),
+                    rhs: Arc::clone(&dynamic.rhs),
                     default: !dynamic.default,
                 },
                 vec![lhs.stat_min(catalog)?],
@@ -154,7 +154,7 @@ impl ScalarFnVTable for DynamicComparison {
             CompareOperator::Lte => Some(DynamicComparison.new_expr(
                 DynamicComparisonExpr {
                     operator: CompareOperator::Gt,
-                    rhs: dynamic.rhs.clone(),
+                    rhs: Arc::clone(&dynamic.rhs),
                     default: !dynamic.default,
                 },
                 vec![lhs.stat_min(catalog)?],
@@ -392,7 +392,7 @@ mod tests {
     #[test]
     fn execute_value_flips() -> VortexResult<()> {
         let threshold = Arc::new(AtomicI32::new(5));
-        let threshold_clone = threshold.clone();
+        let threshold_clone = Arc::clone(&threshold);
         let expr = dynamic(
             CompareOperator::Lt,
             move || Some(threshold_clone.load(Ordering::SeqCst).into()),
@@ -402,7 +402,7 @@ mod tests {
         );
         let input = buffer![1i32, 5, 10].into_array();
 
-        let result = input.apply(&expr)?;
+        let result = input.clone().apply(&expr)?;
         assert_arrays_eq!(result, BoolArray::from_iter([true, false, false]));
 
         threshold.store(10, Ordering::SeqCst);
diff --git a/vortex-array/src/scalar_fn/fns/fill_null/kernel.rs b/vortex-array/src/scalar_fn/fns/fill_null/kernel.rs
index 409acf3ce9c..dd2a6c9b16b 100644
--- a/vortex-array/src/scalar_fn/fns/fill_null/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/fill_null/kernel.rs
@@ -3,21 +3,24 @@
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::builtins::ArrayBuiltins;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::fill_null::FillNull as FillNullExpr;
-use crate::vtable::VTable;
 
 /// Fill nulls in an array with a scalar value without reading buffers.
 ///
@@ -30,7 +33,8 @@ use crate::vtable::VTable;
 /// The fill value is guaranteed to be non-null. The array is guaranteed to have mixed
 /// validity (neither all-valid nor all-invalid).
 pub trait FillNullReduce: VTable {
-    fn fill_null(array: &Self::Array, fill_value: &Scalar) -> VortexResult<Option<ArrayRef>>;
+    fn fill_null(array: ArrayView<'_, Self>, fill_value: &Scalar)
+    -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Fill nulls in an array with a scalar value, potentially reading buffers.
@@ -44,7 +48,7 @@ pub trait FillNullReduce: VTable {
 /// validity (neither all-valid nor all-invalid).
 pub trait FillNullKernel: VTable {
     fn fill_null(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         fill_value: &Scalar,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -55,12 +59,17 @@ pub trait FillNullKernel: VTable {
 /// Returns `Some(result)` if the precondition short-circuits the fill_null operation,
 /// or `None` if fill_null should proceed with the encoding-specific implementation.
 pub(super) fn precondition(
-    array: &dyn Array,
+    array: &ArrayRef,
     fill_value: &Scalar,
 ) -> VortexResult<Option<ArrayRef>> {
+    vortex_ensure!(
+        !fill_value.is_null(),
+        "fill_null requires a non-null fill value"
+    );
+
     // If the array has no nulls, fill_null is a no-op (just cast for nullability).
     if !array.dtype().is_nullable() || array.all_valid()? {
-        return array.to_array().cast(fill_value.dtype().clone()).map(Some);
+        return array.clone().cast(fill_value.dtype().clone()).map(Some);
     }
 
     // If all values are null, replace the entire array with the fill value.
@@ -76,7 +85,7 @@ pub(super) fn precondition(
 /// Fill null on a [`ConstantArray`] by replacing null scalars with the fill value,
 /// or casting non-null scalars to the fill value's dtype.
 pub(crate) fn fill_null_constant(
-    array: &ConstantArray,
+    array: ArrayView<Constant>,
     fill_value: &Scalar,
 ) -> VortexResult<ArrayRef> {
     let scalar = if array.scalar().is_null() {
@@ -99,7 +108,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, FillNullExpr>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -110,10 +119,12 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let fill_value = scalar_fn_array.children()[1]
+        let fill_value = scalar_fn_array
+            .get_child(1)
             .as_constant()
             .vortex_expect("fill_null fill_value must be constant");
-        if let Some(result) = precondition(&**array, &fill_value)? {
+        let arr = array.array().clone();
+        if let Some(result) = precondition(&arr, &fill_value)? {
             return Ok(Some(result));
         }
         <V as FillNullReduce>::fill_null(array, &fill_value)
@@ -132,7 +143,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, FillNullExpr>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -144,10 +155,12 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let fill_value = scalar_fn_array.children()[1]
+        let fill_value = scalar_fn_array
+            .get_child(1)
             .as_constant()
             .vortex_expect("fill_null fill_value must be constant");
-        if let Some(result) = precondition(&**array, &fill_value)? {
+        let arr = array.array().clone();
+        if let Some(result) = precondition(&arr, &fill_value)? {
             return Ok(Some(result));
         }
         <V as FillNullKernel>::fill_null(array, &fill_value, ctx)
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 c2b52d9be30..656029bf82d 100644
--- a/vortex-array/src/scalar_fn/fns/fill_null/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/fill_null/mod.rs
@@ -17,9 +17,9 @@ use crate::ArrayRef;
 use crate::CanonicalView;
 use crate::ColumnarView;
 use crate::ExecutionCtx;
-use crate::arrays::BoolVTable;
-use crate::arrays::DecimalVTable;
-use crate::arrays::PrimitiveVTable;
+use crate::arrays::Bool;
+use crate::arrays::Decimal;
+use crate::arrays::Primitive;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::expr::Expression;
@@ -92,24 +92,30 @@ impl ScalarFnVTable for FillNull {
             .with_nullability(arg_dtypes[1].nullability()))
     }
 
-    fn execute(&self, _options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [input, fill_value]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Wrong arg count"))?;
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input = args.get(0)?;
+        let fill_value = args.get(1)?;
 
         let fill_scalar = fill_value
             .as_constant()
             .ok_or_else(|| vortex_err!("fill_null fill_value must be a constant/scalar"))?;
 
+        vortex_ensure!(
+            !fill_scalar.is_null(),
+            "fill_null requires a non-null fill value"
+        );
+
         let Some(columnar) = input.as_opt::<AnyColumnar>() else {
-            return input.execute::<ArrayRef>(args.ctx)?.fill_null(fill_scalar);
+            return input.execute::<ArrayRef>(ctx)?.fill_null(fill_scalar);
         };
 
         match columnar {
-            ColumnarView::Canonical(canonical) => {
-                fill_null_canonical(canonical, &fill_scalar, args.ctx)
-            }
+            ColumnarView::Canonical(canonical) => fill_null_canonical(canonical, &fill_scalar, ctx),
             ColumnarView::Constant(constant) => fill_null_constant(constant, &fill_scalar),
         }
     }
@@ -156,7 +162,8 @@ fn fill_null_canonical(
     fill_value: &Scalar,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
-    if let Some(result) = precondition(canonical.as_ref(), fill_value)? {
+    let arr = canonical.to_array_ref();
+    if let Some(result) = precondition(&arr, fill_value)? {
         // The result of precondition may return another ScalarFn, in which case we should
         // apply it immediately.
         // TODO(aduffy): Remove this once we have better driver check. We're also implicitly
@@ -164,19 +171,17 @@ fn fill_null_canonical(
         return result.execute::<ArrayRef>(ctx);
     }
     match canonical {
-        CanonicalView::Bool(a) => <BoolVTable as FillNullKernel>::fill_null(a, fill_value, ctx)?
+        CanonicalView::Bool(a) => <Bool as FillNullKernel>::fill_null(a, fill_value, ctx)?
             .ok_or_else(|| vortex_err!("FillNullKernel for BoolArray returned None")),
         CanonicalView::Primitive(a) => {
-            <PrimitiveVTable as FillNullKernel>::fill_null(a, fill_value, ctx)?
+            <Primitive as FillNullKernel>::fill_null(a, fill_value, ctx)?
                 .ok_or_else(|| vortex_err!("FillNullKernel for PrimitiveArray returned None"))
         }
-        CanonicalView::Decimal(a) => {
-            <DecimalVTable as FillNullKernel>::fill_null(a, fill_value, ctx)?
-                .ok_or_else(|| vortex_err!("FillNullKernel for DecimalArray returned None"))
-        }
+        CanonicalView::Decimal(a) => <Decimal as FillNullKernel>::fill_null(a, fill_value, ctx)?
+            .ok_or_else(|| vortex_err!("FillNullKernel for DecimalArray returned None")),
         other => vortex_bail!(
             "No FillNullKernel for canonical array {}",
-            other.as_ref().encoding_id()
+            other.to_array_ref().encoding_id()
         ),
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/get_item.rs b/vortex-array/src/scalar_fn/fns/get_item.rs
index 947995b47ff..353ebc0925b 100644
--- a/vortex-array/src/scalar_fn/fns/get_item.rs
+++ b/vortex-array/src/scalar_fn/fns/get_item.rs
@@ -4,14 +4,15 @@
 use std::fmt::Formatter;
 
 use prost::Message;
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::arrays::StructArray;
+use crate::arrays::struct_::StructArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::builtins::ExprBuiltins;
 use crate::dtype::DType;
@@ -105,12 +106,13 @@ impl ScalarFnVTable for GetItem {
         Ok(field_dtype)
     }
 
-    fn execute(&self, field_name: &FieldName, mut args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let input = args
-            .inputs
-            .pop()
-            .vortex_expect("missing input for GetItem expression")
-            .execute::<StructArray>(args.ctx)?;
+    fn execute(
+        &self,
+        field_name: &FieldName,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input = args.get(0)?.execute::<StructArray>(ctx)?;
         let field = input.unmasked_field_by_name(field_name).cloned()?;
 
         match input.dtype().nullability() {
@@ -217,9 +219,7 @@ impl ScalarFnVTable for GetItem {
 mod tests {
     use vortex_buffer::buffer;
 
-    use crate::Array;
     use crate::IntoArray;
-    use crate::arrays::StructArray;
     use crate::dtype::DType;
     use crate::dtype::FieldNames;
     use crate::dtype::Nullability;
@@ -231,6 +231,7 @@ mod tests {
     use crate::expr::lit;
     use crate::expr::pack;
     use crate::expr::root;
+    use crate::scalar_fn::fns::get_item::StructArray;
     use crate::validity::Validity;
 
     fn test_array() -> StructArray {
@@ -245,7 +246,7 @@ mod tests {
     fn get_item_by_name() {
         let st = test_array();
         let get_item = get_item("a", root());
-        let item = st.to_array().apply(&get_item).unwrap();
+        let item = st.into_array().apply(&get_item).unwrap();
         assert_eq!(item.dtype(), &DType::from(PType::I32))
     }
 
@@ -253,7 +254,7 @@ mod tests {
     fn get_item_by_name_none() {
         let st = test_array();
         let get_item = get_item("c", root());
-        assert!(st.to_array().apply(&get_item).is_err());
+        assert!(st.into_array().apply(&get_item).is_err());
     }
 
     #[test]
@@ -266,7 +267,7 @@ mod tests {
             Validity::AllInvalid,
         )
         .unwrap()
-        .to_array();
+        .into_array();
 
         let get_item_expr = get_item("a", root());
         let item = st.apply(&get_item_expr).unwrap();
@@ -369,6 +370,6 @@ mod tests {
         )
         .unwrap();
 
-        st.to_array().apply(&get_item("data", root())).unwrap();
+        st.into_array().apply(&get_item("data", root())).unwrap();
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/is_null.rs b/vortex-array/src/scalar_fn/fns/is_null.rs
index 2c10f0f81a9..dd3ef3366c6 100644
--- a/vortex-array/src/scalar_fn/fns/is_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_null.rs
@@ -3,11 +3,11 @@
 
 use std::fmt::Formatter;
 
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
 use crate::builtins::ArrayBuiltins;
@@ -34,7 +34,7 @@ impl ScalarFnVTable for IsNull {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("is_null")
+        ScalarFnId::from("vortex.is_null")
     }
 
     fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -75,17 +75,22 @@ impl ScalarFnVTable for IsNull {
         Ok(DType::Bool(Nullability::NonNullable))
     }
 
-    fn execute(&self, _data: &Self::Options, mut args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let child = args.inputs.pop().vortex_expect("Missing input child");
+    fn execute(
+        &self,
+        _data: &Self::Options,
+        args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let child = args.get(0)?;
         if let Some(scalar) = child.as_constant() {
-            return Ok(ConstantArray::new(scalar.is_null(), args.row_count).into_array());
+            return Ok(ConstantArray::new(scalar.is_null(), args.row_count()).into_array());
         }
 
         match child.validity()? {
             Validity::NonNullable | Validity::AllValid => {
-                Ok(ConstantArray::new(false, args.row_count).into_array())
+                Ok(ConstantArray::new(false, args.row_count()).into_array())
             }
-            Validity::AllInvalid => Ok(ConstantArray::new(true, args.row_count).into_array()),
+            Validity::AllInvalid => Ok(ConstantArray::new(true, args.row_count()).into_array()),
             Validity::Array(a) => a.not(),
         }
     }
diff --git a/vortex-array/src/scalar_fn/fns/like/kernel.rs b/vortex-array/src/scalar_fn/fns/like/kernel.rs
index cca235bbd04..0489504cc93 100644
--- a/vortex-array/src/scalar_fn/fns/like/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/like/kernel.rs
@@ -4,17 +4,18 @@
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::like::Like as LikeExpr;
 use crate::scalar_fn::fns::like::LikeOptions;
-use crate::vtable::VTable;
 
 /// Like pattern matching on an array without reading buffers.
 ///
@@ -26,8 +27,8 @@ use crate::vtable::VTable;
 /// the parent `ScalarFnArray`.
 pub trait LikeReduce: VTable {
     fn like(
-        array: &Self::Array,
-        pattern: &dyn Array,
+        array: ArrayView<'_, Self>,
+        pattern: &ArrayRef,
         options: LikeOptions,
     ) -> VortexResult<Option<ArrayRef>>;
 }
@@ -41,8 +42,8 @@ pub trait LikeReduce: VTable {
 /// the parent `ScalarFnArray`.
 pub trait LikeKernel: VTable {
     fn like(
-        array: &Self::Array,
-        pattern: &dyn Array,
+        array: ArrayView<'_, Self>,
+        pattern: &ArrayRef,
         options: LikeOptions,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -60,7 +61,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, LikeExpr>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -70,8 +71,7 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let children = scalar_fn_array.children();
-        let pattern = &*children[1];
+        let pattern = scalar_fn_array.get_child(1);
         let options = *parent.options;
         <V as LikeReduce>::like(array, pattern, options)
     }
@@ -89,7 +89,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, LikeExpr>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -100,8 +100,7 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let children = scalar_fn_array.children();
-        let pattern = &*children[1];
+        let pattern = scalar_fn_array.get_child(1);
         let options = *parent.options;
         <V as LikeKernel>::like(array, pattern, options, ctx)
     }
diff --git a/vortex-array/src/scalar_fn/fns/like/mod.rs b/vortex-array/src/scalar_fn/fns/like/mod.rs
index cb0f41aa249..da52f730061 100644
--- a/vortex-array/src/scalar_fn/fns/like/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/like/mod.rs
@@ -10,12 +10,11 @@ pub use kernel::*;
 use prost::Message;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::arrow::Datum;
 use crate::arrow::from_arrow_array_with_len;
 use crate::dtype::DType;
@@ -137,11 +136,14 @@ impl ScalarFnVTable for Like {
         ))
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [child, pattern]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Wrong argument count"))?;
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let child = args.get(0)?;
+        let pattern = args.get(1)?;
 
         arrow_like(&child, &pattern, *options)
     }
@@ -201,8 +203,8 @@ impl ScalarFnVTable for Like {
 
 /// Implementation of LIKE using the Arrow crate.
 pub(crate) fn arrow_like(
-    array: &dyn Array,
-    pattern: &dyn Array,
+    array: &ArrayRef,
+    pattern: &ArrayRef,
     options: LikeOptions,
 ) -> VortexResult<ArrayRef> {
     let nullable = array.dtype().is_nullable() | pattern.dtype().is_nullable();
@@ -254,6 +256,7 @@ impl<'a> LikeVariant<'a> {
 
 #[cfg(test)]
 mod tests {
+    use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
@@ -275,7 +278,7 @@ mod tests {
         let not_expr = not(root());
         let bools = BoolArray::from_iter([false, true, false, false, true, true]);
         assert_arrays_eq!(
-            bools.to_array().apply(&not_expr).unwrap(),
+            bools.into_array().apply(&not_expr).unwrap(),
             BoolArray::from_iter([true, false, true, true, false, false])
         );
     }
diff --git a/vortex-array/src/scalar_fn/fns/list_contains/kernel.rs b/vortex-array/src/scalar_fn/fns/list_contains/kernel.rs
index e3970e147ab..7bc643606a7 100644
--- a/vortex-array/src/scalar_fn/fns/list_contains/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/list_contains/kernel.rs
@@ -4,29 +4,33 @@
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::list_contains::ListContains as ListContainsExpr;
-use crate::vtable::VTable;
 
 /// Check list-contains without reading buffers (metadata-only).
 ///
 /// This trait dispatches on the **element** (needle) child at index 1 of the `ListContains`
 /// expression. `Self::Array` is the concrete element encoding, while the list (haystack) is
-/// passed as an opaque `&dyn Array`.
+/// passed as an opaque `&ArrayRef`.
 ///
 /// A future `ListContainsListReduce` could dispatch on the list side (child 0) for encodings
 /// with specialized list representations.
 ///
 /// Return `None` if the operation cannot be resolved from metadata alone.
 pub trait ListContainsElementReduce: VTable {
-    fn list_contains(list: &dyn Array, element: &Self::Array) -> VortexResult<Option<ArrayRef>>;
+    fn list_contains(
+        list: &ArrayRef,
+        element: ArrayView<'_, Self>,
+    ) -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Check list-contains, potentially reading buffers.
@@ -36,8 +40,8 @@ pub trait ListContainsElementReduce: VTable {
 /// the provided [`ExecutionCtx`].
 pub trait ListContainsElementKernel: VTable {
     fn list_contains(
-        list: &dyn Array,
-        element: &Self::Array,
+        list: &ArrayRef,
+        element: ArrayView<'_, Self>,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
@@ -54,7 +58,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, ListContainsExpr>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -65,8 +69,8 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let list = &scalar_fn_array.children()[0];
-        <V as ListContainsElementReduce>::list_contains(list.as_ref(), array)
+        let list = scalar_fn_array.get_child(0);
+        <V as ListContainsElementReduce>::list_contains(list, array)
     }
 }
 
@@ -82,7 +86,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, ListContainsExpr>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -94,7 +98,7 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let list = &scalar_fn_array.children()[0];
-        <V as ListContainsElementKernel>::list_contains(list.as_ref(), array, ctx)
+        let list = scalar_fn_array.get_child(0);
+        <V as ListContainsElementKernel>::list_contains(list, array, ctx)
     }
 }
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 c3c1f48c4e8..b4d6c3e6bc4 100644
--- a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
@@ -15,17 +15,19 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
+use vortex_utils::iter::ReduceBalancedIterExt;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::ToCanonical;
 use crate::arrays::BoolArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
@@ -50,7 +52,6 @@ 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;
-use crate::vtable::ValidityHelper;
 
 #[derive(Clone)]
 pub struct ListContains;
@@ -119,20 +120,23 @@ impl ScalarFnVTable for ListContains {
         Ok(DType::Bool(nullability))
     }
 
-    fn execute(&self, _options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [list_array, value_array]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Wrong number of arguments for ListContains expression"))?;
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let list_array = args.get(0)?;
+        let value_array = args.get(1)?;
 
         if let Some(list_scalar) = list_array.as_constant()
             && let Some(value_scalar) = value_array.as_constant()
         {
             let result = compute_contains_scalar(&list_scalar, &value_scalar)?;
-            return Ok(ConstantArray::new(result, args.row_count).into_array());
+            return Ok(ConstantArray::new(result, args.row_count()).into_array());
         }
 
-        compute_list_contains(list_array.as_ref(), value_array.as_ref())
+        compute_list_contains(&list_array, &value_array, ctx)
     }
 
     fn stat_falsification(
@@ -199,7 +203,11 @@ fn compute_contains_scalar(list: &Scalar, needle: &Scalar) -> VortexResult<Scala
     Ok(Scalar::bool(contains, nullability))
 }
 
-fn compute_list_contains(array: &dyn Array, value: &dyn Array) -> VortexResult<ArrayRef> {
+fn compute_list_contains(
+    array: &ArrayRef,
+    value: &ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
     let DType::List(elem_dtype, _) = array.dtype() else {
         vortex_bail!("Array must be of List type");
     };
@@ -222,7 +230,7 @@ fn compute_list_contains(array: &dyn Array, value: &dyn Array) -> VortexResult<A
     let nullability = array.dtype().nullability() | value.dtype().nullability();
 
     if let Some(value_scalar) = value.as_constant() {
-        list_contains_scalar(array, &value_scalar, nullability)
+        list_contains_scalar(array, &value_scalar, nullability, ctx)
     } else if let Some(list_scalar) = array.as_constant() {
         constant_list_scalar_contains(&list_scalar.as_list(), value, nullability)
     } else {
@@ -233,71 +241,49 @@ fn compute_list_contains(array: &dyn Array, value: &dyn Array) -> VortexResult<A
 /// There is a constant list scalar (haystack) being compared to an array of needles.
 fn constant_list_scalar_contains(
     list_scalar: &ListScalar,
-    values: &dyn Array,
+    values: &ArrayRef,
     nullability: Nullability,
 ) -> VortexResult<ArrayRef> {
     let elements = list_scalar.elements().vortex_expect("non null");
 
     let len = values.len();
     let false_scalar = Scalar::bool(false, nullability);
-    let values = values.to_array();
-    let mut partials = Vec::with_capacity(elements.len());
-
-    for element in elements {
-        let res = Binary
-            .try_new_array(
-                len,
-                Operator::Eq,
-                [
-                    ConstantArray::new(element, len).into_array(),
-                    values.clone(),
-                ],
-            )?
-            .fill_null(false_scalar.clone())?;
-        partials.push(res);
-    }
-
-    if partials.is_empty() {
-        return Ok(ConstantArray::new(false_scalar, len).to_array());
-    }
-
-    or_arrays_balanced(partials)
-}
-
-fn or_arrays_balanced(mut arrays: Vec<ArrayRef>) -> VortexResult<ArrayRef> {
-    debug_assert!(!arrays.is_empty());
 
-    while arrays.len() > 1 {
-        let mut next = Vec::with_capacity(arrays.len().div_ceil(2));
-        let mut i = 0;
-        while i + 1 < arrays.len() {
-            next.push(arrays[i].binary(arrays[i + 1].clone(), Operator::Or)?);
-            i += 2;
-        }
-        if i < arrays.len() {
-            next.push(arrays[i].clone());
-        }
-        arrays = next;
-    }
+    let result = elements
+        .iter()
+        .map(|element| {
+            Binary
+                .try_new_array(
+                    len,
+                    Operator::Eq,
+                    [
+                        ConstantArray::new(element.clone(), len).into_array(),
+                        values.clone(),
+                    ],
+                )?
+                .fill_null(false_scalar.clone())
+        })
+        .collect::<VortexResult<Vec<_>>>()?
+        .into_iter()
+        .try_reduce_balanced(|acc, res| acc.binary(res, Operator::Or))?;
 
-    Ok(arrays
-        .pop()
-        .expect("or_arrays_balanced must be called with at least one array"))
+    Ok(result.unwrap_or_else(|| ConstantArray::new(false_scalar, len).into_array()))
 }
 
 /// Returns a [`BoolArray`] where each bit represents if a list contains the scalar.
 fn list_contains_scalar(
-    array: &dyn Array,
+    array: &ArrayRef,
     value: &Scalar,
     nullability: Nullability,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     // If the list array is constant, we perform a single comparison.
-    if array.len() > 1 && array.is::<ConstantVTable>() {
-        let contains = list_contains_scalar(&array.slice(0..1)?, value, nullability)?;
+    if array.len() > 1 && array.is::<Constant>() {
+        let contains = list_contains_scalar(&array.slice(0..1)?, value, nullability, ctx)?;
         return Ok(ConstantArray::new(contains.scalar_at(0)?, array.len()).into_array());
     }
 
-    let list_array = array.to_listview();
+    let list_array = array.clone().execute::<ListViewArray>(ctx)?;
 
     let elems = list_array.elements();
     if elems.is_empty() {
@@ -306,9 +292,14 @@ fn list_contains_scalar(
     }
 
     let rhs = ConstantArray::new(value.clone(), elems.len());
-    let matching_elements =
-        Binary.try_new_array(elems.len(), Operator::Eq, &[elems.clone(), rhs.to_array()])?;
-    let matches = matching_elements.to_bool();
+    let matching_elements = Binary.try_new_array(
+        elems.len(),
+        Operator::Eq,
+        &[elems.clone(), rhs.clone().into_array()],
+    )?;
+
+    // TODO(ngates): we should execute this into a Columnar and check for constant.
+    let matches = matching_elements.execute::<BoolArray>(ctx)?;
 
     // Fast path: no elements match.
     if let Some(pred) = matches.as_constant() {
@@ -334,14 +325,17 @@ fn list_contains_scalar(
             // All elements match, and all comparisons are valid (result in `true`).
             Some(true) => {
                 // True, unless the list itself is empty or NULL.
-                list_is_not_empty(&list_array, nullability)
+                list_is_not_empty(&list_array, nullability, ctx)
             }
         };
     }
 
     // Get the offsets and sizes as primitive arrays.
-    let offsets = list_array.offsets().to_primitive();
-    let sizes = list_array.sizes().to_primitive();
+    let offsets = list_array
+        .offsets()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let sizes = list_array.sizes().clone().execute::<PrimitiveArray>(ctx)?;
 
     // Process based on the offset and size types.
     let list_matches = match_each_integer_ptype!(offsets.ptype(), |O| {
@@ -352,7 +346,7 @@ fn list_contains_scalar(
 
     Ok(BoolArray::new(
         list_matches,
-        list_array.validity().clone().union_nullability(nullability),
+        list_array.validity()?.union_nullability(nullability),
     )
     .into_array())
 }
@@ -392,7 +386,7 @@ fn list_false_or_null(
     list_array: &ListViewArray,
     nullability: Nullability,
 ) -> VortexResult<ArrayRef> {
-    match list_array.validity() {
+    match list_array.validity()? {
         Validity::NonNullable => {
             // All false.
             Ok(ConstantArray::new(Scalar::bool(false, nullability), list_array.len()).into_array())
@@ -415,7 +409,7 @@ fn list_false_or_null(
         Validity::Array(validity_array) => {
             // Create a new bool array with false, and the provided nulls
             let buffer = BitBuffer::new_unset(list_array.len());
-            Ok(BoolArray::new(buffer, Validity::Array(validity_array.clone())).into_array())
+            Ok(BoolArray::new(buffer, Validity::Array(validity_array)).into_array())
         }
     }
 }
@@ -425,9 +419,10 @@ fn list_false_or_null(
 fn list_is_not_empty(
     list_array: &ListViewArray,
     nullability: Nullability,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     // Short-circuit for all invalid.
-    if matches!(list_array.validity(), Validity::AllInvalid) {
+    if matches!(list_array.validity()?, Validity::AllInvalid) {
         return Ok(ConstantArray::new(
             Scalar::null(DType::Bool(Nullability::Nullable)),
             list_array.len(),
@@ -435,7 +430,7 @@ fn list_is_not_empty(
         .into_array());
     }
 
-    let sizes = list_array.sizes().to_primitive();
+    let sizes = list_array.sizes().clone().execute::<PrimitiveArray>(ctx)?;
     let buffer = match_each_integer_ptype!(sizes.ptype(), |S| {
         BitBuffer::from_iter(sizes.as_slice::<S>().iter().map(|&size| size != S::zero()))
     });
@@ -443,7 +438,7 @@ fn list_is_not_empty(
     // Copy over the validity mask from the input.
     Ok(BoolArray::new(
         buffer,
-        list_array.validity().clone().union_nullability(nullability),
+        list_array.validity()?.union_nullability(nullability),
     )
     .into_array())
 }
@@ -452,8 +447,6 @@ fn list_is_not_empty(
 mod tests {
     use std::sync::Arc;
 
-    use super::or_arrays_balanced;
-
     use itertools::Itertools;
     use rstest::rstest;
     use vortex_buffer::BitBuffer;
@@ -461,16 +454,9 @@ mod tests {
     use vortex_utils::aliases::hash_map::HashMap;
     use vortex_utils::aliases::hash_set::HashSet;
 
-    use crate::Array;
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::arrays::BoolArray;
-    use crate::arrays::ConstantArray;
-    use crate::arrays::ConstantVTable;
     use crate::arrays::ListArray;
-    use crate::arrays::ListVTable;
-    use crate::arrays::ListViewArray;
-    use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinArray;
     use crate::assert_arrays_eq;
     use crate::canonical::ToCanonical;
@@ -493,6 +479,11 @@ mod tests {
     use crate::expr::root;
     use crate::expr::stats::Stat;
     use crate::scalar::Scalar;
+    use crate::scalar_fn::fns::list_contains::BoolArray;
+    use crate::scalar_fn::fns::list_contains::Constant;
+    use crate::scalar_fn::fns::list_contains::ConstantArray;
+    use crate::scalar_fn::fns::list_contains::ListViewArray;
+    use crate::scalar_fn::fns::list_contains::PrimitiveArray;
     use crate::validity::Validity;
 
     fn test_array() -> ArrayRef {
@@ -683,7 +674,7 @@ mod tests {
 
         // Test contains true
         let expr = list_contains(lit(list_scalar.clone()), lit(2i32));
-        let result = arr.apply(&expr).unwrap();
+        let result = arr.clone().apply(&expr).unwrap();
         assert_eq!(
             result.scalar_at(0).unwrap(),
             Scalar::bool(true, Nullability::NonNullable)
@@ -703,7 +694,6 @@ mod tests {
     fn nonnull_strings(values: Vec<Vec<&str>>) -> ArrayRef {
         ListArray::from_iter_slow::<u64, _>(values, Arc::new(DType::Utf8(Nullability::NonNullable)))
             .unwrap()
-            .as_::<ListVTable>()
             .to_listview()
             .into_array()
     }
@@ -726,6 +716,7 @@ mod tests {
 
         ListArray::try_new(elements, offsets, Validity::NonNullable)
             .unwrap()
+            .as_array()
             .to_listview()
             .into_array()
     }
@@ -809,49 +800,11 @@ mod tests {
 
         let expr = list_contains(root(), lit(2i32));
         let contains = list_array.apply(&expr).unwrap();
-        assert!(contains.is::<ConstantVTable>(), "Expected constant result");
+        assert!(contains.is::<Constant>(), "Expected constant result");
         let expected = BoolArray::from_iter([true, true]);
         assert_arrays_eq!(contains, expected);
     }
 
-    fn array_depth(array: &dyn Array) -> usize {
-        1 + (0..array.nchildren())
-            .filter_map(|idx| array.nth_child(idx))
-            .map(|child| array_depth(child.as_ref()))
-            .max()
-            .unwrap_or(0)
-    }
-
-    #[test]
-    fn test_or_arrays_balanced_depth() {
-        let arrays = vec![
-            BoolArray::from_iter([true, false]).into_array(),
-            BoolArray::from_iter([false, true]).into_array(),
-            BoolArray::from_iter([false, false]).into_array(),
-            BoolArray::from_iter([true, true]).into_array(),
-            BoolArray::from_iter([true, false]).into_array(),
-        ];
-
-        let result = or_arrays_balanced(arrays).unwrap();
-        assert_eq!(array_depth(result.as_ref()), 4);
-    }
-
-    #[test]
-    fn test_constant_list_large_regression() {
-        let list_scalar = Scalar::list(
-            Arc::new(DType::Primitive(I32, Nullability::NonNullable)),
-            (0i32..2048).map(Into::into).collect(),
-            Nullability::NonNullable,
-        );
-
-        let values = PrimitiveArray::from_iter(0i32..2048).into_array();
-        let expr = list_contains(lit(list_scalar), root());
-        let contains = values.apply(&expr).unwrap();
-
-        let expected = BoolArray::from_iter(std::iter::repeat_n(true, 2048));
-        assert_arrays_eq!(contains, expected);
-    }
-
     #[test]
     fn test_all_nulls() {
         let list_array = ConstantArray::new(
@@ -865,7 +818,7 @@ mod tests {
 
         let expr = list_contains(root(), lit(2i32));
         let contains = list_array.apply(&expr).unwrap();
-        assert!(contains.is::<ConstantVTable>(), "Expected constant result");
+        assert!(contains.is::<Constant>(), "Expected constant result");
 
         let expected = BoolArray::new(
             [false, false, false, false, false].into_iter().collect(),
@@ -907,7 +860,7 @@ mod tests {
         };
 
         let expr = list_contains(root(), lit(42i32));
-        let result = list_array.apply(&expr).unwrap();
+        let result = list_array.into_array().apply(&expr).unwrap();
 
         let expected = BoolArray::from_iter([false, false, false, false]);
         assert_arrays_eq!(result, expected);
@@ -932,7 +885,7 @@ mod tests {
         // Searching for null
         let null_scalar = Scalar::null(DType::Primitive(I32, Nullability::Nullable));
         let expr = list_contains(root(), lit(null_scalar));
-        let result = list_array.apply(&expr).unwrap();
+        let result = list_array.clone().into_array().apply(&expr).unwrap();
 
         let expected = BoolArray::new(
             [false, false, false].into_iter().collect(),
@@ -942,7 +895,7 @@ mod tests {
 
         // Searching for non-null
         let expr2 = list_contains(root(), lit(42i32));
-        let result2 = list_array.apply(&expr2).unwrap();
+        let result2 = list_array.into_array().apply(&expr2).unwrap();
 
         let expected2 = BoolArray::from_iter([false, false, false]);
         assert_arrays_eq!(result2, expected2);
@@ -959,13 +912,13 @@ mod tests {
             ListViewArray::new(elements.into_array(), offsets, sizes, Validity::NonNullable);
 
         let expr = list_contains(root(), lit(2i32));
-        let result = list_array.apply(&expr).unwrap();
+        let result = list_array.clone().into_array().apply(&expr).unwrap();
 
         let expected = BoolArray::from_iter([false, true, false, false]);
         assert_arrays_eq!(result, expected);
 
         let expr5 = list_contains(root(), lit(5i32));
-        let result5 = list_array.apply(&expr5).unwrap();
+        let result5 = list_array.into_array().apply(&expr5).unwrap();
 
         let expected5 = BoolArray::from_iter([false, false, true, false]);
         assert_arrays_eq!(result5, expected5);
@@ -981,13 +934,13 @@ mod tests {
             ListViewArray::new(elements.into_array(), offsets, sizes, Validity::NonNullable);
 
         let expr = list_contains(root(), lit(255i32));
-        let result = list_array.apply(&expr).unwrap();
+        let result = list_array.clone().into_array().apply(&expr).unwrap();
 
         let expected = BoolArray::from_iter([false, false, false, true]);
         assert_arrays_eq!(result, expected);
 
         let expr_zero = list_contains(root(), lit(0i32));
-        let result_zero = list_array.apply(&expr_zero).unwrap();
+        let result_zero = list_array.into_array().apply(&expr_zero).unwrap();
 
         let expected_zero = BoolArray::from_iter([true, false, false, false]);
         assert_arrays_eq!(result_zero, expected_zero);
diff --git a/vortex-array/src/scalar_fn/fns/literal.rs b/vortex-array/src/scalar_fn/fns/literal.rs
index adf80a7e549..97d8089a5bf 100644
--- a/vortex-array/src/scalar_fn/fns/literal.rs
+++ b/vortex-array/src/scalar_fn/fns/literal.rs
@@ -10,6 +10,7 @@ use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
 use crate::dtype::DType;
@@ -37,7 +38,7 @@ impl ScalarFnVTable for Literal {
     type Options = Scalar;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("vortex.literal")
+        ScalarFnId::from("vortex.literal")
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -84,8 +85,13 @@ impl ScalarFnVTable for Literal {
         Ok(options.dtype().clone())
     }
 
-    fn execute(&self, scalar: &Scalar, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        Ok(ConstantArray::new(scalar.clone(), args.row_count).into_array())
+    fn execute(
+        &self,
+        scalar: &Scalar,
+        args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        Ok(ConstantArray::new(scalar.clone(), args.row_count()).into_array())
     }
 
     fn stat_expression(
diff --git a/vortex-array/src/scalar_fn/fns/mask/kernel.rs b/vortex-array/src/scalar_fn/fns/mask/kernel.rs
index 2187ea1a86d..5346e4e236c 100644
--- a/vortex-array/src/scalar_fn/fns/mask/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/mask/kernel.rs
@@ -6,13 +6,14 @@ use vortex_error::vortex_err;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::BoolVTable;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::Bool;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::mask::Mask as MaskExpr;
-use crate::vtable::VTable;
 
 /// Mask an array without reading buffers.
 ///
@@ -27,7 +28,7 @@ use crate::vtable::VTable;
 /// The mask is guaranteed to have the same length as the array. Trivial cases
 /// (`AllValid`, `AllInvalid`, `NonNullable`) are handled by the caller before dispatch.
 pub trait MaskReduce: VTable {
-    fn mask(array: &Self::Array, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
+    fn mask(array: ArrayView<'_, Self>, mask: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Mask an array, potentially reading buffers.
@@ -43,7 +44,7 @@ pub trait MaskReduce: VTable {
 /// (`AllValid`, `AllInvalid`, `NonNullable`) are handled by the caller before dispatch.
 pub trait MaskKernel: VTable {
     fn mask(
-        array: &Self::Array,
+        array: ArrayView<'_, Self>,
         mask: &ArrayRef,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
@@ -61,7 +62,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, MaskExpr>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -71,10 +72,11 @@ where
         }
         // The mask child (child 1) is a non-nullable BoolArray where true=keep.
         // If it's not yet a BoolArray, we can't reduce without execution.
-        let mask_child = parent
+        let parent_ref: ArrayRef = (*parent).clone();
+        let mask_child = parent_ref
             .nth_child(1)
             .ok_or_else(|| vortex_err!("Mask expression must have 2 children"))?;
-        if mask_child.as_opt::<BoolVTable>().is_none() {
+        if mask_child.as_opt::<Bool>().is_none() {
             return Ok(None);
         };
         <V as MaskReduce>::mask(array, &mask_child)
@@ -93,7 +95,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, MaskExpr>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs
index f5eded6364a..eaf83307b35 100644
--- a/vortex-array/src/scalar_fn/fns/mask/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs
@@ -8,16 +8,17 @@ pub use kernel::*;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::BoolArray;
+use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
-use crate::arrays::ConstantVTable;
-use crate::arrays::mask_validity_canonical;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::masked::mask_validity_canonical;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
@@ -94,17 +95,20 @@ impl ScalarFnVTable for Mask {
         Ok(arg_dtypes[0].as_nullable())
     }
 
-    fn execute(&self, _options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [input, mask_array]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Wrong arg count"))?;
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input = args.get(0)?;
+        let mask_array = args.get(1)?;
 
         if let Some(result) = execute_constant(&input, &mask_array)? {
             return Ok(result);
         }
 
-        execute_canonical(input, mask_array, args.ctx)
+        execute_canonical(input, mask_array, ctx)
     }
 
     fn simplify(
@@ -150,7 +154,7 @@ impl ScalarFnVTable for Mask {
 fn execute_constant(input: &ArrayRef, mask_array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
     let len = input.len();
 
-    if let Some(constant_mask) = mask_array.as_opt::<ConstantVTable>() {
+    if let Some(constant_mask) = mask_array.as_opt::<Constant>() {
         let mask_value = constant_mask.scalar().as_bool().value().unwrap_or(false);
         return if mask_value {
             input.cast(input.dtype().as_nullable()).map(Some)
@@ -161,7 +165,7 @@ fn execute_constant(input: &ArrayRef, mask_array: &ArrayRef) -> VortexResult<Opt
         };
     }
 
-    if let Some(constant_input) = input.as_opt::<ConstantVTable>()
+    if let Some(constant_input) = input.as_opt::<Constant>()
         && constant_input.scalar().is_null()
     {
         return Ok(Some(
@@ -176,7 +180,7 @@ fn execute_constant(input: &ArrayRef, mask_array: &ArrayRef) -> VortexResult<Opt
 fn execute_canonical(
     input: ArrayRef,
     mask_array: ArrayRef,
-    ctx: &mut crate::executor::ExecutionCtx,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
     let mask_bool = mask_array.execute::<BoolArray>(ctx)?;
     let validity_mask = vortex_mask::Mask::from(mask_bool.to_bit_buffer());
diff --git a/vortex-array/src/scalar_fn/fns/merge.rs b/vortex-array/src/scalar_fn/fns/merge.rs
index 21f4c467040..01445eb6c54 100644
--- a/vortex-array/src/scalar_fn/fns/merge.rs
+++ b/vortex-array/src/scalar_fn/fns/merge.rs
@@ -14,8 +14,10 @@ use vortex_session::VortexSession;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray as _;
 use crate::arrays::StructArray;
+use crate::arrays::struct_::StructArrayExt;
 use crate::dtype::DType;
 use crate::dtype::FieldNames;
 use crate::dtype::Nullability;
@@ -49,7 +51,7 @@ impl ScalarFnVTable for Merge {
     type Options = DuplicateHandling;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("vortex.merge")
+        ScalarFnId::from("vortex.merge")
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -138,14 +140,19 @@ impl ScalarFnVTable for Merge {
         ))
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
         // Collect fields in order of appearance. Later fields overwrite earlier fields.
         let mut field_names = Vec::new();
         let mut arrays = Vec::new();
         let mut duplicate_names = HashSet::<_>::new();
 
-        for input in args.inputs {
-            let array = input.execute::<StructArray>(args.ctx)?;
+        for i in 0..args.num_inputs() {
+            let array = args.get(i)?.execute::<StructArray>(ctx)?;
             if array.dtype().is_nullable() {
                 vortex_bail!("merge expects non-nullable input");
             }
@@ -153,7 +160,7 @@ impl ScalarFnVTable for Merge {
             for (field_name, field_array) in array
                 .names()
                 .iter()
-                .zip_eq(array.unmasked_fields().iter().cloned())
+                .zip_eq(array.iter_unmasked_fields().cloned())
             {
                 // Update or insert field.
                 if let Some(idx) = field_names.iter().position(|name| name == field_name) {
@@ -175,7 +182,7 @@ impl ScalarFnVTable for Merge {
 
         // TODO(DK): When children are allowed to be nullable, this needs to change.
         let validity = Validity::NonNullable;
-        let len = args.row_count;
+        let len = args.row_count();
         Ok(
             StructArray::try_new(FieldNames::from(field_names), arrays, len, validity)?
                 .into_array(),
@@ -208,10 +215,10 @@ impl ScalarFnVTable for Merge {
             for name in child_dtype.names().iter() {
                 if let Some(idx) = names.iter().position(|n| n == name) {
                     duplicate_names.insert(name.clone());
-                    children[idx] = child.clone();
+                    children[idx] = Arc::clone(&child);
                 } else {
                     names.push(name.clone());
-                    children.push(child.clone());
+                    children.push(Arc::clone(&child));
                 }
             }
 
@@ -282,11 +289,11 @@ mod tests {
     use vortex_error::VortexResult;
     use vortex_error::vortex_bail;
 
-    use crate::Array;
+    use crate::ArrayRef;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::StructArray;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
     use crate::dtype::Nullability::NonNullable;
@@ -300,9 +307,10 @@ mod tests {
     use crate::expr::merge_opts;
     use crate::expr::root;
     use crate::scalar_fn::fns::merge::DuplicateHandling;
+    use crate::scalar_fn::fns::merge::StructArray;
     use crate::scalar_fn::fns::pack::Pack;
 
-    fn primitive_field(array: &dyn Array, field_path: &[&str]) -> VortexResult<PrimitiveArray> {
+    fn primitive_field(array: &ArrayRef, field_path: &[&str]) -> VortexResult<PrimitiveArray> {
         let mut field_path = field_path.iter();
 
         let Some(field) = field_path.next() else {
@@ -483,7 +491,7 @@ mod tests {
         ])
         .unwrap()
         .into_array();
-        let actual_array = test_array.clone().apply(&expr).unwrap().to_struct();
+        let actual_array = test_array.apply(&expr).unwrap().to_struct();
 
         assert_eq!(
             actual_array
@@ -524,7 +532,7 @@ mod tests {
         ])
         .unwrap()
         .into_array();
-        let actual_array = test_array.clone().apply(&expr).unwrap().to_struct();
+        let actual_array = test_array.apply(&expr).unwrap().to_struct();
 
         assert_eq!(actual_array.names(), ["a", "c", "b", "d"]);
     }
diff --git a/vortex-array/src/scalar_fn/fns/mod.rs b/vortex-array/src/scalar_fn/fns/mod.rs
index 95c66b09ef6..94fc8fb0384 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 case_when;
 pub mod cast;
 pub mod dynamic;
 pub mod fill_null;
diff --git a/vortex-array/src/scalar_fn/fns/not/kernel.rs b/vortex-array/src/scalar_fn/fns/not/kernel.rs
index 60b291af07b..0d42982eb6f 100644
--- a/vortex-array/src/scalar_fn/fns/not/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/not/kernel.rs
@@ -5,12 +5,13 @@ use vortex_error::VortexResult;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::not::Not as NotExpr;
-use crate::vtable::VTable;
 
 /// Invert a boolean array without reading buffers.
 ///
@@ -18,7 +19,7 @@ use crate::vtable::VTable;
 /// and structure without needing to read or execute on the underlying buffers.
 /// Implementations should return `None` if the operation requires buffer access.
 pub trait NotReduce: VTable {
-    fn invert(array: &Self::Array) -> VortexResult<Option<ArrayRef>>;
+    fn invert(array: ArrayView<'_, Self>) -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Invert a boolean array, potentially reading buffers.
@@ -26,7 +27,8 @@ pub trait NotReduce: VTable {
 /// Unlike [`NotReduce`], this trait is for invert implementations that may need
 /// to read and execute on the underlying buffers to produce the result.
 pub trait NotKernel: VTable {
-    fn invert(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<Option<ArrayRef>>;
+    fn invert(array: ArrayView<'_, Self>, ctx: &mut ExecutionCtx)
+    -> VortexResult<Option<ArrayRef>>;
 }
 
 /// Adaptor that wraps a [`NotReduce`] impl as an [`ArrayParentReduceRule`].
@@ -41,7 +43,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         _parent: ScalarFnArrayView<'_, NotExpr>,
         _child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -61,7 +63,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         _parent: ScalarFnArrayView<'_, NotExpr>,
         _child_idx: usize,
         ctx: &mut ExecutionCtx,
diff --git a/vortex-array/src/scalar_fn/fns/not/mod.rs b/vortex-array/src/scalar_fn/fns/not/mod.rs
index 7a65faac96d..c70c8794fe6 100644
--- a/vortex-array/src/scalar_fn/fns/not/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/not/mod.rs
@@ -6,17 +6,17 @@ mod kernel;
 use std::fmt::Formatter;
 
 pub use kernel::*;
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::arrays::Bool;
 use crate::arrays::BoolArray;
-use crate::arrays::BoolVTable;
 use crate::arrays::ConstantArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::expr::Expression;
@@ -84,8 +84,13 @@ impl ScalarFnVTable for Not {
         Ok(child_dtype.clone())
     }
 
-    fn execute(&self, _data: &Self::Options, mut args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let child = args.inputs.pop().vortex_expect("Missing input child");
+    fn execute(
+        &self,
+        _data: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let child = args.get(0)?;
 
         // For constant boolean
         if let Some(scalar) = child.as_constant() {
@@ -93,16 +98,16 @@ impl ScalarFnVTable for Not {
                 Some(b) => Scalar::bool(!b, child.dtype().nullability()),
                 None => Scalar::null(child.dtype().clone()),
             };
-            return Ok(ConstantArray::new(value, args.row_count).into_array());
+            return Ok(ConstantArray::new(value, args.row_count()).into_array());
         }
 
         // For boolean array
-        if let Some(bool) = child.as_opt::<BoolVTable>() {
+        if let Some(bool) = child.as_opt::<Bool>() {
             return Ok(BoolArray::new(!bool.to_bit_buffer(), bool.validity()?).into_array());
         }
 
         // Otherwise, execute and try again
-        child.execute::<ArrayRef>(args.ctx)?.not()
+        child.execute::<ArrayRef>(ctx)?.not()
     }
 
     fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
@@ -116,8 +121,9 @@ impl ScalarFnVTable for Not {
 
 #[cfg(test)]
 mod tests {
+    use crate::IntoArray;
     use crate::ToCanonical;
-    use crate::arrays::BoolArray;
+    use crate::arrays::bool::BoolArrayExt;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::expr::col;
@@ -125,6 +131,7 @@ mod tests {
     use crate::expr::not;
     use crate::expr::root;
     use crate::expr::test_harness;
+    use crate::scalar_fn::fns::not::BoolArray;
 
     #[test]
     fn invert_booleans() {
@@ -132,7 +139,7 @@ mod tests {
         let bools = BoolArray::from_iter([false, true, false, false, true, true]);
         assert_eq!(
             bools
-                .to_array()
+                .into_array()
                 .apply(&not_expr)
                 .unwrap()
                 .to_bool()
diff --git a/vortex-array/src/scalar_fn/fns/operators.rs b/vortex-array/src/scalar_fn/fns/operators.rs
index 2b0502f08f3..498c9c67307 100644
--- a/vortex-array/src/scalar_fn/fns/operators.rs
+++ b/vortex-array/src/scalar_fn/fns/operators.rs
@@ -267,3 +267,18 @@ impl TryFrom<Operator> for CompareOperator {
         }
     }
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for CompareOperator {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(match u.int_in_range(0..=5)? {
+            0 => CompareOperator::Eq,
+            1 => CompareOperator::NotEq,
+            2 => CompareOperator::Gt,
+            3 => CompareOperator::Gte,
+            4 => CompareOperator::Lt,
+            5 => CompareOperator::Lte,
+            _ => unreachable!(),
+        })
+    }
+}
diff --git a/vortex-array/src/scalar_fn/fns/pack.rs b/vortex-array/src/scalar_fn/fns/pack.rs
index 4bec40a2115..13626bb107b 100644
--- a/vortex-array/src/scalar_fn/fns/pack.rs
+++ b/vortex-array/src/scalar_fn/fns/pack.rs
@@ -4,6 +4,7 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use itertools::Itertools as _;
 use prost::Message;
@@ -12,6 +13,7 @@ use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::StructArray;
 use crate::dtype::DType;
@@ -53,7 +55,7 @@ impl ScalarFnVTable for Pack {
     type Options = PackOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("vortex.pack")
+        ScalarFnId::from("vortex.pack")
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -89,7 +91,7 @@ impl ScalarFnVTable for Pack {
 
     fn child_name(&self, instance: &Self::Options, child_idx: usize) -> ChildName {
         match instance.names.get(child_idx) {
-            Some(name) => ChildName::from(name.inner().clone()),
+            Some(name) => ChildName::from(Arc::clone(name.inner())),
             None => unreachable!(
                 "Invalid child index {} for Pack expression with {} fields",
                 child_idx,
@@ -130,13 +132,20 @@ impl ScalarFnVTable for Pack {
         Ok(Some(lit(true)))
     }
 
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let len = args.row_count;
-        let value_arrays = args.inputs;
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let len = args.row_count();
+        let value_arrays: Vec<ArrayRef> = (0..args.num_inputs())
+            .map(|i| args.get(i))
+            .collect::<VortexResult<_>>()?;
         let validity: Validity = options.nullability.into();
         StructArray::try_new(options.names.clone(), value_arrays, len, validity)?
             .into_array()
-            .execute(args.ctx)
+            .execute(ctx)
     }
 
     // This applies a nullability
@@ -157,19 +166,18 @@ mod tests {
 
     use super::Pack;
     use super::PackOptions;
-    use crate::Array;
     use crate::ArrayRef;
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::PrimitiveArray;
-    use crate::arrays::StructArray;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::assert_arrays_eq;
     use crate::dtype::Nullability;
     use crate::expr::col;
     use crate::expr::pack;
     use crate::scalar_fn::ScalarFnVTableExt;
+    use crate::scalar_fn::fns::pack::StructArray;
     use crate::validity::Validity;
-    use crate::vtable::ValidityHelper;
 
     fn test_array() -> ArrayRef {
         StructArray::from_fields(&[
@@ -180,7 +188,7 @@ mod tests {
         .into_array()
     }
 
-    fn primitive_field(array: &dyn Array, field_path: &[&str]) -> VortexResult<PrimitiveArray> {
+    fn primitive_field(array: &ArrayRef, field_path: &[&str]) -> VortexResult<PrimitiveArray> {
         let mut field_path = field_path.iter();
 
         let Some(field) = field_path.next() else {
@@ -223,18 +231,18 @@ mod tests {
         let actual_array = test_array().apply(&expr).unwrap().to_struct();
 
         assert_eq!(actual_array.names(), ["one", "two", "three"]);
-        assert_eq!(actual_array.validity(), &Validity::NonNullable);
+        assert!(matches!(actual_array.validity(), Ok(Validity::NonNullable)));
 
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["one"]).unwrap(),
+            primitive_field(&actual_array.clone().into_array(), &["one"]).unwrap(),
             PrimitiveArray::from_iter([0i32, 1, 2])
         );
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["two"]).unwrap(),
+            primitive_field(&actual_array.clone().into_array(), &["two"]).unwrap(),
             PrimitiveArray::from_iter([4i32, 5, 6])
         );
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["three"]).unwrap(),
+            primitive_field(&actual_array.into_array(), &["three"]).unwrap(),
             PrimitiveArray::from_iter([0i32, 1, 2])
         );
     }
@@ -264,19 +272,19 @@ mod tests {
         assert_eq!(actual_array.names(), ["one", "two", "three"]);
 
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["one"]).unwrap(),
+            primitive_field(&actual_array.clone().into_array(), &["one"]).unwrap(),
             PrimitiveArray::from_iter([0i32, 1, 2])
         );
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["two", "two_one"]).unwrap(),
+            primitive_field(&actual_array.clone().into_array(), &["two", "two_one"]).unwrap(),
             PrimitiveArray::from_iter([4i32, 5, 6])
         );
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["two", "two_two"]).unwrap(),
+            primitive_field(&actual_array.clone().into_array(), &["two", "two_two"]).unwrap(),
             PrimitiveArray::from_iter([4i32, 5, 6])
         );
         assert_arrays_eq!(
-            primitive_field(actual_array.as_ref(), &["three"]).unwrap(),
+            primitive_field(&actual_array.into_array(), &["three"]).unwrap(),
             PrimitiveArray::from_iter([0i32, 1, 2])
         );
     }
@@ -294,7 +302,7 @@ mod tests {
         let actual_array = test_array().apply(&expr).unwrap().to_struct();
 
         assert_eq!(actual_array.names(), ["one", "two", "three"]);
-        assert_eq!(actual_array.validity(), &Validity::AllValid);
+        assert!(matches!(actual_array.validity(), Ok(Validity::AllValid)));
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/root.rs b/vortex-array/src/scalar_fn/fns/root.rs
index e8572a47981..7e04746db19 100644
--- a/vortex-array/src/scalar_fn/fns/root.rs
+++ b/vortex-array/src/scalar_fn/fns/root.rs
@@ -8,6 +8,7 @@ use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::dtype::FieldPath;
 use crate::expr::StatsCatalog;
@@ -68,7 +69,12 @@ impl ScalarFnVTable for Root {
         vortex_bail!("Root expression does not support return_dtype")
     }
 
-    fn execute(&self, _data: &Self::Options, _args: ExecutionArgs) -> VortexResult<ArrayRef> {
+    fn execute(
+        &self,
+        _data: &Self::Options,
+        _args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
         vortex_bail!("Root expression is not executable")
     }
 
diff --git a/vortex-array/src/scalar_fn/fns/select.rs b/vortex-array/src/scalar_fn/fns/select.rs
index cad8ad06c2b..2f93df5e789 100644
--- a/vortex-array/src/scalar_fn/fns/select.rs
+++ b/vortex-array/src/scalar_fn/fns/select.rs
@@ -16,8 +16,10 @@ use vortex_proto::expr::select_opts::Opts;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::arrays::StructArray;
+use crate::arrays::struct_::StructArrayExt;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
 use crate::dtype::FieldNames;
@@ -46,7 +48,7 @@ impl ScalarFnVTable for Select {
     type Options = FieldSelection;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new_ref("vortex.select")
+        ScalarFnId::from("vortex.select")
     }
 
     fn serialize(&self, instance: &FieldSelection) -> VortexResult<Option<Vec<u8>>> {
@@ -141,13 +143,10 @@ impl ScalarFnVTable for Select {
     fn execute(
         &self,
         selection: &FieldSelection,
-        mut args: ExecutionArgs,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<ArrayRef> {
-        let child = args
-            .inputs
-            .pop()
-            .vortex_expect("Missing input child")
-            .execute::<StructArray>(args.ctx)?;
+        let child = args.get(0)?.execute::<StructArray>(ctx)?;
 
         let result = match selection {
             FieldSelection::Include(f) => child.project(f.as_ref()),
@@ -162,7 +161,7 @@ impl ScalarFnVTable for Select {
             }
         }?;
 
-        result.into_array().execute(args.ctx)
+        result.into_array().execute(ctx)
     }
 
     fn simplify(
@@ -309,7 +308,7 @@ mod tests {
 
     use crate::IntoArray;
     use crate::ToCanonical;
-    use crate::arrays::StructArray;
+    use crate::arrays::struct_::StructArrayExt;
     use crate::dtype::DType;
     use crate::dtype::FieldName;
     use crate::dtype::FieldNames;
@@ -322,6 +321,7 @@ mod tests {
     use crate::expr::select_exclude;
     use crate::expr::test_harness;
     use crate::scalar_fn::fns::select::Select;
+    use crate::scalar_fn::fns::select::StructArray;
 
     fn test_array() -> StructArray {
         StructArray::from_fields(&[
@@ -335,7 +335,7 @@ mod tests {
     pub fn include_columns() {
         let st = test_array();
         let select = select(vec![FieldName::from("a")], root());
-        let selected = st.to_array().apply(&select).unwrap().to_struct();
+        let selected = st.into_array().apply(&select).unwrap().to_struct();
         let selected_names = selected.names().clone();
         assert_eq!(selected_names.as_ref(), &["a"]);
     }
@@ -344,7 +344,7 @@ mod tests {
     pub fn exclude_columns() {
         let st = test_array();
         let select = select_exclude(vec![FieldName::from("a")], root());
-        let selected = st.to_array().apply(&select).unwrap().to_struct();
+        let selected = st.into_array().apply(&select).unwrap().to_struct();
         let selected_names = selected.names().clone();
         assert_eq!(selected_names.as_ref(), &["b"]);
     }
diff --git a/vortex-array/src/scalar_fn/fns/zip/kernel.rs b/vortex-array/src/scalar_fn/fns/zip/kernel.rs
index 75097ed5dd9..5cfefee70d7 100644
--- a/vortex-array/src/scalar_fn/fns/zip/kernel.rs
+++ b/vortex-array/src/scalar_fn/fns/zip/kernel.rs
@@ -3,18 +3,18 @@
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::arrays::ExactScalarFn;
-use crate::arrays::ScalarFnArrayView;
+use crate::array::ArrayView;
+use crate::array::VTable;
 use crate::arrays::ScalarFnVTable;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayExt;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::kernel::ExecuteParentKernel;
 use crate::optimizer::rules::ArrayParentReduceRule;
 use crate::scalar_fn::fns::zip::Zip as ZipExpr;
-use crate::vtable::VTable;
 
 /// Zip two arrays using a mask without reading buffers.
 ///
@@ -26,9 +26,9 @@ use crate::vtable::VTable;
 /// the parent `ScalarFnArray`.
 pub trait ZipReduce: VTable {
     fn zip(
-        array: &Self::Array,
-        if_false: &dyn Array,
-        mask: &Mask,
+        array: ArrayView<'_, Self>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
     ) -> VortexResult<Option<ArrayRef>>;
 }
 
@@ -41,9 +41,9 @@ pub trait ZipReduce: VTable {
 /// the parent `ScalarFnArray`.
 pub trait ZipKernel: VTable {
     fn zip(
-        array: &Self::Array,
-        if_false: &dyn Array,
-        mask: &Mask,
+        array: ArrayView<'_, Self>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
 }
@@ -60,7 +60,7 @@ where
 
     fn reduce_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, ZipExpr>,
         child_idx: usize,
     ) -> VortexResult<Option<ArrayRef>> {
@@ -70,11 +70,9 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let children = scalar_fn_array.children();
-        let if_false = &*children[1];
-        let mask_array = &*children[2];
-        let mask = mask_array.try_to_mask_fill_null_false()?;
-        <V as ZipReduce>::zip(array, if_false, &mask)
+        let if_false = scalar_fn_array.get_child(1);
+        let mask_array = scalar_fn_array.get_child(2);
+        <V as ZipReduce>::zip(array, if_false, mask_array)
     }
 }
 
@@ -90,7 +88,7 @@ where
 
     fn execute_parent(
         &self,
-        array: &V::Array,
+        array: ArrayView<'_, V>,
         parent: ScalarFnArrayView<'_, ZipExpr>,
         child_idx: usize,
         ctx: &mut ExecutionCtx,
@@ -101,10 +99,8 @@ where
         let scalar_fn_array = parent
             .as_opt::<ScalarFnVTable>()
             .vortex_expect("ExactScalarFn matcher confirmed ScalarFnArray");
-        let children = scalar_fn_array.children();
-        let if_false = &*children[1];
-        let mask_array = &*children[2];
-        let mask = mask_array.try_to_mask_fill_null_false()?;
-        <V as ZipKernel>::zip(array, if_false, &mask, ctx)
+        let if_false = scalar_fn_array.get_child(1);
+        let mask_array = scalar_fn_array.get_child(2);
+        <V as ZipKernel>::zip(array, if_false, mask_array, ctx)
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/zip/mod.rs b/vortex-array/src/scalar_fn/fns/zip/mod.rs
index 081545e3bea..5de3524be9a 100644
--- a/vortex-array/src/scalar_fn/fns/zip/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/zip/mod.rs
@@ -6,16 +6,18 @@ mod kernel;
 use std::fmt::Formatter;
 
 pub use kernel::*;
+use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-use vortex_mask::AllOr;
 use vortex_mask::Mask;
+use vortex_mask::MaskValues;
 use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 use crate::builders::ArrayBuilder;
 use crate::builders::builder_with_capacity;
 use crate::builtins::ArrayBuiltins;
@@ -104,13 +106,19 @@ impl ScalarFnVTable for Zip {
             .union_nullability(arg_dtypes[1].nullability()))
     }
 
-    fn execute(&self, _options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let [if_true, if_false, mask_array]: [ArrayRef; _] = args
-            .inputs
-            .try_into()
-            .map_err(|_| vortex_err!("Wrong arg count"))?;
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let if_true = args.get(0)?;
+        let if_false = args.get(1)?;
+        let mask_array = args.get(2)?;
 
-        let mask = mask_array.try_to_mask_fill_null_false()?;
+        let mask = mask_array
+            .execute::<BoolArray>(ctx)?
+            .to_mask_fill_null_false();
 
         let return_dtype = if_true
             .dtype()
@@ -118,22 +126,17 @@ impl ScalarFnVTable for Zip {
             .union_nullability(if_false.dtype().nullability());
 
         if mask.all_true() {
-            return if_true.cast(return_dtype)?.execute(args.ctx);
+            return if_true.cast(return_dtype)?.execute(ctx);
         }
 
-        let return_dtype = if_true
-            .dtype()
-            .clone()
-            .union_nullability(if_false.dtype().nullability());
-
         if mask.all_false() {
-            return if_false.cast(return_dtype)?.execute(args.ctx);
+            return if_false.cast(return_dtype)?.execute(ctx);
         }
 
         if !if_true.is_canonical() || !if_false.is_canonical() {
-            let if_true = if_true.execute::<ArrayRef>(args.ctx)?;
-            let if_false = if_false.execute::<ArrayRef>(args.ctx)?;
-            return if_true.zip(if_false, mask.into_array());
+            let if_true = if_true.execute::<ArrayRef>(ctx)?;
+            let if_false = if_false.execute::<ArrayRef>(ctx)?;
+            return mask.into_array().zip(if_true, if_false);
         }
 
         zip_impl(&if_true, &if_false, &mask)
@@ -170,8 +173,8 @@ impl ScalarFnVTable for Zip {
 }
 
 pub(crate) fn zip_impl(
-    if_true: &dyn Array,
-    if_false: &dyn Array,
+    if_true: &ArrayRef,
+    if_false: &ArrayRef,
     mask: &Mask,
 ) -> VortexResult<ArrayRef> {
     assert_eq!(
@@ -184,34 +187,37 @@ pub(crate) fn zip_impl(
         .dtype()
         .clone()
         .union_nullability(if_false.dtype().nullability());
+
+    if mask.all_true() {
+        return if_true.cast(return_type);
+    }
+    if mask.all_false() {
+        return if_false.cast(return_type);
+    }
+
     zip_impl_with_builder(
         if_true,
         if_false,
-        mask,
+        mask.values()
+            .vortex_expect("zip_impl_with_builder: mask is not all-true or all-false"),
         builder_with_capacity(&return_type, if_true.len()),
     )
 }
 
 fn zip_impl_with_builder(
-    if_true: &dyn Array,
-    if_false: &dyn Array,
-    mask: &Mask,
+    if_true: &ArrayRef,
+    if_false: &ArrayRef,
+    mask: &MaskValues,
     mut builder: Box<dyn ArrayBuilder>,
 ) -> VortexResult<ArrayRef> {
-    match mask.slices() {
-        AllOr::All => Ok(if_true.to_array()),
-        AllOr::None => Ok(if_false.to_array()),
-        AllOr::Some(slices) => {
-            for (start, end) in slices {
-                builder.extend_from_array(&if_false.slice(builder.len()..*start)?);
-                builder.extend_from_array(&if_true.slice(*start..*end)?);
-            }
-            if builder.len() < if_false.len() {
-                builder.extend_from_array(&if_false.slice(builder.len()..if_false.len())?);
-            }
-            Ok(builder.finish())
-        }
+    for (start, end) in mask.slices() {
+        builder.extend_from_array(&if_false.slice(builder.len()..*start)?);
+        builder.extend_from_array(&if_true.slice(*start..*end)?);
+    }
+    if builder.len() < if_false.len() {
+        builder.extend_from_array(&if_false.slice(builder.len()..if_false.len())?);
     }
+    Ok(builder.finish())
 }
 
 #[cfg(test)]
@@ -219,20 +225,26 @@ mod tests {
     use arrow_array::cast::AsArray;
     use arrow_select::zip::zip as arrow_zip;
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
     use vortex_mask::Mask;
 
-    use crate::Array;
+    use super::zip_impl;
+    use crate::ArrayRef;
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::Struct;
     use crate::arrays::StructArray;
-    use crate::arrays::VarBinViewVTable;
+    use crate::arrays::VarBinView;
     use crate::arrow::IntoArrowArray;
     use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::builders::BufferGrowthStrategy;
     use crate::builders::VarBinViewBuilder;
     use crate::builtins::ArrayBuiltins;
+    use crate::columnar::Columnar;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -244,7 +256,7 @@ mod tests {
     #[test]
     fn dtype() {
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-        let expr = zip_expr(root(), lit(0i32), lit(true));
+        let expr = zip_expr(lit(true), root(), lit(0i32));
         let result_dtype = expr.return_dtype(&dtype).unwrap();
         assert_eq!(
             result_dtype,
@@ -254,7 +266,7 @@ mod tests {
 
     #[test]
     fn test_display() {
-        let expr = zip_expr(root(), lit(0i32), lit(true));
+        let expr = zip_expr(lit(true), root(), lit(0i32));
         assert_eq!(expr.to_string(), "zip($, 0i32, true)");
     }
 
@@ -264,7 +276,7 @@ mod tests {
         let if_true = buffer![10, 20, 30, 40, 50].into_array();
         let if_false = buffer![1, 2, 3, 4, 5].into_array();
 
-        let result = if_true.zip(if_false, mask.into_array()).unwrap();
+        let result = mask.into_array().zip(if_true, if_false).unwrap();
         let expected = buffer![10, 2, 3, 40, 5].into_array();
 
         assert_arrays_eq!(result, expected);
@@ -277,16 +289,62 @@ mod tests {
         let if_false =
             PrimitiveArray::from_option_iter([Some(1), Some(2), Some(3), None]).into_array();
 
-        let result = if_true.zip(if_false.clone(), mask.into_array()).unwrap();
+        let result = mask.into_array().zip(if_true, if_false.clone()).unwrap();
         let expected =
             PrimitiveArray::from_option_iter([Some(10), Some(20), Some(30), Some(40)]).into_array();
 
         assert_arrays_eq!(result, expected);
-
-        // result must be nullable even if_true was not
         assert_eq!(result.dtype(), if_false.dtype())
     }
 
+    #[test]
+    fn test_zip_all_false_widens_nullability() {
+        let mask = Mask::new_false(4);
+        let if_true =
+            PrimitiveArray::from_option_iter([Some(10), Some(20), Some(30), None]).into_array();
+        let if_false = buffer![1i32, 2, 3, 4].into_array();
+
+        let result = mask.into_array().zip(if_true.clone(), if_false).unwrap();
+        let expected =
+            PrimitiveArray::from_option_iter([Some(1), Some(2), Some(3), Some(4)]).into_array();
+
+        assert_arrays_eq!(result, expected);
+        assert_eq!(result.dtype(), if_true.dtype());
+    }
+
+    #[test]
+    fn test_zip_impl_all_true_widens_nullability() -> VortexResult<()> {
+        let mask = Mask::new_true(4);
+        let if_true = buffer![10i32, 20, 30, 40].into_array();
+        let if_false =
+            PrimitiveArray::from_option_iter([Some(1), Some(2), Some(3), None]).into_array();
+
+        let result = zip_impl(&if_true, &if_false, &mask)?;
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(10i32), Some(20), Some(30), Some(40)])
+                .into_array()
+        );
+        assert_eq!(result.dtype(), if_false.dtype());
+        Ok(())
+    }
+
+    #[test]
+    fn test_zip_impl_all_false_widens_nullability() -> VortexResult<()> {
+        let mask = Mask::new_false(4);
+        let if_true =
+            PrimitiveArray::from_option_iter([Some(10), Some(20), Some(30), None]).into_array();
+        let if_false = buffer![1i32, 2, 3, 4].into_array();
+
+        let result = zip_impl(&if_true, &if_false, &mask)?;
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)]).into_array()
+        );
+        assert_eq!(result.dtype(), if_true.dtype());
+        Ok(())
+    }
+
     #[test]
     #[should_panic]
     fn test_invalid_lengths() {
@@ -294,57 +352,52 @@ mod tests {
         let if_true = buffer![10, 20, 30].into_array();
         let if_false = buffer![1, 2, 3, 4].into_array();
 
-        let _result = if_true.zip(if_false, mask.into_array()).unwrap();
+        let _result = mask.into_array().zip(if_true, if_false).unwrap();
     }
 
     #[test]
-    fn test_fragmentation() {
+    fn test_fragmentation() -> VortexResult<()> {
         let len = 100;
 
         let const1 = ConstantArray::new(
             Scalar::utf8("hello_this_is_a_longer_string", Nullability::Nullable),
             len,
         )
-        .to_array();
+        .into_array();
 
         let const2 = ConstantArray::new(
             Scalar::utf8("world_this_is_another_string", Nullability::Nullable),
             len,
         )
-        .to_array();
+        .into_array();
 
         let indices: Vec<usize> = (0..len).step_by(2).collect();
         let mask = Mask::from_indices(len, indices);
         let mask_array = mask.into_array();
 
-        let result = const1.zip(const2.clone(), mask_array.clone()).unwrap();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask_array
+            .zip(const1.clone(), const2.clone())?
+            .execute::<Columnar>(&mut ctx)?
+            .into_array();
 
         insta::assert_snapshot!(result.display_tree(), @r"
         root: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%) [all_valid]
-          metadata: EmptyMetadata
+          metadata: 
           buffer: buffer_0 host 29 B (align=1) (1.75%)
           buffer: buffer_1 host 28 B (align=1) (1.69%)
           buffer: views host 1.60 kB (align=16) (96.56%)
         ");
 
-        // test wrapped in a struct
-        let wrapped1 = StructArray::try_from_iter([("nested", const1)])
-            .unwrap()
-            .to_array();
-        let wrapped2 = StructArray::try_from_iter([("nested", const2)])
-            .unwrap()
-            .to_array();
-
-        let wrapped_result = wrapped1.zip(wrapped2, mask_array).unwrap();
-        insta::assert_snapshot!(wrapped_result.display_tree(), @r"
-        root: vortex.struct({nested=utf8?}, len=100) nbytes=1.66 kB (100.00%)
-          metadata: EmptyMetadata
-          nested: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%) [all_valid]
-            metadata: EmptyMetadata
-            buffer: buffer_0 host 29 B (align=1) (1.75%)
-            buffer: buffer_1 host 28 B (align=1) (1.69%)
-            buffer: views host 1.60 kB (align=16) (96.56%)
-        ");
+        let wrapped1 = StructArray::try_from_iter([("nested", const1)])?.into_array();
+        let wrapped2 = StructArray::try_from_iter([("nested", const2)])?.into_array();
+
+        let wrapped_result = mask_array
+            .zip(wrapped1, wrapped2)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(wrapped_result.is::<Struct>());
+
+        Ok(())
     }
 
     #[test]
@@ -379,15 +432,18 @@ mod tests {
             builder.finish()
         };
 
-        // [1,2,4,5,7,8,..]
         let mask = Mask::from_indices(200, (0..100).filter(|i| i % 3 != 0).collect());
         let mask_array = mask.clone().into_array();
 
-        let zipped = if_true.zip(if_false.clone(), mask_array).unwrap();
-        let zipped = zipped.as_opt::<VarBinViewVTable>().unwrap();
-        assert_eq!(zipped.nbuffers(), 2);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let zipped = mask_array
+            .zip(if_true.clone(), if_false.clone())
+            .unwrap()
+            .execute::<ArrayRef>(&mut ctx)
+            .unwrap();
+        let zipped = zipped.as_opt::<VarBinView>().unwrap();
+        assert_eq!(zipped.data_buffers().len(), 2);
 
-        // assert the result is the same as arrow
         let expected = arrow_zip(
             mask.into_array()
                 .into_arrow_preferred()
@@ -398,7 +454,7 @@ mod tests {
         )
         .unwrap();
 
-        let actual = zipped.clone().into_array().into_arrow_preferred().unwrap();
+        let actual = zipped.array().clone().into_arrow_preferred().unwrap();
         assert_eq!(actual.as_ref(), expected.as_ref());
     }
 }
diff --git a/vortex-array/src/scalar_fn/foreign.rs b/vortex-array/src/scalar_fn/foreign.rs
new file mode 100644
index 00000000000..e7d3ee641cc
--- /dev/null
+++ b/vortex-array/src/scalar_fn/foreign.rs
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::expr::Expression;
+use crate::scalar_fn::Arity;
+use crate::scalar_fn::ChildName;
+use crate::scalar_fn::ExecutionArgs;
+use crate::scalar_fn::ScalarFn;
+use crate::scalar_fn::ScalarFnId;
+use crate::scalar_fn::ScalarFnRef;
+use crate::scalar_fn::ScalarFnVTable;
+
+/// Options payload for a foreign scalar function.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ForeignScalarFnOptions {
+    metadata: Vec<u8>,
+    arity: usize,
+}
+
+impl ForeignScalarFnOptions {
+    pub fn new(metadata: Vec<u8>, arity: usize) -> Self {
+        Self { metadata, arity }
+    }
+}
+
+impl Display for ForeignScalarFnOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "foreign(arity={}, metadata={}B)",
+            self.arity,
+            self.metadata.len()
+        )
+    }
+}
+
+/// Scalar function placeholder used when deserializing an unknown scalar function ID.
+#[derive(Clone, Debug)]
+pub struct ForeignScalarFnVTable {
+    id: ScalarFnId,
+}
+
+impl ForeignScalarFnVTable {
+    pub fn new(id: ScalarFnId) -> Self {
+        Self { id }
+    }
+
+    pub fn make_scalar_fn(id: ScalarFnId, metadata: Vec<u8>, arity: usize) -> ScalarFnRef {
+        ScalarFn::new(Self::new(id), ForeignScalarFnOptions::new(metadata, arity)).erased()
+    }
+}
+
+impl ScalarFnVTable for ForeignScalarFnVTable {
+    type Options = ForeignScalarFnOptions;
+
+    fn id(&self) -> ScalarFnId {
+        self.id.clone()
+    }
+
+    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(options.metadata.clone()))
+    }
+
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        Ok(ForeignScalarFnOptions::new(metadata.to_vec(), 0))
+    }
+
+    fn arity(&self, options: &Self::Options) -> Arity {
+        Arity::Exact(options.arity)
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        ChildName::new_arc(format!("arg{child_idx}").into())
+    }
+
+    fn fmt_sql(
+        &self,
+        _options: &Self::Options,
+        expr: &Expression,
+        f: &mut Formatter<'_>,
+    ) -> fmt::Result {
+        write!(f, "{}(", self.id)?;
+        for i in 0..expr.children().len() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            expr.child(i).fmt_sql(f)?;
+        }
+        write!(f, ")")
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _args: &[DType]) -> VortexResult<DType> {
+        Ok(DType::Variant(Nullability::Nullable))
+    }
+
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        _args: &dyn ExecutionArgs,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        vortex_bail!("Cannot execute unknown scalar function '{}'", self.id);
+    }
+}
diff --git a/vortex-array/src/scalar_fn/mod.rs b/vortex-array/src/scalar_fn/mod.rs
index acce0a8cba3..39e45f00e08 100644
--- a/vortex-array/src/scalar_fn/mod.rs
+++ b/vortex-array/src/scalar_fn/mod.rs
@@ -11,14 +11,22 @@ use arcref::ArcRef;
 
 mod vtable;
 pub use vtable::*;
+
 mod plugin;
 pub use plugin::*;
+
+mod foreign;
+pub use foreign::*;
+
 mod typed;
 pub use typed::*;
+
 mod erased;
 pub use erased::*;
+
 mod options;
 pub use options::*;
+
 mod signature;
 pub use signature::*;
 
@@ -31,11 +39,11 @@ pub type ScalarFnId = ArcRef<str>;
 /// Private module to seal [`typed::DynScalarFn`].
 mod sealed {
     use crate::scalar_fn::ScalarFnVTable;
-    use crate::scalar_fn::typed::ScalarFnInner;
+    use crate::scalar_fn::typed::ScalarFn;
 
     /// Marker trait to prevent external implementations of [`super::typed::DynScalarFn`].
     pub(crate) trait Sealed {}
 
     /// This can be the **only** implementor for [`super::typed::DynScalarFn`].
-    impl<V: ScalarFnVTable> Sealed for ScalarFnInner<V> {}
+    impl<V: ScalarFnVTable> Sealed for ScalarFn<V> {}
 }
diff --git a/vortex-array/src/scalar_fn/options.rs b/vortex-array/src/scalar_fn/options.rs
index 98efdfcdad8..4707533ca28 100644
--- a/vortex-array/src/scalar_fn/options.rs
+++ b/vortex-array/src/scalar_fn/options.rs
@@ -13,7 +13,7 @@ use crate::scalar_fn::typed::DynScalarFn;
 
 /// An opaque handle to expression options.
 pub struct ScalarFnOptions<'a> {
-    pub(crate) inner: &'a dyn DynScalarFn,
+    pub(super) inner: &'a dyn DynScalarFn,
 }
 
 impl Display for ScalarFnOptions<'_> {
diff --git a/vortex-array/src/scalar_fn/plugin.rs b/vortex-array/src/scalar_fn/plugin.rs
index 30cb9ad58dc..bafaf2b6137 100644
--- a/vortex-array/src/scalar_fn/plugin.rs
+++ b/vortex-array/src/scalar_fn/plugin.rs
@@ -1,93 +1,48 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::any::Any;
 use std::fmt::Debug;
-use std::fmt::Display;
-use std::fmt::Formatter;
-use std::hash::Hash;
-use std::hash::Hasher;
+use std::sync::Arc;
 
-use arcref::ArcRef;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
 
+use crate::scalar_fn::ScalarFn;
 use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::ScalarFnVTable;
-use crate::scalar_fn::typed::DynScalarFnVTable;
-use crate::scalar_fn::typed::ScalarFnVTableAdapter;
 
-/// A Vortex scalar function vtable plugin, used to deserialize or instantiate scalar functions
-/// dynamically.
-#[derive(Clone)]
-pub struct ScalarFnPlugin(ArcRef<dyn DynScalarFnVTable>);
-
-impl ScalarFnPlugin {
-    /// Creates a new [`ScalarFnPlugin`] from a vtable.
-    pub fn new<V: ScalarFnVTable>(vtable: V) -> Self {
-        Self(ArcRef::new_arc(std::sync::Arc::new(ScalarFnVTableAdapter(
-            vtable,
-        ))))
-    }
-
-    /// Creates a new [`ScalarFnPlugin`] from a static reference to a vtable.
-    pub const fn new_static<V: ScalarFnVTable>(vtable: &'static V) -> Self {
-        // SAFETY: We can safely cast the vtable to a ScalarFnVTableAdapter since it has the same
-        // layout (#[repr(transparent)]).
-        let adapted: &'static ScalarFnVTableAdapter<V> =
-            unsafe { &*(vtable as *const V as *const ScalarFnVTableAdapter<V>) };
-        Self(ArcRef::new_ref(adapted as &'static dyn DynScalarFnVTable))
-    }
-
-    /// Returns the ID of this vtable.
-    pub fn id(&self) -> ScalarFnId {
-        self.0.id()
-    }
-
-    /// Returns whether this vtable is of a given type.
-    pub fn is<V: ScalarFnVTable>(&self) -> bool {
-        self.0.as_any().is::<V>()
-    }
-
-    /// Return the vtable as an Any reference.
-    pub fn as_any(&self) -> &dyn Any {
-        self.0.as_any()
-    }
-
-    /// Deserialize options of this scalar function vtable from metadata, returning a bound
-    /// [`ScalarFnRef`].
-    pub fn deserialize(
-        &self,
-        metadata: &[u8],
-        session: &VortexSession,
-    ) -> VortexResult<ScalarFnRef> {
-        let options = self.0.options_deserialize(metadata, session)?;
-        Ok(self.0.bind_deserialized(options))
-    }
+/// Reference-counted pointer to a scalar function plugin.
+pub type ScalarFnPluginRef = Arc<dyn ScalarFnPlugin>;
+
+/// Registry trait for ID-based deserialization of scalar functions.
+///
+/// Plugins are registered in the session by their [`ScalarFnId`]. When a serialized scalar
+/// function is encountered, the session resolves the ID to the plugin and calls [`deserialize`]
+/// to reconstruct the value as a [`ScalarFnRef`].
+///
+/// [`deserialize`]: ScalarFnPlugin::deserialize
+pub trait ScalarFnPlugin: 'static + Send + Sync {
+    /// Returns the ID for this scalar function.
+    fn id(&self) -> ScalarFnId;
+
+    /// Deserialize a scalar function from serialized metadata.
+    fn deserialize(&self, metadata: &[u8], session: &VortexSession) -> VortexResult<ScalarFnRef>;
 }
 
-impl PartialEq for ScalarFnPlugin {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.id() == other.0.id()
+impl Debug for dyn ScalarFnPlugin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("ScalarFnPlugin").field(&self.id()).finish()
     }
 }
-impl Eq for ScalarFnPlugin {}
 
-impl Hash for ScalarFnPlugin {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.id().hash(state);
+impl<V: ScalarFnVTable> ScalarFnPlugin for V {
+    fn id(&self) -> ScalarFnId {
+        ScalarFnVTable::id(self)
     }
-}
-
-impl Display for ScalarFnPlugin {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0.id())
-    }
-}
 
-impl Debug for ScalarFnPlugin {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0.id())
+    fn deserialize(&self, metadata: &[u8], session: &VortexSession) -> VortexResult<ScalarFnRef> {
+        let options = ScalarFnVTable::deserialize(self, metadata, session)?;
+        Ok(ScalarFn::new(self.clone(), options).erased())
     }
 }
diff --git a/vortex-array/src/scalar_fn/session.rs b/vortex-array/src/scalar_fn/session.rs
index 3ea8d71b534..eef759bf8e3 100644
--- a/vortex-array/src/scalar_fn/session.rs
+++ b/vortex-array/src/scalar_fn/session.rs
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::registry::Registry;
 
-use crate::scalar_fn::ScalarFnPlugin;
+use crate::scalar_fn::ScalarFnPluginRef;
 use crate::scalar_fn::ScalarFnVTable;
 use crate::scalar_fn::fns::between::Between;
 use crate::scalar_fn::fns::binary::Binary;
@@ -23,7 +25,8 @@ use crate::scalar_fn::fns::root::Root;
 use crate::scalar_fn::fns::select::Select;
 
 /// Registry of scalar function vtables.
-pub type ScalarFnRegistry = Registry<ScalarFnPlugin>;
+/// Registry of scalar function vtables.
+pub type ScalarFnRegistry = Registry<ScalarFnPluginRef>;
 
 /// Session state for scalar function vtables and rewrite rules.
 #[derive(Debug)]
@@ -38,8 +41,8 @@ impl ScalarFnSession {
 
     /// Register a scalar function vtable in the session, replacing any existing vtable with the same ID.
     pub fn register<V: ScalarFnVTable>(&self, vtable: V) {
-        let plugin = ScalarFnPlugin::new(vtable);
-        self.registry.register(plugin.id(), plugin);
+        self.registry
+            .register(vtable.id(), Arc::new(vtable) as ScalarFnPluginRef);
     }
 }
 
diff --git a/vortex-array/src/scalar_fn/signature.rs b/vortex-array/src/scalar_fn/signature.rs
index c1cfef77137..45b2fe2ef51 100644
--- a/vortex-array/src/scalar_fn/signature.rs
+++ b/vortex-array/src/scalar_fn/signature.rs
@@ -7,7 +7,7 @@ use crate::scalar_fn::typed::DynScalarFn;
 
 /// Information about the signature of an expression.
 pub struct ScalarFnSignature<'a> {
-    pub(crate) inner: &'a dyn DynScalarFn,
+    pub(super) inner: &'a dyn DynScalarFn,
 }
 
 impl ScalarFnSignature<'_> {
diff --git a/vortex-array/src/scalar_fn/typed.rs b/vortex-array/src/scalar_fn/typed.rs
index fd1c68ebe44..88072ff4002 100644
--- a/vortex-array/src/scalar_fn/typed.rs
+++ b/vortex-array/src/scalar_fn/typed.rs
@@ -4,10 +4,8 @@
 //! Typed and inner representations of scalar functions.
 //!
 //! - [`ScalarFn<V>`]: The public typed wrapper, parameterized by a concrete [`ScalarFnVTable`].
-//! - [`ScalarFnInner<V>`]: The private inner struct that holds the vtable + options.
+//! - [`ScalarFn<V>`]: The private inner struct that holds the vtable + options.
 //! - [`DynScalarFn`]: The private sealed trait for type-erased dispatch (bound, options in self).
-//! - [`DynScalarFnVTable`]: The private trait for vtable-only dispatch (no options).
-//! - [`ScalarFnVTableAdapter<V>`]: The vtable-only adapter used by [`super::ScalarFnPlugin`].
 
 use std::any::Any;
 use std::fmt;
@@ -18,11 +16,10 @@ use std::hash::Hash;
 use std::hash::Hasher;
 use std::sync::Arc;
 
-use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_session::VortexSession;
 
 use crate::ArrayRef;
+use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::Expression;
 use crate::expr::StatsCatalog;
@@ -38,76 +35,53 @@ use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::ScalarFnVTable;
 use crate::scalar_fn::SimplifyCtx;
 
-// ============================================================================
-// DynScalarFnVTable — vtable-only trait (for ScalarFnPlugin)
-// ============================================================================
-
-/// An object-safe trait for vtable-only dispatch (no bound options).
+/// A typed scalar function instance, parameterized by a concrete [`ScalarFnVTable`].
 ///
-/// Used by [`ScalarFnPlugin`] for registration, identity, and deserialization.
-/// Methods that require options take them as `&dyn Any` parameters.
-pub(crate) trait DynScalarFnVTable: 'static + Send + Sync {
-    fn as_any(&self) -> &dyn Any;
-    fn id(&self) -> ScalarFnId;
-
-    fn options_deserialize(
-        &self,
-        metadata: &[u8],
-        session: &VortexSession,
-    ) -> VortexResult<Box<dyn Any + Send + Sync>>;
-
-    /// Bind deserialized options to create a [`ScalarFnRef`].
-    fn bind_deserialized(&self, options: Box<dyn Any + Send + Sync>) -> ScalarFnRef;
+/// You can construct one via [`new()`], and erase the type with [`erased()`] to obtain a
+/// [`ScalarFnRef`].
+///
+/// [`new()`]: ScalarFn::new
+/// [`erased()`]: ScalarFn::erased
+pub struct ScalarFn<V: ScalarFnVTable> {
+    vtable: V,
+    options: V::Options,
 }
 
-/// Vtable-only adapter, wraps `V` for [`ScalarFnPlugin`].
-#[repr(transparent)]
-pub(super) struct ScalarFnVTableAdapter<V>(pub(super) V);
-
-impl<V: ScalarFnVTable> DynScalarFnVTable for ScalarFnVTableAdapter<V> {
-    #[inline(always)]
-    fn as_any(&self) -> &dyn Any {
-        &self.0
+impl<V: ScalarFnVTable> ScalarFn<V> {
+    /// Create a new typed scalar function instance.
+    pub fn new(vtable: V, options: V::Options) -> Self {
+        Self { vtable, options }
     }
 
-    #[inline(always)]
-    fn id(&self) -> ScalarFnId {
-        V::id(&self.0)
+    /// Returns a reference to the vtable.
+    pub fn vtable(&self) -> &V {
+        &self.vtable
     }
 
-    fn options_deserialize(
-        &self,
-        bytes: &[u8],
-        session: &VortexSession,
-    ) -> VortexResult<Box<dyn Any + Send + Sync>> {
-        Ok(Box::new(V::deserialize(&self.0, bytes, session)?))
+    /// Returns a reference to the options.
+    pub fn options(&self) -> &V::Options {
+        &self.options
     }
 
-    fn bind_deserialized(&self, options: Box<dyn Any + Send + Sync>) -> ScalarFnRef {
-        let options = *options
-            .downcast::<V::Options>()
-            .ok()
-            .vortex_expect("Failed to downcast deserialized options to expected type");
-        ScalarFn::<V>::new(self.0.clone(), options).erased()
+    /// Erase the concrete type information, returning a type-erased [`ScalarFnRef`].
+    pub fn erased(self) -> ScalarFnRef {
+        ScalarFnRef(Arc::new(self))
     }
 }
 
-// ============================================================================
-// DynScalarFn — bound trait (for ScalarFnRef), options stored in self
-// ============================================================================
-
 /// An object-safe, sealed trait for bound scalar function dispatch.
 ///
-/// Options are stored inside the implementing [`ScalarFnInner<V>`], not passed externally.
+/// Options are stored inside the implementing [`ScalarFn<V>`], not passed externally.
 /// This is the sole trait behind [`ScalarFnRef`]'s `Arc<dyn DynScalarFn>`.
-pub(crate) trait DynScalarFn: 'static + Send + Sync + super::sealed::Sealed {
+pub(super) trait DynScalarFn: 'static + Send + Sync + super::sealed::Sealed {
     fn as_any(&self) -> &dyn Any;
     fn id(&self) -> ScalarFnId;
     fn options_any(&self) -> &dyn Any;
 
     // Bound methods — options accessed from self
-    fn execute(&self, args: ExecutionArgs) -> VortexResult<ArrayRef>;
+    fn execute(&self, args: &dyn ExecutionArgs, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef>;
     fn return_dtype(&self, arg_types: &[DType]) -> VortexResult<DType>;
+    fn coerce_args(&self, arg_types: &[DType]) -> VortexResult<Vec<DType>>;
     fn reduce(
         &self,
         node: &dyn ReduceNode,
@@ -147,20 +121,7 @@ pub(crate) trait DynScalarFn: 'static + Send + Sync + super::sealed::Sealed {
     fn options_debug(&self, f: &mut Formatter<'_>) -> fmt::Result;
 }
 
-// ============================================================================
-// ScalarFnInner<V> — bound adapter (vtable + options)
-// ============================================================================
-
-/// The private inner representation of a bound scalar function, pairing a vtable with its options.
-///
-/// This is the sole implementor of [`DynScalarFn`], enabling [`ScalarFnRef`] to safely downcast
-/// back to the concrete vtable type via [`Any`].
-pub(super) struct ScalarFnInner<V: ScalarFnVTable> {
-    pub(super) vtable: V,
-    pub(super) options: V::Options,
-}
-
-impl<V: ScalarFnVTable> DynScalarFn for ScalarFnInner<V> {
+impl<V: ScalarFnVTable> DynScalarFn for ScalarFn<V> {
     #[inline(always)]
     fn as_any(&self) -> &dyn Any {
         self
@@ -175,19 +136,17 @@ impl<V: ScalarFnVTable> DynScalarFn for ScalarFnInner<V> {
         &self.options
     }
 
-    fn execute(&self, args: ExecutionArgs) -> VortexResult<ArrayRef> {
-        let expected_row_count = args.row_count;
+    fn execute(&self, args: &dyn ExecutionArgs, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+        let expected_row_count = args.row_count();
         #[cfg(debug_assertions)]
         let expected_dtype = {
-            let args_dtypes: Vec<DType> = args
-                .inputs
-                .iter()
-                .map(|array| array.dtype().clone())
-                .collect();
+            let args_dtypes: Vec<DType> = (0..args.num_inputs())
+                .map(|i| args.get(i).map(|a| a.dtype().clone()))
+                .collect::<VortexResult<_>>()?;
             V::return_dtype(&self.vtable, &self.options, &args_dtypes)
         }?;
 
-        let result = V::execute(&self.vtable, &self.options, args)?;
+        let result = V::execute(&self.vtable, &self.options, args, ctx)?;
 
         assert_eq!(
             result.len(),
@@ -216,6 +175,10 @@ impl<V: ScalarFnVTable> DynScalarFn for ScalarFnInner<V> {
         V::return_dtype(&self.vtable, &self.options, arg_dtypes)
     }
 
+    fn coerce_args(&self, arg_types: &[DType]) -> VortexResult<Vec<DType>> {
+        V::coerce_args(&self.vtable, &self.options, arg_types)
+    }
+
     fn reduce(
         &self,
         node: &dyn ReduceNode,
@@ -299,38 +262,3 @@ impl<V: ScalarFnVTable> DynScalarFn for ScalarFnInner<V> {
         Debug::fmt(&self.options, f)
     }
 }
-
-// ============================================================================
-// ScalarFn<V> — typed wrapper
-// ============================================================================
-
-/// A typed scalar function instance, parameterized by a concrete [`ScalarFnVTable`].
-///
-/// You can construct one via [`new()`], and erase the type with [`erased()`] to obtain a
-/// [`ScalarFnRef`].
-///
-/// [`new()`]: ScalarFn::new
-/// [`erased()`]: ScalarFn::erased
-pub struct ScalarFn<V: ScalarFnVTable>(pub(super) Arc<ScalarFnInner<V>>);
-
-impl<V: ScalarFnVTable> ScalarFn<V> {
-    /// Create a new typed scalar function instance.
-    pub fn new(vtable: V, options: V::Options) -> Self {
-        Self(Arc::new(ScalarFnInner { vtable, options }))
-    }
-
-    /// Returns a reference to the vtable.
-    pub fn vtable(&self) -> &V {
-        &self.0.vtable
-    }
-
-    /// Returns a reference to the options.
-    pub fn options(&self) -> &V::Options {
-        &self.0.options
-    }
-
-    /// Erase the concrete type information, returning a type-erased [`ScalarFnRef`].
-    pub fn erased(self) -> ScalarFnRef {
-        ScalarFnRef(self.0)
-    }
-}
diff --git a/vortex-array/src/scalar_fn/vtable.rs b/vortex-array/src/scalar_fn/vtable.rs
index d35cabca6b1..c9588e8aa13 100644
--- a/vortex-array/src/scalar_fn/vtable.rs
+++ b/vortex-array/src/scalar_fn/vtable.rs
@@ -13,6 +13,7 @@ use arcref::ArcRef;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
 use vortex_session::VortexSession;
 
 use crate::ArrayRef;
@@ -67,7 +68,7 @@ pub trait ScalarFnVTable: 'static + Sized + Clone + Send + Sync {
     /// Returns the name of the nth child of the expr.
     fn child_name(&self, options: &Self::Options, child_idx: usize) -> ChildName;
 
-    /// Format this expression in nice human-readable SQL-style format
+    /// Format this expression in a nice human-readable SQL-style format
     ///
     /// The implementation should recursively format child expressions by calling
     /// `expr.child(i).fmt_sql(f)`.
@@ -78,8 +79,30 @@ pub trait ScalarFnVTable: 'static + Sized + Clone + Send + Sync {
         f: &mut Formatter<'_>,
     ) -> fmt::Result;
 
+    /// Coerce the arguments of this function.
+    ///
+    /// This is optionally used by Vortex users when performing type coercion over a Vortex
+    /// expression. Note that direct Vortex query engine integrations (e.g. DuckDB, DataFusion,
+    /// etc.) do not perform type coercion and rely on the engine's own logical planner.
+    ///
+    /// Note that the default implementation simply returns the arguments without coercion, and it
+    /// is expected that the [`ScalarFnVTable::return_dtype`] call may still fail.
+    fn coerce_args(&self, options: &Self::Options, args: &[DType]) -> VortexResult<Vec<DType>> {
+        let _ = options;
+        Ok(args.to_vec())
+    }
+
     /// Compute the return [`DType`] of the expression if evaluated over the given input types.
-    fn return_dtype(&self, options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType>;
+    ///
+    /// # Preconditions
+    ///
+    /// The length of `args` must match the [`Arity`] of this function. Callers are responsible
+    /// for validating this (e.g., [`Expression::try_new`] checks arity at construction time).
+    /// Implementations may assume correct arity and will panic or return nonsensical results if
+    /// violated.
+    ///
+    /// [`Expression::try_new`]: crate::expr::Expression::try_new
+    fn return_dtype(&self, options: &Self::Options, args: &[DType]) -> VortexResult<DType>;
 
     /// Execute the expression over the input arguments.
     ///
@@ -92,7 +115,12 @@ pub trait ScalarFnVTable: 'static + Sized + Clone + Send + Sync {
     ///
     /// This provides maximum opportunities for array-level optimizations using execute_parent
     /// kernels.
-    fn execute(&self, options: &Self::Options, args: ExecutionArgs) -> VortexResult<ArrayRef>;
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef>;
 
     /// Implement an abstract reduction rule over a tree of scalar functions.
     ///
@@ -199,12 +227,25 @@ pub trait ScalarFnVTable: 'static + Sized + Clone + Send + Sync {
         true
     }
 
-    /// Returns whether this expression itself is fallible. Conservatively default to *true*.
+    /// Returns whether this expression is semantically fallible. Conservatively defaults to
+    /// `true`.
+    ///
+    /// An expression is semantically fallible if there exists a set of well-typed inputs that
+    /// causes the expression to produce an error as part of its _defined behavior_. For example,
+    /// `checked_add` is fallible because integer overflow is a domain error, and division is
+    /// fallible because of division by zero.
     ///
-    /// An expression is runtime fallible is there is an input set that causes the expression to
-    /// panic or return an error, for example checked_add is fallible if there is overflow.
+    /// This does **not** include execution errors that are incidental to the implementation, such
+    /// as canonicalization failures, memory allocation errors, or encoding mismatches. Those can
+    /// happen to any expression and are not what this method captures.
     ///
-    /// Note: this is only applicable to expressions that pass type-checking
+    /// This property is used by optimizations that speculatively evaluate an expression over values
+    /// that may not appear in the actual input. For example, pushing a scalar function down to a
+    /// dictionary's values array is only safe when the function is infallible or all values are
+    /// referenced, since a fallible function might error on a value left unreferenced after
+    /// slicing that would never be encountered during normal evaluation.
+    ///
+    /// Note: this is only applicable to expressions that pass type-checking via
     /// [`ScalarFnVTable::return_dtype`].
     fn is_fallible(&self, options: &Self::Options) -> bool {
         _ = options;
@@ -291,13 +332,48 @@ pub trait SimplifyCtx {
 }
 
 /// Arguments for expression execution.
-pub struct ExecutionArgs<'a> {
-    /// The inputs for the expression, one per child.
-    pub inputs: Vec<ArrayRef>,
-    /// The row count of the execution scope.
-    pub row_count: usize,
-    /// The execution context.
-    pub ctx: &'a mut ExecutionCtx,
+pub trait ExecutionArgs {
+    /// Returns the input array at the given index.
+    fn get(&self, index: usize) -> VortexResult<ArrayRef>;
+
+    /// Returns the number of inputs.
+    fn num_inputs(&self) -> usize;
+
+    /// Returns the row count of the execution scope.
+    fn row_count(&self) -> usize;
+}
+
+/// A concrete [`ExecutionArgs`] backed by a `Vec<ArrayRef>`.
+pub struct VecExecutionArgs {
+    inputs: Vec<ArrayRef>,
+    row_count: usize,
+}
+
+impl VecExecutionArgs {
+    /// Create a new `VecExecutionArgs`.
+    pub fn new(inputs: Vec<ArrayRef>, row_count: usize) -> Self {
+        Self { inputs, row_count }
+    }
+}
+
+impl ExecutionArgs for VecExecutionArgs {
+    fn get(&self, index: usize) -> VortexResult<ArrayRef> {
+        self.inputs.get(index).cloned().ok_or_else(|| {
+            vortex_err!(
+                "Input index {} out of bounds (num_inputs={})",
+                index,
+                self.inputs.len()
+            )
+        })
+    }
+
+    fn num_inputs(&self) -> usize {
+        self.inputs.len()
+    }
+
+    fn row_count(&self) -> usize {
+        self.row_count
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
diff --git a/vortex-array/src/search_sorted.rs b/vortex-array/src/search_sorted.rs
index 15f3c2843bb..cf096bbb8e2 100644
--- a/vortex-array/src/search_sorted.rs
+++ b/vortex-array/src/search_sorted.rs
@@ -12,7 +12,7 @@ use std::hint;
 
 use vortex_error::VortexResult;
 
-use crate::Array;
+use crate::ArrayRef;
 use crate::scalar::Scalar;
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -262,7 +262,7 @@ fn search_sorted_side_idx<F: FnMut(usize) -> VortexResult<Ordering>>(
     }
 }
 
-impl IndexOrd<Scalar> for dyn Array + '_ {
+impl IndexOrd<Scalar> for ArrayRef {
     fn index_cmp(&self, idx: usize, elem: &Scalar) -> VortexResult<Option<Ordering>> {
         let scalar_a = self.scalar_at(idx)?;
         Ok(scalar_a.partial_cmp(elem))
diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs
index d360a7bc35c..68a00569caf 100644
--- a/vortex-array/src/serde.rs
+++ b/vortex-array/src/serde.rs
@@ -24,13 +24,12 @@ use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::array as fba;
 use vortex_flatbuffers::array::Compression;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::Array;
 use crate::ArrayContext;
 use crate::ArrayRef;
-use crate::ArrayVisitor;
-use crate::ArrayVisitorExt;
+use crate::array::new_foreign_array;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::dtype::TryFromBytes;
@@ -47,7 +46,7 @@ pub struct SerializeOptions {
     pub include_padding: bool,
 }
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Serialize the array into a sequence of byte buffers that should be written contiguously.
     /// This function returns a vec to avoid copying data buffers.
     ///
@@ -61,6 +60,7 @@ impl dyn Array + '_ {
     pub fn serialize(
         &self,
         ctx: &ArrayContext,
+        session: &VortexSession,
         options: &SerializeOptions,
     ) -> VortexResult<Vec<ByteBuffer>> {
         // Collect all array buffers
@@ -119,7 +119,7 @@ impl dyn Array + '_ {
         // Set up the flatbuffer builder
         let mut fbb = FlatBufferBuilder::new();
 
-        let root = ArrayNodeFlatBuffer::try_new(ctx, self)?;
+        let root = ArrayNodeFlatBuffer::try_new(ctx, session, self)?;
         let fb_root = root.try_write_flatbuffer(&mut fbb)?;
 
         let fb_buffers = fbb.create_vector(&fb_buffers);
@@ -159,15 +159,21 @@ impl dyn Array + '_ {
 /// A utility struct for creating an [`fba::ArrayNode`] flatbuffer.
 pub struct ArrayNodeFlatBuffer<'a> {
     ctx: &'a ArrayContext,
-    array: &'a dyn Array,
+    session: &'a VortexSession,
+    array: &'a ArrayRef,
     buffer_idx: u16,
 }
 
 impl<'a> ArrayNodeFlatBuffer<'a> {
-    pub fn try_new(ctx: &'a ArrayContext, array: &'a dyn Array) -> VortexResult<Self> {
+    pub fn try_new(
+        ctx: &'a ArrayContext,
+        session: &'a VortexSession,
+        array: &'a ArrayRef,
+    ) -> VortexResult<Self> {
         // Depth-first traversal of the array to ensure it supports serialization.
+        // FIXME(ngates): this serializes the metadata and throws it away!
         for child in array.depth_first_traversal() {
-            if child.metadata()?.is_none() {
+            if child.metadata(session)?.is_none() {
                 vortex_bail!(
                     "Array {} does not support serialization",
                     child.encoding_id()
@@ -183,6 +189,7 @@ impl<'a> ArrayNodeFlatBuffer<'a> {
         };
         Ok(Self {
             ctx,
+            session,
             array,
             buffer_idx: 0,
         })
@@ -203,7 +210,7 @@ impl<'a> ArrayNodeFlatBuffer<'a> {
                 )
             })?;
 
-        let metadata = self.array.metadata()?.ok_or_else(|| {
+        let metadata = self.array.metadata(self.session)?.ok_or_else(|| {
             vortex_err!(
                 "Array {} does not support serialization",
                 self.array.encoding_id()
@@ -216,7 +223,7 @@ impl<'a> ArrayNodeFlatBuffer<'a> {
             .map_err(|_| vortex_err!("Array can have at most u16::MAX buffers"))?;
         let mut child_buffer_idx = self.buffer_idx + nbuffers;
 
-        let children = &self
+        let children = self
             .array
             .children()
             .iter()
@@ -224,6 +231,7 @@ impl<'a> ArrayNodeFlatBuffer<'a> {
                 // Update the number of buffers required.
                 let msg = ArrayNodeFlatBuffer {
                     ctx: self.ctx,
+                    session: self.session,
                     array: child,
                     buffer_idx: child_buffer_idx,
                 }
@@ -237,7 +245,7 @@ impl<'a> ArrayNodeFlatBuffer<'a> {
                 Ok(msg)
             })
             .collect::<VortexResult<Vec<_>>>()?;
-        let children = Some(fbb.create_vector(children));
+        let children = Some(fbb.create_vector(&children));
 
         let buffers = Some(fbb.create_vector_from_iter((0..nbuffers).map(|i| i + self.buffer_idx)));
         let stats = Some(self.array.statistics().write_flatbuffer(fbb)?);
@@ -270,27 +278,27 @@ pub trait ArrayChildren {
     }
 }
 
-impl ArrayChildren for &[ArrayRef] {
+impl<T: AsRef<[ArrayRef]>> ArrayChildren for T {
     fn get(&self, index: usize, dtype: &DType, len: usize) -> VortexResult<ArrayRef> {
-        let array = self[index].clone();
+        let array = self.as_ref()[index].clone();
         assert_eq!(array.len(), len);
         assert_eq!(array.dtype(), dtype);
         Ok(array)
     }
 
     fn len(&self) -> usize {
-        <[_]>::len(self)
+        self.as_ref().len()
     }
 }
 
-/// [`ArrayParts`] represents a parsed but not-yet-decoded deserialized [`Array`].
+/// [`SerializedArray`] represents a parsed but not-yet-decoded deserialized array.
 /// It contains all the information from the serialized form, without anything extra. i.e.
 /// it is missing a [`DType`] and `len`, and the `encoding_id` is not yet resolved to a concrete
 /// vtable.
 ///
-/// An [`ArrayParts`] can be fully decoded into an [`ArrayRef`] using the `decode` function.
+/// An [`SerializedArray`] can be fully decoded into an [`ArrayRef`] using the `decode` function.
 #[derive(Clone)]
-pub struct ArrayParts {
+pub struct SerializedArray {
     // Typed as fb::ArrayNode
     flatbuffer: FlatBuffer,
     // The location of the current fb::ArrayNode
@@ -298,9 +306,9 @@ pub struct ArrayParts {
     buffers: Arc<[BufferHandle]>,
 }
 
-impl Debug for ArrayParts {
+impl Debug for SerializedArray {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ArrayParts")
+        f.debug_struct("SerializedArray")
             .field("encoding_id", &self.encoding_id())
             .field("children", &(0..self.nchildren()).map(|i| self.child(i)))
             .field(
@@ -312,42 +320,36 @@ impl Debug for ArrayParts {
     }
 }
 
-impl ArrayParts {
-    /// Decode an [`ArrayParts`] into an [`ArrayRef`].
+impl SerializedArray {
+    /// Decode an [`SerializedArray`] into an [`ArrayRef`].
     pub fn decode(
         &self,
         dtype: &DType,
         len: usize,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
         session: &VortexSession,
     ) -> VortexResult<ArrayRef> {
         let encoding_idx = self.flatbuffer().encoding();
         let encoding_id = ctx
             .resolve(encoding_idx)
             .ok_or_else(|| vortex_err!("Unknown encoding index: {}", encoding_idx))?;
-        let vtable = session
-            .arrays()
-            .registry()
-            .find(&encoding_id)
-            .ok_or_else(|| vortex_err!("Unknown encoding: {}", encoding_id))?;
-
-        let children = ArrayPartsChildren {
-            parts: self,
+        let Some(plugin) = session.arrays().registry().find(&encoding_id) else {
+            if session.allows_unknown() {
+                return self.decode_foreign(encoding_id, dtype, len, ctx);
+            }
+            return Err(vortex_err!("Unknown encoding: {}", encoding_id));
+        };
+
+        let children = SerializedArrayChildren {
+            ser: self,
             ctx,
             session,
         };
 
         let buffers = self.collect_buffers()?;
 
-        let decoded = vtable.build(
-            encoding_id.clone(),
-            dtype,
-            len,
-            self.metadata(),
-            &buffers,
-            &children,
-            session,
-        )?;
+        let decoded =
+            plugin.deserialize(dtype, len, self.metadata(), &buffers, &children, session)?;
 
         assert_eq!(
             decoded.len(),
@@ -377,12 +379,40 @@ impl ArrayParts {
         if let Some(stats) = self.flatbuffer().stats() {
             decoded
                 .statistics()
-                .set_iter(StatsSet::from_flatbuffer(&stats, dtype)?.into_iter());
+                .set_iter(StatsSet::from_flatbuffer(&stats, dtype, session)?.into_iter());
         }
 
         Ok(decoded)
     }
 
+    fn decode_foreign(
+        &self,
+        encoding_id: crate::array::ArrayId,
+        dtype: &DType,
+        len: usize,
+        ctx: &ReadContext,
+    ) -> VortexResult<ArrayRef> {
+        let children = (0..self.nchildren())
+            .map(|idx| {
+                let child = self.child(idx);
+                let child_encoding_idx = child.flatbuffer().encoding();
+                let child_encoding_id = ctx
+                    .resolve(child_encoding_idx)
+                    .ok_or_else(|| vortex_err!("Unknown encoding index: {}", child_encoding_idx))?;
+                child.decode_foreign(child_encoding_id, dtype, len, ctx)
+            })
+            .collect::<VortexResult<Vec<_>>>()?;
+
+        new_foreign_array(
+            encoding_id,
+            dtype.clone(),
+            len,
+            self.metadata().to_vec(),
+            self.collect_buffers()?.into_owned(),
+            children,
+        )
+    }
+
     /// Returns the array encoding.
     pub fn encoding_id(&self) -> u16 {
         self.flatbuffer().encoding()
@@ -404,7 +434,7 @@ impl ArrayParts {
     }
 
     /// Returns the nth child of the array.
-    pub fn child(&self, idx: usize) -> ArrayParts {
+    pub fn child(&self, idx: usize) -> SerializedArray {
         let children = self
             .flatbuffer()
             .children()
@@ -489,7 +519,7 @@ impl ArrayParts {
     /// without needing to access the actual buffer data.
     pub fn buffer_lengths(&self) -> Vec<usize> {
         let fb_array = root::<fba::Array>(self.flatbuffer.as_ref())
-            .vortex_expect("ArrayParts flatbuffer must be a valid Array");
+            .vortex_expect("SerializedArray flatbuffer must be a valid Array");
         fb_array
             .buffers()
             .map(|buffers| buffers.iter().map(|b| b.length() as usize).collect())
@@ -507,7 +537,7 @@ impl ArrayParts {
         Ok((fb_buffer, flatbuffer_loc))
     }
 
-    /// Create an [`ArrayParts`] from a pre-existing array tree flatbuffer and pre-resolved buffer
+    /// Create an [`SerializedArray`] from a pre-existing array tree flatbuffer and pre-resolved buffer
     /// handles.
     ///
     /// The caller is responsible for resolving buffers from whatever source (device segments, host
@@ -518,24 +548,24 @@ impl ArrayParts {
         buffers: Vec<BufferHandle>,
     ) -> VortexResult<Self> {
         let (flatbuffer, flatbuffer_loc) = Self::validate_array_tree(array_tree)?;
-        Ok(ArrayParts {
+        Ok(SerializedArray {
             flatbuffer,
             flatbuffer_loc,
             buffers: buffers.into(),
         })
     }
 
-    /// Create an [`ArrayParts`] from a raw array tree flatbuffer (metadata only).
+    /// Create an [`SerializedArray`] from a raw array tree flatbuffer (metadata only).
     ///
-    /// This constructor creates an `ArrayParts` with no buffer data, useful for
+    /// This constructor creates a `SerializedArray` with no buffer data, useful for
     /// inspecting the metadata when the actual buffer data is not needed
     /// (e.g., displaying buffer sizes from inlined array tree metadata).
     ///
-    /// Note: Calling `buffer()` on the returned `ArrayParts` will fail since
+    /// Note: Calling `buffer()` on the returned `SerializedArray` will fail since
     /// no actual buffer data is available.
     pub fn from_array_tree(array_tree: impl Into<ByteBuffer>) -> VortexResult<Self> {
         let (flatbuffer, flatbuffer_loc) = Self::validate_array_tree(array_tree)?;
-        Ok(ArrayParts {
+        Ok(SerializedArray {
             flatbuffer,
             flatbuffer_loc,
             buffers: Arc::new([]),
@@ -547,7 +577,7 @@ impl ArrayParts {
         unsafe { fba::ArrayNode::follow(self.flatbuffer.as_ref(), self.flatbuffer_loc) }
     }
 
-    /// Returns a new [`ArrayParts`] with the given node as the root
+    /// Returns a new [`SerializedArray`] with the given node as the root
     // TODO(ngates): we may want a wrapper that avoids this clone.
     fn with_root(&self, root: fba::ArrayNode) -> Self {
         let mut this = self.clone();
@@ -555,7 +585,7 @@ impl ArrayParts {
         this
     }
 
-    /// Create an [`ArrayParts`] from a pre-existing flatbuffer (ArrayNode) and a segment containing
+    /// Create an [`SerializedArray`] from a pre-existing flatbuffer (ArrayNode) and a segment containing
     /// only the data buffers (without the flatbuffer suffix).
     ///
     /// This is used when the flatbuffer is stored separately in layout metadata (e.g., when
@@ -568,7 +598,7 @@ impl ArrayParts {
         Self::from_flatbuffer_and_segment_with_overrides(array_tree, segment, &HashMap::new())
     }
 
-    /// Create an [`ArrayParts`] from a pre-existing flatbuffer (ArrayNode) and a segment,
+    /// Create an [`SerializedArray`] from a pre-existing flatbuffer (ArrayNode) and a segment,
     /// substituting host-resident buffer overrides for specific buffer indices.
     ///
     /// Buffers whose index appears in `buffer_overrides` are resolved from the provided
@@ -613,7 +643,7 @@ impl ArrayParts {
             })
             .collect::<VortexResult<Arc<[_]>>>()?;
 
-        Ok(ArrayParts {
+        Ok(SerializedArray {
             flatbuffer: fb_buffer,
             flatbuffer_loc,
             buffers,
@@ -621,31 +651,31 @@ impl ArrayParts {
     }
 }
 
-struct ArrayPartsChildren<'a> {
-    parts: &'a ArrayParts,
-    ctx: &'a ArrayContext,
+struct SerializedArrayChildren<'a> {
+    ser: &'a SerializedArray,
+    ctx: &'a ReadContext,
     session: &'a VortexSession,
 }
 
-impl ArrayChildren for ArrayPartsChildren<'_> {
+impl ArrayChildren for SerializedArrayChildren<'_> {
     fn get(&self, index: usize, dtype: &DType, len: usize) -> VortexResult<ArrayRef> {
-        self.parts
+        self.ser
             .child(index)
             .decode(dtype, len, self.ctx, self.session)
     }
 
     fn len(&self) -> usize {
-        self.parts.nchildren()
+        self.ser.nchildren()
     }
 }
 
-impl TryFrom<ByteBuffer> for ArrayParts {
+impl TryFrom<ByteBuffer> for SerializedArray {
     type Error = VortexError;
 
     fn try_from(value: ByteBuffer) -> Result<Self, Self::Error> {
         // The final 4 bytes contain the length of the flatbuffer.
         if value.len() < 4 {
-            vortex_bail!("ArrayParts buffer is too short");
+            vortex_bail!("SerializedArray buffer is too short");
         }
 
         // We align each buffer individually, so we remove alignment requirements on the buffer.
@@ -653,7 +683,7 @@ impl TryFrom<ByteBuffer> for ArrayParts {
 
         let fb_length = u32::try_from_le_bytes(&value.as_slice()[value.len() - 4..])? as usize;
         if value.len() < 4 + fb_length {
-            vortex_bail!("ArrayParts buffer is too short for flatbuffer");
+            vortex_bail!("SerializedArray buffer is too short for flatbuffer");
         }
 
         let fb_offset = value.len() - 4 - fb_length;
@@ -664,10 +694,108 @@ impl TryFrom<ByteBuffer> for ArrayParts {
     }
 }
 
-impl TryFrom<BufferHandle> for ArrayParts {
+impl TryFrom<BufferHandle> for SerializedArray {
     type Error = VortexError;
 
     fn try_from(value: BufferHandle) -> Result<Self, Self::Error> {
         Self::try_from(value.try_to_host_sync()?)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use flatbuffers::FlatBufferBuilder;
+    use vortex_session::VortexSession;
+    use vortex_session::registry::ReadContext;
+
+    use super::SerializeOptions;
+    use super::SerializedArray;
+    use crate::ArrayContext;
+    use crate::array::ArrayId;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::flatbuffers as fba;
+    use crate::session::ArraySession;
+
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
+
+    #[test]
+    fn unknown_array_encoding_allow_unknown() {
+        let mut fbb = FlatBufferBuilder::new();
+
+        let child_metadata = fbb.create_vector(&[9u8]);
+        let child = fba::ArrayNode::create(
+            &mut fbb,
+            &fba::ArrayNodeArgs {
+                encoding: 1,
+                metadata: Some(child_metadata),
+                children: None,
+                buffers: None,
+                stats: None,
+            },
+        );
+
+        let children = fbb.create_vector(&[child]);
+        let metadata = fbb.create_vector(&[1u8, 2, 3]);
+        let root = fba::ArrayNode::create(
+            &mut fbb,
+            &fba::ArrayNodeArgs {
+                encoding: 0,
+                metadata: Some(metadata),
+                children: Some(children),
+                buffers: None,
+                stats: None,
+            },
+        );
+        let array = fba::Array::create(
+            &mut fbb,
+            &fba::ArrayArgs {
+                root: Some(root),
+                buffers: None,
+            },
+        );
+        fbb.finish_minimal(array);
+        let (buf, start) = fbb.collapse();
+        let tree = vortex_buffer::ByteBuffer::from(buf).slice(start..);
+
+        let ser = SerializedArray::from_array_tree(tree).unwrap();
+        let ctx = ReadContext::new([
+            ArrayId::new_ref("vortex.test.foreign_array"),
+            ArrayId::new_ref("vortex.test.foreign_child"),
+        ]);
+        let session = VortexSession::empty()
+            .with::<ArraySession>()
+            .allow_unknown();
+
+        let decoded = ser
+            .decode(&DType::Variant(Nullability::Nullable), 5, &ctx, &session)
+            .unwrap();
+        assert_eq!(decoded.encoding_id().as_ref(), "vortex.test.foreign_array");
+        assert_eq!(decoded.nchildren(), 1);
+        assert_eq!(
+            decoded.nth_child(0).unwrap().encoding_id().as_ref(),
+            "vortex.test.foreign_child"
+        );
+        assert_eq!(decoded.metadata(&SESSION).unwrap().unwrap(), vec![1, 2, 3]);
+        assert_eq!(
+            decoded
+                .nth_child(0)
+                .unwrap()
+                .metadata(&SESSION)
+                .unwrap()
+                .unwrap(),
+            vec![9]
+        );
+
+        let serialized = decoded
+            .serialize(
+                &ArrayContext::default(),
+                &SESSION,
+                &SerializeOptions::default(),
+            )
+            .unwrap();
+        assert!(!serialized.is_empty());
+    }
+}
diff --git a/vortex-array/src/session/mod.rs b/vortex-array/src/session/mod.rs
index 7caa908940c..62ed46cb34c 100644
--- a/vortex-array/src/session/mod.rs
+++ b/vortex-array/src/session/mod.rs
@@ -1,28 +1,33 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
+use vortex_error::VortexResult;
 use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::registry::Registry;
 
-use crate::arrays::BoolVTable;
-use crate::arrays::ChunkedVTable;
-use crate::arrays::ConstantVTable;
-use crate::arrays::DecimalVTable;
-use crate::arrays::ExtensionVTable;
-use crate::arrays::FixedSizeListVTable;
-use crate::arrays::ListVTable;
-use crate::arrays::ListViewVTable;
-use crate::arrays::MaskedVTable;
-use crate::arrays::NullVTable;
-use crate::arrays::PrimitiveVTable;
-use crate::arrays::StructVTable;
-use crate::arrays::VarBinVTable;
-use crate::arrays::VarBinViewVTable;
-use crate::vtable::ArrayId;
-use crate::vtable::DynVTable;
+use crate::ArrayRef;
+use crate::array::ArrayPlugin;
+use crate::array::ArrayPluginRef;
+use crate::arrays::Bool;
+use crate::arrays::Chunked;
+use crate::arrays::Constant;
+use crate::arrays::Decimal;
+use crate::arrays::Extension;
+use crate::arrays::FixedSizeList;
+use crate::arrays::List;
+use crate::arrays::ListView;
+use crate::arrays::Masked;
+use crate::arrays::Null;
+use crate::arrays::Patched;
+use crate::arrays::Primitive;
+use crate::arrays::Struct;
+use crate::arrays::VarBin;
+use crate::arrays::VarBinView;
 
-pub type ArrayRegistry = Registry<&'static dyn DynVTable>;
+pub type ArrayRegistry = Registry<ArrayPluginRef>;
 
 #[derive(Debug)]
 pub struct ArraySession {
@@ -31,41 +36,49 @@ pub struct ArraySession {
 }
 
 impl ArraySession {
+    pub fn empty() -> ArraySession {
+        Self {
+            registry: ArrayRegistry::default(),
+        }
+    }
+
     pub fn registry(&self) -> &ArrayRegistry {
         &self.registry
     }
 
     /// Register a new array encoding, replacing any existing encoding with the same ID.
-    pub fn register(&self, id: impl Into<ArrayId>, encoding: impl Into<&'static dyn DynVTable>) {
-        self.registry.register(id.into(), encoding.into())
+    pub fn register<P: ArrayPlugin>(&self, plugin: P) {
+        self.registry
+            .register(plugin.id(), Arc::new(plugin) as ArrayPluginRef);
     }
 }
 
 impl Default for ArraySession {
     fn default() -> Self {
-        let encodings = ArrayRegistry::default();
+        let this = ArraySession {
+            registry: ArrayRegistry::default(),
+        };
 
         // Register the canonical encodings.
-        encodings.register(NullVTable::ID, NullVTable);
-        encodings.register(BoolVTable::ID, BoolVTable);
-        encodings.register(PrimitiveVTable::ID, PrimitiveVTable);
-        encodings.register(DecimalVTable::ID, DecimalVTable);
-        encodings.register(VarBinViewVTable::ID, VarBinViewVTable);
-        encodings.register(ListViewVTable::ID, ListViewVTable);
-        encodings.register(FixedSizeListVTable::ID, FixedSizeListVTable);
-        encodings.register(StructVTable::ID, StructVTable);
-        encodings.register(ExtensionVTable::ID, ExtensionVTable);
+        this.register(Null);
+        this.register(Bool);
+        this.register(Primitive);
+        this.register(Decimal);
+        this.register(VarBinView);
+        this.register(ListView);
+        this.register(FixedSizeList);
+        this.register(Struct);
+        this.register(Extension);
 
         // Register the utility encodings.
-        encodings.register(ChunkedVTable::ID, ChunkedVTable);
-        encodings.register(ConstantVTable::ID, ConstantVTable);
-        encodings.register(MaskedVTable::ID, MaskedVTable);
-        encodings.register(ListVTable::ID, ListVTable);
-        encodings.register(VarBinVTable::ID, VarBinVTable);
+        this.register(Chunked);
+        this.register(Constant);
+        this.register(List);
+        this.register(Masked);
+        this.register(Patched);
+        this.register(VarBin);
 
-        Self {
-            registry: encodings,
-        }
+        this
     }
 }
 
@@ -75,6 +88,14 @@ pub trait ArraySessionExt: SessionExt {
     fn arrays(&self) -> Ref<'_, ArraySession> {
         self.get::<ArraySession>()
     }
+
+    /// Serialize an array using a plugin from the registry.
+    fn array_serialize(&self, array: &ArrayRef) -> VortexResult<Option<Vec<u8>>> {
+        let Some(plugin) = self.arrays().registry.find(&array.encoding_id()) else {
+            return Ok(None);
+        };
+        plugin.serialize(array, &self.session())
+    }
 }
 
 impl<S: SessionExt> ArraySessionExt for S {}
diff --git a/vortex-array/src/session/rewrite.rs b/vortex-array/src/session/rewrite.rs
deleted file mode 100644
index 58f84c6f5ea..00000000000
--- a/vortex-array/src/session/rewrite.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::sync::Arc;
-
-use vortex_error::VortexResult;
-use vortex_utils::aliases::dash_map::DashMap;
-
-use crate::array::ArrayRef;
-use crate::transform::context::ArrayRuleContext;
-use crate::transform::rules::AnyArrayParent;
-use crate::transform::rules::ArrayParentMatcher;
-use crate::transform::rules::ArrayParentReduceRule;
-use crate::transform::rules::ArrayReduceRule;
-use crate::vtable::ArrayId;
-use crate::vtable::VTable;
-
-/// Dynamic trait for array reduce rules
-pub trait DynArrayReduceRule: Debug + Send + Sync {
-    fn reduce(&self, array: &ArrayRef, ctx: &ArrayRuleContext) -> VortexResult<Option<ArrayRef>>;
-}
-
-/// Dynamic trait for array parent reduce rules
-pub trait DynArrayParentReduceRule: Debug + Send + Sync {
-    fn reduce_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &ArrayRuleContext,
-    ) -> VortexResult<Option<ArrayRef>>;
-}
-
-/// Adapter for ArrayReduceRule
-struct ArrayReduceRuleAdapter<V: VTable, R> {
-    rule: R,
-    _phantom: PhantomData<V>,
-}
-
-impl<V: VTable, R: Debug> Debug for ArrayReduceRuleAdapter<V, R> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ArrayReduceRuleAdapter")
-            .field("rule", &self.rule)
-            .finish()
-    }
-}
-
-/// Adapter for ArrayParentReduceRule
-struct ArrayParentReduceRuleAdapter<Child: VTable, Parent: ArrayParentMatcher, R> {
-    rule: R,
-    _phantom: PhantomData<(Child, Parent)>,
-}
-
-impl<Child: VTable, Parent: ArrayParentMatcher, R: Debug> Debug
-    for ArrayParentReduceRuleAdapter<Child, Parent, R>
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ArrayParentReduceRuleAdapter")
-            .field("rule", &self.rule)
-            .finish()
-    }
-}
-
-impl<V, R> DynArrayReduceRule for ArrayReduceRuleAdapter<V, R>
-where
-    V: VTable,
-    R: ArrayReduceRule<V>,
-{
-    fn reduce(&self, array: &ArrayRef, ctx: &ArrayRuleContext) -> VortexResult<Option<ArrayRef>> {
-        let Some(view) = array.as_opt::<V>() else {
-            return Ok(None);
-        };
-        self.rule.reduce(view, ctx)
-    }
-}
-
-impl<Child, Parent, R> DynArrayParentReduceRule for ArrayParentReduceRuleAdapter<Child, Parent, R>
-where
-    Child: VTable,
-    Parent: ArrayParentMatcher,
-    R: ArrayParentReduceRule<Child, Parent>,
-{
-    fn reduce_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &ArrayRuleContext,
-    ) -> VortexResult<Option<ArrayRef>> {
-        let Some(view) = array.as_opt::<Child>() else {
-            return Ok(None);
-        };
-        let Some(parent_view) = Parent::try_match(parent) else {
-            return Ok(None);
-        };
-        self.rule.reduce_parent(view, parent_view, child_idx, ctx)
-    }
-}
-
-/// Inner struct that holds all the rule registries.
-/// Wrapped in a single Arc by ArrayRewriteRuleRegistry for efficient cloning.
-#[derive(Default, Debug)]
-struct ArrayRewriteRuleRegistryInner {
-    /// Reduce rules indexed by encoding ID
-    reduce_rules: DashMap<ArrayId, Vec<Arc<dyn DynArrayReduceRule>>>,
-    /// Parent reduce rules for specific parent types, indexed by (child_id, parent_id)
-    parent_rules: DashMap<(ArrayId, ArrayId), Vec<Arc<dyn DynArrayParentReduceRule>>>,
-    /// Wildcard parent rules (match any parent), indexed by child_id only
-    any_parent_rules: DashMap<ArrayId, Vec<Arc<dyn DynArrayParentReduceRule>>>,
-}
-
-/// Registry of array rewrite rules.
-///
-/// Stores rewrite rules indexed by the encoding ID they apply to.
-#[derive(Clone, Debug)]
-pub struct ArrayRewriteRuleRegistry {
-    inner: Arc<ArrayRewriteRuleRegistryInner>,
-}
-
-impl Default for ArrayRewriteRuleRegistry {
-    fn default() -> Self {
-        Self {
-            inner: Arc::new(ArrayRewriteRuleRegistryInner::default()),
-        }
-    }
-}
-
-impl ArrayRewriteRuleRegistry {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Register a reduce rule for a specific array encoding.
-    pub fn register_reduce_rule<V, R>(&self, vtable: &V, rule: R)
-    where
-        V: VTable,
-        R: ArrayReduceRule<V> + 'static,
-    {
-        let adapter = ArrayReduceRuleAdapter {
-            rule,
-            _phantom: PhantomData,
-        };
-        let encoding_id = V::id(vtable);
-        self.inner
-            .reduce_rules
-            .entry(encoding_id)
-            .or_default()
-            .push(Arc::new(adapter));
-    }
-
-    /// Register a parent rule for a specific parent type.
-    pub fn register_parent_rule<Child, Parent, R>(
-        &self,
-        child_encoding: &Child,
-        parent_encoding: &Parent,
-        rule: R,
-    ) where
-        Child: VTable,
-        Parent: VTable,
-        R: ArrayParentReduceRule<Child, Parent> + 'static,
-    {
-        let adapter = ArrayParentReduceRuleAdapter {
-            rule,
-            _phantom: PhantomData,
-        };
-        let child_id = Child::id(child_encoding);
-        let parent_id = Parent::id(parent_encoding);
-        self.inner
-            .parent_rules
-            .entry((child_id, parent_id))
-            .or_default()
-            .push(Arc::new(adapter));
-    }
-
-    /// Register a parent rule that matches ANY parent type (wildcard).
-    pub fn register_any_parent_rule<Child, R>(&self, child_encoding: &Child, rule: R)
-    where
-        Child: VTable,
-        R: ArrayParentReduceRule<Child, AnyArrayParent> + 'static,
-    {
-        let adapter = ArrayParentReduceRuleAdapter {
-            rule,
-            _phantom: PhantomData,
-        };
-        let child_id = Child::id(child_encoding);
-        self.inner
-            .any_parent_rules
-            .entry(child_id)
-            .or_default()
-            .push(Arc::new(adapter));
-    }
-
-    /// Execute a callback with all reduce rules for a given encoding ID.
-    pub(crate) fn with_reduce_rules<F, R>(&self, id: &ArrayId, f: F) -> R
-    where
-        F: FnOnce(&mut dyn Iterator<Item = &dyn DynArrayReduceRule>) -> R,
-    {
-        f(&mut self
-            .inner
-            .reduce_rules
-            .get(id)
-            .iter()
-            .flat_map(|v| v.value())
-            .map(|arc| arc.as_ref()))
-    }
-
-    /// Execute a callback with all parent reduce rules for a given child and parent encoding ID.
-    ///
-    /// Returns rules from both specific parent rules (if parent_id provided) and "any parent" wildcard rules.
-    pub(crate) fn with_parent_rules<F, R>(
-        &self,
-        child_id: &ArrayId,
-        parent_id: Option<&ArrayId>,
-        f: F,
-    ) -> R
-    where
-        F: FnOnce(&mut dyn Iterator<Item = &dyn DynArrayParentReduceRule>) -> R,
-    {
-        let specific_entry = parent_id.and_then(|pid| {
-            self.inner
-                .parent_rules
-                .get(&(child_id.clone(), pid.clone()))
-        });
-        let wildcard_entry = self.inner.any_parent_rules.get(child_id);
-
-        f(&mut specific_entry
-            .iter()
-            .flat_map(|v| v.value())
-            .chain(wildcard_entry.iter().flat_map(|v| v.value()))
-            .map(|arc| arc.as_ref()))
-    }
-}
diff --git a/vortex-array/src/stats/array.rs b/vortex-array/src/stats/array.rs
index 1b1943c65a7..bd2e3cf7dea 100644
--- a/vortex-array/src/stats/array.rs
+++ b/vortex-array/src/stats/array.rs
@@ -14,15 +14,17 @@ use super::MutTypedStatsSetRef;
 use super::StatsSet;
 use super::StatsSetIntoIter;
 use super::TypedStatsSetRef;
-use crate::Array;
+use crate::ArrayRef;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::is_constant::is_constant;
+use crate::aggregate_fn::fns::is_sorted::is_sorted;
+use crate::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use crate::aggregate_fn::fns::min_max::MinMaxResult;
+use crate::aggregate_fn::fns::min_max::min_max;
+use crate::aggregate_fn::fns::nan_count::nan_count;
+use crate::aggregate_fn::fns::sum::sum;
 use crate::builders::builder_with_capacity;
-use crate::compute::MinMaxResult;
-use crate::compute::is_constant;
-use crate::compute::is_sorted;
-use crate::compute::is_strict_sorted;
-use crate::compute::min_max;
-use crate::compute::nan_count;
-use crate::compute::sum;
 use crate::expr::stats::Precision;
 use crate::expr::stats::Stat;
 use crate::expr::stats::StatsProvider;
@@ -41,12 +43,12 @@ pub struct ArrayStats {
 /// Constructed by calling [`ArrayStats::to_ref`].
 pub struct StatsSetRef<'a> {
     // We need to reference back to the array
-    dyn_array_ref: &'a dyn Array,
+    dyn_array_ref: &'a ArrayRef,
     array_stats: &'a ArrayStats,
 }
 
 impl ArrayStats {
-    pub fn to_ref<'a>(&'a self, array: &'a dyn Array) -> StatsSetRef<'a> {
+    pub fn to_ref<'a>(&'a self, array: &'a ArrayRef) -> StatsSetRef<'a> {
         StatsSetRef {
             dyn_array_ref: array,
             array_stats: self,
@@ -81,6 +83,10 @@ impl From<ArrayStats> for StatsSet {
 }
 
 impl StatsSetRef<'_> {
+    pub(crate) fn replace(&self, stats: StatsSet) {
+        *self.array_stats.inner.write() = stats;
+    }
+
     pub fn set_iter(&self, iter: StatsSetIntoIter) {
         let mut guard = self.array_stats.inner.write();
         for (stat, value) in iter {
@@ -130,6 +136,13 @@ impl StatsSetRef<'_> {
         self.array_stats.inner.read().clone()
     }
 
+    /// Returns a clone of the underlying [`ArrayStats`].
+    ///
+    /// Since [`ArrayStats`] uses `Arc` internally, this is a cheap reference-count increment.
+    pub fn to_array_stats(&self) -> ArrayStats {
+        self.array_stats.clone()
+    }
+
     pub fn with_iter<
         F: for<'a> FnOnce(&mut dyn Iterator<Item = &'a (Stat, Precision<ScalarValue>)>) -> R,
         R,
@@ -142,21 +155,27 @@ impl StatsSetRef<'_> {
     }
 
     pub fn compute_stat(&self, stat: Stat) -> VortexResult<Option<Scalar>> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
         // If it's already computed and exact, we can return it.
         if let Some(Precision::Exact(s)) = self.get(stat) {
             return Ok(Some(s));
         }
 
         Ok(match stat {
-            Stat::Min => min_max(self.dyn_array_ref)?.map(|MinMaxResult { min, max: _ }| min),
-            Stat::Max => min_max(self.dyn_array_ref)?.map(|MinMaxResult { min: _, max }| max),
+            Stat::Min => {
+                min_max(self.dyn_array_ref, &mut ctx)?.map(|MinMaxResult { min, max: _ }| min)
+            }
+            Stat::Max => {
+                min_max(self.dyn_array_ref, &mut ctx)?.map(|MinMaxResult { min: _, max }| max)
+            }
             Stat::Sum => {
                 Stat::Sum
                     .dtype(self.dyn_array_ref.dtype())
                     .is_some()
                     .then(|| {
                         // Sum is supported for this dtype.
-                        sum(self.dyn_array_ref)
+                        sum(self.dyn_array_ref, &mut ctx)
                     })
                     .transpose()?
             }
@@ -165,11 +184,11 @@ impl StatsSetRef<'_> {
                 if self.dyn_array_ref.is_empty() {
                     None
                 } else {
-                    is_constant(self.dyn_array_ref)?.map(|v| v.into())
+                    Some(is_constant(self.dyn_array_ref, &mut ctx)?.into())
                 }
             }
-            Stat::IsSorted => is_sorted(self.dyn_array_ref)?.map(|v| v.into()),
-            Stat::IsStrictSorted => is_strict_sorted(self.dyn_array_ref)?.map(|v| v.into()),
+            Stat::IsSorted => Some(is_sorted(self.dyn_array_ref, &mut ctx)?.into()),
+            Stat::IsStrictSorted => Some(is_strict_sorted(self.dyn_array_ref, &mut ctx)?.into()),
             Stat::UncompressedSizeInBytes => {
                 let mut builder =
                     builder_with_capacity(self.dyn_array_ref.dtype(), self.dyn_array_ref.len());
@@ -186,7 +205,7 @@ impl StatsSetRef<'_> {
                     .is_some()
                     .then(|| {
                         // NaNCount is supported for this dtype.
-                        nan_count(self.dyn_array_ref)
+                        nan_count(self.dyn_array_ref, &mut ctx)
                     })
                     .transpose()?
                     .map(|s| s.into())
diff --git a/vortex-array/src/stats/flatbuffers.rs b/vortex-array/src/stats/flatbuffers.rs
index fafa6ae32f1..2fbe7774a40 100644
--- a/vortex-array/src/stats/flatbuffers.rs
+++ b/vortex-array/src/stats/flatbuffers.rs
@@ -7,6 +7,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::array as fba;
+use vortex_session::VortexSession;
 
 use crate::dtype::DType;
 use crate::dtype::Nullability;
@@ -113,6 +114,7 @@ impl StatsSet {
     pub fn from_flatbuffer<'a>(
         fb: &fba::ArrayStats<'a>,
         array_dtype: &DType,
+        session: &VortexSession,
     ) -> VortexResult<Self> {
         let mut stats_set = StatsSet::default();
 
@@ -142,7 +144,8 @@ impl StatsSet {
                     if let Some(max) = fb.max()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(max.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(max.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
@@ -161,7 +164,8 @@ impl StatsSet {
                     if let Some(min) = fb.min()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(min.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(min.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
@@ -193,7 +197,8 @@ impl StatsSet {
                     if let Some(sum) = fb.sum()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(sum.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(sum.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
diff --git a/vortex-array/src/stream/ext.rs b/vortex-array/src/stream/ext.rs
index 1f37f688420..e1f39f67214 100644
--- a/vortex-array/src/stream/ext.rs
+++ b/vortex-array/src/stream/ext.rs
@@ -7,6 +7,7 @@ use futures::TryStreamExt;
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
+use crate::IntoArray;
 use crate::arrays::ChunkedArray;
 use crate::stream::ArrayStream;
 use crate::stream::SendableArrayStream;
@@ -33,7 +34,7 @@ pub trait ArrayStreamExt: ArrayStream {
             if chunks.len() == 1 {
                 Ok(chunks.remove(0))
             } else {
-                Ok(ChunkedArray::try_new(chunks, dtype)?.to_array())
+                Ok(ChunkedArray::try_new(chunks, dtype)?.into_array())
             }
         }
     }
diff --git a/vortex-array/src/stream/mod.rs b/vortex-array/src/stream/mod.rs
index 92f7affa5ab..1d44fc83380 100644
--- a/vortex-array/src/stream/mod.rs
+++ b/vortex-array/src/stream/mod.rs
@@ -9,7 +9,6 @@ use futures::Stream;
 use futures::stream;
 use vortex_error::VortexResult;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::dtype::DType;
 
@@ -32,7 +31,7 @@ impl ArrayStream for SendableArrayStream {
     }
 }
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Create an [`ArrayStream`] over the array.
     pub fn to_array_stream(&self) -> impl ArrayStream + 'static {
         ArrayStreamAdapter::new(self.dtype().clone(), stream::iter(self.to_array_iterator()))
diff --git a/vortex-array/src/test_harness.rs b/vortex-array/src/test_harness.rs
index 348f79829fd..099b51bd289 100644
--- a/vortex-array/src/test_harness.rs
+++ b/vortex-array/src/test_harness.rs
@@ -8,25 +8,19 @@ use goldenfile::differs::binary_diff;
 use itertools::Itertools;
 use vortex_error::VortexResult;
 
-use crate::DeserializeMetadata;
-use crate::SerializeMetadata;
 use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
 
 /// Check that a named metadata matches its previous versioning.
 ///
 /// Goldenfile takes care of checking for equality against a checked-in file.
 #[allow(clippy::unwrap_used)]
-pub fn check_metadata<T>(name: &str, metadata: T)
-where
-    T: SerializeMetadata,
-    T: DeserializeMetadata,
-{
+pub fn check_metadata(name: &str, metadata: &[u8]) {
     let mut mint = Mint::new("goldenfiles/");
-    let meta = metadata.serialize();
     let mut f = mint
         .new_goldenfile_with_differ(name, Box::new(binary_diff))
         .unwrap();
-    f.write_all(&meta).unwrap();
+    f.write_all(metadata).unwrap();
 }
 
 /// Outputs the indices of the true values in a BoolArray
diff --git a/vortex-array/src/validity.rs b/vortex-array/src/validity.rs
index 3b9b8b0f387..a5f6903e712 100644
--- a/vortex-array/src/validity.rs
+++ b/vortex-array/src/validity.rs
@@ -16,7 +16,6 @@ use vortex_mask::AllOr;
 use vortex_mask::Mask;
 use vortex_mask::MaskValues;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
@@ -24,9 +23,9 @@ use crate::IntoArray;
 use crate::ToCanonical;
 use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
-use crate::arrays::ScalarFnArrayExt;
+use crate::arrays::bool::BoolArrayExt;
+use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::builtins::ArrayBuiltins;
-use crate::compute::sum;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::optimizer::ArrayOptimizer;
@@ -36,7 +35,7 @@ use crate::scalar_fn::fns::binary::Binary;
 use crate::scalar_fn::fns::operators::Operator;
 
 /// Validity information for an array
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Validity {
     /// Items *can't* be null
     NonNullable,
@@ -50,6 +49,17 @@ pub enum Validity {
     Array(ArrayRef),
 }
 
+impl Debug for Validity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NonNullable => write!(f, "NonNullable"),
+            Self::AllValid => write!(f, "AllValid"),
+            Self::AllInvalid => write!(f, "AllInvalid"),
+            Self::Array(arr) => write!(f, "SomeValid({})", arr.display_values()),
+        }
+    }
+}
+
 impl Validity {
     /// Make a step towards canonicalising validity if necessary
     pub fn execute(self, ctx: &mut ExecutionCtx) -> VortexResult<Validity> {
@@ -111,34 +121,6 @@ impl Validity {
         }
     }
 
-    #[inline]
-    pub fn all_valid(&self, len: usize) -> VortexResult<bool> {
-        Ok(match self {
-            _ if len == 0 => true,
-            Validity::NonNullable | Validity::AllValid => true,
-            Validity::AllInvalid => false,
-            Validity::Array(array) => {
-                usize::try_from(&sum(array).vortex_expect("must have sum for bool array"))
-                    .vortex_expect("sum must be a usize")
-                    == array.len()
-            }
-        })
-    }
-
-    #[inline]
-    pub fn all_invalid(&self, len: usize) -> VortexResult<bool> {
-        Ok(match self {
-            _ if len == 0 => true,
-            Validity::NonNullable | Validity::AllValid => false,
-            Validity::AllInvalid => true,
-            Validity::Array(array) => {
-                usize::try_from(&sum(array).vortex_expect("must have sum for bool array"))
-                    .vortex_expect("sum must be a usize")
-                    == 0
-            }
-        })
-    }
-
     /// Returns whether the `index` item is valid.
     #[inline]
     pub fn is_valid(&self, index: usize) -> VortexResult<bool> {
@@ -167,7 +149,7 @@ impl Validity {
         }
     }
 
-    pub fn take(&self, indices: &dyn Array) -> VortexResult<Self> {
+    pub fn take(&self, indices: &ArrayRef) -> VortexResult<Self> {
         match self {
             Self::NonNullable => match indices.validity_mask()?.bit_buffer() {
                 AllOr::All => {
@@ -187,10 +169,7 @@ impl Validity {
             },
             Self::AllInvalid => Ok(Self::AllInvalid),
             Self::Array(is_valid) => {
-                let maybe_is_valid = is_valid
-                    .take(indices.to_array())?
-                    .to_canonical()?
-                    .into_array();
+                let maybe_is_valid = is_valid.take(indices.clone())?;
                 // Null indices invalidate that position.
                 let is_valid = maybe_is_valid.fill_null(Scalar::from(false))?;
                 Ok(Self::Array(is_valid))
@@ -222,34 +201,55 @@ impl Validity {
             v @ (Validity::NonNullable | Validity::AllValid | Validity::AllInvalid) => {
                 Ok(v.clone())
             }
-            Validity::Array(arr) => Ok(Validity::Array(
-                arr.filter(mask.clone())?
-                    // TODO(connor): This is wrong!!! We should not be eagerly decompressing the
-                    // validity array.
-                    .to_canonical()?
-                    .into_array(),
-            )),
+            Validity::Array(arr) => Ok(Validity::Array(arr.filter(mask.clone())?)),
         }
     }
 
-    #[inline]
+    /// Converts this validity into a [`Mask`] of the given length.
+    ///
+    /// Valid elements are `true` and invalid elements are `false`.
     pub fn to_mask(&self, length: usize) -> Mask {
         match self {
-            Self::NonNullable | Self::AllValid => Mask::AllTrue(length),
-            Self::AllInvalid => Mask::AllFalse(length),
-            Self::Array(is_valid) => {
+            Self::NonNullable | Self::AllValid => Mask::new_true(length),
+            Self::AllInvalid => Mask::new_false(length),
+            Self::Array(a) => a.to_bool().to_mask(),
+        }
+    }
+
+    pub fn execute_mask(&self, length: usize, ctx: &mut ExecutionCtx) -> VortexResult<Mask> {
+        match self {
+            Self::NonNullable | Self::AllValid => Ok(Mask::AllTrue(length)),
+            Self::AllInvalid => Ok(Mask::AllFalse(length)),
+            Self::Array(arr) => {
                 assert_eq!(
-                    is_valid.len(),
+                    arr.len(),
                     length,
                     "Validity::Array length must equal to_logical's argument: {}, {}.",
-                    is_valid.len(),
+                    arr.len(),
                     length,
                 );
-                is_valid.to_bool().to_mask()
+                // TODO(ngates): I'm not sure execution should take arrays by ownership.
+                //  If so we should fix call sites to clone and this function takes self.
+                arr.clone().execute::<Mask>(ctx)
             }
         }
     }
 
+    /// 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> {
+        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),
+        }
+    }
+
     /// Logically & two Validity values of the same length
     #[inline]
     pub fn and(self, rhs: Validity) -> VortexResult<Validity> {
@@ -280,8 +280,9 @@ impl Validity {
         self,
         len: usize,
         indices_offset: usize,
-        indices: &dyn Array,
+        indices: &ArrayRef,
         patches: &Validity,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Self> {
         match (&self, patches) {
             (Validity::NonNullable, Validity::NonNullable) => return Ok(Validity::NonNullable),
@@ -296,7 +297,7 @@ impl Validity {
             _ => {}
         };
 
-        let own_nullability = if self == Validity::NonNullable {
+        let own_nullability = if matches!(self, Validity::NonNullable) {
             Nullability::NonNullable
         } else {
             Nullability::Nullable
@@ -306,27 +307,27 @@ impl Validity {
             Validity::NonNullable => BoolArray::from(BitBuffer::new_set(len)),
             Validity::AllValid => BoolArray::from(BitBuffer::new_set(len)),
             Validity::AllInvalid => BoolArray::from(BitBuffer::new_unset(len)),
-            Validity::Array(a) => a.to_bool(),
+            Validity::Array(a) => a.execute::<BoolArray>(ctx)?,
         };
 
         let patch_values = match patches {
             Validity::NonNullable => BoolArray::from(BitBuffer::new_set(indices.len())),
             Validity::AllValid => BoolArray::from(BitBuffer::new_set(indices.len())),
             Validity::AllInvalid => BoolArray::from(BitBuffer::new_unset(indices.len())),
-            Validity::Array(a) => a.to_bool(),
+            Validity::Array(a) => a.clone().execute::<BoolArray>(ctx)?,
         };
 
         let patches = Patches::new(
             len,
             indices_offset,
-            indices.to_array(),
+            indices.clone(),
             patch_values.into_array(),
             // TODO(0ax1): chunk offsets
             None,
         )?;
 
         Ok(Self::from_array(
-            source.patch(&patches)?.into_array(),
+            source.patch(&patches, ctx)?.into_array(),
             own_nullability,
         ))
     }
@@ -374,7 +375,7 @@ impl Validity {
 
     /// Create Validity by copying the given array's validity.
     #[inline]
-    pub fn copy_from_array(array: &dyn Array) -> VortexResult<Self> {
+    pub fn copy_from_array(array: &ArrayRef) -> VortexResult<Self> {
         Ok(Validity::from_mask(
             array.validity_mask()?,
             array.dtype().nullability(),
@@ -385,7 +386,6 @@ impl Validity {
     ///
     /// Note: You want to pass the nullability of parent array and not the nullability of the validity array itself
     ///     as that is always nonnullable
-    #[inline]
     fn from_array(value: ArrayRef, nullability: Nullability) -> Self {
         if !matches!(value.dtype(), DType::Bool(Nullability::NonNullable)) {
             vortex_panic!("Expected a non-nullable boolean array")
@@ -415,23 +415,6 @@ impl Validity {
     }
 }
 
-impl PartialEq for Validity {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::NonNullable, Self::NonNullable) => true,
-            (Self::AllValid, Self::AllValid) => true,
-            (Self::AllInvalid, Self::AllInvalid) => true,
-            (Self::Array(a), Self::Array(b)) => {
-                let a = a.to_bool();
-                let b = b.to_bool();
-                a.to_bit_buffer() == b.to_bit_buffer()
-            }
-            _ => false,
-        }
-    }
-}
-
 impl From<BitBuffer> for Validity {
     #[inline]
     fn from(value: BitBuffer) -> Self {
@@ -531,9 +514,11 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::arrays::BoolArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::Nullability;
+    use crate::validity::BoolArray;
     use crate::validity::Validity;
 
     #[rstest]
@@ -598,9 +583,21 @@ mod tests {
     ) {
         let indices =
             PrimitiveArray::new(Buffer::copy_from(positions), Validity::NonNullable).into_array();
-        assert_eq!(
-            validity.patch(len, 0, &indices, &patches).unwrap(),
-            expected
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        assert!(
+            validity
+                .patch(
+                    len,
+                    0,
+                    &indices,
+                    &patches,
+                    &mut LEGACY_SESSION.create_execution_ctx(),
+                )
+                .unwrap()
+                .mask_eq(&expected, &mut ctx)
+                .unwrap()
         );
     }
 
@@ -608,7 +605,13 @@ mod tests {
     #[should_panic]
     fn out_of_bounds_patch() {
         Validity::NonNullable
-            .patch(2, 0, &buffer![4].into_array(), &Validity::AllInvalid)
+            .patch(
+                2,
+                0,
+                &buffer![4].into_array(),
+                &Validity::AllInvalid,
+                &mut LEGACY_SESSION.create_execution_ctx(),
+            )
             .unwrap();
     }
 
@@ -652,6 +655,13 @@ mod tests {
         #[case] indices: ArrayRef,
         #[case] expected: Validity,
     ) {
-        assert_eq!(validity.take(&indices).unwrap(), expected);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(
+            validity
+                .take(&indices)
+                .unwrap()
+                .mask_eq(&expected, &mut ctx)
+                .unwrap()
+        );
     }
 }
diff --git a/vortex-array/src/variants.rs b/vortex-array/src/variants.rs
index c02803a631e..f60eea316a9 100644
--- a/vortex-array/src/variants.rs
+++ b/vortex-array/src/variants.rs
@@ -6,18 +6,27 @@ use std::cmp::Ordering;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
-
-use crate::Array;
-use crate::compute::sum;
+use vortex_mask::Mask;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
+use crate::aggregate_fn::fns::sum::sum;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::FieldNames;
 use crate::dtype::PType;
 use crate::dtype::extension::ExtDTypeRef;
 use crate::scalar::PValue;
+use crate::scalar::Scalar;
 use crate::search_sorted::IndexOrd;
 
-impl dyn Array + '_ {
+impl ArrayRef {
     /// Downcasts the array for null-specific behavior.
     pub fn as_null_typed(&self) -> NullTyped<'_> {
         matches!(self.dtype(), DType::Null)
@@ -80,16 +89,30 @@ impl dyn Array + '_ {
             .then(|| ExtensionTyped(self))
             .vortex_expect("Array does not have DType::Extension")
     }
+
+    pub fn try_to_mask_fill_null_false(&self, ctx: &mut ExecutionCtx) -> VortexResult<Mask> {
+        if !matches!(self.dtype(), DType::Bool(_)) {
+            vortex_bail!("mask must be bool array, has dtype {}", self.dtype());
+        }
+
+        // Convert nulls to false first in case this can be done cheaply by the encoding.
+        let array = self
+            .clone()
+            .fill_null(Scalar::bool(false, self.dtype().nullability()))?;
+
+        Ok(array.execute::<BoolArray>(ctx)?.to_mask_fill_null_false())
+    }
 }
 
 #[expect(dead_code)]
-pub struct NullTyped<'a>(&'a dyn Array);
+pub struct NullTyped<'a>(&'a ArrayRef);
 
-pub struct BoolTyped<'a>(&'a dyn Array);
+pub struct BoolTyped<'a>(&'a ArrayRef);
 
 impl BoolTyped<'_> {
     pub fn true_count(&self) -> VortexResult<usize> {
-        let true_count = sum(self.0)?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let true_count = sum(self.0, &mut ctx)?;
         Ok(true_count
             .as_primitive()
             .as_::<usize>()
@@ -97,7 +120,7 @@ impl BoolTyped<'_> {
     }
 }
 
-pub struct PrimitiveTyped<'a>(&'a dyn Array);
+pub struct PrimitiveTyped<'a>(&'a ArrayRef);
 
 impl PrimitiveTyped<'_> {
     pub fn ptype(&self) -> PType {
@@ -151,15 +174,15 @@ impl IndexOrd<PValue> for PrimitiveTyped<'_> {
 }
 
 #[expect(dead_code)]
-pub struct Utf8Typed<'a>(&'a dyn Array);
+pub struct Utf8Typed<'a>(&'a ArrayRef);
 
 #[expect(dead_code)]
-pub struct BinaryTyped<'a>(&'a dyn Array);
+pub struct BinaryTyped<'a>(&'a ArrayRef);
 
 #[expect(dead_code)]
-pub struct DecimalTyped<'a>(&'a dyn Array);
+pub struct DecimalTyped<'a>(&'a ArrayRef);
 
-pub struct StructTyped<'a>(&'a dyn Array);
+pub struct StructTyped<'a>(&'a ArrayRef);
 
 impl StructTyped<'_> {
     pub fn names(&self) -> &FieldNames {
@@ -182,9 +205,9 @@ impl StructTyped<'_> {
 }
 
 #[expect(dead_code)]
-pub struct ListTyped<'a>(&'a dyn Array);
+pub struct ListTyped<'a>(&'a ArrayRef);
 
-pub struct ExtensionTyped<'a>(&'a dyn Array);
+pub struct ExtensionTyped<'a>(&'a ArrayRef);
 
 impl ExtensionTyped<'_> {
     /// Returns the extension logical [`DType`].
diff --git a/vortex-array/src/vtable/array.rs b/vortex-array/src/vtable/array.rs
deleted file mode 100644
index 3bfeeac83aa..00000000000
--- a/vortex-array/src/vtable/array.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hasher;
-
-use crate::Precision;
-use crate::dtype::DType;
-use crate::stats::StatsSetRef;
-use crate::vtable::VTable;
-
-// FIXME(ngates): inline into VTable when possible
-pub trait BaseArrayVTable<V: VTable> {
-    fn len(array: &V::Array) -> usize;
-
-    fn dtype(array: &V::Array) -> &DType;
-
-    fn stats(array: &V::Array) -> StatsSetRef<'_>;
-
-    fn array_hash<H: Hasher>(array: &V::Array, state: &mut H, precision: Precision);
-
-    fn array_eq(array: &V::Array, other: &V::Array, precision: Precision) -> bool;
-}
diff --git a/vortex-array/src/vtable/dyn_.rs b/vortex-array/src/vtable/dyn_.rs
deleted file mode 100644
index 257ca5494a6..00000000000
--- a/vortex-array/src/vtable/dyn_.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::any::type_name;
-use std::fmt;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::marker::PhantomData;
-
-use arcref::ArcRef;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_session::VortexSession;
-
-use crate::Array;
-use crate::ArrayAdapter;
-use crate::ArrayRef;
-use crate::buffer::BufferHandle;
-use crate::dtype::DType;
-use crate::executor::ExecutionCtx;
-use crate::serde::ArrayChildren;
-use crate::vtable::VTable;
-
-/// ArrayId is a globally unique name for the array's vtable.
-pub type ArrayId = ArcRef<str>;
-
-/// Dynamically typed vtable trait.
-///
-/// This trait is sealed, therefore users should implement the strongly typed [`VTable`] trait
-/// instead. The [`ArrayVTableExt::vtable`] function can be used to lift the implementation into
-/// this object-safe form.
-///
-/// This trait contains the implementation API for Vortex arrays, allowing us to keep the public
-/// [`Array`] trait API to a minimum.
-pub trait DynVTable: 'static + private::Sealed + Send + Sync + Debug {
-    #[allow(clippy::too_many_arguments)]
-    fn build(
-        &self,
-        id: ArrayId,
-        dtype: &DType,
-        len: usize,
-        metadata: &[u8],
-        buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-        session: &VortexSession,
-    ) -> VortexResult<ArrayRef>;
-    fn with_children(&self, array: &dyn Array, children: Vec<ArrayRef>) -> VortexResult<ArrayRef>;
-
-    /// See [`VTable::reduce`]
-    fn reduce(&self, array: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
-
-    /// See [`VTable::reduce_parent`]
-    fn reduce_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>>;
-
-    /// See [`VTable::execute`]
-    fn execute(&self, array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef>;
-
-    /// See [`VTable::execute_parent`]
-    fn execute_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>>;
-}
-
-/// Adapter struct used to lift the [`VTable`] trait into an object-safe [`DynVTable`]
-/// implementation.
-struct ArrayVTableAdapter<V: VTable>(PhantomData<V>);
-
-impl<V: VTable> DynVTable for ArrayVTableAdapter<V> {
-    fn build(
-        &self,
-        _id: ArrayId,
-        dtype: &DType,
-        len: usize,
-        metadata: &[u8],
-        buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-        session: &VortexSession,
-    ) -> VortexResult<ArrayRef> {
-        let metadata = V::deserialize(metadata, dtype, len, buffers, session)?;
-        let array = V::build(dtype, len, &metadata, buffers, children)?;
-        assert_eq!(array.len(), len, "Array length mismatch after building");
-        assert_eq!(array.dtype(), dtype, "Array dtype mismatch after building");
-        Ok(array.to_array())
-    }
-
-    fn with_children(&self, array: &dyn Array, children: Vec<ArrayRef>) -> VortexResult<ArrayRef> {
-        let mut array = array.as_::<V>().clone();
-        V::with_children(&mut array, children)?;
-        Ok(array.to_array())
-    }
-
-    fn reduce(&self, array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
-        let Some(reduced) = V::reduce(downcast::<V>(array))? else {
-            return Ok(None);
-        };
-        vortex_ensure!(
-            reduced.len() == array.len(),
-            "Reduced array length mismatch from {} to {}",
-            array.encoding_id(),
-            reduced.encoding_id()
-        );
-        vortex_ensure!(
-            reduced.dtype() == array.dtype(),
-            "Reduced array dtype mismatch from {} to {}",
-            array.encoding_id(),
-            reduced.encoding_id()
-        );
-        Ok(Some(reduced))
-    }
-
-    fn reduce_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>> {
-        let Some(reduced) = V::reduce_parent(downcast::<V>(array), parent, child_idx)? else {
-            return Ok(None);
-        };
-
-        vortex_ensure!(
-            reduced.len() == parent.len(),
-            "Reduced array length mismatch from {} to {}",
-            parent.encoding_id(),
-            reduced.encoding_id()
-        );
-        vortex_ensure!(
-            reduced.dtype() == parent.dtype(),
-            "Reduced array dtype mismatch from {} to {}",
-            parent.encoding_id(),
-            reduced.encoding_id()
-        );
-
-        Ok(Some(reduced))
-    }
-
-    fn execute(&self, array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        let result = V::execute(downcast::<V>(array), ctx)?;
-
-        if cfg!(debug_assertions) {
-            vortex_ensure!(
-                result.as_ref().len() == array.len(),
-                "Result length mismatch for {:?}",
-                self
-            );
-            vortex_ensure!(
-                result.as_ref().dtype() == array.dtype(),
-                "Executed canonical dtype mismatch for {:?}",
-                self
-            );
-        }
-
-        // TODO(ngates): do we want to do this on every execution? We used to in to_canonical.
-        result
-            .as_ref()
-            .statistics()
-            .inherit_from(array.statistics());
-
-        Ok(result)
-    }
-
-    fn execute_parent(
-        &self,
-        array: &ArrayRef,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        let Some(result) = V::execute_parent(downcast::<V>(array), parent, child_idx, ctx)? else {
-            return Ok(None);
-        };
-
-        if cfg!(debug_assertions) {
-            vortex_ensure!(
-                result.as_ref().len() == parent.len(),
-                "Executed parent canonical length mismatch"
-            );
-            vortex_ensure!(
-                result.as_ref().dtype() == parent.dtype(),
-                "Executed parent canonical dtype mismatch"
-            );
-        }
-
-        Ok(Some(result))
-    }
-}
-
-fn downcast<V: VTable>(array: &ArrayRef) -> &V::Array {
-    array
-        .as_any()
-        .downcast_ref::<ArrayAdapter<V>>()
-        .vortex_expect("Failed to downcast array to expected encoding type")
-        .as_inner()
-}
-
-impl<V: VTable> Debug for ArrayVTableAdapter<V> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "Encoding<{}>", type_name::<V>())
-    }
-}
-
-impl<V: VTable> From<V> for &'static dyn DynVTable {
-    fn from(_vtable: V) -> Self {
-        const { &ArrayVTableAdapter::<V>(PhantomData) }
-    }
-}
-
-pub trait ArrayVTableExt {
-    /// Wraps the vtable into an [`DynVTable`] by static reference.
-    fn vtable() -> &'static dyn DynVTable;
-}
-
-impl<V: VTable> ArrayVTableExt for V {
-    fn vtable() -> &'static dyn DynVTable {
-        const { &ArrayVTableAdapter::<V>(PhantomData) }
-    }
-}
-
-mod private {
-    use super::ArrayVTableAdapter;
-    use crate::vtable::VTable;
-
-    pub trait Sealed {}
-    impl<V: VTable> Sealed for ArrayVTableAdapter<V> {}
-}
diff --git a/vortex-array/src/vtable/mod.rs b/vortex-array/src/vtable/mod.rs
deleted file mode 100644
index 67acf8fa69e..00000000000
--- a/vortex-array/src/vtable/mod.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! This module contains the VTable definitions for a Vortex encoding.
-
-mod array;
-mod dyn_;
-mod operations;
-mod validity;
-mod visitor;
-
-use std::fmt::Debug;
-use std::ops::Deref;
-
-pub use array::*;
-pub use dyn_::*;
-pub use operations::*;
-pub use validity::*;
-pub use visitor::*;
-use vortex_error::VortexResult;
-use vortex_session::VortexSession;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::Canonical;
-use crate::IntoArray;
-use crate::buffer::BufferHandle;
-use crate::builders::ArrayBuilder;
-use crate::dtype::DType;
-use crate::executor::ExecutionCtx;
-use crate::serde::ArrayChildren;
-
-/// The array [`VTable`] encapsulates logic for an Array type within Vortex.
-///
-/// The logic is split across several "VTable" traits to enable easier code organization than
-/// simply lumping everything into a single trait.
-///
-/// From this [`VTable`] trait, we derive implementations for the sealed [`Array`] and [`DynVTable`]
-/// traits.
-///
-/// The functions defined in these vtable traits will typically document their pre- and
-/// post-conditions. The pre-conditions are validated inside the [`Array`] and [`DynVTable`]
-/// implementations so do not need to be checked in the vtable implementations (for example, index
-/// out of bounds). Post-conditions are validated after invocation of the vtable function and will
-/// panic if violated.
-pub trait VTable: 'static + Sized + Send + Sync + Debug {
-    type Array: 'static + Send + Sync + Clone + Debug + Deref<Target = dyn Array> + IntoArray;
-    type Metadata: Debug;
-
-    type ArrayVTable: BaseArrayVTable<Self>;
-    type OperationsVTable: OperationsVTable<Self>;
-    type ValidityVTable: ValidityVTable<Self>;
-    type VisitorVTable: VisitorVTable<Self>;
-
-    /// Returns the ID of the array.
-    fn id(array: &Self::Array) -> ArrayId;
-
-    /// Exports metadata for an array.
-    ///
-    /// All other parts of the array are exported using the [`crate::vtable::VisitorVTable`].
-    ///
-    /// * If the array does not contain metadata, it should return
-    ///   [`crate::metadata::EmptyMetadata`].
-    fn metadata(array: &Self::Array) -> VortexResult<Self::Metadata>;
-
-    /// Serialize metadata into a byte buffer for IPC or file storage.
-    /// Return `None` if the array cannot be serialized.
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>>;
-
-    /// Deserialize array metadata from a byte buffer.
-    ///
-    /// To reduce the serialized form, arrays do not store their own DType and length. Instead,
-    /// this is passed down from the parent array during deserialization. These properties are
-    /// exposed here for use during deserialization.
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata>;
-
-    /// Writes the array into a canonical builder.
-    ///
-    /// ## Post-conditions
-    /// - The length of the builder is incremented by the length of the input array.
-    fn append_to_builder(
-        array: &Self::Array,
-        builder: &mut dyn ArrayBuilder,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<()> {
-        let canonical = array.to_array().execute::<Canonical>(ctx)?;
-        builder.extend_from_array(canonical.as_ref());
-        Ok(())
-    }
-
-    /// Build an array from components.
-    ///
-    /// This is called on the file and IPC deserialization pathways, to reconstruct the array from
-    /// type-erased components.
-    ///
-    /// Encoding implementers should take note that all validation necessary to ensure the encoding
-    /// is safe to read should happen inside of this method.
-    ///
-    /// # Safety and correctness
-    ///
-    /// This method should *never* panic, it must always return an error or else it returns a
-    /// valid `Array` that meets all the encoding's preconditions.
-    ///
-    /// For example, the `build` implementation for a dictionary encoding should ensure that all
-    /// codes lie in the valid range. For a UTF-8 array, it should check the bytes to ensure they
-    /// are all valid string data bytes. Any corrupt files or malformed data buffers should be
-    /// caught here, before returning the deserialized array.
-    ///
-    /// # Validation
-    ///
-    /// Validation is mainly meant to ensure that all internal pointers in the encoding reference
-    /// valid ranges of data, and that all data conforms to its DType constraints. These ensure
-    /// that no array operations will panic at runtime, or yield undefined behavior when unsafe
-    /// operations like `get_unchecked` use indices in the array buffer.
-    ///
-    /// Examples of the kinds of validation that should be part of the `build` step:
-    ///
-    /// * Checking that any offsets buffers point to valid offsets in some other child array
-    /// * Checking that any buffers for data or validity have the appropriate size for the
-    ///   encoding
-    /// * Running UTF-8 validation for any buffers that are expected to hold flat UTF-8 data
-    // TODO(ngates): take the parts by ownership, since most arrays need them anyway
-    fn build(
-        dtype: &DType,
-        len: usize,
-        metadata: &Self::Metadata,
-        buffers: &[BufferHandle],
-        children: &dyn ArrayChildren,
-    ) -> VortexResult<Self::Array>;
-
-    /// Replaces the children in `array` with `children`. The count must be the same and types
-    /// of children must be expected.
-    fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()>;
-
-    /// Execute this array to produce an [`ArrayRef`].
-    ///
-    /// Array execution is designed such that repeated execution of an array will eventually
-    /// converge to a canonical representation. Implementations of this function should therefore
-    /// ensure they make progress towards that goal.
-    ///
-    /// This includes fully evaluating the array, such us decoding run-end encoding, or executing
-    /// one of the array's children and re-building the array with the executed child.
-    ///
-    /// It is recommended to only perform a single step of execution per call to this function,
-    /// such that surrounding arrays have an opportunity to perform their own parent reduction
-    /// or execution logic.
-    ///
-    /// The returned array must be logically equivalent to the input array. In other words, the
-    /// recursively canonicalized forms of both arrays must be equal.
-    ///
-    /// Debug builds will panic if the returned array is of the wrong type, wrong length, or
-    /// incorrectly contains null values.
-    ///
-    // TODO(ngates): in the future, we may pass a "target encoding hint" such that this array
-    //  can produce a more optimal representation for the parent. This could be used to preserve
-    //  varbin vs varbinview or list vs listview encodings when the parent knows it prefers
-    //  one representation over another, such as when exporting to a specific Arrow array.
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef>;
-
-    /// Attempt to execute the parent of this array.
-    ///
-    /// This function allows arrays to plug in specialized execution logic for their parent. For
-    /// example, strings compressed as FSST arrays can implement a custom equality comparison when
-    /// the comparing against a scalar string.
-    ///
-    /// Returns `Ok(None)` if no specialized execution is possible.
-    fn execute_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        _ = (array, parent, child_idx, ctx);
-        Ok(None)
-    }
-
-    /// Attempt to reduce the array to a more simple representation.
-    ///
-    /// Returns `Ok(None)` if no reduction is possible.
-    fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
-        _ = array;
-        Ok(None)
-    }
-
-    /// Attempt to perform a reduction of the parent of this array.
-    ///
-    /// This function allows arrays to plug in reduction rules to their parents, for example
-    /// run-end arrays can pull-down scalar functions and apply them only over their values.
-    ///
-    /// Returns `Ok(None)` if no reduction is possible.
-    fn reduce_parent(
-        array: &Self::Array,
-        parent: &ArrayRef,
-        child_idx: usize,
-    ) -> VortexResult<Option<ArrayRef>> {
-        _ = (array, parent, child_idx);
-        Ok(None)
-    }
-}
-
-/// Placeholder type used to indicate when a particular vtable is not supported by the encoding.
-pub struct NotSupported;
-
-#[macro_export]
-macro_rules! vtable {
-    ($V:ident) => {
-        $crate::aliases::paste::paste! {
-            impl AsRef<dyn $crate::Array> for [<$V Array>] {
-                fn as_ref(&self) -> &dyn $crate::Array {
-                    // We can unsafe cast ourselves to an ArrayAdapter.
-                    unsafe { &*(self as *const [<$V Array>] as *const $crate::ArrayAdapter<[<$V VTable>]>) }
-                }
-            }
-
-            impl std::ops::Deref for [<$V Array>] {
-                type Target = dyn $crate::Array;
-
-                fn deref(&self) -> &Self::Target {
-                    // We can unsafe cast ourselves to an ArrayAdapter.
-                    unsafe { &*(self as *const [<$V Array>] as *const $crate::ArrayAdapter<[<$V VTable>]>) }
-                }
-            }
-
-            impl $crate::IntoArray for [<$V Array>] {
-                fn into_array(self) -> $crate::ArrayRef {
-                    // We can unsafe transmute ourselves to an ArrayAdapter.
-                    std::sync::Arc::new(unsafe { std::mem::transmute::<[<$V Array>], $crate::ArrayAdapter::<[<$V VTable>]>>(self) })
-                }
-            }
-
-            impl From<[<$V Array>]> for $crate::ArrayRef {
-                fn from(value: [<$V Array>]) -> $crate::ArrayRef {
-                    use $crate::IntoArray;
-                    value.into_array()
-                }
-            }
-        }
-    };
-}
diff --git a/vortex-array/src/vtable/validity.rs b/vortex-array/src/vtable/validity.rs
deleted file mode 100644
index 6281445293b..00000000000
--- a/vortex-array/src/vtable/validity.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_error::VortexResult;
-
-use crate::Array;
-use crate::ArrayRef;
-use crate::validity::Validity;
-use crate::vtable::VTable;
-
-pub trait ValidityVTable<V: VTable> {
-    /// Returns the [`Validity`] of the array.
-    ///
-    /// ## Pre-conditions
-    ///
-    /// - The array DType is nullable.
-    fn validity(array: &V::Array) -> VortexResult<Validity>;
-}
-
-/// An implementation of the [`ValidityVTable`] for arrays that hold validity as a child array.
-pub struct ValidityVTableFromValidityHelper;
-
-/// Expose validity held as a child array.
-pub trait ValidityHelper {
-    fn validity(&self) -> &Validity;
-}
-
-impl<V: VTable> ValidityVTable<V> for ValidityVTableFromValidityHelper
-where
-    V::Array: ValidityHelper,
-{
-    fn validity(array: &V::Array) -> VortexResult<Validity> {
-        Ok(array.validity().clone())
-    }
-}
-
-/// An implementation of the [`ValidityVTable`] for arrays that hold an unsliced validity
-/// and a slice into it.
-pub struct ValidityVTableFromValiditySliceHelper;
-
-pub trait ValiditySliceHelper {
-    fn unsliced_validity_and_slice(&self) -> (&Validity, usize, usize);
-
-    fn sliced_validity(&self) -> VortexResult<Validity> {
-        let (unsliced_validity, start, stop) = self.unsliced_validity_and_slice();
-        unsliced_validity.slice(start..stop)
-    }
-}
-
-impl<V: VTable> ValidityVTable<V> for ValidityVTableFromValiditySliceHelper
-where
-    V::Array: ValiditySliceHelper,
-{
-    fn validity(array: &V::Array) -> VortexResult<Validity> {
-        array.sliced_validity()
-    }
-}
-
-/// An implementation of the [`ValidityVTable`] for arrays that delegate validity entirely
-/// to a child array.
-pub struct ValidityVTableFromChild;
-
-pub trait ValidityChild<V: VTable> {
-    fn validity_child(array: &V::Array) -> &ArrayRef;
-}
-
-impl<V: VTable> ValidityVTable<V> for ValidityVTableFromChild
-where
-    V: ValidityChild<V>,
-{
-    fn validity(array: &V::Array) -> VortexResult<Validity> {
-        V::validity_child(array).validity()
-    }
-}
-
-/// An implementation of the [`ValidityVTable`] for arrays that hold an unsliced validity
-/// and a slice into it.
-pub struct ValidityVTableFromChildSliceHelper;
-
-pub trait ValidityChildSliceHelper {
-    fn unsliced_child_and_slice(&self) -> (&ArrayRef, usize, usize);
-
-    fn sliced_child_array(&self) -> VortexResult<ArrayRef> {
-        let (unsliced_validity, start, stop) = self.unsliced_child_and_slice();
-        unsliced_validity.slice(start..stop)
-    }
-}
-
-impl<V: VTable> ValidityVTable<V> for ValidityVTableFromChildSliceHelper
-where
-    V::Array: ValidityChildSliceHelper,
-{
-    fn validity(array: &V::Array) -> VortexResult<Validity> {
-        array.sliced_child_array()?.validity()
-    }
-}
diff --git a/vortex-array/src/vtable/visitor.rs b/vortex-array/src/vtable/visitor.rs
deleted file mode 100644
index be90ce029c3..00000000000
--- a/vortex-array/src/vtable/visitor.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use crate::ArrayBufferVisitor;
-use crate::ArrayChildVisitor;
-use crate::ArrayChildVisitorUnnamed;
-use crate::ArrayRef;
-use crate::IntoArray;
-use crate::arrays::ConstantArray;
-use crate::buffer::BufferHandle;
-use crate::validity::Validity;
-use crate::vtable::VTable;
-
-/// Returns the validity as a child array if it produces one.
-///
-/// - `NonNullable` and `AllValid` produce no child (returns `None`)
-/// - `AllInvalid` produces a `ConstantArray` of `false` values
-/// - `Array` returns the validity array
-#[inline]
-pub fn validity_to_child(validity: &Validity, len: usize) -> Option<ArrayRef> {
-    match validity {
-        Validity::NonNullable | Validity::AllValid => None,
-        Validity::AllInvalid => Some(ConstantArray::new(false, len).into_array()),
-        Validity::Array(array) => Some(array.clone()),
-    }
-}
-
-/// Returns 1 if validity produces a child, 0 otherwise.
-#[inline]
-pub fn validity_nchildren(validity: &Validity) -> usize {
-    match validity {
-        Validity::NonNullable | Validity::AllValid => 0,
-        Validity::AllInvalid | Validity::Array(_) => 1,
-    }
-}
-
-pub trait VisitorVTable<V: VTable> {
-    /// Visit the buffers of the array.
-    fn visit_buffers(array: &V::Array, visitor: &mut dyn ArrayBufferVisitor);
-
-    /// Count the number of buffers in the array.
-    fn nbuffers(array: &V::Array) -> usize {
-        struct NBuffers(usize);
-
-        impl ArrayBufferVisitor for NBuffers {
-            fn visit_buffer_handle(&mut self, _name: &str, _handle: &BufferHandle) {
-                self.0 += 1;
-            }
-        }
-
-        let mut visitor = NBuffers(0);
-        <V::VisitorVTable as VisitorVTable<V>>::visit_buffers(array, &mut visitor);
-        visitor.0
-    }
-
-    /// Return the names of the buffers in the array.
-    fn buffer_names(array: &V::Array) -> Vec<String> {
-        struct BufferNames(Vec<String>);
-
-        impl ArrayBufferVisitor for BufferNames {
-            fn visit_buffer_handle(&mut self, name: &str, _handle: &BufferHandle) {
-                self.0.push(name.to_string());
-            }
-        }
-
-        let mut visitor = BufferNames(Vec::new());
-        <V::VisitorVTable as VisitorVTable<V>>::visit_buffers(array, &mut visitor);
-        visitor.0
-    }
-
-    /// Visit the children of the array.
-    fn visit_children(array: &V::Array, visitor: &mut dyn ArrayChildVisitor);
-
-    /// Visit the children of the array without names.
-    ///
-    /// This is more efficient than [`Self::visit_children`] when you don't need the
-    /// child names (e.g., for counting or accessing by index). The default
-    /// implementation wraps the named visitor, but array types can override
-    /// this to avoid allocating names.
-    fn visit_children_unnamed(array: &V::Array, visitor: &mut dyn ArrayChildVisitorUnnamed) {
-        struct UnnamedWrapper<'a>(&'a mut dyn ArrayChildVisitorUnnamed);
-
-        impl ArrayChildVisitor for UnnamedWrapper<'_> {
-            fn visit_child(&mut self, _name: &str, array: &ArrayRef) {
-                self.0.visit_child(array);
-            }
-        }
-
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(array, &mut UnnamedWrapper(visitor));
-    }
-
-    /// Count the number of children in the array.
-    fn nchildren(array: &V::Array) -> usize {
-        struct NChildren(usize);
-
-        impl ArrayChildVisitorUnnamed for NChildren {
-            fn visit_child(&mut self, _array: &ArrayRef) {
-                self.0 += 1;
-            }
-        }
-
-        let mut visitor = NChildren(0);
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(array, &mut visitor);
-        visitor.0
-    }
-
-    /// Get the nth child of the array without allocating a Vec.
-    ///
-    /// Returns `None` if the index is out of bounds.
-    fn nth_child(array: &V::Array, idx: usize) -> Option<ArrayRef> {
-        struct NthChildVisitor {
-            target_idx: usize,
-            current_idx: usize,
-            result: Option<ArrayRef>,
-        }
-
-        impl ArrayChildVisitorUnnamed for NthChildVisitor {
-            fn visit_child(&mut self, array: &ArrayRef) {
-                if self.current_idx == self.target_idx && self.result.is_none() {
-                    self.result = Some(array.clone());
-                }
-                self.current_idx += 1;
-            }
-        }
-
-        let mut visitor = NthChildVisitor {
-            target_idx: idx,
-            current_idx: 0,
-            result: None,
-        };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(array, &mut visitor);
-        visitor.result
-    }
-}
diff --git a/vortex-bench/src/compress/mod.rs b/vortex-bench/src/compress/mod.rs
index 95699390f93..41e1e53a65c 100644
--- a/vortex-bench/src/compress/mod.rs
+++ b/vortex-bench/src/compress/mod.rs
@@ -178,6 +178,7 @@ pub fn calculate_ratios(
     ratios: &mut Vec<CustomUnitMeasurement>,
 ) {
     calculate_vortex_parquet_ratios(measurements, compressed_sizes, bench_name, ratios);
+    calculate_vortex_lance_ratios(measurements, compressed_sizes, bench_name, ratios);
 }
 
 fn calculate_vortex_parquet_ratios(
@@ -225,3 +226,100 @@ fn calculate_vortex_parquet_ratios(
         });
     }
 }
+
+fn calculate_vortex_lance_ratios(
+    measurements: &HashMap<(Format, CompressOp), Duration>,
+    compressed_sizes: &HashMap<Format, u64>,
+    bench_name: &str,
+    ratios: &mut Vec<CustomUnitMeasurement>,
+) {
+    // Size ratio: vortex vs lance.
+    if let (Some(vortex_size), Some(lance_size)) = (
+        compressed_sizes.get(&Format::OnDiskVortex),
+        compressed_sizes.get(&Format::Lance),
+    ) {
+        ratios.push(CustomUnitMeasurement {
+            name: format!("vortex:lance size/{bench_name}"),
+            format: Format::OnDiskVortex,
+            unit: Cow::from("ratio"),
+            value: *vortex_size as f64 / *lance_size as f64,
+        });
+    }
+
+    // Compress time ratio: vortex vs lance.
+    if let (Some(vortex_time), Some(lance_time)) = (
+        measurements.get(&(Format::OnDiskVortex, CompressOp::Compress)),
+        measurements.get(&(Format::Lance, CompressOp::Compress)),
+    ) {
+        ratios.push(CustomUnitMeasurement {
+            name: format!("vortex:lance ratio compress time/{bench_name}"),
+            format: Format::OnDiskVortex,
+            unit: Cow::from("ratio"),
+            value: vortex_time.as_nanos() as f64 / lance_time.as_nanos() as f64,
+        });
+    }
+
+    // Decompress time ratio: vortex vs lance.
+    if let (Some(vortex_time), Some(lance_time)) = (
+        measurements.get(&(Format::OnDiskVortex, CompressOp::Decompress)),
+        measurements.get(&(Format::Lance, CompressOp::Decompress)),
+    ) {
+        ratios.push(CustomUnitMeasurement {
+            name: format!("vortex:lance ratio decompress time/{bench_name}"),
+            format: Format::OnDiskVortex,
+            unit: Cow::from("ratio"),
+            value: vortex_time.as_nanos() as f64 / lance_time.as_nanos() as f64,
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use super::*;
+
+    #[test]
+    fn calculate_ratios_adds_vortex_lance_metrics() {
+        let mut timings = HashMap::new();
+        timings.insert(
+            (Format::OnDiskVortex, CompressOp::Compress),
+            Duration::from_millis(20),
+        );
+        timings.insert(
+            (Format::Lance, CompressOp::Compress),
+            Duration::from_millis(10),
+        );
+        timings.insert(
+            (Format::OnDiskVortex, CompressOp::Decompress),
+            Duration::from_millis(12),
+        );
+        timings.insert(
+            (Format::Lance, CompressOp::Decompress),
+            Duration::from_millis(6),
+        );
+
+        let mut compressed_sizes = HashMap::new();
+        compressed_sizes.insert(Format::OnDiskVortex, 400);
+        compressed_sizes.insert(Format::Lance, 200);
+
+        let mut ratios = Vec::new();
+        calculate_ratios(&timings, &compressed_sizes, "demo", &mut ratios);
+
+        assert!(
+            ratios
+                .iter()
+                .any(|m| m.name == "vortex:lance size/demo" && m.value == 2.0)
+        );
+        assert!(
+            ratios
+                .iter()
+                .any(|m| { m.name == "vortex:lance ratio compress time/demo" && m.value == 2.0 })
+        );
+        assert!(
+            ratios
+                .iter()
+                .any(|m| { m.name == "vortex:lance ratio decompress time/demo" && m.value == 2.0 })
+        );
+    }
+}
diff --git a/vortex-bench/src/conversions.rs b/vortex-bench/src/conversions.rs
index 1ab3c1e7f20..3f21ab30ba0 100644
--- a/vortex-bench/src/conversions.rs
+++ b/vortex-bench/src/conversions.rs
@@ -19,6 +19,7 @@ use tracing::info;
 use tracing::trace;
 use vortex::VortexSessionDefault;
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::ChunkedArray;
 use vortex::array::arrow::FromArrowArray;
@@ -214,7 +215,7 @@ pub async fn write_parquet_as_vortex(
         let data = parquet_to_vortex_chunks(parquet_path).await?;
         let write_options = compaction.apply_options(SESSION.write_options());
         write_options
-            .write(&mut output_file, data.to_array_stream())
+            .write(&mut output_file, data.into_array().to_array_stream())
             .await?;
         output_file.flush().await?;
         Ok(())
diff --git a/vortex-bench/src/datasets/feature_vectors.rs b/vortex-bench/src/datasets/feature_vectors.rs
index 4928c0df326..e09f29f49ec 100644
--- a/vortex-bench/src/datasets/feature_vectors.rs
+++ b/vortex-bench/src/datasets/feature_vectors.rs
@@ -15,7 +15,7 @@ use arrow_schema::Field;
 use arrow_schema::Schema;
 use async_trait::async_trait;
 use parquet::arrow::ArrowWriter;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 
@@ -81,7 +81,7 @@ pub async fn feature_vectors_parquet() -> Result<PathBuf> {
             ]));
 
             let file = File::create(&temp_path)?;
-            let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?;
+            let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?;
             let mut rng = StdRng::seed_from_u64(42);
 
             for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) {
@@ -100,8 +100,10 @@ pub async fn feature_vectors_parquet() -> Result<PathBuf> {
                 }
                 let embedding = list_builder.finish();
 
-                let batch =
-                    RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(embedding)])?;
+                let batch = RecordBatch::try_new(
+                    Arc::clone(&schema),
+                    vec![Arc::new(ids), Arc::new(embedding)],
+                )?;
                 writer.write(&batch)?;
             }
 
diff --git a/vortex-bench/src/datasets/nested_lists.rs b/vortex-bench/src/datasets/nested_lists.rs
index 5f0fbac80f5..3c89ed8eb2b 100644
--- a/vortex-bench/src/datasets/nested_lists.rs
+++ b/vortex-bench/src/datasets/nested_lists.rs
@@ -14,7 +14,7 @@ use arrow_schema::Field;
 use arrow_schema::Schema;
 use async_trait::async_trait;
 use parquet::arrow::ArrowWriter;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 
@@ -77,7 +77,7 @@ pub async fn nested_lists_parquet() -> Result<PathBuf> {
             ]));
 
             let file = std::fs::File::create(&temp_path)?;
-            let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?;
+            let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?;
             let mut rng = StdRng::seed_from_u64(42);
 
             for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) {
@@ -97,8 +97,10 @@ pub async fn nested_lists_parquet() -> Result<PathBuf> {
                 }
                 let values = list_builder.finish();
 
-                let batch =
-                    RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(values)])?;
+                let batch = RecordBatch::try_new(
+                    Arc::clone(&schema),
+                    vec![Arc::new(ids), Arc::new(values)],
+                )?;
                 writer.write(&batch)?;
             }
 
diff --git a/vortex-bench/src/datasets/nested_structs.rs b/vortex-bench/src/datasets/nested_structs.rs
index b3f362ed904..c4a522184d3 100644
--- a/vortex-bench/src/datasets/nested_structs.rs
+++ b/vortex-bench/src/datasets/nested_structs.rs
@@ -15,7 +15,7 @@ use arrow_schema::Fields;
 use arrow_schema::Schema;
 use async_trait::async_trait;
 use parquet::arrow::ArrowWriter;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 
@@ -92,7 +92,7 @@ pub async fn nested_structs_parquet() -> Result<PathBuf> {
             ]));
 
             let file = std::fs::File::create(&temp_path)?;
-            let mut writer = ArrowWriter::try_new(file, schema.clone(), None)?;
+            let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None)?;
             let mut rng = StdRng::seed_from_u64(42);
 
             for batch_start in (0..ROW_COUNT).step_by(BATCH_SIZE) {
@@ -124,8 +124,10 @@ pub async fn nested_structs_parquet() -> Result<PathBuf> {
                     None,
                 )?;
 
-                let batch =
-                    RecordBatch::try_new(schema.clone(), vec![Arc::new(ids), Arc::new(outer)])?;
+                let batch = RecordBatch::try_new(
+                    Arc::clone(&schema),
+                    vec![Arc::new(ids), Arc::new(outer)],
+                )?;
                 writer.write(&batch)?;
             }
 
diff --git a/vortex-bench/src/datasets/struct_list_of_ints.rs b/vortex-bench/src/datasets/struct_list_of_ints.rs
index c83a8de4723..4999c05adac 100644
--- a/vortex-bench/src/datasets/struct_list_of_ints.rs
+++ b/vortex-bench/src/datasets/struct_list_of_ints.rs
@@ -8,7 +8,7 @@ use anyhow::Result;
 use arrow_array::RecordBatch;
 use async_trait::async_trait;
 use parquet::arrow::ArrowWriter;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex::array::ArrayRef;
@@ -17,7 +17,8 @@ use vortex::array::arrays::ChunkedArray;
 use vortex::array::arrays::ListArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::recursive_list_from_list_view;
+use vortex::array::arrays::chunked::ChunkedArrayExt;
+use vortex::array::arrays::listview::recursive_list_from_list_view;
 use vortex::array::validity::Validity;
 use vortex::dtype::FieldNames;
 
@@ -115,15 +116,14 @@ impl Dataset for StructListOfInts {
             let array = self.to_vortex_array().await?;
 
             // Convert to Arrow RecordBatches and write to parquet
-            let chunked = array.as_::<vortex::array::arrays::ChunkedVTable>();
-            let chunks = chunked.chunks();
+            let chunked = array.as_::<vortex::array::arrays::Chunked>();
 
             let file = File::create(&temp_path)?;
             let mut writer: Option<ArrowWriter<File>> = None;
 
-            for chunk in chunks.iter() {
+            for chunk in chunked.iter_chunks() {
                 let converted = recursive_list_from_list_view(chunk.clone())?;
-                let batch = RecordBatch::try_from(converted.as_ref())?;
+                let batch = RecordBatch::try_from(&converted)?;
 
                 if writer.is_none() {
                     writer = Some(ArrowWriter::try_new(
diff --git a/vortex-bench/src/datasets/taxi_data.rs b/vortex-bench/src/datasets/taxi_data.rs
index 133f7c55586..cc3c6f61b81 100644
--- a/vortex-bench/src/datasets/taxi_data.rs
+++ b/vortex-bench/src/datasets/taxi_data.rs
@@ -8,6 +8,7 @@ use async_trait::async_trait;
 use tokio::fs::File as TokioFile;
 use tokio::io::AsyncWriteExt;
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::stream::ArrayStreamExt;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::WriteOptionsSessionExt;
@@ -93,7 +94,7 @@ pub async fn taxi_data_vortex() -> Result<PathBuf> {
 
         SESSION
             .write_options()
-            .write(&mut output_file, data.to_array_stream())
+            .write(&mut output_file, data.into_array().to_array_stream())
             .await?;
         output_file.flush().await?;
         Ok(buf)
@@ -112,7 +113,7 @@ pub async fn taxi_data_vortex_compact() -> Result<PathBuf> {
         let data = parquet_to_vortex_chunks(taxi_data_parquet().await?).await?;
 
         write_options
-            .write(&mut output_file, data.to_array_stream())
+            .write(&mut output_file, data.into_array().to_array_stream())
             .await?;
 
         output_file.flush().await?;
diff --git a/vortex-bench/src/datasets/tpch_l_comment.rs b/vortex-bench/src/datasets/tpch_l_comment.rs
index dfe46673cde..00a141f03ba 100644
--- a/vortex-bench/src/datasets/tpch_l_comment.rs
+++ b/vortex-bench/src/datasets/tpch_l_comment.rs
@@ -7,7 +7,6 @@ use anyhow::Result;
 use async_trait::async_trait;
 use futures::TryStreamExt;
 use glob::glob;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::ToCanonical;
diff --git a/vortex-bench/src/downloadable_dataset.rs b/vortex-bench/src/downloadable_dataset.rs
index 7aa140ec1b2..78ab162d688 100644
--- a/vortex-bench/src/downloadable_dataset.rs
+++ b/vortex-bench/src/downloadable_dataset.rs
@@ -4,6 +4,7 @@
 use async_trait::async_trait;
 use tokio::fs::File;
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::stream::ArrayStreamExt;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::WriteOptionsSessionExt;
@@ -69,7 +70,7 @@ impl Dataset for DownloadableDataset {
                     &mut File::create(path)
                         .await
                         .map_err(|e| anyhow::anyhow!("Failed to create file: {}", e))?,
-                    data.to_array_stream(),
+                    data.into_array().to_array_stream(),
                 )
                 .await
                 .map_err(|e| anyhow::anyhow!("Failed to write vortex file: {}", e))?;
diff --git a/vortex-bench/src/lib.rs b/vortex-bench/src/lib.rs
index 6dad0f0f6a1..a1b7c46bb16 100644
--- a/vortex-bench/src/lib.rs
+++ b/vortex-bench/src/lib.rs
@@ -26,6 +26,7 @@ use tpcds::TpcDsBenchmark;
 use tpch::benchmark::TpcHBenchmark;
 pub use utils::file::*;
 pub use utils::logging::*;
+use vortex::compressor::BtrBlocksCompressorBuilder;
 use vortex::error::VortexExpect;
 use vortex::error::vortex_err;
 use vortex::file::VortexWriteOptions;
@@ -231,7 +232,7 @@ impl CompactionStrategy {
         match self {
             CompactionStrategy::Compact => options.with_strategy(
                 WriteStrategyBuilder::default()
-                    .with_compact_encodings()
+                    .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
                     .build(),
             ),
             CompactionStrategy::Default => options,
diff --git a/vortex-bench/src/polarsignals/data.rs b/vortex-bench/src/polarsignals/data.rs
index 021f3fb6c48..eb2db956ee4 100644
--- a/vortex-bench/src/polarsignals/data.rs
+++ b/vortex-bench/src/polarsignals/data.rs
@@ -22,7 +22,7 @@ use arrow_schema::Schema;
 use parquet::arrow::ArrowWriter;
 use parquet::basic::Compression;
 use parquet::file::properties::WriterProperties;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 
@@ -143,7 +143,7 @@ pub fn generate_polarsignals_parquet(n_rows: usize, output_path: &Path) -> Resul
     let props = WriterProperties::builder()
         .set_compression(Compression::SNAPPY)
         .build();
-    let mut writer = ArrowWriter::try_new(file, schema.clone(), Some(props))?;
+    let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), Some(props))?;
 
     let batch_size = 10_000;
     let num_threads = std::thread::available_parallelism()
@@ -159,11 +159,11 @@ pub fn generate_polarsignals_parquet(n_rows: usize, output_path: &Path) -> Resul
         chunk
             .iter()
             .map(|&(start, len)| {
-                let schema = schema.clone();
-                let label_sets = label_sets.clone();
-                let function_names = function_names.clone();
-                let function_filenames = function_filenames.clone();
-                let build_ids = build_ids.clone();
+                let schema = Arc::clone(&schema);
+                let label_sets = Arc::clone(&label_sets);
+                let function_names = Arc::clone(&function_names);
+                let function_filenames = Arc::clone(&function_filenames);
+                let build_ids = Arc::clone(&build_ids);
                 std::thread::spawn(move || {
                     let mut rng = StdRng::seed_from_u64(42 + start as u64);
                     build_batch(
@@ -235,7 +235,7 @@ fn build_batch(
     }
 
     let batch = RecordBatch::try_new(
-        schema.clone(),
+        Arc::clone(schema),
         vec![
             Arc::new(labels_array),
             Arc::new(locations_array),
diff --git a/vortex-bench/src/public_bi.rs b/vortex-bench/src/public_bi.rs
index 0539266ed0d..3602cd2cd33 100644
--- a/vortex-bench/src/public_bi.rs
+++ b/vortex-bench/src/public_bi.rs
@@ -26,6 +26,7 @@ use tracing::info;
 use tracing::trace;
 use url::Url;
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::stream::ArrayStreamExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
@@ -371,7 +372,7 @@ impl PBIData {
                                 &mut File::create(output_path)
                                     .await
                                     .map_err(|e| anyhow::anyhow!("Failed to create file: {}", e))?,
-                                data.to_array_stream(),
+                                data.into_array().to_array_stream(),
                             )
                             .await
                             .map_err(|e| anyhow::anyhow!("Failed to write vortex file: {}", e))?;
diff --git a/vortex-bench/src/random_access/take.rs b/vortex-bench/src/random_access/take.rs
index df48cd075c0..13358fb9531 100644
--- a/vortex-bench/src/random_access/take.rs
+++ b/vortex-bench/src/random_access/take.rs
@@ -3,6 +3,7 @@
 
 use std::iter::once;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use arrow_array::PrimitiveArray;
 use arrow_array::types::Int64Type;
@@ -14,9 +15,9 @@ use itertools::Itertools;
 use parquet::arrow::ParquetRecordBatchStreamBuilder;
 use parquet::arrow::arrow_reader::ArrowReaderMetadata;
 use parquet::arrow::arrow_reader::ArrowReaderOptions;
+use parquet::file::metadata::PageIndexPolicy;
 use stream::StreamExt;
 use tokio::fs::File;
-use vortex::array::Array;
 use vortex::array::Canonical;
 use vortex::array::IntoArray;
 use vortex::array::VortexSessionExecute;
@@ -100,7 +101,7 @@ impl ParquetRandomAccessor {
     /// Open a Parquet file, parse the footer, and return a ready-to-use accessor.
     pub async fn open(path: PathBuf, name: impl Into<String>) -> anyhow::Result<Self> {
         let mut file = File::open(&path).await?;
-        let options = ArrowReaderOptions::new().with_page_index(true);
+        let options = ArrowReaderOptions::new().with_page_index_policy(PageIndexPolicy::Required);
         let arrow_metadata = ArrowReaderMetadata::load_async(&mut file, options).await?;
 
         let row_group_offsets = once(0)
@@ -167,7 +168,7 @@ impl RandomAccessor for ParquetRandomAccessor {
             .with_batch_size(10_000_000)
             .build()?;
 
-        let schema = reader.schema().clone();
+        let schema = Arc::clone(reader.schema());
 
         let batches = reader
             .enumerate()
diff --git a/vortex-bench/src/runner.rs b/vortex-bench/src/runner.rs
index b6e81d67009..6c9064b6a29 100644
--- a/vortex-bench/src/runner.rs
+++ b/vortex-bench/src/runner.rs
@@ -19,6 +19,24 @@ use crate::BenchmarkDataset;
 use crate::Engine;
 use crate::Format;
 use crate::Target;
+
+/// Controls whether queries are benchmarked or explained.
+pub enum BenchmarkMode {
+    /// Run each query `iterations` times, collecting timing.
+    Run { iterations: usize },
+    /// Prepend `EXPLAIN` to each query, print the result, skip timing.
+    Explain,
+}
+
+/// Trait implemented by engine-specific query results so the runner can
+/// extract row counts (for validation in Run mode) and display text
+/// (for Explain mode).
+pub trait BenchmarkQueryResult {
+    /// Number of result rows (used for row-count validation).
+    fn row_count(&self) -> usize;
+    /// Human-readable representation of the result (used by Explain mode).
+    fn display(self) -> String;
+}
 use crate::display::DisplayFormat;
 use crate::display::print_measurements_json;
 use crate::display::render_table;
@@ -97,38 +115,32 @@ impl SqlBenchmarkRunner {
     /// Run a synchronous query benchmark.
     ///
     /// Executes the query function `iterations` times, collecting timing information.
-    /// The function should return `(row_count, optional_timing, result)` where:
-    /// - `row_count` is used for validation
-    /// - `optional_timing` can be `Some(Duration)` if the callback wants to report its own timing
+    /// The function should return `(Option<Duration>, R)` where:
+    /// - `Option<Duration>` can be `Some(Duration)` if the callback wants to report its own timing
     ///   (e.g., DuckDB's internal timing), or `None` to use external wall-clock measurement
-    ///
-    /// This handles:
-    /// - Memory tracking (start/end)
-    /// - Timing each iteration
-    /// - Recording measurements
-    /// - Row count validation
-    /// - Progress bar updates
-    fn run_query<F>(&mut self, query_idx: usize, format: Format, iterations: usize, mut f: F)
+    /// - `R` implements `BenchmarkQueryResult` for row count and display
+    fn run_query<R, F>(&mut self, query_idx: usize, format: Format, iterations: usize, mut f: F)
     where
-        F: FnMut() -> (usize, Option<Duration>),
+        R: BenchmarkQueryResult,
+        F: FnMut() -> (Option<Duration>, R),
     {
         self.start_query();
 
         let mut runs = Vec::with_capacity(iterations);
-        let mut result = None;
+        let mut row_count = None;
 
         for _ in 0..iterations {
             let start = Instant::now();
-            let (row_count, timing) = f();
+            let (timing, result) = f();
             let elapsed = timing.unwrap_or_else(|| start.elapsed());
             runs.push(elapsed);
 
-            if result.is_none() {
-                result = Some(row_count);
+            if row_count.is_none() {
+                row_count = Some(result.row_count());
             }
         }
 
-        let row_count = result.expect("iterations must be > 0");
+        let row_count = row_count.expect("iterations must be > 0");
         self.record_query(query_idx, format, runs, row_count);
     }
 
@@ -235,74 +247,89 @@ impl SqlBenchmarkRunner {
         }
     }
 
-    /// Run all queries for all formats synchronously.
+    /// Run (or explain) all queries for all formats synchronously.
     ///
-    /// For each format:
-    /// 1. Calls `setup` to create a context for that format
-    /// 2. Iterates over all queries, calling `execute` for each
+    /// In `Run` mode, executes each query `iterations` times, collecting timing.
+    /// In `Explain` mode, prepends `EXPLAIN` to each query, executes once, and
+    /// prints `R::display()`. No progress bar or timing in Explain mode.
     ///
-    /// The `execute` callback receives the context, query index, and query string,
-    /// and should return `(row_count, optional_timing)` where `optional_timing` can be
-    /// `Some(Duration)` if the callback wants to report its own timing.
-    pub fn run_all<Ctx, S, E>(
+    /// The `execute` callback returns `(Option<Duration>, R)` where
+    /// `Option<Duration>` overrides wall-clock timing, and `R` implements
+    /// `BenchmarkQueryResult`.
+    pub fn run_all<Ctx, R, S, E>(
         &mut self,
         queries: &[(usize, String)],
-        iterations: usize,
+        mode: BenchmarkMode,
         mut setup: S,
         mut execute: E,
     ) -> anyhow::Result<()>
     where
+        R: BenchmarkQueryResult,
         S: FnMut(Format) -> anyhow::Result<Ctx>,
-        E: FnMut(&mut Ctx, usize, Format, &str) -> anyhow::Result<(usize, Option<Duration>)>,
+        E: FnMut(&mut Ctx, usize, Format, &str) -> anyhow::Result<(Option<Duration>, R)>,
     {
-        let bar_length = queries.len() * self.formats.len();
-        let progress_bar = if self.hide_progress_bar || bar_length == 0 {
-            ProgressBar::hidden()
-        } else {
-            ProgressBar::new(bar_length as u64)
-        };
-
-        for format in self.formats.clone() {
-            let mut ctx = setup(format)?;
-
-            for (query_idx, query) in queries.iter() {
-                let query_idx = *query_idx;
-                tracing::debug!(%format, query_idx, "Running query");
-                self.run_query(query_idx, format, iterations, || {
-                    let (row_count, timing) = execute(&mut ctx, query_idx, format, query.as_str())
-                        .unwrap_or_else(|err| {
-                            vortex_panic!("query {query_idx} failed: {err}");
+        match mode {
+            BenchmarkMode::Run { iterations } => {
+                let bar_length = queries.len() * self.formats.len();
+                let progress_bar = if self.hide_progress_bar || bar_length == 0 {
+                    ProgressBar::hidden()
+                } else {
+                    ProgressBar::new(bar_length as u64)
+                };
+
+                for format in self.formats.clone() {
+                    let mut ctx = setup(format)?;
+
+                    for (query_idx, query) in queries.iter() {
+                        let query_idx = *query_idx;
+                        tracing::debug!(%format, query_idx, "Running query");
+                        self.run_query(query_idx, format, iterations, || {
+                            execute(&mut ctx, query_idx, format, query.as_str()).unwrap_or_else(
+                                |err| {
+                                    vortex_panic!("query {query_idx} failed: {err}");
+                                },
+                            )
                         });
-                    (row_count, timing)
-                });
 
-                progress_bar.inc(1);
+                        progress_bar.inc(1);
+                    }
+                }
+
+                progress_bar.finish();
+            }
+            BenchmarkMode::Explain => {
+                for format in self.formats.clone() {
+                    let mut ctx = setup(format)?;
+
+                    for (query_idx, query) in queries.iter() {
+                        let explain_query = format!("EXPLAIN {query}");
+                        let (_, result) = execute(&mut ctx, *query_idx, format, &explain_query)?;
+                        println!("=== Q{query_idx} [{format}] ===");
+                        println!("{query}");
+                        println!();
+                        println!("{}", result.display());
+                        println!();
+                    }
+                }
             }
         }
 
-        progress_bar.finish();
-
         Ok(())
     }
 
-    /// Run all queries for all formats asynchronously.
+    /// Run (or explain) all queries for all formats asynchronously.
     ///
-    /// For each format:
-    /// 1. Calls `setup` to create a context for that format
-    /// 2. Iterates over all queries, calling `execute` for each
-    ///
-    /// The `execute` callback receives the context, query index, and query string,
-    /// and should return `(row_count, optional_timing, result)` where `optional_timing` can be
-    /// `Some(Duration)` if the callback wants to report its own timing.
+    /// Same semantics as `run_all` but for async execute callbacks.
     /// Use `Box::pin(async move { ... })` in the closure.
-    pub async fn run_all_async<Ctx, S, SFut, E, T>(
+    pub async fn run_all_async<Ctx, R, S, SFut, E>(
         &mut self,
         queries: &[(usize, String)],
-        iterations: usize,
+        mode: BenchmarkMode,
         setup: S,
         mut execute: E,
     ) -> anyhow::Result<()>
     where
+        R: BenchmarkQueryResult,
         S: Fn(Format) -> SFut,
         SFut: Future<Output = anyhow::Result<Ctx>>,
         E: for<'c> FnMut(
@@ -310,53 +337,72 @@ impl SqlBenchmarkRunner {
             &'c Ctx,
             &'c str,
         ) -> Pin<
-            Box<dyn Future<Output = anyhow::Result<(usize, Option<Duration>, T)>> + 'c>,
+            Box<dyn Future<Output = anyhow::Result<(Option<Duration>, R)>> + 'c>,
         >,
     {
-        let bar_length = queries.len() * self.formats.len();
-        let progress_bar = if self.hide_progress_bar || bar_length == 0 {
-            ProgressBar::hidden()
-        } else {
-            ProgressBar::new(bar_length as u64)
-        };
-
-        for format in self.formats.clone() {
-            let ctx = setup(format).await?;
-
-            for (query_idx, query) in queries.iter() {
-                let query_idx = *query_idx;
-
-                self.start_query();
-
-                let mut runs = Vec::with_capacity(iterations);
-                let mut result = None;
-
-                tracing::debug!(%format, query_idx, "Running query");
-
-                for _ in 0..iterations {
-                    let start = Instant::now();
-                    let (row_count, timing, iter_result) = execute(query_idx, &ctx, query.as_str())
-                        .await
-                        .unwrap_or_else(|err| {
-                            vortex_panic!("query {query_idx} failed: {err}");
-                        });
-                    let elapsed = timing.unwrap_or_else(|| start.elapsed());
-                    runs.push(elapsed);
-
-                    if result.is_none() {
-                        result = Some((row_count, iter_result));
+        match mode {
+            BenchmarkMode::Run { iterations } => {
+                let bar_length = queries.len() * self.formats.len();
+                let progress_bar = if self.hide_progress_bar || bar_length == 0 {
+                    ProgressBar::hidden()
+                } else {
+                    ProgressBar::new(bar_length as u64)
+                };
+
+                for format in self.formats.clone() {
+                    let ctx = setup(format).await?;
+
+                    for (query_idx, query) in queries.iter() {
+                        let query_idx = *query_idx;
+
+                        self.start_query();
+
+                        let mut runs = Vec::with_capacity(iterations);
+                        let mut row_count = None;
+
+                        tracing::debug!(%format, query_idx, "Running query");
+
+                        for _ in 0..iterations {
+                            let start = Instant::now();
+                            let (timing, result) = execute(query_idx, &ctx, query.as_str())
+                                .await
+                                .unwrap_or_else(|err| {
+                                    vortex_panic!("query {query_idx} failed: {err}");
+                                });
+                            let elapsed = timing.unwrap_or_else(|| start.elapsed());
+                            runs.push(elapsed);
+
+                            if row_count.is_none() {
+                                row_count = Some(result.row_count());
+                            }
+                        }
+
+                        let row_count = row_count.expect("iterations must be > 0");
+                        self.record_query(query_idx, format, runs, row_count);
+
+                        progress_bar.inc(1);
                     }
                 }
 
-                let (row_count, _) = result.expect("iterations must be > 0");
-                self.record_query(query_idx, format, runs, row_count);
-
-                progress_bar.inc(1);
+                progress_bar.finish();
+            }
+            BenchmarkMode::Explain => {
+                for format in self.formats.clone() {
+                    let ctx = setup(format).await?;
+
+                    for (query_idx, query) in queries.iter() {
+                        let explain_query = format!("EXPLAIN {query}");
+                        let (_, result) = execute(*query_idx, &ctx, &explain_query).await?;
+                        println!("=== Q{query_idx} [{format}] ===");
+                        println!("{query}");
+                        println!();
+                        println!("{}", result.display());
+                        println!();
+                    }
+                }
             }
         }
 
-        progress_bar.finish();
-
         Ok(())
     }
 }
diff --git a/vortex-bench/src/statpopgen/builder.rs b/vortex-bench/src/statpopgen/builder.rs
index 25b6a2735b2..7c46d1ff2b8 100644
--- a/vortex-bench/src/statpopgen/builder.rs
+++ b/vortex-bench/src/statpopgen/builder.rs
@@ -437,7 +437,7 @@ impl<'a> GnomADBuilder<'a> {
             });
 
         RecordBatch::try_new(
-            self.schema.clone(),
+            Arc::clone(&self.schema),
             variant_fields
                 .into_iter()
                 .chain(info_fields)
diff --git a/vortex-bench/src/statpopgen/download_vcf.rs b/vortex-bench/src/statpopgen/download_vcf.rs
index 7d5552541c5..ed1ab2826a6 100644
--- a/vortex-bench/src/statpopgen/download_vcf.rs
+++ b/vortex-bench/src/statpopgen/download_vcf.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use anyhow::Context;
 use anyhow::Result;
 use anyhow::bail;
@@ -61,7 +63,7 @@ impl StatPopGenBenchmark {
                 let mut bgzf_reader = noodles_bgzf::r#async::io::Reader::new(buf_reader);
 
                 // Read and parse VCF header
-                let mut vcf_reader = noodles_vcf::AsyncReader::new(&mut bgzf_reader);
+                let mut vcf_reader = noodles_vcf::r#async::io::Reader::new(&mut bgzf_reader);
 
                 // Read and print the first 100,000 records
                 let header = vcf_reader.read_header().await?;
@@ -74,14 +76,14 @@ impl StatPopGenBenchmark {
                 );
                 let mut record = Record::default();
                 let schema = schema_from_vcf_header(&header);
-                let mut builder = GnomADBuilder::new(&header, schema.clone());
+                let mut builder = GnomADBuilder::new(&header, Arc::clone(&schema));
                 let file = File::create(parquet_output_path).await?;
-                let mut writer = AsyncArrowWriter::try_new(file, schema.clone(), None)
+                let mut writer = AsyncArrowWriter::try_new(file, Arc::clone(&schema), None)
                     .context("Failed to create parquet writer")?;
                 for i in progress.wrap_iter(0..self.n_rows) {
                     if i % ROW_GROUP_SIZE_IN_VARIANTS == 0 {
                         let rb = builder.finish()?;
-                        builder = GnomADBuilder::new(&header, schema.clone());
+                        builder = GnomADBuilder::new(&header, Arc::clone(&schema));
                         writer
                             .write(&rb)
                             .await
diff --git a/vortex-bench/src/statpopgen/statpopgen_benchmark.rs b/vortex-bench/src/statpopgen/statpopgen_benchmark.rs
index 941859dc90b..dc5fa6448ad 100644
--- a/vortex-bench/src/statpopgen/statpopgen_benchmark.rs
+++ b/vortex-bench/src/statpopgen/statpopgen_benchmark.rs
@@ -52,7 +52,7 @@ impl StatPopGenBenchmark {
             )
         })?;
 
-        let data_path = "statspopgen".to_data_path().join(format!("{n_rows}/"));
+        let data_path = "statpopgen".to_data_path().join(format!("{n_rows}/"));
 
         let data_url =
             Url::from_directory_path(data_path).map_err(|_| anyhow::anyhow!("bad data path?"))?;
diff --git a/vortex-bench/src/tpch/tpchgen.rs b/vortex-bench/src/tpch/tpchgen.rs
index 75fe4db9e8f..1d7273f3ccc 100644
--- a/vortex-bench/src/tpch/tpchgen.rs
+++ b/vortex-bench/src/tpch/tpchgen.rs
@@ -136,7 +136,7 @@ pub async fn generate_tpch_tables(options: TpchGenOptions) -> Result<()> {
     let (tx, rx) = mpsc::unbounded_channel();
 
     for f in all_futures {
-        let limiter = limiter.clone();
+        let limiter = Arc::clone(&limiter);
         let tx = tx.clone();
         tokio::task::spawn(async move {
             let _guard = limiter.acquire().await?;
@@ -232,7 +232,7 @@ fn generate_table_files(
                 let iter = create_single_batch_iterator(generator, &options_clone, partition_idx)?;
 
                 // Create generator and process batches in streaming fashion
-                let schema = iter.schema().clone();
+                let schema = Arc::clone(iter.schema());
 
                 // Create writer based on format
                 let mut writer: Box<dyn FileWriter + Send> = match write_format {
diff --git a/vortex-btrblocks/Cargo.toml b/vortex-btrblocks/Cargo.toml
index 1c745306c4a..35383a5f5ed 100644
--- a/vortex-btrblocks/Cargo.toml
+++ b/vortex-btrblocks/Cargo.toml
@@ -14,7 +14,6 @@ rust-version = { workspace = true }
 version = { workspace = true }
 
 [dependencies]
-enum-iterator = { workspace = true }
 getrandom_v03 = { workspace = true }
 itertools = { workspace = true }
 num-traits = { workspace = true }
@@ -25,6 +24,7 @@ tracing = { workspace = true }
 vortex-alp = { workspace = true }
 vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
+vortex-compressor = { workspace = true }
 vortex-datetime-parts = { workspace = true }
 vortex-decimal-byte-parts = { workspace = true }
 vortex-error = { workspace = true }
@@ -35,6 +35,7 @@ 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 }
@@ -47,7 +48,7 @@ vortex-array = { workspace = true, features = ["_test-harness"] }
 
 [features]
 # This feature enabled unstable encodings for which we don't guarantee stability.
-unstable_encodings = ["vortex-zstd?/unstable_encodings"]
+unstable_encodings = ["dep:vortex-tensor", "vortex-zstd?/unstable_encodings"]
 pco = ["dep:pco", "dep:vortex-pco"]
 zstd = ["dep:vortex-zstd"]
 
@@ -64,15 +65,5 @@ name = "compress_listview"
 harness = false
 test = false
 
-[[bench]]
-name = "dict_encode"
-harness = false
-test = false
-
-[[bench]]
-name = "stats_calc"
-harness = false
-test = false
-
 [package.metadata.cargo-machete]
 ignored = ["getrandom_v03"]
diff --git a/vortex-btrblocks/benches/compress.rs b/vortex-btrblocks/benches/compress.rs
index 75139361ed5..18a48881678 100644
--- a/vortex-btrblocks/benches/compress.rs
+++ b/vortex-btrblocks/benches/compress.rs
@@ -9,7 +9,7 @@ mod benchmarks {
     use divan::Bencher;
     use divan::counter::BytesCount;
     use divan::counter::ItemsCount;
-    use rand::RngCore;
+    use rand::Rng;
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::ArrayRef;
@@ -21,11 +21,11 @@ mod benchmarks {
 
     fn make_clickbench_window_name() -> ArrayRef {
         // A test that's meant to mirror the WindowName column from ClickBench.
-        let mut values = buffer_mut![-1i32; 1_000_000];
+        let mut values = buffer_mut![-1i32; 65_536];
         let mut visited = HashSet::new();
         let mut rng = StdRng::seed_from_u64(1u64);
         while visited.len() < 223 {
-            let random = (rng.next_u32() as usize) % 1_000_000;
+            let random = (rng.next_u32() as usize) % 65_536;
             if visited.contains(&random) {
                 continue;
             }
@@ -46,7 +46,7 @@ mod benchmarks {
             .with_inputs(|| &array)
             .input_counter(|array| ItemsCount::new(array.len()))
             .input_counter(|array| BytesCount::of_many::<i32>(array.len()))
-            .bench_refs(|array| compressor.compress(array.as_ref()).unwrap());
+            .bench_refs(|array| compressor.compress(&array.clone().into_array()).unwrap());
     }
 }
 
diff --git a/vortex-btrblocks/benches/compress_listview.rs b/vortex-btrblocks/benches/compress_listview.rs
index 4c1f234fcd4..11f5f92437e 100644
--- a/vortex-btrblocks/benches/compress_listview.rs
+++ b/vortex-btrblocks/benches/compress_listview.rs
@@ -10,7 +10,7 @@ mod benchmarks {
     use divan::Bencher;
     use divan::counter::BytesCount;
     use divan::counter::ItemsCount;
-    use rand::Rng;
+    use rand::RngExt;
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::ArrayRef;
@@ -181,7 +181,7 @@ mod benchmarks {
             .with_inputs(|| &array)
             .input_counter(|_| ItemsCount::new(NUM_ROWS))
             .input_counter(move |_| BytesCount::new(nbytes as usize))
-            .bench_refs(|array| compressor.compress(array.as_ref()).unwrap());
+            .bench_refs(|array| compressor.compress(array).unwrap());
     }
 }
 
diff --git a/vortex-btrblocks/public-api.lock b/vortex-btrblocks/public-api.lock
index bc5af615759..06928421496 100644
--- a/vortex-btrblocks/public-api.lock
+++ b/vortex-btrblocks/public-api.lock
@@ -1,323 +1,711 @@
 pub mod vortex_btrblocks
 
-pub enum vortex_btrblocks::FloatCode
+pub use vortex_btrblocks::ArrayAndStats
 
-pub vortex_btrblocks::FloatCode::Alp
+pub use vortex_btrblocks::BoolStats
 
-pub vortex_btrblocks::FloatCode::AlpRd
+pub use vortex_btrblocks::CascadingCompressor
 
-pub vortex_btrblocks::FloatCode::Constant
+pub use vortex_btrblocks::CompressorContext
 
-pub vortex_btrblocks::FloatCode::Dict
+pub use vortex_btrblocks::FloatStats
 
-pub vortex_btrblocks::FloatCode::Pco
+pub use vortex_btrblocks::GenerateStatsOptions
 
-pub vortex_btrblocks::FloatCode::Rle
+pub use vortex_btrblocks::IntegerStats
 
-pub vortex_btrblocks::FloatCode::RunEnd
+pub use vortex_btrblocks::MAX_CASCADE
 
-pub vortex_btrblocks::FloatCode::Sparse
+pub use vortex_btrblocks::Scheme
 
-pub vortex_btrblocks::FloatCode::Uncompressed
+pub use vortex_btrblocks::SchemeExt
 
-impl core::clone::Clone for vortex_btrblocks::FloatCode
+pub use vortex_btrblocks::SchemeId
 
-pub fn vortex_btrblocks::FloatCode::clone(&self) -> vortex_btrblocks::FloatCode
+pub use vortex_btrblocks::StringStats
 
-impl core::cmp::Eq for vortex_btrblocks::FloatCode
+pub mod vortex_btrblocks::schemes
 
-impl core::cmp::Ord for vortex_btrblocks::FloatCode
+pub mod vortex_btrblocks::schemes::bool
 
-pub fn vortex_btrblocks::FloatCode::cmp(&self, other: &vortex_btrblocks::FloatCode) -> core::cmp::Ordering
+pub use vortex_btrblocks::schemes::bool::BoolConstantScheme
 
-impl core::cmp::PartialEq for vortex_btrblocks::FloatCode
+pub use vortex_btrblocks::schemes::bool::BoolStats
 
-pub fn vortex_btrblocks::FloatCode::eq(&self, other: &vortex_btrblocks::FloatCode) -> bool
+pub mod vortex_btrblocks::schemes::decimal
 
-impl core::cmp::PartialOrd for vortex_btrblocks::FloatCode
+pub struct vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub fn vortex_btrblocks::FloatCode::partial_cmp(&self, other: &vortex_btrblocks::FloatCode) -> core::option::Option<core::cmp::Ordering>
+impl core::clone::Clone for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-impl core::fmt::Debug for vortex_btrblocks::FloatCode
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::clone(&self) -> vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub fn vortex_btrblocks::FloatCode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::cmp::Eq for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-impl core::hash::Hash for vortex_btrblocks::FloatCode
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub fn vortex_btrblocks::FloatCode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::eq(&self, other: &vortex_btrblocks::schemes::decimal::DecimalScheme) -> bool
 
-impl core::marker::Copy for vortex_btrblocks::FloatCode
+impl core::fmt::Debug for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-impl core::marker::StructuralPartialEq for vortex_btrblocks::FloatCode
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl enum_iterator::Sequence for vortex_btrblocks::FloatCode
+impl core::marker::Copy for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub const vortex_btrblocks::FloatCode::CARDINALITY: usize
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub fn vortex_btrblocks::FloatCode::first() -> core::option::Option<Self>
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::decimal::DecimalScheme
 
-pub fn vortex_btrblocks::FloatCode::last() -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_btrblocks::FloatCode::next(&self) -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::FloatCode::previous(&self) -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-pub enum vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::num_children(&self) -> usize
 
-pub vortex_btrblocks::IntCode::BitPacking
+pub fn vortex_btrblocks::schemes::decimal::DecimalScheme::scheme_name(&self) -> &'static str
 
-pub vortex_btrblocks::IntCode::Constant
+pub mod vortex_btrblocks::schemes::float
 
-pub vortex_btrblocks::IntCode::Dict
+pub use vortex_btrblocks::schemes::float::FloatConstantScheme
 
-pub vortex_btrblocks::IntCode::For
+pub use vortex_btrblocks::schemes::float::FloatDictScheme
 
-pub vortex_btrblocks::IntCode::Pco
+pub use vortex_btrblocks::schemes::float::FloatStats
 
-pub vortex_btrblocks::IntCode::Rle
+pub use vortex_btrblocks::schemes::float::is_float_primitive
 
-pub vortex_btrblocks::IntCode::RunEnd
+pub struct vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub vortex_btrblocks::IntCode::Sequence
+impl core::clone::Clone for vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub vortex_btrblocks::IntCode::Sparse
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::clone(&self) -> vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub vortex_btrblocks::IntCode::Uncompressed
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub vortex_btrblocks::IntCode::ZigZag
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::ALPRDScheme
 
-impl core::clone::Clone for vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::eq(&self, other: &vortex_btrblocks::schemes::float::ALPRDScheme) -> bool
 
-pub fn vortex_btrblocks::IntCode::clone(&self) -> vortex_btrblocks::IntCode
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::ALPRDScheme
 
-impl core::cmp::Eq for vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::Ord for vortex_btrblocks::IntCode
+impl core::marker::Copy for vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub fn vortex_btrblocks::IntCode::cmp(&self, other: &vortex_btrblocks::IntCode) -> core::cmp::Ordering
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::ALPRDScheme
 
-impl core::cmp::PartialEq for vortex_btrblocks::IntCode
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::ALPRDScheme
 
-pub fn vortex_btrblocks::IntCode::eq(&self, other: &vortex_btrblocks::IntCode) -> bool
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-impl core::cmp::PartialOrd for vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::IntCode::partial_cmp(&self, other: &vortex_btrblocks::IntCode) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-impl core::fmt::Debug for vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::float::ALPRDScheme::scheme_name(&self) -> &'static str
 
-pub fn vortex_btrblocks::IntCode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub struct vortex_btrblocks::schemes::float::ALPScheme
 
-impl core::hash::Hash for vortex_btrblocks::IntCode
+impl core::clone::Clone for vortex_btrblocks::schemes::float::ALPScheme
 
-pub fn vortex_btrblocks::IntCode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_btrblocks::schemes::float::ALPScheme::clone(&self) -> vortex_btrblocks::schemes::float::ALPScheme
 
-impl core::marker::Copy for vortex_btrblocks::IntCode
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::ALPScheme
 
-impl core::marker::StructuralPartialEq for vortex_btrblocks::IntCode
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::ALPScheme
 
-impl enum_iterator::Sequence for vortex_btrblocks::IntCode
+pub fn vortex_btrblocks::schemes::float::ALPScheme::eq(&self, other: &vortex_btrblocks::schemes::float::ALPScheme) -> bool
 
-pub const vortex_btrblocks::IntCode::CARDINALITY: usize
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::ALPScheme
 
-pub fn vortex_btrblocks::IntCode::first() -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::float::ALPScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_btrblocks::IntCode::last() -> core::option::Option<Self>
+impl core::marker::Copy for vortex_btrblocks::schemes::float::ALPScheme
 
-pub fn vortex_btrblocks::IntCode::next(&self) -> core::option::Option<Self>
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::ALPScheme
 
-pub fn vortex_btrblocks::IntCode::previous(&self) -> core::option::Option<Self>
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::ALPScheme
 
-pub enum vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::ALPScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub vortex_btrblocks::StringCode::Constant
+pub fn vortex_btrblocks::schemes::float::ALPScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub vortex_btrblocks::StringCode::Dict
+pub fn vortex_btrblocks::schemes::float::ALPScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-pub vortex_btrblocks::StringCode::Fsst
+pub fn vortex_btrblocks::schemes::float::ALPScheme::num_children(&self) -> usize
 
-pub vortex_btrblocks::StringCode::Sparse
+pub fn vortex_btrblocks::schemes::float::ALPScheme::scheme_name(&self) -> &'static str
 
-pub vortex_btrblocks::StringCode::Uncompressed
+pub struct vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub vortex_btrblocks::StringCode::Zstd
+impl core::clone::Clone for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub vortex_btrblocks::StringCode::ZstdBuffers
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::clone(&self) -> vortex_btrblocks::schemes::float::FloatRLEScheme
 
-impl core::clone::Clone for vortex_btrblocks::StringCode
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub fn vortex_btrblocks::StringCode::clone(&self) -> vortex_btrblocks::StringCode
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-impl core::cmp::Eq for vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::eq(&self, other: &vortex_btrblocks::schemes::float::FloatRLEScheme) -> bool
 
-impl core::cmp::Ord for vortex_btrblocks::StringCode
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub fn vortex_btrblocks::StringCode::cmp(&self, other: &vortex_btrblocks::StringCode) -> core::cmp::Ordering
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl core::cmp::PartialEq for vortex_btrblocks::StringCode
+impl core::marker::Copy for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub fn vortex_btrblocks::StringCode::eq(&self, other: &vortex_btrblocks::StringCode) -> bool
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-impl core::cmp::PartialOrd for vortex_btrblocks::StringCode
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::FloatRLEScheme
 
-pub fn vortex_btrblocks::StringCode::partial_cmp(&self, other: &vortex_btrblocks::StringCode) -> core::option::Option<core::cmp::Ordering>
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
 
-impl core::fmt::Debug for vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_btrblocks::StringCode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
 
-impl core::hash::Hash for vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::StringCode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-impl core::marker::Copy for vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::num_children(&self) -> usize
 
-impl core::marker::StructuralPartialEq for vortex_btrblocks::StringCode
+pub fn vortex_btrblocks::schemes::float::FloatRLEScheme::scheme_name(&self) -> &'static str
 
-impl enum_iterator::Sequence for vortex_btrblocks::StringCode
+pub struct vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub const vortex_btrblocks::StringCode::CARDINALITY: usize
+impl core::clone::Clone for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub fn vortex_btrblocks::StringCode::first() -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::clone(&self) -> vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub fn vortex_btrblocks::StringCode::last() -> core::option::Option<Self>
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub fn vortex_btrblocks::StringCode::next(&self) -> core::option::Option<Self>
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub fn vortex_btrblocks::StringCode::previous(&self) -> core::option::Option<Self>
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::eq(&self, other: &vortex_btrblocks::schemes::float::NullDominatedSparseScheme) -> bool
 
-pub struct vortex_btrblocks::BtrBlocksCompressor
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub vortex_btrblocks::BtrBlocksCompressor::float_schemes: alloc::vec::Vec<&'static dyn vortex_btrblocks::compressor::float::FloatScheme>
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub vortex_btrblocks::BtrBlocksCompressor::int_schemes: alloc::vec::Vec<&'static dyn vortex_btrblocks::compressor::integer::IntegerScheme>
+impl core::marker::Copy for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub vortex_btrblocks::BtrBlocksCompressor::string_schemes: alloc::vec::Vec<&'static dyn vortex_btrblocks::compressor::string::StringScheme>
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-impl vortex_btrblocks::BtrBlocksCompressor
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::NullDominatedSparseScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::compress(&self, array: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-impl core::clone::Clone for vortex_btrblocks::BtrBlocksCompressor
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::clone(&self) -> vortex_btrblocks::BtrBlocksCompressor
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-impl core::default::Default for vortex_btrblocks::BtrBlocksCompressor
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::default() -> Self
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::num_children(&self) -> usize
 
-impl vortex_btrblocks::CanonicalCompressor for vortex_btrblocks::BtrBlocksCompressor
+pub fn vortex_btrblocks::schemes::float::NullDominatedSparseScheme::scheme_name(&self) -> &'static str
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::compress_canonical(&self, array: vortex_array::canonical::Canonical, ctx: vortex_btrblocks::ctx::CompressorContext, excludes: vortex_btrblocks::ctx::Excludes<'_>) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub struct vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::float_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::float::FloatScheme]
+impl core::clone::Clone for vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::int_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::integer::IntegerScheme]
+pub fn vortex_btrblocks::schemes::float::PcoScheme::clone(&self) -> vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::string_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::string::StringScheme]
+impl core::cmp::Eq for vortex_btrblocks::schemes::float::PcoScheme
 
-pub struct vortex_btrblocks::BtrBlocksCompressorBuilder
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::float::PcoScheme
 
-impl vortex_btrblocks::BtrBlocksCompressorBuilder
+pub fn vortex_btrblocks::schemes::float::PcoScheme::eq(&self, other: &vortex_btrblocks::schemes::float::PcoScheme) -> bool
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::build(self) -> vortex_btrblocks::BtrBlocksCompressor
+impl core::fmt::Debug for vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::empty() -> Self
+pub fn vortex_btrblocks::schemes::float::PcoScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::exclude_float(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::FloatCode>) -> Self
+impl core::marker::Copy for vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::exclude_int(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::IntCode>) -> Self
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::exclude_string(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::StringCode>) -> Self
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::float::PcoScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::include_float(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::FloatCode>) -> Self
+pub fn vortex_btrblocks::schemes::float::PcoScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::include_int(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::IntCode>) -> Self
+pub fn vortex_btrblocks::schemes::float::PcoScheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::include_string(self, codes: impl core::iter::traits::collect::IntoIterator<Item = vortex_btrblocks::StringCode>) -> Self
+pub fn vortex_btrblocks::schemes::float::PcoScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-impl core::clone::Clone for vortex_btrblocks::BtrBlocksCompressorBuilder
+pub fn vortex_btrblocks::schemes::float::PcoScheme::scheme_name(&self) -> &'static str
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::clone(&self) -> vortex_btrblocks::BtrBlocksCompressorBuilder
+pub mod vortex_btrblocks::schemes::integer
 
-impl core::default::Default for vortex_btrblocks::BtrBlocksCompressorBuilder
+pub use vortex_btrblocks::schemes::integer::IntConstantScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::default() -> Self
+pub use vortex_btrblocks::schemes::integer::IntDictScheme
 
-impl core::fmt::Debug for vortex_btrblocks::BtrBlocksCompressorBuilder
+pub use vortex_btrblocks::schemes::integer::IntegerStats
 
-pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub use vortex_btrblocks::schemes::integer::is_integer_primitive
+
+pub struct vortex_btrblocks::schemes::integer::BitPackingScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::clone(&self) -> vortex_btrblocks::schemes::integer::BitPackingScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::BitPackingScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::BitPackingScheme
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::BitPackingScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::integer::FoRScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::FoRScheme
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::clone(&self) -> vortex_btrblocks::schemes::integer::FoRScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::FoRScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::FoRScheme
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::FoRScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::FoRScheme
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::FoRScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::FoRScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::FoRScheme
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::FoRScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::clone(&self) -> vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::IntRLEScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::IntRLEScheme
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::integer::IntRLEScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::integer::PcoScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::PcoScheme
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::clone(&self) -> vortex_btrblocks::schemes::integer::PcoScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::PcoScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::PcoScheme
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::PcoScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::PcoScheme
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::PcoScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::PcoScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::PcoScheme
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::PcoScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::integer::RunEndScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::RunEndScheme
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::clone(&self) -> vortex_btrblocks::schemes::integer::RunEndScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::RunEndScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::RunEndScheme
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::RunEndScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::RunEndScheme
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::RunEndScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::RunEndScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::RunEndScheme
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::integer::RunEndScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::integer::SequenceScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::SequenceScheme
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::clone(&self) -> vortex_btrblocks::schemes::integer::SequenceScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::SequenceScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::SequenceScheme
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::SequenceScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::SequenceScheme
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::SequenceScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::SequenceScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::SequenceScheme
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-pub struct vortex_btrblocks::GenerateStatsOptions
+pub fn vortex_btrblocks::schemes::integer::SequenceScheme::scheme_name(&self) -> &'static str
 
-pub vortex_btrblocks::GenerateStatsOptions::count_distinct_values: bool
+pub struct vortex_btrblocks::schemes::integer::SparseScheme
 
-impl core::default::Default for vortex_btrblocks::GenerateStatsOptions
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub fn vortex_btrblocks::GenerateStatsOptions::default() -> Self
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::clone(&self) -> vortex_btrblocks::schemes::integer::SparseScheme
 
-pub struct vortex_btrblocks::IntegerStats
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::SparseScheme
 
-impl core::clone::Clone for vortex_btrblocks::IntegerStats
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub fn vortex_btrblocks::IntegerStats::clone(&self) -> vortex_btrblocks::IntegerStats
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::SparseScheme) -> bool
 
-impl core::fmt::Debug for vortex_btrblocks::IntegerStats
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub fn vortex_btrblocks::IntegerStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_btrblocks::CompressorStats for vortex_btrblocks::IntegerStats
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub type vortex_btrblocks::IntegerStats::ArrayVTable = vortex_array::arrays::primitive::vtable::PrimitiveVTable
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub fn vortex_btrblocks::IntegerStats::generate_opts(input: &vortex_array::arrays::primitive::array::PrimitiveArray, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::SparseScheme
 
-pub fn vortex_btrblocks::IntegerStats::sample_opts(&self, sample_size: u32, sample_count: u32, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub fn vortex_btrblocks::IntegerStats::source(&self) -> &vortex_array::arrays::primitive::array::PrimitiveArray
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
 
-pub trait vortex_btrblocks::CanonicalCompressor
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::CanonicalCompressor::compress_canonical(&self, array: vortex_array::canonical::Canonical, ctx: vortex_btrblocks::ctx::CompressorContext, excludes: vortex_btrblocks::ctx::Excludes<'_>) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
 
-pub fn vortex_btrblocks::CanonicalCompressor::float_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::float::FloatScheme]
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::num_children(&self) -> usize
 
-pub fn vortex_btrblocks::CanonicalCompressor::int_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::integer::IntegerScheme]
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::scheme_name(&self) -> &'static str
 
-pub fn vortex_btrblocks::CanonicalCompressor::string_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::string::StringScheme]
+pub fn vortex_btrblocks::schemes::integer::SparseScheme::stats_options(&self) -> vortex_compressor::stats::options::GenerateStatsOptions
 
-impl vortex_btrblocks::CanonicalCompressor for vortex_btrblocks::BtrBlocksCompressor
+pub struct vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::compress_canonical(&self, array: vortex_array::canonical::Canonical, ctx: vortex_btrblocks::ctx::CompressorContext, excludes: vortex_btrblocks::ctx::Excludes<'_>) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+impl core::clone::Clone for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::float_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::float::FloatScheme]
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::clone(&self) -> vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::int_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::integer::IntegerScheme]
+impl core::cmp::Eq for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::BtrBlocksCompressor::string_schemes(&self) -> &[&'static dyn vortex_btrblocks::compressor::string::StringScheme]
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub trait vortex_btrblocks::CompressorStats: core::fmt::Debug + core::clone::Clone
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::eq(&self, other: &vortex_btrblocks::schemes::integer::ZigZagScheme) -> bool
 
-pub type vortex_btrblocks::CompressorStats::ArrayVTable: vortex_array::vtable::VTable
+impl core::fmt::Debug for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::CompressorStats::generate(input: &<Self::ArrayVTable as vortex_array::vtable::VTable>::Array) -> Self
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_btrblocks::CompressorStats::generate_opts(input: &<Self::ArrayVTable as vortex_array::vtable::VTable>::Array, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+impl core::marker::Copy for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::CompressorStats::sample(&self, sample_size: u32, sample_count: u32) -> Self
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::CompressorStats::sample_opts(&self, sample_size: u32, sample_count: u32, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::integer::ZigZagScheme
 
-pub fn vortex_btrblocks::CompressorStats::source(&self) -> &<Self::ArrayVTable as vortex_array::vtable::VTable>::Array
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
 
-impl vortex_btrblocks::CompressorStats for vortex_btrblocks::IntegerStats
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-pub type vortex_btrblocks::IntegerStats::ArrayVTable = vortex_array::arrays::primitive::vtable::PrimitiveVTable
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
 
-pub fn vortex_btrblocks::IntegerStats::generate_opts(input: &vortex_array::arrays::primitive::array::PrimitiveArray, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
 
-pub fn vortex_btrblocks::IntegerStats::sample_opts(&self, sample_size: u32, sample_count: u32, opts: vortex_btrblocks::GenerateStatsOptions) -> Self
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::integer::ZigZagScheme::scheme_name(&self) -> &'static str
+
+pub mod vortex_btrblocks::schemes::string
+
+pub use vortex_btrblocks::schemes::string::StringConstantScheme
+
+pub use vortex_btrblocks::schemes::string::StringDictScheme
+
+pub use vortex_btrblocks::schemes::string::StringStats
+
+pub use vortex_btrblocks::schemes::string::is_utf8_string
+
+pub struct vortex_btrblocks::schemes::string::FSSTScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::string::FSSTScheme
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::clone(&self) -> vortex_btrblocks::schemes::string::FSSTScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::string::FSSTScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::string::FSSTScheme
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::eq(&self, other: &vortex_btrblocks::schemes::string::FSSTScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::string::FSSTScheme
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::string::FSSTScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::string::FSSTScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::string::FSSTScheme
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::string::FSSTScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::clone(&self) -> vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::eq(&self, other: &vortex_btrblocks::schemes::string::NullDominatedSparseScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::string::NullDominatedSparseScheme
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::string::NullDominatedSparseScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::schemes::string::ZstdScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::string::ZstdScheme
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::clone(&self) -> vortex_btrblocks::schemes::string::ZstdScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::string::ZstdScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::string::ZstdScheme
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::eq(&self, other: &vortex_btrblocks::schemes::string::ZstdScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::string::ZstdScheme
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::string::ZstdScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::string::ZstdScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::string::ZstdScheme
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::compress(&self, _compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::string::ZstdScheme::scheme_name(&self) -> &'static str
+
+pub mod vortex_btrblocks::schemes::temporal
+
+pub struct vortex_btrblocks::schemes::temporal::TemporalScheme
+
+impl core::clone::Clone for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::clone(&self) -> vortex_btrblocks::schemes::temporal::TemporalScheme
+
+impl core::cmp::Eq for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+impl core::cmp::PartialEq for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::eq(&self, other: &vortex_btrblocks::schemes::temporal::TemporalScheme) -> bool
+
+impl core::fmt::Debug for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+impl core::marker::StructuralPartialEq for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_btrblocks::schemes::temporal::TemporalScheme
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::num_children(&self) -> usize
+
+pub fn vortex_btrblocks::schemes::temporal::TemporalScheme::scheme_name(&self) -> &'static str
+
+pub struct vortex_btrblocks::BtrBlocksCompressor(pub vortex_compressor::compressor::CascadingCompressor)
+
+impl vortex_btrblocks::BtrBlocksCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressor::compress(&self, array: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+impl core::clone::Clone for vortex_btrblocks::BtrBlocksCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressor::clone(&self) -> vortex_btrblocks::BtrBlocksCompressor
+
+impl core::default::Default for vortex_btrblocks::BtrBlocksCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressor::default() -> Self
+
+impl core::fmt::Debug for vortex_btrblocks::BtrBlocksCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressor::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::ops::deref::Deref for vortex_btrblocks::BtrBlocksCompressor
+
+pub type vortex_btrblocks::BtrBlocksCompressor::Target = vortex_compressor::compressor::CascadingCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressor::deref(&self) -> &vortex_compressor::compressor::CascadingCompressor
+
+pub struct vortex_btrblocks::BtrBlocksCompressorBuilder
+
+impl vortex_btrblocks::BtrBlocksCompressorBuilder
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::build(self) -> vortex_btrblocks::BtrBlocksCompressor
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::exclude_schemes(self, ids: impl core::iter::traits::collect::IntoIterator<Item = vortex_compressor::scheme::SchemeId>) -> Self
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::only_cuda_compatible(self) -> Self
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::with_compact(self) -> Self
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::with_new_scheme(self, scheme: &'static dyn vortex_compressor::scheme::Scheme) -> Self
+
+impl core::clone::Clone for vortex_btrblocks::BtrBlocksCompressorBuilder
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::clone(&self) -> vortex_btrblocks::BtrBlocksCompressorBuilder
+
+impl core::default::Default for vortex_btrblocks::BtrBlocksCompressorBuilder
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::default() -> Self
+
+impl core::fmt::Debug for vortex_btrblocks::BtrBlocksCompressorBuilder
+
+pub fn vortex_btrblocks::BtrBlocksCompressorBuilder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_btrblocks::IntegerStats::source(&self) -> &vortex_array::arrays::primitive::array::PrimitiveArray
+pub const vortex_btrblocks::ALL_SCHEMES: &[&dyn vortex_compressor::scheme::Scheme]
 
-pub fn vortex_btrblocks::integer_dictionary_encode(stats: &vortex_btrblocks::IntegerStats) -> vortex_array::arrays::dict::array::DictArray
+pub fn vortex_btrblocks::compress_patches(patches: vortex_array::patches::Patches) -> vortex_error::VortexResult<vortex_array::patches::Patches>
diff --git a/vortex-btrblocks/src/builder.rs b/vortex-btrblocks/src/builder.rs
index d329ec8c139..da405b153e8 100644
--- a/vortex-btrblocks/src/builder.rs
+++ b/vortex-btrblocks/src/builder.rs
@@ -3,156 +3,188 @@
 
 //! Builder for configuring `BtrBlocksCompressor` instances.
 
-use itertools::Itertools;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::BtrBlocksCompressor;
-use crate::FloatCode;
-use crate::IntCode;
-use crate::StringCode;
-use crate::compressor::float::ALL_FLOAT_SCHEMES;
-use crate::compressor::float::FloatScheme;
-use crate::compressor::integer::ALL_INT_SCHEMES;
-use crate::compressor::integer::IntegerScheme;
-use crate::compressor::string::ALL_STRING_SCHEMES;
-use crate::compressor::string::StringScheme;
+use crate::CascadingCompressor;
+use crate::Scheme;
+use crate::SchemeExt;
+use crate::SchemeId;
+use crate::schemes::bool;
+use crate::schemes::decimal;
+use crate::schemes::float;
+use crate::schemes::integer;
+use crate::schemes::string;
+use crate::schemes::temporal;
+
+/// All available compression schemes.
+///
+/// This list is order-sensitive: the builder preserves this order when constructing
+/// the final scheme list, so that tie-breaking is deterministic.
+pub const ALL_SCHEMES: &[&dyn Scheme] = &[
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    // Bool schemes.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    &bool::BoolConstantScheme,
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    // Integer schemes.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    &integer::IntConstantScheme,
+    // NOTE: FoR must precede BitPacking to avoid unnecessary patches.
+    &integer::FoRScheme,
+    // NOTE: ZigZag should precede BitPacking because we don't want negative numbers.
+    &integer::ZigZagScheme,
+    &integer::BitPackingScheme,
+    &integer::SparseScheme,
+    &integer::IntDictScheme,
+    &integer::RunEndScheme,
+    &integer::SequenceScheme,
+    &integer::IntRLEScheme,
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    // Float schemes.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    &float::FloatConstantScheme,
+    &float::ALPScheme,
+    &float::ALPRDScheme,
+    &float::FloatDictScheme,
+    &float::NullDominatedSparseScheme,
+    &float::FloatRLEScheme,
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    // String schemes.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    &string::StringDictScheme,
+    &string::FSSTScheme,
+    &string::StringConstantScheme,
+    &string::NullDominatedSparseScheme,
+    // Decimal schemes.
+    &decimal::DecimalScheme,
+    // Temporal schemes.
+    &temporal::TemporalScheme,
+];
 
 /// Builder for creating configured [`BtrBlocksCompressor`] instances.
 ///
-/// Use this builder to configure which compression schemes are allowed for each data type.
-/// By default, all schemes are enabled.
+/// By default, all schemes in [`ALL_SCHEMES`] are enabled. Feature-gated schemes (Pco, Zstd)
+/// are not in `ALL_SCHEMES` and must be added explicitly via
+/// [`with_scheme`](BtrBlocksCompressorBuilder::with_new_scheme) or
+/// [`with_compact`](BtrBlocksCompressorBuilder::with_compact).
 ///
 /// # Examples
 ///
 /// ```rust
-/// use vortex_btrblocks::{BtrBlocksCompressorBuilder, IntCode, FloatCode};
+/// use vortex_btrblocks::{BtrBlocksCompressorBuilder, Scheme, SchemeExt};
+/// use vortex_btrblocks::schemes::integer::IntDictScheme;
 ///
-/// // Default compressor - all schemes allowed
+/// // Default compressor with all schemes in ALL_SCHEMES.
 /// let compressor = BtrBlocksCompressorBuilder::default().build();
 ///
-/// // Exclude specific schemes
-/// let compressor = BtrBlocksCompressorBuilder::default()
-///     .exclude_int([IntCode::Dict])
-///     .build();
-///
-/// // Exclude then re-include
+/// // Remove specific schemes.
 /// let compressor = BtrBlocksCompressorBuilder::default()
-///     .exclude_int([IntCode::Dict, IntCode::Rle])
-///     .include_int([IntCode::Dict])
+///     .exclude_schemes([IntDictScheme.id()])
 ///     .build();
 /// ```
 #[derive(Debug, Clone)]
 pub struct BtrBlocksCompressorBuilder {
-    int_schemes: HashSet<&'static dyn IntegerScheme>,
-    float_schemes: HashSet<&'static dyn FloatScheme>,
-    string_schemes: HashSet<&'static dyn StringScheme>,
+    schemes: Vec<&'static dyn Scheme>,
 }
 
 impl Default for BtrBlocksCompressorBuilder {
     fn default() -> Self {
         Self {
-            int_schemes: ALL_INT_SCHEMES
-                .iter()
-                .copied()
-                .filter(|s| s.code() != IntCode::Pco)
-                .collect(),
-            float_schemes: ALL_FLOAT_SCHEMES
-                .iter()
-                .copied()
-                .filter(|s| s.code() != FloatCode::Pco)
-                .collect(),
-            string_schemes: ALL_STRING_SCHEMES
-                .iter()
-                .copied()
-                .filter(|s| s.code() != StringCode::Zstd && s.code() != StringCode::ZstdBuffers)
-                .collect(),
+            schemes: ALL_SCHEMES.to_vec(),
         }
     }
 }
 
 impl BtrBlocksCompressorBuilder {
-    /// Create a new builder with no encodings enabled.
-    pub fn empty() -> Self {
-        Self {
-            int_schemes: Default::default(),
-            float_schemes: Default::default(),
-            string_schemes: Default::default(),
-        }
-    }
+    /// Adds an external compression scheme not in [`ALL_SCHEMES`].
+    ///
+    /// This allows encoding crates outside of `vortex-btrblocks` to register their own schemes
+    /// with the compressor.
+    ///
+    /// # Panics
+    ///
+    /// Panics if a scheme with the same [`SchemeId`] is already present.
+    pub fn with_new_scheme(mut self, scheme: &'static dyn Scheme) -> Self {
+        assert!(
+            !self.schemes.iter().any(|s| s.id() == scheme.id()),
+            "scheme {:?} is already present in the builder",
+            scheme.id(),
+        );
 
-    /// Excludes the specified integer compression schemes.
-    pub fn exclude_int(mut self, codes: impl IntoIterator<Item = IntCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        self.int_schemes.retain(|s| !codes.contains(&s.code()));
+        self.schemes.push(scheme);
         self
     }
 
-    /// Excludes the specified float compression schemes.
-    pub fn exclude_float(mut self, codes: impl IntoIterator<Item = FloatCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        self.float_schemes.retain(|s| !codes.contains(&s.code()));
-        self
-    }
+    /// Adds compact encoding schemes (Zstd for strings, 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,
+    /// Pco schemes for integers and floats are included.
+    ///
+    /// # Panics
+    ///
+    /// 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);
 
-    /// Excludes the specified string compression schemes.
-    pub fn exclude_string(mut self, codes: impl IntoIterator<Item = StringCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        self.string_schemes.retain(|s| !codes.contains(&s.code()));
-        self
+        #[cfg(feature = "pco")]
+        let builder = builder
+            .with_new_scheme(&integer::PcoScheme)
+            .with_new_scheme(&float::PcoScheme);
+
+        builder
     }
 
-    /// Includes the specified integer compression schemes.
-    pub fn include_int(mut self, codes: impl IntoIterator<Item = IntCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        for scheme in ALL_INT_SCHEMES {
-            if codes.contains(&scheme.code()) {
-                self.int_schemes.insert(*scheme);
-            }
-        }
-        self
+    /// 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)
     }
 
-    /// Includes the specified float compression schemes.
-    pub fn include_float(mut self, codes: impl IntoIterator<Item = FloatCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        for scheme in ALL_FLOAT_SCHEMES {
-            if codes.contains(&scheme.code()) {
-                self.float_schemes.insert(*scheme);
-            }
-        }
-        self
+    /// Excludes schemes without CUDA kernel support and adds Zstd for string 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,
+    /// interleaved Zstd compression is used.
+    pub fn only_cuda_compatible(self) -> Self {
+        let builder = self.exclude_schemes([
+            integer::SparseScheme.id(),
+            integer::IntRLEScheme.id(),
+            float::FloatRLEScheme.id(),
+            float::NullDominatedSparseScheme.id(),
+            string::StringDictScheme.id(),
+            string::FSSTScheme.id(),
+        ]);
+
+        #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+        let builder = builder.with_new_scheme(&string::ZstdBuffersScheme);
+        #[cfg(all(feature = "zstd", not(feature = "unstable_encodings")))]
+        let builder = builder.with_new_scheme(&string::ZstdScheme);
+
+        builder
     }
 
-    /// Includes the specified string compression schemes.
-    pub fn include_string(mut self, codes: impl IntoIterator<Item = StringCode>) -> Self {
-        let codes: HashSet<_> = codes.into_iter().collect();
-        for scheme in ALL_STRING_SCHEMES {
-            if codes.contains(&scheme.code()) {
-                self.string_schemes.insert(*scheme);
-            }
-        }
+    /// Removes the specified compression schemes by their [`SchemeId`].
+    pub fn exclude_schemes(mut self, ids: impl IntoIterator<Item = SchemeId>) -> Self {
+        let ids: HashSet<_> = ids.into_iter().collect();
+        self.schemes.retain(|s| !ids.contains(&s.id()));
         self
     }
 
-    /// Builds the configured `BtrBlocksCompressor`.
+    /// Builds the configured [`BtrBlocksCompressor`].
     pub fn build(self) -> BtrBlocksCompressor {
-        // Note we should apply the schemes in the same order, in case try conflict.
-        BtrBlocksCompressor {
-            int_schemes: self
-                .int_schemes
-                .into_iter()
-                .sorted_by_key(|s| s.code())
-                .collect_vec(),
-            float_schemes: self
-                .float_schemes
-                .into_iter()
-                .sorted_by_key(|s| s.code())
-                .collect_vec(),
-            string_schemes: self
-                .string_schemes
-                .into_iter()
-                .sorted_by_key(|s| s.code())
-                .collect_vec(),
-        }
+        BtrBlocksCompressor(CascadingCompressor::new(self.schemes))
     }
 }
diff --git a/vortex-btrblocks/src/canonical_compressor.rs b/vortex-btrblocks/src/canonical_compressor.rs
index b606d4ba4ae..1739a41214f 100644
--- a/vortex-btrblocks/src/canonical_compressor.rs
+++ b/vortex-btrblocks/src/canonical_compressor.rs
@@ -1,112 +1,60 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Canonical array compression implementation.
+//! BtrBlocks-specific compressor wrapping the generic [`CascadingCompressor`].
+
+use std::ops::Deref;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::ListArray;
-use vortex_array::arrays::ListViewArray;
-use vortex_array::arrays::StructArray;
-use vortex_array::arrays::TemporalArray;
-use vortex_array::arrays::list_from_list_view;
-use vortex_array::compute::Cost;
-use vortex_array::compute::IsConstantOpts;
-use vortex_array::compute::is_constant_opts;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::Nullability;
-use vortex_array::extension::datetime::TemporalMetadata;
-use vortex_array::vtable::ValidityHelper;
 use vortex_error::VortexResult;
 
 use crate::BtrBlocksCompressorBuilder;
-use crate::CompressorContext;
-use crate::CompressorExt;
-use crate::Excludes;
-use crate::FloatCompressor;
-use crate::IntCode;
-use crate::IntCompressor;
-use crate::StringCompressor;
-use crate::compressor::decimal::compress_decimal;
-use crate::compressor::float::FloatScheme;
-use crate::compressor::integer::IntegerScheme;
-use crate::compressor::string::StringScheme;
-use crate::compressor::temporal::compress_temporal;
-
-/// Trait for compressors that can compress canonical arrays.
-///
-/// Provides access to configured compression schemes and the ability to
-/// compress canonical arrays recursively.
-pub trait CanonicalCompressor {
-    /// Compresses a canonical array with the specified options.
-    fn compress_canonical(
-        &self,
-        array: Canonical,
-        ctx: CompressorContext,
-        excludes: Excludes,
-    ) -> VortexResult<ArrayRef>;
-
-    /// Returns the enabled integer compression schemes.
-    fn int_schemes(&self) -> &[&'static dyn IntegerScheme];
-
-    /// Returns the enabled float compression schemes.
-    fn float_schemes(&self) -> &[&'static dyn FloatScheme];
+use crate::CascadingCompressor;
 
-    /// Returns the enabled string compression schemes.
-    fn string_schemes(&self) -> &[&'static dyn StringScheme];
-}
-
-/// The main compressor type implementing BtrBlocks-inspired compression.
-///
-/// This compressor applies adaptive compression schemes to arrays based on their data types
-/// and characteristics. It recursively compresses nested structures like structs and lists,
-/// and chooses optimal compression schemes for primitive types.
-///
-/// The compressor works by:
-/// 1. Canonicalizing input arrays to a standard representation
-/// 2. Analyzing data characteristics to choose optimal compression schemes
-/// 3. Recursively compressing nested structures
-/// 4. Applying type-specific compression for primitives, strings, and temporal data
+/// The BtrBlocks-style compressor with all built-in schemes pre-registered.
 ///
-/// Use [`BtrBlocksCompressorBuilder`] to configure which compression schemes are enabled.
+/// This is a thin wrapper around [`CascadingCompressor`] that provides a default set of
+/// compression schemes via [`BtrBlocksCompressorBuilder`].
 ///
 /// # Examples
 ///
 /// ```rust
-/// use vortex_btrblocks::{BtrBlocksCompressor, BtrBlocksCompressorBuilder, IntCode};
+/// use vortex_btrblocks::{BtrBlocksCompressor, BtrBlocksCompressorBuilder, Scheme, SchemeExt};
+/// use vortex_btrblocks::schemes::integer::IntDictScheme;
 ///
-/// // Default compressor - all schemes allowed
+/// // Default compressor - all schemes allowed.
 /// let compressor = BtrBlocksCompressor::default();
 ///
-/// // Exclude specific schemes using the builder
+/// // Remove specific schemes using the builder.
 /// let compressor = BtrBlocksCompressorBuilder::default()
-///     .exclude_int([IntCode::Dict])
+///     .exclude_schemes([IntDictScheme.id()])
 ///     .build();
 /// ```
 #[derive(Clone)]
-pub struct BtrBlocksCompressor {
-    /// Integer compressor with configured schemes.
-    pub int_schemes: Vec<&'static dyn IntegerScheme>,
+pub struct BtrBlocksCompressor(
+    /// The underlying cascading compressor.
+    pub CascadingCompressor,
+);
 
-    /// Float compressor with configured schemes.
-    pub float_schemes: Vec<&'static dyn FloatScheme>,
+impl BtrBlocksCompressor {
+    /// Compresses an array using BtrBlocks-inspired compression.
+    pub fn compress(&self, array: &ArrayRef) -> VortexResult<ArrayRef> {
+        self.0.compress(array)
+    }
+}
 
-    /// String compressor with configured schemes.
-    pub string_schemes: Vec<&'static dyn StringScheme>,
+impl Deref for BtrBlocksCompressor {
+    type Target = CascadingCompressor;
+
+    fn deref(&self) -> &CascadingCompressor {
+        &self.0
+    }
 }
 
 impl std::fmt::Debug for BtrBlocksCompressor {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BtrBlocksCompressor")
-            .field("int_schemes", &self.int_schemes.len())
-            .field("float_schemes", &self.float_schemes.len())
-            .field("string_schemes", &self.string_schemes.len())
+            .field("compressor", &self.0)
             .finish()
     }
 }
@@ -117,224 +65,18 @@ impl Default for BtrBlocksCompressor {
     }
 }
 
-impl BtrBlocksCompressor {
-    /// Compresses an array using BtrBlocks-inspired compression.
-    ///
-    /// First canonicalizes and compacts the array, then applies optimal compression schemes.
-    pub fn compress(&self, array: &dyn Array) -> VortexResult<ArrayRef> {
-        // Canonicalize the array
-        let canonical = array.to_canonical()?;
-
-        // Compact it, removing any wasted space before we attempt to compress it
-        let compact = canonical.compact()?;
-
-        self.compress_canonical(compact, CompressorContext::default(), Excludes::none())
-    }
-
-    pub(crate) fn integer_compressor(&self) -> IntCompressor<'_> {
-        IntCompressor {
-            btr_blocks_compressor: self,
-        }
-    }
-
-    pub(crate) fn float_compressor(&self) -> FloatCompressor<'_> {
-        FloatCompressor {
-            btr_blocks_compressor: self,
-        }
-    }
-
-    pub(crate) fn string_compressor(&self) -> StringCompressor<'_> {
-        StringCompressor {
-            btr_blocks_compressor: self,
-        }
-    }
-
-    /// Compresses a [`ListArray`] by narrowing offsets and recursively compressing elements.
-    fn compress_list_array(
-        &self,
-        list_array: ListArray,
-        ctx: CompressorContext,
-    ) -> VortexResult<ArrayRef> {
-        // Reset the offsets to remove garbage data that might prevent us from narrowing our
-        // offsets (there could be a large amount of trailing garbage data that the current
-        // views do not reference at all).
-        let list_array = list_array.reset_offsets(true)?;
-
-        let compressed_elems = self.compress(list_array.elements())?;
-
-        // Note that since the type of our offsets are not encoded in our `DType`, and since
-        // we guarantee above that all elements are referenced by offsets, we may narrow the
-        // widths.
-        let compressed_offsets = self.compress_canonical(
-            Canonical::Primitive(list_array.offsets().to_primitive().narrow()?),
-            ctx,
-            Excludes::from(&[IntCode::Dict]),
-        )?;
-
-        Ok(ListArray::try_new(
-            compressed_elems,
-            compressed_offsets,
-            list_array.validity().clone(),
-        )?
-        .into_array())
-    }
-
-    /// Compresses a [`ListViewArray`] by narrowing offsets/sizes and recursively compressing
-    /// elements.
-    fn compress_list_view_array(
-        &self,
-        list_view: ListViewArray,
-        ctx: CompressorContext,
-    ) -> VortexResult<ArrayRef> {
-        let compressed_elems = self.compress(list_view.elements())?;
-        let compressed_offsets = self.compress_canonical(
-            Canonical::Primitive(list_view.offsets().to_primitive().narrow()?),
-            ctx,
-            Excludes::none(),
-        )?;
-        let compressed_sizes = self.compress_canonical(
-            Canonical::Primitive(list_view.sizes().to_primitive().narrow()?),
-            ctx,
-            Excludes::none(),
-        )?;
-        Ok(ListViewArray::try_new(
-            compressed_elems,
-            compressed_offsets,
-            compressed_sizes,
-            list_view.validity().clone(),
-        )?
-        .into_array())
-    }
-}
-
-impl CanonicalCompressor for BtrBlocksCompressor {
-    /// Compresses a canonical array by dispatching to type-specific compressors.
-    ///
-    /// Recursively compresses nested structures and applies optimal schemes for each data type.
-    fn compress_canonical(
-        &self,
-        array: Canonical,
-        ctx: CompressorContext,
-        excludes: Excludes,
-    ) -> VortexResult<ArrayRef> {
-        match array {
-            Canonical::Null(null_array) => Ok(null_array.into_array()),
-            // TODO(aduffy): Sparse, other bool compressors.
-            Canonical::Bool(bool_array) => Ok(bool_array.into_array()),
-            Canonical::Primitive(primitive) => {
-                if primitive.ptype().is_int() {
-                    self.integer_compressor()
-                        .compress(self, &primitive, ctx, excludes.int)
-                } else {
-                    self.float_compressor()
-                        .compress(self, &primitive, ctx, excludes.float)
-                }
-            }
-            Canonical::Decimal(decimal) => compress_decimal(self, &decimal),
-            Canonical::Struct(struct_array) => {
-                let fields = struct_array
-                    .unmasked_fields()
-                    .iter()
-                    .map(|field| self.compress(field))
-                    .collect::<Result<Vec<_>, _>>()?;
-
-                Ok(StructArray::try_new(
-                    struct_array.names().clone(),
-                    fields,
-                    struct_array.len(),
-                    struct_array.validity().clone(),
-                )?
-                .into_array())
-            }
-            Canonical::List(list_view_array) => {
-                if list_view_array.is_zero_copy_to_list() || list_view_array.elements().is_empty() {
-                    // Offsets are already monotonic and non-overlapping, so we
-                    // can drop the sizes array and compress as a ListArray.
-                    let list_array = list_from_list_view(list_view_array)?;
-                    self.compress_list_array(list_array, ctx)
-                } else {
-                    self.compress_list_view_array(list_view_array, ctx)
-                }
-            }
-            Canonical::FixedSizeList(fsl_array) => {
-                let compressed_elems = self.compress(fsl_array.elements())?;
-
-                Ok(FixedSizeListArray::try_new(
-                    compressed_elems,
-                    fsl_array.list_size(),
-                    fsl_array.validity().clone(),
-                    fsl_array.len(),
-                )?
-                .into_array())
-            }
-            Canonical::VarBinView(strings) => {
-                if strings
-                    .dtype()
-                    .eq_ignore_nullability(&DType::Utf8(Nullability::NonNullable))
-                {
-                    self.string_compressor()
-                        .compress(self, &strings, ctx, excludes.string)
-                } else {
-                    // Binary arrays do not compress
-                    Ok(strings.into_array())
-                }
-            }
-            Canonical::Extension(ext_array) => {
-                // We compress Timestamp-level arrays with DateTimeParts compression
-                if let Ok(temporal_array) = TemporalArray::try_from(ext_array.to_array())
-                    && let TemporalMetadata::Timestamp(..) = temporal_array.temporal_metadata()
-                {
-                    if is_constant_opts(
-                        temporal_array.as_ref(),
-                        &IsConstantOpts {
-                            cost: Cost::Canonicalize,
-                        },
-                    )?
-                    .unwrap_or_default()
-                    {
-                        return Ok(ConstantArray::new(
-                            temporal_array.as_ref().scalar_at(0)?,
-                            ext_array.len(),
-                        )
-                        .into_array());
-                    }
-                    return compress_temporal(self, temporal_array);
-                }
-
-                // Compress the underlying storage array.
-                let compressed_storage = self.compress(ext_array.storage())?;
-
-                Ok(
-                    ExtensionArray::new(ext_array.ext_dtype().clone(), compressed_storage)
-                        .into_array(),
-                )
-            }
-        }
-    }
-
-    fn int_schemes(&self) -> &[&'static dyn IntegerScheme] {
-        &self.int_schemes
-    }
-
-    fn float_schemes(&self) -> &[&'static dyn FloatScheme] {
-        &self.float_schemes
-    }
-
-    fn string_schemes(&self) -> &[&'static dyn StringScheme] {
-        &self.string_schemes
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::IntoArray;
-    use vortex_array::arrays::ListVTable;
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::List;
+    use vortex_array::arrays::ListView;
     use vortex_array::arrays::ListViewArray;
-    use vortex_array::arrays::ListViewVTable;
     use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
+    use vortex_buffer::BitBuffer;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
 
@@ -365,13 +107,71 @@ mod tests {
         #[case] input: ListViewArray,
         #[case] expect_list: bool,
     ) -> VortexResult<()> {
-        let result = BtrBlocksCompressor::default().compress(input.as_ref())?;
+        let array_ref = input.clone().into_array();
+        let result = BtrBlocksCompressor::default().compress(&array_ref)?;
         if expect_list {
-            assert!(result.as_opt::<ListVTable>().is_some());
+            assert!(result.as_opt::<List>().is_some());
         } else {
-            assert!(result.as_opt::<ListViewVTable>().is_some());
+            assert!(result.as_opt::<ListView>().is_some());
         }
         assert_arrays_eq!(result, input);
         Ok(())
     }
+
+    #[test]
+    fn test_constant_all_true() -> VortexResult<()> {
+        let array = BoolArray::new(BitBuffer::from(vec![true; 100]), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.clone().into_array())?;
+        assert!(compressed.is::<Constant>());
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
+
+    #[test]
+    fn test_constant_all_false() -> VortexResult<()> {
+        let array = BoolArray::new(BitBuffer::from(vec![false; 100]), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.clone().into_array())?;
+        assert!(compressed.is::<Constant>());
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
+
+    #[test]
+    fn test_nullable_all_valid_compressed() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![true; 100]),
+            Validity::from(BitBuffer::from(vec![true; 100])),
+        );
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.clone().into_array())?;
+        assert!(compressed.is::<Constant>());
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
+
+    #[test]
+    fn test_nullable_with_nulls_not_compressed() -> VortexResult<()> {
+        let validity = Validity::from(BitBuffer::from_iter((0..100).map(|i| i % 3 != 0)));
+        let array = BoolArray::new(BitBuffer::from(vec![true; 100]), validity);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.clone().into_array())?;
+        assert!(!compressed.is::<Constant>());
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
+
+    #[test]
+    fn test_mixed_not_constant() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![true, false, true, false, true]),
+            Validity::NonNullable,
+        );
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.clone().into_array())?;
+        assert!(!compressed.is::<Constant>());
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
 }
diff --git a/vortex-btrblocks/src/compressor/decimal.rs b/vortex-btrblocks/src/compressor/decimal.rs
deleted file mode 100644
index 36b3111453e..00000000000
--- a/vortex-btrblocks/src/compressor/decimal.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::arrays::DecimalArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::narrowed_decimal;
-use vortex_array::dtype::DecimalType;
-use vortex_array::vtable::ValidityHelper;
-use vortex_decimal_byte_parts::DecimalBytePartsArray;
-use vortex_error::VortexResult;
-
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::CompressorContext;
-use crate::Excludes;
-
-// TODO(joe): add support splitting i128/256 buffers into chunks primitive values for compression.
-// 2 for i128 and 4 for i256
-pub fn compress_decimal(
-    compressor: &BtrBlocksCompressor,
-    decimal: &DecimalArray,
-) -> VortexResult<ArrayRef> {
-    let decimal = narrowed_decimal(decimal.clone());
-    let validity = decimal.validity();
-    let prim = match decimal.values_type() {
-        DecimalType::I8 => PrimitiveArray::new(decimal.buffer::<i8>(), validity.clone()),
-        DecimalType::I16 => PrimitiveArray::new(decimal.buffer::<i16>(), validity.clone()),
-        DecimalType::I32 => PrimitiveArray::new(decimal.buffer::<i32>(), validity.clone()),
-        DecimalType::I64 => PrimitiveArray::new(decimal.buffer::<i64>(), validity.clone()),
-        _ => return Ok(decimal.to_array()),
-    };
-
-    let compressed = compressor.compress_canonical(
-        Canonical::Primitive(prim),
-        CompressorContext::default(),
-        Excludes::none(),
-    )?;
-
-    DecimalBytePartsArray::try_new(compressed, decimal.decimal_dtype()).map(|d| d.to_array())
-}
diff --git a/vortex-btrblocks/src/compressor/float/dictionary.rs b/vortex-btrblocks/src/compressor/float/dictionary.rs
deleted file mode 100644
index 40888b045f9..00000000000
--- a/vortex-btrblocks/src/compressor/float/dictionary.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Float-specific dictionary encoding implementation.
-//!
-//! Vortex encoders must always produce unsigned integer codes; signed codes are only accepted for external compatibility.
-
-use vortex_array::IntoArray;
-use vortex_array::arrays::DictArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::dtype::half::f16;
-use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
-use vortex_buffer::Buffer;
-
-use super::stats::ErasedDistinctValues;
-use super::stats::FloatStats;
-
-macro_rules! typed_encode {
-    ($stats:ident, $typed:ident, $validity:ident, $typ:ty) => {{
-        let values: Buffer<$typ> = $typed.values.iter().map(|x| x.0).collect();
-
-        let max_code = values.len();
-        let codes = if max_code <= u8::MAX as usize {
-            let buf =
-                <DictEncoder as Encode<$typ, u8>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        } else if max_code <= u16::MAX as usize {
-            let buf =
-                <DictEncoder as Encode<$typ, u16>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        } else {
-            let buf =
-                <DictEncoder as Encode<$typ, u32>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        };
-
-        let values_validity = match $validity {
-            Validity::NonNullable => Validity::NonNullable,
-            _ => Validity::AllValid,
-        };
-        let values = PrimitiveArray::new(values, values_validity).into_array();
-
-        // SAFETY: enforced by the DictEncoder
-        unsafe { DictArray::new_unchecked(codes, values).set_all_values_referenced(true) }
-    }};
-}
-
-/// Compresses a floating-point array into a dictionary arrays according to attached stats.
-pub fn dictionary_encode(stats: &FloatStats) -> DictArray {
-    let validity = stats.src.validity();
-    match &stats.distinct_values {
-        ErasedDistinctValues::F16(typed) => typed_encode!(stats, typed, validity, f16),
-        ErasedDistinctValues::F32(typed) => typed_encode!(stats, typed, validity, f32),
-        ErasedDistinctValues::F64(typed) => typed_encode!(stats, typed, validity, f64),
-    }
-}
-
-struct DictEncoder;
-
-trait Encode<T, I> {
-    /// Using the distinct value set, turn the values into a set of codes.
-    fn encode(distinct: &[T], values: &[T]) -> Buffer<I>;
-}
-
-macro_rules! impl_encode {
-    ($typ:ty, $utyp:ty) => { impl_encode!($typ, $utyp, u8, u16, u32); };
-    ($typ:ty, $utyp:ty, $($ityp:ty),+) => {
-        $(
-        impl Encode<$typ, $ityp> for DictEncoder {
-            #[allow(clippy::cast_possible_truncation)]
-            fn encode(distinct: &[$typ], values: &[$typ]) -> Buffer<$ityp> {
-                let mut codes =
-                    vortex_utils::aliases::hash_map::HashMap::<$utyp, $ityp>::with_capacity(
-                        distinct.len(),
-                    );
-                for (code, &value) in distinct.iter().enumerate() {
-                    codes.insert(value.to_bits(), code as $ityp);
-                }
-
-                let mut output = vortex_buffer::BufferMut::with_capacity(values.len());
-                for value in values {
-                    // Any code lookups which fail are for nulls, so their value
-                    // does not matter.
-                    output.push(codes.get(&value.to_bits()).copied().unwrap_or_default());
-                }
-
-                return output.freeze();
-            }
-        }
-        )*
-    };
-}
-
-impl_encode!(f16, u16);
-impl_encode!(f32, u32);
-impl_encode!(f64, u64);
-
-#[cfg(test)]
-mod tests {
-    use vortex_array::Array;
-    use vortex_array::IntoArray;
-    use vortex_array::arrays::BoolArray;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::assert_arrays_eq;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::buffer;
-
-    use super::super::FloatStats;
-    use crate::CompressorStats;
-    use crate::compressor::float::dictionary::dictionary_encode;
-
-    #[test]
-    fn test_float_dict_encode() {
-        // Create an array that has some nulls
-        let values = buffer![1f32, 2f32, 2f32, 0f32, 1f32];
-        let validity =
-            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array());
-        let array = PrimitiveArray::new(values, validity);
-
-        let stats = FloatStats::generate(&array);
-        let dict_array = dictionary_encode(&stats);
-        assert_eq!(dict_array.values().len(), 2);
-        assert_eq!(dict_array.codes().len(), 5);
-
-        let undict = dict_array;
-
-        // We just use code zero but it doesn't really matter.
-        // We can just shove a whole validity buffer in there instead.
-        let expected = PrimitiveArray::new(
-            buffer![1f32, 2f32, 2f32, 1f32, 1f32],
-            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()),
-        )
-        .into_array();
-        assert_arrays_eq!(undict.as_ref(), expected.as_ref());
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/float/mod.rs b/vortex-btrblocks/src/compressor/float/mod.rs
deleted file mode 100644
index 5ee2a203afd..00000000000
--- a/vortex-btrblocks/src/compressor/float/mod.rs
+++ /dev/null
@@ -1,746 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-pub(crate) mod dictionary;
-pub(super) mod stats;
-
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use enum_iterator::Sequence;
-use vortex_alp::ALPArray;
-use vortex_alp::ALPVTable;
-use vortex_alp::RDEncoder;
-use vortex_alp::alp_encode;
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::DictArray;
-use vortex_array::arrays::DictArrayParts;
-use vortex_array::arrays::MaskedArray;
-use vortex_array::arrays::PrimitiveVTable;
-use vortex_array::dtype::PType;
-use vortex_array::scalar::Scalar;
-use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_error::VortexResult;
-use vortex_error::vortex_panic;
-use vortex_sparse::SparseArray;
-use vortex_sparse::SparseVTable;
-
-use self::dictionary::dictionary_encode;
-pub use self::stats::FloatStats;
-use super::integer::DictScheme as IntDictScheme;
-use super::integer::RunEndScheme as IntRunEndScheme;
-use super::integer::SparseScheme as IntSparseScheme;
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::Compressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::Excludes;
-use crate::GenerateStatsOptions;
-use crate::IntCode;
-use crate::Scheme;
-use crate::SchemeExt;
-use crate::compressor::patches::compress_patches;
-use crate::compressor::rle;
-use crate::compressor::rle::RLEScheme;
-
-pub trait FloatScheme: Scheme<StatsType = FloatStats, CodeType = FloatCode> + Send + Sync {}
-
-impl<T> FloatScheme for T where T: Scheme<StatsType = FloatStats, CodeType = FloatCode> + Send + Sync
-{}
-
-impl PartialEq for dyn FloatScheme {
-    fn eq(&self, other: &Self) -> bool {
-        self.code() == other.code()
-    }
-}
-
-impl Eq for dyn FloatScheme {}
-
-impl Hash for dyn FloatScheme {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.code().hash(state)
-    }
-}
-
-/// All available float compression schemes.
-pub const ALL_FLOAT_SCHEMES: &[&dyn FloatScheme] = &[
-    &UncompressedScheme,
-    &ConstantScheme,
-    &ALPScheme,
-    &ALPRDScheme,
-    &DictScheme,
-    &NullDominated,
-    &RLE_FLOAT_SCHEME,
-    #[cfg(feature = "pco")]
-    &PcoScheme,
-];
-
-/// [`Compressor`] for floating-point numbers.
-#[derive(Clone, Copy)]
-pub struct FloatCompressor<'a> {
-    /// Reference to the parent compressor.
-    pub btr_blocks_compressor: &'a dyn CanonicalCompressor,
-}
-
-impl<'a> Compressor for FloatCompressor<'a> {
-    type ArrayVTable = PrimitiveVTable;
-    type SchemeType = dyn FloatScheme;
-    type StatsType = FloatStats;
-
-    fn gen_stats(&self, array: &<Self::ArrayVTable as VTable>::Array) -> Self::StatsType {
-        if self
-            .btr_blocks_compressor
-            .float_schemes()
-            .iter()
-            .any(|s| s.code() == DictScheme.code())
-        {
-            FloatStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: true,
-                },
-            )
-        } else {
-            FloatStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: false,
-                },
-            )
-        }
-    }
-
-    fn schemes(&self) -> &[&'static dyn FloatScheme] {
-        self.btr_blocks_compressor.float_schemes()
-    }
-
-    fn default_scheme(&self) -> &'static Self::SchemeType {
-        &UncompressedScheme
-    }
-}
-
-/// Unique identifier for float compression schemes.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Sequence, Ord, PartialOrd)]
-pub enum FloatCode {
-    /// No compression applied.
-    Uncompressed,
-    /// Constant encoding for arrays with a single distinct value.
-    Constant,
-    /// ALP (Adaptive Lossless floating-Point) encoding.
-    Alp,
-    /// ALPRD (ALP with Right Division) encoding variant.
-    AlpRd,
-    /// Dictionary encoding for low-cardinality float values.
-    Dict,
-    /// Run-end encoding.
-    RunEnd,
-    /// RLE encoding - generic run-length encoding.
-    Rle,
-    /// Sparse encoding for null-dominated arrays.
-    Sparse,
-    /// Pco (pcodec) compression for floats.
-    Pco,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct UncompressedScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct ConstantScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct ALPScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct ALPRDScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct DictScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct NullDominated;
-
-/// Pco (pcodec) compression for floats.
-#[cfg(feature = "pco")]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct PcoScheme;
-
-/// Configuration for float RLE compression.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct FloatRLEConfig;
-
-impl rle::RLEConfig for FloatRLEConfig {
-    type Stats = FloatStats;
-    type Code = FloatCode;
-
-    const CODE: FloatCode = FloatCode::Rle;
-
-    fn compress_values(
-        compressor: &BtrBlocksCompressor,
-        values: &vortex_array::arrays::PrimitiveArray,
-        ctx: CompressorContext,
-        excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        compressor.compress_canonical(Canonical::Primitive(values.clone()), ctx, excludes.into())
-    }
-}
-
-/// RLE scheme for float compression.
-pub const RLE_FLOAT_SCHEME: RLEScheme<FloatRLEConfig> = RLEScheme::new();
-
-impl Scheme for UncompressedScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::Uncompressed
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        _stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<f64> {
-        Ok(1.0)
-    }
-
-    fn compress(
-        &self,
-        _btr_blocks_compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(stats.source().to_array())
-    }
-}
-
-impl Scheme for ConstantScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::Constant
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _btr_blocks_compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<f64> {
-        // Never select Constant when sampling
-        if ctx.is_sample {
-            return Ok(0.0);
-        }
-
-        if stats.null_count as usize == stats.src.len() || stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        // Can only have 1 distinct value
-        if stats.distinct_values_count != 1 {
-            return Ok(0.0);
-        }
-
-        Ok(stats.value_count as f64)
-    }
-
-    fn compress(
-        &self,
-        _btr_blocks_compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        let scalar_idx =
-            (0..stats.source().len()).position(|idx| stats.source().is_valid(idx).unwrap_or(false));
-
-        match scalar_idx {
-            Some(idx) => {
-                let scalar = stats.source().scalar_at(idx)?;
-                let const_arr = ConstantArray::new(scalar, stats.src.len()).into_array();
-                if !stats.source().all_valid()? {
-                    Ok(MaskedArray::try_new(const_arr, stats.src.validity().clone())?.into_array())
-                } else {
-                    Ok(const_arr)
-                }
-            }
-            None => Ok(ConstantArray::new(
-                Scalar::null(stats.src.dtype().clone()),
-                stats.src.len(),
-            )
-            .into_array()),
-        }
-    }
-}
-
-impl Scheme for ALPScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::Alp
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[FloatCode],
-    ) -> VortexResult<f64> {
-        // We don't support ALP for f16
-        if stats.source().ptype() == PType::F16 {
-            return Ok(0.0);
-        }
-
-        if ctx.allowed_cascading == 0 {
-            // ALP does not compress on its own, we need to be able to cascade it with
-            // an integer compressor.
-            return Ok(0.0);
-        }
-
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &FloatStats,
-        ctx: CompressorContext,
-        excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        let alp_encoded = alp_encode(&stats.source().to_primitive(), None)?;
-        let alp = alp_encoded.as_::<ALPVTable>();
-        let alp_ints = alp.encoded().to_primitive();
-
-        // Compress the ALP ints.
-        // Patches are not compressed. They should be infrequent, and if they are not then we want
-        // to keep them linear for easy indexing.
-        let mut int_excludes = Vec::new();
-        if excludes.contains(&FloatCode::Dict) {
-            int_excludes.push(IntDictScheme.code());
-        }
-        if excludes.contains(&FloatCode::RunEnd) {
-            int_excludes.push(IntRunEndScheme.code());
-        }
-
-        let compressed_alp_ints = compressor.compress_canonical(
-            Canonical::Primitive(alp_ints),
-            ctx.descend(),
-            Excludes::int_only(&int_excludes),
-        )?;
-
-        let patches = alp.patches().map(compress_patches).transpose()?;
-
-        Ok(ALPArray::new(compressed_alp_ints, alp.exponents(), patches).into_array())
-    }
-}
-
-impl Scheme for ALPRDScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::AlpRd
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[FloatCode],
-    ) -> VortexResult<f64> {
-        if stats.source().ptype() == PType::F16 {
-            return Ok(0.0);
-        }
-
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        let encoder = match stats.source().ptype() {
-            PType::F32 => RDEncoder::new(stats.source().as_slice::<f32>()),
-            PType::F64 => RDEncoder::new(stats.source().as_slice::<f64>()),
-            ptype => vortex_panic!("cannot ALPRD compress ptype {ptype}"),
-        };
-
-        let mut alp_rd = encoder.encode(stats.source());
-
-        let patches = alp_rd
-            .left_parts_patches()
-            .map(compress_patches)
-            .transpose()?;
-        alp_rd.replace_left_parts_patches(patches);
-
-        Ok(alp_rd.into_array())
-    }
-}
-
-impl Scheme for DictScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::Dict
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[FloatCode],
-    ) -> VortexResult<f64> {
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        // If the array is high cardinality (>50% unique values) skip.
-        if stats.distinct_values_count > stats.value_count / 2 {
-            return Ok(0.0);
-        }
-
-        // Take a sample and run compression on the sample to determine before/after size.
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        let dict = dictionary_encode(stats);
-        let has_all_values_referenced = dict.has_all_values_referenced();
-        let DictArrayParts { codes, values, .. } = dict.into_parts();
-
-        let compressed_codes = compressor.compress_canonical(
-            Canonical::Primitive(codes.to_primitive()),
-            ctx.descend(),
-            Excludes::int_only(&[IntCode::Dict, IntCode::Sequence]),
-        )?;
-
-        assert!(values.is_canonical());
-        let compressed_values = compressor.compress_canonical(
-            Canonical::Primitive(values.to_primitive()),
-            ctx.descend(),
-            Excludes::from(&[FloatCode::Dict]),
-        )?;
-
-        // SAFETY: compressing codes or values does not alter the invariants
-        unsafe {
-            Ok(
-                DictArray::new_unchecked(compressed_codes, compressed_values)
-                    .set_all_values_referenced(has_all_values_referenced)
-                    .into_array(),
-            )
-        }
-    }
-}
-
-impl Scheme for NullDominated {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> Self::CodeType {
-        FloatCode::Sparse
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        // Only use `SparseScheme` if we can cascade.
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        if stats.value_count == 0 {
-            // All nulls should use ConstantScheme
-            return Ok(0.0);
-        }
-
-        // If the majority is null, will compress well.
-        if stats.null_count as f64 / stats.src.len() as f64 > 0.9 {
-            return Ok(stats.src.len() as f64 / stats.value_count as f64);
-        }
-
-        // Otherwise we don't go this route
-        Ok(0.0)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        assert!(ctx.allowed_cascading > 0);
-
-        // We pass None as we only run this pathway for NULL-dominated float arrays
-        let sparse_encoded = SparseArray::encode(stats.src.as_ref(), None)?;
-
-        if let Some(sparse) = sparse_encoded.as_opt::<SparseVTable>() {
-            // Compress the values
-            let new_excludes = [IntSparseScheme.code()];
-
-            // Don't attempt to compress the non-null values
-
-            let indices = sparse.patches().indices().to_primitive().narrow()?;
-            let compressed_indices = compressor.compress_canonical(
-                Canonical::Primitive(indices.to_primitive()),
-                ctx.descend(),
-                Excludes::int_only(&new_excludes),
-            )?;
-
-            SparseArray::try_new(
-                compressed_indices,
-                sparse.patches().values().clone(),
-                sparse.len(),
-                sparse.fill_scalar().clone(),
-            )
-            .map(|a| a.into_array())
-        } else {
-            Ok(sparse_encoded)
-        }
-    }
-}
-
-#[cfg(feature = "pco")]
-impl Scheme for PcoScheme {
-    type StatsType = FloatStats;
-    type CodeType = FloatCode;
-
-    fn code(&self) -> FloatCode {
-        FloatCode::Pco
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[FloatCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(vortex_pco::PcoArray::from_primitive(
-            stats.source(),
-            pco::DEFAULT_COMPRESSION_LEVEL,
-            8192,
-        )?
-        .into_array())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use std::iter;
-
-    use vortex_array::Array;
-    use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::assert_arrays_eq;
-    use vortex_array::builders::ArrayBuilder;
-    use vortex_array::builders::PrimitiveBuilder;
-    use vortex_array::display::DisplayOptions;
-    use vortex_array::dtype::Nullability;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
-    use vortex_buffer::buffer_mut;
-    use vortex_error::VortexResult;
-
-    use super::RLE_FLOAT_SCHEME;
-    use crate::BtrBlocksCompressor;
-    use crate::CompressorContext;
-    use crate::CompressorExt;
-    use crate::CompressorStats;
-    use crate::Scheme;
-
-    #[test]
-    fn test_empty() -> VortexResult<()> {
-        // Make sure empty array compression does not fail
-        let btr = BtrBlocksCompressor::default();
-        let result = btr.float_compressor().compress(
-            &btr,
-            &PrimitiveArray::new(Buffer::<f32>::empty(), Validity::NonNullable),
-            CompressorContext::default(),
-            &[],
-        )?;
-
-        assert!(result.is_empty());
-        Ok(())
-    }
-
-    #[test]
-    fn test_compress() -> VortexResult<()> {
-        let mut values = buffer_mut![1.0f32; 1024];
-        // Sprinkle some other values in.
-        for i in 0..1024 {
-            // Insert 2.0 at all odd positions.
-            // This should force dictionary encoding and exclude run-end due to the
-            // average run length being 1.
-            values[i] = (i % 50) as f32;
-        }
-
-        let floats = values.into_array().to_primitive();
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &floats, CompressorContext::default(), &[])?;
-        assert_eq!(compressed.len(), 1024);
-
-        let display = compressed
-            .display_as(DisplayOptions::MetadataOnly)
-            .to_string()
-            .to_lowercase();
-        assert_eq!(display, "vortex.dict(f32, len=1024)");
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_rle_compression() -> VortexResult<()> {
-        let mut values = Vec::new();
-        values.extend(iter::repeat_n(1.5f32, 100));
-        values.extend(iter::repeat_n(2.7f32, 200));
-        values.extend(iter::repeat_n(3.15f32, 150));
-
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let stats = super::FloatStats::generate(&array);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            RLE_FLOAT_SCHEME.compress(&btr, &stats, CompressorContext::default(), &[])?;
-
-        let decoded = compressed;
-        let expected = Buffer::copy_from(&values).into_array();
-        assert_arrays_eq!(decoded.as_ref(), expected.as_ref());
-        Ok(())
-    }
-
-    #[test]
-    fn test_sparse_compression() -> VortexResult<()> {
-        let mut array = PrimitiveBuilder::<f32>::with_capacity(Nullability::Nullable, 100);
-        array.append_value(f32::NAN);
-        array.append_value(-f32::NAN);
-        array.append_value(f32::INFINITY);
-        array.append_value(-f32::INFINITY);
-        array.append_value(0.0f32);
-        array.append_value(-0.0f32);
-        array.append_nulls(90);
-
-        let floats = array.finish_into_primitive();
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &floats, CompressorContext::default(), &[])?;
-        assert_eq!(compressed.len(), 96);
-
-        let display = compressed
-            .display_as(DisplayOptions::MetadataOnly)
-            .to_string()
-            .to_lowercase();
-        assert_eq!(display, "vortex.sparse(f32?, len=96)");
-
-        Ok(())
-    }
-}
-
-/// Tests to verify that each float compression scheme produces the expected encoding.
-#[cfg(test)]
-mod scheme_selection_tests {
-
-    use vortex_alp::ALPVTable;
-    use vortex_array::arrays::ConstantVTable;
-    use vortex_array::arrays::DictVTable;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::builders::ArrayBuilder;
-    use vortex_array::builders::PrimitiveBuilder;
-    use vortex_array::dtype::Nullability;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
-    use vortex_error::VortexResult;
-
-    use crate::BtrBlocksCompressor;
-    use crate::CompressorContext;
-    use crate::CompressorExt;
-
-    #[test]
-    fn test_constant_compressed() -> VortexResult<()> {
-        let values: Vec<f64> = vec![42.5; 100];
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<ConstantVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_alp_compressed() -> VortexResult<()> {
-        let values: Vec<f64> = (0..1000).map(|i| (i as f64) * 0.01).collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<ALPVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_dict_compressed() -> VortexResult<()> {
-        let distinct_values = [1.1, 2.2, 3.3, 4.4, 5.5];
-        let values: Vec<f64> = (0..1000)
-            .map(|i| distinct_values[i % distinct_values.len()])
-            .collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<DictVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_null_dominated_compressed() -> VortexResult<()> {
-        let mut builder = PrimitiveBuilder::<f64>::with_capacity(Nullability::Nullable, 100);
-        for i in 0..5 {
-            builder.append_value(i as f64);
-        }
-        builder.append_nulls(95);
-        let array = builder.finish_into_primitive();
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.float_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        // Verify the compressed array preserves values.
-        assert_eq!(compressed.len(), 100);
-        Ok(())
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/integer/dictionary.rs b/vortex-btrblocks/src/compressor/integer/dictionary.rs
deleted file mode 100644
index 9cf2ac7fe3a..00000000000
--- a/vortex-btrblocks/src/compressor/integer/dictionary.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Dictionary compressor that reuses the unique values in the `IntegerStats`.
-//!
-//! Vortex encoders must always produce unsigned integer codes; signed codes are only accepted for external compatibility.
-
-use vortex_array::IntoArray;
-use vortex_array::arrays::DictArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::validity::Validity;
-use vortex_array::vtable::ValidityHelper;
-use vortex_buffer::Buffer;
-
-use super::IntegerStats;
-use super::stats::ErasedStats;
-
-macro_rules! typed_encode {
-    ($stats:ident, $typed:ident, $validity:ident, $typ:ty) => {{
-        let values: Buffer<$typ> = $typed.distinct_values.keys().map(|x| x.0).collect();
-
-        let max_code = values.len();
-        let codes = if max_code <= u8::MAX as usize {
-            let buf =
-                <DictEncoder as Encode<$typ, u8>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        } else if max_code <= u16::MAX as usize {
-            let buf =
-                <DictEncoder as Encode<$typ, u16>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        } else {
-            let buf =
-                <DictEncoder as Encode<$typ, u32>>::encode(&values, $stats.src.as_slice::<$typ>());
-            PrimitiveArray::new(buf, $validity.clone()).into_array()
-        };
-
-        let values_validity = match $validity {
-            Validity::NonNullable => Validity::NonNullable,
-            _ => Validity::AllValid,
-        };
-
-        let values = PrimitiveArray::new(values, values_validity).into_array();
-        // SAFETY: invariants enforced in DictEncoder
-        unsafe { DictArray::new_unchecked(codes, values).set_all_values_referenced(true) }
-    }};
-}
-
-/// Compresses an integer array into a dictionary arrays according to attached stats.
-#[expect(
-    clippy::cognitive_complexity,
-    reason = "complexity from match on all integer types"
-)]
-pub fn dictionary_encode(stats: &IntegerStats) -> DictArray {
-    // We need to preserve the nullability somehow from the original
-    let src_validity = stats.src.validity();
-
-    match &stats.typed {
-        ErasedStats::U8(typed) => typed_encode!(stats, typed, src_validity, u8),
-        ErasedStats::U16(typed) => typed_encode!(stats, typed, src_validity, u16),
-        ErasedStats::U32(typed) => typed_encode!(stats, typed, src_validity, u32),
-        ErasedStats::U64(typed) => typed_encode!(stats, typed, src_validity, u64),
-        ErasedStats::I8(typed) => typed_encode!(stats, typed, src_validity, i8),
-        ErasedStats::I16(typed) => typed_encode!(stats, typed, src_validity, i16),
-        ErasedStats::I32(typed) => typed_encode!(stats, typed, src_validity, i32),
-        ErasedStats::I64(typed) => typed_encode!(stats, typed, src_validity, i64),
-    }
-}
-
-struct DictEncoder;
-
-trait Encode<T, I> {
-    /// Using the distinct value set, turn the values into a set of codes.
-    fn encode(distinct: &[T], values: &[T]) -> Buffer<I>;
-}
-
-macro_rules! impl_encode {
-    ($typ:ty) => { impl_encode!($typ, u8, u16, u32); };
-    ($typ:ty, $($ityp:ty),+) => {
-        $(
-        impl Encode<$typ, $ityp> for DictEncoder {
-            #[allow(clippy::cast_possible_truncation)]
-            fn encode(distinct: &[$typ], values: &[$typ]) -> Buffer<$ityp> {
-                let mut codes =
-                    vortex_utils::aliases::hash_map::HashMap::<$typ, $ityp>::with_capacity(
-                        distinct.len(),
-                    );
-                for (code, &value) in distinct.iter().enumerate() {
-                    codes.insert(value, code as $ityp);
-                }
-
-                let mut output = vortex_buffer::BufferMut::with_capacity(values.len());
-                for value in values {
-                    // Any code lookups which fail are for nulls, so their value
-                    // does not matter.
-                    // SAFETY: we have exactly sized output to be as large as values.
-                    unsafe { output.push_unchecked(codes.get(value).copied().unwrap_or_default()) };
-                }
-
-                return output.freeze();
-            }
-        }
-        )*
-    };
-}
-
-impl_encode!(u8);
-impl_encode!(u16);
-impl_encode!(u32);
-impl_encode!(u64);
-impl_encode!(i8);
-impl_encode!(i16);
-impl_encode!(i32);
-impl_encode!(i64);
-
-#[cfg(test)]
-mod tests {
-    use vortex_array::Array;
-    use vortex_array::IntoArray;
-    use vortex_array::arrays::BoolArray;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::assert_arrays_eq;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::buffer;
-
-    use super::IntegerStats;
-    use super::dictionary_encode;
-    use crate::CompressorStats;
-
-    #[test]
-    fn test_dict_encode_integer_stats() {
-        // Create an array that has some nulls
-        let data = buffer![100i32, 200, 100, 0, 100];
-        let validity =
-            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array());
-        let array = PrimitiveArray::new(data, validity);
-
-        let stats = IntegerStats::generate(&array);
-        let dict_array = dictionary_encode(&stats);
-        assert_eq!(dict_array.values().len(), 2);
-        assert_eq!(dict_array.codes().len(), 5);
-
-        let undict = dict_array;
-
-        // We just use code zero, but it doesn't really matter.
-        // We can just shove a whole validity buffer in there instead.
-        let expected = PrimitiveArray::new(
-            buffer![100i32, 200, 100, 100, 100],
-            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()),
-        )
-        .into_array();
-        assert_arrays_eq!(undict.as_ref(), expected.as_ref());
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/integer/mod.rs b/vortex-btrblocks/src/compressor/integer/mod.rs
deleted file mode 100644
index dbfb76c22bd..00000000000
--- a/vortex-btrblocks/src/compressor/integer/mod.rs
+++ /dev/null
@@ -1,1220 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-pub(crate) mod dictionary;
-pub(super) mod stats;
-
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use enum_iterator::Sequence;
-pub use stats::IntegerStats;
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::DictArray;
-use vortex_array::arrays::MaskedArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::PrimitiveVTable;
-use vortex_array::scalar::Scalar;
-use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-use vortex_fastlanes::FoRArray;
-use vortex_fastlanes::bitpack_compress::bit_width_histogram;
-use vortex_fastlanes::bitpack_compress::bitpack_encode;
-use vortex_fastlanes::bitpack_compress::find_best_bit_width;
-use vortex_runend::RunEndArray;
-use vortex_runend::compress::runend_encode;
-use vortex_sequence::sequence_encode;
-use vortex_sparse::SparseArray;
-use vortex_sparse::SparseVTable;
-use vortex_zigzag::ZigZagArray;
-use vortex_zigzag::zigzag_encode;
-
-use self::dictionary::dictionary_encode;
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::Compressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::Excludes;
-use crate::GenerateStatsOptions;
-use crate::Scheme;
-use crate::SchemeExt;
-use crate::compressor::patches::compress_patches;
-use crate::compressor::rle;
-use crate::compressor::rle::RLEScheme;
-
-/// All available integer compression schemes.
-pub const ALL_INT_SCHEMES: &[&dyn IntegerScheme] = &[
-    &ConstantScheme,
-    &FORScheme,
-    &ZigZagScheme,
-    &BitPackingScheme,
-    &SparseScheme,
-    &DictScheme,
-    &RunEndScheme,
-    &SequenceScheme,
-    &RLE_INTEGER_SCHEME,
-    #[cfg(feature = "pco")]
-    &PcoScheme,
-];
-
-/// [`Compressor`] for signed and unsigned integers.
-#[derive(Clone, Copy)]
-pub struct IntCompressor<'a> {
-    /// Reference to the parent compressor.
-    pub btr_blocks_compressor: &'a dyn CanonicalCompressor,
-}
-
-impl<'a> Compressor for IntCompressor<'a> {
-    type ArrayVTable = PrimitiveVTable;
-    type SchemeType = dyn IntegerScheme;
-    type StatsType = IntegerStats;
-
-    fn schemes(&self) -> &[&'static dyn IntegerScheme] {
-        self.btr_blocks_compressor.int_schemes()
-    }
-
-    fn default_scheme(&self) -> &'static Self::SchemeType {
-        &UncompressedScheme
-    }
-
-    fn gen_stats(&self, array: &<Self::ArrayVTable as VTable>::Array) -> Self::StatsType {
-        if self
-            .btr_blocks_compressor
-            .int_schemes()
-            .iter()
-            .any(|s| s.code() == IntCode::Dict)
-        {
-            IntegerStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: true,
-                },
-            )
-        } else {
-            IntegerStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: false,
-                },
-            )
-        }
-    }
-}
-
-pub trait IntegerScheme:
-    Scheme<StatsType = IntegerStats, CodeType = IntCode> + Send + Sync
-{
-}
-
-// Auto-impl
-impl<T> IntegerScheme for T where
-    T: Scheme<StatsType = IntegerStats, CodeType = IntCode> + Send + Sync
-{
-}
-
-impl PartialEq for dyn IntegerScheme {
-    fn eq(&self, other: &Self) -> bool {
-        self.code() == other.code()
-    }
-}
-
-impl Eq for dyn IntegerScheme {}
-
-impl Hash for dyn IntegerScheme {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.code().hash(state)
-    }
-}
-
-/// Unique identifier for integer compression schemes.
-///
-/// NOTE: Variant order matters for tie-breaking; `For` must precede `BitPacking` to avoid unnecessary patches.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Sequence, Ord, PartialOrd)]
-pub enum IntCode {
-    /// No compression applied.
-    Uncompressed,
-    /// Constant encoding for arrays with a single distinct value.
-    Constant,
-    /// Frame of Reference encoding - subtracts minimum value then bitpacks.
-    For,
-    /// BitPacking encoding - compresses non-negative integers by reducing bit width.
-    BitPacking,
-    /// ZigZag encoding - transforms negative integers to positive for better bitpacking.
-    ZigZag,
-    /// Sparse encoding - optimizes null-dominated or single-value-dominated arrays.
-    Sparse,
-    /// Dictionary encoding - creates a dictionary of unique values.
-    Dict,
-    /// Run-end encoding - run-length encoding with end positions.
-    RunEnd,
-    /// Sequence encoding - detects sequential patterns.
-    Sequence,
-    /// RLE encoding - generic run-length encoding.
-    Rle,
-    /// Pco (pcodec) compression for integers.
-    Pco,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-
-pub struct UncompressedScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-
-pub struct ConstantScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-
-pub struct FORScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct ZigZagScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct BitPackingScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct SparseScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct DictScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct RunEndScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct SequenceScheme;
-
-/// Pco (pcodec) compression for integers.
-#[cfg(feature = "pco")]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct PcoScheme;
-
-/// Threshold for the average run length in an array before we consider run-end encoding.
-const RUN_END_THRESHOLD: u32 = 4;
-
-/// Configuration for integer RLE compression.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct IntRLEConfig;
-
-impl rle::RLEConfig for IntRLEConfig {
-    type Stats = IntegerStats;
-    type Code = IntCode;
-
-    const CODE: IntCode = IntCode::Rle;
-
-    fn compress_values(
-        compressor: &BtrBlocksCompressor,
-        values: &PrimitiveArray,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        compressor.compress_canonical(Canonical::Primitive(values.clone()), ctx, excludes.into())
-    }
-}
-
-/// RLE scheme for integer compression.
-pub const RLE_INTEGER_SCHEME: RLEScheme<IntRLEConfig> = RLEScheme::new();
-
-impl Scheme for UncompressedScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::Uncompressed
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        _stats: &IntegerStats,
-        _ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // no compression
-        Ok(1.0)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        _ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(stats.source().to_array())
-    }
-}
-
-impl Scheme for ConstantScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::Constant
-    }
-
-    fn is_constant(&self) -> bool {
-        true
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // Never yield ConstantScheme for a sample, it could be a false-positive.
-        if ctx.is_sample {
-            return Ok(0.0);
-        }
-
-        // Only arrays with one distinct values can be constant compressed.
-        if stats.distinct_values_count > 1 {
-            return Ok(0.0);
-        }
-
-        Ok(stats.value_count as f64)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        _ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        let scalar_idx =
-            (0..stats.source().len()).position(|idx| stats.source().is_valid(idx).unwrap_or(false));
-
-        match scalar_idx {
-            Some(idx) => {
-                let scalar = stats.source().scalar_at(idx)?;
-                let const_arr = ConstantArray::new(scalar, stats.src.len()).into_array();
-                if !stats.source().all_valid()? {
-                    Ok(MaskedArray::try_new(const_arr, stats.src.validity().clone())?.into_array())
-                } else {
-                    Ok(const_arr)
-                }
-            }
-            None => Ok(ConstantArray::new(
-                Scalar::null(stats.src.dtype().clone()),
-                stats.src.len(),
-            )
-            .into_array()),
-        }
-    }
-}
-
-impl Scheme for FORScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::For
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // Only apply if we are not at the leaf
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        // All-null cannot be FOR compressed.
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        // Only apply when the min is not already zero.
-        if stats.typed.min_is_zero() {
-            return Ok(0.0);
-        }
-
-        // Difference between max and min
-        let full_width: u32 = stats
-            .src
-            .ptype()
-            .bit_width()
-            .try_into()
-            .vortex_expect("bit width must fit in u32");
-        let for_bw = match stats.typed.max_minus_min().checked_ilog2() {
-            Some(l) => l + 1,
-            // If max-min == 0, it we should use a different compression scheme
-            // as we don't want to bitpack down to 0 bits.
-            None => return Ok(0.0),
-        };
-
-        // If BitPacking could apply (non-negative values) and FOR doesn't reduce bit width
-        // compared to BitPacking, don't use FOR since it has overhead (storing reference).
-        // Only skip FOR when min >= 0, otherwise BitPacking can't apply directly.
-        if let Some(max_log) = stats
-            .typed
-            .max_ilog2()
-            .filter(|_| !stats.typed.min_is_negative())
-        {
-            let bitpack_bw = max_log + 1;
-            if for_bw >= bitpack_bw {
-                return Ok(0.0);
-            }
-        }
-
-        Ok(full_width as f64 / for_bw as f64)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        let for_array = FoRArray::encode(stats.src.clone())?;
-        let biased = for_array.encoded().to_primitive();
-        let biased_stats = IntegerStats::generate_opts(
-            &biased,
-            GenerateStatsOptions {
-                count_distinct_values: false,
-            },
-        );
-
-        // Immediately bitpack. If any other scheme was preferable, it would be chosen instead
-        // of bitpacking.
-        // NOTE: we could delegate in the future if we had another downstream codec that performs
-        //  as well.
-        let leaf_ctx = CompressorContext {
-            is_sample: ctx.is_sample,
-            allowed_cascading: 0,
-        };
-        let compressed =
-            BitPackingScheme.compress(compressor, &biased_stats, leaf_ctx, excludes)?;
-
-        let for_compressed = FoRArray::try_new(compressed, for_array.reference_scalar().clone())?;
-        for_compressed
-            .as_ref()
-            .statistics()
-            .inherit_from(for_array.as_ref().statistics());
-        Ok(for_compressed.into_array())
-    }
-}
-
-impl Scheme for ZigZagScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::ZigZag
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // ZigZag is only useful when we cascade it with another encoding
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        // Don't try and compress all-null arrays
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        // ZigZag is only useful when there are negative values.
-        if !stats.typed.min_is_negative() {
-            return Ok(0.0);
-        }
-
-        // Run compression on a sample to see how it performs.
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        // Zigzag encode the values, then recursively compress the inner values.
-        let zag = zigzag_encode(stats.src.clone())?;
-        let encoded = zag.encoded().to_primitive();
-
-        // ZigZag should be after Dict, RunEnd or Sparse.
-        // We should only do these "container" style compressors once.
-        let mut new_excludes = vec![
-            ZigZagScheme.code(),
-            DictScheme.code(),
-            RunEndScheme.code(),
-            SparseScheme.code(),
-        ];
-        new_excludes.extend_from_slice(excludes);
-
-        let compressed = compressor.compress_canonical(
-            Canonical::Primitive(encoded),
-            ctx.descend(),
-            Excludes::int_only(&new_excludes),
-        )?;
-
-        tracing::debug!("zigzag output: {}", compressed.encoding_id());
-
-        Ok(ZigZagArray::try_new(compressed)?.into_array())
-    }
-}
-
-impl Scheme for BitPackingScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::BitPacking
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // BitPacking only works for non-negative values
-        if stats.typed.min_is_negative() {
-            return Ok(0.0);
-        }
-
-        // Don't compress all-null arrays
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        _ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        let histogram = bit_width_histogram(stats.source())?;
-        let bw = find_best_bit_width(stats.source().ptype(), &histogram)?;
-        // If best bw is determined to be the current bit-width, return the original array.
-        if bw as usize == stats.source().ptype().bit_width() {
-            return Ok(stats.source().clone().into_array());
-        }
-        let mut packed = bitpack_encode(stats.source(), bw, Some(&histogram))?;
-
-        let patches = packed.patches().map(compress_patches).transpose()?;
-        packed.replace_patches(patches);
-
-        Ok(packed.into_array())
-    }
-}
-
-impl Scheme for SparseScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::Sparse
-    }
-
-    // We can avoid asserting the encoding tree instead.
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // Only use `SparseScheme` if we can cascade.
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        if stats.value_count == 0 {
-            // All nulls should use ConstantScheme
-            return Ok(0.0);
-        }
-
-        // If the majority is null, will compress well.
-        if stats.null_count as f64 / stats.src.len() as f64 > 0.9 {
-            return Ok(stats.src.len() as f64 / stats.value_count as f64);
-        }
-
-        // See if the top value accounts for >= 90% of the set values.
-        let (_, top_count) = stats.typed.top_value_and_count();
-
-        if top_count == stats.value_count {
-            // top_value is the only value, should use ConstantScheme instead
-            return Ok(0.0);
-        }
-
-        let freq = top_count as f64 / stats.value_count as f64;
-        if freq >= 0.9 {
-            // We only store the positions of the non-top values.
-            return Ok(stats.value_count as f64 / (stats.value_count - top_count) as f64);
-        }
-
-        Ok(0.0)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        assert!(ctx.allowed_cascading > 0);
-        let (top_pvalue, top_count) = stats.typed.top_value_and_count();
-        if top_count as usize == stats.src.len() {
-            // top_value is the only value, use ConstantScheme
-            return Ok(ConstantArray::new(
-                Scalar::primitive_value(
-                    top_pvalue,
-                    top_pvalue.ptype(),
-                    stats.src.dtype().nullability(),
-                ),
-                stats.src.len(),
-            )
-            .into_array());
-        }
-
-        let sparse_encoded = SparseArray::encode(
-            stats.src.as_ref(),
-            Some(Scalar::primitive_value(
-                top_pvalue,
-                top_pvalue.ptype(),
-                stats.src.dtype().nullability(),
-            )),
-        )?;
-
-        if let Some(sparse) = sparse_encoded.as_opt::<SparseVTable>() {
-            // Compress the values
-            let mut new_excludes = vec![SparseScheme.code(), IntCode::Dict];
-            new_excludes.extend_from_slice(excludes);
-
-            let compressed_values = compressor.compress_canonical(
-                Canonical::Primitive(sparse.patches().values().to_primitive()),
-                ctx.descend(),
-                Excludes::int_only(&new_excludes),
-            )?;
-
-            let indices = sparse.patches().indices().to_primitive().narrow()?;
-
-            let compressed_indices = compressor.compress_canonical(
-                Canonical::Primitive(indices),
-                ctx.descend(),
-                Excludes::int_only(&new_excludes),
-            )?;
-
-            SparseArray::try_new(
-                compressed_indices,
-                compressed_values,
-                sparse.len(),
-                sparse.fill_scalar().clone(),
-            )
-            .map(|a| a.into_array())
-        } else {
-            Ok(sparse_encoded)
-        }
-    }
-}
-
-impl Scheme for DictScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::Dict
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // Dict should not be terminal.
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        // If > 50% of the values are distinct, skip dict.
-        if stats.distinct_values_count > stats.value_count / 2 {
-            return Ok(0.0);
-        }
-
-        // Ignore nulls encoding for the estimate. We only focus on values.
-        let values_size = stats.source().ptype().bit_width() * stats.distinct_values_count as usize;
-
-        // Assume codes are compressed RLE + BitPacking.
-        let codes_bw = usize::BITS - stats.distinct_values_count.leading_zeros();
-
-        let n_runs = (stats.value_count / stats.average_run_length) as usize;
-
-        // Assume that codes will either be BitPack or RLE-BitPack
-        let codes_size_bp = (codes_bw * stats.value_count) as usize;
-        let codes_size_rle_bp = usize::checked_mul((codes_bw + 32) as usize, n_runs);
-
-        let codes_size = usize::min(codes_size_bp, codes_size_rle_bp.unwrap_or(usize::MAX));
-
-        let before = stats.value_count as usize * stats.source().ptype().bit_width();
-
-        Ok(before as f64 / (values_size + codes_size) as f64)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        assert!(ctx.allowed_cascading > 0);
-
-        // TODO(aduffy): we can be more prescriptive: we know that codes will EITHER be
-        //    RLE or FOR + BP. Cascading probably wastes some time here.
-
-        let dict = dictionary_encode(stats);
-
-        // Cascade the codes child
-        // Don't allow SequenceArray as the codes child as it merely adds extra indirection without actually compressing data.
-        let mut new_excludes = vec![IntCode::Dict, IntCode::Sequence];
-        new_excludes.extend_from_slice(excludes);
-
-        let compressed_codes = compressor.compress_canonical(
-            Canonical::Primitive(dict.codes().to_primitive().narrow()?),
-            ctx.descend(),
-            Excludes::int_only(&new_excludes),
-        )?;
-
-        // SAFETY: compressing codes does not change their values
-        unsafe {
-            Ok(
-                DictArray::new_unchecked(compressed_codes, dict.values().clone())
-                    .set_all_values_referenced(dict.has_all_values_referenced())
-                    .into_array(),
-            )
-        }
-    }
-}
-
-impl Scheme for RunEndScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::RunEnd
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // If the run length is below the threshold, drop it.
-        if stats.average_run_length < RUN_END_THRESHOLD {
-            return Ok(0.0);
-        }
-
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        // Run compression on a sample, see how it performs.
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &IntegerStats,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        assert!(ctx.allowed_cascading > 0);
-
-        // run-end encode the ends
-        let (ends, values) = runend_encode(&stats.src);
-
-        let mut new_excludes = vec![RunEndScheme.code(), DictScheme.code()];
-        new_excludes.extend_from_slice(excludes);
-
-        let compressed_ends = compressor.compress_canonical(
-            Canonical::Primitive(ends.to_primitive()),
-            ctx.descend(),
-            Excludes::int_only(&new_excludes),
-        )?;
-
-        let compressed_values = compressor.compress_canonical(
-            Canonical::Primitive(values.to_primitive()),
-            ctx.descend(),
-            Excludes::int_only(&new_excludes),
-        )?;
-
-        // SAFETY: compression doesn't affect invariants
-        unsafe {
-            Ok(
-                RunEndArray::new_unchecked(compressed_ends, compressed_values, 0, stats.src.len())
-                    .into_array(),
-            )
-        }
-    }
-}
-
-impl Scheme for SequenceScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> Self::CodeType {
-        IntCode::Sequence
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        if stats.null_count > 0 {
-            return Ok(0.0);
-        }
-
-        // If the distinct_values_count was computed (!= u32::MAX)
-        // Then all values in a sequence must be unique.
-        if stats.distinct_values_count != u32::MAX
-            && stats.distinct_values_count as usize != stats.src.len()
-        {
-            return Ok(0.0);
-        }
-
-        // Since two values are required to store base and multiplier the
-        // compression ratio is divided by 2.
-        Ok(sequence_encode(&stats.src)?
-            .map(|_| stats.src.len() as f64 / 2.0)
-            .unwrap_or(0.0))
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        if stats.null_count > 0 {
-            vortex_bail!("sequence encoding does not support nulls");
-        }
-        sequence_encode(&stats.src)?.ok_or_else(|| vortex_err!("cannot sequence encode array"))
-    }
-}
-
-#[cfg(feature = "pco")]
-impl Scheme for PcoScheme {
-    type StatsType = IntegerStats;
-    type CodeType = IntCode;
-
-    fn code(&self) -> IntCode {
-        IntCode::Pco
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[IntCode],
-    ) -> VortexResult<f64> {
-        // Pco does not support I8 or U8.
-        if matches!(
-            stats.src.ptype(),
-            vortex_array::dtype::PType::I8 | vortex_array::dtype::PType::U8
-        ) {
-            return Ok(0.0);
-        }
-
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[IntCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(vortex_pco::PcoArray::from_primitive(
-            stats.source(),
-            pco::DEFAULT_COMPRESSION_LEVEL,
-            8192,
-        )?
-        .into_array())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::iter;
-
-    use itertools::Itertools;
-    use rand::RngCore;
-    use rand::SeedableRng;
-    use rand::rngs::StdRng;
-    use vortex_array::Array;
-    use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
-    use vortex_array::arrays::DictVTable;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::assert_arrays_eq;
-    use vortex_array::validity::Validity;
-    use vortex_array::vtable::ValidityHelper;
-    use vortex_buffer::Buffer;
-    use vortex_buffer::BufferMut;
-    use vortex_buffer::buffer;
-    use vortex_error::VortexResult;
-    use vortex_sequence::SequenceVTable;
-    use vortex_sparse::SparseVTable;
-
-    use super::IntegerStats;
-    use super::RLE_INTEGER_SCHEME;
-    use super::SequenceScheme;
-    use super::SparseScheme;
-    use crate::BtrBlocksCompressor;
-    use crate::CompressorContext;
-    use crate::CompressorExt;
-    use crate::CompressorStats;
-    use crate::Scheme;
-
-    #[test]
-    fn test_empty() -> VortexResult<()> {
-        // Make sure empty array compression does not fail
-        let btr = BtrBlocksCompressor::default();
-        let result = btr.integer_compressor().compress(
-            &btr,
-            &PrimitiveArray::new(Buffer::<i32>::empty(), Validity::NonNullable),
-            CompressorContext::default(),
-            &[],
-        )?;
-
-        assert!(result.is_empty());
-        Ok(())
-    }
-
-    #[test]
-    fn test_dict_encodable() -> VortexResult<()> {
-        let mut codes = BufferMut::<i32>::with_capacity(65_535);
-        // Write some runs of length 3 of a handful of different values. Interrupted by some
-        // one-off values.
-
-        let numbers = [0, 10, 50, 100, 1000, 3000]
-            .into_iter()
-            .map(|i| 12340 * i) // must be big enough to not prefer fastlanes.bitpacked
-            .collect_vec();
-
-        let mut rng = StdRng::seed_from_u64(1u64);
-        while codes.len() < 64000 {
-            let run_length = rng.next_u32() % 5;
-            let value = numbers[rng.next_u32() as usize % numbers.len()];
-            for _ in 0..run_length {
-                codes.push(value);
-            }
-        }
-
-        let primitive = codes.freeze().into_array().to_primitive();
-        let btr = BtrBlocksCompressor::default();
-        let compressed = btr.integer_compressor().compress(
-            &btr,
-            &primitive,
-            CompressorContext::default(),
-            &[],
-        )?;
-        assert!(compressed.is::<DictVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn sparse_with_nulls() -> VortexResult<()> {
-        let array = PrimitiveArray::new(
-            buffer![189u8, 189, 189, 0, 46],
-            Validity::from_iter(vec![true, true, true, true, false]),
-        );
-        let btr = BtrBlocksCompressor::default();
-        let compressed = SparseScheme.compress(
-            &btr,
-            &IntegerStats::generate(&array),
-            CompressorContext::default(),
-            &[],
-        )?;
-        assert!(compressed.is::<SparseVTable>());
-        let decoded = compressed.clone();
-        let expected =
-            PrimitiveArray::new(buffer![189u8, 189, 189, 0, 0], array.validity().clone())
-                .into_array();
-        assert_arrays_eq!(decoded.as_ref(), expected.as_ref());
-        Ok(())
-    }
-
-    #[test]
-    fn sparse_mostly_nulls() -> VortexResult<()> {
-        let array = PrimitiveArray::new(
-            buffer![189u8, 189, 189, 189, 189, 189, 189, 189, 189, 0, 46],
-            Validity::from_iter(vec![
-                false, false, false, false, false, false, false, false, false, false, true,
-            ]),
-        );
-        let btr = BtrBlocksCompressor::default();
-        let compressed = SparseScheme.compress(
-            &btr,
-            &IntegerStats::generate(&array),
-            CompressorContext::default(),
-            &[],
-        )?;
-        assert!(compressed.is::<SparseVTable>());
-        let decoded = compressed.clone();
-        let expected = PrimitiveArray::new(
-            buffer![0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46],
-            array.validity().clone(),
-        )
-        .into_array();
-        assert_arrays_eq!(decoded.as_ref(), expected.as_ref());
-        Ok(())
-    }
-
-    #[test]
-    fn nullable_sequence() -> VortexResult<()> {
-        let values = (0i32..20).step_by(7).collect_vec();
-        let array = PrimitiveArray::from_option_iter(values.clone().into_iter().map(Some));
-        let btr = BtrBlocksCompressor::default();
-        let compressed = SequenceScheme.compress(
-            &btr,
-            &IntegerStats::generate(&array),
-            CompressorContext::default(),
-            &[],
-        )?;
-        assert!(compressed.is::<SequenceVTable>());
-        let decoded = compressed;
-        let expected = PrimitiveArray::from_option_iter(values.into_iter().map(Some)).into_array();
-        assert_arrays_eq!(decoded.as_ref(), expected.as_ref());
-        Ok(())
-    }
-
-    #[test]
-    fn test_rle_compression() -> VortexResult<()> {
-        let mut values = Vec::new();
-        values.extend(iter::repeat_n(42i32, 100));
-        values.extend(iter::repeat_n(123i32, 200));
-        values.extend(iter::repeat_n(987i32, 150));
-
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed = RLE_INTEGER_SCHEME.compress(
-            &btr,
-            &IntegerStats::generate(&array),
-            CompressorContext::default(),
-            &[],
-        )?;
-
-        let decoded = compressed;
-        let expected = Buffer::copy_from(&values).into_array();
-        assert_arrays_eq!(decoded.as_ref(), expected.as_ref());
-        Ok(())
-    }
-
-    #[test_with::env(CI)]
-    #[test_with::no_env(VORTEX_SKIP_SLOW_TESTS)]
-    fn compress_large_int() -> VortexResult<()> {
-        const NUM_LISTS: usize = 10_000;
-        const ELEMENTS_PER_LIST: usize = 5_000;
-
-        let prim = (0..NUM_LISTS)
-            .flat_map(|list_idx| {
-                (0..ELEMENTS_PER_LIST).map(move |elem_idx| (list_idx * 1000 + elem_idx) as f64)
-            })
-            .collect::<PrimitiveArray>()
-            .into_array();
-
-        let btr = BtrBlocksCompressor::default();
-        drop(btr.compress(prim.as_ref())?);
-
-        Ok(())
-    }
-}
-
-/// Tests to verify that each integer compression scheme produces the expected encoding.
-#[cfg(test)]
-mod scheme_selection_tests {
-    use std::iter;
-
-    use vortex_array::arrays::ConstantVTable;
-    use vortex_array::arrays::DictVTable;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::Buffer;
-    use vortex_error::VortexResult;
-    use vortex_fastlanes::BitPackedVTable;
-    use vortex_fastlanes::FoRVTable;
-    use vortex_fastlanes::RLEVTable;
-    use vortex_runend::RunEndVTable;
-    use vortex_sequence::SequenceVTable;
-    use vortex_sparse::SparseVTable;
-
-    use crate::BtrBlocksCompressor;
-    use crate::CompressorContext;
-    use crate::CompressorExt;
-
-    #[test]
-    fn test_constant_compressed() -> VortexResult<()> {
-        let values: Vec<i32> = iter::repeat_n(42, 100).collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<ConstantVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_for_compressed() -> VortexResult<()> {
-        let values: Vec<i32> = (0..1000).map(|i| 1_000_000 + ((i * 37) % 100)).collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<FoRVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_bitpacking_compressed() -> VortexResult<()> {
-        let values: Vec<u32> = (0..1000).map(|i| i % 16).collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<BitPackedVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_sparse_compressed() -> VortexResult<()> {
-        let mut values: Vec<i32> = Vec::new();
-        for i in 0..1000 {
-            if i % 20 == 0 {
-                values.push(2_000_000 + (i * 7) % 1000);
-            } else {
-                values.push(1_000_000);
-            }
-        }
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<SparseVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_dict_compressed() -> VortexResult<()> {
-        use rand::RngCore;
-        use rand::SeedableRng;
-        use rand::rngs::StdRng;
-
-        let mut codes = Vec::with_capacity(65_535);
-        let numbers: Vec<i32> = [0, 10, 50, 100, 1000, 3000]
-            .into_iter()
-            .map(|i| 12340 * i) // must be big enough to not prefer fastlanes.bitpacked
-            .collect();
-
-        let mut rng = StdRng::seed_from_u64(1u64);
-        while codes.len() < 64000 {
-            let run_length = rng.next_u32() % 5;
-            let value = numbers[rng.next_u32() as usize % numbers.len()];
-            for _ in 0..run_length {
-                codes.push(value);
-            }
-        }
-
-        let array = PrimitiveArray::new(Buffer::copy_from(&codes), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<DictVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_runend_compressed() -> VortexResult<()> {
-        let mut values: Vec<i32> = Vec::new();
-        for i in 0..100 {
-            values.extend(iter::repeat_n((i32::MAX - 50).wrapping_add(i), 10));
-        }
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<RunEndVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_sequence_compressed() -> VortexResult<()> {
-        let values: Vec<i32> = (0..1000).map(|i| i * 7).collect();
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<SequenceVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_rle_compressed() -> VortexResult<()> {
-        let mut values: Vec<i32> = Vec::new();
-        for i in 0..10 {
-            values.extend(iter::repeat_n(i, 100));
-        }
-        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
-        let btr = BtrBlocksCompressor::default();
-        let compressed =
-            btr.integer_compressor()
-                .compress(&btr, &array, CompressorContext::default(), &[])?;
-        assert!(compressed.is::<RLEVTable>());
-        Ok(())
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/mod.rs b/vortex-btrblocks/src/compressor/mod.rs
deleted file mode 100644
index af59ad41bda..00000000000
--- a/vortex-btrblocks/src/compressor/mod.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Compressor traits for type-specific compression.
-
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::scalar::Scalar;
-use vortex_array::vtable::VTable;
-use vortex_error::VortexResult;
-
-use crate::BtrBlocksCompressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::Scheme;
-
-pub(crate) mod decimal;
-pub(crate) mod float;
-pub(crate) mod integer;
-mod patches;
-mod rle;
-pub(crate) mod string;
-pub(crate) mod temporal;
-
-/// Maximum cascade depth for compression.
-pub(crate) const MAX_CASCADE: usize = 3;
-
-/// A compressor for a particular input type.
-///
-/// This trait defines the interface for type-specific compressors that can adaptively
-/// choose and apply compression schemes based on data characteristics. Compressors
-/// analyze input arrays, select optimal compression schemes, and handle cascading
-/// compression with multiple encoding layers.
-///
-/// The compressor works by generating statistics on the input data, evaluating
-/// available compression schemes, and selecting the one with the best compression ratio.
-pub trait Compressor {
-    /// The VTable type for arrays this compressor operates on.
-    type ArrayVTable: VTable;
-    /// The compression scheme type used by this compressor.
-    type SchemeType: Scheme<StatsType = Self::StatsType> + ?Sized;
-    /// The statistics type used to analyze arrays for compression.
-    type StatsType: CompressorStats<ArrayVTable = Self::ArrayVTable>;
-
-    /// Generates statistics for the given array to guide compression scheme selection.
-    fn gen_stats(&self, array: &<Self::ArrayVTable as VTable>::Array) -> Self::StatsType;
-
-    /// Returns all available compression schemes for this compressor.
-    fn schemes(&self) -> &[&'static Self::SchemeType];
-    /// Returns the default fallback compression scheme.
-    fn default_scheme(&self) -> &'static Self::SchemeType;
-}
-
-/// Extension trait providing scheme selection and compression for compressors.
-pub trait CompressorExt: Compressor
-where
-    Self::SchemeType: 'static,
-{
-    /// Selects the best compression scheme based on expected compression ratios.
-    ///
-    /// Evaluates all available schemes against the provided statistics and returns
-    /// the one with the highest compression ratio. Falls back to the default scheme
-    /// if no scheme provides compression benefits.
-    #[allow(clippy::cognitive_complexity)]
-    fn choose_scheme(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[<Self::SchemeType as Scheme>::CodeType],
-    ) -> VortexResult<&'static Self::SchemeType> {
-        let mut best_ratio = 1.0;
-        let mut best_scheme: Option<&'static Self::SchemeType> = None;
-
-        // logging helpers
-        let depth = MAX_CASCADE - ctx.allowed_cascading;
-
-        for scheme in self.schemes().iter() {
-            // Skip excluded schemes
-            if excludes.contains(&scheme.code()) {
-                continue;
-            }
-
-            // We never choose Constant for a sample
-            if ctx.is_sample && scheme.is_constant() {
-                continue;
-            }
-
-            tracing::trace!(
-                is_sample = ctx.is_sample,
-                depth,
-                is_constant = scheme.is_constant(),
-                ?scheme,
-                "Trying compression scheme"
-            );
-
-            let ratio = scheme.expected_compression_ratio(compressor, stats, ctx, excludes)?;
-            tracing::trace!(
-                is_sample = ctx.is_sample,
-                depth,
-                ratio,
-                ?scheme,
-                "Expected compression result"
-            );
-
-            if !(ratio.is_subnormal() || ratio.is_infinite() || ratio.is_nan()) {
-                if ratio > best_ratio {
-                    best_ratio = ratio;
-                    best_scheme = Some(*scheme);
-                }
-            } else {
-                tracing::trace!(
-                    "Calculated invalid compression ratio {ratio} for scheme: {scheme:?}. Must not be sub-normal, infinite or nan."
-                );
-            }
-        }
-
-        tracing::trace!(depth, scheme = ?best_scheme, ratio = best_ratio, "best scheme found");
-
-        if let Some(best) = best_scheme {
-            Ok(best)
-        } else {
-            Ok(self.default_scheme())
-        }
-    }
-
-    /// Compresses an array using this compressor.
-    ///
-    /// Generates statistics on the input array, selects the best compression scheme,
-    /// and applies it. Returns the original array if compression would increase size.
-    fn compress(
-        &self,
-        btr_blocks_compressor: &BtrBlocksCompressor,
-        array: &<<Self as Compressor>::ArrayVTable as VTable>::Array,
-        ctx: CompressorContext,
-        excludes: &[<Self::SchemeType as Scheme>::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        // Avoid compressing empty arrays.
-        if array.is_empty() {
-            return Ok(array.to_array());
-        }
-
-        // Avoid compressing all-null arrays.
-        if array.all_invalid()? {
-            return Ok(
-                ConstantArray::new(Scalar::null(array.dtype().clone()), array.len()).into_array(),
-            );
-        }
-
-        // Generate stats on the array directly.
-        let stats = self.gen_stats(array);
-        let best_scheme = self.choose_scheme(btr_blocks_compressor, &stats, ctx, excludes)?;
-
-        let output = best_scheme.compress(btr_blocks_compressor, &stats, ctx, excludes)?;
-        if output.nbytes() < array.nbytes() {
-            Ok(output)
-        } else {
-            tracing::debug!("resulting tree too large: {}", output.encoding_id());
-            Ok(array.to_array())
-        }
-    }
-}
-
-// Blanket implementation for all Compressor types with 'static SchemeType
-impl<T: Compressor> CompressorExt for T where T::SchemeType: 'static {}
diff --git a/vortex-btrblocks/src/compressor/rle.rs b/vortex-btrblocks/src/compressor/rle.rs
deleted file mode 100644
index c0cb20780bb..00000000000
--- a/vortex-btrblocks/src/compressor/rle.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::marker::PhantomData;
-
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_error::VortexResult;
-use vortex_fastlanes::RLEArray;
-
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::Excludes;
-use crate::IntCode;
-use crate::Scheme;
-use crate::SchemeExt;
-
-/// Threshold for the average run length in an array before we consider run-length encoding.
-pub const RUN_LENGTH_THRESHOLD: u32 = 4;
-
-/// Trait for accessing RLE-specific statistics.
-pub trait RLEStats {
-    fn value_count(&self) -> u32;
-    fn average_run_length(&self) -> u32;
-    fn source(&self) -> &PrimitiveArray;
-}
-
-/// Configuration trait for RLE schemes.
-///
-/// Implement this trait to define the behavior of an RLE scheme for a specific
-/// stats and code type combination.
-pub trait RLEConfig: Debug + Send + Sync + 'static {
-    /// The statistics type used by this RLE scheme.
-    type Stats: RLEStats + CompressorStats;
-    /// The code type used to identify schemes.
-    type Code: Copy + Clone + Debug + Hash + Eq + Ord;
-
-    /// The unique code identifying this RLE scheme.
-    const CODE: Self::Code;
-
-    /// Compress the values array after RLE encoding.
-    fn compress_values(
-        compressor: &BtrBlocksCompressor,
-        values: &PrimitiveArray,
-        ctx: CompressorContext,
-        excludes: &[Self::Code],
-    ) -> VortexResult<ArrayRef>;
-}
-
-/// RLE scheme that is generic over a configuration type.
-///
-/// This is a ZST (zero-sized type) - all behavior is defined by the `RLEConfig` trait.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct RLEScheme<C: RLEConfig>(PhantomData<C>);
-
-impl<C: RLEConfig> RLEScheme<C> {
-    /// Creates a new RLE scheme.
-    pub const fn new() -> Self {
-        Self(PhantomData)
-    }
-}
-
-impl<C: RLEConfig> Default for RLEScheme<C> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<C: RLEConfig> Scheme for RLEScheme<C> {
-    type StatsType = C::Stats;
-    type CodeType = C::Code;
-
-    fn code(&self) -> C::Code {
-        C::CODE
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[C::Code],
-    ) -> VortexResult<f64> {
-        // RLE is only useful when we cascade it with another encoding.
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        // Don't compress all-null or empty arrays.
-        if stats.value_count() == 0 {
-            return Ok(0.0);
-        }
-
-        // Check whether RLE is a good fit, based on the average run length.
-        if stats.average_run_length() < RUN_LENGTH_THRESHOLD {
-            return Ok(0.0);
-        }
-
-        // Run compression on a sample to see how it performs.
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[C::Code],
-    ) -> VortexResult<ArrayRef> {
-        let rle_array = RLEArray::encode(RLEStats::source(stats))?;
-
-        if ctx.allowed_cascading == 0 {
-            return Ok(rle_array.into_array());
-        }
-
-        // Prevent RLE recursion.
-        let mut new_excludes = vec![self.code()];
-        new_excludes.extend_from_slice(excludes);
-
-        let compressed_values = C::compress_values(
-            compressor,
-            &rle_array.values().to_primitive(),
-            ctx.descend(),
-            &new_excludes,
-        )?;
-
-        let compressed_indices = compressor.compress_canonical(
-            Canonical::Primitive(rle_array.indices().to_primitive().narrow()?),
-            ctx.descend(),
-            Excludes::from(&[IntCode::Dict]),
-        )?;
-
-        let compressed_offsets = compressor.compress_canonical(
-            Canonical::Primitive(rle_array.values_idx_offsets().to_primitive().narrow()?),
-            ctx.descend(),
-            Excludes::from(&[IntCode::Dict]),
-        )?;
-
-        // SAFETY: Recursive compression doesn't affect the invariants.
-        unsafe {
-            Ok(RLEArray::new_unchecked(
-                compressed_values,
-                compressed_indices,
-                compressed_offsets,
-                rle_array.dtype().clone(),
-                rle_array.offset(),
-                rle_array.len(),
-            )
-            .into_array())
-        }
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/string.rs b/vortex-btrblocks/src/compressor/string.rs
deleted file mode 100644
index 53686997ef6..00000000000
--- a/vortex-btrblocks/src/compressor/string.rs
+++ /dev/null
@@ -1,672 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use enum_iterator::Sequence;
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::DictArray;
-use vortex_array::arrays::MaskedArray;
-use vortex_array::arrays::VarBinArray;
-use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::VarBinViewVTable;
-use vortex_array::builders::dict::dict_encode;
-use vortex_array::compute::is_constant;
-use vortex_array::scalar::Scalar;
-use vortex_array::vtable::VTable;
-use vortex_array::vtable::ValidityHelper;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-use vortex_fsst::FSSTArray;
-use vortex_fsst::fsst_compress;
-use vortex_fsst::fsst_train_compressor;
-use vortex_sparse::SparseArray;
-use vortex_sparse::SparseVTable;
-use vortex_utils::aliases::hash_set::HashSet;
-
-use super::integer::DictScheme as IntDictScheme;
-use super::integer::SequenceScheme as IntSequenceScheme;
-use super::integer::SparseScheme as IntSparseScheme;
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::Compressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::Excludes;
-use crate::GenerateStatsOptions;
-use crate::IntCode;
-use crate::Scheme;
-use crate::SchemeExt;
-use crate::sample::sample;
-
-/// Array of variable-length byte arrays, and relevant stats for compression.
-#[derive(Clone, Debug)]
-pub struct StringStats {
-    src: VarBinViewArray,
-    estimated_distinct_count: u32,
-    value_count: u32,
-    null_count: u32,
-}
-
-/// Estimate the number of distinct strings in the var bin view array.
-fn estimate_distinct_count(strings: &VarBinViewArray) -> VortexResult<u32> {
-    let views = strings.views();
-    // Iterate the views. Two strings which are equal must have the same first 8-bytes.
-    // NOTE: there are cases where this performs pessimally, e.g. when we have strings that all
-    // share a 4-byte prefix and have the same length.
-    let mut distinct = HashSet::with_capacity(views.len() / 2);
-    views.iter().for_each(|&view| {
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "approximate uniqueness with view prefix"
-        )]
-        let len_and_prefix = view.as_u128() as u64;
-        distinct.insert(len_and_prefix);
-    });
-
-    Ok(u32::try_from(distinct.len())?)
-}
-
-impl StringStats {
-    fn generate_opts_fallible(
-        input: &VarBinViewArray,
-        opts: GenerateStatsOptions,
-    ) -> VortexResult<Self> {
-        let null_count = input
-            .statistics()
-            .compute_null_count()
-            .ok_or_else(|| vortex_err!("Failed to compute null_count"))?;
-        let value_count = input.len() - null_count;
-        let estimated_distinct = if opts.count_distinct_values {
-            estimate_distinct_count(input)?
-        } else {
-            u32::MAX
-        };
-
-        Ok(Self {
-            src: input.clone(),
-            value_count: u32::try_from(value_count)?,
-            null_count: u32::try_from(null_count)?,
-            estimated_distinct_count: estimated_distinct,
-        })
-    }
-}
-
-impl CompressorStats for StringStats {
-    type ArrayVTable = VarBinViewVTable;
-
-    fn generate_opts(input: &VarBinViewArray, opts: GenerateStatsOptions) -> Self {
-        Self::generate_opts_fallible(input, opts)
-            .vortex_expect("StringStats::generate_opts should not fail")
-    }
-
-    fn source(&self) -> &VarBinViewArray {
-        &self.src
-    }
-
-    fn sample_opts(&self, sample_size: u32, sample_count: u32, opts: GenerateStatsOptions) -> Self {
-        let sampled = sample(self.src.as_ref(), sample_size, sample_count).to_varbinview();
-
-        Self::generate_opts(&sampled, opts)
-    }
-}
-
-/// All available string compression schemes.
-pub const ALL_STRING_SCHEMES: &[&dyn StringScheme] = &[
-    &UncompressedScheme,
-    &DictScheme,
-    &FSSTScheme,
-    &ConstantScheme,
-    &NullDominated,
-    #[cfg(feature = "zstd")]
-    &ZstdScheme,
-    #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-    &ZstdBuffersScheme,
-];
-
-/// [`Compressor`] for strings.
-#[derive(Clone, Copy)]
-pub struct StringCompressor<'a> {
-    /// Reference to the parent compressor.
-    pub btr_blocks_compressor: &'a dyn CanonicalCompressor,
-}
-
-impl<'a> Compressor for StringCompressor<'a> {
-    type ArrayVTable = VarBinViewVTable;
-    type SchemeType = dyn StringScheme;
-    type StatsType = StringStats;
-
-    fn gen_stats(&self, array: &<Self::ArrayVTable as VTable>::Array) -> Self::StatsType {
-        if self
-            .btr_blocks_compressor
-            .string_schemes()
-            .iter()
-            .any(|s| s.code() == DictScheme.code())
-        {
-            StringStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: true,
-                },
-            )
-        } else {
-            StringStats::generate_opts(
-                array,
-                GenerateStatsOptions {
-                    count_distinct_values: false,
-                },
-            )
-        }
-    }
-
-    fn schemes(&self) -> &[&'static dyn StringScheme] {
-        self.btr_blocks_compressor.string_schemes()
-    }
-
-    fn default_scheme(&self) -> &'static Self::SchemeType {
-        &UncompressedScheme
-    }
-}
-
-pub trait StringScheme:
-    Scheme<StatsType = StringStats, CodeType = StringCode> + Send + Sync
-{
-}
-
-impl<T> StringScheme for T where
-    T: Scheme<StatsType = StringStats, CodeType = StringCode> + Send + Sync
-{
-}
-
-impl PartialEq for dyn StringScheme {
-    fn eq(&self, other: &Self) -> bool {
-        self.code() == other.code()
-    }
-}
-
-impl Eq for dyn StringScheme {}
-
-impl Hash for dyn StringScheme {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.code().hash(state)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct UncompressedScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct DictScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct FSSTScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct ConstantScheme;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct NullDominated;
-
-/// Zstd compression without dictionaries (nvCOMP compatible).
-#[cfg(feature = "zstd")]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct ZstdScheme;
-
-/// Zstd buffer-level compression preserving array layout for GPU decompression.
-#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct ZstdBuffersScheme;
-
-/// Unique identifier for string compression schemes.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Sequence, Ord, PartialOrd)]
-pub enum StringCode {
-    /// No compression applied.
-    Uncompressed,
-    /// Dictionary encoding for low-cardinality strings.
-    Dict,
-    /// FSST (Fast Static Symbol Table) compression.
-    Fsst,
-    /// Constant encoding for arrays with a single distinct value.
-    Constant,
-    /// Sparse encoding for null-dominated arrays.
-    Sparse,
-    /// Zstd compression without dictionaries.
-    Zstd,
-    /// Zstd buffer-level compression preserving array layout.
-    ZstdBuffers,
-}
-
-impl Scheme for UncompressedScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> StringCode {
-        StringCode::Uncompressed
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        _stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<f64> {
-        Ok(1.0)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(stats.source().to_array())
-    }
-}
-
-impl Scheme for DictScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> StringCode {
-        StringCode::Dict
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[StringCode],
-    ) -> VortexResult<f64> {
-        // If we don't have a sufficiently high number of distinct values, do not attempt Dict.
-        if stats.estimated_distinct_count > stats.value_count / 2 {
-            return Ok(0.0);
-        }
-
-        // If array is all null, do not attempt dict.
-        if stats.value_count == 0 {
-            return Ok(0.0);
-        }
-
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<ArrayRef> {
-        let dict = dict_encode(&stats.source().clone().into_array())?;
-
-        // If we are not allowed to cascade, do not attempt codes or values compression.
-        if ctx.allowed_cascading == 0 {
-            return Ok(dict.into_array());
-        }
-
-        // Find best compressor for codes and values separately
-        let compressed_codes = compressor.compress_canonical(
-            Canonical::Primitive(dict.codes().to_primitive()),
-            ctx.descend(),
-            Excludes::from(&[IntDictScheme.code(), IntSequenceScheme.code()]),
-        )?;
-
-        // Attempt to compress the values with non-Dict compression.
-        // Currently this will only be FSST.
-        let compressed_values = compressor.compress_canonical(
-            Canonical::VarBinView(dict.values().to_varbinview()),
-            ctx.descend(),
-            Excludes::from(&[DictScheme.code()]),
-        )?;
-
-        // SAFETY: compressing codes or values does not alter the invariants
-        unsafe {
-            Ok(
-                DictArray::new_unchecked(compressed_codes, compressed_values)
-                    .set_all_values_referenced(dict.has_all_values_referenced())
-                    .into_array(),
-            )
-        }
-    }
-}
-
-impl Scheme for FSSTScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> StringCode {
-        StringCode::Fsst
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<ArrayRef> {
-        let fsst = {
-            let compressor = fsst_train_compressor(&stats.src);
-            fsst_compress(&stats.src, &compressor)
-        };
-
-        let compressed_original_lengths = compressor.compress_canonical(
-            Canonical::Primitive(fsst.uncompressed_lengths().to_primitive().narrow()?),
-            ctx,
-            Excludes::none(),
-        )?;
-
-        let compressed_codes_offsets = compressor.compress_canonical(
-            Canonical::Primitive(fsst.codes().offsets().to_primitive().narrow()?),
-            ctx,
-            Excludes::none(),
-        )?;
-        let compressed_codes = VarBinArray::try_new(
-            compressed_codes_offsets,
-            fsst.codes().bytes().clone(),
-            fsst.codes().dtype().clone(),
-            fsst.codes().validity().clone(),
-        )?;
-
-        let fsst = FSSTArray::try_new(
-            fsst.dtype().clone(),
-            fsst.symbols().clone(),
-            fsst.symbol_lengths().clone(),
-            compressed_codes,
-            compressed_original_lengths,
-        )?;
-
-        Ok(fsst.into_array())
-    }
-}
-
-impl Scheme for ConstantScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> Self::CodeType {
-        StringCode::Constant
-    }
-
-    fn is_constant(&self) -> bool {
-        true
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        if ctx.is_sample {
-            return Ok(0.0);
-        }
-
-        if stats.estimated_distinct_count > 1 || !is_constant(stats.src.as_ref())?.unwrap_or(false)
-        {
-            return Ok(0.0);
-        }
-
-        // Force constant is these cases
-        Ok(f64::MAX)
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        let scalar_idx =
-            (0..stats.source().len()).position(|idx| stats.source().is_valid(idx).unwrap_or(false));
-
-        match scalar_idx {
-            Some(idx) => {
-                let scalar = stats.source().scalar_at(idx)?;
-                let const_arr = ConstantArray::new(scalar, stats.src.len()).into_array();
-                if !stats.source().all_valid()? {
-                    Ok(MaskedArray::try_new(const_arr, stats.src.validity().clone())?.into_array())
-                } else {
-                    Ok(const_arr)
-                }
-            }
-            None => Ok(ConstantArray::new(
-                Scalar::null(stats.src.dtype().clone()),
-                stats.src.len(),
-            )
-            .into_array()),
-        }
-    }
-}
-
-impl Scheme for NullDominated {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> Self::CodeType {
-        StringCode::Sparse
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        // Only use `SparseScheme` if we can cascade.
-        if ctx.allowed_cascading == 0 {
-            return Ok(0.0);
-        }
-
-        if stats.value_count == 0 {
-            // All nulls should use ConstantScheme
-            return Ok(0.0);
-        }
-
-        // If the majority is null, will compress well.
-        if stats.null_count as f64 / stats.src.len() as f64 > 0.9 {
-            return Ok(stats.src.len() as f64 / stats.value_count as f64);
-        }
-
-        // Otherwise we don't go this route
-        Ok(0.0)
-    }
-
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        _excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef> {
-        assert!(ctx.allowed_cascading > 0);
-
-        // We pass None as we only run this pathway for NULL-dominated string arrays
-        let sparse_encoded = SparseArray::encode(stats.src.as_ref(), None)?;
-
-        if let Some(sparse) = sparse_encoded.as_opt::<SparseVTable>() {
-            // Compress the indices only (not the values for strings)
-            let new_excludes = vec![IntSparseScheme.code(), IntCode::Dict];
-
-            let indices = sparse.patches().indices().to_primitive().narrow()?;
-            let compressed_indices = compressor.compress_canonical(
-                Canonical::Primitive(indices),
-                ctx.descend(),
-                Excludes::int_only(&new_excludes),
-            )?;
-
-            SparseArray::try_new(
-                compressed_indices,
-                sparse.patches().values().clone(),
-                sparse.len(),
-                sparse.fill_scalar().clone(),
-            )
-            .map(|a| a.into_array())
-        } else {
-            Ok(sparse_encoded)
-        }
-    }
-}
-
-#[cfg(feature = "zstd")]
-impl Scheme for ZstdScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> StringCode {
-        StringCode::Zstd
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<ArrayRef> {
-        let compacted = stats.source().compact_buffers()?;
-        Ok(
-            vortex_zstd::ZstdArray::from_var_bin_view_without_dict(&compacted, 3, 8192)?
-                .into_array(),
-        )
-    }
-}
-
-#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-impl Scheme for ZstdBuffersScheme {
-    type StatsType = StringStats;
-    type CodeType = StringCode;
-
-    fn code(&self) -> StringCode {
-        StringCode::ZstdBuffers
-    }
-
-    fn compress(
-        &self,
-        _compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        _ctx: CompressorContext,
-        _excludes: &[StringCode],
-    ) -> VortexResult<ArrayRef> {
-        Ok(vortex_zstd::ZstdBuffersArray::compress(&stats.source().to_array(), 3)?.into_array())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_array::arrays::VarBinViewArray;
-    use vortex_array::builders::ArrayBuilder;
-    use vortex_array::builders::VarBinViewBuilder;
-    use vortex_array::display::DisplayOptions;
-    use vortex_array::dtype::DType;
-    use vortex_array::dtype::Nullability;
-    use vortex_error::VortexResult;
-
-    use crate::BtrBlocksCompressor;
-
-    #[test]
-    fn test_strings() -> VortexResult<()> {
-        let mut strings = Vec::new();
-        for _ in 0..1024 {
-            strings.push(Some("hello-world-1234"));
-        }
-        for _ in 0..1024 {
-            strings.push(Some("hello-world-56789"));
-        }
-        let strings = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
-
-        let compressed = BtrBlocksCompressor::default().compress(strings.as_ref())?;
-        assert_eq!(compressed.len(), 2048);
-
-        let display = compressed
-            .display_as(DisplayOptions::MetadataOnly)
-            .to_string()
-            .to_lowercase();
-        assert_eq!(display, "vortex.dict(utf8, len=2048)");
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_sparse_nulls() -> VortexResult<()> {
-        let mut strings = VarBinViewBuilder::with_capacity(DType::Utf8(Nullability::Nullable), 100);
-        strings.append_nulls(99);
-
-        strings.append_value("one little string");
-
-        let strings = strings.finish_into_varbinview();
-
-        let compressed = BtrBlocksCompressor::default().compress(strings.as_ref())?;
-        assert_eq!(compressed.len(), 100);
-
-        let display = compressed
-            .display_as(DisplayOptions::MetadataOnly)
-            .to_string()
-            .to_lowercase();
-        assert_eq!(display, "vortex.sparse(utf8?, len=100)");
-
-        Ok(())
-    }
-}
-
-/// Tests to verify that each string compression scheme produces the expected encoding.
-#[cfg(test)]
-mod scheme_selection_tests {
-    use vortex_array::arrays::ConstantVTable;
-    use vortex_array::arrays::DictVTable;
-    use vortex_array::arrays::VarBinViewArray;
-    use vortex_array::dtype::DType;
-    use vortex_array::dtype::Nullability;
-    use vortex_error::VortexResult;
-    use vortex_fsst::FSSTVTable;
-
-    use crate::BtrBlocksCompressor;
-
-    #[test]
-    fn test_constant_compressed() -> VortexResult<()> {
-        let strings: Vec<Option<&str>> = vec![Some("constant_value"); 100];
-        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
-        let compressed = BtrBlocksCompressor::default().compress(array.as_ref())?;
-        assert!(compressed.is::<ConstantVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_dict_compressed() -> VortexResult<()> {
-        let distinct_values = ["apple", "banana", "cherry"];
-        let mut strings = Vec::with_capacity(1000);
-        for i in 0..1000 {
-            strings.push(Some(distinct_values[i % 3]));
-        }
-        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
-        let compressed = BtrBlocksCompressor::default().compress(array.as_ref())?;
-        assert!(compressed.is::<DictVTable>());
-        Ok(())
-    }
-
-    #[test]
-    fn test_fsst_compressed() -> VortexResult<()> {
-        let mut strings = Vec::with_capacity(1000);
-        for i in 0..1000 {
-            strings.push(Some(format!(
-                "this_is_a_common_prefix_with_some_variation_{i}_and_a_common_suffix_pattern"
-            )));
-        }
-        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
-        let compressed = BtrBlocksCompressor::default().compress(array.as_ref())?;
-        assert!(compressed.is::<FSSTVTable>());
-        Ok(())
-    }
-}
diff --git a/vortex-btrblocks/src/compressor/temporal.rs b/vortex-btrblocks/src/compressor/temporal.rs
deleted file mode 100644
index 6fb917be58d..00000000000
--- a/vortex-btrblocks/src/compressor/temporal.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Specialized compressor for DateTimeParts metadata.
-
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::TemporalArray;
-use vortex_datetime_parts::DateTimePartsArray;
-use vortex_datetime_parts::TemporalParts;
-use vortex_datetime_parts::split_temporal;
-use vortex_error::VortexResult;
-
-use crate::BtrBlocksCompressor;
-use crate::CanonicalCompressor;
-use crate::CompressorContext;
-use crate::Excludes;
-
-/// Compress a temporal array into a `DateTimePartsArray`.
-pub fn compress_temporal(
-    compressor: &BtrBlocksCompressor,
-    array: TemporalArray,
-) -> VortexResult<ArrayRef> {
-    let dtype = array.dtype().clone();
-    let TemporalParts {
-        days,
-        seconds,
-        subseconds,
-    } = split_temporal(array)?;
-
-    let ctx = CompressorContext::default().descend();
-
-    let days = compressor.compress_canonical(
-        Canonical::Primitive(days.to_primitive().narrow()?),
-        ctx,
-        Excludes::none(),
-    )?;
-    let seconds = compressor.compress_canonical(
-        Canonical::Primitive(seconds.to_primitive().narrow()?),
-        ctx,
-        Excludes::none(),
-    )?;
-    let subseconds = compressor.compress_canonical(
-        Canonical::Primitive(subseconds.to_primitive().narrow()?),
-        ctx,
-        Excludes::none(),
-    )?;
-
-    Ok(DateTimePartsArray::try_new(dtype, days, seconds, subseconds)?.into_array())
-}
diff --git a/vortex-btrblocks/src/ctx.rs b/vortex-btrblocks/src/ctx.rs
deleted file mode 100644
index f2cb6a37102..00000000000
--- a/vortex-btrblocks/src/ctx.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Compression context types for recursive compression.
-
-use crate::FloatCode;
-use crate::IntCode;
-use crate::MAX_CASCADE;
-use crate::StringCode;
-
-/// Holds references to exclude lists for each compression code type.
-///
-/// This struct is passed through recursive compression calls to specify
-/// which schemes should be excluded at each level.
-#[derive(Debug, Clone, Copy, Default)]
-pub struct Excludes<'a> {
-    /// Integer schemes to exclude.
-    pub int: &'a [IntCode],
-    /// Float schemes to exclude.
-    pub float: &'a [FloatCode],
-    /// String schemes to exclude.
-    pub string: &'a [StringCode],
-}
-
-impl<'a> Excludes<'a> {
-    /// Creates an empty excludes (no exclusions).
-    pub const fn none() -> Self {
-        Self {
-            int: &[],
-            float: &[],
-            string: &[],
-        }
-    }
-
-    /// Creates excludes with only integer exclusions.
-    pub const fn int_only(int: &'a [IntCode]) -> Self {
-        Self {
-            int,
-            float: &[],
-            string: &[],
-        }
-    }
-
-    /// Creates excludes with only float exclusions.
-    pub const fn float_only(float: &'a [FloatCode]) -> Self {
-        Self {
-            int: &[],
-            float,
-            string: &[],
-        }
-    }
-
-    /// Creates excludes with only string exclusions.
-    pub const fn string_only(string: &'a [StringCode]) -> Self {
-        Self {
-            int: &[],
-            float: &[],
-            string,
-        }
-    }
-}
-
-impl<'a> From<&'a [IntCode]> for Excludes<'a> {
-    fn from(int: &'a [IntCode]) -> Self {
-        Self::int_only(int)
-    }
-}
-
-impl<'a, const N: usize> From<&'a [IntCode; N]> for Excludes<'a> {
-    fn from(int: &'a [IntCode; N]) -> Self {
-        Self::int_only(int)
-    }
-}
-
-impl<'a> From<&'a [FloatCode]> for Excludes<'a> {
-    fn from(float: &'a [FloatCode]) -> Self {
-        Self::float_only(float)
-    }
-}
-
-impl<'a, const N: usize> From<&'a [FloatCode; N]> for Excludes<'a> {
-    fn from(float: &'a [FloatCode; N]) -> Self {
-        Self::float_only(float)
-    }
-}
-
-impl<'a> From<&'a [StringCode]> for Excludes<'a> {
-    fn from(string: &'a [StringCode]) -> Self {
-        Self::string_only(string)
-    }
-}
-
-impl<'a, const N: usize> From<&'a [StringCode; N]> for Excludes<'a> {
-    fn from(string: &'a [StringCode; N]) -> Self {
-        Self::string_only(string)
-    }
-}
-
-/// Context passed through recursive compression calls.
-///
-/// Bundles `is_sample` and `allowed_cascading` which always travel together.
-/// Excludes are passed separately since they're type-specific.
-#[derive(Debug, Clone, Copy)]
-pub struct CompressorContext {
-    /// Whether we're compressing a sample (for ratio estimation).
-    pub is_sample: bool,
-    /// Remaining cascade depth allowed.
-    pub allowed_cascading: usize,
-}
-
-impl Default for CompressorContext {
-    fn default() -> Self {
-        Self {
-            is_sample: false,
-            allowed_cascading: MAX_CASCADE,
-        }
-    }
-}
-
-impl CompressorContext {
-    /// Descend one level in the cascade (decrements `allowed_cascading`).
-    pub fn descend(self) -> Self {
-        Self {
-            allowed_cascading: self.allowed_cascading.saturating_sub(1),
-            ..self
-        }
-    }
-
-    /// Returns a context marked as sample compression (for ratio estimation).
-    pub fn as_sample(self) -> Self {
-        Self {
-            is_sample: true,
-            ..self
-        }
-    }
-}
diff --git a/vortex-btrblocks/src/lib.rs b/vortex-btrblocks/src/lib.rs
index 6d542352024..1f6d5a2d816 100644
--- a/vortex-btrblocks/src/lib.rs
+++ b/vortex-btrblocks/src/lib.rs
@@ -12,55 +12,68 @@
 //!
 //! # Key Features
 //!
-//! - **Adaptive Compression**: Automatically selects the best compression scheme based on data patterns
-//! - **Type-Specific Compressors**: Specialized compression for integers, floats, strings, and temporal data
-//! - **Cascaded Encoding**: Multiple compression layers can be applied for optimal results
-//! - **Statistical Analysis**: Uses data sampling and statistics to predict compression ratios
-//! - **Recursive Structure Handling**: Compresses nested structures like structs and lists
+//! - **Adaptive Compression**: Automatically selects the best compression scheme based on data
+//!   patterns.
+//! - **Unified Scheme Trait**: A single [`Scheme`] trait covers all data types (integers, floats,
+//!   strings, etc.) with a [`SchemeId`] for identity.
+//! - **Cascaded Encoding**: Multiple compression layers can be applied for optimal results.
+//! - **Statistical Analysis**: Uses data sampling and statistics to predict compression ratios.
+//! - **Recursive Structure Handling**: Compresses nested structures like structs and lists.
+//!
+//! # How It Works
+//!
+//! [`BtrBlocksCompressor::compress()`] takes an `&ArrayRef` and returns an `ArrayRef` that may
+//! use a different encoding. It first canonicalizes the input, then dispatches by type.
+//! Primitives and strings go through `choose_and_compress`, which evaluates every enabled
+//! [`Scheme`] and picks the one with the best compression ratio. Compound types like structs
+//! and lists recurse into their fields and elements.
+//!
+//! Each `Scheme` implementation declares whether it [`matches`](Scheme::matches) a given
+//! canonical form and, if so, estimates the compression ratio (often by compressing a ~1%
+//! sample). There is no dynamic registry — the set of schemes is fixed at build time via
+//! [`ALL_SCHEMES`].
+//!
+//! Schemes can produce arrays that are themselves further compressed (e.g. FoR then BitPacking),
+//! up to [`MAX_CASCADE`] (3) layers deep. Descendant exclusion rules for of [`SchemeId`] prevents
+//! the same scheme from being applied twice in a chain.
 //!
 //! # Example
 //!
 //! ```rust
-//! use vortex_btrblocks::{BtrBlocksCompressor, BtrBlocksCompressorBuilder, IntCode};
-//! use vortex_array::Array;
+//! use vortex_btrblocks::{BtrBlocksCompressor, BtrBlocksCompressorBuilder, Scheme, SchemeExt};
+//! use vortex_btrblocks::schemes::integer::IntDictScheme;
 //!
-//! // Default compressor with all schemes enabled
+//! // Default compressor with all schemes enabled.
 //! let compressor = BtrBlocksCompressor::default();
 //!
-//! // Configure with builder to exclude specific schemes
+//! // Remove specific schemes using the builder.
 //! let compressor = BtrBlocksCompressorBuilder::default()
-//!     .exclude_int([IntCode::Dict])
+//!     .exclude_schemes([IntDictScheme.id()])
 //!     .build();
 //! ```
 //!
 //! [BtrBlocks]: https://www.cs.cit.tum.de/fileadmin/w00cfj/dis/papers/btrblocks.pdf
 
-pub use compressor::float::FloatCode;
-use compressor::float::FloatCompressor;
-pub use compressor::integer::IntCode;
-use compressor::integer::IntCompressor;
-pub use compressor::string::StringCode;
-use compressor::string::StringCompressor;
-
 mod builder;
 mod canonical_compressor;
-mod compressor;
-mod ctx;
-mod sample;
-mod scheme;
-mod stats;
+/// Compression scheme implementations.
+pub mod schemes;
 
+// Re-export framework types from vortex-compressor for backwards compatibility.
+// Btrblocks-specific exports.
+pub use builder::ALL_SCHEMES;
 pub use builder::BtrBlocksCompressorBuilder;
 pub use canonical_compressor::BtrBlocksCompressor;
-pub use canonical_compressor::CanonicalCompressor;
-use compressor::Compressor;
-use compressor::CompressorExt;
-use compressor::MAX_CASCADE;
-pub use compressor::integer::IntegerStats;
-pub use compressor::integer::dictionary::dictionary_encode as integer_dictionary_encode;
-use ctx::CompressorContext;
-use ctx::Excludes;
-use scheme::Scheme;
-use scheme::SchemeExt;
-pub use stats::CompressorStats;
-pub use stats::GenerateStatsOptions;
+pub use schemes::patches::compress_patches;
+pub use vortex_compressor::CascadingCompressor;
+pub use vortex_compressor::ctx::CompressorContext;
+pub use vortex_compressor::ctx::MAX_CASCADE;
+pub use vortex_compressor::scheme::Scheme;
+pub use vortex_compressor::scheme::SchemeExt;
+pub use vortex_compressor::scheme::SchemeId;
+pub use vortex_compressor::stats::ArrayAndStats;
+pub use vortex_compressor::stats::BoolStats;
+pub use vortex_compressor::stats::FloatStats;
+pub use vortex_compressor::stats::GenerateStatsOptions;
+pub use vortex_compressor::stats::IntegerStats;
+pub use vortex_compressor::stats::StringStats;
diff --git a/vortex-btrblocks/src/sample.rs b/vortex-btrblocks/src/sample.rs
deleted file mode 100644
index b841a5f3fb2..00000000000
--- a/vortex-btrblocks/src/sample.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use rand::Rng;
-use rand::SeedableRng;
-use rand::prelude::StdRng;
-use vortex_array::Array;
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ChunkedArray;
-use vortex_error::VortexExpect;
-
-use crate::stats::SAMPLE_COUNT;
-use crate::stats::SAMPLE_SIZE;
-
-pub(crate) fn sample(input: &dyn Array, sample_size: u32, sample_count: u32) -> ArrayRef {
-    if input.len() <= (sample_size as usize) * (sample_count as usize) {
-        return input.to_array();
-    }
-
-    let slices = stratified_slices(
-        input.len(),
-        sample_size,
-        sample_count,
-        &mut StdRng::seed_from_u64(1234567890u64),
-    );
-
-    // For every slice, grab the relevant slice and repack into a new PrimitiveArray.
-    let chunks: Vec<_> = slices
-        .into_iter()
-        .map(|(start, end)| {
-            input
-                .slice(start..end)
-                .vortex_expect("slice should succeed")
-        })
-        .collect();
-    ChunkedArray::try_new(chunks, input.dtype().clone())
-        .vortex_expect("sample slices should form valid chunked array")
-        .into_array()
-}
-
-/// Computes the number of sample chunks to cover approximately 1% of `len` elements,
-/// with a minimum of `SAMPLE_SIZE * SAMPLE_COUNT` (1024) values.
-pub(crate) fn sample_count_approx_one_percent(len: usize) -> u32 {
-    let approximately_one_percent =
-        (len / 100) / usize::try_from(SAMPLE_SIZE).vortex_expect("SAMPLE_SIZE must fit in usize");
-    u32::max(
-        u32::next_multiple_of(
-            approximately_one_percent
-                .try_into()
-                .vortex_expect("sample count must fit in u32"),
-            16,
-        ),
-        SAMPLE_COUNT,
-    )
-}
-
-pub fn stratified_slices(
-    length: usize,
-    sample_size: u32,
-    sample_count: u32,
-    rng: &mut StdRng,
-) -> Vec<(usize, usize)> {
-    let total_num_samples: usize = (sample_count as usize) * (sample_size as usize);
-    if total_num_samples >= length {
-        return vec![(0usize, length)];
-    }
-
-    let partitions = partition_indices(length, sample_count);
-    let num_samples_per_partition: Vec<usize> = partition_indices(total_num_samples, sample_count)
-        .into_iter()
-        .map(|(start, stop)| stop - start)
-        .collect();
-
-    partitions
-        .into_iter()
-        .zip(num_samples_per_partition)
-        .map(|((start, stop), size)| {
-            assert!(
-                stop - start >= size,
-                "Slices must be bigger than their sampled size"
-            );
-            let random_start = rng.random_range(start..=(stop - size));
-            (random_start, random_start + size)
-        })
-        .collect()
-}
-
-/// Split a range of array indices into as-equal-as-possible slices. If the provided `num_partitions` doesn't
-/// evenly divide into `length`, then the first `(length % num_partitions)` slices will have an extra element.
-pub fn partition_indices(length: usize, num_partitions: u32) -> Vec<(usize, usize)> {
-    let num_long_parts = length % num_partitions as usize;
-    let short_step = length / num_partitions as usize;
-    let long_step = short_step + 1;
-    let long_stop = num_long_parts * long_step;
-
-    (0..long_stop)
-        .step_by(long_step)
-        .map(|off| (off, off + long_step))
-        .chain(
-            (long_stop..length)
-                .step_by(short_step)
-                .map(|off| (off, off + short_step)),
-        )
-        .collect()
-}
diff --git a/vortex-btrblocks/src/scheme.rs b/vortex-btrblocks/src/scheme.rs
deleted file mode 100644
index 63cb4bad28a..00000000000
--- a/vortex-btrblocks/src/scheme.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Compression scheme traits.
-
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::hash::Hasher;
-
-use vortex_array::ArrayRef;
-use vortex_error::VortexResult;
-
-use crate::BtrBlocksCompressor;
-use crate::CompressorContext;
-use crate::CompressorStats;
-use crate::sample::sample_count_approx_one_percent;
-use crate::stats::SAMPLE_SIZE;
-
-/// Top-level compression scheme trait.
-///
-/// Variants are specialized for each data type, e.g. see `IntegerScheme`, `FloatScheme`, etc.
-pub trait Scheme: Debug {
-    /// Type of the stats generated by the compression scheme.
-    type StatsType: CompressorStats;
-    /// Type of the code used to uniquely identify the compression scheme.
-    type CodeType: Copy + Eq + Hash + Ord;
-
-    /// Scheme unique identifier.
-    fn code(&self) -> Self::CodeType;
-
-    /// True if this is the singular Constant scheme for this data type.
-    fn is_constant(&self) -> bool {
-        false
-    }
-
-    /// Estimate the compression ratio for running this scheme (and its children)
-    /// for the given input.
-    ///
-    /// Depth is the depth in the encoding tree we've already reached before considering this
-    /// scheme.
-    ///
-    /// Returns the estimated compression ratio as well as the tree of compressors to use.
-    fn expected_compression_ratio(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        self.estimate_compression_ratio_with_sampling(compressor, stats, ctx, excludes)
-    }
-
-    /// Compress the input with this scheme, yielding a new array.
-    fn compress(
-        &self,
-        compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[Self::CodeType],
-    ) -> VortexResult<ArrayRef>;
-}
-
-impl<C: Copy + Eq + Hash + Ord, V: CompressorStats> PartialEq for dyn Scheme<CodeType = C, StatsType = V> {
-    fn eq(&self, other: &Self) -> bool {
-        self.code() == other.code()
-    }
-}
-impl<C: Copy + Eq + Hash + Ord, V: CompressorStats> Eq for dyn Scheme<CodeType = C, StatsType = V> {}
-impl<C: Copy + Eq + Hash + Ord, V: CompressorStats> Hash for dyn Scheme<CodeType = C, StatsType = V> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.code().hash(state)
-    }
-}
-
-/// Extension trait providing sampling-based compression ratio estimation for schemes.
-pub trait SchemeExt: Scheme {
-    /// Estimates compression ratio by compressing a sample of the data.
-    ///
-    /// This method samples approximately 1% of the data (with a minimum of 1024 values)
-    /// and compresses it to estimate the overall compression ratio.
-    fn estimate_compression_ratio_with_sampling(
-        &self,
-        btr_blocks_compressor: &BtrBlocksCompressor,
-        stats: &Self::StatsType,
-        ctx: CompressorContext,
-        excludes: &[Self::CodeType],
-    ) -> VortexResult<f64> {
-        let sample = if ctx.is_sample {
-            stats.clone()
-        } else {
-            let source_len = stats.source().len();
-            let sample_count = sample_count_approx_one_percent(source_len);
-
-            tracing::trace!(
-                "Sampling {} values out of {}",
-                SAMPLE_SIZE as u64 * sample_count as u64,
-                source_len
-            );
-
-            stats.sample(SAMPLE_SIZE, sample_count)
-        };
-
-        let after = self
-            .compress(btr_blocks_compressor, &sample, ctx.as_sample(), excludes)?
-            .nbytes();
-        let before = sample.source().nbytes();
-
-        tracing::debug!(
-            "estimate_compression_ratio_with_sampling(compressor={self:#?} ctx={ctx:?}) = {}",
-            before as f64 / after as f64
-        );
-
-        Ok(before as f64 / after as f64)
-    }
-}
-
-// Blanket implementation for all Scheme types
-impl<T: Scheme + ?Sized> SchemeExt for T {}
diff --git a/vortex-btrblocks/src/schemes/bool.rs b/vortex-btrblocks/src/schemes/bool.rs
new file mode 100644
index 00000000000..c27251a8599
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/bool.rs
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Bool compression schemes.
+
+pub use vortex_compressor::builtins::BoolConstantScheme;
+pub use vortex_compressor::stats::BoolStats;
diff --git a/vortex-btrblocks/src/schemes/decimal.rs b/vortex-btrblocks/src/schemes/decimal.rs
new file mode 100644
index 00000000000..ce5262ba5ce
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/decimal.rs
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Decimal compression scheme using byte-part decomposition.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::decimal::narrowed_decimal;
+use vortex_array::dtype::DecimalType;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_decimal_byte_parts::DecimalByteParts;
+use vortex_error::VortexResult;
+
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+use crate::SchemeExt;
+
+/// Compression scheme for decimal arrays via byte-part decomposition.
+///
+/// Narrows the decimal to the smallest integer type, compresses the underlying primitive, and wraps
+/// the result in a `DecimalBytePartsArray`.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct DecimalScheme;
+
+impl Scheme for DecimalScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.decimal.byte_parts"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        matches!(canonical, Canonical::Decimal(_))
+    }
+
+    /// Children: primitive=0.
+    fn num_children(&self) -> usize {
+        1
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Decimal compression is almost always beneficial (narrowing + primitive compression).
+        CompressionEstimate::AlwaysUse
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // TODO(joe): add support splitting i128/256 buffers into chunks of primitive values
+        // for compression. 2 for i128 and 4 for i256.
+        let decimal = data.array().clone().to_decimal();
+        let decimal = narrowed_decimal(decimal);
+        let validity = decimal.validity()?;
+        let prim = match decimal.values_type() {
+            DecimalType::I8 => PrimitiveArray::new(decimal.buffer::<i8>(), validity),
+            DecimalType::I16 => PrimitiveArray::new(decimal.buffer::<i16>(), validity),
+            DecimalType::I32 => PrimitiveArray::new(decimal.buffer::<i32>(), validity),
+            DecimalType::I64 => PrimitiveArray::new(decimal.buffer::<i64>(), validity),
+            _ => return Ok(decimal.into_array()),
+        };
+
+        let compressed = compressor.compress_child(&prim.into_array(), &ctx, self.id(), 0)?;
+
+        DecimalByteParts::try_new(compressed, decimal.decimal_dtype()).map(|d| d.into_array())
+    }
+}
diff --git a/vortex-btrblocks/src/schemes/float.rs b/vortex-btrblocks/src/schemes/float.rs
new file mode 100644
index 00000000000..e74b130bbd0
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/float.rs
@@ -0,0 +1,487 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Float compression schemes.
+
+use vortex_alp::ALP;
+use vortex_alp::ALPArrayExt;
+use vortex_alp::ALPArraySlotsExt;
+use vortex_alp::ALPRDArrayExt;
+use vortex_alp::ALPRDArrayOwnedExt;
+use vortex_alp::RDEncoder;
+use vortex_alp::alp_encode;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::dtype::PType;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::scheme::ChildSelection;
+use vortex_compressor::scheme::DescendantExclusion;
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+use vortex_sparse::Sparse;
+
+use super::integer::SparseScheme as IntSparseScheme;
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+use crate::SchemeExt;
+use crate::compress_patches;
+use crate::schemes::rle_ancestor_exclusions;
+use crate::schemes::rle_descendant_exclusions;
+
+/// ALP (Adaptive Lossless floating-Point) encoding.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ALPScheme;
+
+/// ALPRD (ALP with Real Double) encoding variant.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ALPRDScheme;
+
+/// Sparse encoding for null-dominated float arrays.
+///
+/// This is the same as the integer `SparseScheme`, but we only use this for null-dominated arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct NullDominatedSparseScheme;
+
+/// Pco (pcodec) compression for floats.
+#[cfg(feature = "pco")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct PcoScheme;
+
+// Re-export builtin schemes from vortex-compressor.
+pub use vortex_compressor::builtins::FloatConstantScheme;
+pub use vortex_compressor::builtins::FloatDictScheme;
+pub use vortex_compressor::builtins::is_float_primitive;
+pub use vortex_compressor::stats::FloatStats;
+
+/// RLE scheme for float arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FloatRLEScheme;
+
+impl Scheme for ALPScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.alp"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    /// Children: encoded_ints=0.
+    fn num_children(&self) -> usize {
+        1
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // ALP encodes floats as integers. Without integer compression afterward, the encoded ints
+        // are the same size.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        // We don't support ALP for f16.
+        if data.array_as_primitive().ptype() == PType::F16 {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let alp_encoded = alp_encode(&data.array_as_primitive(), None)?;
+
+        // Compress the ALP ints.
+        let compressed_alp_ints =
+            compressor.compress_child(alp_encoded.encoded(), &ctx, self.id(), 0)?;
+
+        // Patches are not compressed. They should be infrequent, and if they are not then we want
+        // to keep them linear for easy indexing.
+        let patches = alp_encoded.patches().map(compress_patches).transpose()?;
+
+        Ok(ALP::new(compressed_alp_ints, alp_encoded.exponents(), patches).into_array())
+    }
+}
+
+impl Scheme for ALPRDScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.alprd"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // We don't support ALPRD for f16.
+        if data.array_as_primitive().ptype() == PType::F16 {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let primitive_array = data.array_as_primitive();
+
+        let encoder = match primitive_array.ptype() {
+            PType::F32 => RDEncoder::new(primitive_array.as_slice::<f32>()),
+            PType::F64 => RDEncoder::new(primitive_array.as_slice::<f64>()),
+            ptype => vortex_panic!("cannot ALPRD compress ptype {ptype}"),
+        };
+
+        let alp_rd = encoder.encode(&primitive_array);
+        let dtype = alp_rd.dtype().clone();
+        let right_bit_width = alp_rd.right_bit_width();
+        let mut parts = ALPRDArrayOwnedExt::into_data_parts(alp_rd);
+        parts.left_parts_patches = parts.left_parts_patches.map(compress_patches).transpose()?;
+
+        Ok(vortex_alp::ALPRD::try_new(
+            dtype,
+            parts.left_parts,
+            parts.left_parts_dictionary,
+            parts.right_parts,
+            right_bit_width,
+            parts.left_parts_patches,
+        )?
+        .into_array())
+    }
+}
+
+impl Scheme for NullDominatedSparseScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.sparse"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    /// Children: indices=0.
+    fn num_children(&self) -> usize {
+        1
+    }
+
+    /// The indices of a null-dominated sparse array should not be sparse-encoded again.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![DescendantExclusion {
+            excluded: IntSparseScheme.id(),
+            children: ChildSelection::All,
+        }]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let len = data.array_len() as f64;
+        let stats = data.float_stats();
+        let value_count = stats.value_count();
+
+        // All-null arrays should be compressed as constant instead anyways.
+        if value_count == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        // If the majority (90%) of values is null, this will compress well.
+        if stats.null_count() as f64 / len > 0.9 {
+            return CompressionEstimate::Ratio(len / value_count as f64);
+        }
+
+        // Otherwise we don't go this route.
+        CompressionEstimate::Skip
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // We pass None as we only run this pathway for NULL-dominated float arrays.
+        let sparse_encoded = Sparse::encode(data.array(), None)?;
+
+        if let Some(sparse) = sparse_encoded.as_opt::<Sparse>() {
+            let indices = sparse.patches().indices().to_primitive().narrow()?;
+            let compressed_indices =
+                compressor.compress_child(&indices.into_array(), &ctx, self.id(), 0)?;
+
+            Sparse::try_new(
+                compressed_indices,
+                sparse.patches().values().clone(),
+                sparse.len(),
+                sparse.fill_scalar().clone(),
+            )
+            .map(|a| a.into_array())
+        } else {
+            Ok(sparse_encoded)
+        }
+    }
+}
+
+#[cfg(feature = "pco")]
+impl Scheme for PcoScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.pco"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        Ok(vortex_pco::Pco::from_primitive(
+            &data.array_as_primitive(),
+            pco::DEFAULT_COMPRESSION_LEVEL,
+            8192,
+        )?
+        .into_array())
+    }
+}
+
+impl Scheme for FloatRLEScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.rle"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    /// Children: values=0, indices=1, offsets=2.
+    fn num_children(&self) -> usize {
+        3
+    }
+
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        rle_descendant_exclusions()
+    }
+
+    fn ancestor_exclusions(&self) -> Vec<vortex_compressor::scheme::AncestorExclusion> {
+        rle_ancestor_exclusions()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // RLE is only useful when we cascade it with another encoding.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        if data.float_stats().average_run_length() < super::integer::RUN_LENGTH_THRESHOLD {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        super::integer::rle_compress(self, compressor, data, ctx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::iter;
+
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::builders::ArrayBuilder;
+    use vortex_array::builders::PrimitiveBuilder;
+    use vortex_array::display::DisplayOptions;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer_mut;
+    use vortex_compressor::CascadingCompressor;
+    use vortex_error::VortexResult;
+    use vortex_fastlanes::RLE;
+
+    use crate::BtrBlocksCompressor;
+    use crate::schemes::float::FloatRLEScheme;
+
+    #[test]
+    fn test_empty() -> VortexResult<()> {
+        let btr = BtrBlocksCompressor::default();
+        let array = PrimitiveArray::new(Buffer::<f32>::empty(), Validity::NonNullable).into_array();
+        let result = btr.compress(&array)?;
+
+        assert!(result.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn test_compress() -> VortexResult<()> {
+        let mut values = buffer_mut![1.0f32; 1024];
+        for i in 0..1024 {
+            values[i] = (i % 50) as f32;
+        }
+
+        let array = values.into_array();
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array)?;
+        assert_eq!(compressed.len(), 1024);
+
+        let display = compressed
+            .display_as(DisplayOptions::MetadataOnly)
+            .to_string()
+            .to_lowercase();
+        assert_eq!(display, "vortex.dict(f32, len=1024)");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_rle_compression() -> VortexResult<()> {
+        let mut values = Vec::new();
+        values.extend(iter::repeat_n(1.5f32, 100));
+        values.extend(iter::repeat_n(2.7f32, 200));
+        values.extend(iter::repeat_n(3.15f32, 150));
+
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+
+        let compressor = CascadingCompressor::new(vec![&FloatRLEScheme]);
+        let compressed = compressor.compress(&array.into_array())?;
+        assert!(compressed.is::<RLE>());
+
+        let expected = Buffer::copy_from(&values).into_array();
+        assert_arrays_eq!(compressed, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_sparse_compression() -> VortexResult<()> {
+        let mut array = PrimitiveBuilder::<f32>::with_capacity(Nullability::Nullable, 100);
+        array.append_value(f32::NAN);
+        array.append_value(-f32::NAN);
+        array.append_value(f32::INFINITY);
+        array.append_value(-f32::INFINITY);
+        array.append_value(0.0f32);
+        array.append_value(-0.0f32);
+        array.append_nulls(90);
+
+        let array = array.finish_into_primitive().into_array();
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array)?;
+        assert_eq!(compressed.len(), 96);
+
+        let display = compressed
+            .display_as(DisplayOptions::MetadataOnly)
+            .to_string()
+            .to_lowercase();
+        assert_eq!(display, "vortex.sparse(f32?, len=96)");
+
+        Ok(())
+    }
+}
+
+/// Tests to verify that each float compression scheme produces the expected encoding.
+#[cfg(test)]
+mod scheme_selection_tests {
+    use vortex_alp::ALP;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::Dict;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::builders::ArrayBuilder;
+    use vortex_array::builders::PrimitiveBuilder;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+
+    use crate::BtrBlocksCompressor;
+
+    #[test]
+    fn test_constant_compressed() -> VortexResult<()> {
+        let values: Vec<f64> = vec![42.5; 100];
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Constant>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_alp_compressed() -> VortexResult<()> {
+        let values: Vec<f64> = (0..1000).map(|i| (i as f64) * 0.01).collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<ALP>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_dict_compressed() -> VortexResult<()> {
+        let distinct_values = [1.1, 2.2, 3.3, 4.4, 5.5];
+        let values: Vec<f64> = (0..1000)
+            .map(|i| distinct_values[i % distinct_values.len()])
+            .collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<ALP>());
+        assert!(compressed.children()[0].is::<Dict>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_null_dominated_compressed() -> VortexResult<()> {
+        let mut builder = PrimitiveBuilder::<f64>::with_capacity(Nullability::Nullable, 100);
+        for i in 0..5 {
+            builder.append_value(i as f64);
+        }
+        builder.append_nulls(95);
+        let array = builder.finish_into_primitive();
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        // Verify the compressed array preserves values.
+        assert_eq!(compressed.len(), 100);
+        Ok(())
+    }
+}
diff --git a/vortex-btrblocks/src/schemes/integer.rs b/vortex-btrblocks/src/schemes/integer.rs
new file mode 100644
index 00000000000..f56b8d478f0
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/integer.rs
@@ -0,0 +1,1171 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Integer compression schemes.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::ToCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::Patched;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::scalar::Scalar;
+use vortex_compressor::builtins::FloatDictScheme;
+use vortex_compressor::builtins::StringDictScheme;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::scheme::AncestorExclusion;
+use vortex_compressor::scheme::ChildSelection;
+use vortex_compressor::scheme::DescendantExclusion;
+#[cfg(feature = "unstable_encodings")]
+use vortex_compressor::scheme::SchemeId;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+use vortex_fastlanes::BitPacked;
+#[cfg(feature = "unstable_encodings")]
+use vortex_fastlanes::Delta;
+use vortex_fastlanes::FoR;
+use vortex_fastlanes::FoRArrayExt;
+use vortex_fastlanes::RLE;
+use vortex_fastlanes::RLEArrayExt;
+use vortex_fastlanes::USE_EXPERIMENTAL_PATCHES;
+use vortex_fastlanes::bitpack_compress::bit_width_histogram;
+use vortex_fastlanes::bitpack_compress::bitpack_encode;
+use vortex_fastlanes::bitpack_compress::find_best_bit_width;
+use vortex_runend::RunEnd;
+use vortex_runend::compress::runend_encode;
+use vortex_sequence::sequence_encode;
+use vortex_sparse::Sparse;
+use vortex_zigzag::ZigZag;
+use vortex_zigzag::ZigZagArrayExt;
+use vortex_zigzag::zigzag_encode;
+
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::GenerateStatsOptions;
+use crate::Scheme;
+use crate::SchemeExt;
+use crate::compress_patches;
+use crate::schemes::rle_ancestor_exclusions;
+use crate::schemes::rle_descendant_exclusions;
+
+/// Frame of Reference encoding.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FoRScheme;
+
+/// ZigZag encoding for negative integers.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ZigZagScheme;
+
+/// BitPacking encoding for non-negative integers.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct BitPackingScheme;
+
+/// Sparse encoding for single-value-dominated arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct SparseScheme;
+
+/// Run-end encoding with end positions.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct RunEndScheme;
+
+/// Sequence encoding for sequential patterns.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct SequenceScheme;
+
+/// Pco (pcodec) compression for integers.
+#[cfg(feature = "pco")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct PcoScheme;
+
+// Re-export builtin schemes from vortex-compressor.
+pub use vortex_compressor::builtins::IntConstantScheme;
+pub use vortex_compressor::builtins::IntDictScheme;
+pub use vortex_compressor::builtins::is_integer_primitive;
+pub use vortex_compressor::stats::IntegerStats;
+
+/// RLE scheme for integer arrays.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct IntRLEScheme;
+
+/// Threshold for the average run length in an array before we consider run-length encoding.
+pub(crate) const RUN_LENGTH_THRESHOLD: u32 = 4;
+
+/// Threshold for the average run length in an array before we consider run-end encoding.
+const RUN_END_THRESHOLD: u32 = 4;
+
+impl Scheme for FoRScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.for"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    /// Dict codes always start at 0, so FoR (which subtracts the min) is a no-op.
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        vec![
+            AncestorExclusion {
+                ancestor: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: FloatDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: StringDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // FoR only subtracts the min. Without further compression (e.g. BitPacking), the output is
+        // the same size.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        let stats = data.integer_stats();
+
+        // Only apply when the min is not already zero.
+        if stats.erased().min_is_zero() {
+            return CompressionEstimate::Skip;
+        }
+
+        // Difference between max and min.
+        let for_bitwidth = match stats.erased().max_minus_min().checked_ilog2() {
+            Some(l) => l + 1,
+            // If max-min == 0, the we should be compressing this as a constant array.
+            None => return CompressionEstimate::Skip,
+        };
+
+        // If BitPacking can be applied (only non-negative values) and FoR doesn't reduce bit width
+        // compared to BitPacking, don't use FoR since it has a small amount of overhead (storing
+        // the reference) for effectively no benefits.
+        if let Some(max_log) = stats
+            .erased()
+            .max_ilog2()
+            // Only skip FoR when min >= 0, otherwise BitPacking can't be applied without ZigZag.
+            .filter(|_| !stats.erased().min_is_negative())
+        {
+            let bitpack_bitwidth = max_log + 1;
+            if for_bitwidth >= bitpack_bitwidth {
+                return CompressionEstimate::Skip;
+            }
+        }
+
+        let full_width: u32 = data
+            .array_as_primitive()
+            .ptype()
+            .bit_width()
+            .try_into()
+            .vortex_expect("bit width must fit in u32");
+
+        CompressionEstimate::Ratio(full_width as f64 / for_bitwidth as f64)
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let primitive = data.array().to_primitive();
+        let for_array = FoR::encode(primitive)?;
+        let biased = for_array.encoded().to_primitive();
+
+        // Immediately bitpack. If any other scheme was preferable, it would be chosen instead
+        // of bitpacking.
+        // NOTE: we could delegate in the future if we had another downstream codec that performs
+        //  as well.
+        let leaf_ctx = ctx.clone().as_leaf();
+        let mut biased_data = ArrayAndStats::new(biased.into_array(), ctx.merged_stats_options());
+        let compressed = BitPackingScheme.compress(compressor, &mut biased_data, leaf_ctx)?;
+
+        // TODO(connor): This should really be `new_unchecked`.
+        let for_compressed = FoR::try_new(compressed, for_array.reference_scalar().clone())?;
+        for_compressed
+            .as_ref()
+            .statistics()
+            .inherit_from(for_array.as_ref().statistics());
+
+        Ok(for_compressed.into_array())
+    }
+}
+
+impl Scheme for ZigZagScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.zigzag"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    /// Children: encoded=0.
+    fn num_children(&self) -> usize {
+        1
+    }
+
+    /// ZigZag is a bijective value transform that preserves cardinality, run patterns, and value
+    /// dominance. If Dict, RunEnd, or Sparse lost on the original array, they will lose on ZigZag's
+    /// output too, so we skip evaluating them.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::All,
+            },
+            DescendantExclusion {
+                excluded: RunEndScheme.id(),
+                children: ChildSelection::All,
+            },
+            DescendantExclusion {
+                excluded: SparseScheme.id(),
+                children: ChildSelection::All,
+            },
+        ]
+    }
+
+    /// Dict codes are unsigned integers (0..cardinality). ZigZag only helps negatives.
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        vec![
+            AncestorExclusion {
+                ancestor: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: FloatDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: StringDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // ZigZag only transforms negative values to positive. Without further compression,
+        // the output is the same size.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        let stats = data.integer_stats();
+
+        // ZigZag is only useful when there are negative values.
+        if !stats.erased().min_is_negative() {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // Zigzag encode the values, then recursively compress the inner values.
+        let zag = zigzag_encode(data.array_as_primitive())?;
+        let encoded = zag.encoded().to_primitive();
+
+        let compressed = compressor.compress_child(&encoded.into_array(), &ctx, self.id(), 0)?;
+
+        tracing::debug!("zigzag output: {}", compressed.encoding_id());
+
+        Ok(ZigZag::try_new(compressed)?.into_array())
+    }
+}
+
+impl Scheme for BitPackingScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.bitpacking"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let stats = data.integer_stats();
+
+        // BitPacking only works for non-negative values.
+        if stats.erased().min_is_negative() {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let primitive_array = data.array_as_primitive();
+
+        let histogram = bit_width_histogram(&primitive_array)?;
+        let bw = find_best_bit_width(primitive_array.ptype(), &histogram)?;
+
+        // If best bw is determined to be the current bit-width, return the original array.
+        if bw as usize == primitive_array.ptype().bit_width() {
+            return Ok(primitive_array.into_array());
+        }
+
+        // Otherwise we can bitpack the array.
+        let packed = bitpack_encode(&primitive_array, bw, Some(&histogram))?;
+
+        let packed_stats = packed.statistics().to_owned();
+        let ptype = packed.dtype().as_ptype();
+        let mut parts = BitPacked::into_parts(packed);
+
+        let array = if *USE_EXPERIMENTAL_PATCHES {
+            let patches = parts.patches.take();
+            // Transpose patches into G-ALP style PatchedArray, wrapping an inner BitPackedArray.
+            let array = BitPacked::try_new(
+                parts.packed,
+                ptype,
+                parts.validity,
+                None,
+                parts.bit_width,
+                parts.len,
+                parts.offset,
+            )?
+            .into_array();
+
+            match patches {
+                None => array,
+                Some(p) => Patched::from_array_and_patches(
+                    array,
+                    &p,
+                    &mut LEGACY_SESSION.create_execution_ctx(),
+                )?
+                .with_stats_set(packed_stats)
+                .into_array(),
+            }
+        } else {
+            // Compress patches and place back into BitPackedArray.
+            let patches = parts.patches.take().map(compress_patches).transpose()?;
+            parts.patches = patches;
+            BitPacked::try_new(
+                parts.packed,
+                ptype,
+                parts.validity,
+                parts.patches,
+                parts.bit_width,
+                parts.len,
+                parts.offset,
+            )?
+            .with_stats_set(packed_stats)
+            .into_array()
+        };
+
+        Ok(array)
+    }
+}
+
+impl Scheme for SparseScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.sparse"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    fn stats_options(&self) -> GenerateStatsOptions {
+        GenerateStatsOptions {
+            count_distinct_values: true,
+        }
+    }
+
+    /// Children: values=0, indices=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    /// Sparse indices (child 1) are monotonically increasing positions with all unique values.
+    /// Dict, RunEnd, RLE, and Sparse are all pointless on such data.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: RunEndScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: IntRLEScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: SparseScheme.id(),
+                children: ChildSelection::One(1),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let len = data.array_len() as f64;
+        let stats = data.integer_stats();
+        let value_count = stats.value_count();
+
+        // All-null arrays should be compressed as constant instead anyways.
+        if value_count == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        // If the majority (90%) of values is null, this will compress well.
+        if stats.null_count() as f64 / len > 0.9 {
+            return CompressionEstimate::Ratio(len / value_count as f64);
+        }
+
+        let (_, most_frequent_count) = stats
+            .erased()
+            .most_frequent_value_and_count()
+            .vortex_expect(
+                "this must be present since `SparseScheme` declared that we need distinct values",
+            );
+
+        // If the most frequent value is the only value, we should compress as constant instead.
+        if most_frequent_count == value_count {
+            return CompressionEstimate::Skip;
+        }
+        debug_assert!(value_count > most_frequent_count);
+
+        // See if the most frequent value accounts for >= 90% of the set values.
+        let freq = most_frequent_count as f64 / value_count as f64;
+        if freq < 0.9 {
+            return CompressionEstimate::Skip;
+        }
+
+        // We only store the positions of the non-top values.
+        CompressionEstimate::Ratio(value_count as f64 / (value_count - most_frequent_count) as f64)
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let len = data.array_len();
+        // TODO(connor): Fight the borrow checker (needs interior mutability)!
+        let stats = data.integer_stats().clone();
+        let array = data.array();
+
+        let (most_frequent_value, most_frequent_count) = stats
+            .erased()
+            .most_frequent_value_and_count()
+            .vortex_expect(
+                "this must be present since `SparseScheme` declared that we need distinct values",
+            );
+
+        if most_frequent_count as usize == len {
+            // If the most frequent value is the only value, we should compress as constant instead.
+            return Ok(ConstantArray::new(
+                Scalar::primitive_value(
+                    most_frequent_value,
+                    most_frequent_value.ptype(),
+                    array.dtype().nullability(),
+                ),
+                len,
+            )
+            .into_array());
+        }
+
+        let sparse_encoded = Sparse::encode(
+            array,
+            Some(Scalar::primitive_value(
+                most_frequent_value,
+                most_frequent_value.ptype(),
+                array.dtype().nullability(),
+            )),
+        )?;
+
+        if let Some(sparse) = sparse_encoded.as_opt::<Sparse>() {
+            let compressed_values = compressor.compress_child(
+                &sparse.patches().values().to_primitive().into_array(),
+                &ctx,
+                self.id(),
+                0,
+            )?;
+
+            let indices = sparse.patches().indices().to_primitive().narrow()?;
+
+            let compressed_indices =
+                compressor.compress_child(&indices.into_array(), &ctx, self.id(), 1)?;
+
+            Sparse::try_new(
+                compressed_indices,
+                compressed_values,
+                sparse.len(),
+                sparse.fill_scalar().clone(),
+            )
+            .map(|a| a.into_array())
+        } else {
+            Ok(sparse_encoded)
+        }
+    }
+}
+
+impl Scheme for RunEndScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.runend"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    /// Children: values=0, ends=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    /// RunEnd ends (child 1) are monotonically increasing positions with all unique values.
+    /// Dict, RunEnd, RLE, and Sparse are all pointless on such data.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: RunEndScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: IntRLEScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: SparseScheme.id(),
+                children: ChildSelection::One(1),
+            },
+        ]
+    }
+
+    /// Dict values (child 0) are all unique by definition, so run-end encoding them is
+    /// pointless. Codes (child 1) can have runs and may benefit from RunEnd.
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        vec![
+            AncestorExclusion {
+                ancestor: IntDictScheme.id(),
+                children: ChildSelection::One(0),
+            },
+            AncestorExclusion {
+                ancestor: FloatDictScheme.id(),
+                children: ChildSelection::One(0),
+            },
+            AncestorExclusion {
+                ancestor: StringDictScheme.id(),
+                children: ChildSelection::One(0),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // If the run length is below the threshold, drop it.
+        if data.integer_stats().average_run_length() < RUN_END_THRESHOLD {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // Run-end encode the ends.
+        let (ends, values) = runend_encode(data.array_as_primitive().as_view());
+
+        let compressed_values =
+            compressor.compress_child(&values.to_primitive().into_array(), &ctx, self.id(), 0)?;
+
+        let compressed_ends = compressor.compress_child(&ends.into_array(), &ctx, self.id(), 1)?;
+
+        // SAFETY: compression doesn't affect invariants.
+        Ok(unsafe {
+            RunEnd::new_unchecked(compressed_ends, compressed_values, 0, data.array_len())
+                .into_array()
+        })
+    }
+}
+
+impl Scheme for SequenceScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.sequence"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    /// Sequence encoding on dictionary codes just adds a layer of indirection without compressing
+    /// the data. Dict codes are compact integers that benefit from BitPacking or FoR, not from
+    /// sequence detection.
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        vec![
+            AncestorExclusion {
+                ancestor: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: FloatDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            AncestorExclusion {
+                ancestor: StringDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // It is pointless checking if a sample is a sequence since it will not correspond to the
+        // entire array.
+        if ctx.is_sample() {
+            return CompressionEstimate::Skip;
+        }
+
+        let stats = data.integer_stats();
+
+        // `SequenceArray` does not support nulls.
+        if stats.null_count() > 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        // If the distinct_values_count was computed, and not all values are unique, then this
+        // cannot be encoded as a sequence array.
+        if stats
+            .distinct_count()
+            .is_some_and(|count| count as usize != data.array_len())
+        {
+            return CompressionEstimate::Skip;
+        }
+
+        // TODO(connor): Why do we sequence encode the whole thing and then throw it away? And then
+        // why do we divide the ratio by 2???
+
+        CompressionEstimate::Estimate(Box::new(|_compressor, data, _ctx| {
+            let Some(encoded) = sequence_encode(&data.array_as_primitive())? else {
+                // If we are unable to sequence encode this array, make sure we skip.
+                return Ok(CompressionEstimate::Skip);
+            };
+
+            // TODO(connor): This doesn't really make sense?
+            // Since two values are required to store base and multiplier the compression ratio is
+            // divided by 2.
+            Ok(CompressionEstimate::Ratio(encoded.len() as f64 / 2.0))
+        }))
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let stats = data.integer_stats();
+
+        if stats.null_count() > 0 {
+            vortex_bail!("sequence encoding does not support nulls");
+        }
+        sequence_encode(&data.array_as_primitive())?
+            .ok_or_else(|| vortex_err!("cannot sequence encode array"))
+    }
+}
+
+#[cfg(feature = "pco")]
+impl Scheme for PcoScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.pco"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        use vortex_array::dtype::PType;
+
+        // Pco does not support I8 or U8.
+        if matches!(data.array_as_primitive().ptype(), PType::I8 | PType::U8) {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        Ok(vortex_pco::Pco::from_primitive(
+            &data.array_as_primitive(),
+            pco::DEFAULT_COMPRESSION_LEVEL,
+            8192,
+        )?
+        .into_array())
+    }
+}
+
+/// Shared compression logic for RLE schemes.
+pub(crate) fn rle_compress(
+    scheme: &dyn Scheme,
+    compressor: &CascadingCompressor,
+    data: &mut ArrayAndStats,
+    ctx: CompressorContext,
+) -> VortexResult<ArrayRef> {
+    let array = data.array_as_primitive();
+    let rle_array = RLE::encode(&array)?;
+
+    let compressed_values = compressor.compress_child(
+        &rle_array.values().to_primitive().into_array(),
+        &ctx,
+        scheme.id(),
+        0,
+    )?;
+
+    // Delta is an unstable encoding, once we deem it stable we can switch over to this always.
+    #[cfg(feature = "unstable_encodings")]
+    let compressed_indices = try_compress_delta(
+        compressor,
+        &rle_array.indices().to_primitive().narrow()?.into_array(),
+        &ctx,
+        scheme.id(),
+        1,
+    )?;
+
+    #[cfg(not(feature = "unstable_encodings"))]
+    let compressed_indices = compressor.compress_child(
+        &rle_array.indices().to_primitive().narrow()?.into_array(),
+        &ctx,
+        scheme.id(),
+        1,
+    )?;
+
+    let compressed_offsets = compressor.compress_child(
+        &rle_array
+            .values_idx_offsets()
+            .to_primitive()
+            .narrow()?
+            .into_array(),
+        &ctx,
+        scheme.id(),
+        2,
+    )?;
+
+    // SAFETY: Recursive compression doesn't affect the invariants.
+    unsafe {
+        Ok(RLE::new_unchecked(
+            compressed_values,
+            compressed_indices,
+            compressed_offsets,
+            rle_array.offset(),
+            rle_array.len(),
+        )
+        .into_array())
+    }
+}
+
+#[cfg(feature = "unstable_encodings")]
+fn try_compress_delta(
+    compressor: &CascadingCompressor,
+    child: &ArrayRef,
+    parent_ctx: &CompressorContext,
+    parent_id: SchemeId,
+    child_index: usize,
+) -> VortexResult<ArrayRef> {
+    let (bases, deltas) =
+        vortex_fastlanes::delta_compress(&child.to_primitive(), &mut compressor.execution_ctx())?;
+
+    let compressed_bases =
+        compressor.compress_child(&bases.into_array(), parent_ctx, parent_id, child_index)?;
+    let compressed_deltas =
+        compressor.compress_child(&deltas.into_array(), parent_ctx, parent_id, child_index)?;
+
+    Delta::try_new(compressed_bases, compressed_deltas, 0, child.len()).map(IntoArray::into_array)
+}
+
+impl Scheme for IntRLEScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.rle"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    /// Children: values=0, indices=1, offsets=2.
+    fn num_children(&self) -> usize {
+        3
+    }
+
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        rle_descendant_exclusions()
+    }
+
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        rle_ancestor_exclusions()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // RLE is only useful when we cascade it with another encoding.
+        if ctx.finished_cascading() {
+            return CompressionEstimate::Skip;
+        }
+
+        if data.integer_stats().average_run_length() < RUN_LENGTH_THRESHOLD {
+            return CompressionEstimate::Skip;
+        }
+
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        rle_compress(self, compressor, data, ctx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::iter;
+
+    use itertools::Itertools;
+    use rand::Rng;
+    use rand::SeedableRng;
+    use rand::rngs::StdRng;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::Dict;
+    use vortex_array::arrays::Masked;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_buffer::BufferMut;
+    use vortex_buffer::buffer;
+    use vortex_compressor::CascadingCompressor;
+    use vortex_error::VortexResult;
+    use vortex_fastlanes::RLE;
+    use vortex_sequence::Sequence;
+
+    use crate::BtrBlocksCompressor;
+    use crate::schemes::integer::IntRLEScheme;
+
+    #[test]
+    fn test_empty() -> VortexResult<()> {
+        // Make sure empty array compression does not fail.
+        let btr = BtrBlocksCompressor::default();
+        let array = PrimitiveArray::new(Buffer::<i32>::empty(), Validity::NonNullable);
+        let result = btr.compress(&array.into_array())?;
+
+        assert!(result.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn test_dict_encodable() -> VortexResult<()> {
+        let mut codes = BufferMut::<i32>::with_capacity(65_535);
+        // Write some runs of length 3 of a handful of different values. Interrupted by some
+        // one-off values.
+
+        let numbers = [0, 10, 50, 100, 1000, 3000]
+            .into_iter()
+            .map(|i| 12340 * i) // must be big enough to not prefer fastlanes.bitpacked
+            .collect_vec();
+
+        let mut rng = StdRng::seed_from_u64(1u64);
+        while codes.len() < 64000 {
+            let run_length = rng.next_u32() % 5;
+            let value = numbers[rng.next_u32() as usize % numbers.len()];
+            for _ in 0..run_length {
+                codes.push(value);
+            }
+        }
+
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&codes.freeze().into_array())?;
+        assert!(compressed.is::<Dict>());
+        Ok(())
+    }
+
+    #[test]
+    fn constant_mostly_nulls() -> VortexResult<()> {
+        let array = PrimitiveArray::new(
+            buffer![189u8, 189, 189, 189, 189, 189, 189, 189, 189, 0, 46],
+            Validity::from_iter(vec![
+                false, false, false, false, false, false, false, false, false, false, true,
+            ]),
+        );
+        let validity = array.validity()?;
+
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+
+        assert!(compressed.is::<Masked>());
+        assert!(compressed.children()[0].is::<Constant>());
+
+        let decoded = compressed;
+        let expected =
+            PrimitiveArray::new(buffer![0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46], validity).into_array();
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn nullable_sequence() -> VortexResult<()> {
+        let values = (0i32..20).step_by(7).collect_vec();
+        let array = PrimitiveArray::from_option_iter(values.clone().into_iter().map(Some));
+
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Sequence>());
+
+        let decoded = compressed;
+        let expected = PrimitiveArray::from_option_iter(values.into_iter().map(Some)).into_array();
+        assert_arrays_eq!(decoded, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_rle_compression() -> VortexResult<()> {
+        let mut values = Vec::new();
+        values.extend(iter::repeat_n(42i32, 100));
+        values.extend(iter::repeat_n(123i32, 200));
+        values.extend(iter::repeat_n(987i32, 150));
+
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let compressor = CascadingCompressor::new(vec![&IntRLEScheme]);
+        let compressed = compressor.compress(&array.into_array())?;
+        assert!(compressed.is::<RLE>());
+
+        let expected = Buffer::copy_from(&values).into_array();
+        assert_arrays_eq!(compressed, expected);
+        Ok(())
+    }
+
+    #[test_with::env(CI)]
+    #[test_with::no_env(VORTEX_SKIP_SLOW_TESTS)]
+    fn compress_large_int() -> VortexResult<()> {
+        const NUM_LISTS: usize = 10_000;
+        const ELEMENTS_PER_LIST: usize = 5_000;
+
+        let prim = (0..NUM_LISTS)
+            .flat_map(|list_idx| {
+                (0..ELEMENTS_PER_LIST).map(move |elem_idx| (list_idx * 1000 + elem_idx) as f64)
+            })
+            .collect::<PrimitiveArray>()
+            .into_array();
+
+        let btr = BtrBlocksCompressor::default();
+        btr.compress(&prim)?;
+
+        Ok(())
+    }
+}
+
+/// Tests to verify that each integer compression scheme produces the expected encoding.
+#[cfg(test)]
+mod scheme_selection_tests {
+    use std::iter;
+
+    use rand::Rng;
+    use rand::SeedableRng;
+    use rand::rngs::StdRng;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::Dict;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::expr::stats::Precision;
+    use vortex_array::expr::stats::Stat;
+    use vortex_array::expr::stats::StatsProviderExt;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+    use vortex_fastlanes::BitPacked;
+    use vortex_fastlanes::FoR;
+    use vortex_runend::RunEnd;
+    use vortex_sequence::Sequence;
+    use vortex_sparse::Sparse;
+
+    use crate::BtrBlocksCompressor;
+
+    #[test]
+    fn test_constant_compressed() -> VortexResult<()> {
+        let values: Vec<i32> = iter::repeat_n(42, 100).collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Constant>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_for_compressed() -> VortexResult<()> {
+        let values: Vec<i32> = (0..1000).map(|i| 1_000_000 + ((i * 37) % 100)).collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<FoR>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_bitpacking_compressed() -> VortexResult<()> {
+        let values: Vec<u32> = (0..1000).map(|i| i % 16).collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<BitPacked>());
+        assert_eq!(
+            compressed.statistics().get_as::<u64>(Stat::NullCount),
+            Some(Precision::exact(0u64))
+        );
+        assert_eq!(
+            compressed.statistics().get_as::<u32>(Stat::Min),
+            Some(Precision::exact(0u32))
+        );
+        assert_eq!(
+            compressed.statistics().get_as::<u32>(Stat::Max),
+            Some(Precision::exact(15u32))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_sparse_compressed() -> VortexResult<()> {
+        let mut values: Vec<i32> = Vec::new();
+        for i in 0..1000 {
+            if i % 20 == 0 {
+                values.push(2_000_000 + (i * 7) % 1000);
+            } else {
+                values.push(1_000_000);
+            }
+        }
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Sparse>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_dict_compressed() -> VortexResult<()> {
+        let mut codes = Vec::with_capacity(65_535);
+        let numbers: Vec<i32> = [0, 10, 50, 100, 1000, 3000]
+            .into_iter()
+            .map(|i| 12340 * i) // must be big enough to not prefer fastlanes.bitpacked
+            .collect();
+
+        let mut rng = StdRng::seed_from_u64(1u64);
+        while codes.len() < 64000 {
+            let run_length = rng.next_u32() % 5;
+            let value = numbers[rng.next_u32() as usize % numbers.len()];
+            for _ in 0..run_length {
+                codes.push(value);
+            }
+        }
+
+        let array = PrimitiveArray::new(Buffer::copy_from(&codes), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Dict>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_runend_compressed() -> VortexResult<()> {
+        let mut values: Vec<i32> = Vec::new();
+        for i in 0..100 {
+            values.extend(iter::repeat_n((i32::MAX - 50).wrapping_add(i), 10));
+        }
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<RunEnd>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_sequence_compressed() -> VortexResult<()> {
+        let values: Vec<i32> = (0..1000).map(|i| i * 7).collect();
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        assert!(compressed.is::<Sequence>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_rle_compressed() -> VortexResult<()> {
+        let mut values: Vec<i32> = Vec::new();
+        for i in 0..1024 {
+            values.extend(iter::repeat_n(i, 10));
+        }
+        let array = PrimitiveArray::new(Buffer::copy_from(&values), Validity::NonNullable);
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array.into_array())?;
+        eprintln!("{}", compressed.display_tree());
+        assert!(compressed.is::<RunEnd>());
+        Ok(())
+    }
+}
diff --git a/vortex-btrblocks/src/schemes/mod.rs b/vortex-btrblocks/src/schemes/mod.rs
new file mode 100644
index 00000000000..36dcaade4cf
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/mod.rs
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compression scheme implementations.
+
+pub mod bool;
+pub mod float;
+pub mod integer;
+pub mod string;
+
+pub mod decimal;
+pub mod temporal;
+
+pub(crate) mod patches;
+
+use vortex_compressor::builtins::FloatDictScheme;
+use vortex_compressor::builtins::IntDictScheme;
+use vortex_compressor::builtins::StringDictScheme;
+use vortex_compressor::scheme::AncestorExclusion;
+use vortex_compressor::scheme::ChildSelection;
+use vortex_compressor::scheme::DescendantExclusion;
+use vortex_compressor::scheme::SchemeExt;
+
+use crate::schemes::integer::SparseScheme;
+
+/// Shared descendant exclusion rules for RLE schemes.
+///
+/// RLE indices (child 1) and offsets (child 2) are monotonically increasing positions with all
+/// unique values. Dict and Sparse are pointless on such data. Self-exclusion already prevents
+/// RLE on RLE children.
+fn rle_descendant_exclusions() -> Vec<DescendantExclusion> {
+    vec![
+        DescendantExclusion {
+            excluded: IntDictScheme.id(),
+            children: ChildSelection::Many(&[1, 2]),
+        },
+        // TODO(connor): This is wrong for some reason?
+        // DescendantExclusion {
+        //     excluded: RunEndScheme.id(),
+        //     children: ChildSelection::Many(&[1, 2]),
+        // },
+        DescendantExclusion {
+            excluded: SparseScheme.id(),
+            children: ChildSelection::Many(&[1, 2]),
+        },
+    ]
+}
+
+/// Shared ancestor exclusion rules for RLE schemes.
+///
+/// Dict values (child 0) are all unique by definition, so RLE is pointless on them.
+fn rle_ancestor_exclusions() -> Vec<AncestorExclusion> {
+    vec![
+        AncestorExclusion {
+            ancestor: IntDictScheme.id(),
+            children: ChildSelection::One(0),
+        },
+        AncestorExclusion {
+            ancestor: FloatDictScheme.id(),
+            children: ChildSelection::One(0),
+        },
+        AncestorExclusion {
+            ancestor: StringDictScheme.id(),
+            children: ChildSelection::One(0),
+        },
+    ]
+}
diff --git a/vortex-btrblocks/src/compressor/patches.rs b/vortex-btrblocks/src/schemes/patches.rs
similarity index 68%
rename from vortex-btrblocks/src/compressor/patches.rs
rename to vortex-btrblocks/src/schemes/patches.rs
index 9890ab7bd07..8a82058ddb7 100644
--- a/vortex-btrblocks/src/compressor/patches.rs
+++ b/vortex-btrblocks/src/schemes/patches.rs
@@ -1,15 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex_array::Array;
+use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
 use vortex_array::patches::Patches;
+use vortex_error::VortexError;
 use vortex_error::VortexResult;
 
 /// Compresses the given patches by downscaling integers and checking for constant values.
-pub fn compress_patches(patches: &Patches) -> VortexResult<Patches> {
+pub fn compress_patches(patches: Patches) -> VortexResult<Patches> {
     // Downscale the patch indices.
     let indices = patches.indices().to_primitive().narrow()?.into_array();
 
@@ -24,13 +26,17 @@ pub fn compress_patches(patches: &Patches) -> VortexResult<Patches> {
     } else {
         values.clone()
     };
+    let chunk_offsets = patches
+        .chunk_offsets()
+        .as_ref()
+        .map(|offsets| Ok::<ArrayRef, VortexError>(offsets.to_primitive().narrow()?.into_array()))
+        .transpose()?;
 
     Patches::new(
         patches.array_len(),
         patches.offset(),
         indices,
         values,
-        // TODO(0ax1): chunk offsets
-        None,
+        chunk_offsets,
     )
 }
diff --git a/vortex-btrblocks/src/schemes/string.rs b/vortex-btrblocks/src/schemes/string.rs
new file mode 100644
index 00000000000..7aec016534e
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/string.rs
@@ -0,0 +1,378 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! String compression schemes.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::arrays::varbin::VarBinArrayExt;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::scheme::ChildSelection;
+use vortex_compressor::scheme::DescendantExclusion;
+use vortex_error::VortexResult;
+use vortex_fsst::FSST;
+use vortex_fsst::FSSTArrayExt;
+use vortex_fsst::fsst_compress;
+use vortex_fsst::fsst_train_compressor;
+use vortex_sparse::Sparse;
+
+use super::integer::IntDictScheme;
+use super::integer::SparseScheme as IntSparseScheme;
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+use crate::SchemeExt;
+
+/// FSST (Fast Static Symbol Table) compression.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FSSTScheme;
+
+/// Sparse encoding for null-dominated arrays.
+///
+/// This is the same as the integer `SparseScheme`, but we only use this for null-dominated arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct NullDominatedSparseScheme;
+
+/// Zstd compression without dictionaries (nvCOMP compatible).
+#[cfg(feature = "zstd")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ZstdScheme;
+
+/// Zstd buffer-level compression preserving array layout for GPU decompression.
+#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ZstdBuffersScheme;
+
+// Re-export builtin schemes from vortex-compressor.
+pub use vortex_compressor::builtins::StringConstantScheme;
+pub use vortex_compressor::builtins::StringDictScheme;
+pub use vortex_compressor::builtins::is_utf8_string;
+pub use vortex_compressor::stats::StringStats;
+
+impl Scheme for FSSTScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.fsst"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    /// Children: lengths=0, code_offsets=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let utf8 = data.array_as_utf8();
+        let compressor_fsst = fsst_train_compressor(&utf8);
+        let fsst = fsst_compress(&utf8, utf8.len(), utf8.dtype(), &compressor_fsst);
+
+        let compressed_original_lengths = compressor.compress_child(
+            &fsst
+                .uncompressed_lengths()
+                .to_primitive()
+                .narrow()?
+                .into_array(),
+            &ctx,
+            self.id(),
+            0,
+        )?;
+
+        let compressed_codes_offsets = compressor.compress_child(
+            &fsst.codes().offsets().to_primitive().narrow()?.into_array(),
+            &ctx,
+            self.id(),
+            1,
+        )?;
+        let compressed_codes = VarBinArray::try_new(
+            compressed_codes_offsets,
+            fsst.codes().bytes().clone(),
+            fsst.codes().dtype().clone(),
+            fsst.codes().validity()?,
+        )?;
+
+        let fsst = FSST::try_new(
+            fsst.dtype().clone(),
+            fsst.symbols().clone(),
+            fsst.symbol_lengths().clone(),
+            compressed_codes,
+            compressed_original_lengths,
+        )?;
+
+        Ok(fsst.into_array())
+    }
+}
+
+impl Scheme for NullDominatedSparseScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.sparse"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    /// Children: indices=0.
+    fn num_children(&self) -> usize {
+        1
+    }
+
+    /// The indices of a null-dominated sparse array should not be sparse-encoded again.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![
+            DescendantExclusion {
+                excluded: IntSparseScheme.id(),
+                children: ChildSelection::All,
+            },
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::All,
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let len = data.array_len() as f64;
+        let stats = data.string_stats();
+        let value_count = stats.value_count();
+
+        // All-null arrays should be compressed as constant instead anyways.
+        if value_count == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        // If the majority (90%) of values is null, this will compress well.
+        if stats.null_count() as f64 / len > 0.9 {
+            return CompressionEstimate::Ratio(len / value_count as f64);
+        }
+
+        // Otherwise we don't go this route.
+        CompressionEstimate::Skip
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // We pass None as we only run this pathway for NULL-dominated string arrays.
+        let sparse_encoded = Sparse::encode(data.array(), None)?;
+
+        if let Some(sparse) = sparse_encoded.as_opt::<Sparse>() {
+            // Compress the indices only (not the values for strings).
+            let indices = sparse.patches().indices().to_primitive().narrow()?;
+            let compressed_indices =
+                compressor.compress_child(&indices.into_array(), &ctx, self.id(), 0)?;
+
+            Sparse::try_new(
+                compressed_indices,
+                sparse.patches().values().clone(),
+                sparse.len(),
+                sparse.fill_scalar().clone(),
+            )
+            .map(|a| a.into_array())
+        } else {
+            Ok(sparse_encoded)
+        }
+    }
+}
+
+#[cfg(feature = "zstd")]
+impl Scheme for ZstdScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.zstd"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let compacted = data.array_as_utf8().compact_buffers()?;
+        Ok(vortex_zstd::Zstd::from_var_bin_view_without_dict(&compacted, 3, 8192)?.into_array())
+    }
+}
+
+#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+impl Scheme for ZstdBuffersScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.zstd_buffers"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        Ok(
+            vortex_zstd::ZstdBuffers::compress(data.array(), 3, &vortex_array::LEGACY_SESSION)?
+                .into_array(),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::builders::ArrayBuilder;
+    use vortex_array::builders::VarBinViewBuilder;
+    use vortex_array::display::DisplayOptions;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_error::VortexResult;
+
+    use crate::BtrBlocksCompressor;
+
+    #[test]
+    fn test_strings() -> VortexResult<()> {
+        let mut strings = Vec::new();
+        for _ in 0..1024 {
+            strings.push(Some("hello-world-1234"));
+        }
+        for _ in 0..1024 {
+            strings.push(Some("hello-world-56789"));
+        }
+        let strings = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
+
+        let array_ref = strings.into_array();
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array_ref)?;
+        assert_eq!(compressed.len(), 2048);
+
+        let display = compressed
+            .display_as(DisplayOptions::MetadataOnly)
+            .to_string()
+            .to_lowercase();
+        assert_eq!(display, "vortex.dict(utf8, len=2048)");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_sparse_nulls() -> VortexResult<()> {
+        let mut strings = VarBinViewBuilder::with_capacity(DType::Utf8(Nullability::Nullable), 100);
+        strings.append_nulls(99);
+
+        strings.append_value("one little string");
+
+        let strings = strings.finish_into_varbinview();
+
+        let array_ref = strings.into_array();
+        let btr = BtrBlocksCompressor::default();
+        let compressed = btr.compress(&array_ref)?;
+        assert_eq!(compressed.len(), 100);
+
+        let display = compressed
+            .display_as(DisplayOptions::MetadataOnly)
+            .to_string()
+            .to_lowercase();
+        assert_eq!(display, "vortex.sparse(utf8?, len=100)");
+
+        Ok(())
+    }
+}
+
+/// Tests to verify that each string compression scheme produces the expected encoding.
+#[cfg(test)]
+mod scheme_selection_tests {
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::Dict;
+    use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_error::VortexResult;
+    use vortex_fsst::FSST;
+
+    use crate::BtrBlocksCompressor;
+
+    #[test]
+    fn test_constant_compressed() -> VortexResult<()> {
+        let strings: Vec<Option<&str>> = vec![Some("constant_value"); 100];
+        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
+        let array_ref = array.into_array();
+        let compressed = BtrBlocksCompressor::default().compress(&array_ref)?;
+        assert!(compressed.is::<Constant>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_dict_compressed() -> VortexResult<()> {
+        let distinct_values = ["apple", "banana", "cherry"];
+        let mut strings = Vec::with_capacity(1000);
+        for i in 0..1000 {
+            strings.push(Some(distinct_values[i % 3]));
+        }
+        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
+        let array_ref = array.into_array();
+        let compressed = BtrBlocksCompressor::default().compress(&array_ref)?;
+        assert!(compressed.is::<Dict>());
+        Ok(())
+    }
+
+    #[test]
+    fn test_fsst_compressed() -> VortexResult<()> {
+        let mut strings = Vec::with_capacity(1000);
+        for i in 0..1000 {
+            strings.push(Some(format!(
+                "this_is_a_common_prefix_with_some_variation_{i}_and_a_common_suffix_pattern"
+            )));
+        }
+        let array = VarBinViewArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
+        let array_ref = array.into_array();
+        let compressed = BtrBlocksCompressor::default().compress(&array_ref)?;
+        assert!(compressed.is::<FSST>());
+        Ok(())
+    }
+}
diff --git a/vortex-btrblocks/src/schemes/temporal.rs b/vortex-btrblocks/src/schemes/temporal.rs
new file mode 100644
index 00000000000..306ccaf982d
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/temporal.rs
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Temporal compression scheme using datetime-part decomposition.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::ToCanonical;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::TemporalArray;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::dtype::extension::Matcher;
+use vortex_array::extension::datetime::AnyTemporal;
+use vortex_array::extension::datetime::TemporalMetadata;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_datetime_parts::DateTimeParts;
+use vortex_datetime_parts::TemporalParts;
+use vortex_datetime_parts::split_temporal;
+use vortex_error::VortexResult;
+
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+use crate::SchemeExt;
+
+/// Compression scheme for temporal timestamp arrays via datetime-part decomposition.
+///
+/// Splits timestamps into days, seconds, and subseconds components, compresses each
+/// independently, and wraps the result in a `DateTimePartsArray`.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TemporalScheme;
+
+impl Scheme for TemporalScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.ext.temporal"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        let Canonical::Extension(ext) = canonical else {
+            return false;
+        };
+
+        let ext_dtype = ext.ext_dtype();
+
+        matches!(
+            AnyTemporal::try_match(ext_dtype),
+            Some(TemporalMetadata::Timestamp(..))
+        )
+    }
+
+    /// Children: days=0, seconds=1, subseconds=2.
+    fn num_children(&self) -> usize {
+        3
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Temporal compression (splitting into parts) is almost always beneficial.
+        CompressionEstimate::AlwaysUse
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let array = data.array().clone();
+        let ext_array = array.to_extension();
+        let temporal_array = TemporalArray::try_from(ext_array.clone().into_array())?;
+
+        // Check for constant array and return early if so.
+        let is_constant = is_constant(
+            &ext_array.clone().into_array(),
+            &mut compressor.execution_ctx(),
+        )?;
+
+        if is_constant {
+            return Ok(ConstantArray::new(ext_array.scalar_at(0)?, ext_array.len()).into_array());
+        }
+
+        let dtype = temporal_array.dtype().clone();
+        let TemporalParts {
+            days,
+            seconds,
+            subseconds,
+        } = split_temporal(temporal_array)?;
+
+        let days = compressor.compress_child(
+            &days.to_primitive().narrow()?.into_array(),
+            &ctx,
+            self.id(),
+            0,
+        )?;
+        let seconds = compressor.compress_child(
+            &seconds.to_primitive().narrow()?.into_array(),
+            &ctx,
+            self.id(),
+            1,
+        )?;
+        let subseconds = compressor.compress_child(
+            &subseconds.to_primitive().narrow()?.into_array(),
+            &ctx,
+            self.id(),
+            2,
+        )?;
+
+        Ok(DateTimeParts::try_new(dtype, days, seconds, subseconds)?.into_array())
+    }
+}
diff --git a/vortex-btrblocks/src/stats.rs b/vortex-btrblocks/src/stats.rs
deleted file mode 100644
index b3e25cfb8d6..00000000000
--- a/vortex-btrblocks/src/stats.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Compression statistics types.
-
-use std::fmt::Debug;
-
-use vortex_array::vtable::VTable;
-
-/// Configures how stats are generated.
-pub struct GenerateStatsOptions {
-    /// Should distinct values should be counted during stats generation.
-    pub count_distinct_values: bool,
-    // pub count_runs: bool,
-    // should this be scheme-specific?
-}
-
-impl Default for GenerateStatsOptions {
-    fn default() -> Self {
-        Self {
-            count_distinct_values: true,
-            // count_runs: true,
-        }
-    }
-}
-
-/// The size of each sampled run.
-pub(crate) const SAMPLE_SIZE: u32 = 64;
-/// The number of sampled runs.
-///
-/// # Warning
-///
-/// The product of SAMPLE_SIZE and SAMPLE_COUNT should be (roughly) a multiple of 1024 so that
-/// fastlanes bitpacking of sampled vectors does not introduce (large amounts of) padding.
-pub(crate) const SAMPLE_COUNT: u32 = 16;
-
-/// Stats for the compressor.
-pub trait CompressorStats: Debug + Clone {
-    /// The type of the underlying source array vtable.
-    type ArrayVTable: VTable;
-
-    /// Generates stats with default options.
-    fn generate(input: &<Self::ArrayVTable as VTable>::Array) -> Self {
-        Self::generate_opts(input, GenerateStatsOptions::default())
-    }
-
-    /// Generates stats with provided options.
-    fn generate_opts(
-        input: &<Self::ArrayVTable as VTable>::Array,
-        opts: GenerateStatsOptions,
-    ) -> Self;
-
-    /// Returns the underlying source array that statistics were generated from.
-    fn source(&self) -> &<Self::ArrayVTable as VTable>::Array;
-
-    /// Sample the array with default options.
-    fn sample(&self, sample_size: u32, sample_count: u32) -> Self {
-        self.sample_opts(sample_size, sample_count, GenerateStatsOptions::default())
-    }
-
-    /// Sample the array with provided options.
-    fn sample_opts(&self, sample_size: u32, sample_count: u32, opts: GenerateStatsOptions) -> Self;
-}
diff --git a/vortex-buffer/benches/vortex_bitbuffer.rs b/vortex-buffer/benches/vortex_bitbuffer.rs
index cc84bf2c2e6..807f890b706 100644
--- a/vortex-buffer/benches/vortex_bitbuffer.rs
+++ b/vortex-buffer/benches/vortex_bitbuffer.rs
@@ -12,6 +12,15 @@ use vortex_buffer::BitBuffer;
 use vortex_buffer::BitBufferMut;
 
 fn main() {
+    // Pre-warm CPUID feature detection so the one-time probe cost is never
+    // included in any benchmark iteration.
+    #[cfg(target_arch = "x86_64")]
+    {
+        let _ = is_x86_feature_detected!("avx2");
+        let _ = is_x86_feature_detected!("avx512f");
+        let _ = is_x86_feature_detected!("avx512vpopcntdq");
+    }
+
     divan::main();
 }
 
@@ -26,6 +35,11 @@ impl FromIterator<bool> for Arrow<BooleanBuffer> {
 
 const INPUT_SIZE: &[usize] = &[128, 1024, 2048, 16_384, 65_536];
 
+#[inline]
+fn true_count_pattern(i: usize) -> bool {
+    (i.is_multiple_of(3)) ^ (i.is_multiple_of(11))
+}
+
 #[cfg(not(codspeed))]
 #[divan::bench(args = INPUT_SIZE)]
 fn from_iter_arrow(n: usize) {
@@ -160,7 +174,8 @@ fn slice_arrow_buffer(bencher: Bencher, length: usize) {
 
 #[divan::bench(args = INPUT_SIZE)]
 fn true_count_vortex_buffer(bencher: Bencher, length: usize) {
-    let buffer = BitBuffer::from_iter((0..length).map(|i| i % 2 == 0));
+    let buffer = BitBuffer::from_iter((0..length).map(true_count_pattern));
+
     bencher
         .with_inputs(|| &buffer)
         .bench_refs(|buffer| buffer.true_count())
@@ -168,7 +183,12 @@ fn true_count_vortex_buffer(bencher: Bencher, length: usize) {
 
 #[divan::bench(args = INPUT_SIZE)]
 fn true_count_arrow_buffer(bencher: Bencher, length: usize) {
-    let buffer = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
+    let buffer = Arrow(BooleanBuffer::from_iter(
+        (0..length).map(true_count_pattern),
+    ));
+
+    buffer.0.count_set_bits();
+
     bencher
         .with_inputs(|| &buffer)
         .bench_refs(|buffer| buffer.0.count_set_bits());
diff --git a/vortex-buffer/benches/vortex_buffer.rs b/vortex-buffer/benches/vortex_buffer.rs
index 712890a5a4a..1fc28023c75 100644
--- a/vortex-buffer/benches/vortex_buffer.rs
+++ b/vortex-buffer/benches/vortex_buffer.rs
@@ -73,6 +73,17 @@ impl<T: ArrowNativeType, R: ArrowNativeType> MapEach<T, R> for Arrow<ScalarBuffe
     }
 }
 
+impl<T: Copy, R> MapEach<T, R> for Buffer<T> {
+    type Output = BufferMut<R>;
+
+    fn map_each<F>(self, f: F) -> Self::Output
+    where
+        F: FnMut(T) -> R,
+    {
+        Buffer::<T>::map_each_in_place(self, f)
+    }
+}
+
 impl<T: Copy, R> MapEach<T, R> for BufferMut<T> {
     type Output = BufferMut<R>;
 
@@ -85,7 +96,7 @@ impl<T: Copy, R> MapEach<T, R> for BufferMut<T> {
 }
 
 #[divan::bench(
-    types = [Arrow<ScalarBuffer<i32>>, BufferMut<i32>],
+    types = [Arrow<ScalarBuffer<i32>>, Buffer<i32>, BufferMut<i32>],
     args = INPUT_SIZE,
 )]
 fn map_each<B: MapEach<i32, u32> + FromIterator<i32>>(bencher: Bencher, n: i32) {
diff --git a/vortex-buffer/public-api.lock b/vortex-buffer/public-api.lock
index 88a389a9af6..29b941c77d4 100644
--- a/vortex-buffer/public-api.lock
+++ b/vortex-buffer/public-api.lock
@@ -14,6 +14,138 @@ pub use vortex_buffer::UnalignedBitChunk
 
 pub use vortex_buffer::UnalignedBitChunkIterator
 
+pub mod vortex_buffer::trusted_len
+
+pub struct vortex_buffer::trusted_len::TrustedLenAdapter<I>
+
+impl<I: core::iter::traits::iterator::Iterator> core::iter::traits::iterator::Iterator for vortex_buffer::trusted_len::TrustedLenAdapter<I>
+
+pub type vortex_buffer::trusted_len::TrustedLenAdapter<I>::Item = <I as core::iter::traits::iterator::Iterator>::Item
+
+pub fn vortex_buffer::trusted_len::TrustedLenAdapter<I>::next(&mut self) -> core::option::Option<Self::Item>
+
+pub fn vortex_buffer::trusted_len::TrustedLenAdapter<I>::size_hint(&self) -> (usize, core::option::Option<usize>)
+
+impl<I: core::iter::traits::iterator::Iterator> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::trusted_len::TrustedLenAdapter<I>
+
+pub unsafe trait vortex_buffer::trusted_len::TrustedLen: core::iter::traits::iterator::Iterator
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<i16>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<i32>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<i64>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<i8>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<u16>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<u32>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<u64>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<u8>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::Range<usize>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<i16>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<i32>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<i64>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<i8>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<u16>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<u32>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<u64>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<u8>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::step_by::StepBy<core::ops::range::RangeInclusive<usize>>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<i16>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<i32>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<i64>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<i8>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<u16>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<u32>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<u64>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<u8>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::Range<usize>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<i16>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<i32>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<i64>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<i8>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<u16>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<u32>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<u64>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<u8>
+
+impl vortex_buffer::trusted_len::TrustedLen for core::ops::range::RangeInclusive<usize>
+
+impl<'a, I, T: 'a, E: 'a> vortex_buffer::trusted_len::TrustedLen for itertools::process_results_impl::ProcessResults<'a, I, E> where I: vortex_buffer::trusted_len::TrustedLen<Item = core::result::Result<T, E>>
+
+impl<'a, I, T> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::cloned::Cloned<I> where I: vortex_buffer::trusted_len::TrustedLen<Item = &'a T>, T: core::clone::Clone + 'a
+
+impl<'a, I, T> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::copied::Copied<I> where I: vortex_buffer::trusted_len::TrustedLen<Item = &'a T>, T: core::marker::Copy + 'a
+
+impl<'a> vortex_buffer::trusted_len::TrustedLen for arrow_buffer::util::bit_chunk_iterator::BitChunkIterator<'a>
+
+impl<'a> vortex_buffer::trusted_len::TrustedLen for arrow_buffer::util::bit_chunk_iterator::UnalignedBitChunkIterator<'a>
+
+impl<'a> vortex_buffer::trusted_len::TrustedLen for arrow_buffer::util::bit_iterator::BitIterator<'a>
+
+impl<B, I, F> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::map::Map<I, F> where I: vortex_buffer::trusted_len::TrustedLen, F: core::ops::function::FnMut(<I as core::iter::traits::iterator::Iterator>::Item) -> B
+
+impl<I, T> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::enumerate::Enumerate<I> where I: vortex_buffer::trusted_len::TrustedLen<Item = T>
+
+impl<I: core::iter::traits::iterator::Iterator> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::trusted_len::TrustedLenAdapter<I>
+
+impl<I> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::skip::Skip<I> where I: vortex_buffer::trusted_len::TrustedLen
+
+impl<T, U> vortex_buffer::trusted_len::TrustedLen for core::iter::adapters::zip::Zip<T, U> where T: vortex_buffer::trusted_len::TrustedLen, U: vortex_buffer::trusted_len::TrustedLen
+
+impl<T, const N: usize> vortex_buffer::trusted_len::TrustedLen for core::array::iter::IntoIter<T, N>
+
+impl<T: core::clone::Clone> vortex_buffer::trusted_len::TrustedLen for core::iter::sources::repeat_n::RepeatN<T>
+
+impl<T: core::marker::Copy> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::BufferIterator<T>
+
+impl<T> vortex_buffer::trusted_len::TrustedLen for alloc::vec::into_iter::IntoIter<T>
+
+impl<T> vortex_buffer::trusted_len::TrustedLen for core::slice::iter::Iter<'_, T>
+
+impl<T> vortex_buffer::trusted_len::TrustedLen for core::slice::iter::IterMut<'_, T>
+
+impl<T> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::Iter<'_, T>
+
+pub trait vortex_buffer::trusted_len::TrustedLenExt: core::iter::traits::iterator::Iterator + core::marker::Sized
+
+pub unsafe fn vortex_buffer::trusted_len::TrustedLenExt::trusted_len(self) -> vortex_buffer::trusted_len::TrustedLenAdapter<Self>
+
+impl<I: core::iter::traits::iterator::Iterator> vortex_buffer::trusted_len::TrustedLenExt for I
+
+pub unsafe fn I::trusted_len(self) -> vortex_buffer::trusted_len::TrustedLenAdapter<Self>
+
 pub macro vortex_buffer::bitbuffer!
 
 pub macro vortex_buffer::bitbuffer_mut!
@@ -170,14 +302,8 @@ impl vortex_buffer::BitBuffer
 
 pub fn vortex_buffer::BitBuffer::into_inner(self) -> (usize, usize, vortex_buffer::ByteBuffer)
 
-pub fn vortex_buffer::BitBuffer::into_mut(self) -> vortex_buffer::BitBufferMut
-
 pub fn vortex_buffer::BitBuffer::try_into_mut(self) -> core::result::Result<vortex_buffer::BitBufferMut, Self>
 
-impl vortex_buffer::BitBuffer
-
-pub fn vortex_buffer::BitBuffer::iter_bit_views<const NB: usize>(&self) -> impl core::iter::traits::iterator::Iterator<Item = vortex_buffer::BitView<'_, NB>> + '_
-
 impl core::clone::Clone for vortex_buffer::BitBuffer
 
 pub fn vortex_buffer::BitBuffer::clone(&self) -> vortex_buffer::BitBuffer
@@ -208,6 +334,10 @@ impl core::fmt::Debug for vortex_buffer::BitBuffer
 
 pub fn vortex_buffer::BitBuffer::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
+impl core::fmt::Display for vortex_buffer::BitBuffer
+
+pub fn vortex_buffer::BitBuffer::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
 impl core::iter::traits::collect::FromIterator<bool> for vortex_buffer::BitBuffer
 
 pub fn vortex_buffer::BitBuffer::from_iter<T: core::iter::traits::collect::IntoIterator<Item = bool>>(iter: T) -> Self
@@ -320,6 +450,10 @@ pub fn vortex_buffer::BitBufferMut::empty() -> Self
 
 pub fn vortex_buffer::BitBufferMut::false_count(&self) -> usize
 
+pub fn vortex_buffer::BitBufferMut::fill_range(&mut self, start: usize, end: usize, value: bool)
+
+pub unsafe fn vortex_buffer::BitBufferMut::fill_range_unchecked(&mut self, start: usize, end: usize, value: bool)
+
 pub fn vortex_buffer::BitBufferMut::freeze(self) -> vortex_buffer::BitBuffer
 
 pub fn vortex_buffer::BitBufferMut::from_buffer(buffer: vortex_buffer::ByteBufferMut, offset: usize, len: usize) -> Self
@@ -372,10 +506,6 @@ pub unsafe fn vortex_buffer::BitBufferMut::value_unchecked(&self, index: usize)
 
 pub fn vortex_buffer::BitBufferMut::with_capacity(capacity: usize) -> Self
 
-impl vortex_buffer::BitBufferMut
-
-pub fn vortex_buffer::BitBufferMut::iter_bit_views<const NB: usize>(&self) -> impl core::iter::traits::iterator::Iterator<Item = vortex_buffer::BitView<'_, NB>> + '_
-
 impl core::clone::Clone for vortex_buffer::BitBufferMut
 
 pub fn vortex_buffer::BitBufferMut::clone(&self) -> vortex_buffer::BitBufferMut
@@ -412,52 +542,6 @@ pub type vortex_buffer::BitBufferMut::Output = vortex_buffer::BitBufferMut
 
 pub fn vortex_buffer::BitBufferMut::not(self) -> Self::Output
 
-pub struct vortex_buffer::BitSlice
-
-pub vortex_buffer::BitSlice::len: usize
-
-pub vortex_buffer::BitSlice::start: usize
-
-pub struct vortex_buffer::BitView<'a, const NB: usize>
-
-impl<'a, const NB: usize> vortex_buffer::BitView<'a, NB>
-
-pub const vortex_buffer::BitView<'a, NB>::N: usize
-
-pub const vortex_buffer::BitView<'a, NB>::N_WORDS: usize
-
-pub fn vortex_buffer::BitView<'a, NB>::as_raw(&self) -> &[u8; NB]
-
-pub fn vortex_buffer::BitView<'a, NB>::from_slice(bits: &'a [u8]) -> Self
-
-pub fn vortex_buffer::BitView<'a, NB>::iter_ones<F>(&self, f: F) where F: core::ops::function::FnMut(usize)
-
-pub fn vortex_buffer::BitView<'a, NB>::iter_slices<F>(&self, f: F) where F: core::ops::function::FnMut(vortex_buffer::BitSlice)
-
-pub fn vortex_buffer::BitView<'a, NB>::iter_words(&self) -> impl core::iter::traits::iterator::Iterator<Item = usize> + '_
-
-pub fn vortex_buffer::BitView<'a, NB>::iter_zeros<F>(&self, f: F) where F: core::ops::function::FnMut(usize)
-
-pub fn vortex_buffer::BitView<'a, NB>::new(bits: &'a [u8; NB]) -> Self
-
-pub fn vortex_buffer::BitView<'a, NB>::new_owned(bits: [u8; NB]) -> Self
-
-pub fn vortex_buffer::BitView<'a, NB>::true_count(&self) -> usize
-
-pub fn vortex_buffer::BitView<'a, NB>::try_iter_ones<F>(&self, f: F) -> vortex_error::VortexResult<()> where F: core::ops::function::FnMut(usize) -> vortex_error::VortexResult<()>
-
-pub fn vortex_buffer::BitView<'a, NB>::with_prefix(n_true: usize) -> Self
-
-impl<const NB: usize> vortex_buffer::BitView<'static, NB>
-
-pub const fn vortex_buffer::BitView<'static, NB>::all_false() -> Self
-
-pub const fn vortex_buffer::BitView<'static, NB>::all_true() -> Self
-
-impl<const NB: usize> core::fmt::Debug for vortex_buffer::BitView<'_, NB>
-
-pub fn vortex_buffer::BitView<'_, NB>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
 pub struct vortex_buffer::Buffer<T>
 
 impl vortex_buffer::Buffer<u8>
@@ -522,6 +606,8 @@ pub fn vortex_buffer::Buffer<T>::iter(&self) -> vortex_buffer::Iter<'_, T>
 
 pub fn vortex_buffer::Buffer<T>::len(&self) -> usize
 
+pub fn vortex_buffer::Buffer<T>::map_each_in_place<R, F>(self, f: F) -> vortex_buffer::BufferMut<R> where T: core::marker::Copy, F: core::ops::function::FnMut(T) -> R
+
 pub fn vortex_buffer::Buffer<T>::slice(&self, range: impl core::ops::range::RangeBounds<usize>) -> Self
 
 pub fn vortex_buffer::Buffer<T>::slice_ref(&self, subset: &[T]) -> Self
@@ -626,7 +712,9 @@ pub type vortex_buffer::Buffer<T>::Target = [T]
 
 pub fn vortex_buffer::Buffer<T>::deref(&self) -> &Self::Target
 
-pub struct vortex_buffer::BufferIterator<T>
+pub struct vortex_buffer::BufferIterator<T: core::marker::Copy>
+
+impl<T: core::marker::Copy> core::iter::traits::exact_size::ExactSizeIterator for vortex_buffer::BufferIterator<T>
 
 impl<T: core::marker::Copy> core::iter::traits::iterator::Iterator for vortex_buffer::BufferIterator<T>
 
@@ -636,6 +724,8 @@ pub fn vortex_buffer::BufferIterator<T>::next(&mut self) -> core::option::Option
 
 pub fn vortex_buffer::BufferIterator<T>::size_hint(&self) -> (usize, core::option::Option<usize>)
 
+impl<T: core::marker::Copy> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::BufferIterator<T>
+
 pub struct vortex_buffer::BufferMut<T>
 
 impl<T> vortex_buffer::BufferMut<T>
@@ -920,6 +1010,8 @@ impl<T> core::iter::traits::exact_size::ExactSizeIterator for vortex_buffer::Ite
 
 pub fn vortex_buffer::Iter<'_, T>::len(&self) -> usize
 
+impl<T> vortex_buffer::trusted_len::TrustedLen for vortex_buffer::Iter<'_, T>
+
 pub const vortex_buffer::ALIGNMENT_TO_HOST_COPY: vortex_buffer::Alignment
 
 pub trait vortex_buffer::AlignedBuf: bytes::buf::buf_impl::Buf
@@ -930,6 +1022,10 @@ pub fn vortex_buffer::AlignedBuf::copy_to_const_aligned<const A: usize>(&mut sel
 
 impl<B: bytes::buf::buf_impl::Buf> vortex_buffer::AlignedBuf for B
 
+pub fn B::copy_to_aligned(&mut self, len: usize, alignment: vortex_buffer::Alignment) -> vortex_buffer::ByteBuffer
+
+pub fn B::copy_to_const_aligned<const A: usize>(&mut self, len: usize) -> vortex_buffer::ConstByteBuffer<A>
+
 pub fn vortex_buffer::get_bit(buf: &[u8], index: usize) -> bool
 
 pub unsafe fn vortex_buffer::get_bit_unchecked(buf: *const u8, index: usize) -> bool
diff --git a/vortex-buffer/src/bit/buf.rs b/vortex-buffer/src/bit/buf.rs
index f0539c839ca..61cc5e30044 100644
--- a/vortex-buffer/src/bit/buf.rs
+++ b/vortex-buffer/src/bit/buf.rs
@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
 use std::ops::BitAnd;
 use std::ops::BitOr;
 use std::ops::BitXor;
@@ -18,6 +21,7 @@ use crate::bit::BitIndexIterator;
 use crate::bit::BitIterator;
 use crate::bit::BitSliceIterator;
 use crate::bit::UnalignedBitChunk;
+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_unary_op;
@@ -35,6 +39,18 @@ pub struct BitBuffer {
     len: usize,
 }
 
+const LIMIT_LEN: usize = 16;
+impl Display for BitBuffer {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        let limit = f.precision().unwrap_or(LIMIT_LEN);
+        let buf: Vec<bool> = self.into_iter().take(limit).collect();
+        f.debug_struct("BitBuffer")
+            .field("len", &self.len)
+            .field("buffer", &buf)
+            .finish()
+    }
+}
+
 impl PartialEq for BitBuffer {
     fn eq(&self, other: &Self) -> bool {
         if self.len != other.len {
@@ -85,7 +101,11 @@ impl BitBuffer {
         // Slice the buffer to ensure the offset is within the first byte
         let byte_offset = offset / 8;
         let offset = offset % 8;
-        let buffer = buffer.slice(byte_offset..);
+        let buffer = if byte_offset != 0 {
+            buffer.slice(byte_offset..)
+        } else {
+            buffer
+        };
 
         Self {
             buffer,
@@ -296,7 +316,7 @@ impl BitBuffer {
 
     /// Get the number of set bits in the buffer.
     pub fn true_count(&self) -> usize {
-        self.unaligned_chunks().count_ones()
+        count_ones(self.buffer.as_slice(), self.offset, self.len)
     }
 
     /// Get the number of unset bits in the buffer.
@@ -327,7 +347,8 @@ impl BitBuffer {
                 self.len,
             );
         }
-        bitwise_unary_op(self, |a| a)
+
+        bitwise_unary_op(self.clone(), |a| a)
     }
 }
 
@@ -346,16 +367,6 @@ impl BitBuffer {
             Err(buffer) => Err(BitBuffer::new_with_offset(buffer, self.len, self.offset)),
         }
     }
-
-    /// Get a mutable version of this `BitBuffer` along with bit offset in the first byte.
-    ///
-    /// If the caller doesn't hold only reference to the underlying buffer, a copy is created.
-    /// The second value of the tuple is a bit_offset of the first value in the first byte
-    pub fn into_mut(self) -> BitBufferMut {
-        let (offset, len, inner) = self.into_inner();
-        // TODO(robert): if we are copying here we could strip offset bits
-        BitBufferMut::from_buffer(inner.into_mut(), offset, len)
-    }
 }
 
 impl From<&[bool]> for BitBuffer {
@@ -379,6 +390,7 @@ impl FromIterator<bool> for BitBuffer {
 impl BitOr for BitBuffer {
     type Output = Self;
 
+    #[inline]
     fn bitor(self, rhs: Self) -> Self::Output {
         BitOr::bitor(&self, &rhs)
     }
@@ -387,6 +399,7 @@ impl BitOr for BitBuffer {
 impl BitOr for &BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitor(self, rhs: Self) -> Self::Output {
         bitwise_binary_op(self, rhs, |a, b| a | b)
     }
@@ -395,6 +408,7 @@ impl BitOr for &BitBuffer {
 impl BitOr<&BitBuffer> for BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitor(self, rhs: &BitBuffer) -> Self::Output {
         (&self).bitor(rhs)
     }
@@ -403,6 +417,7 @@ impl BitOr<&BitBuffer> for BitBuffer {
 impl BitAnd for &BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitand(self, rhs: Self) -> Self::Output {
         bitwise_binary_op(self, rhs, |a, b| a & b)
     }
@@ -411,6 +426,7 @@ impl BitAnd for &BitBuffer {
 impl BitAnd<BitBuffer> for &BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitand(self, rhs: BitBuffer) -> Self::Output {
         self.bitand(&rhs)
     }
@@ -419,6 +435,7 @@ impl BitAnd<BitBuffer> for &BitBuffer {
 impl BitAnd<&BitBuffer> for BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitand(self, rhs: &BitBuffer) -> Self::Output {
         (&self).bitand(rhs)
     }
@@ -427,6 +444,7 @@ impl BitAnd<&BitBuffer> for BitBuffer {
 impl BitAnd<BitBuffer> for BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitand(self, rhs: BitBuffer) -> Self::Output {
         (&self).bitand(&rhs)
     }
@@ -435,22 +453,25 @@ impl BitAnd<BitBuffer> for BitBuffer {
 impl Not for &BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn not(self) -> Self::Output {
-        bitwise_unary_op(self, |a| !a)
+        !self.clone()
     }
 }
 
 impl Not for BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn not(self) -> Self::Output {
-        (&self).not()
+        bitwise_unary_op(self, |a| !a)
     }
 }
 
 impl BitXor for &BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitxor(self, rhs: Self) -> Self::Output {
         bitwise_binary_op(self, rhs, |a, b| a ^ b)
     }
@@ -459,6 +480,7 @@ impl BitXor for &BitBuffer {
 impl BitXor<&BitBuffer> for BitBuffer {
     type Output = BitBuffer;
 
+    #[inline]
     fn bitxor(self, rhs: &BitBuffer) -> Self::Output {
         (&self).bitxor(rhs)
     }
diff --git a/vortex-buffer/src/bit/buf_mut.rs b/vortex-buffer/src/bit/buf_mut.rs
index 5d16c783af9..e0e2f85877d 100644
--- a/vortex-buffer/src/bit/buf_mut.rs
+++ b/vortex-buffer/src/bit/buf_mut.rs
@@ -16,6 +16,61 @@ use crate::bit::set_bit_unchecked;
 use crate::bit::unset_bit_unchecked;
 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) {
+    if start_bit >= end_bit {
+        return;
+    }
+
+    let fill_byte: u8 = if value { 0xFF } else { 0x00 };
+
+    let start_byte = start_bit / 8;
+    let start_rem = start_bit % 8;
+    let end_byte = end_bit / 8;
+    let end_rem = end_bit % 8;
+
+    if start_byte == end_byte {
+        // All bits are in the same byte
+        let mask = ((1u8 << (end_rem - start_rem)) - 1) << start_rem;
+        if value {
+            slice[start_byte] |= mask;
+        } else {
+            slice[start_byte] &= !mask;
+        }
+    } else {
+        // First partial byte
+        if start_rem != 0 {
+            let mask = !((1u8 << start_rem) - 1);
+            if value {
+                slice[start_byte] |= mask;
+            } else {
+                slice[start_byte] &= !mask;
+            }
+        }
+
+        // Middle bytes
+        let fill_start = if start_rem != 0 {
+            start_byte + 1
+        } else {
+            start_byte
+        };
+        if fill_start < end_byte {
+            slice[fill_start..end_byte].fill(fill_byte);
+        }
+
+        // Last partial byte
+        if end_rem != 0 {
+            let mask = (1u8 << end_rem) - 1;
+            if value {
+                slice[end_byte] |= mask;
+            } else {
+                slice[end_byte] &= !mask;
+            }
+        }
+    }
+}
+
 /// A mutable bitset buffer that allows random access to individual bits for set and get.
 ///
 ///
@@ -398,13 +453,13 @@ impl BitBufferMut {
     /// the length will be incremented by `n`.
     ///
     /// Panics if the buffer does not have `n` slots left.
+    #[inline]
     pub fn append_n(&mut self, value: bool, n: usize) {
         if n == 0 {
             return;
         }
 
-        let start_bit_pos = self.offset + self.len;
-        let end_bit_pos = start_bit_pos + n;
+        let end_bit_pos = self.offset + self.len + n;
         let required_bytes = end_bit_pos.div_ceil(8);
 
         // Ensure buffer has enough bytes
@@ -412,58 +467,38 @@ impl BitBufferMut {
             self.buffer.push_n(0x00, required_bytes - self.buffer.len());
         }
 
-        let fill_byte = if value { 0xFF } else { 0x00 };
-
-        // Calculate byte positions
-        let start_byte = start_bit_pos / 8;
-        let start_bit = start_bit_pos % 8;
-        let end_byte = end_bit_pos / 8;
-        let end_bit = end_bit_pos % 8;
-
-        let slice = self.buffer.as_mut_slice();
-
-        if start_byte == end_byte {
-            // All bits are in the same byte
-            let mask = ((1u8 << (end_bit - start_bit)) - 1) << start_bit;
-            if value {
-                slice[start_byte] |= mask;
-            } else {
-                slice[start_byte] &= !mask;
-            }
-        } else {
-            // Fill the first partial byte
-            if start_bit != 0 {
-                let mask = !((1u8 << start_bit) - 1);
-                if value {
-                    slice[start_byte] |= mask;
-                } else {
-                    slice[start_byte] &= !mask;
-                }
-            }
+        let start = self.len;
+        self.len += n;
+        self.fill_range(start, self.len, value);
+    }
 
-            // Fill the complete middle bytes
-            let fill_start = if start_bit != 0 {
-                start_byte + 1
-            } else {
-                start_byte
-            };
-            let fill_end = end_byte;
-            if fill_start < fill_end {
-                slice[fill_start..fill_end].fill(fill_byte);
-            }
+    /// Sets all bits in the range `[start, end)` to `value`.
+    ///
+    /// This operates on an arbitrary range within the existing length of the buffer.
+    /// 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}");
 
-            // Fill the last partial byte
-            if end_bit != 0 {
-                let mask = (1u8 << end_bit) - 1;
-                if value {
-                    slice[end_byte] |= mask;
-                } else {
-                    slice[end_byte] &= !mask;
-                }
-            }
-        }
+        // SAFETY: assertions above guarantee start <= end <= self.len,
+        // so offset + end fits within the buffer.
+        unsafe { self.fill_range_unchecked(start, end, value) }
+    }
 
-        self.len += n;
+    /// Sets all bits in the range `[start, end)` to `value` without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// The 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.as_mut_slice(),
+            self.offset + start,
+            self.offset + end,
+            value,
+        );
     }
 
     /// Append a [`BitBuffer`] to this [`BitBufferMut`]
@@ -612,6 +647,7 @@ impl Default for BitBufferMut {
 impl Not for BitBufferMut {
     type Output = BitBufferMut;
 
+    #[inline]
     fn not(mut self) -> Self::Output {
         ops::bitwise_unary_op_mut(&mut self, |b| !b);
         self
@@ -620,7 +656,7 @@ impl Not for BitBufferMut {
 
 impl From<&[bool]> for BitBufferMut {
     fn from(value: &[bool]) -> Self {
-        BitBuffer::collect_bool(value.len(), |i| value[i]).into_mut()
+        BitBufferMut::collect_bool(value.len(), |i| value[i])
     }
 }
 
@@ -1147,7 +1183,7 @@ mod tests {
         for i in 0..10 {
             let buf = bitbuffer![0 1 0 1 0 1 0 1 0 1];
 
-            let mut buf_mut = buf.clone().into_mut();
+            let mut buf_mut = BitBufferMut::copy_from(&buf);
             assert_eq!(buf_mut.len(), 10);
 
             let tail = buf_mut.split_off(i);
@@ -1165,7 +1201,7 @@ mod tests {
         for i in 0..10 {
             let buf = bitbuffer![0 1 0 1 0 1 0 1 0 1 0 1].slice(2..);
 
-            let mut buf_mut = buf.clone().into_mut();
+            let mut buf_mut = BitBufferMut::copy_from(&buf);
             assert_eq!(buf_mut.len(), 10);
 
             let tail = buf_mut.split_off(i);
diff --git a/vortex-buffer/src/bit/count_ones.rs b/vortex-buffer/src/bit/count_ones.rs
new file mode 100644
index 00000000000..6d70d47cfa7
--- /dev/null
+++ b/vortex-buffer/src/bit/count_ones.rs
@@ -0,0 +1,229 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#[cfg(target_arch = "x86_64")]
+use vortex_error::VortexExpect;
+
+#[inline]
+pub fn count_ones(bytes: &[u8], offset: usize, len: usize) -> usize {
+    if bytes.is_empty() {
+        return 0;
+    }
+
+    let (head, middle, tail) = align_offset_len(bytes, offset, len);
+
+    let mut count = head.map_or(0, |v| v.count_ones() as usize);
+
+    if !middle.is_empty() {
+        count += count_ones_aligned(middle);
+    }
+
+    count + tail.map_or(0, |v| v.count_ones() as usize)
+}
+
+#[inline]
+fn align_offset_len(bytes: &[u8], offset: usize, len: usize) -> (Option<u8>, &[u8], Option<u8>) {
+    let start_byte = offset / 8;
+    let start_bit = offset % 8;
+    let end_bit = offset + len;
+    let end_byte = end_bit / 8;
+    let head = (start_bit != 0).then(|| {
+        let start_len = (8 - start_bit).min(len);
+        mask_byte(bytes[start_byte], start_bit, start_len)
+    });
+
+    let middle_start = start_byte + usize::from(start_bit != 0);
+    let middle_end = end_byte;
+    let middle = if middle_start < middle_end {
+        &bytes[middle_start..middle_end]
+    } else {
+        &[]
+    };
+
+    let consumed = if start_bit != 0 {
+        (8 - start_bit).min(len)
+    } else {
+        0
+    } + middle.len() * 8;
+    let tail_len = len - consumed;
+    let tail = (tail_len != 0).then(|| mask_byte(bytes[middle_end], 0, tail_len));
+
+    (head, middle, tail)
+}
+
+#[inline]
+fn mask_byte(byte: u8, bit_offset: usize, bit_len: usize) -> u8 {
+    debug_assert!(bit_offset < 8);
+    debug_assert!(bit_len <= 8 - bit_offset);
+
+    let shifted = byte >> bit_offset;
+    let mask = if bit_len == 8 {
+        u8::MAX
+    } else {
+        (1u8 << bit_len) - 1
+    };
+
+    shifted & mask
+}
+
+#[inline]
+fn count_ones_aligned(bytes: &[u8]) -> usize {
+    #[cfg(target_arch = "x86_64")]
+    {
+        if bytes.len() >= 64
+            && is_x86_feature_detected!("avx512f")
+            && is_x86_feature_detected!("avx512vpopcntdq")
+        {
+            // SAFETY: Runtime detection guarantees the required target features.
+            return unsafe { count_ones_aligned_avx512(bytes) };
+        }
+
+        if bytes.len() >= 32 && is_x86_feature_detected!("avx2") {
+            // SAFETY: Runtime detection guarantees the required target features.
+            return unsafe { count_ones_aligned_avx2(bytes) };
+        }
+    }
+
+    count_ones_aligned_scalar(bytes)
+}
+
+#[inline]
+fn count_ones_aligned_scalar(bytes: &[u8]) -> usize {
+    let (words, tail) = bytes.as_chunks::<8>();
+    let count = words
+        .iter()
+        .map(|word| u64::from_le_bytes(*word).count_ones() as usize)
+        .sum::<usize>();
+
+    count
+        + tail
+            .iter()
+            .map(|byte| byte.count_ones() as usize)
+            .sum::<usize>()
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2")]
+unsafe fn count_ones_aligned_avx2(bytes: &[u8]) -> usize {
+    use std::arch::x86_64::__m256i;
+    use std::arch::x86_64::_mm256_add_epi8;
+    use std::arch::x86_64::_mm256_add_epi64;
+    use std::arch::x86_64::_mm256_and_si256;
+    use std::arch::x86_64::_mm256_loadu_si256;
+    use std::arch::x86_64::_mm256_sad_epu8;
+    use std::arch::x86_64::_mm256_set1_epi8;
+    use std::arch::x86_64::_mm256_setr_epi8;
+    use std::arch::x86_64::_mm256_setzero_si256;
+    use std::arch::x86_64::_mm256_shuffle_epi8;
+    use std::arch::x86_64::_mm256_srli_epi16;
+    use std::arch::x86_64::_mm256_storeu_si256;
+
+    #[inline]
+    unsafe fn byte_popcount(chunk: __m256i, mask: __m256i, lookup: __m256i) -> __m256i {
+        let lo = unsafe { _mm256_and_si256(chunk, mask) };
+        let hi = unsafe { _mm256_and_si256(_mm256_srli_epi16(chunk, 4), mask) };
+        unsafe {
+            _mm256_add_epi8(
+                _mm256_shuffle_epi8(lookup, lo),
+                _mm256_shuffle_epi8(lookup, hi),
+            )
+        }
+    }
+
+    let lookup = _mm256_setr_epi8(
+        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3,
+        3, 4,
+    );
+    let mask = _mm256_set1_epi8(0x0f);
+    let zero = _mm256_setzero_si256();
+    let mut accum = _mm256_setzero_si256();
+    let mut index = 0;
+
+    while index + 128 <= bytes.len() {
+        for lane in 0..4 {
+            let ptr = unsafe { bytes.as_ptr().add(index + lane * 32) }.cast::<__m256i>();
+            let chunk = unsafe { _mm256_loadu_si256(ptr) };
+            let counts = unsafe { byte_popcount(chunk, mask, lookup) };
+            accum = _mm256_add_epi64(accum, _mm256_sad_epu8(counts, zero));
+        }
+        index += 128;
+    }
+
+    while index + 32 <= bytes.len() {
+        let ptr = unsafe { bytes.as_ptr().add(index) }.cast::<__m256i>();
+        let chunk = unsafe { _mm256_loadu_si256(ptr) };
+        let counts = unsafe { byte_popcount(chunk, mask, lookup) };
+        accum = _mm256_add_epi64(accum, _mm256_sad_epu8(counts, zero));
+        index += 32;
+    }
+
+    let mut lanes = [0u64; 4];
+    unsafe { _mm256_storeu_si256(lanes.as_mut_ptr().cast::<__m256i>(), accum) };
+
+    usize::try_from(lanes.iter().sum::<u64>()).vortex_expect("true_count doesn't fit in usize")
+        + count_ones_aligned_scalar(&bytes[index..])
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx512f,avx512vpopcntdq")]
+unsafe fn count_ones_aligned_avx512(bytes: &[u8]) -> usize {
+    use std::arch::x86_64::__m512i;
+    use std::arch::x86_64::_mm512_add_epi64;
+    use std::arch::x86_64::_mm512_loadu_si512;
+    use std::arch::x86_64::_mm512_popcnt_epi64;
+    use std::arch::x86_64::_mm512_setzero_si512;
+    use std::arch::x86_64::_mm512_storeu_si512;
+
+    let mut accum = _mm512_setzero_si512();
+    let mut index = 0;
+
+    while index + 64 <= bytes.len() {
+        let ptr = unsafe { bytes.as_ptr().add(index) }.cast::<__m512i>();
+        let chunk = unsafe { _mm512_loadu_si512(ptr) };
+        accum = _mm512_add_epi64(accum, _mm512_popcnt_epi64(chunk));
+        index += 64;
+    }
+
+    let mut lanes = [0u64; 8];
+    unsafe { _mm512_storeu_si512(lanes.as_mut_ptr().cast::<__m512i>(), accum) };
+
+    usize::try_from(lanes.iter().sum::<u64>()).vortex_expect("true_count doesn't fit in usize")
+        + count_ones_aligned_scalar(&bytes[index..])
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use crate::BitBuffer;
+
+    #[cfg_attr(miri, ignore)]
+    #[rstest]
+    fn test_count_ones_matches_iteration_for_slices(
+        #[values(
+            0usize, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+            23, 24, 25, 26, 27, 28, 29, 30
+        )]
+        offset: usize,
+        #[values(
+            0usize, 1, 2, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 255, 256, 257, 513
+        )]
+        slice_len: usize,
+    ) {
+        let len = 513;
+        let buf = BitBuffer::collect_bool(len + 31, |i| (i % 3 == 0) ^ (i % 11 == 0));
+
+        if offset + slice_len > buf.len() {
+            return;
+        }
+
+        let sliced = buf.slice(offset..offset + slice_len);
+        let expected = sliced.iter().filter(|bit| *bit).count();
+
+        assert_eq!(
+            sliced.true_count(),
+            expected,
+            "offset={offset} len={slice_len}"
+        );
+    }
+}
diff --git a/vortex-buffer/src/bit/mod.rs b/vortex-buffer/src/bit/mod.rs
index be8c43e7291..034be84a18c 100644
--- a/vortex-buffer/src/bit/mod.rs
+++ b/vortex-buffer/src/bit/mod.rs
@@ -10,9 +10,9 @@
 mod arrow;
 mod buf;
 mod buf_mut;
+mod count_ones;
 mod macros;
 mod ops;
-mod view;
 
 pub use arrow_buffer::bit_chunk_iterator::BitChunkIterator;
 pub use arrow_buffer::bit_chunk_iterator::BitChunks;
@@ -23,7 +23,6 @@ pub use arrow_buffer::bit_iterator::BitIterator;
 pub use arrow_buffer::bit_iterator::BitSliceIterator;
 pub use buf::*;
 pub use buf_mut::*;
-pub use view::*;
 
 /// Get the bit value at `index` out of `buf`.
 ///
diff --git a/vortex-buffer/src/bit/ops.rs b/vortex-buffer/src/bit/ops.rs
index d44224cc1d3..9406c728f06 100644
--- a/vortex-buffer/src/bit/ops.rs
+++ b/vortex-buffer/src/bit/ops.rs
@@ -4,17 +4,57 @@
 use crate::BitBuffer;
 use crate::BitBufferMut;
 use crate::Buffer;
+use crate::ByteBufferMut;
 use crate::trusted_len::TrustedLenExt;
 
-pub(super) fn bitwise_unary_op<F: FnMut(u64) -> u64>(buffer: &BitBuffer, op: F) -> BitBuffer {
-    let iter = buffer.chunks().iter_padded().map(op);
-    let iter = unsafe { iter.trusted_len() };
-
-    let result = Buffer::<u64>::from_trusted_len_iter(iter).into_byte_buffer();
-
-    BitBuffer::new(result, buffer.len())
+#[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) };
+            }
+
+            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) };
+                }
+            }
+
+            // 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)
+        }
+    }
 }
 
+#[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();
 
@@ -54,6 +94,25 @@ pub(super) fn bitwise_binary_op<F: FnMut(u64, u64) -> u64>(
 ) -> BitBuffer {
     assert_eq!(left.len(), right.len());
 
+    // If the buffers are aligned, we can use the fast path.
+    if left.offset().is_multiple_of(8) && right.offset().is_multiple_of(8) {
+        let left_chunks = left.unaligned_chunks();
+        let right_chunks = right.unaligned_chunks();
+        if left_chunks.lead_padding() == 0
+            && left_chunks.trailing_padding() == 0
+            && right_chunks.lead_padding() == 0
+            && right_chunks.trailing_padding() == 0
+        {
+            let iter = left_chunks
+                .iter()
+                .zip(right_chunks.iter())
+                .map(|(l, r)| op(l, r));
+            let iter = unsafe { iter.trusted_len() };
+            let result = Buffer::<u64>::from_trusted_len_iter(iter).into_byte_buffer();
+            return BitBuffer::new(result, left.len());
+        }
+    }
+
     let iter = left
         .chunks()
         .iter_padded()
@@ -68,6 +127,8 @@ pub(super) fn bitwise_binary_op<F: FnMut(u64, u64) -> u64>(
 
 #[cfg(test)]
 mod tests {
+    use std::ops::Not;
+
     use super::*;
     use crate::bitbuffer;
     use crate::buffer;
@@ -75,7 +136,7 @@ mod tests {
     #[test]
     fn test_bitwise_unary_not() {
         let buffer = BitBuffer::new(buffer![0b10101010u8], 4);
-        let result = bitwise_unary_op(&buffer, |x| !x);
+        let result = bitwise_unary_op(buffer, |x| !x);
         assert_eq!(result, bitbuffer![true, false, true, false]);
     }
 
@@ -105,4 +166,26 @@ mod tests {
         let result = bitwise_binary_op(&left, &right, |l, r| l ^ r);
         assert_eq!(result, bitbuffer![false, true, true, false]);
     }
+
+    /// Regression test for a bug where [`bitwise_unary_op`] produced corrupt results when
+    /// the [`BitBuffer`]'s underlying byte pointer was not u64-aligned. Slicing a buffer by
+    /// a non-multiple-of-8 number of bytes can cause this misalignment. The bug only
+    /// manifested for buffers larger than 16 bytes (> 128 bits), because Arrow's
+    /// `UnalignedBitChunk` switches from byte-copying to `align_to` at that threshold.
+    ///
+    /// Issue: <https://github.com/vortex-data/vortex/issues/6895>
+    #[test]
+    fn test_bitwise_unary_not_misaligned_buffer() {
+        // Slice off 1 byte to shift the pointer off u64 alignment. Use 129 bits (17 bytes)
+        // to exceed the 16-byte threshold where `UnalignedBitChunk` uses `align_to`.
+        let padded = BitBuffer::new_set(8 + 129);
+        let buf = padded.slice(8..8 + 129);
+
+        let result = buf.not();
+        assert_eq!(
+            result.true_count(),
+            0,
+            "expected all-false after NOT of all-true"
+        );
+    }
 }
diff --git a/vortex-buffer/src/bit/view.rs b/vortex-buffer/src/bit/view.rs
deleted file mode 100644
index 1b05cd0c123..00000000000
--- a/vortex-buffer/src/bit/view.rs
+++ /dev/null
@@ -1,665 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::borrow::Cow;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::marker::PhantomData;
-
-use vortex_error::VortexResult;
-
-use crate::BitBuffer;
-use crate::BitBufferMut;
-
-/// A borrowed fixed-size mask of length `N` bits.
-///
-/// Since const generic expressions are not yet stable, we instead define the type over the
-/// number of bytes `NB`, and compute `N` as `NB * 8`.
-///
-/// This struct is designed to provide a view over a Vortex [`BitBuffer`], therefore the
-/// bit-ordering is LSB0 (least-significant-bit first).
-///
-/// Note that [`BitView`] does not support an offset. Therefore, bits are assumed to start at
-/// index and end at index `N - 1`.
-pub struct BitView<'a, const NB: usize> {
-    bits: Cow<'a, [u8; NB]>,
-    // TODO(ngates): we may want to expose this for optimizations.
-    // If set to Selection::Prefix, then all true bits are at the start of the array.
-    // selection: Selection,
-    true_count: usize,
-}
-
-impl<const NB: usize> Debug for BitView<'_, NB> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct(&format!("BitView[{}]", NB * 8))
-            .field("true_count", &self.true_count)
-            .field("bits", &self.as_raw())
-            .finish()
-    }
-}
-
-impl<const NB: usize> BitView<'static, NB> {
-    const ALL_TRUE: [u8; NB] = [u8::MAX; NB];
-    const ALL_FALSE: [u8; NB] = [0; NB];
-
-    /// Creates a [`BitView`] with all bits set to `true`.
-    pub const fn all_true() -> Self {
-        unsafe { BitView::new_unchecked(&Self::ALL_TRUE, NB * 8) }
-    }
-
-    /// Creates a [`BitView`] with all bits set to `false`.
-    pub const fn all_false() -> Self {
-        unsafe { BitView::new_unchecked(&Self::ALL_FALSE, 0) }
-    }
-}
-
-impl<'a, const NB: usize> BitView<'a, NB> {
-    /// The number of bits in the view.
-    pub const N: usize = NB * 8;
-    /// The number of machine words in the view.
-    pub const N_WORDS: usize = NB * 8 / (usize::BITS as usize);
-
-    const _ASSERT_MULTIPLE_OF_8: () = assert!(
-        NB.is_multiple_of(8),
-        "NB must be a multiple of 8 for N to be a multiple of 64"
-    );
-
-    /// Creates a [`BitView`] from raw bits, computing the true count.
-    pub fn new(bits: &'a [u8; NB]) -> Self {
-        let ptr = bits.as_ptr().cast::<usize>();
-        let true_count = (0..Self::N_WORDS)
-            .map(|idx| unsafe { ptr.add(idx).read_unaligned().count_ones() as usize })
-            .sum();
-        BitView {
-            bits: Cow::Borrowed(bits),
-            true_count,
-        }
-    }
-
-    /// Creates a [`BitView`] from owned raw bits.
-    pub fn new_owned(bits: [u8; NB]) -> Self {
-        let ptr = bits.as_ptr().cast::<usize>();
-        let true_count = (0..Self::N_WORDS)
-            .map(|idx| unsafe { ptr.add(idx).read_unaligned().count_ones() as usize })
-            .sum();
-        BitView {
-            bits: Cow::Owned(bits),
-            true_count,
-        }
-    }
-
-    /// Creates a [`BitView`] from raw bits and a known true count.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `true_count` is correct for the provided `bits`.
-    pub(crate) const unsafe fn new_unchecked(bits: &'a [u8; NB], true_count: usize) -> Self {
-        BitView {
-            bits: Cow::Borrowed(bits),
-            true_count,
-        }
-    }
-
-    /// Creates a [`BitView`] from a byte slice.
-    ///
-    /// # Panics
-    ///
-    /// If the length of the slice is not equal to `NB`.
-    pub fn from_slice(bits: &'a [u8]) -> Self {
-        assert_eq!(bits.len(), NB);
-        let bits_array = unsafe { &*(bits.as_ptr().cast::<[u8; NB]>()) };
-        BitView::new(bits_array)
-    }
-
-    /// Creates a [`BitView`] from a mutable byte array, populating it with the requested prefix
-    /// of `true` bits.
-    pub fn with_prefix(n_true: usize) -> Self {
-        assert!(n_true <= Self::N);
-
-        // We're going to own our own array of bits
-        let mut bits = [0u8; NB];
-
-        // All-true words first
-        let n_full_words = n_true / (usize::BITS as usize);
-        let remaining_bits = n_true % (usize::BITS as usize);
-
-        let ptr = bits.as_mut_ptr().cast::<usize>();
-
-        // Fill the all-true words
-        for word_idx in 0..n_full_words {
-            unsafe { ptr.add(word_idx).write_unaligned(usize::MAX) };
-        }
-
-        // Fill the remaining bits in the next word
-        if remaining_bits > 0 {
-            let mask = (1usize << remaining_bits) - 1;
-            unsafe { ptr.add(n_full_words).write_unaligned(mask) };
-        }
-
-        Self {
-            bits: Cow::Owned(bits),
-            true_count: n_true,
-        }
-    }
-
-    /// Returns the number of `true` bits in the view.
-    pub fn true_count(&self) -> usize {
-        self.true_count
-    }
-
-    /// Iterate the [`BitView`] in fixed-size words.
-    ///
-    /// The words are loaded using unaligned loads to ensure correct bit ordering.
-    /// For example, bit 0 is located in `word & 1 << 0`, bit 63 is located in `word & 1 << 63`,
-    /// assuming the word size is 64 bits.
-    pub fn iter_words(&self) -> impl Iterator<Item = usize> + '_ {
-        let ptr = self.bits.as_ptr().cast::<usize>();
-        // We use constant N_WORDS to trigger loop unrolling.
-        (0..Self::N_WORDS).map(move |idx| unsafe { ptr.add(idx).read_unaligned() })
-    }
-
-    /// Runs the provided function `f` for each index of a `true` bit in the view.
-    pub fn iter_ones<F>(&self, mut f: F)
-    where
-        F: FnMut(usize),
-    {
-        match self.true_count {
-            0 => {}
-            n if n == Self::N => (0..Self::N).for_each(&mut f),
-            _ => {
-                let mut bit_idx = 0;
-                for mut raw in self.iter_words() {
-                    while raw != 0 {
-                        let bit_pos = raw.trailing_zeros();
-                        f(bit_idx + bit_pos as usize);
-                        raw &= raw - 1; // Clear the bit at `bit_pos`
-                    }
-                    bit_idx += usize::BITS as usize;
-                }
-            }
-        }
-    }
-
-    /// Runs the provided function `f` for each index of a `true` bit in the view.
-    pub fn try_iter_ones<F>(&self, mut f: F) -> VortexResult<()>
-    where
-        F: FnMut(usize) -> VortexResult<()>,
-    {
-        match self.true_count {
-            0 => Ok(()),
-            n if n == Self::N => {
-                for i in 0..Self::N {
-                    f(i)?;
-                }
-                Ok(())
-            }
-            _ => {
-                let mut bit_idx = 0;
-                for mut raw in self.iter_words() {
-                    while raw != 0 {
-                        let bit_pos = raw.trailing_zeros();
-                        f(bit_idx + bit_pos as usize)?;
-                        raw &= raw - 1; // Clear the bit at `bit_pos`
-                    }
-                    bit_idx += usize::BITS as usize;
-                }
-                Ok(())
-            }
-        }
-    }
-
-    /// Runs the provided function `f` for each index of a `true` bit in the view.
-    pub fn iter_zeros<F>(&self, mut f: F)
-    where
-        F: FnMut(usize),
-    {
-        match self.true_count {
-            0 => (0..Self::N).for_each(&mut f),
-            n if n == Self::N => {}
-            _ => {
-                let mut bit_idx = 0;
-                for mut raw in self.iter_words() {
-                    while raw != usize::MAX {
-                        let bit_pos = raw.trailing_ones();
-                        f(bit_idx + bit_pos as usize);
-                        raw |= 1usize << bit_pos; // Set the zero bit to 1
-                    }
-                    bit_idx += usize::BITS as usize;
-                }
-            }
-        }
-    }
-
-    /// Runs the provided function `f` for each range of `true` bits in the view.
-    ///
-    /// The function `f` receives a [`BitSlice`] containing the inclusive `start` bit as well as
-    /// the length.
-    ///
-    /// FIXME(ngates): this is still broken.
-    pub fn iter_slices<F>(&self, mut f: F)
-    where
-        F: FnMut(BitSlice),
-    {
-        if self.true_count == 0 {
-            return;
-        }
-
-        let mut abs_bit_offset: usize = 0; // Absolute bit index of the *current* word being processed
-        let mut slice_start_bit: usize = 0; // Absolute start index of the run of 1s being tracked
-        let mut slice_length: usize = 0; // Accumulated length of the run of 1s
-
-        for mut word in self.iter_words() {
-            match word {
-                0 => {
-                    // If a slice was being tracked, the run ends at the start of this word.
-                    if slice_length > 0 {
-                        f(BitSlice {
-                            start: slice_start_bit,
-                            len: slice_length,
-                        });
-                        slice_length = 0;
-                    }
-                }
-                usize::MAX => {
-                    // If a slice was not already open, it starts at the beginning of this word.
-                    if slice_length == 0 {
-                        slice_start_bit = abs_bit_offset;
-                    }
-                    // Extend the length by a full word (64 bits).
-                    slice_length += usize::BITS as usize;
-                }
-                _ => {
-                    while word != 0 {
-                        // Find the first set bit (start of a run of 1s)
-                        let zeros = word.trailing_zeros() as usize;
-
-                        // If a run was open, and we hit a zero gap, report the finished slice
-                        if slice_length > 0 && zeros > 0 {
-                            f(BitSlice {
-                                start: slice_start_bit,
-                                len: slice_length,
-                            });
-                            slice_length = 0; // Reset state for a new slice
-                        }
-
-                        // Advance past the zeros
-                        word >>= zeros;
-
-                        if word == 0 {
-                            break;
-                        }
-
-                        // Find the contiguous ones (the length of the current run segment)
-                        let ones = word.trailing_ones() as usize;
-
-                        // If slice_length is 0, we found the *absolute* start of a new slice.
-                        if slice_length == 0 {
-                            // Calculate the bit index within the *entire* mask where this run starts
-                            let current_word_idx = abs_bit_offset + zeros;
-                            slice_start_bit = current_word_idx;
-                        }
-
-                        // Accumulate the length of the slice
-                        slice_length += ones;
-
-                        // Advance past the ones
-                        word >>= ones;
-                    }
-                }
-            }
-
-            abs_bit_offset += usize::BITS as usize;
-        }
-
-        if slice_length > 0 {
-            f(BitSlice {
-                start: slice_start_bit,
-                len: slice_length,
-            });
-        }
-    }
-
-    /// Returns the raw bits of the view.
-    pub fn as_raw(&self) -> &[u8; NB] {
-        self.bits.as_ref()
-    }
-}
-
-/// A slice of bits within a [`BitBuffer`].
-///
-/// We use this struct to avoid a common mistake of assuming the slices represent (start, end) ranges,
-pub struct BitSlice {
-    /// The starting bit index of the slice.
-    pub start: usize,
-    /// The length of the slice in bits.
-    pub len: usize,
-}
-
-impl BitBuffer {
-    /// Iterate the buffer as [`BitView`]s of size `NB` where the number of bits in each view
-    /// is `NB * 8`.
-    ///
-    /// The final chunk will be filled with unset padding bits if the bit buffer's length is not
-    /// a multiple of `N`.
-    ///
-    /// The number of bits `N` must be a multiple of 64.
-    ///
-    /// # Panics
-    ///
-    /// If the bit offset is not zero
-    pub fn iter_bit_views<const NB: usize>(&self) -> impl Iterator<Item = BitView<'_, NB>> + '_ {
-        assert_eq!(
-            self.offset(),
-            0,
-            "BitView iteration requires zero bit offset"
-        );
-        BitViewIterator::new(self.inner().as_ref(), self.len())
-    }
-}
-
-impl BitBufferMut {
-    /// Iterate the buffer as [`BitView`]s of size `NB` where the number of bits in each view
-    /// is `NB * 8`.
-    ///
-    /// The final chunk will be filled with unset padding bits if the bit buffer's length is not
-    /// a multiple of `N`.
-    ///
-    /// The number of bits `N` must be a multiple of 64.
-    ///
-    /// # Panics
-    ///
-    /// If the bit offset is not zero
-    pub fn iter_bit_views<const NB: usize>(&self) -> impl Iterator<Item = BitView<'_, NB>> + '_ {
-        assert_eq!(
-            self.offset(),
-            0,
-            "BitView iteration requires zero bit offset"
-        );
-        BitViewIterator::new(self.inner().as_ref(), self.len())
-    }
-}
-
-/// Iterator over fixed-size [`BitView`]s within a byte slice.
-pub(super) struct BitViewIterator<'a, const NB: usize> {
-    bits: &'a [u8],
-    // The index of the view to be returned next
-    view_idx: usize,
-    // The total number of views
-    n_views: usize,
-    // Phantom to capture `NB`
-    _phantom: PhantomData<[u8; NB]>,
-}
-
-impl<'a, const NB: usize> BitViewIterator<'a, NB> {
-    /// Create a new [`BitViewIterator`].
-    fn new(bits: &'a [u8], len: usize) -> Self {
-        debug_assert_eq!(len.div_ceil(8), bits.len());
-        let n_views = bits.len().div_ceil(NB);
-        BitViewIterator {
-            bits,
-            view_idx: 0,
-            n_views,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-impl<'a, const NB: usize> Iterator for BitViewIterator<'a, NB> {
-    type Item = BitView<'a, NB>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.view_idx == self.n_views {
-            return None;
-        }
-
-        let start_byte = self.view_idx * NB;
-        let end_byte = start_byte + NB;
-
-        let bits = if end_byte <= self.bits.len() {
-            // Full view from the original bits
-            BitView::from_slice(&self.bits[start_byte..end_byte])
-        } else {
-            // Partial view, copy to scratch
-            let remaining_bytes = self.bits.len() - start_byte;
-            let mut remaining = [0u8; NB];
-            remaining[..remaining_bytes].copy_from_slice(&self.bits[start_byte..]);
-            BitView::new_owned(remaining)
-        };
-
-        self.view_idx += 1;
-        Some(bits)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const NB: usize = 128; // Number of bytes
-    const N: usize = NB * 8; // Number of bits
-
-    #[test]
-    fn test_iter_ones_empty() {
-        let bits = [0; NB];
-        let view = BitView::<NB>::new(&bits);
-
-        let mut ones = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-
-        assert_eq!(ones, Vec::<usize>::new());
-        assert_eq!(view.true_count(), 0);
-    }
-
-    #[test]
-    fn test_iter_ones_all_set() {
-        let view = BitView::<NB>::all_true();
-
-        let mut ones = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-
-        assert_eq!(ones.len(), N);
-        assert_eq!(ones, (0..N).collect::<Vec<_>>());
-        assert_eq!(view.true_count(), N);
-    }
-
-    #[test]
-    fn test_iter_zeros_empty() {
-        let bits = [0; NB];
-        let view = BitView::<NB>::new(&bits);
-
-        let mut zeros = Vec::new();
-        view.iter_zeros(|idx| zeros.push(idx));
-
-        assert_eq!(zeros.len(), N);
-        assert_eq!(zeros, (0..N).collect::<Vec<_>>());
-    }
-
-    #[test]
-    fn test_iter_zeros_all_set() {
-        let view = BitView::<NB>::all_true();
-
-        let mut zeros = Vec::new();
-        view.iter_zeros(|idx| zeros.push(idx));
-
-        assert_eq!(zeros, Vec::<usize>::new());
-    }
-
-    #[test]
-    fn test_iter_ones_single_bit() {
-        let mut bits = [0; NB];
-        bits[0] = 1; // Set bit 0 (LSB)
-        let view = BitView::new(&bits);
-
-        let mut ones = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-
-        assert_eq!(ones, vec![0]);
-        assert_eq!(view.true_count(), 1);
-    }
-
-    #[test]
-    fn test_iter_zeros_single_bit_unset() {
-        let mut bits = [u8::MAX; NB];
-        bits[0] = u8::MAX ^ 1; // Clear bit 0 (LSB)
-        let view = BitView::new(&bits);
-
-        let mut zeros = Vec::new();
-        view.iter_zeros(|idx| zeros.push(idx));
-
-        assert_eq!(zeros, vec![0]);
-    }
-
-    #[test]
-    fn test_iter_ones_multiple_bits_first_word() {
-        let mut bits = [0; NB];
-        bits[0] = 0b1010101; // Set bits 0, 2, 4, 6
-        let view = BitView::new(&bits);
-
-        let mut ones = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-
-        assert_eq!(ones, vec![0, 2, 4, 6]);
-        assert_eq!(view.true_count(), 4);
-    }
-
-    #[test]
-    fn test_iter_zeros_multiple_bits_first_word() {
-        let mut bits = [u8::MAX; NB];
-        bits[0] = !0b1010101; // Clear bits 0, 2, 4, 6
-        let view = BitView::new(&bits);
-
-        let mut zeros = Vec::new();
-        view.iter_zeros(|idx| zeros.push(idx));
-
-        assert_eq!(zeros, vec![0, 2, 4, 6]);
-    }
-
-    #[test]
-    fn test_lsb_bit_ordering() {
-        let mut bits = [0; NB];
-        bits[0] = 0b11111111; // Set bits 0-7 (LSB ordering)
-        let view = BitView::new(&bits);
-
-        let mut ones = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-
-        assert_eq!(ones, vec![0, 1, 2, 3, 4, 5, 6, 7]);
-        assert_eq!(view.true_count(), 8);
-    }
-
-    #[test]
-    fn test_all_false_static() {
-        let view = BitView::<NB>::all_false();
-
-        let mut ones = Vec::new();
-        let mut zeros = Vec::new();
-        view.iter_ones(|idx| ones.push(idx));
-        view.iter_zeros(|idx| zeros.push(idx));
-
-        assert_eq!(ones, Vec::<usize>::new());
-        assert_eq!(zeros, (0..N).collect::<Vec<_>>());
-        assert_eq!(view.true_count(), 0);
-    }
-
-    #[test]
-    fn test_compatibility_with_mask_all_true() {
-        // Create corresponding BitView
-        let view = BitView::<NB>::all_true();
-
-        // Collect ones from BitView
-        let mut bitview_ones = Vec::new();
-        view.iter_ones(|idx| bitview_ones.push(idx));
-
-        // Get indices from Mask (all indices for all_true mask)
-        let expected_indices: Vec<usize> = (0..N).collect();
-
-        assert_eq!(bitview_ones, expected_indices);
-        assert_eq!(view.true_count(), N);
-    }
-
-    #[test]
-    fn test_compatibility_with_mask_all_false() {
-        // Create corresponding BitView
-        let view = BitView::<NB>::all_false();
-
-        // Collect ones from BitView
-        let mut bitview_ones = Vec::new();
-        view.iter_ones(|idx| bitview_ones.push(idx));
-
-        // Collect zeros from BitView
-        let mut bitview_zeros = Vec::new();
-        view.iter_zeros(|idx| bitview_zeros.push(idx));
-
-        assert_eq!(bitview_ones, Vec::<usize>::new());
-        assert_eq!(bitview_zeros, (0..N).collect::<Vec<_>>());
-        assert_eq!(view.true_count(), 0);
-    }
-
-    #[test]
-    fn test_compatibility_with_mask_from_indices() {
-        // Create a Mask from specific indices
-        let indices = vec![0, 10, 20, 63, 64, 100, 500, 1023];
-
-        // Create corresponding BitView
-        let mut bits = [0; NB];
-        for idx in &indices {
-            let word_idx = idx / 8;
-            let bit_idx = idx % 8;
-            bits[word_idx] |= 1u8 << bit_idx;
-        }
-        let view = BitView::new(&bits);
-
-        // Collect ones from BitView
-        let mut bitview_ones = Vec::new();
-        view.iter_ones(|idx| bitview_ones.push(idx));
-
-        assert_eq!(bitview_ones, indices);
-        assert_eq!(view.true_count(), indices.len());
-    }
-
-    #[test]
-    fn test_compatibility_with_mask_slices() {
-        // Create a Mask from slices (ranges)
-        let slices = vec![(0, 10), (100, 110), (500, 510)];
-
-        // Create corresponding BitView
-        let mut bits = [0; NB];
-        for (start, end) in &slices {
-            for idx in *start..*end {
-                let word_idx = idx / 8;
-                let bit_idx = idx % 8;
-                bits[word_idx] |= 1u8 << bit_idx;
-            }
-        }
-        let view = BitView::new(&bits);
-
-        // Collect ones from BitView
-        let mut bitview_ones = Vec::new();
-        view.iter_ones(|idx| bitview_ones.push(idx));
-
-        // Expected indices from slices
-        let mut expected_indices = Vec::new();
-        for (start, end) in &slices {
-            expected_indices.extend(*start..*end);
-        }
-
-        assert_eq!(bitview_ones, expected_indices);
-        assert_eq!(view.true_count(), expected_indices.len());
-    }
-
-    #[test]
-    fn test_with_prefix() {
-        assert_eq!(BitView::<NB>::with_prefix(0).true_count(), 0);
-
-        // May as well test all the possible prefix lengths!
-        for i in 1..N {
-            let view = BitView::<NB>::with_prefix(i);
-
-            // Collect slices (there should be one slice from 0 to n_true)
-            let mut slices = vec![];
-            view.iter_slices(|slice| slices.push(slice));
-
-            assert_eq!(slices.len(), 1);
-        }
-    }
-}
diff --git a/vortex-buffer/src/buffer.rs b/vortex-buffer/src/buffer.rs
index f941db6dbec..053cb5baee5 100644
--- a/vortex-buffer/src/buffer.rs
+++ b/vortex-buffer/src/buffer.rs
@@ -208,6 +208,31 @@ impl<T> Buffer<T> {
         buffer.freeze()
     }
 
+    /// Map each element of the buffer with a closure.
+    pub fn map_each_in_place<R, F>(self, mut f: F) -> BufferMut<R>
+    where
+        T: Copy,
+        F: FnMut(T) -> R,
+    {
+        match self.try_into_mut() {
+            Ok(mut_buf) => mut_buf.map_each_in_place(f),
+            Err(buf) => {
+                let len = buf.len();
+                let mut out_buf = BufferMut::with_capacity(len);
+                out_buf
+                    .spare_capacity_mut()
+                    .iter_mut()
+                    .zip(buf)
+                    .for_each(|(out, in_)| {
+                        out.write(f(in_));
+                    });
+                // Safety: just assigned to each value
+                unsafe { out_buf.set_len(len) }
+                out_buf
+            }
+        }
+    }
+
     /// Clear the buffer, preserving existing capacity.
     pub fn clear(&mut self) {
         self.bytes.clear();
@@ -645,9 +670,11 @@ impl Buf for ByteBuffer {
 }
 
 /// Owned iterator over a [`Buffer`].
-pub struct BufferIterator<T> {
-    buffer: Buffer<T>,
-    index: usize,
+pub struct BufferIterator<T: Copy> {
+    // Keep the buffer alive for the duration of the iteration.
+    _buffer: Buffer<T>,
+    ptr: *const T,
+    end: *const T,
 }
 
 impl<T: Copy> Iterator for BufferIterator<T> {
@@ -655,29 +682,37 @@ impl<T: Copy> Iterator for BufferIterator<T> {
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        (self.index < self.buffer.len()).then(move || {
-            let value = self.buffer[self.index];
-            self.index += 1;
-            value
-        })
+        if self.ptr == self.end {
+            None
+        } else {
+            // SAFETY: ptr is within the buffer and has not reached end.
+            let value = unsafe { self.ptr.read() };
+            self.ptr = unsafe { self.ptr.add(1) };
+            Some(value)
+        }
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = self.buffer.len() - self.index;
+        let remaining = unsafe { self.end.offset_from(self.ptr) } as usize;
         (remaining, Some(remaining))
     }
 }
 
+impl<T: Copy> ExactSizeIterator for BufferIterator<T> {}
+
 impl<T: Copy> IntoIterator for Buffer<T> {
     type Item = T;
     type IntoIter = BufferIterator<T>;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
+        let ptr = self.as_slice().as_ptr();
+        let end = unsafe { ptr.add(self.len()) };
         BufferIterator {
-            buffer: self,
-            index: 0,
+            _buffer: self,
+            ptr,
+            end,
         }
     }
 }
diff --git a/vortex-buffer/src/lib.rs b/vortex-buffer/src/lib.rs
index f16684b842d..8f6d0cf24c3 100644
--- a/vortex-buffer/src/lib.rs
+++ b/vortex-buffer/src/lib.rs
@@ -70,7 +70,8 @@ mod memmap2;
 #[cfg(feature = "serde")]
 mod serde;
 mod string;
-mod trusted_len;
+/// Trusted-length iterator trait and adapters for safe pre-allocation.
+pub mod trusted_len;
 
 /// An immutable buffer of u8.
 pub type ByteBuffer = Buffer<u8>;
diff --git a/vortex-buffer/src/trusted_len.rs b/vortex-buffer/src/trusted_len.rs
index 649b47d1a3c..13cf25d0546 100644
--- a/vortex-buffer/src/trusted_len.rs
+++ b/vortex-buffer/src/trusted_len.rs
@@ -65,6 +65,7 @@ impl<I: Iterator> Iterator for TrustedLenAdapter<I> {
 
 unsafe impl<I: Iterator> TrustedLen for TrustedLenAdapter<I> {}
 
+/// Extension trait for wrapping any iterator in a [`TrustedLenAdapter`].
 pub trait TrustedLenExt: Iterator + Sized {
     /// Wraps this iterator in a `TrustedLenAdapter`.
     ///
diff --git a/vortex-compressor/Cargo.toml b/vortex-compressor/Cargo.toml
new file mode 100644
index 00000000000..da9bd07889c
--- /dev/null
+++ b/vortex-compressor/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "vortex-compressor"
+authors = { workspace = true }
+categories = { workspace = true }
+description = "Encoding-agnostic compression framework for Vortex arrays"
+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]
+itertools = { workspace = true }
+num-traits = { workspace = true }
+parking_lot = { workspace = true }
+rand = { workspace = true }
+rustc-hash = { workspace = true }
+tracing = { workspace = true }
+vortex-array = { workspace = true }
+vortex-buffer = { workspace = true }
+vortex-error = { workspace = true }
+vortex-mask = { workspace = true }
+vortex-utils = { workspace = true }
+
+[dev-dependencies]
+divan = { workspace = true }
+rstest = { workspace = true }
+vortex-array = { workspace = true, features = ["_test-harness"] }
+
+[lints]
+workspace = true
+
+[[bench]]
+name = "dict_encode"
+harness = false
+test = false
+
+[[bench]]
+name = "stats_calc"
+harness = false
+test = false
diff --git a/vortex-btrblocks/benches/dict_encode.rs b/vortex-compressor/benches/dict_encode.rs
similarity index 76%
rename from vortex-btrblocks/benches/dict_encode.rs
rename to vortex-compressor/benches/dict_encode.rs
index 06914f7c1b2..1c47e951fb8 100644
--- a/vortex-btrblocks/benches/dict_encode.rs
+++ b/vortex-compressor/benches/dict_encode.rs
@@ -9,10 +9,9 @@ use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builders::dict::dict_encode;
 use vortex_array::validity::Validity;
-use vortex_btrblocks::CompressorStats;
-use vortex_btrblocks::IntegerStats;
-use vortex_btrblocks::integer_dictionary_encode;
 use vortex_buffer::BufferMut;
+use vortex_compressor::builtins::integer_dictionary_encode;
+use vortex_compressor::stats::IntegerStats;
 
 fn make_array() -> PrimitiveArray {
     let values: BufferMut<i32> = (0..50).cycle().take(64_000).collect();
@@ -34,16 +33,17 @@ fn encode_generic(bencher: Bencher) {
     let array = make_array().into_array();
     bencher
         .with_inputs(|| &array)
-        .bench_refs(|array| dict_encode(array.as_ref()).unwrap());
+        .bench_refs(|array| dict_encode(array).unwrap());
 }
 
 #[cfg(not(codspeed))]
 #[divan::bench]
 fn encode_specialized(bencher: Bencher) {
-    let stats = IntegerStats::generate(&make_array());
+    let array = make_array();
+    let stats = IntegerStats::generate(&array);
     bencher
         .with_inputs(|| &stats)
-        .bench_refs(|stats| integer_dictionary_encode(stats));
+        .bench_refs(|stats| integer_dictionary_encode(array.clone(), stats));
 }
 
 fn main() {
diff --git a/vortex-btrblocks/benches/stats_calc.rs b/vortex-compressor/benches/stats_calc.rs
similarity index 95%
rename from vortex-btrblocks/benches/stats_calc.rs
rename to vortex-compressor/benches/stats_calc.rs
index a272c16210c..5675c8de434 100644
--- a/vortex-btrblocks/benches/stats_calc.rs
+++ b/vortex-compressor/benches/stats_calc.rs
@@ -10,11 +10,10 @@ mod benchmarks {
     use divan::Bencher;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::validity::Validity;
-    use vortex_btrblocks::CompressorStats;
-    use vortex_btrblocks::GenerateStatsOptions;
-    use vortex_btrblocks::IntegerStats;
     use vortex_buffer::Buffer;
     use vortex_buffer::BufferMut;
+    use vortex_compressor::stats::GenerateStatsOptions;
+    use vortex_compressor::stats::IntegerStats;
 
     fn generate_dataset(max_run: u32, distinct: u32) -> Buffer<u32> {
         let mut output = BufferMut::with_capacity(64_000);
diff --git a/vortex-compressor/public-api.lock b/vortex-compressor/public-api.lock
new file mode 100644
index 00000000000..0f16ccc61ab
--- /dev/null
+++ b/vortex-compressor/public-api.lock
@@ -0,0 +1,933 @@
+pub mod vortex_compressor
+
+pub mod vortex_compressor::builtins
+
+pub struct vortex_compressor::builtins::BoolConstantScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::BoolConstantScheme
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::clone(&self) -> vortex_compressor::builtins::BoolConstantScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::BoolConstantScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::BoolConstantScheme
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::eq(&self, other: &vortex_compressor::builtins::BoolConstantScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::BoolConstantScheme
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::BoolConstantScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::BoolConstantScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::BoolConstantScheme
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::FloatConstantScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::FloatConstantScheme
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::clone(&self) -> vortex_compressor::builtins::FloatConstantScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::FloatConstantScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::FloatConstantScheme
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::eq(&self, other: &vortex_compressor::builtins::FloatConstantScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::FloatConstantScheme
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::FloatConstantScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::FloatConstantScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::FloatConstantScheme
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::FloatDictScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::FloatDictScheme
+
+pub fn vortex_compressor::builtins::FloatDictScheme::clone(&self) -> vortex_compressor::builtins::FloatDictScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::FloatDictScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::FloatDictScheme
+
+pub fn vortex_compressor::builtins::FloatDictScheme::eq(&self, other: &vortex_compressor::builtins::FloatDictScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::FloatDictScheme
+
+pub fn vortex_compressor::builtins::FloatDictScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::FloatDictScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::FloatDictScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::FloatDictScheme
+
+pub fn vortex_compressor::builtins::FloatDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::FloatDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::FloatDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::FloatDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::FloatDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::IntConstantScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::IntConstantScheme
+
+pub fn vortex_compressor::builtins::IntConstantScheme::clone(&self) -> vortex_compressor::builtins::IntConstantScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::IntConstantScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::IntConstantScheme
+
+pub fn vortex_compressor::builtins::IntConstantScheme::eq(&self, other: &vortex_compressor::builtins::IntConstantScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::IntConstantScheme
+
+pub fn vortex_compressor::builtins::IntConstantScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::IntConstantScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::IntConstantScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::IntConstantScheme
+
+pub fn vortex_compressor::builtins::IntConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::IntConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::IntConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::IntConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::IntConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::IntDictScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::IntDictScheme
+
+pub fn vortex_compressor::builtins::IntDictScheme::clone(&self) -> vortex_compressor::builtins::IntDictScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::IntDictScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::IntDictScheme
+
+pub fn vortex_compressor::builtins::IntDictScheme::eq(&self, other: &vortex_compressor::builtins::IntDictScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::IntDictScheme
+
+pub fn vortex_compressor::builtins::IntDictScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::IntDictScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::IntDictScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::IntDictScheme
+
+pub fn vortex_compressor::builtins::IntDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::IntDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::IntDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::IntDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::IntDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::IntDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::IntDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::IntDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::StringConstantScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::StringConstantScheme
+
+pub fn vortex_compressor::builtins::StringConstantScheme::clone(&self) -> vortex_compressor::builtins::StringConstantScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::StringConstantScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::StringConstantScheme
+
+pub fn vortex_compressor::builtins::StringConstantScheme::eq(&self, other: &vortex_compressor::builtins::StringConstantScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::StringConstantScheme
+
+pub fn vortex_compressor::builtins::StringConstantScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::StringConstantScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::StringConstantScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::StringConstantScheme
+
+pub fn vortex_compressor::builtins::StringConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::StringConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::StringConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::StringConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::StringConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::builtins::StringDictScheme
+
+impl core::clone::Clone for vortex_compressor::builtins::StringDictScheme
+
+pub fn vortex_compressor::builtins::StringDictScheme::clone(&self) -> vortex_compressor::builtins::StringDictScheme
+
+impl core::cmp::Eq for vortex_compressor::builtins::StringDictScheme
+
+impl core::cmp::PartialEq for vortex_compressor::builtins::StringDictScheme
+
+pub fn vortex_compressor::builtins::StringDictScheme::eq(&self, other: &vortex_compressor::builtins::StringDictScheme) -> bool
+
+impl core::fmt::Debug for vortex_compressor::builtins::StringDictScheme
+
+pub fn vortex_compressor::builtins::StringDictScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::builtins::StringDictScheme
+
+impl core::marker::StructuralPartialEq for vortex_compressor::builtins::StringDictScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::StringDictScheme
+
+pub fn vortex_compressor::builtins::StringDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::StringDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::StringDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::StringDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::StringDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::StringDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::StringDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::StringDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub fn vortex_compressor::builtins::float_dictionary_encode(array: vortex_array::arrays::primitive::vtable::PrimitiveArray, stats: &vortex_compressor::stats::FloatStats) -> vortex_error::VortexResult<vortex_array::arrays::dict::vtable::DictArray>
+
+pub fn vortex_compressor::builtins::integer_dictionary_encode(array: vortex_array::arrays::primitive::vtable::PrimitiveArray, stats: &vortex_compressor::stats::IntegerStats) -> vortex_error::VortexResult<vortex_array::arrays::dict::vtable::DictArray>
+
+pub fn vortex_compressor::builtins::is_float_primitive(canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::is_integer_primitive(canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::is_utf8_string(canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub mod vortex_compressor::ctx
+
+pub struct vortex_compressor::ctx::CompressorContext
+
+impl vortex_compressor::ctx::CompressorContext
+
+pub fn vortex_compressor::ctx::CompressorContext::as_leaf(self) -> Self
+
+pub fn vortex_compressor::ctx::CompressorContext::cascade_history(&self) -> &[(vortex_compressor::scheme::SchemeId, usize)]
+
+pub fn vortex_compressor::ctx::CompressorContext::finished_cascading(&self) -> bool
+
+pub fn vortex_compressor::ctx::CompressorContext::is_sample(&self) -> bool
+
+pub fn vortex_compressor::ctx::CompressorContext::merged_stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl core::clone::Clone for vortex_compressor::ctx::CompressorContext
+
+pub fn vortex_compressor::ctx::CompressorContext::clone(&self) -> vortex_compressor::ctx::CompressorContext
+
+impl core::fmt::Debug for vortex_compressor::ctx::CompressorContext
+
+pub fn vortex_compressor::ctx::CompressorContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub const vortex_compressor::ctx::MAX_CASCADE: usize
+
+pub mod vortex_compressor::estimate
+
+pub enum vortex_compressor::estimate::CompressionEstimate
+
+pub vortex_compressor::estimate::CompressionEstimate::AlwaysUse
+
+pub vortex_compressor::estimate::CompressionEstimate::Estimate(alloc::boxed::Box<vortex_compressor::estimate::EstimateFn>)
+
+pub vortex_compressor::estimate::CompressionEstimate::Ratio(f64)
+
+pub vortex_compressor::estimate::CompressionEstimate::Sample
+
+pub vortex_compressor::estimate::CompressionEstimate::Skip
+
+impl core::fmt::Debug for vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::estimate::CompressionEstimate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub type vortex_compressor::estimate::EstimateFn = (dyn core::ops::function::FnOnce(&vortex_compressor::CascadingCompressor, &mut vortex_compressor::stats::ArrayAndStats, vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_compressor::estimate::CompressionEstimate> + core::marker::Send + core::marker::Sync)
+
+pub mod vortex_compressor::scheme
+
+pub enum vortex_compressor::scheme::ChildSelection
+
+pub vortex_compressor::scheme::ChildSelection::All
+
+pub vortex_compressor::scheme::ChildSelection::Many(&'static [usize])
+
+pub vortex_compressor::scheme::ChildSelection::One(usize)
+
+impl vortex_compressor::scheme::ChildSelection
+
+pub fn vortex_compressor::scheme::ChildSelection::contains(&self, child_index: usize) -> bool
+
+impl core::clone::Clone for vortex_compressor::scheme::ChildSelection
+
+pub fn vortex_compressor::scheme::ChildSelection::clone(&self) -> vortex_compressor::scheme::ChildSelection
+
+impl core::fmt::Debug for vortex_compressor::scheme::ChildSelection
+
+pub fn vortex_compressor::scheme::ChildSelection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::scheme::ChildSelection
+
+pub struct vortex_compressor::scheme::AncestorExclusion
+
+pub vortex_compressor::scheme::AncestorExclusion::ancestor: vortex_compressor::scheme::SchemeId
+
+pub vortex_compressor::scheme::AncestorExclusion::children: vortex_compressor::scheme::ChildSelection
+
+impl core::clone::Clone for vortex_compressor::scheme::AncestorExclusion
+
+pub fn vortex_compressor::scheme::AncestorExclusion::clone(&self) -> vortex_compressor::scheme::AncestorExclusion
+
+impl core::fmt::Debug for vortex_compressor::scheme::AncestorExclusion
+
+pub fn vortex_compressor::scheme::AncestorExclusion::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::scheme::AncestorExclusion
+
+pub struct vortex_compressor::scheme::DescendantExclusion
+
+pub vortex_compressor::scheme::DescendantExclusion::children: vortex_compressor::scheme::ChildSelection
+
+pub vortex_compressor::scheme::DescendantExclusion::excluded: vortex_compressor::scheme::SchemeId
+
+impl core::clone::Clone for vortex_compressor::scheme::DescendantExclusion
+
+pub fn vortex_compressor::scheme::DescendantExclusion::clone(&self) -> vortex_compressor::scheme::DescendantExclusion
+
+impl core::fmt::Debug for vortex_compressor::scheme::DescendantExclusion
+
+pub fn vortex_compressor::scheme::DescendantExclusion::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::scheme::DescendantExclusion
+
+pub struct vortex_compressor::scheme::SchemeId
+
+impl core::clone::Clone for vortex_compressor::scheme::SchemeId
+
+pub fn vortex_compressor::scheme::SchemeId::clone(&self) -> vortex_compressor::scheme::SchemeId
+
+impl core::cmp::Eq for vortex_compressor::scheme::SchemeId
+
+impl core::cmp::PartialEq for vortex_compressor::scheme::SchemeId
+
+pub fn vortex_compressor::scheme::SchemeId::eq(&self, other: &vortex_compressor::scheme::SchemeId) -> bool
+
+impl core::fmt::Debug for vortex_compressor::scheme::SchemeId
+
+pub fn vortex_compressor::scheme::SchemeId::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_compressor::scheme::SchemeId
+
+pub fn vortex_compressor::scheme::SchemeId::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_compressor::scheme::SchemeId
+
+pub fn vortex_compressor::scheme::SchemeId::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_compressor::scheme::SchemeId
+
+impl core::marker::StructuralPartialEq for vortex_compressor::scheme::SchemeId
+
+pub trait vortex_compressor::scheme::Scheme: core::fmt::Debug + core::marker::Send + core::marker::Sync
+
+pub fn vortex_compressor::scheme::Scheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::scheme::Scheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::scheme::Scheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::scheme::Scheme::expected_compression_ratio(&self, _data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::scheme::Scheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::scheme::Scheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::scheme::Scheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::scheme::Scheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::BoolConstantScheme
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::BoolConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::FloatConstantScheme
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::FloatConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::FloatDictScheme
+
+pub fn vortex_compressor::builtins::FloatDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::FloatDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::FloatDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::FloatDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::FloatDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::FloatDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::IntConstantScheme
+
+pub fn vortex_compressor::builtins::IntConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::IntConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::IntConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::IntConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::IntConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::IntConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::IntDictScheme
+
+pub fn vortex_compressor::builtins::IntDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::IntDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::IntDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::IntDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::IntDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::IntDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::IntDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::IntDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::StringConstantScheme
+
+pub fn vortex_compressor::builtins::StringConstantScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::compress(&self, _compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::StringConstantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::StringConstantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::StringConstantScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::StringConstantScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::StringConstantScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl vortex_compressor::scheme::Scheme for vortex_compressor::builtins::StringDictScheme
+
+pub fn vortex_compressor::builtins::StringDictScheme::ancestor_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::AncestorExclusion>
+
+pub fn vortex_compressor::builtins::StringDictScheme::compress(&self, compressor: &vortex_compressor::CascadingCompressor, data: &mut vortex_compressor::stats::ArrayAndStats, ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::builtins::StringDictScheme::descendant_exclusions(&self) -> alloc::vec::Vec<vortex_compressor::scheme::DescendantExclusion>
+
+pub fn vortex_compressor::builtins::StringDictScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_compressor::builtins::StringDictScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_compressor::builtins::StringDictScheme::num_children(&self) -> usize
+
+pub fn vortex_compressor::builtins::StringDictScheme::scheme_name(&self) -> &'static str
+
+pub fn vortex_compressor::builtins::StringDictScheme::stats_options(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+pub trait vortex_compressor::scheme::SchemeExt: vortex_compressor::scheme::Scheme
+
+pub fn vortex_compressor::scheme::SchemeExt::id(&self) -> vortex_compressor::scheme::SchemeId
+
+impl<T: vortex_compressor::scheme::Scheme + ?core::marker::Sized> vortex_compressor::scheme::SchemeExt for T
+
+pub fn T::id(&self) -> vortex_compressor::scheme::SchemeId
+
+pub mod vortex_compressor::stats
+
+pub enum vortex_compressor::stats::FloatErasedStats
+
+pub vortex_compressor::stats::FloatErasedStats::F16(vortex_compressor::stats::FloatTypedStats<half::binary16::f16>)
+
+pub vortex_compressor::stats::FloatErasedStats::F32(vortex_compressor::stats::FloatTypedStats<f32>)
+
+pub vortex_compressor::stats::FloatErasedStats::F64(vortex_compressor::stats::FloatTypedStats<f64>)
+
+impl core::clone::Clone for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::clone(&self) -> vortex_compressor::stats::FloatErasedStats
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<f32>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<f32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<f64>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<f64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<half::binary16::f16>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<half::binary16::f16>) -> Self
+
+impl core::fmt::Debug for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub enum vortex_compressor::stats::IntegerErasedStats
+
+pub vortex_compressor::stats::IntegerErasedStats::I16(vortex_compressor::stats::IntegerTypedStats<i16>)
+
+pub vortex_compressor::stats::IntegerErasedStats::I32(vortex_compressor::stats::IntegerTypedStats<i32>)
+
+pub vortex_compressor::stats::IntegerErasedStats::I64(vortex_compressor::stats::IntegerTypedStats<i64>)
+
+pub vortex_compressor::stats::IntegerErasedStats::I8(vortex_compressor::stats::IntegerTypedStats<i8>)
+
+pub vortex_compressor::stats::IntegerErasedStats::U16(vortex_compressor::stats::IntegerTypedStats<u16>)
+
+pub vortex_compressor::stats::IntegerErasedStats::U32(vortex_compressor::stats::IntegerTypedStats<u32>)
+
+pub vortex_compressor::stats::IntegerErasedStats::U64(vortex_compressor::stats::IntegerTypedStats<u64>)
+
+pub vortex_compressor::stats::IntegerErasedStats::U8(vortex_compressor::stats::IntegerTypedStats<u8>)
+
+impl vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::distinct_count(&self) -> core::option::Option<u32>
+
+pub fn vortex_compressor::stats::IntegerErasedStats::max_ilog2(&self) -> core::option::Option<u32>
+
+pub fn vortex_compressor::stats::IntegerErasedStats::max_minus_min(&self) -> u64
+
+pub fn vortex_compressor::stats::IntegerErasedStats::min_is_negative(&self) -> bool
+
+pub fn vortex_compressor::stats::IntegerErasedStats::min_is_zero(&self) -> bool
+
+pub fn vortex_compressor::stats::IntegerErasedStats::most_frequent_value_and_count(&self) -> core::option::Option<(vortex_array::scalar::typed_view::primitive::pvalue::PValue, u32)>
+
+impl core::clone::Clone for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::clone(&self) -> vortex_compressor::stats::IntegerErasedStats
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i16>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i16>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i32>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i64>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i8>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i8>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u16>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u16>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u32>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u64>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u8>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u8>) -> Self
+
+impl core::fmt::Debug for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::ArrayAndStats
+
+impl vortex_compressor::stats::ArrayAndStats
+
+pub fn vortex_compressor::stats::ArrayAndStats::array(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_compressor::stats::ArrayAndStats::array_as_primitive(&self) -> vortex_array::arrays::primitive::vtable::PrimitiveArray
+
+pub fn vortex_compressor::stats::ArrayAndStats::array_as_utf8(&self) -> vortex_array::arrays::varbinview::vtable::VarBinViewArray
+
+pub fn vortex_compressor::stats::ArrayAndStats::array_len(&self) -> usize
+
+pub fn vortex_compressor::stats::ArrayAndStats::bool_stats(&mut self) -> &vortex_compressor::stats::BoolStats
+
+pub fn vortex_compressor::stats::ArrayAndStats::float_stats(&mut self) -> &vortex_compressor::stats::FloatStats
+
+pub fn vortex_compressor::stats::ArrayAndStats::get_or_insert_with<T: 'static>(&mut self, f: impl core::ops::function::FnOnce() -> T) -> &T
+
+pub fn vortex_compressor::stats::ArrayAndStats::integer_stats(&mut self) -> &vortex_compressor::stats::IntegerStats
+
+pub fn vortex_compressor::stats::ArrayAndStats::into_array(self) -> vortex_array::array::erased::ArrayRef
+
+pub fn vortex_compressor::stats::ArrayAndStats::new(array: vortex_array::array::erased::ArrayRef, opts: vortex_compressor::stats::GenerateStatsOptions) -> Self
+
+pub fn vortex_compressor::stats::ArrayAndStats::string_stats(&mut self) -> &vortex_compressor::stats::StringStats
+
+pub struct vortex_compressor::stats::BoolStats
+
+impl vortex_compressor::stats::BoolStats
+
+pub fn vortex_compressor::stats::BoolStats::generate(input: &vortex_array::arrays::bool::vtable::BoolArray) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_compressor::stats::BoolStats::is_constant(&self) -> bool
+
+pub fn vortex_compressor::stats::BoolStats::null_count(&self) -> u32
+
+pub fn vortex_compressor::stats::BoolStats::true_count(&self) -> u32
+
+pub fn vortex_compressor::stats::BoolStats::value_count(&self) -> u32
+
+impl core::clone::Clone for vortex_compressor::stats::BoolStats
+
+pub fn vortex_compressor::stats::BoolStats::clone(&self) -> vortex_compressor::stats::BoolStats
+
+impl core::fmt::Debug for vortex_compressor::stats::BoolStats
+
+pub fn vortex_compressor::stats::BoolStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::FloatDistinctInfo<T>
+
+impl<T> vortex_compressor::stats::FloatDistinctInfo<T>
+
+pub fn vortex_compressor::stats::FloatDistinctInfo<T>::distinct_values(&self) -> &vortex_utils::aliases::hash_set::HashSet<vortex_array::arrays::primitive::native_value::NativeValue<T>, rustc_hash::FxBuildHasher>
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_compressor::stats::FloatDistinctInfo<T>
+
+pub fn vortex_compressor::stats::FloatDistinctInfo<T>::clone(&self) -> vortex_compressor::stats::FloatDistinctInfo<T>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_compressor::stats::FloatDistinctInfo<T>
+
+pub fn vortex_compressor::stats::FloatDistinctInfo<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::FloatStats
+
+impl vortex_compressor::stats::FloatStats
+
+pub fn vortex_compressor::stats::FloatStats::average_run_length(&self) -> u32
+
+pub fn vortex_compressor::stats::FloatStats::erased(&self) -> &vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatStats::generate(input: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> Self
+
+pub fn vortex_compressor::stats::FloatStats::generate_opts(input: &vortex_array::arrays::primitive::vtable::PrimitiveArray, opts: vortex_compressor::stats::GenerateStatsOptions) -> Self
+
+pub fn vortex_compressor::stats::FloatStats::null_count(&self) -> u32
+
+pub fn vortex_compressor::stats::FloatStats::value_count(&self) -> u32
+
+impl vortex_compressor::stats::FloatStats
+
+pub fn vortex_compressor::stats::FloatStats::distinct_count(&self) -> core::option::Option<u32>
+
+impl core::clone::Clone for vortex_compressor::stats::FloatStats
+
+pub fn vortex_compressor::stats::FloatStats::clone(&self) -> vortex_compressor::stats::FloatStats
+
+impl core::fmt::Debug for vortex_compressor::stats::FloatStats
+
+pub fn vortex_compressor::stats::FloatStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::FloatTypedStats<T>
+
+impl<T> vortex_compressor::stats::FloatTypedStats<T>
+
+pub fn vortex_compressor::stats::FloatTypedStats<T>::distinct(&self) -> core::option::Option<&vortex_compressor::stats::FloatDistinctInfo<T>>
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<f32>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<f32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<f64>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<f64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::FloatTypedStats<half::binary16::f16>> for vortex_compressor::stats::FloatErasedStats
+
+pub fn vortex_compressor::stats::FloatErasedStats::from(typed: vortex_compressor::stats::FloatTypedStats<half::binary16::f16>) -> Self
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_compressor::stats::FloatTypedStats<T>
+
+pub fn vortex_compressor::stats::FloatTypedStats<T>::clone(&self) -> vortex_compressor::stats::FloatTypedStats<T>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_compressor::stats::FloatTypedStats<T>
+
+pub fn vortex_compressor::stats::FloatTypedStats<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::GenerateStatsOptions
+
+pub vortex_compressor::stats::GenerateStatsOptions::count_distinct_values: bool
+
+impl vortex_compressor::stats::GenerateStatsOptions
+
+pub fn vortex_compressor::stats::GenerateStatsOptions::merge(self, other: Self) -> Self
+
+impl core::clone::Clone for vortex_compressor::stats::GenerateStatsOptions
+
+pub fn vortex_compressor::stats::GenerateStatsOptions::clone(&self) -> vortex_compressor::stats::GenerateStatsOptions
+
+impl core::default::Default for vortex_compressor::stats::GenerateStatsOptions
+
+pub fn vortex_compressor::stats::GenerateStatsOptions::default() -> vortex_compressor::stats::GenerateStatsOptions
+
+impl core::fmt::Debug for vortex_compressor::stats::GenerateStatsOptions
+
+pub fn vortex_compressor::stats::GenerateStatsOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_compressor::stats::GenerateStatsOptions
+
+pub struct vortex_compressor::stats::IntegerDistinctInfo<T>
+
+impl<T> vortex_compressor::stats::IntegerDistinctInfo<T>
+
+pub fn vortex_compressor::stats::IntegerDistinctInfo<T>::distinct_values(&self) -> &vortex_utils::aliases::hash_map::HashMap<vortex_array::arrays::primitive::native_value::NativeValue<T>, u32, rustc_hash::FxBuildHasher>
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_compressor::stats::IntegerDistinctInfo<T>
+
+pub fn vortex_compressor::stats::IntegerDistinctInfo<T>::clone(&self) -> vortex_compressor::stats::IntegerDistinctInfo<T>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_compressor::stats::IntegerDistinctInfo<T>
+
+pub fn vortex_compressor::stats::IntegerDistinctInfo<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::IntegerStats
+
+impl vortex_compressor::stats::IntegerStats
+
+pub fn vortex_compressor::stats::IntegerStats::average_run_length(&self) -> u32
+
+pub fn vortex_compressor::stats::IntegerStats::erased(&self) -> &vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerStats::generate(input: &vortex_array::arrays::primitive::vtable::PrimitiveArray) -> Self
+
+pub fn vortex_compressor::stats::IntegerStats::generate_opts(input: &vortex_array::arrays::primitive::vtable::PrimitiveArray, opts: vortex_compressor::stats::GenerateStatsOptions) -> Self
+
+pub fn vortex_compressor::stats::IntegerStats::null_count(&self) -> u32
+
+pub fn vortex_compressor::stats::IntegerStats::value_count(&self) -> u32
+
+impl vortex_compressor::stats::IntegerStats
+
+pub fn vortex_compressor::stats::IntegerStats::distinct_count(&self) -> core::option::Option<u32>
+
+pub fn vortex_compressor::stats::IntegerStats::most_frequent_value_and_count(&self) -> core::option::Option<(vortex_array::scalar::typed_view::primitive::pvalue::PValue, u32)>
+
+impl core::clone::Clone for vortex_compressor::stats::IntegerStats
+
+pub fn vortex_compressor::stats::IntegerStats::clone(&self) -> vortex_compressor::stats::IntegerStats
+
+impl core::fmt::Debug for vortex_compressor::stats::IntegerStats
+
+pub fn vortex_compressor::stats::IntegerStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::IntegerTypedStats<T>
+
+impl<T> vortex_compressor::stats::IntegerTypedStats<T>
+
+pub fn vortex_compressor::stats::IntegerTypedStats<T>::distinct(&self) -> core::option::Option<&vortex_compressor::stats::IntegerDistinctInfo<T>>
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i16>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i16>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i32>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i64>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<i8>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<i8>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u16>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u16>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u32>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u32>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u64>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u64>) -> Self
+
+impl core::convert::From<vortex_compressor::stats::IntegerTypedStats<u8>> for vortex_compressor::stats::IntegerErasedStats
+
+pub fn vortex_compressor::stats::IntegerErasedStats::from(typed: vortex_compressor::stats::IntegerTypedStats<u8>) -> Self
+
+impl<T: core::clone::Clone> core::clone::Clone for vortex_compressor::stats::IntegerTypedStats<T>
+
+pub fn vortex_compressor::stats::IntegerTypedStats<T>::clone(&self) -> vortex_compressor::stats::IntegerTypedStats<T>
+
+impl<T: core::fmt::Debug> core::fmt::Debug for vortex_compressor::stats::IntegerTypedStats<T>
+
+pub fn vortex_compressor::stats::IntegerTypedStats<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::stats::StringStats
+
+impl vortex_compressor::stats::StringStats
+
+pub fn vortex_compressor::stats::StringStats::estimated_distinct_count(&self) -> core::option::Option<u32>
+
+pub fn vortex_compressor::stats::StringStats::generate(input: &vortex_array::arrays::varbinview::vtable::VarBinViewArray) -> Self
+
+pub fn vortex_compressor::stats::StringStats::generate_opts(input: &vortex_array::arrays::varbinview::vtable::VarBinViewArray, opts: vortex_compressor::stats::GenerateStatsOptions) -> Self
+
+pub fn vortex_compressor::stats::StringStats::null_count(&self) -> u32
+
+pub fn vortex_compressor::stats::StringStats::value_count(&self) -> u32
+
+impl core::clone::Clone for vortex_compressor::stats::StringStats
+
+pub fn vortex_compressor::stats::StringStats::clone(&self) -> vortex_compressor::stats::StringStats
+
+impl core::fmt::Debug for vortex_compressor::stats::StringStats
+
+pub fn vortex_compressor::stats::StringStats::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_compressor::CascadingCompressor
+
+impl vortex_compressor::CascadingCompressor
+
+pub fn vortex_compressor::CascadingCompressor::compress(&self, array: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::CascadingCompressor::compress_child(&self, child: &vortex_array::array::erased::ArrayRef, parent_ctx: &vortex_compressor::ctx::CompressorContext, parent_id: vortex_compressor::scheme::SchemeId, child_index: usize) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_compressor::CascadingCompressor::execution_ctx(&self) -> parking_lot::mutex::MutexGuard<'_, vortex_array::executor::ExecutionCtx>
+
+pub fn vortex_compressor::CascadingCompressor::new(schemes: alloc::vec::Vec<&'static dyn vortex_compressor::scheme::Scheme>) -> Self
+
+impl core::clone::Clone for vortex_compressor::CascadingCompressor
+
+pub fn vortex_compressor::CascadingCompressor::clone(&self) -> vortex_compressor::CascadingCompressor
+
+impl core::fmt::Debug for vortex_compressor::CascadingCompressor
+
+pub fn vortex_compressor::CascadingCompressor::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/vortex-compressor/src/builtins/constant/bool.rs b/vortex-compressor/src/builtins/constant/bool.rs
new file mode 100644
index 00000000000..62e156379e9
--- /dev/null
+++ b/vortex-compressor/src/builtins/constant/bool.rs
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Constant encoding for bool arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::builtins::BoolConstantScheme;
+use crate::builtins::constant::compress_constant_array_with_validity;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::Scheme;
+use crate::stats::ArrayAndStats;
+
+impl Scheme for BoolConstantScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.bool.constant"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        matches!(canonical, Canonical::Bool(_))
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Constant detection on a sample is a false positive, since the sample being constant does
+        // not mean the full array is constant.
+        if ctx.is_sample() {
+            return CompressionEstimate::Skip;
+        }
+
+        let array_len = data.array().len();
+        let stats = data.bool_stats();
+
+        // We want to use `Constant` if there are only nulls in the array.
+        if stats.value_count() == 0 {
+            debug_assert_eq!(stats.null_count() as usize, array_len);
+            return CompressionEstimate::AlwaysUse;
+        }
+
+        if stats.is_constant() {
+            return CompressionEstimate::AlwaysUse;
+        }
+
+        CompressionEstimate::Skip
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        compress_constant_array_with_validity(data.array())
+    }
+}
diff --git a/vortex-compressor/src/builtins/constant/float.rs b/vortex-compressor/src/builtins/constant/float.rs
new file mode 100644
index 00000000000..df8ab7464b6
--- /dev/null
+++ b/vortex-compressor/src/builtins/constant/float.rs
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Constant encoding for float arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_error::VortexResult;
+
+use super::is_float_primitive;
+use crate::CascadingCompressor;
+use crate::builtins::FloatConstantScheme;
+use crate::builtins::constant::compress_constant_array_with_validity;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::Scheme;
+use crate::stats::ArrayAndStats;
+
+impl Scheme for FloatConstantScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.constant"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Constant detection on a sample is a false positive, since the sample being constant does
+        // not mean the full array is constant.
+        if ctx.is_sample() {
+            return CompressionEstimate::Skip;
+        }
+
+        let array_len = data.array().len();
+        let stats = data.float_stats();
+
+        // Note that we only compute distinct counts if other schemes have requested it.
+        if let Some(distinct_count) = stats.distinct_count() {
+            if distinct_count > 1 {
+                return CompressionEstimate::Skip;
+            } else {
+                debug_assert_eq!(distinct_count, 1);
+                return CompressionEstimate::AlwaysUse;
+            }
+        }
+
+        // We want to use `Constant` if there are only nulls in the array.
+        if stats.value_count() == 0 {
+            debug_assert_eq!(stats.null_count() as usize, array_len);
+            return CompressionEstimate::AlwaysUse;
+        }
+
+        // TODO(connor): Can we be smart here with the max and min like with integers?
+
+        // Otherwise our best bet is to actually check if the array is constant.
+        // This is an expensive check, but in practice the distinct count is known because we often
+        // include dictionary encoding in our set of schemes, so we rarely call this.
+        CompressionEstimate::Estimate(Box::new(|compressor, data, _ctx| {
+            if is_constant(data.array(), &mut compressor.execution_ctx())? {
+                Ok(CompressionEstimate::AlwaysUse)
+            } else {
+                Ok(CompressionEstimate::Skip)
+            }
+        }))
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        compress_constant_array_with_validity(data.array())
+    }
+}
diff --git a/vortex-compressor/src/builtins/constant/integer.rs b/vortex-compressor/src/builtins/constant/integer.rs
new file mode 100644
index 00000000000..0264893e5c8
--- /dev/null
+++ b/vortex-compressor/src/builtins/constant/integer.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Constant encoding for integer arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_error::VortexResult;
+
+use super::is_integer_primitive;
+use crate::CascadingCompressor;
+use crate::builtins::IntConstantScheme;
+use crate::builtins::constant::compress_constant_array_with_validity;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::Scheme;
+use crate::stats::ArrayAndStats;
+
+impl Scheme for IntConstantScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.constant"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Constant detection on a sample is a false positive, since the sample being constant does
+        // not mean the full array is constant.
+        if ctx.is_sample() {
+            return CompressionEstimate::Skip;
+        }
+
+        let array_len = data.array().len();
+        let stats = data.integer_stats();
+
+        // Note that we only compute distinct counts if other schemes have requested it.
+        if let Some(distinct_count) = stats.distinct_count() {
+            if distinct_count > 1 {
+                return CompressionEstimate::Skip;
+            } else {
+                debug_assert_eq!(distinct_count, 1);
+                return CompressionEstimate::AlwaysUse;
+            }
+        }
+
+        // We want to use `Constant` if there are only nulls in the array.
+        if stats.value_count() == 0 {
+            debug_assert_eq!(stats.null_count() as usize, array_len);
+            return CompressionEstimate::AlwaysUse;
+        }
+
+        // Otherwise, use the max and min to determine if there is a single value.
+        match stats.erased().max_minus_min().checked_ilog2() {
+            Some(_) => CompressionEstimate::Skip,
+            // If max-min == 0, then we know that there is only 1 value.
+            None => CompressionEstimate::AlwaysUse,
+        }
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        compress_constant_array_with_validity(data.array())
+    }
+}
diff --git a/vortex-compressor/src/builtins/constant/mod.rs b/vortex-compressor/src/builtins/constant/mod.rs
new file mode 100644
index 00000000000..1b177fc530b
--- /dev/null
+++ b/vortex-compressor/src/builtins/constant/mod.rs
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Constant encoding schemes for bool, float, integer, and string arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::MaskedArray;
+use vortex_array::scalar::Scalar;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use super::is_float_primitive;
+use super::is_integer_primitive;
+use super::is_utf8_string;
+
+/// Constant encoding for bool arrays where all valid values are the same.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct BoolConstantScheme;
+
+/// Constant encoding for integer arrays with a single distinct value.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct IntConstantScheme;
+
+/// Constant encoding for float arrays with a single distinct value.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FloatConstantScheme;
+
+/// Constant encoding for string arrays with a single distinct value.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct StringConstantScheme;
+
+mod bool;
+mod float;
+mod integer;
+mod string;
+
+/// Shared helper for compressing a constant array (bool, int, float, string) into a
+/// [`ConstantArray`].
+///
+/// Assumes that the source array has constant valid scalars.
+///
+/// If the array has any nulls, returns a [`MaskedArray`] with a [`ConstantArray`] child.`
+fn compress_constant_array_with_validity(source: &ArrayRef) -> VortexResult<ArrayRef> {
+    if source.all_invalid()? {
+        return Ok(
+            ConstantArray::new(Scalar::null(source.dtype().clone()), source.len()).into_array(),
+        );
+    }
+
+    let scalar_idx = (0..source.len())
+        .position(|idx| source.is_valid(idx).unwrap_or(false))
+        .vortex_expect("We checked that there exists a scalar that is not invalid");
+
+    let scalar = source.scalar_at(scalar_idx)?;
+    let const_arr = ConstantArray::new(scalar, source.len()).into_array();
+
+    if !source.all_valid()? {
+        Ok(MaskedArray::try_new(const_arr, source.validity()?)?.into_array())
+    } else {
+        Ok(const_arr)
+    }
+}
diff --git a/vortex-compressor/src/builtins/constant/string.rs b/vortex-compressor/src/builtins/constant/string.rs
new file mode 100644
index 00000000000..96e4e7ba674
--- /dev/null
+++ b/vortex-compressor/src/builtins/constant/string.rs
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Constant encoding for string arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_error::VortexResult;
+
+use super::is_utf8_string;
+use crate::CascadingCompressor;
+use crate::builtins::StringConstantScheme;
+use crate::builtins::constant::compress_constant_array_with_validity;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::Scheme;
+use crate::stats::ArrayAndStats;
+
+impl Scheme for StringConstantScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.constant"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        // Constant detection on a sample is a false positive, since the sample being constant does
+        // not mean the full array is constant.
+        if ctx.is_sample() {
+            return CompressionEstimate::Skip;
+        }
+
+        let array_len = data.array().len();
+        let stats = data.string_stats();
+
+        // We want to use `Constant` if there are only nulls in the array.
+        if stats.value_count() == 0 {
+            debug_assert_eq!(stats.null_count() as usize, array_len);
+            return CompressionEstimate::AlwaysUse;
+        }
+
+        // Since the estimated distinct count is always going to be less than or equal to the actual
+        // distinct count, if this is not equal to 1 the actual is definitely not equal to 1.
+        if stats.estimated_distinct_count().is_some_and(|c| c > 1) {
+            return CompressionEstimate::Skip;
+        }
+
+        // Otherwise our best bet is to actually check if the array is constant.
+        // This is an expensive check, but the alternative of not compressing a constant array is
+        // far less preferable.
+        CompressionEstimate::Estimate(Box::new(|compressor, data, _ctx| {
+            if is_constant(data.array(), &mut compressor.execution_ctx())? {
+                Ok(CompressionEstimate::AlwaysUse)
+            } else {
+                Ok(CompressionEstimate::Skip)
+            }
+        }))
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        compress_constant_array_with_validity(data.array())
+    }
+}
diff --git a/vortex-compressor/src/builtins/dict/float.rs b/vortex-compressor/src/builtins/dict/float.rs
new file mode 100644
index 00000000000..c2cdbeafaf2
--- /dev/null
+++ b/vortex-compressor/src/builtins/dict/float.rs
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Float-specific dictionary encoding implementation.
+//!
+//! Vortex encoders must always produce unsigned integer codes; signed codes are only accepted for
+//! external compatibility.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::arrays::DictArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::dict::DictArrayExt;
+use vortex_array::arrays::dict::DictArraySlotsExt;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::dtype::half::f16;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::builtins::FloatDictScheme;
+use crate::builtins::IntDictScheme;
+use crate::builtins::is_float_primitive;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::ChildSelection;
+use crate::scheme::DescendantExclusion;
+use crate::scheme::Scheme;
+use crate::scheme::SchemeExt;
+use crate::stats::ArrayAndStats;
+use crate::stats::FloatErasedStats;
+use crate::stats::FloatStats;
+use crate::stats::GenerateStatsOptions;
+
+impl Scheme for FloatDictScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.float.dict"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_float_primitive(canonical)
+    }
+
+    fn stats_options(&self) -> GenerateStatsOptions {
+        GenerateStatsOptions {
+            count_distinct_values: true,
+        }
+    }
+
+    /// Children: values=0, codes=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    /// Float dict codes (child 1) are compact unsigned integers that should not be
+    /// dict-encoded again. Float dict values (child 0) flow through ALP into integer-land,
+    /// where integer dict encoding is redundant since the values are already deduplicated at
+    /// the float level.
+    ///
+    /// Additional exclusions for codes (IntSequenceScheme, IntRunEndScheme, FoRScheme,
+    /// ZigZagScheme, SparseScheme, RLE) are expressed as pull rules on those schemes in
+    /// vortex-btrblocks.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::One(1),
+            },
+            DescendantExclusion {
+                excluded: IntDictScheme.id(),
+                children: ChildSelection::One(0),
+            },
+        ]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let stats = data.float_stats();
+
+        if stats.value_count() == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        let distinct_values_count = stats.distinct_count().vortex_expect(
+            "this must be present since `DictScheme` declared that we need distinct values",
+        );
+
+        // If > 50% of the values are distinct, skip dictionary scheme.
+        if distinct_values_count > stats.value_count() / 2 {
+            return CompressionEstimate::Skip;
+        }
+
+        // Let sampling determine the expected ratio.
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // TODO(connor): Fight the borrow checker (needs interior mutability)!
+        let stats = data.float_stats().clone();
+        let dict = dictionary_encode(data.array_as_primitive(), &stats)?;
+
+        let has_all_values_referenced = dict.has_all_values_referenced();
+
+        // Values = child 0.
+        let compressed_values = compressor.compress_child(dict.values(), &ctx, self.id(), 0)?;
+
+        // Codes = child 1.
+        let narrowed_codes = dict
+            .codes()
+            .clone()
+            .execute::<PrimitiveArray>(&mut compressor.execution_ctx())?
+            .narrow()?
+            .into_array();
+        let compressed_codes = compressor.compress_child(&narrowed_codes, &ctx, self.id(), 1)?;
+
+        // SAFETY: compressing codes or values does not alter the invariants.
+        unsafe {
+            Ok(
+                DictArray::new_unchecked(compressed_codes, compressed_values)
+                    .set_all_values_referenced(has_all_values_referenced)
+                    .into_array(),
+            )
+        }
+    }
+}
+
+/// Encodes a typed float array into a [`DictArray`] using the pre-computed distinct values.
+macro_rules! typed_encode {
+    ($source_array:ident, $stats:ident, $typed:ident, $typ:ty) => {{
+        let distinct = $typed.distinct().vortex_expect(
+            "this must be present since `DictScheme` declared that we need distinct values",
+        );
+
+        let values_validity = match $source_array.validity()? {
+            Validity::NonNullable => Validity::NonNullable,
+            _ => Validity::AllValid,
+        };
+        let codes_validity = $source_array.validity()?;
+
+        let values: Buffer<$typ> = distinct.distinct_values().iter().map(|x| x.0).collect();
+
+        let max_code = values.len();
+        let codes = if max_code <= u8::MAX as usize {
+            let buf = <DictEncoder as Encode<$typ, u8>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        } else if max_code <= u16::MAX as usize {
+            let buf = <DictEncoder as Encode<$typ, u16>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        } else {
+            let buf = <DictEncoder as Encode<$typ, u32>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        };
+
+        let values = PrimitiveArray::new(values, values_validity).into_array();
+        // SAFETY: enforced by the DictEncoder.
+        Ok(unsafe { DictArray::new_unchecked(codes, values).set_all_values_referenced(true) })
+    }};
+}
+
+/// Compresses a floating-point array into a dictionary array according to attached stats.
+///
+/// # Errors
+///
+/// Returns an error if unable to compute validity.
+pub fn dictionary_encode(array: PrimitiveArray, stats: &FloatStats) -> VortexResult<DictArray> {
+    match stats.erased() {
+        FloatErasedStats::F16(typed) => typed_encode!(array, stats, typed, f16),
+        FloatErasedStats::F32(typed) => typed_encode!(array, stats, typed, f32),
+        FloatErasedStats::F64(typed) => typed_encode!(array, stats, typed, f64),
+    }
+}
+
+/// Stateless encoder that maps values to dictionary codes via a `HashMap`.
+struct DictEncoder;
+
+/// Trait for encoding values of type `T` into codes of type `I`.
+trait Encode<T, I> {
+    /// Using the distinct value set, turn the values into a set of codes.
+    fn encode(distinct: &[T], values: &[T]) -> Buffer<I>;
+}
+
+/// Implements [`Encode`] for a float type using its bit representation as the hash key.
+macro_rules! impl_encode {
+    ($typ:ty, $utyp:ty) => { impl_encode!($typ, $utyp, u8, u16, u32); };
+    ($typ:ty, $utyp:ty, $($ityp:ty),+) => {
+        $(
+        impl Encode<$typ, $ityp> for DictEncoder {
+            #[allow(clippy::cast_possible_truncation)]
+            fn encode(distinct: &[$typ], values: &[$typ]) -> Buffer<$ityp> {
+                let mut codes =
+                    vortex_utils::aliases::hash_map::HashMap::<$utyp, $ityp>::with_capacity(
+                        distinct.len(),
+                    );
+                for (code, &value) in distinct.iter().enumerate() {
+                    codes.insert(value.to_bits(), code as $ityp);
+                }
+
+                let mut output = vortex_buffer::BufferMut::with_capacity(values.len());
+                for value in values {
+                    // Any code lookups which fail are for nulls, so their value does not matter.
+                    output.push(codes.get(&value.to_bits()).copied().unwrap_or_default());
+                }
+
+                output.freeze()
+            }
+        }
+        )*
+    };
+}
+
+impl_encode!(f16, u16);
+impl_encode!(f32, u32);
+impl_encode!(f64, u64);
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::dict::DictArraySlotsExt;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+
+    use super::dictionary_encode;
+    use crate::stats::FloatStats;
+    use crate::stats::GenerateStatsOptions;
+
+    #[test]
+    fn test_float_dict_encode() {
+        let values = buffer![1f32, 2f32, 2f32, 0f32, 1f32];
+        let validity =
+            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array());
+        let array = PrimitiveArray::new(values, validity);
+
+        let stats = FloatStats::generate_opts(
+            &array,
+            GenerateStatsOptions {
+                count_distinct_values: true,
+            },
+        );
+        let dict_array = dictionary_encode(array, &stats).unwrap();
+        assert_eq!(dict_array.values().len(), 2);
+        assert_eq!(dict_array.codes().len(), 5);
+
+        let expected = PrimitiveArray::new(
+            buffer![1f32, 2f32, 2f32, 1f32, 1f32],
+            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()),
+        )
+        .into_array();
+        let undict = dict_array.as_array().to_primitive().into_array();
+        assert_arrays_eq!(undict, expected);
+    }
+}
diff --git a/vortex-compressor/src/builtins/dict/integer.rs b/vortex-compressor/src/builtins/dict/integer.rs
new file mode 100644
index 00000000000..8671f9d79e6
--- /dev/null
+++ b/vortex-compressor/src/builtins/dict/integer.rs
@@ -0,0 +1,280 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Integer-specific dictionary encoding implementation.
+//!
+//! Vortex encoders must always produce unsigned integer codes; signed codes are only accepted
+//! for external compatibility.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::arrays::DictArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::dict::DictArrayExt;
+use vortex_array::arrays::dict::DictArraySlotsExt;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::builtins::IntDictScheme;
+use crate::builtins::is_integer_primitive;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::Scheme;
+use crate::scheme::SchemeExt;
+use crate::stats::ArrayAndStats;
+use crate::stats::GenerateStatsOptions;
+use crate::stats::IntegerErasedStats;
+use crate::stats::IntegerStats;
+
+impl Scheme for IntDictScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.int.dict"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_integer_primitive(canonical)
+    }
+
+    fn stats_options(&self) -> GenerateStatsOptions {
+        GenerateStatsOptions {
+            count_distinct_values: true,
+        }
+    }
+
+    /// Children: values=0, codes=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let bit_width = data.array_as_primitive().ptype().bit_width();
+        let stats = data.integer_stats();
+
+        if stats.value_count() == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        let distinct_values_count = stats.distinct_count().vortex_expect(
+            "this must be present since `DictScheme` declared that we need distinct values",
+        );
+
+        // If > 50% of the values are distinct, skip dictionary scheme.
+        if distinct_values_count > stats.value_count() / 2 {
+            return CompressionEstimate::Skip;
+        }
+
+        // Ignore nulls encoding for the estimate. We only focus on values.
+
+        let values_size = bit_width * distinct_values_count as usize;
+
+        // TODO(connor): Should we just hardcode this instead of let the compressor choose?
+        // Assume codes are compressed RLE + BitPacking.
+        let codes_bw = u32::BITS - distinct_values_count.leading_zeros();
+
+        let n_runs = (stats.value_count() / stats.average_run_length()) as usize;
+
+        // Assume that codes will either be BitPack or RLE-BitPack.
+        let codes_size_bp = codes_bw as usize * stats.value_count() as usize;
+        let codes_size_rle_bp = usize::checked_mul(codes_bw as usize + 32, n_runs);
+
+        let codes_size = usize::min(codes_size_bp, codes_size_rle_bp.unwrap_or(usize::MAX));
+
+        let before = stats.value_count() as usize * bit_width;
+
+        CompressionEstimate::Ratio(before as f64 / (values_size + codes_size) as f64)
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        // TODO(connor): Fight the borrow checker (needs interior mutability)!
+        let stats = data.integer_stats().clone();
+        let dict = dictionary_encode(data.array_as_primitive(), &stats)?;
+
+        // Values = child 0.
+        let compressed_values = compressor.compress_child(dict.values(), &ctx, self.id(), 0)?;
+
+        // Codes = child 1.
+        let narrowed_codes = dict
+            .codes()
+            .clone()
+            .execute::<PrimitiveArray>(&mut compressor.execution_ctx())?
+            .narrow()?
+            .into_array();
+        let compressed_codes = compressor.compress_child(&narrowed_codes, &ctx, self.id(), 1)?;
+
+        // SAFETY: compressing codes does not change their values.
+        unsafe {
+            Ok(
+                DictArray::new_unchecked(compressed_codes, compressed_values)
+                    .set_all_values_referenced(dict.has_all_values_referenced())
+                    .into_array(),
+            )
+        }
+    }
+}
+
+/// Encodes a typed integer array into a [`DictArray`] using the pre-computed distinct values.
+macro_rules! typed_encode {
+    ($source_array:ident, $stats:ident, $typed:ident, $typ:ty) => {{
+        let distinct = $typed.distinct().vortex_expect(
+            "this must be present since `DictScheme` declared that we need distinct values",
+        );
+
+        let values_validity = match $source_array.validity()? {
+            Validity::NonNullable => Validity::NonNullable,
+            _ => Validity::AllValid,
+        };
+        let codes_validity = $source_array.validity()?;
+
+        let values: Buffer<$typ> = distinct.distinct_values().keys().map(|x| x.0).collect();
+
+        let max_code = values.len();
+        let codes = if max_code <= u8::MAX as usize {
+            let buf = <DictEncoder as Encode<$typ, u8>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        } else if max_code <= u16::MAX as usize {
+            let buf = <DictEncoder as Encode<$typ, u16>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        } else {
+            let buf = <DictEncoder as Encode<$typ, u32>>::encode(
+                &values,
+                $source_array.as_slice::<$typ>(),
+            );
+            PrimitiveArray::new(buf, codes_validity).into_array()
+        };
+
+        let values = PrimitiveArray::new(values, values_validity).into_array();
+        // SAFETY: invariants enforced in DictEncoder.
+        Ok(unsafe { DictArray::new_unchecked(codes, values).set_all_values_referenced(true) })
+    }};
+}
+
+/// Compresses an integer array into a dictionary array according to attached stats.
+///
+/// # Errors
+///
+/// Returns an error if unable to compute validity.
+#[expect(
+    clippy::cognitive_complexity,
+    reason = "complexity from match on all integer types"
+)]
+pub fn dictionary_encode(array: PrimitiveArray, stats: &IntegerStats) -> VortexResult<DictArray> {
+    match stats.erased() {
+        IntegerErasedStats::U8(typed) => typed_encode!(array, stats, typed, u8),
+        IntegerErasedStats::U16(typed) => typed_encode!(array, stats, typed, u16),
+        IntegerErasedStats::U32(typed) => typed_encode!(array, stats, typed, u32),
+        IntegerErasedStats::U64(typed) => typed_encode!(array, stats, typed, u64),
+        IntegerErasedStats::I8(typed) => typed_encode!(array, stats, typed, i8),
+        IntegerErasedStats::I16(typed) => typed_encode!(array, stats, typed, i16),
+        IntegerErasedStats::I32(typed) => typed_encode!(array, stats, typed, i32),
+        IntegerErasedStats::I64(typed) => typed_encode!(array, stats, typed, i64),
+    }
+}
+
+/// Stateless encoder that maps values to dictionary codes via a `HashMap`.
+struct DictEncoder;
+
+/// Trait for encoding values of type `T` into codes of type `I`.
+trait Encode<T, I> {
+    /// Using the distinct value set, turn the values into a set of codes.
+    fn encode(distinct: &[T], values: &[T]) -> Buffer<I>;
+}
+
+/// Implements [`Encode`] for an integer type with all code width variants (u8, u16, u32).
+macro_rules! impl_encode {
+    ($typ:ty) => { impl_encode!($typ, u8, u16, u32); };
+    ($typ:ty, $($ityp:ty),+) => {
+        $(
+        impl Encode<$typ, $ityp> for DictEncoder {
+            #[allow(clippy::cast_possible_truncation)]
+            fn encode(distinct: &[$typ], values: &[$typ]) -> Buffer<$ityp> {
+                let mut codes =
+                    vortex_utils::aliases::hash_map::HashMap::<$typ, $ityp>::with_capacity(
+                        distinct.len(),
+                    );
+                for (code, &value) in distinct.iter().enumerate() {
+                    codes.insert(value, code as $ityp);
+                }
+
+                let mut output = vortex_buffer::BufferMut::with_capacity(values.len());
+                for value in values {
+                    // Any code lookups which fail are for nulls, so their value does not matter.
+                    // SAFETY: we have exactly sized output to be as large as values.
+                    unsafe { output.push_unchecked(codes.get(value).copied().unwrap_or_default()) };
+                }
+
+                output.freeze()
+            }
+        }
+        )*
+    };
+}
+
+impl_encode!(u8);
+impl_encode!(u16);
+impl_encode!(u32);
+impl_encode!(u64);
+impl_encode!(i8);
+impl_encode!(i16);
+impl_encode!(i32);
+impl_encode!(i64);
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::dict::DictArraySlotsExt;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+
+    use super::dictionary_encode;
+    use crate::stats::IntegerStats;
+
+    #[test]
+    fn test_dict_encode_integer_stats() {
+        let data = buffer![100i32, 200, 100, 0, 100];
+        let validity =
+            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array());
+        let array = PrimitiveArray::new(data, validity);
+
+        let stats = IntegerStats::generate_opts(
+            &array,
+            crate::stats::GenerateStatsOptions {
+                count_distinct_values: true,
+            },
+        );
+        let dict_array = dictionary_encode(array, &stats).unwrap();
+        assert_eq!(dict_array.values().len(), 2);
+        assert_eq!(dict_array.codes().len(), 5);
+
+        let expected = PrimitiveArray::new(
+            buffer![100i32, 200, 100, 100, 100],
+            Validity::Array(BoolArray::from_iter([true, true, true, false, true]).into_array()),
+        )
+        .into_array();
+        let undict = dict_array.as_array().to_primitive().into_array();
+        assert_arrays_eq!(undict, expected);
+    }
+}
diff --git a/vortex-compressor/src/builtins/dict/mod.rs b/vortex-compressor/src/builtins/dict/mod.rs
new file mode 100644
index 00000000000..c8e573b4fbc
--- /dev/null
+++ b/vortex-compressor/src/builtins/dict/mod.rs
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Dictionary encoding schemes for integer, float, and string arrays.
+
+/// Dictionary encoding for low-cardinality float values.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct FloatDictScheme;
+
+/// Dictionary encoding for low-cardinality integer values.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct IntDictScheme;
+
+/// Dictionary encoding for low-cardinality string values.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct StringDictScheme;
+
+mod float;
+mod integer;
+mod string;
+
+pub use float::dictionary_encode as float_dictionary_encode;
+pub use integer::dictionary_encode as integer_dictionary_encode;
diff --git a/vortex-compressor/src/builtins/dict/string.rs b/vortex-compressor/src/builtins/dict/string.rs
new file mode 100644
index 00000000000..399910a00ff
--- /dev/null
+++ b/vortex-compressor/src/builtins/dict/string.rs
@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! UTF8-specific dictionary encoding implementation.
+//!
+//! Vortex encoders must always produce unsigned integer codes; signed codes are only accepted
+//! for external compatibility.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::arrays::DictArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::dict::DictArrayExt;
+use vortex_array::arrays::dict::DictArraySlotsExt;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::builders::dict::dict_encode;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::builtins::IntDictScheme;
+use crate::builtins::StringDictScheme;
+use crate::builtins::is_utf8_string;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::scheme::ChildSelection;
+use crate::scheme::DescendantExclusion;
+use crate::scheme::Scheme;
+use crate::scheme::SchemeExt;
+use crate::stats::ArrayAndStats;
+use crate::stats::GenerateStatsOptions;
+
+impl Scheme for StringDictScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.string.dict"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        is_utf8_string(canonical)
+    }
+
+    fn stats_options(&self) -> GenerateStatsOptions {
+        GenerateStatsOptions {
+            count_distinct_values: true,
+        }
+    }
+
+    /// Children: values=0, codes=1.
+    fn num_children(&self) -> usize {
+        2
+    }
+
+    /// String dict codes (child 1) are compact unsigned integers that should not be dict-encoded
+    /// again.
+    ///
+    /// Additional exclusions for codes (IntSequenceScheme, FoRScheme, ZigZagScheme, SparseScheme,
+    /// RunEndScheme, RLE, etc.) are expressed as pull rules on those schemes in `vortex-btrblocks`.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        vec![DescendantExclusion {
+            excluded: IntDictScheme.id(),
+            children: ChildSelection::One(1),
+        }]
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let stats = data.string_stats();
+
+        if stats.value_count() == 0 {
+            return CompressionEstimate::Skip;
+        }
+
+        let estimated_distinct_values_count = stats.estimated_distinct_count().vortex_expect(
+            "this must be present since `DictScheme` declared that we need distinct values",
+        );
+
+        // If > 50% of the values are distinct, skip dictionary scheme.
+        if estimated_distinct_values_count > stats.value_count() / 2 {
+            return CompressionEstimate::Skip;
+        }
+
+        // Let sampling determine the expected ratio.
+        CompressionEstimate::Sample
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let dict = dict_encode(data.array())?;
+
+        // Values = child 0.
+        let compressed_values = compressor.compress_child(dict.values(), &ctx, self.id(), 0)?;
+
+        // Codes = child 1.
+        let narrowed_codes = dict
+            .codes()
+            .clone()
+            .execute::<PrimitiveArray>(&mut compressor.execution_ctx())?
+            .narrow()?
+            .into_array();
+        let compressed_codes = compressor.compress_child(&narrowed_codes, &ctx, self.id(), 1)?;
+
+        // SAFETY: compressing codes or values does not alter the invariants.
+        unsafe {
+            Ok(
+                DictArray::new_unchecked(compressed_codes, compressed_values)
+                    .set_all_values_referenced(dict.has_all_values_referenced())
+                    .into_array(),
+            )
+        }
+    }
+}
diff --git a/vortex-compressor/src/builtins/mod.rs b/vortex-compressor/src/builtins/mod.rs
new file mode 100644
index 00000000000..c5bd9f343f5
--- /dev/null
+++ b/vortex-compressor/src/builtins/mod.rs
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Built-in compression schemes that use only `vortex-array` encodings.
+//!
+//! These schemes produce arrays using types already in `vortex-array` ([`ConstantArray`],
+//! [`DictArray`], [`MaskedArray`], etc.) and have no external encoding crate dependencies.
+//!
+//! [`ConstantArray`]: vortex_array::arrays::ConstantArray
+//! [`DictArray`]: vortex_array::arrays::DictArray
+//! [`MaskedArray`]: vortex_array::arrays::MaskedArray
+
+use vortex_array::Canonical;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+
+/// Returns `true` if the canonical array is a primitive with an integer ptype.
+pub fn is_integer_primitive(canonical: &Canonical) -> bool {
+    matches!(canonical, Canonical::Primitive(p) if p.ptype().is_int())
+}
+
+/// Returns `true` if the canonical form represents a floating-point primitive.
+pub fn is_float_primitive(canonical: &Canonical) -> bool {
+    matches!(canonical, Canonical::Primitive(p) if !p.ptype().is_int())
+}
+
+/// Returns `true` if the canonical array is a UTF-8 string type.
+pub fn is_utf8_string(canonical: &Canonical) -> bool {
+    matches!(canonical,
+        Canonical::VarBinView(v) if
+            v.dtype().eq_ignore_nullability(&DType::Utf8(Nullability::NonNullable))
+    )
+}
+
+mod dict;
+
+pub use dict::FloatDictScheme;
+pub use dict::IntDictScheme;
+pub use dict::StringDictScheme;
+pub use dict::float_dictionary_encode;
+pub use dict::integer_dictionary_encode;
+
+mod constant;
+
+pub use constant::BoolConstantScheme;
+pub use constant::FloatConstantScheme;
+pub use constant::IntConstantScheme;
+pub use constant::StringConstantScheme;
diff --git a/vortex-compressor/src/compressor.rs b/vortex-compressor/src/compressor.rs
new file mode 100644
index 00000000000..099cc858f92
--- /dev/null
+++ b/vortex-compressor/src/compressor.rs
@@ -0,0 +1,616 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Cascading array compression implementation.
+
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+use parking_lot::MutexGuard;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::CanonicalValidity;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::ToCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::arrays::ListArray;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::list::ListArrayExt;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::arrays::listview::list_from_list_view;
+use vortex_array::arrays::primitive::PrimitiveArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::scalar::Scalar;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_panic;
+
+use crate::builtins::IntDictScheme;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::estimate::estimate_compression_ratio_with_sampling;
+use crate::estimate::is_better_ratio;
+use crate::scheme::ChildSelection;
+use crate::scheme::DescendantExclusion;
+use crate::scheme::Scheme;
+use crate::scheme::SchemeExt;
+use crate::scheme::SchemeId;
+use crate::stats::ArrayAndStats;
+use crate::stats::GenerateStatsOptions;
+
+/// The implicit root scheme ID for the compressor's own cascading (e.g. list offset compression).
+///
+/// This is the **only** [`SchemeId`] that is not auto-provided via [`SchemeExt`].
+const ROOT_SCHEME_ID: SchemeId = SchemeId {
+    name: "vortex.compressor.root",
+};
+
+/// Child indices for the compressor's list/listview compression.
+mod root_list_children {
+    /// List/ListView offsets child.
+    pub const OFFSETS: usize = 1;
+    /// ListView sizes child.
+    pub const SIZES: usize = 2;
+}
+
+/// The main compressor type implementing cascading adaptive compression.
+///
+/// This compressor applies adaptive compression [`Scheme`]s to arrays based on their data types and
+/// characteristics. It recursively compresses nested structures like structs and lists, and chooses
+/// optimal compression schemes for leaf types.
+///
+/// The compressor works by:
+/// 1. Canonicalizing input arrays to a standard representation.
+/// 2. Pre-filtering schemes by [`Scheme::matches`] and exclusion rules.
+/// 3. Evaluating each matching scheme's compression ratio on a sample.
+/// 4. Compressing with the best scheme and verifying the result is smaller.
+///
+/// No scheme may appear twice in a cascade chain. The compressor enforces this automatically
+/// along with push/pull exclusion rules declared by each scheme.
+#[derive(Debug, Clone)]
+pub struct CascadingCompressor {
+    /// The enabled compression schemes.
+    schemes: Vec<&'static dyn Scheme>,
+
+    /// Descendant exclusion rules for the compressor's own cascading (e.g. excluding Dict from
+    /// list offsets).
+    root_exclusions: Vec<DescendantExclusion>,
+
+    /// Shared execution context for array operations during compression.
+    ///
+    /// This should have low contention as we only execute arrays one at a time during compression.
+    ctx: Arc<Mutex<ExecutionCtx>>,
+}
+
+impl CascadingCompressor {
+    /// Creates a new compressor with the given schemes.
+    ///
+    /// Root-level exclusion rules (e.g. excluding Dict from list offsets) are built
+    /// automatically.
+    pub fn new(schemes: Vec<&'static dyn Scheme>) -> Self {
+        // Root exclusion: exclude IntDict from list/listview offsets (monotonically
+        // increasing data where dictionary encoding is wasteful).
+        let root_exclusions = vec![DescendantExclusion {
+            excluded: IntDictScheme.id(),
+            children: ChildSelection::One(root_list_children::OFFSETS),
+        }];
+        Self {
+            schemes,
+            root_exclusions,
+            // TODO(connor): The caller should probably pass this in.
+            ctx: Arc::new(Mutex::new(LEGACY_SESSION.create_execution_ctx())),
+        }
+    }
+
+    /// Returns a mutable borrow of the execution context.
+    pub fn execution_ctx(&self) -> MutexGuard<'_, ExecutionCtx> {
+        self.ctx.lock()
+    }
+
+    /// Compresses an array using cascading adaptive compression.
+    ///
+    /// First canonicalizes and compacts the array, then applies optimal compression schemes.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if canonicalization or compression fails.
+    pub fn compress(&self, array: &ArrayRef) -> VortexResult<ArrayRef> {
+        let canonical = array
+            .clone()
+            .execute::<CanonicalValidity>(&mut self.execution_ctx())?
+            .0;
+
+        // Compact it, removing any wasted space before we attempt to compress it.
+        let compact = canonical.compact()?;
+
+        self.compress_canonical(compact, CompressorContext::new())
+    }
+
+    /// Compresses a child array produced by a cascading scheme.
+    ///
+    /// If the cascade budget is exhausted, the canonical array is returned as-is. Otherwise,
+    /// the child context is created by descending and recording the parent scheme + child
+    /// index, and compression proceeds normally.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if compression fails.
+    pub fn compress_child(
+        &self,
+        child: &ArrayRef,
+        parent_ctx: &CompressorContext,
+        parent_id: SchemeId,
+        child_index: usize,
+    ) -> VortexResult<ArrayRef> {
+        if parent_ctx.finished_cascading() {
+            return Ok(child.clone());
+        }
+
+        let canonical = child
+            .clone()
+            .execute::<CanonicalValidity>(&mut self.execution_ctx())?
+            .0;
+        let compact = canonical.compact()?;
+
+        let child_ctx = parent_ctx
+            .clone()
+            .descend_with_scheme(parent_id, child_index);
+        self.compress_canonical(compact, child_ctx)
+    }
+
+    /// Compresses a canonical array by dispatching to type-specific logic.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if compression of any sub-array fails.
+    fn compress_canonical(
+        &self,
+        array: Canonical,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        match array {
+            Canonical::Null(null_array) => Ok(null_array.into_array()),
+            Canonical::Bool(bool_array) => {
+                self.choose_and_compress(Canonical::Bool(bool_array), ctx)
+            }
+            Canonical::Primitive(primitive) => {
+                self.choose_and_compress(Canonical::Primitive(primitive), ctx)
+            }
+            Canonical::Decimal(decimal) => {
+                self.choose_and_compress(Canonical::Decimal(decimal), ctx)
+            }
+            Canonical::Struct(struct_array) => {
+                let fields = struct_array
+                    .iter_unmasked_fields()
+                    .map(|field| self.compress(field))
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                Ok(StructArray::try_new(
+                    struct_array.names().clone(),
+                    fields,
+                    struct_array.len(),
+                    struct_array.validity()?,
+                )?
+                .into_array())
+            }
+            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)?;
+                    self.compress_list_array(list_array, ctx)
+                } else {
+                    self.compress_list_view_array(list_view_array, ctx)
+                }
+            }
+            Canonical::FixedSizeList(fsl_array) => {
+                let compressed_elems = self.compress(fsl_array.elements())?;
+
+                Ok(FixedSizeListArray::try_new(
+                    compressed_elems,
+                    fsl_array.list_size(),
+                    fsl_array.validity()?,
+                    fsl_array.len(),
+                )?
+                .into_array())
+            }
+            Canonical::VarBinView(strings) => {
+                if strings
+                    .dtype()
+                    .eq_ignore_nullability(&DType::Utf8(Nullability::NonNullable))
+                {
+                    self.choose_and_compress(Canonical::VarBinView(strings), ctx)
+                } else {
+                    // We do not compress binary arrays.
+                    Ok(strings.into_array())
+                }
+            }
+            Canonical::Extension(ext_array) => {
+                let before_nbytes = ext_array.as_ref().nbytes();
+
+                // Try scheme-based compression first.
+                let result =
+                    self.choose_and_compress(Canonical::Extension(ext_array.clone()), ctx)?;
+                if result.nbytes() < before_nbytes {
+                    return Ok(result);
+                }
+
+                // Otherwise, fall back to compressing the underlying storage array.
+                let compressed_storage = self.compress(ext_array.storage_array())?;
+
+                Ok(
+                    ExtensionArray::new(ext_array.ext_dtype().clone(), compressed_storage)
+                        .into_array(),
+                )
+            }
+            Canonical::Variant(_) => {
+                vortex_bail!("Variant arrays can not be compressed")
+            }
+        }
+    }
+
+    /// The main scheme-selection entry point for a single leaf array.
+    ///
+    /// Filters allowed schemes by [`matches`] and exclusion rules, merges their [`stats_options`]
+    /// into a single [`GenerateStatsOptions`], then delegates to [`choose_scheme`] to pick the
+    /// winner by estimated compression ratio.
+    ///
+    /// If a winner is found and its compressed output is actually smaller, that output is returned.
+    /// Otherwise, the original array is returned unchanged.
+    ///
+    /// Empty and all-null arrays are short-circuited before any scheme evaluation.
+    ///
+    /// [`matches`]: Scheme::matches
+    /// [`stats_options`]: Scheme::stats_options
+    /// [`choose_scheme`]: Self::choose_scheme
+    fn choose_and_compress(
+        &self,
+        canonical: Canonical,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let eligible_schemes: Vec<&'static dyn Scheme> = self
+            .schemes
+            .iter()
+            .copied()
+            .filter(|s| s.matches(&canonical) && !self.is_excluded(*s, &ctx))
+            .collect();
+
+        let array: ArrayRef = canonical.into();
+
+        // If there are no schemes that we can compress into, then just return it uncompressed.
+        if eligible_schemes.is_empty() {
+            return Ok(array);
+        }
+
+        // Nothing to compress if empty or all-null.
+        if array.is_empty() {
+            return Ok(array);
+        }
+        if array.all_invalid()? {
+            return Ok(
+                ConstantArray::new(Scalar::null(array.dtype().clone()), array.len()).into_array(),
+            );
+        }
+
+        let before_nbytes = array.nbytes();
+
+        let merged_opts = eligible_schemes
+            .iter()
+            .fold(GenerateStatsOptions::default(), |acc, s| {
+                acc.merge(s.stats_options())
+            });
+        let ctx = ctx.with_merged_stats_options(merged_opts);
+
+        let mut data = ArrayAndStats::new(array, merged_opts);
+
+        if let Some(winner) = self.choose_best_scheme(&eligible_schemes, &mut data, ctx.clone())? {
+            // TODO(connor): Add a tracing warning here if compression with the chosen scheme
+            // failed, since there was likely more we could have done while choosing schemes.
+
+            // Sampling and estimation chose a scheme, so let's compress the whole array with it.
+            let compressed = winner.compress(self, &mut data, ctx)?;
+
+            // Only choose the compressed array if it is smaller than the canonical one.
+            if compressed.nbytes() < before_nbytes {
+                // TODO(connor): Add a tracing warning here too.
+                return Ok(compressed);
+            }
+        }
+
+        // No scheme improved on the original.
+        Ok(data.into_array())
+    }
+
+    /// Calls [`expected_compression_ratio`] on each candidate and returns the scheme with the
+    /// highest ratio, or `None` if no scheme exceeds 1.0. Ties are broken by registration order
+    /// (earlier in the list wins).
+    ///
+    /// [`expected_compression_ratio`]: Scheme::expected_compression_ratio
+    fn choose_best_scheme(
+        &self,
+        schemes: &[&'static dyn Scheme],
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<Option<&'static dyn Scheme>> {
+        let mut best: Option<(&'static dyn Scheme, f64)> = None;
+
+        // TODO(connor): Might want to use an `im` data structure inside of `ctx` if the clones here
+        // are expensive.
+        for &scheme in schemes {
+            let estimate = scheme.expected_compression_ratio(data, ctx.clone());
+
+            match estimate {
+                CompressionEstimate::Skip => {}
+                CompressionEstimate::AlwaysUse => return Ok(Some(scheme)),
+                CompressionEstimate::Ratio(ratio) => {
+                    if is_better_ratio(ratio, &best) {
+                        best = Some((scheme, ratio));
+                    }
+                }
+                CompressionEstimate::Sample => {
+                    let sample_ratio = estimate_compression_ratio_with_sampling(
+                        scheme,
+                        self,
+                        data.array(),
+                        ctx.clone(),
+                    )?;
+
+                    if is_better_ratio(sample_ratio, &best) {
+                        best = Some((scheme, sample_ratio));
+                    }
+                }
+                // TODO(connor): Is there a way to deduplicate some of this code?
+                CompressionEstimate::Estimate(estimate_callback) => {
+                    let estimate = estimate_callback(self, data, ctx.clone())?;
+
+                    match estimate {
+                        CompressionEstimate::Skip => {}
+                        CompressionEstimate::AlwaysUse => return Ok(Some(scheme)),
+                        CompressionEstimate::Ratio(ratio) => {
+                            if is_better_ratio(ratio, &best) {
+                                best = Some((scheme, ratio));
+                            }
+                        }
+                        e @ (CompressionEstimate::Sample | CompressionEstimate::Estimate(_)) => {
+                            vortex_panic!(
+                                "an estimation function returned an invalid variant {e:?}"
+                            )
+                        }
+                    }
+                }
+            }
+
+            // tracing::debug!(scheme = %scheme.id(), estimate, "evaluated compression ratio");
+        }
+
+        Ok(best.map(|(s, _)| s))
+    }
+
+    // TODO(connor): Lots of room for optimization here.
+    /// Returns `true` if the candidate scheme should be excluded based on the cascade history and
+    /// exclusion rules.
+    fn is_excluded(&self, candidate: &dyn Scheme, ctx: &CompressorContext) -> bool {
+        let id = candidate.id();
+        let history = ctx.cascade_history();
+
+        // Self-exclusion: no scheme appears twice in any chain.
+        if history.iter().any(|&(sid, _)| sid == id) {
+            return true;
+        }
+
+        let mut iter = history.iter().copied().peekable();
+
+        // The root entry is always first in the history (if present). Check if the root has
+        // excluded us.
+        if let Some((_, child_idx)) = iter.next_if(|&(sid, _)| sid == ROOT_SCHEME_ID)
+            && self
+                .root_exclusions
+                .iter()
+                .any(|rule| rule.excluded == id && rule.children.contains(child_idx))
+        {
+            return true;
+        }
+
+        // Push rules: Check if any of our ancestors have excluded us.
+        for (ancestor_id, child_idx) in iter {
+            if let Some(ancestor) = self.schemes.iter().find(|s| s.id() == ancestor_id)
+                && ancestor
+                    .descendant_exclusions()
+                    .iter()
+                    .any(|rule| rule.excluded == id && rule.children.contains(child_idx))
+            {
+                return true;
+            }
+        }
+
+        // Pull rules: Check if we have excluded ourselves because of our ancestors.
+        for rule in candidate.ancestor_exclusions() {
+            if history
+                .iter()
+                .any(|(sid, cidx)| *sid == rule.ancestor && rule.children.contains(*cidx))
+            {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    /// Compresses a [`ListArray`] by narrowing offsets and recursively compressing elements.
+    fn compress_list_array(
+        &self,
+        list_array: ListArray,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let list_array = list_array.reset_offsets(true)?;
+
+        let compressed_elems = self.compress(list_array.elements())?;
+
+        // Record the root scheme with the offsets child index so root exclusion rules apply.
+        let offset_ctx = ctx.descend_with_scheme(ROOT_SCHEME_ID, root_list_children::OFFSETS);
+        let compressed_offsets = self.compress_canonical(
+            Canonical::Primitive(list_array.offsets().to_primitive().narrow()?),
+            offset_ctx,
+        )?;
+
+        Ok(
+            ListArray::try_new(compressed_elems, compressed_offsets, list_array.validity()?)?
+                .into_array(),
+        )
+    }
+
+    /// Compresses a [`ListViewArray`] by narrowing offsets/sizes and recursively compressing
+    /// elements.
+    fn compress_list_view_array(
+        &self,
+        list_view: ListViewArray,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let compressed_elems = self.compress(list_view.elements())?;
+
+        let offset_ctx = ctx
+            .clone()
+            .descend_with_scheme(ROOT_SCHEME_ID, root_list_children::OFFSETS);
+        let compressed_offsets = self.compress_canonical(
+            Canonical::Primitive(list_view.offsets().to_primitive().narrow()?),
+            offset_ctx,
+        )?;
+
+        let sizes_ctx = ctx.descend_with_scheme(ROOT_SCHEME_ID, root_list_children::SIZES);
+        let compressed_sizes = self.compress_canonical(
+            Canonical::Primitive(list_view.sizes().to_primitive().narrow()?),
+            sizes_ctx,
+        )?;
+
+        Ok(ListViewArray::try_new(
+            compressed_elems,
+            compressed_offsets,
+            compressed_sizes,
+            list_view.validity()?,
+        )?
+        .into_array())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+
+    use super::*;
+    use crate::builtins::FloatDictScheme;
+    use crate::builtins::IntDictScheme;
+    use crate::builtins::StringDictScheme;
+    use crate::ctx::CompressorContext;
+    use crate::scheme::SchemeExt;
+
+    fn compressor() -> CascadingCompressor {
+        CascadingCompressor::new(vec![&IntDictScheme, &FloatDictScheme, &StringDictScheme])
+    }
+
+    #[test]
+    fn test_self_exclusion() {
+        let c = compressor();
+        let ctx = CompressorContext::default().descend_with_scheme(IntDictScheme.id(), 0);
+
+        // IntDictScheme is in the history, so it should be excluded.
+        assert!(c.is_excluded(&IntDictScheme, &ctx));
+    }
+
+    #[test]
+    fn test_root_exclusion_list_offsets() {
+        let c = compressor();
+        let ctx = CompressorContext::default()
+            .descend_with_scheme(ROOT_SCHEME_ID, root_list_children::OFFSETS);
+
+        // IntDict should be excluded for list offsets.
+        assert!(c.is_excluded(&IntDictScheme, &ctx));
+    }
+
+    #[test]
+    fn test_push_rule_float_dict_excludes_int_dict_from_codes() {
+        let c = compressor();
+        // FloatDict cascading through codes (child 1).
+        let ctx = CompressorContext::default().descend_with_scheme(FloatDictScheme.id(), 1);
+
+        // IntDict should be excluded from FloatDict's codes child.
+        assert!(c.is_excluded(&IntDictScheme, &ctx));
+    }
+
+    #[test]
+    fn test_push_rule_float_dict_excludes_int_dict_from_values() {
+        let c = compressor();
+        // FloatDict cascading through values (child 0).
+        let ctx = CompressorContext::default().descend_with_scheme(FloatDictScheme.id(), 0);
+
+        // IntDict should also be excluded from FloatDict's values child (ALP propagation
+        // replacement).
+        assert!(c.is_excluded(&IntDictScheme, &ctx));
+    }
+
+    #[test]
+    fn test_no_exclusion_without_history() {
+        let c = compressor();
+        let ctx = CompressorContext::default();
+
+        // No history means no exclusions.
+        assert!(!c.is_excluded(&IntDictScheme, &ctx));
+    }
+
+    #[test]
+    fn all_null_array_compresses_to_constant() -> VortexResult<()> {
+        let array = PrimitiveArray::new(
+            buffer![0i32, 0, 0, 0, 0],
+            Validity::Array(BoolArray::from_iter([false, false, false, false, false]).into_array()),
+        )
+        .into_array();
+
+        // The compressor should produce a `ConstantArray` for an all-null array regardless of
+        // which schemes are registered.
+        let compressor = CascadingCompressor::new(vec![&IntDictScheme]);
+        let compressed = compressor.compress(&array)?;
+        assert!(compressed.is::<Constant>());
+        Ok(())
+    }
+
+    /// Regression test for <https://github.com/vortex-data/vortex/issues/7227>.
+    ///
+    /// `estimate_compression_ratio_with_sampling` must use the *scheme's* stats options
+    /// (which request distinct-value counting) rather than the context's stats options
+    /// (which may not). With the old code this panicked inside `dictionary_encode` because
+    /// distinct values were never computed for the sample.
+    #[test]
+    fn sampling_uses_scheme_stats_options() -> VortexResult<()> {
+        // Low-cardinality float array so FloatDictScheme considers it compressible.
+        let array = PrimitiveArray::new(
+            buffer![1.0f32, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0],
+            Validity::NonNullable,
+        )
+        .into_array();
+
+        let compressor = CascadingCompressor::new(vec![&FloatDictScheme]);
+
+        // A context with default stats_options (count_distinct_values = false) and
+        // marked as a sample so the function skips the sampling step and compresses
+        // the array directly.
+        let ctx = CompressorContext::new().with_sampling();
+
+        // Before the fix this panicked with:
+        //   "this must be present since `DictScheme` declared that we need distinct values"
+        let ratio =
+            estimate_compression_ratio_with_sampling(&FloatDictScheme, &compressor, &array, ctx)?;
+        assert!(ratio.is_finite());
+        Ok(())
+    }
+}
diff --git a/vortex-compressor/src/ctx.rs b/vortex-compressor/src/ctx.rs
new file mode 100644
index 00000000000..a488bef17bf
--- /dev/null
+++ b/vortex-compressor/src/ctx.rs
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compression context for recursive compression.
+
+use vortex_error::VortexExpect;
+
+use crate::scheme::SchemeId;
+use crate::stats::GenerateStatsOptions;
+
+// TODO(connor): Why is this 3??? This doesn't seem smart or adaptive.
+/// Maximum cascade depth for compression.
+pub const MAX_CASCADE: usize = 3;
+
+/// Context passed through recursive compression calls.
+///
+/// Tracks the cascade history (which schemes and child indices have been applied in the current
+/// chain) so the compressor can enforce exclusion rules and prevent cycles.
+#[derive(Debug, Clone)]
+pub struct CompressorContext {
+    /// Whether we're compressing a sample (for ratio estimation).
+    is_sample: bool,
+
+    /// Remaining cascade depth allowed.
+    allowed_cascading: usize,
+
+    /// Merged stats options from all eligible schemes at this compression site.
+    merged_stats_options: GenerateStatsOptions,
+
+    /// The cascade chain: `(scheme_id, child_index)` pairs from root to current depth.
+    /// Used for self-exclusion, push rules ([`descendant_exclusions`]), and pull rules
+    /// ([`ancestor_exclusions`]).
+    ///
+    /// [`descendant_exclusions`]: crate::scheme::Scheme::descendant_exclusions
+    /// [`ancestor_exclusions`]: crate::scheme::Scheme::ancestor_exclusions
+    cascade_history: Vec<(SchemeId, usize)>,
+}
+
+impl CompressorContext {
+    /// Creates a new `CompressorContext`.
+    ///
+    /// This should **only** be created by the compressor.
+    pub(super) fn new() -> Self {
+        Self {
+            is_sample: false,
+            allowed_cascading: MAX_CASCADE,
+            merged_stats_options: GenerateStatsOptions::default(),
+            cascade_history: Vec::new(),
+        }
+    }
+}
+
+#[cfg(test)]
+impl Default for CompressorContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CompressorContext {
+    /// Whether this context is for sample compression (ratio estimation).
+    pub fn is_sample(&self) -> bool {
+        self.is_sample
+    }
+
+    /// Returns the merged stats generation options for this compression site.
+    pub fn merged_stats_options(&self) -> GenerateStatsOptions {
+        self.merged_stats_options
+    }
+
+    /// Returns the cascade chain of `(scheme_id, child_index)` pairs.
+    pub fn cascade_history(&self) -> &[(SchemeId, usize)] {
+        &self.cascade_history
+    }
+
+    /// Whether cascading is exhausted (no further cascade levels allowed).
+    ///
+    /// This should only be used in the implementation of a [`Scheme`](crate::scheme::Scheme) if the
+    /// scheme knows that it's child _must_ be compressed for it to make any sense being chosen.
+    pub fn finished_cascading(&self) -> bool {
+        self.allowed_cascading == 0
+    }
+
+    /// Returns a context that disallows further cascading.
+    pub fn as_leaf(mut self) -> Self {
+        self.allowed_cascading = 0;
+        self
+    }
+
+    /// Returns a context with the given stats options.
+    pub(super) fn with_merged_stats_options(mut self, opts: GenerateStatsOptions) -> Self {
+        self.merged_stats_options = opts;
+        self
+    }
+
+    /// Returns a context marked as sample compression.
+    pub(super) fn with_sampling(mut self) -> Self {
+        self.is_sample = true;
+        self
+    }
+
+    /// Descends one level in the cascade, recording the current scheme and which child is
+    /// being compressed.
+    ///
+    /// The `child_index` identifies which child of the scheme is being compressed (e.g. for
+    /// Dict: values=0, codes=1).
+    pub(super) fn descend_with_scheme(mut self, id: SchemeId, child_index: usize) -> Self {
+        self.allowed_cascading = self
+            .allowed_cascading
+            .checked_sub(1)
+            .vortex_expect("cannot descend: cascade depth exhausted");
+        self.cascade_history.push((id, child_index));
+        self
+    }
+}
diff --git a/vortex-compressor/src/estimate.rs b/vortex-compressor/src/estimate.rs
new file mode 100644
index 00000000000..b1e3ae3c659
--- /dev/null
+++ b/vortex-compressor/src/estimate.rs
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compression ratio estimation types and sampling-based estimation.
+
+use std::fmt;
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::ctx::CompressorContext;
+use crate::sample::SAMPLE_SIZE;
+use crate::sample::sample;
+use crate::sample::sample_count_approx_one_percent;
+use crate::scheme::Scheme;
+use crate::stats::ArrayAndStats;
+
+/// Closure type for [`CompressionEstimate::Estimate`]. The compressor calls this with the same
+/// arguments it would pass to sampling.
+#[rustfmt::skip]
+pub type EstimateFn = dyn FnOnce(
+        &CascadingCompressor,
+        &mut ArrayAndStats,
+        CompressorContext,
+    ) -> VortexResult<CompressionEstimate>
+    + Send
+    + Sync;
+
+// TODO(connor): We should make use of the fact that some checks are cheap and some checks are
+// expensive (sample or estimate variants).
+/// The result of a [`Scheme`]'s compression ratio estimation.
+///
+/// This type is returned by [`Scheme::expected_compression_ratio`] to tell the compressor how
+/// promising this scheme is for a given array without performing any expensive work.
+///
+/// All expensive or fallible operations (sampling, trial encoding) are deferred to the compressor
+/// via the [`Sample`](CompressionEstimate::Sample) and [`Estimate`](CompressionEstimate::Estimate)
+/// variants.
+///
+/// [`Sample`]: CompressionEstimate::Sample
+/// [`Estimate`]: CompressionEstimate::Estimate
+pub enum CompressionEstimate {
+    /// Do not use this scheme for this array.
+    Skip,
+
+    /// Always use this scheme, as we know it is definitively the best choice.
+    ///
+    /// Some examples include constant detection, decimal byte parts, and temporal decomposition.
+    ///
+    /// The compressor will select this scheme immediately without evaluating further candidates.
+    /// Schemes that return `AlwaysUse` must be mutually exclusive per canonical type (enforced by
+    /// [`Scheme::matches`]), otherwise the winner depends silently on registration order.
+    ///
+    /// [`Scheme::matches`]: crate::scheme::Scheme::matches
+    AlwaysUse,
+
+    /// The estimated compression ratio. This must be greater than `1.0` to be considered by the
+    /// compressor, otherwise it is worse than the canonical encoding.
+    Ratio(f64),
+
+    /// The scheme cannot cheaply estimate its ratio, so the compressor should compress a small
+    /// sample to determine effectiveness.
+    Sample,
+
+    /// A fallible estimation requiring a custom expensive computation. The compressor will call the
+    /// closure and handle the result.
+    ///
+    /// Use this only when the scheme needs to perform trial encoding or other costly checks to
+    /// determine its compression ratio.
+    ///
+    /// The estimation function must **not** return a [`Sample`](CompressionEstimate::Sample) or
+    /// [`Estimate`](CompressionEstimate::Estimate) variant to ensure the estimation process is
+    /// bounded.
+    Estimate(Box<EstimateFn>),
+}
+
+/// Returns `true` if `ratio` is a valid compression ratio (> 1.0, finite, not subnormal) that
+/// beats the current best.
+pub(super) fn is_better_ratio(ratio: f64, best: &Option<(&'static dyn Scheme, f64)>) -> bool {
+    ratio.is_finite() && !ratio.is_subnormal() && ratio > 1.0 && best.is_none_or(|(_, r)| ratio > r)
+}
+
+/// Estimates compression ratio by compressing a ~1% sample of the data.
+///
+/// Creates a new [`ArrayAndStats`] for the sample so that stats are generated from the sample, not
+/// the full array.
+///
+/// # Errors
+///
+/// Returns an error if sample compression fails.
+pub(super) fn estimate_compression_ratio_with_sampling<S: Scheme + ?Sized>(
+    scheme: &S,
+    compressor: &CascadingCompressor,
+    array: &ArrayRef,
+    ctx: CompressorContext,
+) -> VortexResult<f64> {
+    let sample_array = if ctx.is_sample() {
+        array.clone()
+    } else {
+        let source_len = array.len();
+        let sample_count = sample_count_approx_one_percent(source_len);
+
+        tracing::trace!(
+            "Sampling {} values out of {}",
+            SAMPLE_SIZE as u64 * sample_count as u64,
+            source_len
+        );
+
+        // `ArrayAndStats` expects a canonical array (so that it can easily compute lazy stats).
+        let canonical: Canonical =
+            sample(array, SAMPLE_SIZE, sample_count).execute(&mut compressor.execution_ctx())?;
+        canonical.into_array()
+    };
+
+    let mut sample_data = ArrayAndStats::new(sample_array, scheme.stats_options());
+    let sample_ctx = ctx.with_sampling();
+
+    let after = scheme
+        .compress(compressor, &mut sample_data, sample_ctx)?
+        .nbytes();
+    let before = sample_data.array().nbytes();
+
+    // TODO(connor): Issue https://github.com/vortex-data/vortex/issues/7268.
+    // if after == 0 {
+    //     tracing::warn!(
+    //         scheme = %scheme.id(),
+    //         "sample compressed to 0 bytes, which should only happen for constant arrays",
+    //     );
+    // }
+
+    let ratio = before as f64 / after as f64;
+
+    tracing::debug!("estimate_compression_ratio_with_sampling(compressor={scheme:#?}) = {ratio}",);
+
+    Ok(ratio)
+}
+
+impl fmt::Debug for CompressionEstimate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CompressionEstimate::Skip => write!(f, "Skip"),
+            CompressionEstimate::AlwaysUse => write!(f, "AlwaysUse"),
+            CompressionEstimate::Ratio(r) => f.debug_tuple("Ratio").field(r).finish(),
+            CompressionEstimate::Sample => write!(f, "Sample"),
+            CompressionEstimate::Estimate(_) => write!(f, "Estimate(..)"),
+        }
+    }
+}
diff --git a/vortex-compressor/src/lib.rs b/vortex-compressor/src/lib.rs
new file mode 100644
index 00000000000..65fd3f09c56
--- /dev/null
+++ b/vortex-compressor/src/lib.rs
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![deny(missing_docs)]
+#![warn(clippy::missing_docs_in_private_items)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
+#![warn(clippy::missing_safety_doc)]
+
+//! Encoding-agnostic compression framework for Vortex arrays.
+//!
+//! This crate provides the core compression engine: the [`Scheme`](scheme::Scheme) trait,
+//! sampling-based ratio estimation, cascaded compression, and statistics infrastructure for
+//! deciding the best encoding scheme for an array.
+//!
+//! This crate contains no encoding dependencies. Batteries-included compressors are provided by
+//! downstream crates like `vortex-btrblocks`, which register different encodings to the compressor.
+
+pub mod builtins;
+pub mod ctx;
+pub mod estimate;
+pub mod scheme;
+pub mod stats;
+
+mod sample;
+
+mod compressor;
+pub use compressor::CascadingCompressor;
diff --git a/vortex-compressor/src/sample.rs b/vortex-compressor/src/sample.rs
new file mode 100644
index 00000000000..4821c7c6d95
--- /dev/null
+++ b/vortex-compressor/src/sample.rs
@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Sampling utilities for compression ratio estimation.
+
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::prelude::StdRng;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ChunkedArray;
+use vortex_error::VortexExpect;
+
+/// The size of each sampled run.
+pub const SAMPLE_SIZE: u32 = 64;
+
+/// The number of sampled runs.
+///
+/// # Warning
+///
+/// The product of `SAMPLE_SIZE` and `SAMPLE_COUNT` should be (roughly) a multiple of 1024 so that
+/// fastlanes bitpacking of sampled vectors does not introduce (large amounts of) padding.
+pub const SAMPLE_COUNT: u32 = 16;
+
+/// Fixed seed for the sampling RNG, ensuring deterministic compression output.
+const SAMPLE_SEED: u64 = 1234567890;
+
+/// Samples approximately 1% of the input array for compression ratio estimation.
+pub(crate) fn sample(input: &ArrayRef, sample_size: u32, sample_count: u32) -> ArrayRef {
+    if input.len() <= (sample_size as usize) * (sample_count as usize) {
+        return input.clone();
+    }
+
+    let slices = stratified_slices(
+        input.len(),
+        sample_size,
+        sample_count,
+        &mut StdRng::seed_from_u64(SAMPLE_SEED),
+    );
+
+    // For every slice, grab the relevant slice and repack into a new PrimitiveArray.
+    let chunks: Vec<_> = slices
+        .into_iter()
+        .map(|(start, end)| {
+            input
+                .slice(start..end)
+                .vortex_expect("slice should succeed")
+        })
+        .collect();
+    // SAFETY: all chunks are slices of `input`, so they share its dtype.
+    unsafe { ChunkedArray::new_unchecked(chunks, input.dtype().clone()) }.into_array()
+}
+
+/// Computes the number of sample chunks to cover approximately 1% of `len` elements,
+/// with a minimum of `SAMPLE_SIZE * SAMPLE_COUNT` (1024) values.
+pub(crate) fn sample_count_approx_one_percent(len: usize) -> u32 {
+    let approximately_one_percent =
+        (len / 100) / usize::try_from(SAMPLE_SIZE).vortex_expect("SAMPLE_SIZE must fit in usize");
+    u32::max(
+        u32::next_multiple_of(
+            approximately_one_percent
+                .try_into()
+                .vortex_expect("sample count must fit in u32"),
+            16,
+        ),
+        SAMPLE_COUNT,
+    )
+}
+
+/// Divides an array into `sample_count` equal partitions and picks one random contiguous
+/// slice of `sample_size` elements from each partition.
+///
+/// This is a stratified sampling strategy: instead of drawing all samples from one region,
+/// it spreads them evenly across the array so that every part of the data is represented.
+/// Each returned `(start, end)` pair is a half-open range into the original array.
+///
+/// If the total number of requested samples (`sample_size * sample_count`) is greater than or
+/// equal to `length`, a single slice spanning the whole array is returned.
+fn stratified_slices(
+    length: usize,
+    sample_size: u32,
+    sample_count: u32,
+    rng: &mut StdRng,
+) -> Vec<(usize, usize)> {
+    let total_num_samples: usize = (sample_count as usize) * (sample_size as usize);
+    if total_num_samples >= length {
+        return vec![(0usize, length)];
+    }
+
+    let partitions = partition_indices(length, sample_count);
+    let num_samples_per_partition: Vec<usize> = partition_indices(total_num_samples, sample_count)
+        .into_iter()
+        .map(|(start, stop)| stop - start)
+        .collect();
+
+    partitions
+        .into_iter()
+        .zip(num_samples_per_partition)
+        .map(|((start, stop), size)| {
+            assert!(
+                stop - start >= size,
+                "Slices must be bigger than their sampled size"
+            );
+            let random_start = rng.random_range(start..=(stop - size));
+            (random_start, random_start + size)
+        })
+        .collect()
+}
+
+/// Splits `[0, length)` into `num_partitions` contiguous, non-overlapping slices of
+/// approximately equal size.
+///
+/// If `length` is not evenly divisible by `num_partitions`, the first
+/// `length % num_partitions` slices get one extra element. Each returned `(start, end)` pair
+/// is a half-open range.
+fn partition_indices(length: usize, num_partitions: u32) -> Vec<(usize, usize)> {
+    let num_long_parts = length % num_partitions as usize;
+    let short_step = length / num_partitions as usize;
+    let long_step = short_step + 1;
+    let long_stop = num_long_parts * long_step;
+
+    (0..long_stop)
+        .step_by(long_step)
+        .map(|off| (off, off + long_step))
+        .chain(
+            (long_stop..length)
+                .step_by(short_step)
+                .map(|off| (off, off + short_step)),
+        )
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+
+    use super::*;
+
+    #[test]
+    fn sample_is_deterministic() -> VortexResult<()> {
+        // Create a deterministic array with linear-with-noise pattern
+        let values: Vec<i64> = (0i64..100_000).map(|i| i + (i * 7 + 3) % 11).collect();
+
+        let array =
+            PrimitiveArray::new(Buffer::from_iter(values), Validity::NonNullable).into_array();
+
+        let first = sample(&array, SAMPLE_SIZE, SAMPLE_COUNT);
+        for _ in 0..10 {
+            let again = sample(&array, SAMPLE_SIZE, SAMPLE_COUNT);
+            assert_eq!(first.nbytes(), again.nbytes());
+            assert_arrays_eq!(&first, &again);
+        }
+        Ok(())
+    }
+}
diff --git a/vortex-compressor/src/scheme.rs b/vortex-compressor/src/scheme.rs
new file mode 100644
index 00000000000..66b35051e95
--- /dev/null
+++ b/vortex-compressor/src/scheme.rs
@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Unified compression scheme trait and exclusion rules.
+
+use std::fmt;
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::hash::Hasher;
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_error::VortexResult;
+
+use crate::CascadingCompressor;
+use crate::ctx::CompressorContext;
+use crate::estimate::CompressionEstimate;
+use crate::stats::ArrayAndStats;
+use crate::stats::GenerateStatsOptions;
+
+/// Unique identifier for a compression scheme.
+///
+/// The only way to obtain a [`SchemeId`] is through [`SchemeExt::id()`], which is
+/// auto-implemented for all [`Scheme`] types. There is no public constructor.
+///
+/// The only exception to this is for `ROOT_SCHEME_ID` in `compressor.rs`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SchemeId {
+    /// Only constructable within `vortex-compressor`.
+    ///
+    /// The only public way to obtain a [`SchemeId`] is through [`SchemeExt::id()`].
+    pub(super) name: &'static str,
+}
+
+impl fmt::Display for SchemeId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.name)
+    }
+}
+
+/// Selects which children of a cascading scheme a rule applies to.
+#[derive(Debug, Clone, Copy)]
+pub enum ChildSelection {
+    /// Rule applies to all children.
+    All,
+    /// Rule applies to a single child.
+    One(usize),
+    /// Rule applies to multiple specific children.
+    Many(&'static [usize]),
+}
+
+impl ChildSelection {
+    /// Returns `true` if this selection includes the given child index.
+    pub fn contains(&self, child_index: usize) -> bool {
+        match self {
+            ChildSelection::All => true,
+            ChildSelection::One(idx) => *idx == child_index,
+            ChildSelection::Many(indices) => indices.contains(&child_index),
+        }
+    }
+}
+
+/// Push rule: declared by a cascading scheme to exclude another scheme from the subtree
+/// rooted at the specified children.
+///
+/// Use this when the declaring scheme (the ancestor) knows about the excluded scheme. For example,
+/// `ZigZag` excludes `Dict` from all its children.
+#[derive(Debug, Clone, Copy)]
+pub struct DescendantExclusion {
+    /// The scheme to exclude from descendants.
+    pub excluded: SchemeId,
+    /// Which children of the declaring scheme this rule applies to.
+    pub children: ChildSelection,
+}
+
+/// Pull rule: declared by a scheme to exclude itself when the specified ancestor is in the
+/// cascade chain.
+///
+/// Use this when the excluded scheme (the descendant) knows about the ancestor. For example,
+/// `Sequence` excludes itself when `IntDict` is an ancestor on its codes child.
+#[derive(Debug, Clone, Copy)]
+pub struct AncestorExclusion {
+    /// The ancestor scheme that makes the declaring scheme ineligible.
+    pub ancestor: SchemeId,
+    /// Which children of the ancestor this rule applies to.
+    pub children: ChildSelection,
+}
+
+// TODO(connor): Remove all default implemented methods.
+/// A single compression encoding that the [`CascadingCompressor`] can select from.
+///
+/// The compressor evaluates every registered scheme whose [`matches`] returns `true` for a given
+/// array, picks the one with the highest [`expected_compression_ratio`], and calls [`compress`] on
+/// the winner.
+///
+/// One of the key features of the compressor in this crate is that schemes may "cascade". A
+/// scheme's [`compress`] can call back into the compressor via
+/// [`CascadingCompressor::compress_child`] to compress child or transformed arrays, building up
+/// multiple encoding layers (e.g. frame-of-reference and then bit-packing).
+///
+/// # Scheme IDs
+///
+/// Every scheme has a globally unique name returned by [`scheme_name`]. The [`SchemeExt::id`]
+/// method (auto-implemented, cannot be overridden) wraps that name in an opaque [`SchemeId`] used
+/// for equality, hashing, and exclusion rules (see below).
+///
+/// # Cascading and children
+///
+/// Schemes that produce child arrays for further compression must declare [`num_children`] > 0.
+/// Each child should be identified by a stable index. Cascading schemes should use
+/// [`CascadingCompressor::compress_child`] to compress each child array, which handles cascade
+/// level / budget tracking and context management automatically.
+///
+/// No scheme may appear twice in a cascade (descendant) chain (enforced by the compressor). This
+/// keeps the search space a tree.
+///
+/// # Exclusion rules
+///
+/// Schemes declare exclusion rules to prevent incompatible scheme combinations in the cascade
+/// chain:
+///
+/// - [`descendant_exclusions`] (push): "exclude scheme X from my child Y's subtree." Used when the
+///   declaring scheme knows about the excluded scheme.
+/// - [`ancestor_exclusions`] (pull): "exclude me if ancestor X's child Y is above me." Used when
+///   the declaring scheme knows about the ancestor.
+///
+/// We do this because different schemes will live in different crates, and we cannot know the
+/// dependency direction ahead of time.
+///
+/// # Implementing a scheme
+///
+/// [`expected_compression_ratio`] should return [`CompressionEstimate::Sample`] when a cheap
+/// heuristic is not available, asking the compressor to estimate via sampling. Implementors should
+/// return a more specific variant when possible (e.g. [`CompressionEstimate::AlwaysUse`] for
+/// constant detection or [`CompressionEstimate::Skip`] for early rejection based on stats).
+///
+/// Schemes that need statistics that may be expensive to compute should override [`stats_options`]
+/// to declare what they require. The compressor merges all eligible schemes' options before
+/// generating stats, so each stat is always computed at most once for a given array.
+///
+/// [`scheme_name`]: Scheme::scheme_name
+/// [`matches`]: Scheme::matches
+/// [`compress`]: Scheme::compress
+/// [`expected_compression_ratio`]: Scheme::expected_compression_ratio
+/// [`stats_options`]: Scheme::stats_options
+/// [`num_children`]: Scheme::num_children
+/// [`descendant_exclusions`]: Scheme::descendant_exclusions
+/// [`ancestor_exclusions`]: Scheme::ancestor_exclusions
+pub trait Scheme: Debug + Send + Sync {
+    /// The globally unique name for this scheme (e.g. `"vortex.int.bitpacking"`).
+    fn scheme_name(&self) -> &'static str;
+
+    /// Whether this scheme can compress the given canonical array.
+    fn matches(&self, canonical: &Canonical) -> bool;
+
+    /// Returns the stats generation options this scheme requires. The compressor merges all
+    /// eligible schemes' options before generating stats so that a single stats pass satisfies
+    /// every scheme.
+    fn stats_options(&self) -> GenerateStatsOptions {
+        GenerateStatsOptions::default()
+    }
+
+    /// The number of child arrays this scheme produces when cascading. Returns 0 for leaf
+    /// schemes that produce a final encoded array.
+    fn num_children(&self) -> usize {
+        0
+    }
+
+    /// Schemes to exclude from specific children's subtrees (push direction).
+    ///
+    /// Each rule says: "when I cascade through child Y, do not use scheme X anywhere in that
+    /// subtree." Only meaningful when [`num_children`](Scheme::num_children) > 0.
+    fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
+        Vec::new()
+    }
+
+    /// Ancestors that make this scheme ineligible (pull direction).
+    ///
+    /// Each rule says: "if ancestor X cascaded through child Y somewhere above me in the chain, do
+    /// not try me."
+    fn ancestor_exclusions(&self) -> Vec<AncestorExclusion> {
+        Vec::new()
+    }
+
+    /// Cheaply estimate the compression ratio for this scheme on the given array.
+    ///
+    /// This method should be fast and infallible. Any expensive or fallible work should be deferred
+    /// to the compressor by returning [`CompressionEstimate::Sample`] or
+    /// [`CompressionEstimate::Estimate`].
+    ///
+    /// The compressor will ask all schemes what their expected compression ratio is given the array
+    /// and statistics. The scheme with the highest estimated ratio will then be applied to the
+    /// entire array.
+    ///
+    /// Note that the compressor will also use this method when compressing samples, so some
+    /// statistics that might hold for the samples may not hold for the entire array (e.g.,
+    /// `Constant`). Implementations should check `ctx.is_sample` to make sure that they are
+    /// returning the correct information.
+    ///
+    /// The compressor guarantees that empty and all-null arrays are handled before this method is
+    /// called. Implementations may assume the array has at least one valid element. However, a
+    /// constant scheme should still be registered with the compressor to detect single-value arrays
+    /// that are not all-null.
+    fn expected_compression_ratio(
+        &self,
+        _data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate;
+
+    /// Compress the array using this scheme.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if compression fails.
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef>;
+}
+
+impl PartialEq for dyn Scheme {
+    fn eq(&self, other: &Self) -> bool {
+        self.id() == other.id()
+    }
+}
+
+impl Eq for dyn Scheme {}
+
+impl Hash for dyn Scheme {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id().hash(state);
+    }
+}
+
+/// Extension trait providing [`id`](SchemeExt::id) for all [`Scheme`] implementors.
+///
+/// This trait is automatically implemented for every type that implements [`Scheme`]. Because the
+/// blanket implementation covers all types, external crates cannot override `id()`.
+pub trait SchemeExt: Scheme {
+    /// Unique identifier derived from [`scheme_name`](Scheme::scheme_name).
+    fn id(&self) -> SchemeId {
+        SchemeId {
+            name: self.scheme_name(),
+        }
+    }
+}
+
+impl<T: Scheme + ?Sized> SchemeExt for T {}
diff --git a/vortex-compressor/src/stats/bool.rs b/vortex-compressor/src/stats/bool.rs
new file mode 100644
index 00000000000..4f357f048aa
--- /dev/null
+++ b/vortex-compressor/src/stats/bool.rs
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Bool compression statistics.
+
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::bool::BoolArrayExt;
+use vortex_error::VortexResult;
+use vortex_mask::AllOr;
+
+/// Array of booleans and relevant stats for compression.
+#[derive(Clone, Debug)]
+pub struct BoolStats {
+    /// Number of null values.
+    null_count: u32,
+    /// Number of non-null values.
+    value_count: u32,
+    /// Number of `true` values among valid (non-null) elements.
+    true_count: u32,
+}
+
+impl BoolStats {
+    /// Generates stats, returning an error on failure.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if getting validity mask fails or values exceed `u32` bounds.
+    pub fn generate(input: &BoolArray) -> VortexResult<Self> {
+        if input.is_empty() {
+            return Ok(Self {
+                null_count: 0,
+                value_count: 0,
+                true_count: 0,
+            });
+        }
+
+        if input.all_invalid()? {
+            return Ok(Self {
+                null_count: u32::try_from(input.len())?,
+                value_count: 0,
+                true_count: 0,
+            });
+        }
+
+        let validity = input.validity_mask()?;
+        let null_count = validity.false_count();
+        let value_count = validity.true_count();
+
+        let bits = input.to_bit_buffer();
+
+        // Count how many true values exist among valid elements.
+        let true_count = match validity.bit_buffer() {
+            AllOr::All => bits.true_count(),
+            AllOr::None => unreachable!("all-invalid handled above"),
+            AllOr::Some(v) => {
+                // AND the bits with validity to only count valid trues.
+                (&bits & v).true_count()
+            }
+        };
+
+        Ok(Self {
+            null_count: u32::try_from(null_count)?,
+            value_count: u32::try_from(value_count)?,
+            true_count: u32::try_from(true_count)?,
+        })
+    }
+
+    /// Returns the number of null values.
+    pub fn null_count(&self) -> u32 {
+        self.null_count
+    }
+
+    /// Returns the number of non-null values.
+    pub fn value_count(&self) -> u32 {
+        self.value_count
+    }
+
+    /// Returns the number of `true` values among valid elements.
+    pub fn true_count(&self) -> u32 {
+        self.true_count
+    }
+
+    /// Returns `true` if all valid values are the same (all-true or all-false).
+    pub fn is_constant(&self) -> bool {
+        self.value_count > 0 && (self.true_count == 0 || self.true_count == self.value_count)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::arrays::BoolArray;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::BitBuffer;
+    use vortex_error::VortexResult;
+
+    use super::BoolStats;
+
+    #[test]
+    fn test_all_true() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![true, true, true]),
+            Validity::NonNullable,
+        );
+        let stats = BoolStats::generate(&array)?;
+        assert_eq!(stats.value_count, 3);
+        assert_eq!(stats.null_count, 0);
+        assert_eq!(stats.true_count, 3);
+        assert!(stats.is_constant());
+        Ok(())
+    }
+
+    #[test]
+    fn test_all_false() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![false, false, false]),
+            Validity::NonNullable,
+        );
+        let stats = BoolStats::generate(&array)?;
+        assert_eq!(stats.value_count, 3);
+        assert_eq!(stats.null_count, 0);
+        assert_eq!(stats.true_count, 0);
+        assert!(stats.is_constant());
+        Ok(())
+    }
+
+    #[test]
+    fn test_mixed() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![true, false, true]),
+            Validity::NonNullable,
+        );
+        let stats = BoolStats::generate(&array)?;
+        assert_eq!(stats.value_count, 3);
+        assert_eq!(stats.null_count, 0);
+        assert_eq!(stats.true_count, 2);
+        assert!(!stats.is_constant());
+        Ok(())
+    }
+
+    #[test]
+    fn test_with_nulls() -> VortexResult<()> {
+        let array = BoolArray::new(
+            BitBuffer::from(vec![true, false, true]),
+            Validity::from_iter([true, false, true]),
+        );
+        let stats = BoolStats::generate(&array)?;
+        assert_eq!(stats.value_count, 2);
+        assert_eq!(stats.null_count, 1);
+        assert_eq!(stats.true_count, 2);
+        assert!(stats.is_constant());
+        Ok(())
+    }
+}
diff --git a/vortex-compressor/src/stats/cache.rs b/vortex-compressor/src/stats/cache.rs
new file mode 100644
index 00000000000..4582f9e3b09
--- /dev/null
+++ b/vortex-compressor/src/stats/cache.rs
@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Per-compression-site statistics cache and the [`ArrayAndStats`] bundle.
+
+use std::any::Any;
+use std::any::TypeId;
+
+use vortex_array::ArrayRef;
+use vortex_array::ToCanonical;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::VarBinView;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_error::VortexExpect;
+
+use super::BoolStats;
+use super::FloatStats;
+use super::GenerateStatsOptions;
+use super::IntegerStats;
+use super::StringStats;
+
+/// Cache for compression statistics, keyed by concrete type.
+struct StatsCache {
+    // TODO(connor): We could further optimize this with a `SmallVec` here.
+    /// The cache entries, keyed by [`TypeId`].
+    ///
+    /// The total number of statistics types in this stats should be relatively small, so we use a
+    /// vector instead of a hash map.
+    entries: Vec<(TypeId, Box<dyn Any>)>,
+}
+
+impl StatsCache {
+    /// Creates a new empty cache.
+    fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+        }
+    }
+
+    /// Returns a cached value, computing it on first access.
+    fn get_or_insert_with<T: 'static>(&mut self, f: impl FnOnce() -> T) -> &T {
+        let type_id = TypeId::of::<T>();
+        let pos = self.entries.iter().position(|(id, _)| *id == type_id);
+
+        if let Some(pos) = pos {
+            self.entries[pos]
+                .1
+                .downcast_ref::<T>()
+                .vortex_expect("we just checked the TypeID")
+        } else {
+            self.entries.push((type_id, Box::new(f())));
+            self.entries
+                .last()
+                .vortex_expect("just pushed")
+                .1
+                .downcast_ref::<T>()
+                .vortex_expect("we just checked the TypeID")
+        }
+    }
+}
+
+/// An array bundled with its lazily-computed statistics cache.
+///
+/// The cache is guaranteed to correspond to the array. When a scheme creates a derived array (e.g.
+/// FoR bias subtraction), it must create a new [`ArrayAndStats`] so that stale stats from the
+/// original array are not reused.
+///
+/// Built-in stats are accessed via typed methods (`integer_stats`, `float_stats`, `string_stats`)
+/// which generate stats lazily on first access using the stored [`GenerateStatsOptions`].
+///
+/// Extension schemes can use `get_or_insert_with` for custom stats types.
+pub struct ArrayAndStats {
+    /// The array. This is always in canonical form.
+    array: ArrayRef,
+    /// The stats cache.
+    cache: StatsCache,
+    /// The stats generation options.
+    opts: GenerateStatsOptions,
+}
+
+impl ArrayAndStats {
+    /// Creates a new bundle with the given stats generation options.
+    ///
+    /// Stats are generated lazily on first access via the typed accessor methods.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the array is not canonical.
+    pub fn new(array: ArrayRef, opts: GenerateStatsOptions) -> Self {
+        assert!(
+            array.is_canonical(),
+            "ArrayAndStats should only be created with canonical arrays"
+        );
+
+        Self {
+            array,
+            cache: StatsCache::new(),
+            opts,
+        }
+    }
+
+    /// Returns a reference to the array.
+    pub fn array(&self) -> &ArrayRef {
+        &self.array
+    }
+
+    // TODO(connor): This should return an `ArrayView<Primitive>` once more vtable changes land.
+    /// Returns the array as a [`PrimitiveArray`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the array is not a primitive array.
+    pub fn array_as_primitive(&self) -> PrimitiveArray {
+        self.array
+            .as_opt::<Primitive>()
+            .vortex_expect("the array is guaranteed to already be canonical by construction")
+            .into_owned()
+    }
+
+    // TODO(connor): This should return an `ArrayView<VarBinView>` once more vtable changes land.
+    /// Returns the array as a [`VarBinViewArray`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the array is not a UTF-8 string array.
+    pub fn array_as_utf8(&self) -> VarBinViewArray {
+        self.array
+            .as_opt::<VarBinView>()
+            .vortex_expect("the array is guaranteed to already be canonical by construction")
+            .into_owned()
+    }
+
+    /// Consumes the bundle and returns the array.
+    pub fn into_array(self) -> ArrayRef {
+        self.array
+    }
+
+    /// Returns the length of the array.
+    pub fn array_len(&self) -> usize {
+        self.array.len()
+    }
+
+    /// Returns bool stats, generating them lazily on first access.
+    pub fn bool_stats(&mut self) -> &BoolStats {
+        let array = self.array.clone();
+
+        self.cache.get_or_insert_with::<BoolStats>(|| {
+            BoolStats::generate(&array.to_bool()).vortex_expect("BoolStats shouldn't fail")
+        })
+    }
+
+    // TODO(connor): These should all have interior mutability instead!!!
+
+    /// Returns integer stats, generating them lazily on first access.
+    pub fn integer_stats(&mut self) -> &IntegerStats {
+        let array = self.array.clone();
+        let opts = self.opts;
+
+        self.cache.get_or_insert_with::<IntegerStats>(|| {
+            IntegerStats::generate_opts(&array.to_primitive(), opts)
+        })
+    }
+
+    /// Returns float stats, generating them lazily on first access.
+    pub fn float_stats(&mut self) -> &FloatStats {
+        let array = self.array.clone();
+        let opts = self.opts;
+
+        self.cache.get_or_insert_with::<FloatStats>(|| {
+            FloatStats::generate_opts(&array.to_primitive(), opts)
+        })
+    }
+
+    /// Returns string stats, generating them lazily on first access.
+    pub fn string_stats(&mut self) -> &StringStats {
+        let array = self.array.clone();
+        let opts = self.opts;
+
+        self.cache.get_or_insert_with::<StringStats>(|| {
+            StringStats::generate_opts(&array.to_varbinview(), opts)
+        })
+    }
+
+    /// For extension schemes with custom stats types.
+    pub fn get_or_insert_with<T: 'static>(&mut self, f: impl FnOnce() -> T) -> &T {
+        self.cache.get_or_insert_with::<T>(f)
+    }
+}
diff --git a/vortex-btrblocks/src/compressor/float/stats.rs b/vortex-compressor/src/stats/float.rs
similarity index 54%
rename from vortex-btrblocks/src/compressor/float/stats.rs
rename to vortex-compressor/src/stats/float.rs
index 914e24b0dc0..c89de9c9893 100644
--- a/vortex-btrblocks/src/compressor/float/stats.rs
+++ b/vortex-compressor/src/stats/float.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Float compression statistics.
+
 use std::hash::Hash;
 
 use itertools::Itertools;
 use num_traits::Float;
 use rustc_hash::FxBuildHasher;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::NativeValue;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::PrimitiveVTable;
+use vortex_array::arrays::primitive::NativeValue;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::dtype::half::f16;
@@ -20,52 +20,90 @@ use vortex_error::vortex_panic;
 use vortex_mask::AllOr;
 use vortex_utils::aliases::hash_set::HashSet;
 
-use crate::CompressorStats;
-use crate::GenerateStatsOptions;
-use crate::compressor::rle::RLEStats;
-use crate::sample::sample;
+use super::GenerateStatsOptions;
+
+/// Information about the distinct values in a float array.
+#[derive(Debug, Clone)]
+pub struct DistinctInfo<T> {
+    /// The set of distinct float values.
+    distinct_values: HashSet<NativeValue<T>, FxBuildHasher>,
+    /// The count of unique values. This _must_ be non-zero.
+    distinct_count: u32,
+}
+
+impl<T> DistinctInfo<T> {
+    /// Returns a reference to the distinct values set.
+    pub fn distinct_values(&self) -> &HashSet<NativeValue<T>, FxBuildHasher> {
+        &self.distinct_values
+    }
+}
 
+/// Typed statistics for a specific float type.
 #[derive(Debug, Clone)]
-pub struct DistinctValues<T> {
-    pub values: HashSet<NativeValue<T>, FxBuildHasher>,
+pub struct TypedStats<T> {
+    /// Distinct value information, or `None` if not computed.
+    distinct: Option<DistinctInfo<T>>,
+}
+
+impl<T> TypedStats<T> {
+    /// Returns the distinct value information, if computed.
+    pub fn distinct(&self) -> Option<&DistinctInfo<T>> {
+        self.distinct.as_ref()
+    }
 }
 
+/// Type-erased container for one of the [`TypedStats`] variants.
 #[derive(Debug, Clone)]
-pub enum ErasedDistinctValues {
-    F16(DistinctValues<f16>),
-    F32(DistinctValues<f32>),
-    F64(DistinctValues<f64>),
+pub enum ErasedStats {
+    /// Stats for `f16` arrays.
+    F16(TypedStats<f16>),
+    /// Stats for `f32` arrays.
+    F32(TypedStats<f32>),
+    /// Stats for `f64` arrays.
+    F64(TypedStats<f64>),
+}
+
+impl ErasedStats {
+    /// Get the count of distinct values, if we have computed it already.
+    fn distinct_count(&self) -> Option<u32> {
+        match self {
+            ErasedStats::F16(x) => x.distinct.as_ref().map(|d| d.distinct_count),
+            ErasedStats::F32(x) => x.distinct.as_ref().map(|d| d.distinct_count),
+            ErasedStats::F64(x) => x.distinct.as_ref().map(|d| d.distinct_count),
+        }
+    }
 }
 
+/// Implements `From<TypedStats<$T>>` for [`ErasedStats`].
 macro_rules! impl_from_typed {
-    ($typ:ty, $variant:path) => {
-        impl From<DistinctValues<$typ>> for ErasedDistinctValues {
-            fn from(value: DistinctValues<$typ>) -> Self {
-                $variant(value)
+    ($T:ty, $variant:path) => {
+        impl From<TypedStats<$T>> for ErasedStats {
+            fn from(typed: TypedStats<$T>) -> Self {
+                $variant(typed)
             }
         }
     };
 }
 
-impl_from_typed!(f16, ErasedDistinctValues::F16);
-impl_from_typed!(f32, ErasedDistinctValues::F32);
-impl_from_typed!(f64, ErasedDistinctValues::F64);
+impl_from_typed!(f16, ErasedStats::F16);
+impl_from_typed!(f32, ErasedStats::F32);
+impl_from_typed!(f64, ErasedStats::F64);
 
 /// Array of floating-point numbers and relevant stats for compression.
 #[derive(Debug, Clone)]
 pub struct FloatStats {
-    pub(crate) src: PrimitiveArray,
-    // cache for validity.false_count()
-    pub(crate) null_count: u32,
-    // cache for validity.true_count()
-    pub(crate) value_count: u32,
-    #[allow(dead_code)]
-    pub(crate) average_run_length: u32,
-    pub(crate) distinct_values: ErasedDistinctValues,
-    pub(crate) distinct_values_count: u32,
+    /// Cache for `validity.false_count()`.
+    null_count: u32,
+    /// Cache for `validity.true_count()`.
+    value_count: u32,
+    /// The average run length.
+    average_run_length: u32,
+    /// Type-erased typed statistics.
+    erased: ErasedStats,
 }
 
 impl FloatStats {
+    /// Generates stats, returning an error on failure.
     fn generate_opts_fallible(
         input: &PrimitiveArray,
         opts: GenerateStatsOptions,
@@ -77,73 +115,71 @@ impl FloatStats {
             _ => vortex_panic!("cannot generate FloatStats from ptype {}", input.ptype()),
         }
     }
+
+    /// Get the count of distinct values, if we have computed it already.
+    pub fn distinct_count(&self) -> Option<u32> {
+        self.erased.distinct_count()
+    }
 }
 
-impl CompressorStats for FloatStats {
-    type ArrayVTable = PrimitiveVTable;
+impl FloatStats {
+    /// Generates stats with default options.
+    pub fn generate(input: &PrimitiveArray) -> Self {
+        Self::generate_opts(input, GenerateStatsOptions::default())
+    }
 
-    fn generate_opts(input: &PrimitiveArray, opts: GenerateStatsOptions) -> Self {
+    /// Generates stats with provided options.
+    pub fn generate_opts(input: &PrimitiveArray, opts: GenerateStatsOptions) -> Self {
         Self::generate_opts_fallible(input, opts)
             .vortex_expect("FloatStats::generate_opts should not fail")
     }
 
-    fn source(&self) -> &PrimitiveArray {
-        &self.src
-    }
-
-    fn sample_opts(&self, sample_size: u32, sample_count: u32, opts: GenerateStatsOptions) -> Self {
-        let sampled = sample(self.src.as_ref(), sample_size, sample_count).to_primitive();
-
-        Self::generate_opts(&sampled, opts)
+    /// Returns the number of null values.
+    pub fn null_count(&self) -> u32 {
+        self.null_count
     }
-}
 
-impl RLEStats for FloatStats {
-    fn value_count(&self) -> u32 {
+    /// Returns the number of non-null values.
+    pub fn value_count(&self) -> u32 {
         self.value_count
     }
 
-    fn average_run_length(&self) -> u32 {
+    /// Returns the average run length.
+    pub fn average_run_length(&self) -> u32 {
         self.average_run_length
     }
 
-    fn source(&self) -> &PrimitiveArray {
-        &self.src
+    /// Returns the type-erased typed statistics.
+    pub fn erased(&self) -> &ErasedStats {
+        &self.erased
     }
 }
 
+/// Computes typed float statistics for a specific float type.
 fn typed_float_stats<T: NativePType + Float>(
     array: &PrimitiveArray,
     count_distinct_values: bool,
 ) -> VortexResult<FloatStats>
 where
-    DistinctValues<T>: Into<ErasedDistinctValues>,
     NativeValue<T>: Hash + Eq,
+    TypedStats<T>: Into<ErasedStats>,
 {
-    // Special case: empty array
+    // Special case: empty array.
     if array.is_empty() {
         return Ok(FloatStats {
-            src: array.clone(),
             null_count: 0,
             value_count: 0,
             average_run_length: 0,
-            distinct_values_count: 0,
-            distinct_values: DistinctValues {
-                values: HashSet::<NativeValue<T>, FxBuildHasher>::with_hasher(FxBuildHasher),
-            }
-            .into(),
+            erased: TypedStats { distinct: None }.into(),
         });
-    } else if array.all_invalid()? {
+    }
+
+    if array.all_invalid()? {
         return Ok(FloatStats {
-            src: array.clone(),
             null_count: u32::try_from(array.len())?,
             value_count: 0,
             average_run_length: 0,
-            distinct_values_count: 0,
-            distinct_values: DistinctValues {
-                values: HashSet::<NativeValue<T>, FxBuildHasher>::with_hasher(FxBuildHasher),
-            }
-            .into(),
+            erased: TypedStats { distinct: None }.into(),
         });
     }
 
@@ -206,22 +242,18 @@ where
 
     let null_count = u32::try_from(null_count)?;
     let value_count = u32::try_from(value_count)?;
-    let distinct_values_count = if count_distinct_values {
-        u32::try_from(distinct_values.len())?
-    } else {
-        u32::MAX
-    };
+
+    let distinct = count_distinct_values.then(|| DistinctInfo {
+        distinct_count: u32::try_from(distinct_values.len())
+            .vortex_expect("more than u32::MAX distinct values"),
+        distinct_values,
+    });
 
     Ok(FloatStats {
         null_count,
         value_count,
-        distinct_values_count,
-        src: array.clone(),
         average_run_length: value_count / runs,
-        distinct_values: DistinctValues {
-            values: distinct_values,
-        }
-        .into(),
+        erased: TypedStats { distinct }.into(),
     })
 }
 
@@ -234,19 +266,23 @@ mod tests {
     use vortex_buffer::buffer;
 
     use super::FloatStats;
-    use crate::CompressorStats;
 
     #[test]
     fn test_float_stats() {
         let floats = buffer![0.0f32, 1.0f32, 2.0f32].into_array();
         let floats = floats.to_primitive();
 
-        let stats = FloatStats::generate(&floats);
+        let stats = FloatStats::generate_opts(
+            &floats,
+            crate::stats::GenerateStatsOptions {
+                count_distinct_values: true,
+            },
+        );
 
         assert_eq!(stats.value_count, 3);
         assert_eq!(stats.null_count, 0);
         assert_eq!(stats.average_run_length, 1);
-        assert_eq!(stats.distinct_values_count, 3);
+        assert_eq!(stats.distinct_count().unwrap(), 3);
     }
 
     #[test]
@@ -256,11 +292,16 @@ mod tests {
             Validity::from_iter([false, true, true]),
         );
 
-        let stats = FloatStats::generate(&floats);
+        let stats = FloatStats::generate_opts(
+            &floats,
+            crate::stats::GenerateStatsOptions {
+                count_distinct_values: true,
+            },
+        );
 
         assert_eq!(stats.value_count, 2);
         assert_eq!(stats.null_count, 1);
         assert_eq!(stats.average_run_length, 1);
-        assert_eq!(stats.distinct_values_count, 2);
+        assert_eq!(stats.distinct_count().unwrap(), 2);
     }
 }
diff --git a/vortex-btrblocks/src/compressor/integer/stats.rs b/vortex-compressor/src/stats/integer.rs
similarity index 61%
rename from vortex-btrblocks/src/compressor/integer/stats.rs
rename to vortex-compressor/src/stats/integer.rs
index eabc9a2f1f1..b1ff843b667 100644
--- a/vortex-btrblocks/src/compressor/integer/stats.rs
+++ b/vortex-compressor/src/stats/integer.rs
@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Integer compression statistics.
+
 use std::hash::Hash;
 
 use num_traits::PrimInt;
 use rustc_hash::FxBuildHasher;
-use vortex_array::ToCanonical;
-use vortex_array::arrays::NativeValue;
 use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::PrimitiveVTable;
+use vortex_array::arrays::primitive::NativeValue;
 use vortex_array::dtype::IntegerPType;
 use vortex_array::expr::stats::Stat;
 use vortex_array::match_each_integer_ptype;
@@ -21,37 +21,85 @@ use vortex_error::VortexResult;
 use vortex_mask::AllOr;
 use vortex_utils::aliases::hash_map::HashMap;
 
-use crate::CompressorStats;
-use crate::GenerateStatsOptions;
-use crate::compressor::rle::RLEStats;
-use crate::sample::sample;
+use super::GenerateStatsOptions;
 
-#[derive(Clone, Debug)]
+/// Information about the distinct values in an integer array.
+#[derive(Debug, Clone)]
+pub struct DistinctInfo<T> {
+    /// The unique values and their occurrences.
+    distinct_values: HashMap<NativeValue<T>, u32, FxBuildHasher>,
+    /// The count of unique values. This _must_ be non-zero.
+    distinct_count: u32,
+    /// The most frequent value.
+    most_frequent_value: T,
+    /// The number of times the most frequent value occurs.
+    top_frequency: u32,
+}
+
+impl<T> DistinctInfo<T> {
+    /// Returns a reference to the distinct values map.
+    pub fn distinct_values(&self) -> &HashMap<NativeValue<T>, u32, FxBuildHasher> {
+        &self.distinct_values
+    }
+}
+
+/// Typed statistics for a specific integer type.
+#[derive(Debug, Clone)]
 pub struct TypedStats<T> {
-    pub min: T,
-    pub max: T,
-    pub top_value: T,
-    pub top_count: u32,
-    pub distinct_values: HashMap<NativeValue<T>, u32, FxBuildHasher>,
+    /// The minimum value.
+    min: T,
+    /// The maximum value.
+    max: T,
+    /// Distinct value information, or `None` if not computed.
+    distinct: Option<DistinctInfo<T>>,
+}
+
+impl<T> TypedStats<T> {
+    /// Returns the distinct value information, if computed.
+    pub fn distinct(&self) -> Option<&DistinctInfo<T>> {
+        self.distinct.as_ref()
+    }
+}
+
+impl<T> TypedStats<T> {
+    /// Get the count of distinct values, if we have computed it already.
+    fn distinct_count(&self) -> Option<u32> {
+        Some(self.distinct.as_ref()?.distinct_count)
+    }
+
+    /// Get the most commonly occurring value and its count, if we have computed it already.
+    fn most_frequent_value_and_count(&self) -> Option<(&T, u32)> {
+        let distinct = self.distinct.as_ref()?;
+        Some((&distinct.most_frequent_value, distinct.top_frequency))
+    }
 }
 
-/// Type-erased container for one of the [TypedStats] variants.
+/// Type-erased container for one of the [`TypedStats`] variants.
 ///
 /// Building the `TypedStats` is considerably faster and cheaper than building a type-erased
 /// set of stats. We then perform a variety of access methods on them.
 #[derive(Clone, Debug)]
 pub enum ErasedStats {
+    /// Stats for `u8` arrays.
     U8(TypedStats<u8>),
+    /// Stats for `u16` arrays.
     U16(TypedStats<u16>),
+    /// Stats for `u32` arrays.
     U32(TypedStats<u32>),
+    /// Stats for `u64` arrays.
     U64(TypedStats<u64>),
+    /// Stats for `i8` arrays.
     I8(TypedStats<i8>),
+    /// Stats for `i16` arrays.
     I16(TypedStats<i16>),
+    /// Stats for `i32` arrays.
     I32(TypedStats<i32>),
+    /// Stats for `i64` arrays.
     I64(TypedStats<i64>),
 }
 
 impl ErasedStats {
+    /// Returns `true` if the minimum value is zero.
     pub fn min_is_zero(&self) -> bool {
         match &self {
             ErasedStats::U8(x) => x.min == 0,
@@ -65,6 +113,7 @@ impl ErasedStats {
         }
     }
 
+    /// Returns `true` if the minimum value is negative.
     pub fn min_is_negative(&self) -> bool {
         match &self {
             ErasedStats::U8(_)
@@ -78,7 +127,7 @@ impl ErasedStats {
         }
     }
 
-    // Difference between max and min.
+    /// Difference between max and min.
     pub fn max_minus_min(&self) -> u64 {
         match &self {
             ErasedStats::U8(x) => (x.max - x.min) as u64,
@@ -93,10 +142,10 @@ impl ErasedStats {
         }
     }
 
-    /// Returns the ilog2 of the max value when transmuted to unsigned, or None if zero.
+    /// Returns the ilog2 of the max value when transmuted to unsigned, or `None` if zero.
     ///
     /// This matches how BitPacking computes bit width: it reinterprets signed values as
-    /// unsigned (preserving bit pattern) and uses leading_zeros. For non-negative signed
+    /// unsigned (preserving bit pattern) and uses `leading_zeros`. For non-negative signed
     /// values, the transmuted value equals the original value.
     ///
     /// This is used to determine if FOR encoding would reduce bit width compared to
@@ -107,7 +156,7 @@ impl ErasedStats {
             ErasedStats::U16(x) => x.max.checked_ilog2(),
             ErasedStats::U32(x) => x.max.checked_ilog2(),
             ErasedStats::U64(x) => x.max.checked_ilog2(),
-            // Transmute signed to unsigned (bit pattern preserved) to match BitPacking behavior
+            // Transmute signed to unsigned (bit pattern preserved) to match BitPacking behavior.
             ErasedStats::I8(x) => (x.max as u8).checked_ilog2(),
             ErasedStats::I16(x) => (x.max as u16).checked_ilog2(),
             ErasedStats::I32(x) => (x.max as u32).checked_ilog2(),
@@ -115,21 +164,60 @@ impl ErasedStats {
         }
     }
 
-    /// Get the most commonly occurring value and its count
-    pub fn top_value_and_count(&self) -> (PValue, u32) {
+    /// Get the count of distinct values, if we have computed it already.
+    pub fn distinct_count(&self) -> Option<u32> {
         match &self {
-            ErasedStats::U8(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::U16(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::U32(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::U64(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::I8(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::I16(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::I32(x) => (x.top_value.into(), x.top_count),
-            ErasedStats::I64(x) => (x.top_value.into(), x.top_count),
+            ErasedStats::U8(x) => x.distinct_count(),
+            ErasedStats::U16(x) => x.distinct_count(),
+            ErasedStats::U32(x) => x.distinct_count(),
+            ErasedStats::U64(x) => x.distinct_count(),
+            ErasedStats::I8(x) => x.distinct_count(),
+            ErasedStats::I16(x) => x.distinct_count(),
+            ErasedStats::I32(x) => x.distinct_count(),
+            ErasedStats::I64(x) => x.distinct_count(),
+        }
+    }
+
+    /// Get the most commonly occurring value and its count.
+    pub fn most_frequent_value_and_count(&self) -> Option<(PValue, u32)> {
+        match &self {
+            ErasedStats::U8(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::U16(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::U32(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::U64(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::I8(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::I16(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::I32(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
+            ErasedStats::I64(x) => {
+                let (top_value, count) = x.most_frequent_value_and_count()?;
+                Some(((*top_value).into(), count))
+            }
         }
     }
 }
 
+/// Implements `From<TypedStats<$T>>` for [`ErasedStats`].
 macro_rules! impl_from_typed {
     ($T:ty, $variant:path) => {
         impl From<TypedStats<$T>> for ErasedStats {
@@ -152,17 +240,18 @@ impl_from_typed!(i64, ErasedStats::I64);
 /// Array of integers and relevant stats for compression.
 #[derive(Clone, Debug)]
 pub struct IntegerStats {
-    pub(super) src: PrimitiveArray,
-    // cache for validity.false_count()
-    pub(super) null_count: u32,
-    // cache for validity.true_count()
-    pub(super) value_count: u32,
-    pub(super) average_run_length: u32,
-    pub(super) distinct_values_count: u32,
-    pub(crate) typed: ErasedStats,
+    /// Cache for `validity.false_count()`.
+    null_count: u32,
+    /// Cache for `validity.true_count()`.
+    value_count: u32,
+    /// The average run length.
+    average_run_length: u32,
+    /// Type-erased typed statistics.
+    erased: ErasedStats,
 }
 
 impl IntegerStats {
+    /// Generates stats, returning an error on failure.
     fn generate_opts_fallible(
         input: &PrimitiveArray,
         opts: GenerateStatsOptions,
@@ -171,41 +260,52 @@ impl IntegerStats {
             typed_int_stats::<T>(input, opts.count_distinct_values)
         })
     }
-}
 
-impl CompressorStats for IntegerStats {
-    type ArrayVTable = PrimitiveVTable;
+    /// Get the count of distinct values, if we have computed it already.
+    pub fn distinct_count(&self) -> Option<u32> {
+        self.erased.distinct_count()
+    }
 
-    fn generate_opts(input: &PrimitiveArray, opts: GenerateStatsOptions) -> Self {
-        Self::generate_opts_fallible(input, opts)
-            .vortex_expect("IntegerStats::generate_opts should not fail")
+    /// Get the most commonly occurring value and its count, if we have computed it already.
+    pub fn most_frequent_value_and_count(&self) -> Option<(PValue, u32)> {
+        self.erased.most_frequent_value_and_count()
     }
+}
 
-    fn source(&self) -> &PrimitiveArray {
-        &self.src
+impl IntegerStats {
+    /// Generates stats with default options.
+    pub fn generate(input: &PrimitiveArray) -> Self {
+        Self::generate_opts(input, GenerateStatsOptions::default())
     }
 
-    fn sample_opts(&self, sample_size: u32, sample_count: u32, opts: GenerateStatsOptions) -> Self {
-        let sampled = sample(self.src.as_ref(), sample_size, sample_count).to_primitive();
+    /// Generates stats with provided options.
+    pub fn generate_opts(input: &PrimitiveArray, opts: GenerateStatsOptions) -> Self {
+        Self::generate_opts_fallible(input, opts)
+            .vortex_expect("IntegerStats::generate_opts should not fail")
+    }
 
-        Self::generate_opts(&sampled, opts)
+    /// Returns the number of null values.
+    pub fn null_count(&self) -> u32 {
+        self.null_count
     }
-}
 
-impl RLEStats for IntegerStats {
-    fn value_count(&self) -> u32 {
+    /// Returns the number of non-null values.
+    pub fn value_count(&self) -> u32 {
         self.value_count
     }
 
-    fn average_run_length(&self) -> u32 {
+    /// Returns the average run length.
+    pub fn average_run_length(&self) -> u32 {
         self.average_run_length
     }
 
-    fn source(&self) -> &PrimitiveArray {
-        &self.src
+    /// Returns the type-erased typed statistics.
+    pub fn erased(&self) -> &ErasedStats {
+        &self.erased
     }
 }
 
+/// Computes typed integer statistics for a specific integer type.
 fn typed_int_stats<T>(
     array: &PrimitiveArray,
     count_distinct_values: bool,
@@ -215,36 +315,30 @@ where
     TypedStats<T>: Into<ErasedStats>,
     NativeValue<T>: Eq + Hash,
 {
-    // Special case: empty array
+    // Special case: empty array.
     if array.is_empty() {
         return Ok(IntegerStats {
-            src: array.clone(),
             null_count: 0,
             value_count: 0,
             average_run_length: 0,
-            distinct_values_count: 0,
-            typed: TypedStats {
+            erased: TypedStats {
                 min: T::max_value(),
                 max: T::min_value(),
-                top_value: T::default(),
-                top_count: 0,
-                distinct_values: HashMap::with_hasher(FxBuildHasher),
+                distinct: None,
             }
             .into(),
         });
-    } else if array.all_invalid()? {
+    }
+
+    if array.all_invalid()? {
         return Ok(IntegerStats {
-            src: array.clone(),
             null_count: u32::try_from(array.len())?,
             value_count: 0,
             average_run_length: 0,
-            distinct_values_count: 0,
-            typed: TypedStats {
+            erased: TypedStats {
                 min: T::max_value(),
                 max: T::min_value(),
-                top_value: T::default(),
-                top_count: 0,
-                distinct_values: HashMap::with_hasher(FxBuildHasher),
+                distinct: None,
             }
             .into(),
         });
@@ -254,7 +348,7 @@ where
     let null_count = validity.false_count();
     let value_count = validity.true_count();
 
-    // Initialize loop state
+    // Initialize loop state.
     let head_idx = validity
         .first()
         .vortex_expect("All null masks have been handled before");
@@ -299,15 +393,15 @@ where
                 offset += 64;
 
                 match validity.true_count() {
-                    // All nulls -> no stats to update
+                    // All nulls -> no stats to update.
                     0 => continue,
-                    // Inner loop for when validity check can be elided
+                    // Inner loop for when validity check can be elided.
                     64 => inner_loop_nonnull(
                         chunk.try_into().ok().vortex_expect("chunk size must be 64"),
                         count_distinct_values,
                         &mut loop_state,
                     ),
-                    // Inner loop for when we need to check validity
+                    // Inner loop for when we need to check validity.
                     _ => inner_loop_nullable(
                         chunk.try_into().ok().vortex_expect("chunk size must be 64"),
                         count_distinct_values,
@@ -316,7 +410,7 @@ where
                     ),
                 }
             }
-            // Final iteration, run naive loop
+            // Final iteration, run naive loop.
             let remainder = chunks.remainder();
             inner_loop_naive(
                 remainder,
@@ -327,61 +421,59 @@ where
         }
     }
 
-    let (top_value, top_count) = if count_distinct_values {
-        let (&top_value, &top_count) = loop_state
-            .distinct_values
-            .iter()
-            .max_by_key(|&(_, &count)| count)
-            .vortex_expect("non-empty");
-        (top_value.0, top_count)
-    } else {
-        (T::default(), 0)
-    };
-
     let runs = loop_state.runs;
-    let distinct_values_count = if count_distinct_values {
-        u32::try_from(loop_state.distinct_values.len())?
-    } else {
-        u32::MAX
-    };
 
-    let min = array
+    let array_ref = array.as_ref();
+    let min = array_ref
         .statistics()
         .compute_as::<T>(Stat::Min)
         .vortex_expect("min should be computed");
 
-    let max = array
+    let max = array_ref
         .statistics()
         .compute_as::<T>(Stat::Max)
         .vortex_expect("max should be computed");
 
-    let typed = TypedStats {
-        min,
-        max,
-        distinct_values: loop_state.distinct_values,
-        top_value,
-        top_count,
-    };
+    let distinct = count_distinct_values.then(|| {
+        let (&top_value, &top_count) = loop_state
+            .distinct_values
+            .iter()
+            .max_by_key(|&(_, &count)| count)
+            .vortex_expect("we know this is non-empty");
+
+        DistinctInfo {
+            distinct_count: u32::try_from(loop_state.distinct_values.len())
+                .vortex_expect("there are more than `u32::MAX` distinct values"),
+            most_frequent_value: top_value.0,
+            top_frequency: top_count,
+            distinct_values: loop_state.distinct_values,
+        }
+    });
+
+    let typed = TypedStats { min, max, distinct };
 
     let null_count = u32::try_from(null_count)?;
     let value_count = u32::try_from(value_count)?;
 
     Ok(IntegerStats {
-        src: array.clone(),
         null_count,
         value_count,
         average_run_length: value_count / runs,
-        distinct_values_count,
-        typed: typed.into(),
+        erased: typed.into(),
     })
 }
 
+/// Internal loop state for integer stats computation.
 struct LoopState<T> {
+    /// The previous value seen.
     prev: T,
+    /// The run count.
     runs: u32,
+    /// The distinct values map.
     distinct_values: HashMap<NativeValue<T>, u32, FxBuildHasher>,
 }
 
+/// Inner loop for non-null chunks of 64 values.
 #[inline(always)]
 fn inner_loop_nonnull<T: IntegerPType>(
     values: &[T; 64],
@@ -402,6 +494,7 @@ fn inner_loop_nonnull<T: IntegerPType>(
     }
 }
 
+/// Inner loop for nullable chunks of 64 values.
 #[inline(always)]
 fn inner_loop_nullable<T: IntegerPType>(
     values: &[T; 64],
@@ -425,6 +518,7 @@ fn inner_loop_nullable<T: IntegerPType>(
     }
 }
 
+/// Fallback inner loop for remainder values.
 #[inline(always)]
 fn inner_loop_naive<T: IntegerPType>(
     values: &[T],
@@ -461,13 +555,12 @@ mod tests {
 
     use super::IntegerStats;
     use super::typed_int_stats;
-    use crate::CompressorStats;
 
     #[test]
     fn test_naive_count_distinct_values() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![217u8, 0], Validity::NonNullable);
         let stats = typed_int_stats::<u8>(&array, true)?;
-        assert_eq!(stats.distinct_values_count, 2);
+        assert_eq!(stats.distinct_count().unwrap(), 2);
         Ok(())
     }
 
@@ -478,7 +571,7 @@ mod tests {
             Validity::from(BitBuffer::from(vec![true, false])),
         );
         let stats = typed_int_stats::<u8>(&array, true)?;
-        assert_eq!(stats.distinct_values_count, 1);
+        assert_eq!(stats.distinct_count().unwrap(), 1);
         Ok(())
     }
 
@@ -486,7 +579,7 @@ mod tests {
     fn test_count_distinct_values() -> VortexResult<()> {
         let array = PrimitiveArray::new((0..128u8).collect::<Buffer<u8>>(), Validity::NonNullable);
         let stats = typed_int_stats::<u8>(&array, true)?;
-        assert_eq!(stats.distinct_values_count, 128);
+        assert_eq!(stats.distinct_count().unwrap(), 128);
         Ok(())
     }
 
@@ -499,7 +592,7 @@ mod tests {
             )),
         );
         let stats = typed_int_stats::<u8>(&array, true)?;
-        assert_eq!(stats.distinct_values_count, 64);
+        assert_eq!(stats.distinct_count().unwrap(), 64);
         Ok(())
     }
 
@@ -507,11 +600,16 @@ mod tests {
     fn test_integer_stats_leading_nulls() {
         let ints = PrimitiveArray::new(buffer![0, 1, 2], Validity::from_iter([false, true, true]));
 
-        let stats = IntegerStats::generate(&ints);
+        let stats = IntegerStats::generate_opts(
+            &ints,
+            crate::stats::GenerateStatsOptions {
+                count_distinct_values: true,
+            },
+        );
 
         assert_eq!(stats.value_count, 2);
         assert_eq!(stats.null_count, 1);
         assert_eq!(stats.average_run_length, 1);
-        assert_eq!(stats.distinct_values_count, 2);
+        assert_eq!(stats.distinct_count().unwrap(), 2);
     }
 }
diff --git a/vortex-compressor/src/stats/mod.rs b/vortex-compressor/src/stats/mod.rs
new file mode 100644
index 00000000000..276fa8f056c
--- /dev/null
+++ b/vortex-compressor/src/stats/mod.rs
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compression statistics types and caching.
+
+mod bool;
+mod cache;
+mod float;
+mod integer;
+mod options;
+mod string;
+
+pub use bool::BoolStats;
+pub use cache::ArrayAndStats;
+pub use float::DistinctInfo as FloatDistinctInfo;
+pub use float::ErasedStats as FloatErasedStats;
+pub use float::FloatStats;
+pub use float::TypedStats as FloatTypedStats;
+pub use integer::DistinctInfo as IntegerDistinctInfo;
+pub use integer::ErasedStats as IntegerErasedStats;
+pub use integer::IntegerStats;
+pub use integer::TypedStats as IntegerTypedStats;
+pub use options::GenerateStatsOptions;
+pub use string::StringStats;
diff --git a/vortex-compressor/src/stats/options.rs b/vortex-compressor/src/stats/options.rs
new file mode 100644
index 00000000000..d53b69d748a
--- /dev/null
+++ b/vortex-compressor/src/stats/options.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compression statistics types.
+
+/// Configures how stats are generated.
+///
+/// Each scheme declares its required options via [`Scheme::stats_options`]. The compressor
+/// merges all eligible schemes' options before generating stats, so that a single stats pass
+/// satisfies every scheme.
+///
+/// [`Scheme::stats_options`]: crate::scheme::Scheme::stats_options
+#[derive(Debug, Default, Clone, Copy)]
+pub struct GenerateStatsOptions {
+    /// Whether distinct values should be counted during stats generation.
+    pub count_distinct_values: bool,
+}
+
+impl GenerateStatsOptions {
+    /// Merges two options by OR-ing each field. The result enables a stat if either input does.
+    pub fn merge(self, other: Self) -> Self {
+        Self {
+            count_distinct_values: self.count_distinct_values || other.count_distinct_values,
+        }
+    }
+}
diff --git a/vortex-compressor/src/stats/string.rs b/vortex-compressor/src/stats/string.rs
new file mode 100644
index 00000000000..d35d8381611
--- /dev/null
+++ b/vortex-compressor/src/stats/string.rs
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! String compression statistics.
+
+use vortex_array::arrays::VarBinViewArray;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+use vortex_utils::aliases::hash_set::HashSet;
+
+use super::GenerateStatsOptions;
+
+/// Array of variable-length byte arrays, and relevant stats for compression.
+#[derive(Clone, Debug)]
+pub struct StringStats {
+    /// The estimated number of distinct strings, or `None` if not computed.
+    /// This _must_ be non-zero.
+    estimated_distinct_count: Option<u32>,
+    /// The number of non-null values.
+    value_count: u32,
+    /// The number of null values.
+    null_count: u32,
+}
+
+/// Estimate the number of distinct strings in the var bin view array.
+fn estimate_distinct_count(strings: &VarBinViewArray) -> VortexResult<u32> {
+    let views = strings.views();
+    // Iterate the views. Two strings which are equal must have the same first 8-bytes.
+    // NOTE: there are cases where this performs pessimally, e.g. when we have strings that all
+    // share a 4-byte prefix and have the same length.
+    let mut distinct = HashSet::with_capacity(views.len() / 2);
+    views.iter().for_each(|&view| {
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "approximate uniqueness with view prefix"
+        )]
+        let len_and_prefix = view.as_u128() as u64;
+        distinct.insert(len_and_prefix);
+    });
+
+    Ok(u32::try_from(distinct.len())?)
+}
+
+impl StringStats {
+    /// Generates stats, returning an error on failure.
+    fn generate_opts_fallible(
+        input: &VarBinViewArray,
+        opts: GenerateStatsOptions,
+    ) -> VortexResult<Self> {
+        let null_count = input
+            .statistics()
+            .compute_null_count()
+            .ok_or_else(|| vortex_err!("Failed to compute null_count"))?;
+        let value_count = input.len() - null_count;
+        let estimated_distinct_count = opts
+            .count_distinct_values
+            .then(|| estimate_distinct_count(input))
+            .transpose()?;
+
+        Ok(Self {
+            value_count: u32::try_from(value_count)?,
+            null_count: u32::try_from(null_count)?,
+            estimated_distinct_count,
+        })
+    }
+}
+
+impl StringStats {
+    /// Generates stats with default options.
+    pub fn generate(input: &VarBinViewArray) -> Self {
+        Self::generate_opts(input, GenerateStatsOptions::default())
+    }
+
+    /// Generates stats with provided options.
+    pub fn generate_opts(input: &VarBinViewArray, opts: GenerateStatsOptions) -> Self {
+        Self::generate_opts_fallible(input, opts)
+            .vortex_expect("StringStats::generate_opts should not fail")
+    }
+
+    /// Returns the estimated number of distinct strings, or `None` if not computed.
+    ///
+    /// This estimation is always going to be less than or equal to the actual distinct count.
+    pub fn estimated_distinct_count(&self) -> Option<u32> {
+        self.estimated_distinct_count
+    }
+
+    /// Returns the number of non-null values.
+    pub fn value_count(&self) -> u32 {
+        self.value_count
+    }
+
+    /// Returns the number of null values.
+    pub fn null_count(&self) -> u32 {
+        self.null_count
+    }
+}
diff --git a/vortex-cuda/Cargo.toml b/vortex-cuda/Cargo.toml
index 7917d50cfbd..9d21976f92b 100644
--- a/vortex-cuda/Cargo.toml
+++ b/vortex-cuda/Cargo.toml
@@ -25,9 +25,13 @@ unstable_encodings = ["vortex/unstable_encodings"]
 [dependencies]
 arc-swap = { workspace = true }
 async-trait = { workspace = true }
+bytes = { workspace = true }
 cudarc = { workspace = true, features = ["f16"] }
 futures = { workspace = true, features = ["executor"] }
+itertools = { workspace = true }
 kanal = { workspace = true }
+object_store = { workspace = true, features = ["fs"] }
+parking_lot = { workspace = true }
 prost = { workspace = true }
 tokio = { workspace = true, features = ["fs"] }
 tracing = { workspace = true, features = ["std", "attributes"] }
@@ -35,7 +39,7 @@ vortex = { workspace = true, features = ["zstd"] }
 vortex-array = { workspace = true, features = ["cudarc"] }
 vortex-cub = { path = "cub" }
 vortex-cuda-macros = { workspace = true }
-vortex-error = { workspace = true }
+vortex-error = { workspace = true, features = ["object_store"] }
 vortex-nvcomp = { path = "nvcomp" }
 
 [dev-dependencies]
@@ -85,3 +89,7 @@ harness = false
 [[bench]]
 name = "throughput_cuda"
 harness = false
+
+[[bench]]
+name = "transpose_patches"
+harness = false
diff --git a/vortex-cuda/benches/bitpacked_cuda.rs b/vortex-cuda/benches/bitpacked_cuda.rs
index 420e31579f2..a0cc4985ea5 100644
--- a/vortex-cuda/benches/bitpacked_cuda.rs
+++ b/vortex-cuda/benches/bitpacked_cuda.rs
@@ -19,11 +19,13 @@ use criterion::Criterion;
 use criterion::Throughput;
 use cudarc::driver::DeviceRepr;
 use futures::executor::block_on;
+use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity::NonNullable;
 use vortex::buffer::Buffer;
 use vortex::dtype::NativePType;
 use vortex::encodings::fastlanes::BitPackedArray;
+use vortex::encodings::fastlanes::BitPackedData;
 use vortex::encodings::fastlanes::unpack_iter::BitPacked;
 use vortex::error::VortexExpect;
 use vortex::session::VortexSession;
@@ -36,6 +38,10 @@ use crate::common::TimedLaunchStrategy;
 
 const N_ROWS: usize = 100_000_000;
 
+/// Patch frequencies to benchmark (as fractions)
+const PATCH_FREQUENCIES: &[(f64, &str)] =
+    &[(0.001, "0.1%"), (0.01, "1%"), (0.05, "5%"), (0.10, "10%")];
+
 /// Create a bit-packed array with the given bit width
 fn make_bitpacked_array<T>(bit_width: u8, len: usize) -> BitPackedArray
 where
@@ -51,10 +57,50 @@ where
         .collect();
 
     let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable);
-    BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+    BitPackedData::encode(&primitive_array.into_array(), bit_width)
         .vortex_expect("failed to create BitPacked array")
 }
 
+/// Create a bit-packed array with the given bit width and patch frequency.
+///
+/// `patch_frequency` is a fraction (0.0 to 1.0) indicating what proportion of values
+/// should exceed the bit width and become patches.
+///
+/// This function uses bit_width=6 internally since patch values need to exceed
+/// the bit width but still fit in u8 for the From<u8> trait bound.
+fn make_bitpacked_array_with_patches<T>(len: usize, patch_frequency: f64) -> BitPackedArray
+where
+    T: NativePType + Add<Output = T> + From<u8>,
+{
+    // Use bit_width=6 so max packed value is 63, and patch values (64-255) fit in u8
+    let bit_width: u8 = 6;
+    let max_packed_val = (1u64 << bit_width) - 1; // 63
+
+    // Deterministic patch placement: place patches at regular intervals
+    let patch_interval = if patch_frequency > 0.0 {
+        (1.0 / patch_frequency) as usize
+    } else {
+        usize::MAX
+    };
+
+    let values: Vec<T> = (0..len)
+        .map(|i| {
+            if patch_interval > 0 && i % patch_interval == 0 {
+                // Patch value: 128 exceeds 6-bit max (63)
+                <T as From<u8>>::from(128)
+            } else {
+                // Normal value that fits within 6 bits (0-63)
+                let val = (i as u64 & max_packed_val) as u8;
+                <T as From<u8>>::from(val)
+            }
+        })
+        .collect();
+
+    let primitive_array = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
+    BitPackedData::encode(&primitive_array, bit_width)
+        .vortex_expect("failed to create BitPacked array with patches")
+}
+
 /// Generic benchmark function for a specific type and bit width
 fn benchmark_bitunpack_typed<T>(c: &mut Criterion, bit_width: u8, type_name: &str)
 where
@@ -82,7 +128,7 @@ where
                     .with_launch_strategy(Arc::new(timed));
 
                 for _ in 0..iters {
-                    block_on(array.to_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                    block_on(array.clone().into_array().execute_cuda(&mut cuda_ctx)).unwrap();
                 }
 
                 Duration::from_nanos(timer.load(Ordering::Relaxed))
@@ -100,7 +146,58 @@ fn benchmark_bitunpack(c: &mut Criterion) {
     benchmark_bitunpack_typed::<u64>(c, 8, "u64");
 }
 
-criterion::criterion_group!(benches, benchmark_bitunpack);
+/// Benchmark function for unpacking with patches at various frequencies
+fn benchmark_bitunpack_with_patches_typed<T>(c: &mut Criterion, type_name: &str)
+where
+    T: BitPacked + NativePType + DeviceRepr + Add<Output = T> + From<u8>,
+    T::Physical: DeviceRepr,
+{
+    let mut group = c.benchmark_group(format!("bitunpack_cuda_patched_{}", type_name));
+    group.sample_size(10);
+
+    let nbytes = N_ROWS * size_of::<T>();
+    group.throughput(Throughput::Bytes(nbytes as u64));
+
+    for &(patch_freq, patch_label) in PATCH_FREQUENCIES {
+        let array = make_bitpacked_array_with_patches::<T>(N_ROWS, patch_freq);
+
+        group.bench_with_input(
+            BenchmarkId::new("bitunpack_patched", patch_label),
+            &array,
+            |b, array| {
+                b.iter_custom(|iters| {
+                    let timed = TimedLaunchStrategy::default();
+                    let timer = Arc::clone(&timed.total_time_ns);
+
+                    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+                        .vortex_expect("failed to create execution context")
+                        .with_launch_strategy(Arc::new(timed));
+
+                    for _ in 0..iters {
+                        block_on(array.clone().into_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                    }
+
+                    Duration::from_nanos(timer.load(Ordering::Relaxed))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+fn benchmark_bitunpack_with_patches(c: &mut Criterion) {
+    benchmark_bitunpack_with_patches_typed::<u8>(c, "u8");
+    benchmark_bitunpack_with_patches_typed::<u16>(c, "u16");
+    benchmark_bitunpack_with_patches_typed::<u32>(c, "u32");
+    benchmark_bitunpack_with_patches_typed::<u64>(c, "u64");
+}
+
+criterion::criterion_group!(
+    benches,
+    benchmark_bitunpack,
+    benchmark_bitunpack_with_patches
+);
 
 #[cuda_available]
 criterion::criterion_main!(benches);
diff --git a/vortex-cuda/benches/date_time_parts_cuda.rs b/vortex-cuda/benches/date_time_parts_cuda.rs
index dd993ada349..53f303d0b2c 100644
--- a/vortex-cuda/benches/date_time_parts_cuda.rs
+++ b/vortex-cuda/benches/date_time_parts_cuda.rs
@@ -24,6 +24,7 @@ use vortex::array::validity::Validity;
 use vortex::buffer::Buffer;
 use vortex::dtype::DType;
 use vortex::dtype::Nullability;
+use vortex::encodings::datetime_parts::DateTimeParts;
 use vortex::encodings::datetime_parts::DateTimePartsArray;
 use vortex::error::VortexExpect;
 use vortex::extension::datetime::TimeUnit;
@@ -44,7 +45,7 @@ fn make_datetimeparts_array(len: usize, time_unit: TimeUnit) -> DateTimePartsArr
 
     let dtype = DType::Extension(Timestamp::new(time_unit, Nullability::NonNullable).erased());
 
-    DateTimePartsArray::try_new(dtype, days_arr, seconds_arr, subseconds_arr)
+    DateTimeParts::try_new(dtype, days_arr, seconds_arr, subseconds_arr)
         .vortex_expect("Failed to create DateTimePartsArray")
 }
 
@@ -76,7 +77,8 @@ fn benchmark_datetimeparts(c: &mut Criterion) {
 
                     for _ in 0..iters {
                         // block on immediately here
-                        block_on(dtp_array.to_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                        block_on(dtp_array.clone().into_array().execute_cuda(&mut cuda_ctx))
+                            .unwrap();
                     }
 
                     Duration::from_nanos(timer.load(Ordering::Relaxed))
diff --git a/vortex-cuda/benches/dict_cuda.rs b/vortex-cuda/benches/dict_cuda.rs
index 610a8012dfd..db650eacadd 100644
--- a/vortex-cuda/benches/dict_cuda.rs
+++ b/vortex-cuda/benches/dict_cuda.rs
@@ -100,7 +100,7 @@ where
                         .with_launch_strategy(Arc::new(timed));
 
                     for _ in 0..iters {
-                        block_on(dict_array.to_array().execute_cuda(&mut cuda_ctx))
+                        block_on(dict_array.clone().into_array().execute_cuda(&mut cuda_ctx))
                             .vortex_expect("execute");
                     }
 
diff --git a/vortex-cuda/benches/dynamic_dispatch_cuda.rs b/vortex-cuda/benches/dynamic_dispatch_cuda.rs
index 218c8d232b4..9cff91f9856 100644
--- a/vortex-cuda/benches/dynamic_dispatch_cuda.rs
+++ b/vortex-cuda/benches/dynamic_dispatch_cuda.rs
@@ -12,6 +12,7 @@ use std::time::Duration;
 use criterion::BenchmarkId;
 use criterion::Criterion;
 use criterion::Throughput;
+use cudarc::driver::CudaSlice;
 use cudarc::driver::DevicePtr;
 use cudarc::driver::LaunchConfig;
 use cudarc::driver::PushKernelArg;
@@ -23,13 +24,18 @@ use vortex::array::arrays::PrimitiveArray;
 use vortex::array::scalar::Scalar;
 use vortex::array::validity::Validity::NonNullable;
 use vortex::buffer::Buffer;
-use vortex::encodings::alp::ALPArray;
+use vortex::dtype::PType;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::ALPArrayExt;
+use vortex::encodings::alp::ALPArraySlotsExt;
 use vortex::encodings::alp::ALPFloat;
 use vortex::encodings::alp::Exponents;
 use vortex::encodings::alp::alp_encode;
-use vortex::encodings::fastlanes::BitPackedArray;
-use vortex::encodings::fastlanes::FoRArray;
-use vortex::encodings::runend::RunEndArray;
+use vortex::encodings::fastlanes::BitPackedData;
+use vortex::encodings::fastlanes::FoR;
+use vortex::encodings::fastlanes::FoRArrayExt;
+use vortex::encodings::fastlanes::FoRData;
+use vortex::encodings::runend::RunEnd;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
@@ -37,8 +43,9 @@ use vortex::session::VortexSession;
 use vortex_cuda::CudaDeviceBuffer;
 use vortex_cuda::CudaExecutionCtx;
 use vortex_cuda::CudaSession;
-use vortex_cuda::dynamic_dispatch;
-use vortex_cuda::dynamic_dispatch::DynamicDispatchPlan;
+use vortex_cuda::dynamic_dispatch::CudaDispatchPlan;
+use vortex_cuda::dynamic_dispatch::DispatchPlan;
+use vortex_cuda::dynamic_dispatch::MaterializedPlan;
 use vortex_cuda_macros::cuda_available;
 use vortex_cuda_macros::cuda_not_available;
 
@@ -49,14 +56,18 @@ const BENCH_ARGS: &[(usize, &str)] = &[
 ];
 
 /// Launch the dynamic_dispatch kernel and return GPU-timed duration.
+///
+/// This deliberately does not use `CudaDispatchPlan::execute` because the
+/// benchmark pre-allocates the output buffer and device plan once, then reuses
+/// them across iterations.
 fn run_timed(
     cuda_ctx: &mut CudaExecutionCtx,
     array_len: usize,
     output_buf: &CudaDeviceBuffer,
-    device_plan: &Arc<cudarc::driver::CudaSlice<DynamicDispatchPlan>>,
+    device_plan: &Arc<CudaSlice<u8>>,
     shared_mem_bytes: u32,
 ) -> VortexResult<Duration> {
-    let cuda_function = cuda_ctx.load_function("dynamic_dispatch", &["u32"])?;
+    let cuda_function = cuda_ctx.load_function("dynamic_dispatch", &[PType::U32])?;
     let array_len_u64 = array_len as u64;
     let output_view = output_buf.as_view::<u32>();
     let (output_ptr, record_output) = output_view.device_ptr(cuda_ctx.stream());
@@ -106,40 +117,44 @@ fn run_timed(
 
 /// Benchmark runner: builds a dynamic plan and launches the kernel.
 struct BenchRunner {
-    _plan: DynamicDispatchPlan,
+    _plan: CudaDispatchPlan,
     smem_bytes: u32,
     len: usize,
-    // Keep alive
-    device_plan: Arc<cudarc::driver::CudaSlice<DynamicDispatchPlan>>,
+    device_plan: Arc<CudaSlice<u8>>,
     output_buf: CudaDeviceBuffer,
     _plan_buffers: Vec<vortex::array::buffer::BufferHandle>,
 }
 
 impl BenchRunner {
     fn new(array: &vortex::array::ArrayRef, len: usize, cuda_ctx: &CudaExecutionCtx) -> Self {
-        let (plan, plan_buffers) =
-            dynamic_dispatch::build_plan(array, cuda_ctx).vortex_expect("build_plan");
-        let smem_bytes = plan.shared_mem_bytes::<u32>();
+        let plan = match DispatchPlan::new(array).vortex_expect("build_dyn_dispatch_plan") {
+            DispatchPlan::Fused(plan) => plan,
+            _ => unreachable!("encoding not fusable"),
+        };
+        let MaterializedPlan {
+            dispatch_plan,
+            device_buffers,
+            shared_mem_bytes,
+        } = plan.materialize(cuda_ctx).vortex_expect("materialize plan");
 
         let device_plan = Arc::new(
             cuda_ctx
                 .stream()
-                .clone_htod(std::slice::from_ref(&plan))
+                .clone_htod(dispatch_plan.as_bytes())
                 .expect("htod plan"),
         );
 
-        let output_slice = cuda_ctx
-            .device_alloc::<u32>(len.next_multiple_of(1024))
-            .expect("alloc output");
-        let output_buf = CudaDeviceBuffer::new(output_slice);
-
         Self {
-            _plan: plan,
-            smem_bytes,
+            _plan: dispatch_plan,
+            smem_bytes: shared_mem_bytes,
             len,
             device_plan,
-            output_buf,
-            _plan_buffers: plan_buffers,
+            output_buf: CudaDeviceBuffer::new(
+                cuda_ctx
+                    .device_alloc::<u32>(len.next_multiple_of(1024))
+                    .expect("alloc output"),
+            ),
+            _plan_buffers: device_buffers,
         }
     }
 
@@ -175,10 +190,10 @@ fn bench_for_bitpacked(c: &mut Criterion) {
             .map(|i| (i as u64 % (max_val + 1)) as u32)
             .collect();
         let prim = PrimitiveArray::new(Buffer::from(residuals), NonNullable);
-        let bp = BitPackedArray::encode(prim.as_ref(), bit_width).vortex_expect("bitpack");
-        let for_arr =
-            FoRArray::try_new(bp.into_array(), Scalar::from(reference)).vortex_expect("for");
-        let array = for_arr.to_array();
+        let bp = BitPackedData::encode(&prim.into_array(), bit_width).vortex_expect("bitpack");
+        let array = FoR::try_new(bp.into_array(), Scalar::from(reference))
+            .vortex_expect("for")
+            .into_array();
 
         group.bench_with_input(
             BenchmarkId::new("dynamic_dispatch_u32", len_str),
@@ -219,11 +234,11 @@ fn bench_dict_bp_codes(c: &mut Criterion) {
 
         let codes: Vec<u32> = (0..*len).map(|i| (i % dict_size) as u32).collect();
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), dict_bit_width)
+        let codes_bp = BitPackedData::encode(&codes_prim.into_array(), dict_bit_width)
             .vortex_expect("bitpack codes");
         let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
         let dict = DictArray::new(codes_bp.into_array(), values_prim.into_array());
-        let array = dict.to_array();
+        let array = dict.into_array();
 
         group.bench_with_input(
             BenchmarkId::new("dynamic_dispatch_u32", len_str),
@@ -266,8 +281,8 @@ fn bench_runend(c: &mut Criterion) {
 
         let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array();
         let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
-        let re = RunEndArray::new(ends_arr, values_arr);
-        let array = re.to_array();
+        let re = RunEnd::new(ends_arr, values_arr);
+        let array = re.into_array();
 
         group.bench_with_input(
             BenchmarkId::new("dynamic_dispatch_u32", len_str),
@@ -307,21 +322,21 @@ fn bench_dict_bp_codes_bp_for_values(c: &mut Criterion) {
     // Dict values: residuals 0..63 bitpacked, FoR adds 1_000_000
     let dict_residuals: Vec<u32> = (0..dict_size as u32).collect();
     let dict_prim = PrimitiveArray::new(Buffer::from(dict_residuals), NonNullable);
-    let dict_bp =
-        BitPackedArray::encode(dict_prim.as_ref(), dict_bit_width).vortex_expect("bitpack dict");
-    let dict_for = FoRArray::try_new(dict_bp.into_array(), Scalar::from(dict_reference))
-        .vortex_expect("for dict");
+    let dict_bp = BitPackedData::encode(&dict_prim.into_array(), dict_bit_width)
+        .vortex_expect("bitpack dict");
+    let dict_for =
+        FoR::try_new(dict_bp.into_array(), Scalar::from(dict_reference)).vortex_expect("for dict");
 
     for (len, len_str) in BENCH_ARGS {
         group.throughput(Throughput::Bytes((len * size_of::<u32>()) as u64));
 
         let codes: Vec<u32> = (0..*len).map(|i| (i % dict_size) as u32).collect();
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), codes_bit_width)
+        let codes_bp = BitPackedData::encode(&codes_prim.into_array(), codes_bit_width)
             .vortex_expect("bitpack codes");
 
-        let dict = DictArray::new(codes_bp.into_array(), dict_for.to_array());
-        let array = dict.to_array();
+        let dict = DictArray::new(codes_bp.into_array(), dict_for.clone().into_array());
+        let array = dict.into_array();
 
         group.bench_with_input(
             BenchmarkId::new("dynamic_dispatch_u32", len_str),
@@ -368,18 +383,18 @@ fn bench_alp_for_bitpacked(c: &mut Criterion) {
         // Encode: ALP → FoR → BitPacked
         let alp = alp_encode(&float_prim, Some(exponents)).vortex_expect("alp_encode");
         assert!(alp.patches().is_none());
-        let for_arr = FoRArray::encode(alp.encoded().to_primitive()).vortex_expect("for encode");
+        let for_arr = FoRData::encode(alp.encoded().to_primitive()).vortex_expect("for encode");
         let bp =
-            BitPackedArray::encode(for_arr.encoded(), bit_width).vortex_expect("bitpack encode");
+            BitPackedData::encode(for_arr.encoded(), bit_width).vortex_expect("bitpack encode");
 
-        let tree = ALPArray::new(
-            FoRArray::try_new(bp.into_array(), for_arr.reference_scalar().clone())
+        let tree = ALP::new(
+            FoR::try_new(bp.into_array(), for_arr.reference_scalar().clone())
                 .vortex_expect("for_new")
                 .into_array(),
             exponents,
             None,
         );
-        let array = tree.to_array();
+        let array = tree.into_array();
 
         group.bench_with_input(
             BenchmarkId::new("dynamic_dispatch_f32", len_str),
diff --git a/vortex-cuda/benches/for_cuda.rs b/vortex-cuda/benches/for_cuda.rs
index 6da6d196736..cc5fab5e22c 100644
--- a/vortex-cuda/benches/for_cuda.rs
+++ b/vortex-cuda/benches/for_cuda.rs
@@ -25,7 +25,8 @@ use vortex::array::validity::Validity;
 use vortex::buffer::Buffer;
 use vortex::dtype::NativePType;
 use vortex::dtype::PType;
-use vortex::encodings::fastlanes::BitPackedArray;
+use vortex::encodings::fastlanes::BitPackedData;
+use vortex::encodings::fastlanes::FoR;
 use vortex::encodings::fastlanes::FoRArray;
 use vortex::error::VortexExpect;
 use vortex::scalar::Scalar;
@@ -55,13 +56,11 @@ where
         PrimitiveArray::new(Buffer::from(data), Validity::NonNullable).into_array();
 
     if bp && T::PTYPE != PType::U8 {
-        let child =
-            BitPackedArray::encode(primitive_array.as_ref(), 8).vortex_expect("failed to bitpack");
-        FoRArray::try_new(child.into_array(), reference.into())
+        let child = BitPackedData::encode(&primitive_array, 8).vortex_expect("failed to bitpack");
+        FoR::try_new(child.into_array(), reference.into())
             .vortex_expect("failed to create FoR array")
     } else {
-        FoRArray::try_new(primitive_array, reference.into())
-            .vortex_expect("failed to create FoR array")
+        FoR::try_new(primitive_array, reference.into()).vortex_expect("failed to create FoR array")
     }
 }
 
@@ -92,7 +91,8 @@ where
                         .with_launch_strategy(Arc::new(timed));
 
                     for _ in 0..iters {
-                        block_on(for_array.to_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                        block_on(for_array.clone().into_array().execute_cuda(&mut cuda_ctx))
+                            .unwrap();
                     }
 
                     Duration::from_nanos(timer.load(Ordering::Relaxed))
@@ -130,7 +130,8 @@ where
                         .with_launch_strategy(Arc::new(timed));
 
                     for _ in 0..iters {
-                        block_on(for_array.to_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                        block_on(for_array.clone().into_array().execute_cuda(&mut cuda_ctx))
+                            .unwrap();
                     }
 
                     Duration::from_nanos(timer.load(Ordering::Relaxed))
diff --git a/vortex-cuda/benches/runend_cuda.rs b/vortex-cuda/benches/runend_cuda.rs
index 4e0d8ba7edb..c073f60634c 100644
--- a/vortex-cuda/benches/runend_cuda.rs
+++ b/vortex-cuda/benches/runend_cuda.rs
@@ -23,6 +23,7 @@ use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity;
 use vortex::buffer::Buffer;
 use vortex::dtype::NativePType;
+use vortex::encodings::runend::RunEnd;
 use vortex::encodings::runend::RunEndArray;
 use vortex::session::VortexSession;
 use vortex_cuda::CudaSession;
@@ -54,7 +55,7 @@ where
     let ends_array = PrimitiveArray::new(Buffer::from(ends), Validity::NonNullable).into_array();
     let values_array =
         PrimitiveArray::new(Buffer::from(values), Validity::NonNullable).into_array();
-    RunEndArray::new(ends_array, values_array)
+    RunEnd::new(ends_array, values_array)
 }
 
 /// Benchmark run-end decoding for a specific type with varying run lengths
@@ -89,7 +90,13 @@ where
                                 .with_launch_strategy(Arc::new(timed));
 
                         for _ in 0..iters {
-                            block_on(runend_array.to_array().execute_cuda(&mut cuda_ctx)).unwrap();
+                            block_on(
+                                runend_array
+                                    .clone()
+                                    .into_array()
+                                    .execute_cuda(&mut cuda_ctx),
+                            )
+                            .unwrap();
                         }
 
                         Duration::from_nanos(timer.load(Ordering::Relaxed))
diff --git a/vortex-cuda/benches/transpose_patches.rs b/vortex-cuda/benches/transpose_patches.rs
new file mode 100644
index 00000000000..a4a4dfaa099
--- /dev/null
+++ b/vortex-cuda/benches/transpose_patches.rs
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::cast_possible_truncation)]
+
+use std::time::Duration;
+
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::Throughput;
+use futures::executor::block_on;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::dtype::PType;
+use vortex::array::patches::Patches;
+use vortex::buffer::Buffer;
+use vortex::buffer::buffer;
+use vortex::session::VortexSession;
+use vortex_array::validity::Validity;
+use vortex_cuda::CudaSession;
+use vortex_cuda::transpose_patches;
+use vortex_cuda_macros::cuda_available;
+use vortex_cuda_macros::cuda_not_available;
+use vortex_error::VortexExpect;
+
+fn benchmark_transpose(c: &mut Criterion) {
+    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+        .vortex_expect("failed to create execution context");
+
+    let patches = block_on(async {
+        // Assume that we have 64k values, and we have 1024 patches evenly disbursed across
+        // the range.
+        let indices = (0..1024).map(|x| x * 64).collect::<Buffer<u32>>();
+
+        let values = buffer![-1.0f32; 1024];
+
+        let device_indices = cuda_ctx.copy_to_device(indices)?.await?;
+        let device_values = cuda_ctx.copy_to_device(values)?.await?;
+
+        Patches::new(
+            64 * 1024,
+            0,
+            PrimitiveArray::from_buffer_handle(device_indices, PType::U32, Validity::NonNullable)
+                .into_array(),
+            PrimitiveArray::from_buffer_handle(device_values, PType::F32, Validity::NonNullable)
+                .into_array(),
+            None,
+        )
+    })
+    .unwrap();
+
+    let mut group = c.benchmark_group("transpose");
+    group.sample_size(100);
+    group.measurement_time(Duration::from_secs(10));
+
+    group.throughput(Throughput::Bytes(
+        patches.indices().nbytes() + patches.values().nbytes(),
+    ));
+
+    group.bench_with_input(
+        BenchmarkId::new("transpose_patches", 0),
+        &patches,
+        |b, patches| {
+            b.iter(|| block_on(async { transpose_patches(patches, &mut cuda_ctx).await.unwrap() }))
+        },
+    );
+}
+
+criterion::criterion_group!(benches, benchmark_transpose);
+
+#[cuda_available]
+criterion::criterion_main!(benches);
+
+#[cuda_not_available]
+fn main() {}
diff --git a/vortex-cuda/benches/zstd_cuda.rs b/vortex-cuda/benches/zstd_cuda.rs
index 41be9fa8cf9..a5d285d2d2a 100644
--- a/vortex-cuda/benches/zstd_cuda.rs
+++ b/vortex-cuda/benches/zstd_cuda.rs
@@ -13,8 +13,10 @@ use cudarc::driver::DevicePtrMut;
 use cudarc::driver::sys::CUevent_flags;
 use futures::executor::block_on;
 use vortex::array::arrays::VarBinViewArray;
+use vortex::array::vtable::child_to_validity;
+use vortex::encodings::zstd::Zstd;
 use vortex::encodings::zstd::ZstdArray;
-use vortex::encodings::zstd::ZstdArrayParts;
+use vortex::encodings::zstd::ZstdDataParts;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
@@ -58,7 +60,7 @@ fn make_zstd_array(num_strings: usize) -> VortexResult<(ZstdArray, usize)> {
     let zstd_compression_level = -10; // Less compression but faster.
     let zstd_array =
         // Disable dictionary as nvCOMP doesn't support ZSTD dictionaries.
-        ZstdArray::from_var_bin_view_without_dict(&var_bin_view, zstd_compression_level, 2048)?;
+        Zstd::from_var_bin_view_without_dict(&var_bin_view, zstd_compression_level, 2048)?;
 
     Ok((zstd_array, uncompressed_size))
 }
@@ -137,9 +139,15 @@ fn benchmark_zstd_cuda_decompress(c: &mut Criterion) {
                     let mut total_time = Duration::ZERO;
 
                     for _ in 0..iters {
-                        let ZstdArrayParts {
+                        let ZstdDataParts {
                             frames, metadata, ..
-                        } = zstd_array.clone().into_parts();
+                        } = {
+                            let validity = child_to_validity(
+                                &zstd_array.as_ref().slots()[0],
+                                zstd_array.dtype().nullability(),
+                            );
+                            zstd_array.clone().into_data().into_parts(validity)
+                        };
                         let exec = block_on(zstd_kernel_prepare(frames, &metadata, &mut cuda_ctx))
                             .vortex_expect("kernel setup failed");
                         let kernel_time = block_on(execute_zstd_kernel(exec, &mut cuda_ctx))
diff --git a/vortex-cuda/build.rs b/vortex-cuda/build.rs
index ef1eb522b3c..fd035398b14 100644
--- a/vortex-cuda/build.rs
+++ b/vortex-cuda/build.rs
@@ -14,10 +14,10 @@ use std::process::Command;
 
 use fastlanes::FastLanes;
 
-use crate::cuda_kernel_generator::IndentedWriter;
-use crate::cuda_kernel_generator::generate_cuda_unpack_for_width;
+use crate::bit_unpack_gen::generate_cuda_unpack;
 
-pub mod cuda_kernel_generator;
+#[path = "src/bit_unpack_gen.rs"]
+pub mod bit_unpack_gen;
 
 fn main() {
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").expect("Failed to get manifest dir");
@@ -43,12 +43,12 @@ fn main() {
     println!("cargo:rerun-if-env-changed=PROFILE");
 
     // Regenerate bit_unpack kernels only when the generator changes
-    for entry in std::fs::read_dir(Path::new(&manifest_dir).join("cuda_kernel_generator"))
-        .expect("Failed to read cuda_kernel_generator directory")
-        .flatten()
-    {
-        println!("cargo:rerun-if-changed={}", entry.path().display());
-    }
+    println!(
+        "cargo:rerun-if-changed={}",
+        Path::new(&manifest_dir)
+            .join("src/bit_unpack_gen.rs")
+            .display()
+    );
     generate_unpack::<u8>(&kernels_src, 32).expect("Failed to generate unpack for u8");
     generate_unpack::<u16>(&kernels_src, 32).expect("Failed to generate unpack for u16");
     generate_unpack::<u32>(&kernels_src, 32).expect("Failed to generate unpack for u32");
@@ -56,6 +56,7 @@ fn main() {
 
     let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
     generate_dynamic_dispatch_bindings(&kernels_src, &out_dir);
+    generate_patches_bindings(&kernels_src, &out_dir);
 
     if !is_cuda_available() {
         return;
@@ -95,8 +96,7 @@ fn main() {
 fn generate_unpack<T: FastLanes>(output_dir: &Path, thread_count: usize) -> io::Result<PathBuf> {
     let path = output_dir.join(format!("bit_unpack_{}.cu", T::T));
     let mut cu_file = File::create(&path)?;
-    let mut cu_writer = IndentedWriter::new(&mut cu_file);
-    generate_cuda_unpack_for_width::<T, _>(&mut cu_writer, thread_count)?;
+    generate_cuda_unpack::<T>(&mut cu_file, thread_count)?;
     Ok(path)
 }
 
@@ -138,7 +138,7 @@ fn nvcc_compile_ptx(
         .join(cu_path.file_name().unwrap())
         .with_extension("ptx");
 
-    cmd.arg("-std=c++17")
+    cmd.arg("-std=c++20")
         .arg("-arch=native")
         // Flags forwarded to Clang.
         .arg("--compiler-options=-Wall -Wextra -Wpedantic -Werror")
@@ -183,9 +183,6 @@ fn nvcc_compile_ptx(
 }
 
 /// Generate bindings for the dynamic dispatch shared header.
-///
-/// `DynamicDispatchPlan` and related types are shared between CUDA kernels
-/// and Rust host code.
 fn generate_dynamic_dispatch_bindings(kernels_src: &Path, out_dir: &Path) {
     let header = kernels_src.join("dynamic_dispatch.h");
     println!("cargo:rerun-if-changed={}", header.display());
@@ -202,6 +199,23 @@ fn generate_dynamic_dispatch_bindings(kernels_src: &Path, out_dir: &Path) {
         .expect("Failed to write dynamic_dispatch.rs");
 }
 
+/// Generate bindings for patches shared header.
+fn generate_patches_bindings(kernels_src: &Path, out_dir: &Path) {
+    let header = kernels_src.join("patches.h");
+    println!("cargo:rerun-if-changed={}", header.display());
+
+    let bindings = bindgen::Builder::default()
+        .header(header.to_string_lossy())
+        .derive_copy(true)
+        .derive_debug(true)
+        .generate()
+        .expect("Failed to generate dynamic_dispatch bindings");
+
+    bindings
+        .write_to_file(out_dir.join("patches.rs"))
+        .expect("Failed to write patches.rs");
+}
+
 /// Check if CUDA is available based on nvcc.
 fn is_cuda_available() -> bool {
     Command::new("nvcc")
diff --git a/vortex-cuda/cub/build.rs b/vortex-cuda/cub/build.rs
index e9c98a1b214..16b758a57dd 100644
--- a/vortex-cuda/cub/build.rs
+++ b/vortex-cuda/cub/build.rs
@@ -57,7 +57,7 @@ fn is_cuda_available() -> bool {
 fn compile_shared_library(kernel_dir: &Path, sources: &[PathBuf], out_dir: &Path) {
     let lib_path = out_dir.join("libvortex_cub.so");
     let mut cmd = Command::new("nvcc");
-    cmd.args(["-std=c++17", "-arch=native"]);
+    cmd.args(["-std=c++20", "-arch=native"]);
 
     if env::var("PROFILE").unwrap() == "debug" {
         cmd.args(["-O0", "-g", "-G", "-lineinfo"]);
diff --git a/vortex-cuda/cub/src/lib.rs b/vortex-cuda/cub/src/lib.rs
index d7666a46f55..706373255aa 100644
--- a/vortex-cuda/cub/src/lib.rs
+++ b/vortex-cuda/cub/src/lib.rs
@@ -17,8 +17,6 @@
 use std::path::PathBuf;
 use std::sync::OnceLock;
 
-use vortex_cuda_macros::cuda_tests;
-
 /// Raw FFI type definitions and dynamically-loaded function pointers from bindgen.
 #[allow(
     non_upper_case_globals,
@@ -60,11 +58,11 @@ pub fn cub_library() -> Result<&'static sys::CubLibrary, CubError> {
         .map_err(|e| CubError::LibraryLoadError(e.clone()))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use crate::filter;
 
-    #[test]
+    #[vortex_cuda_macros::test]
     fn test_filter_temp_size_u64() -> Result<(), crate::CubError> {
         let temp_bytes = filter::filter_get_temp_size_u64(1000)?;
         // CUB requires some temporary storage
@@ -72,14 +70,14 @@ mod tests {
         Ok(())
     }
 
-    #[test]
+    #[vortex_cuda_macros::test]
     fn test_filter_temp_size_f64() -> Result<(), crate::CubError> {
         let temp_bytes = filter::filter_get_temp_size_f64(10000)?;
         assert!(temp_bytes > 0);
         Ok(())
     }
 
-    #[test]
+    #[vortex_cuda_macros::test]
     fn test_filter_temp_size_zero_items() -> Result<(), crate::CubError> {
         // Just verify the call doesn't fail with zero items
         let _temp_bytes = filter::filter_get_temp_size_u8(0)?;
diff --git a/vortex-cuda/cuda_kernel_generator/indent.rs b/vortex-cuda/cuda_kernel_generator/indent.rs
deleted file mode 100644
index b4159b1a692..00000000000
--- a/vortex-cuda/cuda_kernel_generator/indent.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt;
-use std::io;
-use std::io::Write;
-
-pub struct IndentedWriter<W: Write> {
-    write: W,
-    indent: String,
-}
-
-impl<W: Write> IndentedWriter<W> {
-    pub fn new(write: W) -> Self {
-        Self {
-            write,
-            indent: String::new(),
-        }
-    }
-
-    /// # Errors
-    ///
-    /// Will return Err if writing to the underlying writer fails.
-    pub fn indent<F>(&mut self, indented: F) -> io::Result<()>
-    where
-        F: FnOnce(&mut IndentedWriter<W>) -> io::Result<()>,
-    {
-        let original_ident = self.indent.clone();
-        self.indent += "    ";
-        let res = indented(self);
-        self.indent = original_ident;
-        res
-    }
-
-    /// # Errors
-    ///
-    /// Will return Err if writing to the underlying writer fails.
-    pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        write!(self.write, "{}{}", self.indent, fmt)
-    }
-}
diff --git a/vortex-cuda/cuda_kernel_generator/mod.rs b/vortex-cuda/cuda_kernel_generator/mod.rs
deleted file mode 100644
index cb2dac71c51..00000000000
--- a/vortex-cuda/cuda_kernel_generator/mod.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-mod indent;
-
-use std::io;
-use std::io::Write;
-
-use fastlanes::FastLanes;
-pub use indent::IndentedWriter;
-
-fn generate_lane_decoder<T: FastLanes, W: Write>(
-    output: &mut IndentedWriter<W>,
-    bit_width: usize,
-) -> io::Result<()> {
-    let bits = <T>::T;
-    let lanes = T::LANES;
-
-    let func_name = format!("bit_unpack_{bits}_{bit_width}bw_lane");
-
-    writeln!(
-        output,
-        "__device__ void _{func_name}(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, unsigned int lane) {{"
-    )?;
-
-    output.indent(|output| {
-        writeln!(output, "unsigned int LANE_COUNT = {lanes};")?;
-        if bit_width == 0 {
-            writeln!(output)?;
-            for row in 0..bits {
-                writeln!(output, "out[INDEX({row}, lane)] = reference;")?;
-            }
-        } else if bit_width == bits {
-            writeln!(output)?;
-            for row in 0..bits {
-                writeln!(
-                    output,
-                    "out[INDEX({row}, lane)] = in[LANE_COUNT * {row} + lane] + reference;",
-                )?;
-            }
-        } else {
-            writeln!(output, "uint{bits}_t src;")?;
-            writeln!(output, "uint{bits}_t tmp;")?;
-
-            writeln!(output)?;
-            writeln!(output, "src = in[lane];")?;
-            for row in 0..bits {
-                let curr_word = (row * bit_width) / bits;
-                let next_word = ((row + 1) * bit_width) / bits;
-                let shift = (row * bit_width) % bits;
-
-                if next_word > curr_word {
-                    let remaining_bits = ((row + 1) * bit_width) % bits;
-                    let current_bits = bit_width - remaining_bits;
-                    writeln!(
-                        output,
-                        "tmp = (src >> {shift}) & MASK(uint{bits}_t, {current_bits});"
-                    )?;
-
-                    if next_word < bit_width {
-                        writeln!(output, "src = in[lane + LANE_COUNT * {next_word}];")?;
-                        writeln!(
-                            output,
-                            "tmp |= (src & MASK(uint{bits}_t, {remaining_bits})) << {current_bits};"
-                        )?;
-                    }
-                } else {
-                    writeln!(
-                        output,
-                        "tmp = (src >> {shift}) & MASK(uint{bits}_t, {bit_width});"
-                    )?;
-                }
-
-                writeln!(output, "out[INDEX({row}, lane)] = tmp + reference;")?;
-            }
-        }
-        Ok(())
-    })?;
-
-    writeln!(output, "}}")
-}
-
-/// Generate a runtime dispatch function that routes
-/// to the appropriate bit-width-specific lane decoder.
-fn generate_lane_dispatch<T: FastLanes, W: Write>(
-    output: &mut IndentedWriter<W>,
-) -> io::Result<()> {
-    let bits = <T>::T;
-
-    writeln!(
-        output,
-        "/// Runtime dispatch to the optimized lane decoder for the given bit width."
-    )?;
-    writeln!(output, "__device__ inline void bit_unpack_{bits}_lane(")?;
-    writeln!(output, "    const uint{bits}_t *__restrict in,")?;
-    writeln!(output, "    uint{bits}_t *__restrict out,")?;
-    writeln!(output, "    uint{bits}_t reference,")?;
-    writeln!(output, "    unsigned int lane,")?;
-    writeln!(output, "    uint32_t bit_width")?;
-    writeln!(output, ") {{")?;
-
-    output.indent(|output| {
-        writeln!(output, "switch (bit_width) {{")?;
-        output.indent(|output| {
-            for bw in 0..=bits {
-                writeln!(
-                    output,
-                    "case {bw}: _bit_unpack_{bits}_{bw}bw_lane(in, out, reference, lane); break;"
-                )?;
-            }
-            Ok(())
-        })?;
-        writeln!(output, "}}")
-    })?;
-
-    writeln!(output, "}}")
-}
-
-fn generate_device_kernel_for_width<T: FastLanes, W: Write>(
-    output: &mut IndentedWriter<W>,
-    bit_width: usize,
-    thread_count: usize,
-) -> io::Result<()> {
-    let bits = <T>::T;
-    let lanes = T::LANES;
-    let per_thread_loop_count = lanes / thread_count;
-    let shared_copy_ncount = 1024 / thread_count;
-
-    let func_name = format!("bit_unpack_{bits}_{bit_width}bw_{thread_count}t");
-
-    let local_func_params = format!(
-        "(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, int thread_idx)"
-    );
-
-    writeln!(output, "__device__ void _{func_name}{local_func_params} {{")?;
-
-    output.indent(|output| {
-        writeln!(output, "__shared__ uint{bits}_t shared_out[1024];")?;
-
-        for thread_lane in 0..per_thread_loop_count {
-            writeln!(output, "_bit_unpack_{bits}_{bit_width}bw_lane(in, shared_out, reference, thread_idx * {per_thread_loop_count} + {thread_lane});")?;
-        }
-
-        writeln!(output, "for (int i = 0; i < {shared_copy_ncount}; i++) {{")?;
-        output.indent(|output| {
-            writeln!(output, "auto idx = i * {thread_count} + thread_idx;")?;
-            writeln!(output, "out[idx] = shared_out[idx];")
-        })?;
-        writeln!(output, "}}")
-    })?;
-
-    writeln!(output, "}}")
-}
-
-fn generate_global_kernel_for_width<T: FastLanes, W: Write>(
-    output: &mut IndentedWriter<W>,
-    bit_width: usize,
-    thread_count: usize,
-) -> io::Result<()> {
-    let bits = <T>::T;
-
-    let func_name = format!("bit_unpack_{bits}_{bit_width}bw_{thread_count}t");
-    let func_params = format!(
-        "(const uint{bits}_t *__restrict full_in, uint{bits}_t *__restrict full_out, uint{bits}_t reference)"
-    );
-
-    writeln!(
-        output,
-        "extern \"C\" __global__ void {func_name}{func_params} {{"
-    )?;
-
-    output.indent(|output| {
-        writeln!(output, "int thread_idx = threadIdx.x;")?;
-        writeln!(
-            output,
-            "auto in = full_in + (blockIdx.x * (128 * {bit_width} / sizeof(uint{bits}_t)));"
-        )?;
-        writeln!(output, "auto out = full_out + (blockIdx.x * 1024);")?;
-
-        writeln!(output, "_{func_name}(in, out, reference, thread_idx);")
-    })?;
-
-    writeln!(output, "}}")
-}
-
-/// Generate CUDA lane decoders, dispatch function, and kernel wrappers for all bit widths.
-pub fn generate_cuda_unpack_for_width<T: FastLanes, W: Write>(
-    output: &mut IndentedWriter<W>,
-    thread_count: usize,
-) -> io::Result<()> {
-    let bits = <T>::T;
-
-    writeln!(output, "// AUTO-GENERATED. Do not edit by hand!")?;
-    writeln!(output, "#include <cuda.h>")?;
-    writeln!(output, "#include <cuda_runtime.h>")?;
-    writeln!(output, "#include <stdint.h>")?;
-    writeln!(output, "#include \"fastlanes_common.cuh\"")?;
-    writeln!(output)?;
-
-    // First, emit all lane decoders.
-    for bit_width in 0..=bits {
-        generate_lane_decoder::<T, _>(output, bit_width)?;
-        writeln!(output)?;
-    }
-
-    // Emit the runtime lane dispatch function (used by dynamic_dispatch.cu).
-    generate_lane_dispatch::<T, _>(output)?;
-    writeln!(output)?;
-
-    // Emit device and global kernel wrappers.
-    for bit_width in 0..=bits {
-        generate_device_kernel_for_width::<T, _>(output, bit_width, thread_count)?;
-        writeln!(output)?;
-
-        generate_global_kernel_for_width::<T, _>(output, bit_width, thread_count)?;
-        writeln!(output)?;
-    }
-
-    Ok(())
-}
diff --git a/vortex-cuda/gpu-scan-cli/Cargo.toml b/vortex-cuda/gpu-scan-cli/Cargo.toml
index 9bdf7fc3478..9234d303952 100644
--- a/vortex-cuda/gpu-scan-cli/Cargo.toml
+++ b/vortex-cuda/gpu-scan-cli/Cargo.toml
@@ -16,11 +16,12 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
+clap = { workspace = true, features = ["derive"] }
 futures = { workspace = true, features = ["executor"] }
 tokio = { workspace = true, features = ["macros", "full"] }
 tracing = { workspace = true, features = ["std", "attributes"] }
 tracing-perfetto = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
-vortex = { workspace = true }
+vortex = { workspace = true, features = ["tokio"] }
 vortex-cuda = { workspace = true, features = ["_test-harness"] }
 vortex-cuda-macros = { workspace = true }
diff --git a/vortex-cuda/gpu-scan-cli/src/main.rs b/vortex-cuda/gpu-scan-cli/src/main.rs
index 7aac1762804..4c343742000 100644
--- a/vortex-cuda/gpu-scan-cli/src/main.rs
+++ b/vortex-cuda/gpu-scan-cli/src/main.rs
@@ -3,12 +3,12 @@
 
 #![allow(unused_imports)]
 
-use std::env::args;
 use std::fs::File;
-use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use clap::Parser;
+use clap::Subcommand;
 use futures::StreamExt;
 use tracing::Instrument;
 use tracing_perfetto::PerfettoLayer;
@@ -19,38 +19,110 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use vortex::VortexSessionDefault;
 use vortex::array::ToCanonical;
-use vortex::array::arrays::DictVTable;
-use vortex::buffer::ByteBuffer;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::struct_::StructArrayExt;
 use vortex::buffer::ByteBufferMut;
 use vortex::compressor::BtrBlocksCompressorBuilder;
-use vortex::compressor::FloatCode;
-use vortex::compressor::IntCode;
-use vortex::compressor::StringCode;
 use vortex::error::VortexResult;
-use vortex::file::Footer;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::WriteOptionsSessionExt;
 use vortex::file::WriteStrategyBuilder;
+use vortex::io::session::RuntimeSessionExt;
 use vortex::session::VortexSession;
-use vortex_cuda::CopyDeviceReadAt;
 use vortex_cuda::CudaSession;
+use vortex_cuda::PinnedByteBufferPool;
+use vortex_cuda::PooledByteBufferReadAt;
+use vortex_cuda::PooledFileReadAt;
 use vortex_cuda::TracingLaunchStrategy;
 use vortex_cuda::VortexCudaStreamPool;
 use vortex_cuda::executor::CudaArrayExt;
+use vortex_cuda::layout::CudaFlatLayoutStrategy;
+use vortex_cuda::layout::register_cuda_layout;
 use vortex_cuda_macros::cuda_available;
 use vortex_cuda_macros::cuda_not_available;
 
+#[derive(Parser)]
+#[command(name = "gpu-scan-cli", about = "CUDA GPU scan tool")]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// Convert a Vortex file to use CUDA-compatible encodings.
+    Convert {
+        /// Path to input .vortex file.
+        #[arg(long)]
+        input: PathBuf,
+        /// Path to output CUDA-compatible .vortex file.
+        #[arg(long)]
+        output: PathBuf,
+    },
+    /// Scan a Vortex file using GPU decompression.
+    Scan {
+        /// Path to .vortex file.
+        path: PathBuf,
+        /// If set, the file is already CUDA-compatible (skip recompression).
+        #[arg(long)]
+        gpu_file: bool,
+        /// Output logs as JSON.
+        #[arg(long)]
+        json: bool,
+    },
+}
+
 #[cuda_not_available]
 fn main() {}
 
 #[cuda_available]
 #[tokio::main]
 async fn main() -> VortexResult<()> {
-    let args: Vec<String> = args().collect();
-    let json_output = args.iter().any(|arg| arg == "--json");
+    let cli = Cli::parse();
+
+    match cli.command {
+        Command::Convert { input, output } => cmd_convert(input, output).await,
+        Command::Scan {
+            path,
+            gpu_file,
+            json,
+        } => cmd_scan(path, gpu_file, json).await,
+    }
+}
 
-    let perfetto_file = File::create("trace.pb")?;
+/// Build the write strategy used for CUDA-compatible file output.
+#[cuda_available]
+fn cuda_write_strategy() -> Arc<dyn vortex::layout::LayoutStrategy> {
+    WriteStrategyBuilder::default()
+        .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().only_cuda_compatible())
+        .with_flat_strategy(Arc::new(CudaFlatLayoutStrategy::default()))
+        .build()
+}
+
+/// Convert an input Vortex file to CUDA-compatible encodings and write to disk.
+#[cuda_available]
+async fn cmd_convert(input: PathBuf, output: PathBuf) -> VortexResult<()> {
+    let session = VortexSession::default();
+    register_cuda_layout(&session);
+
+    let input_file = session.open_options().open_path(&input).await?;
+    let scan = input_file.scan()?.into_array_stream()?;
+
+    let mut out = tokio::fs::File::create(&output).await?;
+    session
+        .write_options()
+        .with_strategy(cuda_write_strategy())
+        .write(&mut out, scan)
+        .await?;
+
+    tracing::info!("Wrote CUDA-compatible file to {}", output.display());
+    Ok(())
+}
 
+/// Scan a Vortex file on the GPU, optionally recompressing in memory first.
+#[cuda_available]
+async fn cmd_scan(path: PathBuf, gpu_file: bool, json_output: bool) -> VortexResult<()> {
+    let perfetto_file = File::create("trace.pb")?;
     let perfetto_layer = PerfettoLayer::new(perfetto_file).with_debug_annotations(true);
 
     if json_output {
@@ -77,47 +149,43 @@ async fn main() -> VortexResult<()> {
     }
 
     let session = VortexSession::default();
+    register_cuda_layout(&session);
+
     let mut cuda_ctx = CudaSession::create_execution_ctx(&session)?
         .with_launch_strategy(Arc::new(TracingLaunchStrategy));
 
-    #[allow(clippy::expect_used, clippy::unwrap_in_result)]
-    let input_path = args
-        .iter()
-        .skip(1)
-        .find(|arg| !arg.starts_with("--"))
-        .expect("must provide path to .vortex file");
-    let input_path = PathBuf::from(input_path);
-
-    assert!(input_path.exists(), "input path does not exist");
-
-    let (recompressed, footer) = recompress_for_gpu(input_path, &session).await?;
-
-    // Create a full scan that executes on the GPU
+    let pool = Arc::new(PinnedByteBufferPool::new(Arc::clone(
+        cuda_ctx.stream().context(),
+    )));
     let cuda_stream =
-        VortexCudaStreamPool::new(Arc::clone(cuda_ctx.stream().context()), 1).get_stream()?;
-    let gpu_reader = CopyDeviceReadAt::new(recompressed, cuda_stream);
+        VortexCudaStreamPool::new(Arc::clone(cuda_ctx.stream().context()), 1).stream()?;
+    let handle = session.handle();
 
-    let gpu_file = session
-        .open_options()
-        .with_footer(footer)
-        .open(Arc::new(gpu_reader))
-        .await?;
+    let gpu_file_handle = if gpu_file {
+        let reader = PooledFileReadAt::open(&path, handle, Arc::clone(&pool), cuda_stream)?;
+        session.open_options().open(Arc::new(reader)).await?
+    } else {
+        let (recompressed, footer) = recompress_for_gpu(&path, &session).await?;
+        let reader = PooledByteBufferReadAt::new(recompressed, Arc::clone(&pool), cuda_stream);
+        session
+            .open_options()
+            .with_footer(footer)
+            .open(Arc::new(reader))
+            .await?
+    };
 
-    // execute_micros => µs to execute
-    let mut batches = gpu_file.scan()?.into_array_stream()?;
+    let mut batches = gpu_file_handle.scan()?.into_array_stream()?;
 
     let mut chunk = 0;
     while let Some(next) = batches.next().await.transpose()? {
         let record = next.to_struct();
 
         for (field, field_name) in record
-            .unmasked_fields()
-            .iter()
+            .iter_unmasked_fields()
             .zip(record.struct_fields().names().iter())
         {
             let field_name = field_name.to_string();
-            // skip dict, varbin isn't properly implemented.
-            if field.is::<DictVTable>() {
+            if field.is::<Dict>() {
                 continue;
             }
 
@@ -145,61 +213,20 @@ async fn main() -> VortexResult<()> {
     Ok(())
 }
 
-// Dump the values out as a new Vortex file for analysis.
-
-/// Recompress the input file using only GPU-executable encodings, returning the file as an
-/// in-memory byte array.
+/// Recompress the input file using CUDA-compatible encodings, returning the file as an
+/// in-memory byte buffer along with its footer.
 #[cuda_available]
 async fn recompress_for_gpu(
-    input_path: impl AsRef<Path>,
+    input_path: impl AsRef<std::path::Path>,
     session: &VortexSession,
-) -> VortexResult<(ByteBuffer, Footer)> {
-    // Setup the reader
+) -> VortexResult<(vortex::buffer::ByteBuffer, vortex::file::Footer)> {
     let input = session.open_options().open_path(input_path).await?;
-
-    // Build a scan to read all columns from the input, and recompress them using only GPU-compatible
-    // encodings.
     let scan = input.scan()?.into_array_stream()?;
 
-    // Rebuild a copy of the file that only uses GPU-compatible compression algorithms.
-    let compressor = BtrBlocksCompressorBuilder::empty()
-        .include_int([
-            IntCode::Uncompressed,
-            IntCode::Constant,
-            IntCode::BitPacking,
-            IntCode::For,
-            IntCode::Sequence,
-            IntCode::ZigZag,
-            IntCode::Dict,
-        ])
-        .include_float([
-            FloatCode::Uncompressed,
-            FloatCode::Constant,
-            FloatCode::Alp,
-            FloatCode::AlpRd,
-            FloatCode::RunEnd,
-        ])
-        // Don't compress strings, this is b/c we don't have any BtrBlocks encodings that support
-        // strings.
-        .include_string([
-            StringCode::Uncompressed,
-            StringCode::Constant,
-            StringCode::Dict,
-            StringCode::Zstd,
-            StringCode::ZstdBuffers,
-        ])
-        .build();
-
-    // Read an input stream from a Vortex file.
-    let writer = WriteStrategyBuilder::default()
-        .with_compressor(compressor)
-        .build();
-
-    // Segment sink?
     let mut out = ByteBufferMut::empty();
     let result = session
         .write_options()
-        .with_strategy(writer)
+        .with_strategy(cuda_write_strategy())
         .write(&mut out, scan)
         .await?;
 
diff --git a/vortex-cuda/kernels/src/bit_unpack.cuh b/vortex-cuda/kernels/src/bit_unpack.cuh
index 810c157d527..fb814e3f4fa 100644
--- a/vortex-cuda/kernels/src/bit_unpack.cuh
+++ b/vortex-cuda/kernels/src/bit_unpack.cuh
@@ -11,6 +11,7 @@
 #include "bit_unpack_16.cu"
 #include "bit_unpack_32.cu"
 #include "bit_unpack_64.cu"
+#include "patches.h"
 
 /// Decodes a single lane of packed data.
 ///
diff --git a/vortex-cuda/kernels/src/bit_unpack_16.cu b/vortex-cuda/kernels/src/bit_unpack_16.cu
index 3399f312a39..c329e85157a 100644
--- a/vortex-cuda/kernels/src/bit_unpack_16.cu
+++ b/vortex-cuda/kernels/src/bit_unpack_16.cu
@@ -3,33 +3,24 @@
 #include <cuda_runtime.h>
 #include <stdint.h>
 #include "fastlanes_common.cuh"
+#include "patches.cuh"
 
-__device__ void _bit_unpack_16_0bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
-    unsigned int LANE_COUNT = 64;
-    
-    out[INDEX(0, lane)] = reference;
-    out[INDEX(1, lane)] = reference;
-    out[INDEX(2, lane)] = reference;
-    out[INDEX(3, lane)] = reference;
-    out[INDEX(4, lane)] = reference;
-    out[INDEX(5, lane)] = reference;
-    out[INDEX(6, lane)] = reference;
-    out[INDEX(7, lane)] = reference;
-    out[INDEX(8, lane)] = reference;
-    out[INDEX(9, lane)] = reference;
-    out[INDEX(10, lane)] = reference;
-    out[INDEX(11, lane)] = reference;
-    out[INDEX(12, lane)] = reference;
-    out[INDEX(13, lane)] = reference;
-    out[INDEX(14, lane)] = reference;
-    out[INDEX(15, lane)] = reference;
+template <int BW>
+__device__ void _bit_unpack_16_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane);
+
+template <>
+__device__ void _bit_unpack_16_lane<0>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+    #pragma unroll
+    for (int row = 0; row < 16; row++) {
+        out[INDEX(row, lane)] = reference;
+    }
 }
 
-__device__ void _bit_unpack_16_1bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<1>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 1);
     out[INDEX(0, lane)] = tmp + reference;
@@ -65,11 +56,11 @@ __device__ void _bit_unpack_16_1bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_2bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<2>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 2);
     out[INDEX(0, lane)] = tmp + reference;
@@ -107,11 +98,11 @@ __device__ void _bit_unpack_16_2bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_3bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<3>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 3);
     out[INDEX(0, lane)] = tmp + reference;
@@ -151,11 +142,11 @@ __device__ void _bit_unpack_16_3bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_4bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<4>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 4);
     out[INDEX(0, lane)] = tmp + reference;
@@ -197,11 +188,11 @@ __device__ void _bit_unpack_16_4bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_5bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<5>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 5);
     out[INDEX(0, lane)] = tmp + reference;
@@ -245,11 +236,11 @@ __device__ void _bit_unpack_16_5bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_6bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<6>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 6);
     out[INDEX(0, lane)] = tmp + reference;
@@ -295,11 +286,11 @@ __device__ void _bit_unpack_16_6bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_7bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<7>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 7);
     out[INDEX(0, lane)] = tmp + reference;
@@ -347,11 +338,11 @@ __device__ void _bit_unpack_16_7bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_8bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<8>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 8);
     out[INDEX(0, lane)] = tmp + reference;
@@ -401,11 +392,11 @@ __device__ void _bit_unpack_16_8bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_9bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<9>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 9);
     out[INDEX(0, lane)] = tmp + reference;
@@ -457,11 +448,11 @@ __device__ void _bit_unpack_16_9bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_10bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<10>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 10);
     out[INDEX(0, lane)] = tmp + reference;
@@ -515,11 +506,11 @@ __device__ void _bit_unpack_16_10bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_11bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<11>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 11);
     out[INDEX(0, lane)] = tmp + reference;
@@ -575,11 +566,11 @@ __device__ void _bit_unpack_16_11bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_12bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<12>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 12);
     out[INDEX(0, lane)] = tmp + reference;
@@ -637,11 +628,11 @@ __device__ void _bit_unpack_16_12bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_13bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<13>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 13);
     out[INDEX(0, lane)] = tmp + reference;
@@ -701,11 +692,11 @@ __device__ void _bit_unpack_16_13bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_14bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<14>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 14);
     out[INDEX(0, lane)] = tmp + reference;
@@ -767,11 +758,11 @@ __device__ void _bit_unpack_16_14bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_15bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<15>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
     uint16_t src;
     uint16_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint16_t, 15);
     out[INDEX(0, lane)] = tmp + reference;
@@ -835,25 +826,13 @@ __device__ void _bit_unpack_16_15bw_lane(const uint16_t *__restrict in, uint16_t
     out[INDEX(15, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_16_16bw_lane(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_16_lane<16>(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 64;
-    
-    out[INDEX(0, lane)] = in[LANE_COUNT * 0 + lane] + reference;
-    out[INDEX(1, lane)] = in[LANE_COUNT * 1 + lane] + reference;
-    out[INDEX(2, lane)] = in[LANE_COUNT * 2 + lane] + reference;
-    out[INDEX(3, lane)] = in[LANE_COUNT * 3 + lane] + reference;
-    out[INDEX(4, lane)] = in[LANE_COUNT * 4 + lane] + reference;
-    out[INDEX(5, lane)] = in[LANE_COUNT * 5 + lane] + reference;
-    out[INDEX(6, lane)] = in[LANE_COUNT * 6 + lane] + reference;
-    out[INDEX(7, lane)] = in[LANE_COUNT * 7 + lane] + reference;
-    out[INDEX(8, lane)] = in[LANE_COUNT * 8 + lane] + reference;
-    out[INDEX(9, lane)] = in[LANE_COUNT * 9 + lane] + reference;
-    out[INDEX(10, lane)] = in[LANE_COUNT * 10 + lane] + reference;
-    out[INDEX(11, lane)] = in[LANE_COUNT * 11 + lane] + reference;
-    out[INDEX(12, lane)] = in[LANE_COUNT * 12 + lane] + reference;
-    out[INDEX(13, lane)] = in[LANE_COUNT * 13 + lane] + reference;
-    out[INDEX(14, lane)] = in[LANE_COUNT * 14 + lane] + reference;
-    out[INDEX(15, lane)] = in[LANE_COUNT * 15 + lane] + reference;
+    #pragma unroll
+    for (int row = 0; row < 16; row++) {
+        out[INDEX(row, lane)] = in[LANE_COUNT * row + lane] + reference;
+    }
 }
 
 /// Runtime dispatch to the optimized lane decoder for the given bit width.
@@ -865,312 +844,163 @@ __device__ inline void bit_unpack_16_lane(
     uint32_t bit_width
 ) {
     switch (bit_width) {
-        case 0: _bit_unpack_16_0bw_lane(in, out, reference, lane); break;
-        case 1: _bit_unpack_16_1bw_lane(in, out, reference, lane); break;
-        case 2: _bit_unpack_16_2bw_lane(in, out, reference, lane); break;
-        case 3: _bit_unpack_16_3bw_lane(in, out, reference, lane); break;
-        case 4: _bit_unpack_16_4bw_lane(in, out, reference, lane); break;
-        case 5: _bit_unpack_16_5bw_lane(in, out, reference, lane); break;
-        case 6: _bit_unpack_16_6bw_lane(in, out, reference, lane); break;
-        case 7: _bit_unpack_16_7bw_lane(in, out, reference, lane); break;
-        case 8: _bit_unpack_16_8bw_lane(in, out, reference, lane); break;
-        case 9: _bit_unpack_16_9bw_lane(in, out, reference, lane); break;
-        case 10: _bit_unpack_16_10bw_lane(in, out, reference, lane); break;
-        case 11: _bit_unpack_16_11bw_lane(in, out, reference, lane); break;
-        case 12: _bit_unpack_16_12bw_lane(in, out, reference, lane); break;
-        case 13: _bit_unpack_16_13bw_lane(in, out, reference, lane); break;
-        case 14: _bit_unpack_16_14bw_lane(in, out, reference, lane); break;
-        case 15: _bit_unpack_16_15bw_lane(in, out, reference, lane); break;
-        case 16: _bit_unpack_16_16bw_lane(in, out, reference, lane); break;
+        case 0: _bit_unpack_16_lane<0>(in, out, reference, lane); break;
+        case 1: _bit_unpack_16_lane<1>(in, out, reference, lane); break;
+        case 2: _bit_unpack_16_lane<2>(in, out, reference, lane); break;
+        case 3: _bit_unpack_16_lane<3>(in, out, reference, lane); break;
+        case 4: _bit_unpack_16_lane<4>(in, out, reference, lane); break;
+        case 5: _bit_unpack_16_lane<5>(in, out, reference, lane); break;
+        case 6: _bit_unpack_16_lane<6>(in, out, reference, lane); break;
+        case 7: _bit_unpack_16_lane<7>(in, out, reference, lane); break;
+        case 8: _bit_unpack_16_lane<8>(in, out, reference, lane); break;
+        case 9: _bit_unpack_16_lane<9>(in, out, reference, lane); break;
+        case 10: _bit_unpack_16_lane<10>(in, out, reference, lane); break;
+        case 11: _bit_unpack_16_lane<11>(in, out, reference, lane); break;
+        case 12: _bit_unpack_16_lane<12>(in, out, reference, lane); break;
+        case 13: _bit_unpack_16_lane<13>(in, out, reference, lane); break;
+        case 14: _bit_unpack_16_lane<14>(in, out, reference, lane); break;
+        case 15: _bit_unpack_16_lane<15>(in, out, reference, lane); break;
+        case 16: _bit_unpack_16_lane<16>(in, out, reference, lane); break;
     }
 }
 
-__device__ void _bit_unpack_16_0bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
+template <int BW>
+__device__ void _bit_unpack_16_device(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx, GPUPatches& patches) {
     __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_0bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_0bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
+    #pragma unroll
+    for (int i = 0; i < 2; i++) {
+        _bit_unpack_16_lane<BW>(in, shared_out, reference, thread_idx * 2 + i);
+    }
+    __syncwarp();
+    PatchesCursor<uint16_t> cursor(patches, blockIdx.x, thread_idx, 32);
+    auto patch = cursor.next();
     for (int i = 0; i < 32; i++) {
         auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
+        if (idx == patch.index) {
+            out[idx] = patch.value;
+            patch = cursor.next();
+        } else {
+            out[idx] = shared_out[idx];
+        }
     }
 }
 
-extern "C" __global__ void bit_unpack_16_0bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_0bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 0 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_0bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<0>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_1bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_1bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_1bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_1bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_1bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 1 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_1bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_2bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_2bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_2bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<1>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_2bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_2bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 2 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_2bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<2>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_3bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_3bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_3bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_3bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_3bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 3 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_3bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<3>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_4bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_4bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_4bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_4bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_4bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 4 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_4bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<4>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_5bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_5bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_5bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_5bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_5bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 5 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_5bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<5>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_6bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_6bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_6bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_6bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_6bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 6 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_6bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_7bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_7bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_7bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<6>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_7bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_7bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 7 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_7bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<7>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_8bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_8bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_8bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_8bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_8bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 8 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_8bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<8>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_9bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_9bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_9bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_9bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_9bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 9 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_9bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<9>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_10bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_10bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_10bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_10bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_10bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 10 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_10bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_11bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_11bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_11bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<10>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_11bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_11bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 11 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_11bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_12bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_12bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_12bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<11>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_12bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_12bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 12 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_12bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_13bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_13bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_13bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<12>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_13bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_13bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 13 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_13bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_14bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_14bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_14bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<13>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_14bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_14bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 14 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_14bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<14>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_16_15bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_15bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_15bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_16_15bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_15bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 15 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_15bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_16_16bw_32t(const uint16_t *__restrict in, uint16_t *__restrict out, uint16_t reference, int thread_idx) {
-    __shared__ uint16_t shared_out[1024];
-    _bit_unpack_16_16bw_lane(in, shared_out, reference, thread_idx * 2 + 0);
-    _bit_unpack_16_16bw_lane(in, shared_out, reference, thread_idx * 2 + 1);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_16_device<15>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_16_16bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference) {
+extern "C" __global__ void bit_unpack_16_16bw_32t(const uint16_t *__restrict full_in, uint16_t *__restrict full_out, uint16_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 16 / sizeof(uint16_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_16_16bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_16_device<16>(in, out, reference, thread_idx, patches);
 }
 
diff --git a/vortex-cuda/kernels/src/bit_unpack_32.cu b/vortex-cuda/kernels/src/bit_unpack_32.cu
index 5472478e236..7eb2d49cc49 100644
--- a/vortex-cuda/kernels/src/bit_unpack_32.cu
+++ b/vortex-cuda/kernels/src/bit_unpack_32.cu
@@ -3,49 +3,24 @@
 #include <cuda_runtime.h>
 #include <stdint.h>
 #include "fastlanes_common.cuh"
+#include "patches.cuh"
 
-__device__ void _bit_unpack_32_0bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
-    unsigned int LANE_COUNT = 32;
-    
-    out[INDEX(0, lane)] = reference;
-    out[INDEX(1, lane)] = reference;
-    out[INDEX(2, lane)] = reference;
-    out[INDEX(3, lane)] = reference;
-    out[INDEX(4, lane)] = reference;
-    out[INDEX(5, lane)] = reference;
-    out[INDEX(6, lane)] = reference;
-    out[INDEX(7, lane)] = reference;
-    out[INDEX(8, lane)] = reference;
-    out[INDEX(9, lane)] = reference;
-    out[INDEX(10, lane)] = reference;
-    out[INDEX(11, lane)] = reference;
-    out[INDEX(12, lane)] = reference;
-    out[INDEX(13, lane)] = reference;
-    out[INDEX(14, lane)] = reference;
-    out[INDEX(15, lane)] = reference;
-    out[INDEX(16, lane)] = reference;
-    out[INDEX(17, lane)] = reference;
-    out[INDEX(18, lane)] = reference;
-    out[INDEX(19, lane)] = reference;
-    out[INDEX(20, lane)] = reference;
-    out[INDEX(21, lane)] = reference;
-    out[INDEX(22, lane)] = reference;
-    out[INDEX(23, lane)] = reference;
-    out[INDEX(24, lane)] = reference;
-    out[INDEX(25, lane)] = reference;
-    out[INDEX(26, lane)] = reference;
-    out[INDEX(27, lane)] = reference;
-    out[INDEX(28, lane)] = reference;
-    out[INDEX(29, lane)] = reference;
-    out[INDEX(30, lane)] = reference;
-    out[INDEX(31, lane)] = reference;
-}
-
-__device__ void _bit_unpack_32_1bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <int BW>
+__device__ void _bit_unpack_32_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane);
+
+template <>
+__device__ void _bit_unpack_32_lane<0>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+    #pragma unroll
+    for (int row = 0; row < 32; row++) {
+        out[INDEX(row, lane)] = reference;
+    }
+}
+
+template <>
+__device__ void _bit_unpack_32_lane<1>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 1);
     out[INDEX(0, lane)] = tmp + reference;
@@ -113,11 +88,11 @@ __device__ void _bit_unpack_32_1bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_2bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<2>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 2);
     out[INDEX(0, lane)] = tmp + reference;
@@ -187,11 +162,11 @@ __device__ void _bit_unpack_32_2bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_3bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<3>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 3);
     out[INDEX(0, lane)] = tmp + reference;
@@ -263,11 +238,11 @@ __device__ void _bit_unpack_32_3bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_4bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<4>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 4);
     out[INDEX(0, lane)] = tmp + reference;
@@ -341,11 +316,11 @@ __device__ void _bit_unpack_32_4bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_5bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<5>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 5);
     out[INDEX(0, lane)] = tmp + reference;
@@ -421,11 +396,11 @@ __device__ void _bit_unpack_32_5bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_6bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<6>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 6);
     out[INDEX(0, lane)] = tmp + reference;
@@ -503,11 +478,11 @@ __device__ void _bit_unpack_32_6bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_7bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<7>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 7);
     out[INDEX(0, lane)] = tmp + reference;
@@ -587,11 +562,11 @@ __device__ void _bit_unpack_32_7bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_8bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<8>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 8);
     out[INDEX(0, lane)] = tmp + reference;
@@ -673,11 +648,11 @@ __device__ void _bit_unpack_32_8bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_9bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<9>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 9);
     out[INDEX(0, lane)] = tmp + reference;
@@ -761,11 +736,11 @@ __device__ void _bit_unpack_32_9bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_10bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<10>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 10);
     out[INDEX(0, lane)] = tmp + reference;
@@ -851,11 +826,11 @@ __device__ void _bit_unpack_32_10bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_11bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<11>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 11);
     out[INDEX(0, lane)] = tmp + reference;
@@ -943,11 +918,11 @@ __device__ void _bit_unpack_32_11bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_12bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<12>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 12);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1037,11 +1012,11 @@ __device__ void _bit_unpack_32_12bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_13bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<13>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 13);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1133,11 +1108,11 @@ __device__ void _bit_unpack_32_13bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_14bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<14>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 14);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1231,11 +1206,11 @@ __device__ void _bit_unpack_32_14bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_15bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<15>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 15);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1331,11 +1306,11 @@ __device__ void _bit_unpack_32_15bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_16bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<16>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 16);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1433,11 +1408,11 @@ __device__ void _bit_unpack_32_16bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_17bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<17>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 17);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1537,11 +1512,11 @@ __device__ void _bit_unpack_32_17bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_18bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<18>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 18);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1643,11 +1618,11 @@ __device__ void _bit_unpack_32_18bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_19bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<19>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 19);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1751,11 +1726,11 @@ __device__ void _bit_unpack_32_19bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_20bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<20>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 20);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1861,11 +1836,11 @@ __device__ void _bit_unpack_32_20bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_21bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<21>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 21);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1973,11 +1948,11 @@ __device__ void _bit_unpack_32_21bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_22bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<22>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 22);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2087,11 +2062,11 @@ __device__ void _bit_unpack_32_22bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_23bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<23>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 23);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2203,11 +2178,11 @@ __device__ void _bit_unpack_32_23bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_24bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<24>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 24);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2321,11 +2296,11 @@ __device__ void _bit_unpack_32_24bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_25bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<25>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 25);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2441,11 +2416,11 @@ __device__ void _bit_unpack_32_25bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_26bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<26>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 26);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2563,11 +2538,11 @@ __device__ void _bit_unpack_32_26bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_27bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<27>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 27);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2687,11 +2662,11 @@ __device__ void _bit_unpack_32_27bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_28bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<28>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 28);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2813,11 +2788,11 @@ __device__ void _bit_unpack_32_28bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_29bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<29>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 29);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2941,11 +2916,11 @@ __device__ void _bit_unpack_32_29bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_30bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<30>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 30);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3071,11 +3046,11 @@ __device__ void _bit_unpack_32_30bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_31bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<31>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
     uint32_t src;
     uint32_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint32_t, 31);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3203,41 +3178,13 @@ __device__ void _bit_unpack_32_31bw_lane(const uint32_t *__restrict in, uint32_t
     out[INDEX(31, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_32_32bw_lane(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_32_lane<32>(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 32;
-    
-    out[INDEX(0, lane)] = in[LANE_COUNT * 0 + lane] + reference;
-    out[INDEX(1, lane)] = in[LANE_COUNT * 1 + lane] + reference;
-    out[INDEX(2, lane)] = in[LANE_COUNT * 2 + lane] + reference;
-    out[INDEX(3, lane)] = in[LANE_COUNT * 3 + lane] + reference;
-    out[INDEX(4, lane)] = in[LANE_COUNT * 4 + lane] + reference;
-    out[INDEX(5, lane)] = in[LANE_COUNT * 5 + lane] + reference;
-    out[INDEX(6, lane)] = in[LANE_COUNT * 6 + lane] + reference;
-    out[INDEX(7, lane)] = in[LANE_COUNT * 7 + lane] + reference;
-    out[INDEX(8, lane)] = in[LANE_COUNT * 8 + lane] + reference;
-    out[INDEX(9, lane)] = in[LANE_COUNT * 9 + lane] + reference;
-    out[INDEX(10, lane)] = in[LANE_COUNT * 10 + lane] + reference;
-    out[INDEX(11, lane)] = in[LANE_COUNT * 11 + lane] + reference;
-    out[INDEX(12, lane)] = in[LANE_COUNT * 12 + lane] + reference;
-    out[INDEX(13, lane)] = in[LANE_COUNT * 13 + lane] + reference;
-    out[INDEX(14, lane)] = in[LANE_COUNT * 14 + lane] + reference;
-    out[INDEX(15, lane)] = in[LANE_COUNT * 15 + lane] + reference;
-    out[INDEX(16, lane)] = in[LANE_COUNT * 16 + lane] + reference;
-    out[INDEX(17, lane)] = in[LANE_COUNT * 17 + lane] + reference;
-    out[INDEX(18, lane)] = in[LANE_COUNT * 18 + lane] + reference;
-    out[INDEX(19, lane)] = in[LANE_COUNT * 19 + lane] + reference;
-    out[INDEX(20, lane)] = in[LANE_COUNT * 20 + lane] + reference;
-    out[INDEX(21, lane)] = in[LANE_COUNT * 21 + lane] + reference;
-    out[INDEX(22, lane)] = in[LANE_COUNT * 22 + lane] + reference;
-    out[INDEX(23, lane)] = in[LANE_COUNT * 23 + lane] + reference;
-    out[INDEX(24, lane)] = in[LANE_COUNT * 24 + lane] + reference;
-    out[INDEX(25, lane)] = in[LANE_COUNT * 25 + lane] + reference;
-    out[INDEX(26, lane)] = in[LANE_COUNT * 26 + lane] + reference;
-    out[INDEX(27, lane)] = in[LANE_COUNT * 27 + lane] + reference;
-    out[INDEX(28, lane)] = in[LANE_COUNT * 28 + lane] + reference;
-    out[INDEX(29, lane)] = in[LANE_COUNT * 29 + lane] + reference;
-    out[INDEX(30, lane)] = in[LANE_COUNT * 30 + lane] + reference;
-    out[INDEX(31, lane)] = in[LANE_COUNT * 31 + lane] + reference;
+    #pragma unroll
+    for (int row = 0; row < 32; row++) {
+        out[INDEX(row, lane)] = in[LANE_COUNT * row + lane] + reference;
+    }
 }
 
 /// Runtime dispatch to the optimized lane decoder for the given bit width.
@@ -3249,567 +3196,291 @@ __device__ inline void bit_unpack_32_lane(
     uint32_t bit_width
 ) {
     switch (bit_width) {
-        case 0: _bit_unpack_32_0bw_lane(in, out, reference, lane); break;
-        case 1: _bit_unpack_32_1bw_lane(in, out, reference, lane); break;
-        case 2: _bit_unpack_32_2bw_lane(in, out, reference, lane); break;
-        case 3: _bit_unpack_32_3bw_lane(in, out, reference, lane); break;
-        case 4: _bit_unpack_32_4bw_lane(in, out, reference, lane); break;
-        case 5: _bit_unpack_32_5bw_lane(in, out, reference, lane); break;
-        case 6: _bit_unpack_32_6bw_lane(in, out, reference, lane); break;
-        case 7: _bit_unpack_32_7bw_lane(in, out, reference, lane); break;
-        case 8: _bit_unpack_32_8bw_lane(in, out, reference, lane); break;
-        case 9: _bit_unpack_32_9bw_lane(in, out, reference, lane); break;
-        case 10: _bit_unpack_32_10bw_lane(in, out, reference, lane); break;
-        case 11: _bit_unpack_32_11bw_lane(in, out, reference, lane); break;
-        case 12: _bit_unpack_32_12bw_lane(in, out, reference, lane); break;
-        case 13: _bit_unpack_32_13bw_lane(in, out, reference, lane); break;
-        case 14: _bit_unpack_32_14bw_lane(in, out, reference, lane); break;
-        case 15: _bit_unpack_32_15bw_lane(in, out, reference, lane); break;
-        case 16: _bit_unpack_32_16bw_lane(in, out, reference, lane); break;
-        case 17: _bit_unpack_32_17bw_lane(in, out, reference, lane); break;
-        case 18: _bit_unpack_32_18bw_lane(in, out, reference, lane); break;
-        case 19: _bit_unpack_32_19bw_lane(in, out, reference, lane); break;
-        case 20: _bit_unpack_32_20bw_lane(in, out, reference, lane); break;
-        case 21: _bit_unpack_32_21bw_lane(in, out, reference, lane); break;
-        case 22: _bit_unpack_32_22bw_lane(in, out, reference, lane); break;
-        case 23: _bit_unpack_32_23bw_lane(in, out, reference, lane); break;
-        case 24: _bit_unpack_32_24bw_lane(in, out, reference, lane); break;
-        case 25: _bit_unpack_32_25bw_lane(in, out, reference, lane); break;
-        case 26: _bit_unpack_32_26bw_lane(in, out, reference, lane); break;
-        case 27: _bit_unpack_32_27bw_lane(in, out, reference, lane); break;
-        case 28: _bit_unpack_32_28bw_lane(in, out, reference, lane); break;
-        case 29: _bit_unpack_32_29bw_lane(in, out, reference, lane); break;
-        case 30: _bit_unpack_32_30bw_lane(in, out, reference, lane); break;
-        case 31: _bit_unpack_32_31bw_lane(in, out, reference, lane); break;
-        case 32: _bit_unpack_32_32bw_lane(in, out, reference, lane); break;
+        case 0: _bit_unpack_32_lane<0>(in, out, reference, lane); break;
+        case 1: _bit_unpack_32_lane<1>(in, out, reference, lane); break;
+        case 2: _bit_unpack_32_lane<2>(in, out, reference, lane); break;
+        case 3: _bit_unpack_32_lane<3>(in, out, reference, lane); break;
+        case 4: _bit_unpack_32_lane<4>(in, out, reference, lane); break;
+        case 5: _bit_unpack_32_lane<5>(in, out, reference, lane); break;
+        case 6: _bit_unpack_32_lane<6>(in, out, reference, lane); break;
+        case 7: _bit_unpack_32_lane<7>(in, out, reference, lane); break;
+        case 8: _bit_unpack_32_lane<8>(in, out, reference, lane); break;
+        case 9: _bit_unpack_32_lane<9>(in, out, reference, lane); break;
+        case 10: _bit_unpack_32_lane<10>(in, out, reference, lane); break;
+        case 11: _bit_unpack_32_lane<11>(in, out, reference, lane); break;
+        case 12: _bit_unpack_32_lane<12>(in, out, reference, lane); break;
+        case 13: _bit_unpack_32_lane<13>(in, out, reference, lane); break;
+        case 14: _bit_unpack_32_lane<14>(in, out, reference, lane); break;
+        case 15: _bit_unpack_32_lane<15>(in, out, reference, lane); break;
+        case 16: _bit_unpack_32_lane<16>(in, out, reference, lane); break;
+        case 17: _bit_unpack_32_lane<17>(in, out, reference, lane); break;
+        case 18: _bit_unpack_32_lane<18>(in, out, reference, lane); break;
+        case 19: _bit_unpack_32_lane<19>(in, out, reference, lane); break;
+        case 20: _bit_unpack_32_lane<20>(in, out, reference, lane); break;
+        case 21: _bit_unpack_32_lane<21>(in, out, reference, lane); break;
+        case 22: _bit_unpack_32_lane<22>(in, out, reference, lane); break;
+        case 23: _bit_unpack_32_lane<23>(in, out, reference, lane); break;
+        case 24: _bit_unpack_32_lane<24>(in, out, reference, lane); break;
+        case 25: _bit_unpack_32_lane<25>(in, out, reference, lane); break;
+        case 26: _bit_unpack_32_lane<26>(in, out, reference, lane); break;
+        case 27: _bit_unpack_32_lane<27>(in, out, reference, lane); break;
+        case 28: _bit_unpack_32_lane<28>(in, out, reference, lane); break;
+        case 29: _bit_unpack_32_lane<29>(in, out, reference, lane); break;
+        case 30: _bit_unpack_32_lane<30>(in, out, reference, lane); break;
+        case 31: _bit_unpack_32_lane<31>(in, out, reference, lane); break;
+        case 32: _bit_unpack_32_lane<32>(in, out, reference, lane); break;
     }
 }
 
-__device__ void _bit_unpack_32_0bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
+template <int BW>
+__device__ void _bit_unpack_32_device(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx, GPUPatches& patches) {
     __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_0bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
+    #pragma unroll
+    for (int i = 0; i < 1; i++) {
+        _bit_unpack_32_lane<BW>(in, shared_out, reference, thread_idx * 1 + i);
+    }
+    __syncwarp();
+    PatchesCursor<uint32_t> cursor(patches, blockIdx.x, thread_idx, 32);
+    auto patch = cursor.next();
     for (int i = 0; i < 32; i++) {
         auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
+        if (idx == patch.index) {
+            out[idx] = patch.value;
+            patch = cursor.next();
+        } else {
+            out[idx] = shared_out[idx];
+        }
     }
 }
 
-extern "C" __global__ void bit_unpack_32_0bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_0bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 0 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_0bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_1bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_1bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<0>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_1bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_1bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 1 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_1bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<1>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_2bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_2bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_2bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_2bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 2 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_2bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_3bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_3bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<2>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_3bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_3bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 3 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_3bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<3>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_4bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_4bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_4bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_4bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 4 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_4bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<4>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_5bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_5bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_5bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_5bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 5 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_5bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<5>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_6bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_6bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_6bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_6bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 6 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_6bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_7bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_7bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<6>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_7bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_7bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 7 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_7bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_8bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_8bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<7>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_8bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_8bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 8 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_8bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<8>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_9bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_9bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_9bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_9bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 9 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_9bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<9>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_10bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_10bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_10bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_10bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 10 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_10bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_11bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_11bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<10>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_11bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_11bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 11 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_11bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_12bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_12bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<11>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_12bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_12bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 12 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_12bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<12>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_13bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_13bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_13bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_13bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 13 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_13bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<13>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_14bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_14bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_14bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_14bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 14 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_14bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_15bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_15bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<14>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_15bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_15bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 15 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_15bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<15>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_16bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_16bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_16bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_16bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 16 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_16bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<16>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_17bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_17bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_17bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_17bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 17 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_17bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<17>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_18bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_18bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_18bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_18bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 18 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_18bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_19bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_19bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<18>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_19bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_19bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 19 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_19bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_20bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_20bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<19>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_20bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_20bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 20 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_20bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<20>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_21bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_21bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_21bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_21bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 21 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_21bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<21>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_22bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_22bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_22bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_22bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 22 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_22bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_23bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_23bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<22>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_23bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_23bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 23 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_23bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<23>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_24bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_24bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_24bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_24bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 24 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_24bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_25bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_25bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<24>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_25bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_25bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 25 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_25bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_26bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_26bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<25>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_26bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_26bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 26 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_26bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<26>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_27bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_27bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_27bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_27bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 27 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_27bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_28bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_28bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<27>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_28bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_28bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 28 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_28bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<28>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_29bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_29bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_29bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_29bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 29 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_29bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_30bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_30bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<29>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_30bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_30bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 30 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_30bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<30>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_32_31bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_31bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_32_31bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_31bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 31 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_31bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_32_32bw_32t(const uint32_t *__restrict in, uint32_t *__restrict out, uint32_t reference, int thread_idx) {
-    __shared__ uint32_t shared_out[1024];
-    _bit_unpack_32_32bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_32_device<31>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_32_32bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference) {
+extern "C" __global__ void bit_unpack_32_32bw_32t(const uint32_t *__restrict full_in, uint32_t *__restrict full_out, uint32_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 32 / sizeof(uint32_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_32_32bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_32_device<32>(in, out, reference, thread_idx, patches);
 }
 
diff --git a/vortex-cuda/kernels/src/bit_unpack_64.cu b/vortex-cuda/kernels/src/bit_unpack_64.cu
index cb4d8ecc95c..581ee159376 100644
--- a/vortex-cuda/kernels/src/bit_unpack_64.cu
+++ b/vortex-cuda/kernels/src/bit_unpack_64.cu
@@ -3,81 +3,24 @@
 #include <cuda_runtime.h>
 #include <stdint.h>
 #include "fastlanes_common.cuh"
+#include "patches.cuh"
 
-__device__ void _bit_unpack_64_0bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
-    unsigned int LANE_COUNT = 16;
-    
-    out[INDEX(0, lane)] = reference;
-    out[INDEX(1, lane)] = reference;
-    out[INDEX(2, lane)] = reference;
-    out[INDEX(3, lane)] = reference;
-    out[INDEX(4, lane)] = reference;
-    out[INDEX(5, lane)] = reference;
-    out[INDEX(6, lane)] = reference;
-    out[INDEX(7, lane)] = reference;
-    out[INDEX(8, lane)] = reference;
-    out[INDEX(9, lane)] = reference;
-    out[INDEX(10, lane)] = reference;
-    out[INDEX(11, lane)] = reference;
-    out[INDEX(12, lane)] = reference;
-    out[INDEX(13, lane)] = reference;
-    out[INDEX(14, lane)] = reference;
-    out[INDEX(15, lane)] = reference;
-    out[INDEX(16, lane)] = reference;
-    out[INDEX(17, lane)] = reference;
-    out[INDEX(18, lane)] = reference;
-    out[INDEX(19, lane)] = reference;
-    out[INDEX(20, lane)] = reference;
-    out[INDEX(21, lane)] = reference;
-    out[INDEX(22, lane)] = reference;
-    out[INDEX(23, lane)] = reference;
-    out[INDEX(24, lane)] = reference;
-    out[INDEX(25, lane)] = reference;
-    out[INDEX(26, lane)] = reference;
-    out[INDEX(27, lane)] = reference;
-    out[INDEX(28, lane)] = reference;
-    out[INDEX(29, lane)] = reference;
-    out[INDEX(30, lane)] = reference;
-    out[INDEX(31, lane)] = reference;
-    out[INDEX(32, lane)] = reference;
-    out[INDEX(33, lane)] = reference;
-    out[INDEX(34, lane)] = reference;
-    out[INDEX(35, lane)] = reference;
-    out[INDEX(36, lane)] = reference;
-    out[INDEX(37, lane)] = reference;
-    out[INDEX(38, lane)] = reference;
-    out[INDEX(39, lane)] = reference;
-    out[INDEX(40, lane)] = reference;
-    out[INDEX(41, lane)] = reference;
-    out[INDEX(42, lane)] = reference;
-    out[INDEX(43, lane)] = reference;
-    out[INDEX(44, lane)] = reference;
-    out[INDEX(45, lane)] = reference;
-    out[INDEX(46, lane)] = reference;
-    out[INDEX(47, lane)] = reference;
-    out[INDEX(48, lane)] = reference;
-    out[INDEX(49, lane)] = reference;
-    out[INDEX(50, lane)] = reference;
-    out[INDEX(51, lane)] = reference;
-    out[INDEX(52, lane)] = reference;
-    out[INDEX(53, lane)] = reference;
-    out[INDEX(54, lane)] = reference;
-    out[INDEX(55, lane)] = reference;
-    out[INDEX(56, lane)] = reference;
-    out[INDEX(57, lane)] = reference;
-    out[INDEX(58, lane)] = reference;
-    out[INDEX(59, lane)] = reference;
-    out[INDEX(60, lane)] = reference;
-    out[INDEX(61, lane)] = reference;
-    out[INDEX(62, lane)] = reference;
-    out[INDEX(63, lane)] = reference;
-}
-
-__device__ void _bit_unpack_64_1bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <int BW>
+__device__ void _bit_unpack_64_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane);
+
+template <>
+__device__ void _bit_unpack_64_lane<0>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+    #pragma unroll
+    for (int row = 0; row < 64; row++) {
+        out[INDEX(row, lane)] = reference;
+    }
+}
+
+template <>
+__device__ void _bit_unpack_64_lane<1>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 1);
     out[INDEX(0, lane)] = tmp + reference;
@@ -209,11 +152,11 @@ __device__ void _bit_unpack_64_1bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_2bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<2>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 2);
     out[INDEX(0, lane)] = tmp + reference;
@@ -347,11 +290,11 @@ __device__ void _bit_unpack_64_2bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_3bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<3>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 3);
     out[INDEX(0, lane)] = tmp + reference;
@@ -487,11 +430,11 @@ __device__ void _bit_unpack_64_3bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_4bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<4>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 4);
     out[INDEX(0, lane)] = tmp + reference;
@@ -629,11 +572,11 @@ __device__ void _bit_unpack_64_4bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_5bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<5>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 5);
     out[INDEX(0, lane)] = tmp + reference;
@@ -773,11 +716,11 @@ __device__ void _bit_unpack_64_5bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_6bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<6>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 6);
     out[INDEX(0, lane)] = tmp + reference;
@@ -919,11 +862,11 @@ __device__ void _bit_unpack_64_6bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_7bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<7>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 7);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1067,11 +1010,11 @@ __device__ void _bit_unpack_64_7bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_8bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<8>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 8);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1217,11 +1160,11 @@ __device__ void _bit_unpack_64_8bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_9bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<9>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 9);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1369,11 +1312,11 @@ __device__ void _bit_unpack_64_9bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_10bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<10>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 10);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1523,11 +1466,11 @@ __device__ void _bit_unpack_64_10bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_11bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<11>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 11);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1679,11 +1622,11 @@ __device__ void _bit_unpack_64_11bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_12bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<12>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 12);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1837,11 +1780,11 @@ __device__ void _bit_unpack_64_12bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_13bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<13>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 13);
     out[INDEX(0, lane)] = tmp + reference;
@@ -1997,11 +1940,11 @@ __device__ void _bit_unpack_64_13bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_14bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<14>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 14);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2159,11 +2102,11 @@ __device__ void _bit_unpack_64_14bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_15bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<15>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 15);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2323,11 +2266,11 @@ __device__ void _bit_unpack_64_15bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_16bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<16>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 16);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2489,11 +2432,11 @@ __device__ void _bit_unpack_64_16bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_17bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<17>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 17);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2657,11 +2600,11 @@ __device__ void _bit_unpack_64_17bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_18bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<18>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 18);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2827,11 +2770,11 @@ __device__ void _bit_unpack_64_18bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_19bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<19>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 19);
     out[INDEX(0, lane)] = tmp + reference;
@@ -2999,11 +2942,11 @@ __device__ void _bit_unpack_64_19bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_20bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<20>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 20);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3173,11 +3116,11 @@ __device__ void _bit_unpack_64_20bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_21bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<21>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 21);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3349,11 +3292,11 @@ __device__ void _bit_unpack_64_21bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_22bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<22>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 22);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3527,11 +3470,11 @@ __device__ void _bit_unpack_64_22bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_23bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<23>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 23);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3707,11 +3650,11 @@ __device__ void _bit_unpack_64_23bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_24bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<24>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 24);
     out[INDEX(0, lane)] = tmp + reference;
@@ -3889,11 +3832,11 @@ __device__ void _bit_unpack_64_24bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_25bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<25>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 25);
     out[INDEX(0, lane)] = tmp + reference;
@@ -4073,11 +4016,11 @@ __device__ void _bit_unpack_64_25bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_26bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<26>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 26);
     out[INDEX(0, lane)] = tmp + reference;
@@ -4259,11 +4202,11 @@ __device__ void _bit_unpack_64_26bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_27bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<27>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 27);
     out[INDEX(0, lane)] = tmp + reference;
@@ -4447,11 +4390,11 @@ __device__ void _bit_unpack_64_27bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_28bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<28>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 28);
     out[INDEX(0, lane)] = tmp + reference;
@@ -4637,11 +4580,11 @@ __device__ void _bit_unpack_64_28bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_29bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<29>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 29);
     out[INDEX(0, lane)] = tmp + reference;
@@ -4829,11 +4772,11 @@ __device__ void _bit_unpack_64_29bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_30bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<30>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 30);
     out[INDEX(0, lane)] = tmp + reference;
@@ -5023,11 +4966,11 @@ __device__ void _bit_unpack_64_30bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_31bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<31>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 31);
     out[INDEX(0, lane)] = tmp + reference;
@@ -5219,11 +5162,11 @@ __device__ void _bit_unpack_64_31bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_32bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<32>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 32);
     out[INDEX(0, lane)] = tmp + reference;
@@ -5417,11 +5360,11 @@ __device__ void _bit_unpack_64_32bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_33bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<33>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 33);
     out[INDEX(0, lane)] = tmp + reference;
@@ -5617,11 +5560,11 @@ __device__ void _bit_unpack_64_33bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_34bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<34>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 34);
     out[INDEX(0, lane)] = tmp + reference;
@@ -5819,11 +5762,11 @@ __device__ void _bit_unpack_64_34bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_35bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<35>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 35);
     out[INDEX(0, lane)] = tmp + reference;
@@ -6023,11 +5966,11 @@ __device__ void _bit_unpack_64_35bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_36bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<36>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 36);
     out[INDEX(0, lane)] = tmp + reference;
@@ -6229,11 +6172,11 @@ __device__ void _bit_unpack_64_36bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_37bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<37>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 37);
     out[INDEX(0, lane)] = tmp + reference;
@@ -6437,11 +6380,11 @@ __device__ void _bit_unpack_64_37bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_38bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<38>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 38);
     out[INDEX(0, lane)] = tmp + reference;
@@ -6647,11 +6590,11 @@ __device__ void _bit_unpack_64_38bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_39bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<39>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 39);
     out[INDEX(0, lane)] = tmp + reference;
@@ -6859,11 +6802,11 @@ __device__ void _bit_unpack_64_39bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_40bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<40>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 40);
     out[INDEX(0, lane)] = tmp + reference;
@@ -7073,11 +7016,11 @@ __device__ void _bit_unpack_64_40bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_41bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<41>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 41);
     out[INDEX(0, lane)] = tmp + reference;
@@ -7289,11 +7232,11 @@ __device__ void _bit_unpack_64_41bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_42bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<42>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 42);
     out[INDEX(0, lane)] = tmp + reference;
@@ -7507,11 +7450,11 @@ __device__ void _bit_unpack_64_42bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_43bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<43>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 43);
     out[INDEX(0, lane)] = tmp + reference;
@@ -7727,11 +7670,11 @@ __device__ void _bit_unpack_64_43bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_44bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<44>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 44);
     out[INDEX(0, lane)] = tmp + reference;
@@ -7949,11 +7892,11 @@ __device__ void _bit_unpack_64_44bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_45bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<45>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 45);
     out[INDEX(0, lane)] = tmp + reference;
@@ -8173,11 +8116,11 @@ __device__ void _bit_unpack_64_45bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_46bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<46>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 46);
     out[INDEX(0, lane)] = tmp + reference;
@@ -8399,11 +8342,11 @@ __device__ void _bit_unpack_64_46bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_47bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<47>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 47);
     out[INDEX(0, lane)] = tmp + reference;
@@ -8627,11 +8570,11 @@ __device__ void _bit_unpack_64_47bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_48bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<48>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 48);
     out[INDEX(0, lane)] = tmp + reference;
@@ -8857,11 +8800,11 @@ __device__ void _bit_unpack_64_48bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_49bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<49>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 49);
     out[INDEX(0, lane)] = tmp + reference;
@@ -9089,11 +9032,11 @@ __device__ void _bit_unpack_64_49bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_50bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<50>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 50);
     out[INDEX(0, lane)] = tmp + reference;
@@ -9323,11 +9266,11 @@ __device__ void _bit_unpack_64_50bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_51bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<51>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 51);
     out[INDEX(0, lane)] = tmp + reference;
@@ -9559,11 +9502,11 @@ __device__ void _bit_unpack_64_51bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_52bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<52>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 52);
     out[INDEX(0, lane)] = tmp + reference;
@@ -9797,11 +9740,11 @@ __device__ void _bit_unpack_64_52bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_53bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<53>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 53);
     out[INDEX(0, lane)] = tmp + reference;
@@ -10037,11 +9980,11 @@ __device__ void _bit_unpack_64_53bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_54bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<54>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 54);
     out[INDEX(0, lane)] = tmp + reference;
@@ -10279,11 +10222,11 @@ __device__ void _bit_unpack_64_54bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_55bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<55>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 55);
     out[INDEX(0, lane)] = tmp + reference;
@@ -10523,11 +10466,11 @@ __device__ void _bit_unpack_64_55bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_56bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<56>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 56);
     out[INDEX(0, lane)] = tmp + reference;
@@ -10769,11 +10712,11 @@ __device__ void _bit_unpack_64_56bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_57bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<57>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 57);
     out[INDEX(0, lane)] = tmp + reference;
@@ -11017,11 +10960,11 @@ __device__ void _bit_unpack_64_57bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_58bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<58>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 58);
     out[INDEX(0, lane)] = tmp + reference;
@@ -11267,11 +11210,11 @@ __device__ void _bit_unpack_64_58bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_59bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<59>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 59);
     out[INDEX(0, lane)] = tmp + reference;
@@ -11519,11 +11462,11 @@ __device__ void _bit_unpack_64_59bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_60bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<60>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 60);
     out[INDEX(0, lane)] = tmp + reference;
@@ -11773,11 +11716,11 @@ __device__ void _bit_unpack_64_60bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_61bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<61>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 61);
     out[INDEX(0, lane)] = tmp + reference;
@@ -12029,11 +11972,11 @@ __device__ void _bit_unpack_64_61bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_62bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<62>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 62);
     out[INDEX(0, lane)] = tmp + reference;
@@ -12287,11 +12230,11 @@ __device__ void _bit_unpack_64_62bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_63bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<63>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
     uint64_t src;
     uint64_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint64_t, 63);
     out[INDEX(0, lane)] = tmp + reference;
@@ -12547,73 +12490,13 @@ __device__ void _bit_unpack_64_63bw_lane(const uint64_t *__restrict in, uint64_t
     out[INDEX(63, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_64_64bw_lane(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_64_lane<64>(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 16;
-    
-    out[INDEX(0, lane)] = in[LANE_COUNT * 0 + lane] + reference;
-    out[INDEX(1, lane)] = in[LANE_COUNT * 1 + lane] + reference;
-    out[INDEX(2, lane)] = in[LANE_COUNT * 2 + lane] + reference;
-    out[INDEX(3, lane)] = in[LANE_COUNT * 3 + lane] + reference;
-    out[INDEX(4, lane)] = in[LANE_COUNT * 4 + lane] + reference;
-    out[INDEX(5, lane)] = in[LANE_COUNT * 5 + lane] + reference;
-    out[INDEX(6, lane)] = in[LANE_COUNT * 6 + lane] + reference;
-    out[INDEX(7, lane)] = in[LANE_COUNT * 7 + lane] + reference;
-    out[INDEX(8, lane)] = in[LANE_COUNT * 8 + lane] + reference;
-    out[INDEX(9, lane)] = in[LANE_COUNT * 9 + lane] + reference;
-    out[INDEX(10, lane)] = in[LANE_COUNT * 10 + lane] + reference;
-    out[INDEX(11, lane)] = in[LANE_COUNT * 11 + lane] + reference;
-    out[INDEX(12, lane)] = in[LANE_COUNT * 12 + lane] + reference;
-    out[INDEX(13, lane)] = in[LANE_COUNT * 13 + lane] + reference;
-    out[INDEX(14, lane)] = in[LANE_COUNT * 14 + lane] + reference;
-    out[INDEX(15, lane)] = in[LANE_COUNT * 15 + lane] + reference;
-    out[INDEX(16, lane)] = in[LANE_COUNT * 16 + lane] + reference;
-    out[INDEX(17, lane)] = in[LANE_COUNT * 17 + lane] + reference;
-    out[INDEX(18, lane)] = in[LANE_COUNT * 18 + lane] + reference;
-    out[INDEX(19, lane)] = in[LANE_COUNT * 19 + lane] + reference;
-    out[INDEX(20, lane)] = in[LANE_COUNT * 20 + lane] + reference;
-    out[INDEX(21, lane)] = in[LANE_COUNT * 21 + lane] + reference;
-    out[INDEX(22, lane)] = in[LANE_COUNT * 22 + lane] + reference;
-    out[INDEX(23, lane)] = in[LANE_COUNT * 23 + lane] + reference;
-    out[INDEX(24, lane)] = in[LANE_COUNT * 24 + lane] + reference;
-    out[INDEX(25, lane)] = in[LANE_COUNT * 25 + lane] + reference;
-    out[INDEX(26, lane)] = in[LANE_COUNT * 26 + lane] + reference;
-    out[INDEX(27, lane)] = in[LANE_COUNT * 27 + lane] + reference;
-    out[INDEX(28, lane)] = in[LANE_COUNT * 28 + lane] + reference;
-    out[INDEX(29, lane)] = in[LANE_COUNT * 29 + lane] + reference;
-    out[INDEX(30, lane)] = in[LANE_COUNT * 30 + lane] + reference;
-    out[INDEX(31, lane)] = in[LANE_COUNT * 31 + lane] + reference;
-    out[INDEX(32, lane)] = in[LANE_COUNT * 32 + lane] + reference;
-    out[INDEX(33, lane)] = in[LANE_COUNT * 33 + lane] + reference;
-    out[INDEX(34, lane)] = in[LANE_COUNT * 34 + lane] + reference;
-    out[INDEX(35, lane)] = in[LANE_COUNT * 35 + lane] + reference;
-    out[INDEX(36, lane)] = in[LANE_COUNT * 36 + lane] + reference;
-    out[INDEX(37, lane)] = in[LANE_COUNT * 37 + lane] + reference;
-    out[INDEX(38, lane)] = in[LANE_COUNT * 38 + lane] + reference;
-    out[INDEX(39, lane)] = in[LANE_COUNT * 39 + lane] + reference;
-    out[INDEX(40, lane)] = in[LANE_COUNT * 40 + lane] + reference;
-    out[INDEX(41, lane)] = in[LANE_COUNT * 41 + lane] + reference;
-    out[INDEX(42, lane)] = in[LANE_COUNT * 42 + lane] + reference;
-    out[INDEX(43, lane)] = in[LANE_COUNT * 43 + lane] + reference;
-    out[INDEX(44, lane)] = in[LANE_COUNT * 44 + lane] + reference;
-    out[INDEX(45, lane)] = in[LANE_COUNT * 45 + lane] + reference;
-    out[INDEX(46, lane)] = in[LANE_COUNT * 46 + lane] + reference;
-    out[INDEX(47, lane)] = in[LANE_COUNT * 47 + lane] + reference;
-    out[INDEX(48, lane)] = in[LANE_COUNT * 48 + lane] + reference;
-    out[INDEX(49, lane)] = in[LANE_COUNT * 49 + lane] + reference;
-    out[INDEX(50, lane)] = in[LANE_COUNT * 50 + lane] + reference;
-    out[INDEX(51, lane)] = in[LANE_COUNT * 51 + lane] + reference;
-    out[INDEX(52, lane)] = in[LANE_COUNT * 52 + lane] + reference;
-    out[INDEX(53, lane)] = in[LANE_COUNT * 53 + lane] + reference;
-    out[INDEX(54, lane)] = in[LANE_COUNT * 54 + lane] + reference;
-    out[INDEX(55, lane)] = in[LANE_COUNT * 55 + lane] + reference;
-    out[INDEX(56, lane)] = in[LANE_COUNT * 56 + lane] + reference;
-    out[INDEX(57, lane)] = in[LANE_COUNT * 57 + lane] + reference;
-    out[INDEX(58, lane)] = in[LANE_COUNT * 58 + lane] + reference;
-    out[INDEX(59, lane)] = in[LANE_COUNT * 59 + lane] + reference;
-    out[INDEX(60, lane)] = in[LANE_COUNT * 60 + lane] + reference;
-    out[INDEX(61, lane)] = in[LANE_COUNT * 61 + lane] + reference;
-    out[INDEX(62, lane)] = in[LANE_COUNT * 62 + lane] + reference;
-    out[INDEX(63, lane)] = in[LANE_COUNT * 63 + lane] + reference;
+    #pragma unroll
+    for (int row = 0; row < 64; row++) {
+        out[INDEX(row, lane)] = in[LANE_COUNT * row + lane] + reference;
+    }
 }
 
 /// Runtime dispatch to the optimized lane decoder for the given bit width.
@@ -12625,1111 +12508,547 @@ __device__ inline void bit_unpack_64_lane(
     uint32_t bit_width
 ) {
     switch (bit_width) {
-        case 0: _bit_unpack_64_0bw_lane(in, out, reference, lane); break;
-        case 1: _bit_unpack_64_1bw_lane(in, out, reference, lane); break;
-        case 2: _bit_unpack_64_2bw_lane(in, out, reference, lane); break;
-        case 3: _bit_unpack_64_3bw_lane(in, out, reference, lane); break;
-        case 4: _bit_unpack_64_4bw_lane(in, out, reference, lane); break;
-        case 5: _bit_unpack_64_5bw_lane(in, out, reference, lane); break;
-        case 6: _bit_unpack_64_6bw_lane(in, out, reference, lane); break;
-        case 7: _bit_unpack_64_7bw_lane(in, out, reference, lane); break;
-        case 8: _bit_unpack_64_8bw_lane(in, out, reference, lane); break;
-        case 9: _bit_unpack_64_9bw_lane(in, out, reference, lane); break;
-        case 10: _bit_unpack_64_10bw_lane(in, out, reference, lane); break;
-        case 11: _bit_unpack_64_11bw_lane(in, out, reference, lane); break;
-        case 12: _bit_unpack_64_12bw_lane(in, out, reference, lane); break;
-        case 13: _bit_unpack_64_13bw_lane(in, out, reference, lane); break;
-        case 14: _bit_unpack_64_14bw_lane(in, out, reference, lane); break;
-        case 15: _bit_unpack_64_15bw_lane(in, out, reference, lane); break;
-        case 16: _bit_unpack_64_16bw_lane(in, out, reference, lane); break;
-        case 17: _bit_unpack_64_17bw_lane(in, out, reference, lane); break;
-        case 18: _bit_unpack_64_18bw_lane(in, out, reference, lane); break;
-        case 19: _bit_unpack_64_19bw_lane(in, out, reference, lane); break;
-        case 20: _bit_unpack_64_20bw_lane(in, out, reference, lane); break;
-        case 21: _bit_unpack_64_21bw_lane(in, out, reference, lane); break;
-        case 22: _bit_unpack_64_22bw_lane(in, out, reference, lane); break;
-        case 23: _bit_unpack_64_23bw_lane(in, out, reference, lane); break;
-        case 24: _bit_unpack_64_24bw_lane(in, out, reference, lane); break;
-        case 25: _bit_unpack_64_25bw_lane(in, out, reference, lane); break;
-        case 26: _bit_unpack_64_26bw_lane(in, out, reference, lane); break;
-        case 27: _bit_unpack_64_27bw_lane(in, out, reference, lane); break;
-        case 28: _bit_unpack_64_28bw_lane(in, out, reference, lane); break;
-        case 29: _bit_unpack_64_29bw_lane(in, out, reference, lane); break;
-        case 30: _bit_unpack_64_30bw_lane(in, out, reference, lane); break;
-        case 31: _bit_unpack_64_31bw_lane(in, out, reference, lane); break;
-        case 32: _bit_unpack_64_32bw_lane(in, out, reference, lane); break;
-        case 33: _bit_unpack_64_33bw_lane(in, out, reference, lane); break;
-        case 34: _bit_unpack_64_34bw_lane(in, out, reference, lane); break;
-        case 35: _bit_unpack_64_35bw_lane(in, out, reference, lane); break;
-        case 36: _bit_unpack_64_36bw_lane(in, out, reference, lane); break;
-        case 37: _bit_unpack_64_37bw_lane(in, out, reference, lane); break;
-        case 38: _bit_unpack_64_38bw_lane(in, out, reference, lane); break;
-        case 39: _bit_unpack_64_39bw_lane(in, out, reference, lane); break;
-        case 40: _bit_unpack_64_40bw_lane(in, out, reference, lane); break;
-        case 41: _bit_unpack_64_41bw_lane(in, out, reference, lane); break;
-        case 42: _bit_unpack_64_42bw_lane(in, out, reference, lane); break;
-        case 43: _bit_unpack_64_43bw_lane(in, out, reference, lane); break;
-        case 44: _bit_unpack_64_44bw_lane(in, out, reference, lane); break;
-        case 45: _bit_unpack_64_45bw_lane(in, out, reference, lane); break;
-        case 46: _bit_unpack_64_46bw_lane(in, out, reference, lane); break;
-        case 47: _bit_unpack_64_47bw_lane(in, out, reference, lane); break;
-        case 48: _bit_unpack_64_48bw_lane(in, out, reference, lane); break;
-        case 49: _bit_unpack_64_49bw_lane(in, out, reference, lane); break;
-        case 50: _bit_unpack_64_50bw_lane(in, out, reference, lane); break;
-        case 51: _bit_unpack_64_51bw_lane(in, out, reference, lane); break;
-        case 52: _bit_unpack_64_52bw_lane(in, out, reference, lane); break;
-        case 53: _bit_unpack_64_53bw_lane(in, out, reference, lane); break;
-        case 54: _bit_unpack_64_54bw_lane(in, out, reference, lane); break;
-        case 55: _bit_unpack_64_55bw_lane(in, out, reference, lane); break;
-        case 56: _bit_unpack_64_56bw_lane(in, out, reference, lane); break;
-        case 57: _bit_unpack_64_57bw_lane(in, out, reference, lane); break;
-        case 58: _bit_unpack_64_58bw_lane(in, out, reference, lane); break;
-        case 59: _bit_unpack_64_59bw_lane(in, out, reference, lane); break;
-        case 60: _bit_unpack_64_60bw_lane(in, out, reference, lane); break;
-        case 61: _bit_unpack_64_61bw_lane(in, out, reference, lane); break;
-        case 62: _bit_unpack_64_62bw_lane(in, out, reference, lane); break;
-        case 63: _bit_unpack_64_63bw_lane(in, out, reference, lane); break;
-        case 64: _bit_unpack_64_64bw_lane(in, out, reference, lane); break;
+        case 0: _bit_unpack_64_lane<0>(in, out, reference, lane); break;
+        case 1: _bit_unpack_64_lane<1>(in, out, reference, lane); break;
+        case 2: _bit_unpack_64_lane<2>(in, out, reference, lane); break;
+        case 3: _bit_unpack_64_lane<3>(in, out, reference, lane); break;
+        case 4: _bit_unpack_64_lane<4>(in, out, reference, lane); break;
+        case 5: _bit_unpack_64_lane<5>(in, out, reference, lane); break;
+        case 6: _bit_unpack_64_lane<6>(in, out, reference, lane); break;
+        case 7: _bit_unpack_64_lane<7>(in, out, reference, lane); break;
+        case 8: _bit_unpack_64_lane<8>(in, out, reference, lane); break;
+        case 9: _bit_unpack_64_lane<9>(in, out, reference, lane); break;
+        case 10: _bit_unpack_64_lane<10>(in, out, reference, lane); break;
+        case 11: _bit_unpack_64_lane<11>(in, out, reference, lane); break;
+        case 12: _bit_unpack_64_lane<12>(in, out, reference, lane); break;
+        case 13: _bit_unpack_64_lane<13>(in, out, reference, lane); break;
+        case 14: _bit_unpack_64_lane<14>(in, out, reference, lane); break;
+        case 15: _bit_unpack_64_lane<15>(in, out, reference, lane); break;
+        case 16: _bit_unpack_64_lane<16>(in, out, reference, lane); break;
+        case 17: _bit_unpack_64_lane<17>(in, out, reference, lane); break;
+        case 18: _bit_unpack_64_lane<18>(in, out, reference, lane); break;
+        case 19: _bit_unpack_64_lane<19>(in, out, reference, lane); break;
+        case 20: _bit_unpack_64_lane<20>(in, out, reference, lane); break;
+        case 21: _bit_unpack_64_lane<21>(in, out, reference, lane); break;
+        case 22: _bit_unpack_64_lane<22>(in, out, reference, lane); break;
+        case 23: _bit_unpack_64_lane<23>(in, out, reference, lane); break;
+        case 24: _bit_unpack_64_lane<24>(in, out, reference, lane); break;
+        case 25: _bit_unpack_64_lane<25>(in, out, reference, lane); break;
+        case 26: _bit_unpack_64_lane<26>(in, out, reference, lane); break;
+        case 27: _bit_unpack_64_lane<27>(in, out, reference, lane); break;
+        case 28: _bit_unpack_64_lane<28>(in, out, reference, lane); break;
+        case 29: _bit_unpack_64_lane<29>(in, out, reference, lane); break;
+        case 30: _bit_unpack_64_lane<30>(in, out, reference, lane); break;
+        case 31: _bit_unpack_64_lane<31>(in, out, reference, lane); break;
+        case 32: _bit_unpack_64_lane<32>(in, out, reference, lane); break;
+        case 33: _bit_unpack_64_lane<33>(in, out, reference, lane); break;
+        case 34: _bit_unpack_64_lane<34>(in, out, reference, lane); break;
+        case 35: _bit_unpack_64_lane<35>(in, out, reference, lane); break;
+        case 36: _bit_unpack_64_lane<36>(in, out, reference, lane); break;
+        case 37: _bit_unpack_64_lane<37>(in, out, reference, lane); break;
+        case 38: _bit_unpack_64_lane<38>(in, out, reference, lane); break;
+        case 39: _bit_unpack_64_lane<39>(in, out, reference, lane); break;
+        case 40: _bit_unpack_64_lane<40>(in, out, reference, lane); break;
+        case 41: _bit_unpack_64_lane<41>(in, out, reference, lane); break;
+        case 42: _bit_unpack_64_lane<42>(in, out, reference, lane); break;
+        case 43: _bit_unpack_64_lane<43>(in, out, reference, lane); break;
+        case 44: _bit_unpack_64_lane<44>(in, out, reference, lane); break;
+        case 45: _bit_unpack_64_lane<45>(in, out, reference, lane); break;
+        case 46: _bit_unpack_64_lane<46>(in, out, reference, lane); break;
+        case 47: _bit_unpack_64_lane<47>(in, out, reference, lane); break;
+        case 48: _bit_unpack_64_lane<48>(in, out, reference, lane); break;
+        case 49: _bit_unpack_64_lane<49>(in, out, reference, lane); break;
+        case 50: _bit_unpack_64_lane<50>(in, out, reference, lane); break;
+        case 51: _bit_unpack_64_lane<51>(in, out, reference, lane); break;
+        case 52: _bit_unpack_64_lane<52>(in, out, reference, lane); break;
+        case 53: _bit_unpack_64_lane<53>(in, out, reference, lane); break;
+        case 54: _bit_unpack_64_lane<54>(in, out, reference, lane); break;
+        case 55: _bit_unpack_64_lane<55>(in, out, reference, lane); break;
+        case 56: _bit_unpack_64_lane<56>(in, out, reference, lane); break;
+        case 57: _bit_unpack_64_lane<57>(in, out, reference, lane); break;
+        case 58: _bit_unpack_64_lane<58>(in, out, reference, lane); break;
+        case 59: _bit_unpack_64_lane<59>(in, out, reference, lane); break;
+        case 60: _bit_unpack_64_lane<60>(in, out, reference, lane); break;
+        case 61: _bit_unpack_64_lane<61>(in, out, reference, lane); break;
+        case 62: _bit_unpack_64_lane<62>(in, out, reference, lane); break;
+        case 63: _bit_unpack_64_lane<63>(in, out, reference, lane); break;
+        case 64: _bit_unpack_64_lane<64>(in, out, reference, lane); break;
     }
 }
 
-__device__ void _bit_unpack_64_0bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
+template <int BW>
+__device__ void _bit_unpack_64_device(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx, GPUPatches& patches) {
     __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_0bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
+    #pragma unroll
+    for (int i = 0; i < 1; i++) {
+        _bit_unpack_64_lane<BW>(in, shared_out, reference, thread_idx * 1 + i);
+    }
+    __syncwarp();
+    PatchesCursor<uint64_t> cursor(patches, blockIdx.x, thread_idx, 16);
+    auto patch = cursor.next();
     for (int i = 0; i < 64; i++) {
         auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
+        if (idx == patch.index) {
+            out[idx] = patch.value;
+            patch = cursor.next();
+        } else {
+            out[idx] = shared_out[idx];
+        }
     }
 }
 
-extern "C" __global__ void bit_unpack_64_0bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_0bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 0 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_0bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_1bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_1bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<0>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_1bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_1bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 1 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_1bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<1>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_2bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_2bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_2bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_2bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 2 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_2bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_3bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_3bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<2>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_3bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_3bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 3 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_3bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<3>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_4bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_4bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_4bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_4bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 4 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_4bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_5bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_5bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<4>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_5bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_5bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 5 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_5bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<5>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_6bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_6bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_6bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_6bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 6 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_6bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_7bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_7bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<6>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_7bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_7bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 7 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_7bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<7>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_8bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_8bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_8bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_8bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 8 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_8bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<8>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_9bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_9bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_9bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_9bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 9 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_9bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<9>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_10bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_10bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_10bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_10bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 10 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_10bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_11bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_11bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<10>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_11bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_11bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 11 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_11bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<11>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_12bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_12bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_12bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_12bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 12 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_12bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_13bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_13bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<12>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_13bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_13bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 13 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_13bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_14bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_14bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<13>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_14bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_14bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 14 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_14bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_15bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_15bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<14>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_15bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_15bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 15 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_15bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_16bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_16bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<15>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_16bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_16bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 16 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_16bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<16>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_17bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_17bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_17bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_17bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 17 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_17bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<17>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_18bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_18bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_18bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_18bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 18 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_18bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_19bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_19bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<18>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_19bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_19bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 19 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_19bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<19>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_20bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_20bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_20bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_20bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 20 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_20bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_21bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_21bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<20>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_21bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_21bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 21 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_21bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_22bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_22bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<21>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_22bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_22bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 22 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_22bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_23bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_23bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<22>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_23bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_23bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 23 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_23bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_24bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_24bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<23>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_24bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_24bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 24 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_24bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<24>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_25bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_25bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_25bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_25bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 25 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_25bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<25>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_26bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_26bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_26bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_26bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 26 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_26bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_27bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_27bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<26>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_27bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_27bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 27 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_27bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<27>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_28bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_28bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_28bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_28bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 28 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_28bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_29bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_29bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<28>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_29bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_29bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 29 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_29bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_30bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_30bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<29>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_30bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_30bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 30 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_30bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_31bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_31bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<30>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_31bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_31bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 31 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_31bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<31>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_32bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_32bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_32bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_32bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 32 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_32bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<32>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_33bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_33bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_33bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_33bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 33 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_33bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<33>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_34bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_34bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_34bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_34bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 34 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_34bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_35bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_35bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<34>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_35bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_35bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 35 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_35bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<35>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_36bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_36bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_36bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_36bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 36 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_36bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_37bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_37bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<36>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_37bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_37bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 37 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_37bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_38bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_38bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<37>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_38bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_38bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 38 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_38bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_39bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_39bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<38>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_39bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_39bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 39 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_39bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_40bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_40bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<39>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_40bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_40bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 40 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_40bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<40>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_41bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_41bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_41bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_41bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 41 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_41bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<41>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_42bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_42bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_42bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_42bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 42 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_42bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_43bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_43bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<42>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_43bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_43bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 43 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_43bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<43>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_44bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_44bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_44bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_44bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 44 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_44bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_45bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_45bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<44>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_45bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_45bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 45 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_45bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_46bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_46bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<45>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_46bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_46bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 46 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_46bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_47bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_47bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<46>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_47bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_47bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 47 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_47bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<47>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_48bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_48bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_48bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_48bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 48 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_48bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_49bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_49bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<48>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_49bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_49bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 49 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_49bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_50bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_50bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<49>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_50bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_50bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 50 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_50bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<50>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_51bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_51bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_51bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_51bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 51 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_51bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_52bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_52bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<51>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_52bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_52bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 52 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_52bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<52>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_53bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_53bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_53bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_53bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 53 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_53bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_54bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_54bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<53>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_54bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_54bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 54 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_54bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<54>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_55bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_55bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_55bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_55bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 55 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_55bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_56bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_56bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<55>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_56bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_56bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 56 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_56bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<56>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_57bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_57bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_57bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_57bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 57 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_57bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_58bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_58bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<57>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_58bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_58bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 58 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_58bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<58>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_59bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_59bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_59bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_59bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 59 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_59bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_60bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_60bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<59>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_60bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_60bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 60 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_60bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<60>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_61bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_61bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_61bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_61bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 61 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_61bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_62bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_62bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<61>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_62bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_62bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 62 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_62bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<62>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_64_63bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_63bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_64_63bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_63bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 63 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_63bw_16t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_64_64bw_16t(const uint64_t *__restrict in, uint64_t *__restrict out, uint64_t reference, int thread_idx) {
-    __shared__ uint64_t shared_out[1024];
-    _bit_unpack_64_64bw_lane(in, shared_out, reference, thread_idx * 1 + 0);
-    for (int i = 0; i < 64; i++) {
-        auto idx = i * 16 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_64_device<63>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_64_64bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference) {
+extern "C" __global__ void bit_unpack_64_64bw_16t(const uint64_t *__restrict full_in, uint64_t *__restrict full_out, uint64_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 64 / sizeof(uint64_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_64_64bw_16t(in, out, reference, thread_idx);
+    _bit_unpack_64_device<64>(in, out, reference, thread_idx, patches);
 }
 
diff --git a/vortex-cuda/kernels/src/bit_unpack_8.cu b/vortex-cuda/kernels/src/bit_unpack_8.cu
index 598d93898df..13ef84a2b2f 100644
--- a/vortex-cuda/kernels/src/bit_unpack_8.cu
+++ b/vortex-cuda/kernels/src/bit_unpack_8.cu
@@ -3,25 +3,24 @@
 #include <cuda_runtime.h>
 #include <stdint.h>
 #include "fastlanes_common.cuh"
+#include "patches.cuh"
 
-__device__ void _bit_unpack_8_0bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
-    unsigned int LANE_COUNT = 128;
-    
-    out[INDEX(0, lane)] = reference;
-    out[INDEX(1, lane)] = reference;
-    out[INDEX(2, lane)] = reference;
-    out[INDEX(3, lane)] = reference;
-    out[INDEX(4, lane)] = reference;
-    out[INDEX(5, lane)] = reference;
-    out[INDEX(6, lane)] = reference;
-    out[INDEX(7, lane)] = reference;
+template <int BW>
+__device__ void _bit_unpack_8_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane);
+
+template <>
+__device__ void _bit_unpack_8_lane<0>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+    #pragma unroll
+    for (int row = 0; row < 8; row++) {
+        out[INDEX(row, lane)] = reference;
+    }
 }
 
-__device__ void _bit_unpack_8_1bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<1>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 1);
     out[INDEX(0, lane)] = tmp + reference;
@@ -41,11 +40,11 @@ __device__ void _bit_unpack_8_1bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_2bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<2>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 2);
     out[INDEX(0, lane)] = tmp + reference;
@@ -67,11 +66,11 @@ __device__ void _bit_unpack_8_2bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_3bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<3>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 3);
     out[INDEX(0, lane)] = tmp + reference;
@@ -95,11 +94,11 @@ __device__ void _bit_unpack_8_3bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_4bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<4>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 4);
     out[INDEX(0, lane)] = tmp + reference;
@@ -125,11 +124,11 @@ __device__ void _bit_unpack_8_4bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_5bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<5>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 5);
     out[INDEX(0, lane)] = tmp + reference;
@@ -157,11 +156,11 @@ __device__ void _bit_unpack_8_5bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_6bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<6>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 6);
     out[INDEX(0, lane)] = tmp + reference;
@@ -191,11 +190,11 @@ __device__ void _bit_unpack_8_6bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_7bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<7>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
     uint8_t src;
     uint8_t tmp;
-    
     src = in[lane];
     tmp = (src >> 0) & MASK(uint8_t, 7);
     out[INDEX(0, lane)] = tmp + reference;
@@ -227,17 +226,13 @@ __device__ void _bit_unpack_8_7bw_lane(const uint8_t *__restrict in, uint8_t *__
     out[INDEX(7, lane)] = tmp + reference;
 }
 
-__device__ void _bit_unpack_8_8bw_lane(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
+template <>
+__device__ void _bit_unpack_8_lane<8>(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, unsigned int lane) {
     unsigned int LANE_COUNT = 128;
-    
-    out[INDEX(0, lane)] = in[LANE_COUNT * 0 + lane] + reference;
-    out[INDEX(1, lane)] = in[LANE_COUNT * 1 + lane] + reference;
-    out[INDEX(2, lane)] = in[LANE_COUNT * 2 + lane] + reference;
-    out[INDEX(3, lane)] = in[LANE_COUNT * 3 + lane] + reference;
-    out[INDEX(4, lane)] = in[LANE_COUNT * 4 + lane] + reference;
-    out[INDEX(5, lane)] = in[LANE_COUNT * 5 + lane] + reference;
-    out[INDEX(6, lane)] = in[LANE_COUNT * 6 + lane] + reference;
-    out[INDEX(7, lane)] = in[LANE_COUNT * 7 + lane] + reference;
+    #pragma unroll
+    for (int row = 0; row < 8; row++) {
+        out[INDEX(row, lane)] = in[LANE_COUNT * row + lane] + reference;
+    }
 }
 
 /// Runtime dispatch to the optimized lane decoder for the given bit width.
@@ -249,186 +244,99 @@ __device__ inline void bit_unpack_8_lane(
     uint32_t bit_width
 ) {
     switch (bit_width) {
-        case 0: _bit_unpack_8_0bw_lane(in, out, reference, lane); break;
-        case 1: _bit_unpack_8_1bw_lane(in, out, reference, lane); break;
-        case 2: _bit_unpack_8_2bw_lane(in, out, reference, lane); break;
-        case 3: _bit_unpack_8_3bw_lane(in, out, reference, lane); break;
-        case 4: _bit_unpack_8_4bw_lane(in, out, reference, lane); break;
-        case 5: _bit_unpack_8_5bw_lane(in, out, reference, lane); break;
-        case 6: _bit_unpack_8_6bw_lane(in, out, reference, lane); break;
-        case 7: _bit_unpack_8_7bw_lane(in, out, reference, lane); break;
-        case 8: _bit_unpack_8_8bw_lane(in, out, reference, lane); break;
+        case 0: _bit_unpack_8_lane<0>(in, out, reference, lane); break;
+        case 1: _bit_unpack_8_lane<1>(in, out, reference, lane); break;
+        case 2: _bit_unpack_8_lane<2>(in, out, reference, lane); break;
+        case 3: _bit_unpack_8_lane<3>(in, out, reference, lane); break;
+        case 4: _bit_unpack_8_lane<4>(in, out, reference, lane); break;
+        case 5: _bit_unpack_8_lane<5>(in, out, reference, lane); break;
+        case 6: _bit_unpack_8_lane<6>(in, out, reference, lane); break;
+        case 7: _bit_unpack_8_lane<7>(in, out, reference, lane); break;
+        case 8: _bit_unpack_8_lane<8>(in, out, reference, lane); break;
     }
 }
 
-__device__ void _bit_unpack_8_0bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
+template <int BW>
+__device__ void _bit_unpack_8_device(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx, GPUPatches& patches) {
     __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_0bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_0bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_0bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_0bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
+    #pragma unroll
+    for (int i = 0; i < 4; i++) {
+        _bit_unpack_8_lane<BW>(in, shared_out, reference, thread_idx * 4 + i);
+    }
+    __syncwarp();
+    PatchesCursor<uint8_t> cursor(patches, blockIdx.x, thread_idx, 32);
+    auto patch = cursor.next();
     for (int i = 0; i < 32; i++) {
         auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
+        if (idx == patch.index) {
+            out[idx] = patch.value;
+            patch = cursor.next();
+        } else {
+            out[idx] = shared_out[idx];
+        }
     }
 }
 
-extern "C" __global__ void bit_unpack_8_0bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_0bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 0 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_0bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_8_1bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_1bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_1bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_1bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_1bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_8_device<0>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_8_1bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_1bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 1 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_1bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_8_device<1>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_8_2bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_2bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_2bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_2bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_2bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_8_2bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_2bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 2 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_2bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_8_device<2>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_8_3bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_3bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_3bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_3bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_3bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_8_3bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_3bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 3 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_3bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_8_device<3>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_8_4bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_4bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_4bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_4bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_4bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_8_4bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_4bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 4 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_4bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_8_device<4>(in, out, reference, thread_idx, patches);
 }
 
-__device__ void _bit_unpack_8_5bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_5bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_5bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_5bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_5bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
-}
-
-extern "C" __global__ void bit_unpack_8_5bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_5bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 5 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_5bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_8_6bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_6bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_6bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_6bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_6bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_8_device<5>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_8_6bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_6bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 6 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_6bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_8_7bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_7bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_7bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_7bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_7bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_8_device<6>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_8_7bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_7bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 7 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_7bw_32t(in, out, reference, thread_idx);
-}
-
-__device__ void _bit_unpack_8_8bw_32t(const uint8_t *__restrict in, uint8_t *__restrict out, uint8_t reference, int thread_idx) {
-    __shared__ uint8_t shared_out[1024];
-    _bit_unpack_8_8bw_lane(in, shared_out, reference, thread_idx * 4 + 0);
-    _bit_unpack_8_8bw_lane(in, shared_out, reference, thread_idx * 4 + 1);
-    _bit_unpack_8_8bw_lane(in, shared_out, reference, thread_idx * 4 + 2);
-    _bit_unpack_8_8bw_lane(in, shared_out, reference, thread_idx * 4 + 3);
-    for (int i = 0; i < 32; i++) {
-        auto idx = i * 32 + thread_idx;
-        out[idx] = shared_out[idx];
-    }
+    _bit_unpack_8_device<7>(in, out, reference, thread_idx, patches);
 }
 
-extern "C" __global__ void bit_unpack_8_8bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference) {
+extern "C" __global__ void bit_unpack_8_8bw_32t(const uint8_t *__restrict full_in, uint8_t *__restrict full_out, uint8_t reference, GPUPatches patches) {
     int thread_idx = threadIdx.x;
     auto in = full_in + (blockIdx.x * (128 * 8 / sizeof(uint8_t)));
     auto out = full_out + (blockIdx.x * 1024);
-    _bit_unpack_8_8bw_32t(in, out, reference, thread_idx);
+    _bit_unpack_8_device<8>(in, out, reference, thread_idx, patches);
 }
 
diff --git a/vortex-cuda/kernels/src/dynamic_dispatch.cu b/vortex-cuda/kernels/src/dynamic_dispatch.cu
index 9168a8580ab..29bf26efefb 100644
--- a/vortex-cuda/kernels/src/dynamic_dispatch.cu
+++ b/vortex-cuda/kernels/src/dynamic_dispatch.cu
@@ -1,15 +1,47 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-/// GPU kernel that decompresses a Vortex encoding tree in a single launch via dynamic dispatch.
-///
-/// Stages communicate through shared memory: early input stages populate
-/// persistent smem regions (e.g., dictionary values, run-end endpoints) that
-/// later stages reference via smem offsets.
-///
-/// The final output stage writes directly to global memory instead of back
-/// to shared memory. Shared memory is dynamically sized at launch time to
-/// fit all intermediate buffers that must coexist simultaneously.
+// ═══════════════════════════════════════════════════════════════════════════
+// Dynamic dispatch kernel
+// ═══════════════════════════════════════════════════════════════════════════
+//
+// Vortex arrays are stored as nested encodings — e.g. ALP(FoR(BitPacked))
+// or Dict(codes=BitPacked, values=FoR(BitPacked)). This kernel walks
+// such a tree in a single launch by decomposing it into a linear sequence
+// of stages described by a packed plan buffer on the device.
+//
+// Each block produces ELEMENTS_PER_BLOCK output elements. Input stages
+// are fully decoded per block (every block independently decodes the
+// complete dict values, run-end endpoints, etc. into its own shared
+// memory).
+//
+// ## Pipeline
+//
+// Input stages run first: each decodes a dependency (dict values, run-end
+// endpoints) into shared memory that the output stage later references via
+// byte offsets for DICT gathers and RUNEND binary searches.
+//
+// The output stage then processes the full block through:
+//
+//   source_op → scalar_op (FoR/ZigZag/ALP/DICT) → streaming store
+//
+// in register batches of VALUES_PER_TILE (8 for u32) per thread.
+//
+// ## Source ops
+//
+// BITUNPACK  Cooperative FastLanes unpack into smem scratch, sync,
+//            then batch-read from smem. Tiles at 1024 elements.
+// LOAD       Read from global memory, widening to T if narrower.
+// SEQUENCE   Compute base + i * multiplier in registers.
+// RUNEND     Forward-scan through ends/values arrays that input stages
+//            decoded into shared memory. Per-thread cursor in
+//            runend_cursors[] avoids re-searching across tile iterations.
+//
+// ## Mixed-width support
+//
+// LOAD sources from pending subtrees may have a narrower type than the
+// output (e.g. u8 dict codes in a u32 plan). load_element() widens
+// to T via static_cast — no separate widen kernel or smem intermediate.
 
 #include <assert.h>
 #include <cuda.h>
@@ -22,150 +54,93 @@
 #include "dynamic_dispatch.h"
 #include "types.cuh"
 
-/// Binary search for first element strictly greater than value.
+// ═══════════════════════════════════════════════════════════════════════════
+// Primitives
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Binary search for the first element in `data[0..len)` strictly greater
+/// than `value`. Returns `len` if all elements are ≤ value.
 template <typename T>
 __device__ inline uint64_t upper_bound(const T *data, uint64_t len, uint64_t value) {
     auto it = thrust::upper_bound(thrust::seq, data, data + len, value);
     return it - data;
 }
 
-/// Executes a source operation to fill a shared memory region with decoded data.
-///
-/// This function handles the first phase of each stage's pipeline. It reads
-/// compressed or raw data from global memory and writes decoded elements into
-/// the stage's shared memory region.
-///
-/// @param input      Global memory pointer to the stage's encoded input data
-/// @param smem_output  Shared memory pointer where decoded elements are written
-/// @param chunk_start  Starting index of the chunk to process (block-relative for output stage)
-/// @param chunk_len    Number of elements to produce (may be < ELEMENTS_PER_BLOCK for tail blocks)
-/// @param source_op    Source operation descriptor (BITUNPACK, LOAD, or RUNEND)
-/// @param smem_base    Base of the entire dynamic shared memory pool, used by RUNEND
-///                     to resolve offsets to ends/values decoded by earlier stages
+/// Read one element from global memory at `ptype` width, widen to T.
+/// Signed types are sign-extended; unsigned types are zero-extended.
 template <typename T>
-__device__ inline void dynamic_source_op(const T *__restrict input,
-                                         T *__restrict smem_output,
-                                         uint64_t chunk_start,
-                                         uint32_t chunk_len,
-                                         const struct SourceOp &source_op,
-                                         T *__restrict smem_base) {
-    constexpr uint32_t T_BITS = sizeof(T) * 8;
-
-    switch (source_op.op_code) {
-    case SourceOp::BITUNPACK: {
-        constexpr uint32_t FL_CHUNK_SIZE = 1024;
-        constexpr uint32_t LANES_PER_FL_BLOCK = FL_CHUNK_SIZE / T_BITS;
-        const uint32_t bit_width = source_op.params.bitunpack.bit_width;
-        const uint32_t packed_words_per_fl_block = LANES_PER_FL_BLOCK * bit_width;
-        const uint64_t first_fl_block = chunk_start / FL_CHUNK_SIZE;
-
-        // FL blocks must divide evenly. Otherwise, the last unpack would overflow smem.
-        static_assert((ELEMENTS_PER_BLOCK % FL_CHUNK_SIZE) == 0);
-
-        const auto div_ceil = [](auto a, auto b) {
-            return (a + b - 1) / b;
-        };
-        const uint32_t num_fl_chunks = div_ceil(chunk_len, FL_CHUNK_SIZE);
-
-        for (uint32_t chunk_idx = 0; chunk_idx < num_fl_chunks; ++chunk_idx) {
-            const T *packed_chunk = input + (first_fl_block + chunk_idx) * packed_words_per_fl_block;
-            T *smem_lane = smem_output + chunk_idx * FL_CHUNK_SIZE;
-            // Distribute unpacking across threads via lane-wise decomposition.
-            for (uint32_t lane = threadIdx.x; lane < LANES_PER_FL_BLOCK; lane += blockDim.x) {
-                bit_unpack_lane<T>(packed_chunk, smem_lane, 0, lane, bit_width);
-            }
-        }
-        break;
-    }
-
-    case SourceOp::LOAD: {
-        // Copy elements verbatim from global memory into shared memory.
-        for (uint32_t i = threadIdx.x; i < chunk_len; i += blockDim.x) {
-            smem_output[i] = input[chunk_start + i];
-        }
-        break;
-    }
-
-    case SourceOp::RUNEND: {
-        // Ends and values were decoded into shared memory by earlier stages.
-        const T *ends = &smem_base[source_op.params.runend.ends_smem_offset];
-        const T *values = &smem_base[source_op.params.runend.values_smem_offset];
-        const uint64_t num_runs = source_op.params.runend.num_runs;
-        const uint64_t offset = source_op.params.runend.offset;
-
-        // Each thread binary-searches for its first position's run, then
-        // forward-scans for subsequent positions. Strided positions are
-        // monotonically increasing per thread, so current_run only advances.
-        uint64_t current_run = upper_bound(ends, num_runs, chunk_start + threadIdx.x + offset);
-
-        for (uint32_t i = threadIdx.x; i < chunk_len; i += blockDim.x) {
-            uint64_t pos = chunk_start + i + offset;
-
-            while (current_run < num_runs && static_cast<uint64_t>(ends[current_run]) <= pos) {
-                current_run++;
-            }
-
-            smem_output[i] = values[min(current_run, num_runs - 1)];
-        }
-        break;
-    }
-
+__device__ inline T load_element(const void *__restrict ptr, PTypeTag ptype, uint64_t idx) {
+    switch (ptype) {
+    case PTYPE_U8:
+        return static_cast<T>(static_cast<const uint8_t *>(ptr)[idx]);
+    case PTYPE_I8:
+        return static_cast<T>(static_cast<const int8_t *>(ptr)[idx]);
+    case PTYPE_U16:
+        return static_cast<T>(static_cast<const uint16_t *>(ptr)[idx]);
+    case PTYPE_I16:
+        return static_cast<T>(static_cast<const int16_t *>(ptr)[idx]);
+    case PTYPE_U32:
+    case PTYPE_F32:
+        return static_cast<T>(static_cast<const uint32_t *>(ptr)[idx]);
+    case PTYPE_I32:
+        return static_cast<T>(static_cast<const int32_t *>(ptr)[idx]);
+    case PTYPE_U64:
+    case PTYPE_F64:
+        return static_cast<T>(static_cast<const uint64_t *>(ptr)[idx]);
+    case PTYPE_I64:
+        return static_cast<T>(static_cast<const int64_t *>(ptr)[idx]);
     default:
         __builtin_unreachable();
     }
 }
 
-/// Applies a single scalar operation to N values in registers.
+/// Per-thread run cursor for RUNEND forward-scan, one entry per thread.
 ///
-/// Scalar operations are applied element-wise after the source op fills shared
-/// memory. All ops compose fluently in any order: FoR adds a constant, ZigZag
-/// decodes signed integers, ALP decodes floats, and DICT gathers from a
-/// dictionary in shared memory.
-///
-/// @param values    Array of N values to transform in-place
-/// @param op        The scalar operation descriptor
-/// @param smem_base Base of dynamic shared memory pool (used by DICT to resolve offsets)
+/// Stored in shared memory so the cursor persists across successive
+/// source_op calls in the tile loop. Each thread's positions are
+/// monotonically increasing across tiles, so the cursor only advances
+/// forward — the next tile picks up exactly where the previous one
+/// stopped, avoiding a binary search per tile. The only binary search
+/// is the initial upper_bound seed before the tile loop begins.
+__shared__ uint64_t runend_cursors[BLOCK_SIZE];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Scalar ops
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Apply one scalar operation to N values in registers.
 template <typename T, uint32_t N>
-__device__ inline void apply_scalar_op(T *values, const struct ScalarOp &op, T *__restrict smem_base) {
+__device__ inline void scalar_op(T *values, const struct ScalarOp &op, char *__restrict smem) {
     switch (op.op_code) {
     case ScalarOp::FOR: {
         const T ref = static_cast<T>(op.params.frame_of_ref.reference);
-        // clang-format off
-        #pragma unroll
-        // clang-format on
+#pragma unroll
         for (uint32_t i = 0; i < N; ++i) {
             values[i] += ref;
         }
         break;
     }
     case ScalarOp::ZIGZAG: {
-        // clang-format off
-        #pragma unroll
-        // clang-format on
+#pragma unroll
         for (uint32_t i = 0; i < N; ++i) {
             values[i] = (values[i] >> 1) ^ static_cast<T>(-(values[i] & 1));
         }
         break;
     }
     case ScalarOp::ALP: {
-        const float f = op.params.alp.f;
-        const float e = op.params.alp.e;
-        // clang-format off
-        #pragma unroll
-        // clang-format on
+        const float f = op.params.alp.f, e = op.params.alp.e;
+#pragma unroll
         for (uint32_t i = 0; i < N; ++i) {
-            float result = static_cast<float>(static_cast<int32_t>(values[i])) * f * e;
-            values[i] = static_cast<T>(__float_as_uint(result));
+            float r = static_cast<float>(static_cast<int32_t>(values[i])) * f * e;
+            values[i] = static_cast<T>(__float_as_uint(r));
         }
         break;
     }
     case ScalarOp::DICT: {
-        const T *dict_values = &smem_base[op.params.dict.values_smem_offset];
-        // clang-format off
-        #pragma unroll
-        // clang-format on
+        const T *dict = reinterpret_cast<const T *>(smem + op.params.dict.values_smem_byte_offset);
+#pragma unroll
         for (uint32_t i = 0; i < N; ++i) {
-            values[i] = dict_values[static_cast<uint32_t>(values[i])];
+            values[i] = dict[static_cast<uint32_t>(values[i])];
         }
         break;
     }
@@ -174,167 +149,333 @@ __device__ inline void apply_scalar_op(T *values, const struct ScalarOp &op, T *
     }
 }
 
-/// Store policy for global memory writes.
-enum class StorePolicy {
-    /// Default write-back stores — data stays in L2 cache.
-    WRITEBACK,
-    /// Streaming stores (`__stcs` / `st.cs`) — hint L2 to evict early.
-    /// Use for write-only output data that this kernel will not read again.
-    /// `__stcs` is a regular synchronous store (not async like `cp.async`),
-    /// so the existing `__syncthreads()` barrier after each tile is
-    /// sufficient for ordering.
-    STREAMING,
-};
-
-/// Reads values from `smem_input`, applies scalar ops in registers, and
-/// writes results to `write_dest` at `write_offset`.
-template <typename T, StorePolicy S>
-__device__ void apply_scalar_ops(const T *__restrict smem_input,
-                                 T *__restrict write_dest,
-                                 uint64_t write_offset,
+// ═══════════════════════════════════════════════════════════════════════════
+// Source ops
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// FastLanes cooperative unpack — all threads in the block scatter-write
+/// decoded elements into `dst`. Caller must issue __syncthreads() before
+/// any thread reads from `dst`.
+template <typename T>
+__device__ inline void bitunpack(const T *__restrict packed,
+                                 T *__restrict dst,
+                                 uint64_t chunk_start,
                                  uint32_t chunk_len,
-                                 uint8_t num_scalar_ops,
-                                 const struct ScalarOp *scalar_ops,
-                                 T *__restrict smem_base) {
-    constexpr uint32_t VALUES_PER_LOOP = 64 / sizeof(T);
-    const uint32_t tile_size = blockDim.x * VALUES_PER_LOOP;
-    const uint32_t num_full_tiles = chunk_len / tile_size;
-
-    // Each thread holds multiple values in registers for instruction-level
-    // parallelism, hiding pipeline latency between independent operations.
-    for (uint32_t tile = 0; tile < num_full_tiles; ++tile) {
-        const uint32_t tile_base = tile * tile_size;
-        T values[VALUES_PER_LOOP];
-
-        // clang-format off
-        #pragma unroll
-        // clang-format on
-        for (uint32_t idx = 0; idx < VALUES_PER_LOOP; ++idx) {
-            values[idx] = smem_input[tile_base + idx * blockDim.x + threadIdx.x];
+                                 const struct SourceOp &src) {
+    constexpr uint32_t T_BITS = sizeof(T) * 8;
+    constexpr uint32_t FL_CHUNK = 1024;
+    constexpr uint32_t LANES = FL_CHUNK / T_BITS;
+    const uint32_t bw = src.params.bitunpack.bit_width;
+    const uint32_t words_per_block = LANES * bw;
+    const uint32_t elem_off = src.params.bitunpack.element_offset;
+    const uint32_t dst_off = (chunk_start + elem_off) % FL_CHUNK;
+    const uint64_t first_block = (chunk_start + elem_off) / FL_CHUNK;
+
+    static_assert((ELEMENTS_PER_BLOCK % FL_CHUNK) == 0);
+    const uint32_t n_chunks = (chunk_len + dst_off + FL_CHUNK - 1) / FL_CHUNK;
+
+    for (uint32_t c = 0; c < n_chunks; ++c) {
+        const T *src_chunk = packed + (first_block + c) * words_per_block;
+        T *chunk_dst = dst + c * FL_CHUNK;
+        for (uint32_t lane = threadIdx.x; lane < LANES; lane += blockDim.x) {
+            bit_unpack_lane<T>(src_chunk, chunk_dst, 0, lane, bw);
         }
+    }
+}
 
-        for (uint8_t op_idx = 0; op_idx < num_scalar_ops; ++op_idx) {
-            apply_scalar_op<T, VALUES_PER_LOOP>(values, scalar_ops[op_idx], smem_base);
+/// Read N values from a source op into `out`.
+///
+/// Dispatches on `src.op_code` to handle each encoding:
+///   BITUNPACK — read from `smem_src` at `smem_base` offset.
+///   LOAD      — read from `raw_input` via load_element (type-widening).
+///   SEQUENCE  — compute base + pos × multiplier in registers.
+///   RUNEND    — forward-scan ends/values in smem using runend_cursors.
+///
+/// Position calculation (via THREAD_POS macro):
+///   N > 1 (batched): pos = base + j·blockDim.x + threadIdx.x.
+///                    Caller passes the tile base WITHOUT threadIdx.x.
+///   N = 1 (single):  base is the exact position. No stride added.
+template <typename T, uint32_t N>
+__device__ inline void source_op(T *out,
+                                 const struct SourceOp &src,
+                                 const void *raw_input,
+                                 PTypeTag ptype,
+                                 const T *smem_src,
+                                 uint32_t smem_base,
+                                 uint64_t global_base,
+                                 char *__restrict smem) {
+    // Wrapped in a macro, rather than a lambda, to avoid allocating additional GPU registers.
+#define THREAD_POS(base, j) ((N == 1) ? (base) : ((base) + (j) * blockDim.x + threadIdx.x))
+
+    switch (src.op_code) {
+    case SourceOp::BITUNPACK: {
+#pragma unroll
+        for (uint32_t j = 0; j < N; ++j) {
+            out[j] = smem_src[THREAD_POS(smem_base, j)];
         }
-
-        // clang-format off
-        #pragma unroll
-        // clang-format on
-        for (uint32_t idx = 0; idx < VALUES_PER_LOOP; ++idx) {
-            if constexpr (S == StorePolicy::STREAMING) {
-                __stcs(&write_dest[write_offset + tile_base + idx * blockDim.x + threadIdx.x], values[idx]);
-            } else {
-                write_dest[write_offset + tile_base + idx * blockDim.x + threadIdx.x] = values[idx];
-            }
+        return;
+    }
+    case SourceOp::LOAD: {
+#pragma unroll
+        for (uint32_t j = 0; j < N; ++j) {
+            out[j] = load_element<T>(raw_input, ptype, THREAD_POS(global_base, j));
         }
+        return;
     }
-
-    const uint32_t rem_start = num_full_tiles * tile_size;
-    for (uint32_t elem_idx = rem_start + threadIdx.x; elem_idx < chunk_len; elem_idx += blockDim.x) {
-        T val = smem_input[elem_idx];
-        for (uint8_t op_idx = 0; op_idx < num_scalar_ops; ++op_idx) {
-            apply_scalar_op<T, 1>(&val, scalar_ops[op_idx], smem_base);
+    case SourceOp::SEQUENCE: {
+        const T base = static_cast<T>(src.params.sequence.base);
+        const T mul = static_cast<T>(src.params.sequence.multiplier);
+#pragma unroll
+        for (uint32_t j = 0; j < N; ++j) {
+            out[j] = base + static_cast<T>(THREAD_POS(global_base, j)) * mul;
         }
-        if constexpr (S == StorePolicy::STREAMING) {
-            __stcs(&write_dest[write_offset + elem_idx], val);
-        } else {
-            write_dest[write_offset + elem_idx] = val;
+        return;
+    }
+    case SourceOp::RUNEND: {
+        const T *ends = reinterpret_cast<const T *>(smem + src.params.runend.ends_smem_byte_offset);
+        const T *values = reinterpret_cast<const T *>(smem + src.params.runend.values_smem_byte_offset);
+        const uint64_t num_runs = src.params.runend.num_runs;
+        const uint64_t offset = src.params.runend.offset;
+        uint64_t &run = runend_cursors[threadIdx.x];
+#pragma unroll
+        for (uint32_t j = 0; j < N; ++j) {
+            const uint64_t pos = THREAD_POS(global_base, j) + offset;
+            while (run < num_runs && static_cast<uint64_t>(ends[run]) <= pos) {
+                run++;
+            }
+            out[j] = values[min(run, num_runs - 1)];
         }
+        return;
+    }
+    default:
+        __builtin_unreachable();
     }
+
+#undef THREAD_POS
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Output stage — source_op → scalar_op → streaming store
+// ═══════════════════════════════════════════════════════════════════════════
+//
+// BITUNPACK tiles at SMEM_TILE_SIZE: cooperative unpack → smem → sync →
+// batched read.  LOAD, SEQUENCE, and RUNEND need no smem scratch and
+// process the full block in a single outer iteration, tiled by tile_idx.
+
+/// How many elements to process in this BITUNPACK tile iteration.
+/// The first tile may be shorter due to `element_offset` alignment;
+/// the last tile may be shorter because we've reached `block_len`.
+__device__ inline uint32_t bitunpack_tile_len(const Stage &stage, uint32_t block_len, uint32_t tile_off) {
+    const uint32_t off = (tile_off == 0) ? stage.source.params.bitunpack.element_offset : 0;
+    return min(SMEM_TILE_SIZE - off, block_len - tile_off);
 }
 
-/// Decodes and transforms a stage's data through shared memory, writing
-/// final results to `write_dest` at `write_offset`. Input stages write
-/// back to smem; the output stage writes to global memory.
-template <typename T, StorePolicy S>
-__device__ void execute_stage(const struct Stage &stage,
-                              T *__restrict smem_base,
-                              uint64_t chunk_start,
-                              uint32_t chunk_len,
-                              T *__restrict write_dest,
-                              uint64_t write_offset) {
-    T *smem_output = &smem_base[stage.smem_offset];
-
-    dynamic_source_op<T>(reinterpret_cast<const T *>(stage.input_ptr),
-                         smem_output,
-                         chunk_start,
+/// Process the final / output stage: decode source → apply scalar ops →
+/// streaming-store to global memory. Handles the full block, tiling through
+/// smem scratch for BITUNPACK.
+template <typename T>
+__device__ void execute_output_stage(T *__restrict output,
+                                     const Stage &stage,
+                                     char *__restrict smem,
+                                     uint64_t block_start,
+                                     uint32_t block_len) {
+    constexpr uint32_t VALUES_PER_TILE = 32 / sizeof(T);
+    const uint32_t tile_size = blockDim.x * VALUES_PER_TILE;
+    const auto &src = stage.source;
+    const void *raw_input = reinterpret_cast<const void *>(stage.input_ptr);
+    const PTypeTag ptype = stage.source_ptype;
+
+    if (src.op_code == SourceOp::RUNEND) {
+        // Seed each thread's cursor with the run containing its first
+        // strided position. The RUNEND arm in source_op advances the
+        // cursor monotonically, so this avoids a full binary search on
+        // every element.
+        const T *ends = reinterpret_cast<const T *>(smem + src.params.runend.ends_smem_byte_offset);
+        runend_cursors[threadIdx.x] = upper_bound(ends,
+                                                  src.params.runend.num_runs,
+                                                  block_start + threadIdx.x + src.params.runend.offset);
+    }
+
+    for (uint32_t elem_idx = 0; elem_idx < block_len;) {
+        uint32_t chunk_len;
+        const T *smem_src = nullptr;
+
+        // BITUNPACK uses smem scratch, so the outer loop advances one
+        // chunk at a time. LOAD, SEQUENCE, and RUNEND need no smem
+        // scratch, so chunk_len = block_len (single outer iteration);
+        // tiling happens in the inner tile_idx loop.
+        if (src.op_code == SourceOp::BITUNPACK) {
+            chunk_len = bitunpack_tile_len(stage, block_len, elem_idx);
+            T *scratch = reinterpret_cast<T *>(smem + stage.smem_byte_offset);
+            bitunpack<T>(reinterpret_cast<const T *>(stage.input_ptr),
+                         scratch,
+                         block_start + elem_idx,
                          chunk_len,
-                         stage.source,
-                         smem_base);
-    __syncthreads();
-
-    apply_scalar_ops<T, S>(smem_output,
-                           write_dest,
-                           write_offset,
-                           chunk_len,
-                           stage.num_scalar_ops,
-                           stage.scalar_ops,
-                           smem_base);
-    __syncthreads();
+                         src);
+            constexpr uint32_t FL_CHUNK = 1024; // FastLanes chunk size
+            const uint32_t align = (block_start + elem_idx + src.params.bitunpack.element_offset) % FL_CHUNK;
+            smem_src = scratch + align;
+            // Write barrier: all threads finished bitunpack, safe to read from scratch.
+            __syncthreads();
+        } else {
+            chunk_len = block_len;
+        }
+
+        const uint32_t tile_count = chunk_len / tile_size;
+        for (uint32_t tile_idx = 0; tile_idx < tile_count; ++tile_idx) {
+            const uint64_t tile_start = block_start + elem_idx + static_cast<uint64_t>(tile_idx) * tile_size;
+            T values[VALUES_PER_TILE];
+
+            source_op<T, VALUES_PER_TILE>(values,
+                                          src,
+                                          raw_input,
+                                          ptype,
+                                          smem_src,
+                                          tile_idx * tile_size,
+                                          tile_start,
+                                          smem);
+
+            for (uint8_t op = 0; op < stage.num_scalar_ops; ++op) {
+                scalar_op<T, VALUES_PER_TILE>(values, stage.scalar_ops[op], smem);
+            }
+
+#pragma unroll
+            for (uint32_t j = 0; j < VALUES_PER_TILE; ++j) {
+                // st.cs (cache streaming): marks this line for earliest
+                // eviction in L1 and L2. Output data is written once and
+                // never read again by this kernel, so keeping it cached
+                // would only compete with the packed input buffers and
+                // smem-resident dict/runend data that the next tiles still
+                // need to read. Evict-first lets those stay resident.
+                __stcs(&output[tile_start + j * blockDim.x + threadIdx.x], values[j]);
+            }
+        }
+
+        const uint32_t rem = tile_count * tile_size;
+        for (uint32_t i = rem + threadIdx.x; i < chunk_len; i += blockDim.x) {
+            const uint64_t gpos = block_start + elem_idx + i;
+            T val;
+            source_op<T, 1>(&val, src, raw_input, ptype, smem_src, i, gpos, smem);
+
+            for (uint8_t op = 0; op < stage.num_scalar_ops; ++op) {
+                scalar_op<T, 1>(&val, stage.scalar_ops[op], smem);
+            }
+            __stcs(&output[gpos], val);
+        }
+
+        if (src.op_code == SourceOp::BITUNPACK) {
+            // Read barrier: all threads finished reading scratch, safe to
+            // overwrite it with the next chunk's bitunpack.
+            __syncthreads();
+        }
+        elem_idx += chunk_len;
+    }
 }
 
-/// Entry point of the dynamic dispatch kernel.
-///
-/// Executes the plan's stages in order:
-///   1. Input stages populate shared memory with intermediate data
-///      for the output stage to reference.
-///   2. The output stage decodes the root array and writes directly to
-///      global memory.
+// ═══════════════════════════════════════════════════════════════════════════
+// Input stages — decode dependencies into shared memory for the output stage
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Decode one input stage (dict values, run-end endpoints, etc.) into its
+/// shared memory region so the output stage can reference it later.
+/// Applies any scalar ops in-place before returning.
 ///
-/// @param output    Global memory output buffer
-/// @param array_len Total number of elements to produce
-/// @param plan      Device pointer to the dispatch plan
+/// Unlike execute_output_stage, this does not tile — the entire stage is
+/// decoded in one pass. The output stage needs random access into these
+/// smem regions (e.g. DICT gathers by arbitrary code value), so the data
+/// must be fully resident. The smem limit check in the Rust plan builder
+/// ensures the stage fits; if it doesn't, the plan falls back to Unfused.
 template <typename T>
-__device__ void dynamic_dispatch_impl(T *__restrict output,
-                                      uint64_t array_len,
-                                      const struct DynamicDispatchPlan *__restrict plan) {
-
-    // Dynamically-sized shared memory: The host computes the exact byte count
-    // needed to hold all stage outputs that must coexist simultaneously, and
-    // passes the count at kernel launch (see DynamicDispatchPlan::shared_mem_bytes).
-    extern __shared__ char smem_bytes[];
-    T *smem_base = reinterpret_cast<T *>(smem_bytes);
-
-    __shared__ struct DynamicDispatchPlan smem_plan;
-    if (threadIdx.x == 0) {
-        smem_plan = *plan;
+__device__ void execute_input_stage(const Stage &stage, char *__restrict smem) {
+    T *smem_out = reinterpret_cast<T *>(smem + stage.smem_byte_offset);
+    const auto &src = stage.source;
+
+    if (src.op_code == SourceOp::BITUNPACK) {
+        bitunpack<T>(reinterpret_cast<const T *>(stage.input_ptr), smem_out, 0, stage.len, src);
+        smem_out += src.params.bitunpack.element_offset % SMEM_TILE_SIZE;
+        // Write barrier: cooperative bitunpack finished, safe to read
+        // decoded elements in the scalar-op loop below.
+        __syncthreads();
+
+        if (stage.num_scalar_ops > 0) {
+            for (uint32_t i = threadIdx.x; i < stage.len; i += blockDim.x) {
+                T val = smem_out[i];
+                for (uint8_t op = 0; op < stage.num_scalar_ops; ++op) {
+                    scalar_op<T, 1>(&val, stage.scalar_ops[op], smem);
+                }
+                smem_out[i] = val;
+            }
+            // Write barrier: scalar ops applied in-place, smem region is
+            // now fully populated for subsequent stages to read.
+            __syncthreads();
+        }
+    } else {
+        if (src.op_code == SourceOp::RUNEND) {
+            // Seed each thread's cursor with the run containing its first
+            // strided position. The RUNEND arm in source_op advances the
+            // cursor monotonically, so this avoids a full binary search on
+            // every element.
+            const T *ends = reinterpret_cast<const T *>(smem + src.params.runend.ends_smem_byte_offset);
+            runend_cursors[threadIdx.x] =
+                upper_bound(ends, src.params.runend.num_runs, threadIdx.x + src.params.runend.offset);
+        }
+        const void *raw_input = reinterpret_cast<const void *>(stage.input_ptr);
+        for (uint32_t i = threadIdx.x; i < stage.len; i += blockDim.x) {
+            T val;
+            source_op<T, 1>(&val, src, raw_input, stage.source_ptype, nullptr, 0, i, smem);
+            for (uint8_t op = 0; op < stage.num_scalar_ops; ++op) {
+                scalar_op<T, 1>(&val, stage.scalar_ops[op], smem);
+            }
+            smem_out[i] = val;
+        }
+        // Write barrier: smem region is fully populated for subsequent
+        // stages to read.
+        __syncthreads();
     }
-    __syncthreads();
+}
 
-    const uint8_t last = smem_plan.num_stages - 1;
+// ═══════════════════════════════════════════════════════════════════════════
+// Kernel entry
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Kernel entry point. Parses the packed plan, runs all input stages to
+/// populate shared memory, then runs the output stage to produce results.
+template <typename T>
+__device__ void
+dynamic_dispatch(T *__restrict output, uint64_t array_len, const uint8_t *__restrict packed_plan) {
+    extern __shared__ char smem[];
+
+    const auto *hdr = reinterpret_cast<const struct PlanHeader *>(packed_plan);
+    const uint8_t *cursor = packed_plan + sizeof(struct PlanHeader);
+    const uint8_t last = hdr->num_stages - 1;
 
-    // Input stages: Decode inputs into smem regions.
     for (uint8_t i = 0; i < last; ++i) {
-        const struct Stage &stage = smem_plan.stages[i];
-        T *smem_output = &smem_base[stage.smem_offset];
-        execute_stage<T, StorePolicy::WRITEBACK>(stage, smem_base, 0, stage.len, smem_output, 0);
+        Stage input_stage = parse_stage(cursor);
+        execute_input_stage<T>(input_stage, smem);
     }
 
-    // Output stage: process in SMEM_TILE_SIZE tiles to reduce smem footprint.
-    // Each tile decodes into the same smem region and writes to global memory.
-    const struct Stage &output_stage = smem_plan.stages[last];
+    Stage output_stage = parse_stage(cursor);
     const uint64_t block_start = static_cast<uint64_t>(blockIdx.x) * ELEMENTS_PER_BLOCK;
     const uint64_t block_end = min(block_start + ELEMENTS_PER_BLOCK, array_len);
-    const uint32_t block_len = static_cast<uint32_t>(block_end - block_start);
-
-    for (uint32_t tile_off = 0; tile_off < block_len; tile_off += SMEM_TILE_SIZE) {
-        const uint32_t tile_len = min(SMEM_TILE_SIZE, block_len - tile_off);
-        execute_stage<T, StorePolicy::STREAMING>(output_stage,
-                                                 smem_base,
-                                                 block_start + tile_off,
-                                                 tile_len,
-                                                 output,
-                                                 block_start + tile_off);
-    }
+    execute_output_stage<T>(output,
+                            output_stage,
+                            smem,
+                            block_start,
+                            static_cast<uint32_t>(block_end - block_start));
 }
 
-/// Generates a dynamic dispatch kernel entry point for each unsigned integer type.
-#define GENERATE_DYNAMIC_DISPATCH_KERNEL(suffix, Type)                                                       \
-    extern "C" __global__ void dynamic_dispatch_##suffix(                                                    \
-        Type *__restrict output,                                                                             \
-        uint64_t array_len,                                                                                  \
-        const struct DynamicDispatchPlan *__restrict plan) {                                                 \
-        dynamic_dispatch_impl<Type>(output, array_len, plan);                                                \
+// Kernels are instantiated only for unsigned integer types. Signed and
+// floating-point arrays reuse the unsigned kernel of the same width —
+// the data is bit-identical under reinterpretation, and all arithmetic
+// in the pipeline (FoR add, ZigZag decode, ALP decode, DICT gather) is
+// correct on the unsigned representation. The one place where signedness
+// matters is load_element(), which dispatches on the per-op PTypeTag to
+// sign-extend or zero-extend when widening a narrow source to T.
+#define GENERATE_KERNEL(suffix, Type)                                                                        \
+    extern "C" __global__ void dynamic_dispatch_##suffix(Type *__restrict output,                            \
+                                                         uint64_t array_len,                                 \
+                                                         const uint8_t *__restrict packed_plan) {            \
+        dynamic_dispatch<Type>(output, array_len, packed_plan);                                              \
     }
 
-FOR_EACH_UNSIGNED_INT(GENERATE_DYNAMIC_DISPATCH_KERNEL)
+FOR_EACH_UNSIGNED_INT(GENERATE_KERNEL)
diff --git a/vortex-cuda/kernels/src/dynamic_dispatch.h b/vortex-cuda/kernels/src/dynamic_dispatch.h
index f8fbeaf6c13..95540c51581 100644
--- a/vortex-cuda/kernels/src/dynamic_dispatch.h
+++ b/vortex-cuda/kernels/src/dynamic_dispatch.h
@@ -6,67 +6,149 @@
 /// The plan builder walks an encoding tree and emits a linear sequence of
 /// stages. The kernel executes stages in order within a single launch.
 ///
-/// Shared memory: The plan builder bump-allocates shared memory regions for
-/// each input stage's output. The output stage (last) is placed after all
-/// input stages. Since all regions must coexist for the output stage to
-/// reference, the total shared memory is the end of whichever region extends
-/// furthest, in elements, times `sizeof(T)`.
+/// ## Stage plan
 ///
-/// Example: RunEnd(ends=FoR(BitPacked), values=FoR(BitPacked)) with 100 runs
+/// The plan is packed as a variable-length byte buffer.
 ///
-///   Stage 0 (input):  BITUNPACK(7) → FoR(0)            → smem[0..100)      // run ends
-///   Stage 1 (input):  BITUNPACK(10) → FoR(50)          → smem[100..200)    // run values
-///   Stage 2 (output): RUNEND(ends=0, values=100)        → smem[200..1224)  // resolved
+/// Layout (contiguous bytes):
+///   [PlanHeader]
+///   [PackedStage 0][ScalarOp × N0]
+///   [PackedStage 1][ScalarOp × N1]
+///   ...
 ///
-///   shared_mem_bytes = (200 + 1024) * sizeof(T)
+/// ## Per-op type tracking
+///
+/// Each source op and scalar op may produce a different PType than its input.
+/// For example, DICT transforms codes (e.g. u8) into values (e.g. f32), and
+/// ALP transforms encoded integers (i32) into floats (f32).
+///
+/// `PTypeTag` is a compact enum that identifies the primitive type at each
+/// point in the pipeline. The kernel uses it to dispatch typed memory
+/// operations (LOAD, BITUNPACK) and cross-stage references (DICT gather,
+/// RUNEND lookup) at the correct element width and signedness.
 
 #pragma once
 
 #include <stdint.h>
 
+/// Compact tag identifying a Vortex PType for GPU dispatch.
+///
+/// NOTE: These values intentionally skip F16 (which Rust PType includes),
+/// so numeric values do NOT match Rust PType directly. The Rust
+/// `ptype_to_tag()` function handles the mapping at plan-build time.
+///
+/// The kernel uses this to:
+/// - Select the correct element width for LOAD / BITUNPACK source ops.
+/// - Index shared memory at the correct stride for DICT / RUNEND cross-stage
+///   references.
+/// - Distinguish int vs float for ALP decode.
+enum PTypeTag : uint8_t {
+    PTYPE_U8 = 0,
+    PTYPE_U16 = 1,
+    PTYPE_U32 = 2,
+    PTYPE_U64 = 3,
+    PTYPE_I8 = 4,
+    PTYPE_I16 = 5,
+    PTYPE_I32 = 6,
+    PTYPE_I64 = 7,
+    PTYPE_F32 = 8,
+    PTYPE_F64 = 9,
+};
+
+/// Return the unsigned equivalent of a PTypeTag (same width).
+#ifdef __cplusplus
+#ifdef __CUDACC__
+#define PTYPE_HOST_DEVICE __host__ __device__
+#else
+#define PTYPE_HOST_DEVICE
+#endif
+PTYPE_HOST_DEVICE constexpr PTypeTag ptype_to_unsigned(PTypeTag tag) {
+    switch (tag) {
+    case PTYPE_I8:
+        return PTYPE_U8;
+    case PTYPE_I16:
+        return PTYPE_U16;
+    case PTYPE_I32:
+    case PTYPE_F32:
+        return PTYPE_U32;
+    case PTYPE_I64:
+    case PTYPE_F64:
+        return PTYPE_U64;
+    default:
+        return tag;
+    }
+}
+#endif
+
+/// Number of threads per CUDA block.
+#define BLOCK_SIZE 64
+
 /// Elements processed per CUDA block.
 #define ELEMENTS_PER_BLOCK 2048
 
-/// Shared memory tile size for the output stage. Each block decompresses
-/// ELEMENTS_PER_BLOCK elements but only holds SMEM_TILE_SIZE in smem at a
-/// time — each tile is written to global memory before the next is decoded
-/// into the same region. Input stages cannot tile because their outputs must
-/// remain accessible for random access (e.g., dictionary lookup, run-end
-/// binary search). Smaller tiles reduce smem per block, improving occupancy.
+/// Each tile is flushed to global before the next is decoded.
 #define SMEM_TILE_SIZE 1024
 
+/// Fixed shared memory declared in the kernel (bytes), excluded from
+/// the dynamic shared memory budget. Accounts for
+/// `runend_cursors[BLOCK_SIZE]` — one uint64_t cursor per thread.
+///
+/// Uses a literal (64 * 8 = 512) instead of `BLOCK_SIZE * sizeof(uint64_t)`
+/// so that bindgen can export it as a Rust constant (bindgen cannot evaluate
+/// expressions involving other macros or sizeof).
+#define KERNEL_FIXED_SHARED_BYTES 512
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// Parameters for source ops, which decode data into a stage's shared memory region.
 union SourceParams {
-    /// Unpack bit-packed data using FastLanes layout.
+    /// Unpack FastLanes bit-packed data.
     struct BitunpackParams {
         uint8_t bit_width;
+        uint32_t element_offset; // Sub-byte offset
     } bitunpack;
 
-    /// Copy elements verbatim from global memory to shared memory.
+    /// Copy from global to shared memory.
     struct LoadParams {
-        uint8_t _padding;
+        uint8_t _placeholder;
     } load;
 
     /// Decode run-end encoding using ends and values already in shared memory.
+    ///
+    /// The smem offsets are byte offsets so that ends and values can have
+    /// different element widths.
     struct RunEndParams {
-        uint32_t ends_smem_offset;   // element offset to decoded ends in smem
-        uint32_t values_smem_offset; // element offset to decoded values in smem
+        uint32_t ends_smem_byte_offset;   // byte offset to decoded ends in smem
+        uint32_t values_smem_byte_offset; // byte offset to decoded values in smem
         uint64_t num_runs;
-        uint64_t offset;
+        uint64_t offset; // slice offset into the run-end encoded array
     } runend;
+
+    /// Generate a linear sequence: `value[i] = base + i * multiplier`.
+    struct SequenceParams {
+        int64_t base;
+        int64_t multiplier;
+    } sequence;
 };
 
 struct SourceOp {
-    enum SourceOpCode { BITUNPACK, LOAD, RUNEND } op_code;
+    enum SourceOpCode { BITUNPACK, LOAD, RUNEND, SEQUENCE } op_code;
     union SourceParams params;
 };
 
 /// Scalar ops: element-wise transforms in registers.
-/// All ops compose fluently in any order.
+///
+/// Each scalar op declares its `output_ptype` — the PType of the values it
+/// produces. Most ops preserve the input type (FOR, ZIGZAG), but some
+/// change it:
+///   - ALP: encoded int → float (e.g. i32 → f32)
+///   - DICT: codes type → values type (e.g. u8 → u32)
+///
+/// The plan builder uses `output_ptype` to determine the element width
+/// for shared memory allocation and to propagate type information
+/// through the pipeline.
 union ScalarParams {
     struct FoRParams {
         uint64_t reference;
@@ -78,48 +160,96 @@ union ScalarParams {
     } alp;
 
     /// Dictionary gather: use current value as index into decoded values in smem.
+    ///
+    /// `values_smem_byte_offset` is a byte offset so that values can have
+    /// a different element width than the codes. The plan builder uses
+    /// `output_ptype` (on the enclosing ScalarOp) to determine the values'
+    /// element type.
     struct DictParams {
-        uint32_t values_smem_offset; // element offset to decoded dict values in smem
+        uint32_t values_smem_byte_offset; // byte offset to decoded dict values in smem
     } dict;
 };
 
 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 PTypeTag output_ptype;
     union ScalarParams params;
 };
 
-#define MAX_SCALAR_OPS 4
-
-/// A single stage in the dispatch plan.
+/// Packed stage header, followed by `num_scalar_ops` inline ScalarOps.
 ///
-/// Each stage is a pipeline (source + scalar ops) that writes decoded data
-/// into a shared memory region at `smem_offset`. Input stage outputs persist
-/// in smem so the output stage can reference them (via DICT or RUNEND offsets).
-struct Stage {
-    uint64_t input_ptr;   // global memory pointer to this stage's encoded input
-    uint32_t smem_offset; // element offset within dynamic shared memory for output
-    uint32_t len;         // number of elements this stage produces
+/// `source_ptype` identifies the PType that the source op (BITUNPACK, LOAD,
+/// etc.) produces. This may differ from the output PType when scalar ops
+/// change the type (e.g. DICT transforms u8 codes into u32 values).
+///
+/// `smem_byte_offset` is a byte offset into the dynamic shared memory
+/// pool so that stages with different element widths can coexist.
+struct PackedStage {
+    uint64_t input_ptr;        // global memory pointer to this stage's encoded input
+    uint32_t smem_byte_offset; // byte offset within dynamic shared memory for output
+    uint32_t len;              // number of elements this stage produces
 
     struct SourceOp source;
     uint8_t num_scalar_ops;
-    struct ScalarOp scalar_ops[MAX_SCALAR_OPS];
+    enum PTypeTag source_ptype; // PType produced by the source op
+};
+
+/// Header for the packed plan byte buffer.
+struct __attribute__((aligned(8))) PlanHeader {
+    uint8_t num_stages;
+    enum PTypeTag output_ptype; // PType of the final output array
+    uint16_t plan_size_bytes;   // total size of the packed plan including this header
 };
 
-#define MAX_STAGES 4
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
 
-/// Dispatch plan: a sequence of stages.
+/// Stage parsed from the packed plan byte buffer.
 ///
-/// The plan builder walks the encoding tree recursively, emitting an input
-/// stage each time it encounters a child array that needs to live in shared
-/// memory (e.g., dictionary values, run-end endpoints). Shared memory
-/// offsets are assigned with a simple bump allocator.
+/// Input stages decode data (e.g. dict values, run-end endpoints) into a
+/// shared memory region for the output stage to reference. The output stage
+/// decodes the root encoding and writes to global memory.
 ///
-/// The last stage is the output pipeline which directly writes to global memory.
-struct DynamicDispatchPlan {
-    uint8_t num_stages;
-    struct Stage stages[MAX_STAGES];
+/// `source_ptype` is the PType produced by the source op. Scalar ops may
+/// change the type; the final output PType is given by the last scalar op's
+/// `output_ptype` (or `source_ptype` if there are no scalar ops).
+struct Stage {
+    uint64_t input_ptr;                // encoded input in global memory
+    uint32_t smem_byte_offset;         // byte offset within dynamic shared memory
+    uint32_t len;                      // elements produced
+    enum PTypeTag source_ptype;        // PType produced by the source op
+    struct SourceOp source;            // source decode op
+    uint8_t num_scalar_ops;            // number of scalar ops
+    const struct ScalarOp *scalar_ops; // scalar decode ops
 };
 
-#ifdef __cplusplus
+/// Parse a single stage from the packed plan byte buffer and advance the cursor.
+///
+/// @param cursor  Pointer into the packed plan buffer, pointing at a PackedStage.
+///                On return, advanced past this stage's ScalarOps.
+/// @return        A Stage referencing data within the packed plan buffer.
+__device__ inline Stage parse_stage(const uint8_t *&cursor) {
+    const auto *packed_stage = reinterpret_cast<const struct PackedStage *>(cursor);
+    cursor += sizeof(struct PackedStage);
+
+    const auto *ops = reinterpret_cast<const struct ScalarOp *>(cursor);
+    cursor += packed_stage->num_scalar_ops * sizeof(struct ScalarOp);
+
+    return Stage {
+        .input_ptr = packed_stage->input_ptr,
+        .smem_byte_offset = packed_stage->smem_byte_offset,
+        .len = packed_stage->len,
+        .source_ptype = packed_stage->source_ptype,
+        .source = packed_stage->source,
+        .num_scalar_ops = packed_stage->num_scalar_ops,
+        .scalar_ops = ops,
+    };
 }
+
 #endif
diff --git a/vortex-cuda/kernels/src/fastlanes_common.cuh b/vortex-cuda/kernels/src/fastlanes_common.cuh
index 0054418ca05..660a1c554f4 100644
--- a/vortex-cuda/kernels/src/fastlanes_common.cuh
+++ b/vortex-cuda/kernels/src/fastlanes_common.cuh
@@ -12,4 +12,4 @@ __constant__ int FL_ORDER[] = {0, 4, 2, 6, 1, 5, 3, 7};
 #define INDEX(row, lane) (FL_ORDER[row / 8] * 16 + (row % 8) * 128 + lane)
 
 // Create a mask with 'width' bits set
-#define MASK(T, width) (((T)1 << width) - 1)
+#define MASK(T, width) (((T)1 << width) - 1)
\ No newline at end of file
diff --git a/vortex-cuda/kernels/src/patches.cuh b/vortex-cuda/kernels/src/patches.cuh
new file mode 100644
index 00000000000..24b1705164f
--- /dev/null
+++ b/vortex-cuda/kernels/src/patches.cuh
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#pragma once
+
+#include "patches.h"
+
+/// A single patch: a within-chunk index and its replacement value.
+/// A sentinel patch has index == 1024, which can never match a valid
+/// within-chunk position (0–1023).
+template <typename T>
+struct Patch {
+    uint16_t index;
+    T value;
+};
+
+/// Cursor for iterating over a single lane's patches within a chunk.
+///
+/// Usage in the generated merge-loop:
+///
+///     PatchesCursor<uint32_t> cursor(patches, blockIdx.x, thread_idx, 32);
+///     auto patch = cursor.next();
+///     for (int i = 0; i < 32; i++) {
+///         auto idx = i * 32 + thread_idx;
+///         if (idx == patch.index) {
+///             out[idx] = patch.value;
+///             patch = cursor.next();
+///         } else {
+///             out[idx] = shared_out[idx];
+///         }
+///     }
+template <typename T>
+class PatchesCursor {
+public:
+    /// Construct a cursor positioned at the patches for the given (chunk, lane).
+    /// n_lanes is a compile-time constant emitted by the code generator (16 or 32).
+    __device__ PatchesCursor(const GPUPatches &patches, uint32_t chunk, uint32_t lane, uint32_t n_lanes) {
+        if (patches.lane_offsets == nullptr) {
+            indices = nullptr;
+            values = nullptr;
+            remaining = 0;
+            return;
+        }
+        auto slot = chunk * n_lanes + lane;
+        auto start = patches.lane_offsets[slot];
+        remaining = patches.lane_offsets[slot + 1] - start;
+        indices = patches.indices + start;
+        values = reinterpret_cast<const T *>(patches.values) + start;
+    }
+
+    /// Return the current patch and advance, or a sentinel {1024, 0} if exhausted.
+    __device__ Patch<T> next() {
+        if (remaining == 0) {
+            return {1024, T {}};
+        }
+        Patch<T> patch = {*indices, *values};
+        indices++;
+        values++;
+        remaining--;
+        return patch;
+    }
+
+private:
+    const uint16_t *indices;
+    const T *values;
+    uint8_t remaining;
+};
\ No newline at end of file
diff --git a/vortex-cuda/kernels/src/patches.h b/vortex-cuda/kernels/src/patches.h
new file mode 100644
index 00000000000..acc628ae595
--- /dev/null
+++ b/vortex-cuda/kernels/src/patches.h
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// GPU-resident patches for fused exception patching during bit-unpacking.
+///
+/// Patches are stored in a lane-wise transposed layout: for each (chunk, lane) pair,
+/// the corresponding patch indices and values are stored contiguously. The lane_offsets
+/// array is a CSR-style offset array of size (n_chunks * n_lanes + 1) that maps each
+/// (chunk, lane) slot to its range in the indices and values arrays.
+///
+/// A NULL lane_offsets pointer indicates no patches are present.
+typedef struct {
+    uint32_t *lane_offsets;
+    uint16_t *indices;
+    void *values;
+} GPUPatches;
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/vortex-cuda/macros/src/lib.rs b/vortex-cuda/macros/src/lib.rs
index afe26bfc99e..722664db915 100644
--- a/vortex-cuda/macros/src/lib.rs
+++ b/vortex-cuda/macros/src/lib.rs
@@ -18,10 +18,10 @@
 //! #[cuda_not_available]
 //! fn fallback_function() { /* ... */ }
 //!
-//! // Only compiled in test builds when CUDA is available
-//! #[cuda_test]
-//! mod tests {
-//!     // ...
+//! // Ignore tests when CUDA is not available
+//! #[crate::test]
+//! async fn my_test() {
+//! ...
 //! }
 //! ```
 
@@ -30,7 +30,6 @@ use std::sync::LazyLock;
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::Item;
 use syn::parse_macro_input;
 
 /// Cached result of nvcc availability check.
@@ -61,17 +60,39 @@ pub fn cuda_not_available(_attr: TokenStream, item: TokenStream) -> TokenStream
     }
 }
 
-/// Conditionally compiles the annotated item only in test builds when CUDA is available.
+/// Test attribute to ignore tests if CUDA isn't available. Supports both sync and async tests (using tokio).
+///
+/// Must be named `test` to work with frameworks like `rstest`.
 #[proc_macro_attribute]
-pub fn cuda_tests(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub fn test(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(item as syn::ItemFn);
     if *NVCC_AVAILABLE {
-        let item = parse_macro_input!(item as Item);
-        quote! {
-            #[cfg(test)]
-            #item
+        if item.sig.asyncness.is_some() {
+            quote! {
+                #[tokio::test]
+                #item
+            }
+        } else {
+            quote! {
+                #[test]
+                #item
+            }
         }
         .into()
     } else {
-        TokenStream::new()
+        if item.sig.asyncness.is_some() {
+            quote! {
+                #[tokio::test]
+                #[ignore]
+                #item
+            }
+        } else {
+            quote! {
+                #[test]
+                #[ignore]
+                #item
+            }
+        }
+        .into()
     }
 }
diff --git a/vortex-cuda/nvcomp/src/lib.rs b/vortex-cuda/nvcomp/src/lib.rs
index 650f06069ff..2f9fd00deb9 100644
--- a/vortex-cuda/nvcomp/src/lib.rs
+++ b/vortex-cuda/nvcomp/src/lib.rs
@@ -35,7 +35,6 @@ mod error;
 pub mod zstd;
 
 pub use error::NvcompError;
-use vortex_cuda_macros::cuda_tests;
 
 /// The loaded nvcomp library instance.
 static NVCOMP_LIB: OnceLock<Result<sys::NvcompLibrary, String>> = OnceLock::new();
@@ -66,13 +65,12 @@ pub fn nvcomp_library() -> Result<&'static sys::NvcompLibrary, NvcompError> {
         .as_ref()
         .map_err(|e| NvcompError::LibraryLoadError(e.clone()))
 }
-
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use crate::zstd;
 
     /// Test that we can call nvcompBatchedZstdDecompressGetTempSizeAsync.
-    #[test]
+    #[vortex_cuda_macros::test]
     fn test_get_decompress_temp_size() {
         let num_chunks = 10;
         let max_uncompressed_chunk_bytes = 65536; // 64KB recommended chunk size
diff --git a/vortex-cuda/src/arrow/canonical.rs b/vortex-cuda/src/arrow/canonical.rs
index 3a6d0b3d666..660c2872259 100644
--- a/vortex-cuda/src/arrow/canonical.rs
+++ b/vortex-cuda/src/arrow/canonical.rs
@@ -6,19 +6,18 @@ use futures::future::BoxFuture;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::ToCanonical;
-use vortex::array::arrays::BoolArrayParts;
-use vortex::array::arrays::DecimalArrayParts;
-use vortex::array::arrays::PrimitiveArrayParts;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::StructArrayParts;
+use vortex::array::arrays::bool::BoolDataParts;
+use vortex::array::arrays::decimal::DecimalDataParts;
+use vortex::array::arrays::extension::ExtensionArrayExt;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::array::arrays::struct_::StructDataParts;
 use vortex::array::buffer::BufferHandle;
-use vortex::array::vtable::ValidityHelper;
 use vortex::dtype::DecimalType;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_ensure;
 use vortex::extension::datetime::AnyTemporal;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaExecutionCtx;
 use crate::arrow::ArrowArray;
@@ -68,9 +67,9 @@ fn export_canonical(
             Canonical::Struct(struct_array) => export_struct(struct_array, ctx).await,
             Canonical::Primitive(primitive) => {
                 let len = primitive.len();
-                let PrimitiveArrayParts {
+                let PrimitiveDataParts {
                     buffer, validity, ..
-                } = primitive.into_parts();
+                } = primitive.into_data_parts();
 
                 check_validity_empty(&validity)?;
 
@@ -92,12 +91,12 @@ fn export_canonical(
             }
             Canonical::Decimal(decimal) => {
                 let len = decimal.len();
-                let DecimalArrayParts {
+                let DecimalDataParts {
                     values,
                     values_type,
                     validity,
                     ..
-                } = decimal.into_parts();
+                } = decimal.into_data_parts();
 
                 // verify that there is no null buffer
                 check_validity_empty(&validity)?;
@@ -117,12 +116,12 @@ fn export_canonical(
                     vortex_bail!("only support temporal extension types currently");
                 }
 
-                let values = extension.storage().to_primitive();
+                let values = extension.storage_array().to_primitive();
                 let len = extension.len();
 
-                let PrimitiveArrayParts {
+                let PrimitiveDataParts {
                     buffer, validity, ..
-                } = values.into_parts();
+                } = values.into_data_parts();
 
                 check_validity_empty(&validity)?;
 
@@ -130,13 +129,11 @@ fn export_canonical(
                 export_fixed_size(buffer, len, 0, ctx)
             }
             Canonical::Bool(bool_array) => {
-                let BoolArrayParts {
-                    bits,
-                    offset,
-                    len,
-                    validity,
-                    ..
-                } = bool_array.into_parts();
+                let len = bool_array.len();
+                let validity = bool_array.validity()?;
+                let BoolDataParts {
+                    bits, offset, len, ..
+                } = bool_array.into_data().into_parts(len);
 
                 check_validity_empty(&validity)?;
 
@@ -144,7 +141,7 @@ fn export_canonical(
             }
             Canonical::VarBinView(varbinview) => {
                 let len = varbinview.len();
-                check_validity_empty(varbinview.validity())?;
+                check_validity_empty(&varbinview.validity()?)?;
 
                 let BinaryParts { offsets, bytes } =
                     copy_varbinview_to_varbin(varbinview, ctx).await?;
@@ -184,9 +181,9 @@ async fn export_struct(
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<(ArrowArray, SyncEvent)> {
     let len = array.len();
-    let StructArrayParts {
+    let StructDataParts {
         validity, fields, ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     check_validity_empty(&validity)?;
 
@@ -267,7 +264,6 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
             for child in children {
                 release_array(child);
             }
-            drop(private_data);
         }
 
         // update the release function to NULL to avoid any possibility of double-frees.
@@ -275,8 +271,7 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
     }
 }
 
-#[cuda_tests]
-#[allow(clippy::unwrap_used)]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -308,7 +303,7 @@ mod tests {
     #[case::i64(PrimitiveArray::from_iter(0i64..10).into_array(), 10)]
     #[case::f32(PrimitiveArray::from_iter([1.0f32, 2.0, 3.0]).into_array(), 3)]
     #[case::f64(PrimitiveArray::from_iter([1.0f64, 2.0, 3.0]).into_array(), 3)]
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_primitive(
         #[case] array: vortex::array::ArrayRef,
         #[case] expected_len: i64,
@@ -330,7 +325,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_null() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -346,7 +341,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_decimal() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -365,7 +360,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_temporal() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -388,7 +383,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_varbinview() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -413,7 +408,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_export_struct() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
diff --git a/vortex-cuda/src/arrow/mod.rs b/vortex-cuda/src/arrow/mod.rs
index 1fd35298ce5..27533a986dd 100644
--- a/vortex-cuda/src/arrow/mod.rs
+++ b/vortex-cuda/src/arrow/mod.rs
@@ -22,7 +22,6 @@ use cudarc::driver::CudaEvent;
 use cudarc::driver::CudaStream;
 use cudarc::driver::sys;
 use cudarc::runtime::sys::cudaEvent_t;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::validity::Validity;
@@ -182,7 +181,7 @@ impl PrivateData {
 }
 
 #[async_trait]
-pub trait DeviceArrayExt: Array {
+pub trait DeviceArrayExt {
     async fn export_device_array(
         self,
         ctx: &mut CudaExecutionCtx,
diff --git a/vortex-cuda/src/arrow/varbinview.rs b/vortex-cuda/src/arrow/varbinview.rs
index 6f5ce0e770f..c000d44908c 100644
--- a/vortex-cuda/src/arrow/varbinview.rs
+++ b/vortex-cuda/src/arrow/varbinview.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 use cudarc::driver::LaunchConfig;
 use cudarc::driver::PushKernelArg;
 use vortex::array::arrays::VarBinViewArray;
-use vortex::array::arrays::VarBinViewArrayParts;
+use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
@@ -33,12 +33,12 @@ pub(crate) async fn copy_varbinview_to_varbin(
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<BinaryParts> {
     let len = array.len();
-    let VarBinViewArrayParts {
+    let VarBinViewDataParts {
         views,
         buffers,
         validity,
         ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     // TODO(aduffy): handle nulls
     check_validity_empty(&validity)?;
diff --git a/vortex-cuda/src/bit_unpack_gen.rs b/vortex-cuda/src/bit_unpack_gen.rs
new file mode 100644
index 00000000000..e4efa9bf2eb
--- /dev/null
+++ b/vortex-cuda/src/bit_unpack_gen.rs
@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::io;
+use std::io::Write;
+
+use fastlanes::FastLanes;
+
+/// Emit the per-row bit extraction for a single row of a general-case lane decoder.
+fn write_row(output: &mut impl Write, bits: usize, bit_width: usize, row: usize) -> io::Result<()> {
+    let curr_word = (row * bit_width) / bits;
+    let next_word = ((row + 1) * bit_width) / bits;
+    let shift = (row * bit_width) % bits;
+
+    if next_word > curr_word {
+        let remaining_bits = ((row + 1) * bit_width) % bits;
+        let current_bits = bit_width - remaining_bits;
+        if next_word < bit_width {
+            write!(
+                output,
+                r#"    tmp = (src >> {shift}) & MASK(uint{bits}_t, {current_bits});
+    src = in[lane + LANE_COUNT * {next_word}];
+    tmp |= (src & MASK(uint{bits}_t, {remaining_bits})) << {current_bits};
+    out[INDEX({row}, lane)] = tmp + reference;
+"#
+            )
+        } else {
+            write!(
+                output,
+                r#"    tmp = (src >> {shift}) & MASK(uint{bits}_t, {current_bits});
+    out[INDEX({row}, lane)] = tmp + reference;
+"#
+            )
+        }
+    } else {
+        write!(
+            output,
+            r#"    tmp = (src >> {shift}) & MASK(uint{bits}_t, {bit_width});
+    out[INDEX({row}, lane)] = tmp + reference;
+"#
+        )
+    }
+}
+
+/// Emit a single lane-decoder template specialization.
+///
+/// For `bit_width == 0` and `bit_width == bits`, emits a simple `#pragma unroll`
+/// loop.  For all other bit widths, emits pre-computed per-row bit extraction
+/// with register-cached `src` words — identical to the original hand-unrolled
+/// codegen, preserving minimal memory loads and zero extra work.
+fn generate_lane_decoder(
+    output: &mut impl Write,
+    bits: usize,
+    lanes: usize,
+    bit_width: usize,
+) -> io::Result<()> {
+    if bit_width == 0 {
+        write!(
+            output,
+            r#"template <>
+__device__ void _bit_unpack_{bits}_lane<0>(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, unsigned int lane) {{
+    #pragma unroll
+    for (int row = 0; row < {bits}; row++) {{
+        out[INDEX(row, lane)] = reference;
+    }}
+}}
+"#
+        )
+    } else if bit_width == bits {
+        write!(
+            output,
+            r#"template <>
+__device__ void _bit_unpack_{bits}_lane<{bit_width}>(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, unsigned int lane) {{
+    unsigned int LANE_COUNT = {lanes};
+    #pragma unroll
+    for (int row = 0; row < {bits}; row++) {{
+        out[INDEX(row, lane)] = in[LANE_COUNT * row + lane] + reference;
+    }}
+}}
+"#
+        )
+    } else {
+        write!(
+            output,
+            r#"template <>
+__device__ void _bit_unpack_{bits}_lane<{bit_width}>(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, unsigned int lane) {{
+    unsigned int LANE_COUNT = {lanes};
+    uint{bits}_t src;
+    uint{bits}_t tmp;
+    src = in[lane];
+"#
+        )?;
+
+        for row in 0..bits {
+            write_row(output, bits, bit_width, row)?;
+        }
+
+        writeln!(output, "}}")
+    }
+}
+
+/// Generate a runtime dispatch function that routes to the appropriate
+/// lane-decoder template specialization via a switch statement.
+///
+/// This is used by `dynamic_dispatch.cu` (via `bit_unpack.cuh`) where the
+/// bit width is only known at runtime.
+fn generate_lane_dispatch(output: &mut impl Write, bits: usize) -> io::Result<()> {
+    write!(
+        output,
+        r#"/// Runtime dispatch to the optimized lane decoder for the given bit width.
+__device__ inline void bit_unpack_{bits}_lane(
+    const uint{bits}_t *__restrict in,
+    uint{bits}_t *__restrict out,
+    uint{bits}_t reference,
+    unsigned int lane,
+    uint32_t bit_width
+) {{
+    switch (bit_width) {{
+"#
+    )?;
+
+    for bw in 0..=bits {
+        writeln!(
+            output,
+            "        case {bw}: _bit_unpack_{bits}_lane<{bw}>(in, out, reference, lane); break;"
+        )?;
+    }
+
+    write!(
+        output,
+        r#"    }}
+}}
+"#
+    )
+}
+
+/// Emit the device kernel as a single template parameterized on bit width.
+///
+/// This is written once per element type rather than duplicated for every
+/// bit width — the compiler instantiates it for each `BW` used by the
+/// `extern "C"` global-kernel wrappers below.
+fn generate_device_kernel_template(
+    output: &mut impl Write,
+    bits: usize,
+    lanes: usize,
+    thread_count: usize,
+) -> io::Result<()> {
+    let per_thread_loop_count = lanes / thread_count;
+    let shared_copy_ncount = 1024 / thread_count;
+
+    write!(
+        output,
+        r#"template <int BW>
+__device__ void _bit_unpack_{bits}_device(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, int thread_idx, GPUPatches& patches) {{
+    __shared__ uint{bits}_t shared_out[1024];
+    #pragma unroll
+    for (int i = 0; i < {per_thread_loop_count}; i++) {{
+        _bit_unpack_{bits}_lane<BW>(in, shared_out, reference, thread_idx * {per_thread_loop_count} + i);
+    }}
+    __syncwarp();
+    PatchesCursor<uint{bits}_t> cursor(patches, blockIdx.x, thread_idx, {thread_count});
+    auto patch = cursor.next();
+    for (int i = 0; i < {shared_copy_ncount}; i++) {{
+        auto idx = i * {thread_count} + thread_idx;
+        if (idx == patch.index) {{
+            out[idx] = patch.value;
+            patch = cursor.next();
+        }} else {{
+            out[idx] = shared_out[idx];
+        }}
+    }}
+}}
+"#
+    )
+}
+
+/// Emit a thin `extern "C"` global-kernel wrapper for a single bit width.
+fn generate_global_kernel(
+    output: &mut impl Write,
+    bits: usize,
+    bit_width: usize,
+    thread_count: usize,
+) -> io::Result<()> {
+    let func_name = format!("bit_unpack_{bits}_{bit_width}bw_{thread_count}t");
+
+    write!(
+        output,
+        r#"extern "C" __global__ void {func_name}(const uint{bits}_t *__restrict full_in, uint{bits}_t *__restrict full_out, uint{bits}_t reference, GPUPatches patches) {{
+    int thread_idx = threadIdx.x;
+    auto in = full_in + (blockIdx.x * (128 * {bit_width} / sizeof(uint{bits}_t)));
+    auto out = full_out + (blockIdx.x * 1024);
+    _bit_unpack_{bits}_device<{bit_width}>(in, out, reference, thread_idx, patches);
+}}
+"#
+    )
+}
+
+/// Generate CUDA lane decoders, dispatch function, and kernel wrappers for all bit widths.
+pub fn generate_cuda_unpack<T: FastLanes>(
+    output: &mut impl Write,
+    thread_count: usize,
+) -> io::Result<()> {
+    let bits = T::T;
+    let lanes = T::LANES;
+
+    // File header + forward declaration for the lane-decoder template.
+    write!(
+        output,
+        r#"// AUTO-GENERATED. Do not edit by hand!
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <stdint.h>
+#include "fastlanes_common.cuh"
+#include "patches.cuh"
+
+template <int BW>
+__device__ void _bit_unpack_{bits}_lane(const uint{bits}_t *__restrict in, uint{bits}_t *__restrict out, uint{bits}_t reference, unsigned int lane);
+
+"#
+    )?;
+
+    // Lane-decoder template specializations (one per bit width).
+    for bit_width in 0..=bits {
+        generate_lane_decoder(output, bits, lanes, bit_width)?;
+        writeln!(output)?;
+    }
+
+    // Runtime dispatch function (used by dynamic_dispatch.cu via bit_unpack.cuh).
+    generate_lane_dispatch(output, bits)?;
+    writeln!(output)?;
+
+    // Device kernel template (written once, instantiated per bit width).
+    generate_device_kernel_template(output, bits, lanes, thread_count)?;
+    writeln!(output)?;
+
+    // Thin extern "C" global-kernel wrappers (one per bit width).
+    for bit_width in 0..=bits {
+        generate_global_kernel(output, bits, bit_width, thread_count)?;
+        writeln!(output)?;
+    }
+
+    Ok(())
+}
diff --git a/vortex-cuda/src/canonical.rs b/vortex-cuda/src/canonical.rs
index 3d82770b039..cde3841e196 100644
--- a/vortex-cuda/src/canonical.rs
+++ b/vortex-cuda/src/canonical.rs
@@ -5,21 +5,21 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use futures::future::try_join_all;
-use vortex::array::Array;
 use vortex::array::Canonical;
 use vortex::array::IntoArray;
-use vortex::array::arrays::BinaryView;
 use vortex::array::arrays::BoolArray;
-use vortex::array::arrays::BoolArrayParts;
 use vortex::array::arrays::DecimalArray;
-use vortex::array::arrays::DecimalArrayParts;
 use vortex::array::arrays::ExtensionArray;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::StructArrayParts;
 use vortex::array::arrays::VarBinViewArray;
-use vortex::array::arrays::VarBinViewArrayParts;
+use vortex::array::arrays::bool::BoolDataParts;
+use vortex::array::arrays::decimal::DecimalDataParts;
+use vortex::array::arrays::extension::ExtensionArrayExt;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::array::arrays::struct_::StructDataParts;
+use vortex::array::arrays::varbinview::BinaryView;
+use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::buffer::BitBuffer;
 use vortex::buffer::Buffer;
@@ -41,12 +41,12 @@ impl CanonicalCudaExt for Canonical {
             Canonical::Struct(struct_array) => {
                 // Children should all be canonical now
                 let len = struct_array.len();
-                let StructArrayParts {
+                let StructDataParts {
                     fields,
                     struct_fields,
                     validity,
                     ..
-                } = struct_array.into_parts();
+                } = struct_array.into_data_parts();
 
                 let mut host_fields = vec![];
                 for field in fields.iter() {
@@ -64,24 +64,22 @@ impl CanonicalCudaExt for Canonical {
             Canonical::Bool(bool) => {
                 // NOTE: update to copy to host when adding buffer handle.
                 // Also update other method to copy validity to host.
-                let BoolArrayParts {
-                    bits,
-                    validity,
-                    offset,
-                    len,
-                    ..
-                } = bool.into_parts();
+                let len = bool.len();
+                let validity = bool.validity()?;
+                let BoolDataParts {
+                    bits, offset, len, ..
+                } = bool.into_data().into_parts(len);
 
                 let bits = BitBuffer::new_with_offset(bits.try_into_host()?.await?, offset, len);
                 Ok(Canonical::Bool(BoolArray::new(bits, validity)))
             }
             Canonical::Primitive(prim) => {
-                let PrimitiveArrayParts {
+                let PrimitiveDataParts {
                     ptype,
                     buffer,
                     validity,
                     ..
-                } = prim.into_parts();
+                } = prim.into_data_parts();
                 Ok(Canonical::Primitive(PrimitiveArray::from_byte_buffer(
                     buffer.try_into_host()?.await?,
                     ptype,
@@ -89,13 +87,13 @@ impl CanonicalCudaExt for Canonical {
                 )))
             }
             Canonical::Decimal(decimal) => {
-                let DecimalArrayParts {
+                let DecimalDataParts {
                     decimal_dtype,
                     values,
                     values_type,
                     validity,
                     ..
-                } = decimal.into_parts();
+                } = decimal.into_data_parts();
                 Ok(Canonical::Decimal(unsafe {
                     DecimalArray::new_unchecked_handle(
                         BufferHandle::new_host(values.try_into_host()?.await?),
@@ -106,12 +104,12 @@ impl CanonicalCudaExt for Canonical {
                 }))
             }
             Canonical::VarBinView(varbinview) => {
-                let VarBinViewArrayParts {
+                let VarBinViewDataParts {
                     views,
                     buffers,
                     validity,
                     dtype,
-                } = varbinview.into_parts();
+                } = varbinview.into_data_parts();
 
                 // Copy all device views to host
                 let host_views = views.try_into_host()?.await?;
@@ -133,7 +131,7 @@ impl CanonicalCudaExt for Canonical {
             Canonical::Extension(ext) => {
                 // Copy the storage array to host and rewrap in ExtensionArray.
                 let host_storage = ext
-                    .storage()
+                    .storage_array()
                     .to_canonical()?
                     .into_host()
                     .await?
diff --git a/vortex-cuda/src/device_buffer.rs b/vortex-cuda/src/device_buffer.rs
index 17bcd44f5d4..3257318cde4 100644
--- a/vortex-cuda/src/device_buffer.rs
+++ b/vortex-cuda/src/device_buffer.rs
@@ -81,8 +81,6 @@ mod private {
     }
 }
 
-// Get it back out as a View of u8
-
 impl CudaDeviceBuffer {
     /// Creates a new CUDA device buffer from a [`CudaSlice<T>`].
     ///
@@ -101,6 +99,16 @@ impl CudaDeviceBuffer {
         }
     }
 
+    /// Returns the byte offset within the allocated buffer.
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Returns the adjusted device pointer accounting for the offset.
+    pub fn offset_ptr(&self) -> sys::CUdeviceptr {
+        self.device_ptr + self.offset as u64
+    }
+
     /// Returns a [`CudaView`] to the CUDA device buffer.
     pub fn as_view<T: DeviceRepr + 'static>(&self) -> CudaView<'_, T> {
         // Return a new &[T]
@@ -159,7 +167,7 @@ impl CudaBufferExt for BufferHandle {
             .as_any()
             .downcast_ref::<CudaDeviceBuffer>()
             .ok_or_else(|| vortex_err!("expected CudaDeviceBuffer"))?
-            .device_ptr;
+            .offset_ptr();
 
         Ok(ptr)
     }
@@ -281,7 +289,7 @@ impl DeviceBuffer for CudaDeviceBuffer {
 
     /// Slices the CUDA device buffer to a subrange.
     ///
-    /// **IMPORTANT**: this is a byte range, not elements range, due to the DeviceBuffer interface.
+    /// This is a byte range, not elements range, due to the DeviceBuffer interface.
     fn slice(&self, range: Range<usize>) -> Arc<dyn DeviceBuffer> {
         assert!(
             range.end <= self.len,
@@ -322,7 +330,7 @@ impl DeviceBuffer for CudaDeviceBuffer {
         let effective_ptr = self.device_ptr + self.offset as u64;
         if effective_ptr.is_multiple_of(*alignment as u64) {
             Ok(Arc::new(CudaDeviceBuffer {
-                allocation: self.allocation.clone(),
+                allocation: Arc::clone(&self.allocation),
                 offset: self.offset,
                 len: self.len,
                 device_ptr: self.device_ptr,
diff --git a/vortex-cuda/src/dynamic_dispatch/mod.rs b/vortex-cuda/src/dynamic_dispatch/mod.rs
index 45e2462b29e..192438d0329 100644
--- a/vortex-cuda/src/dynamic_dispatch/mod.rs
+++ b/vortex-cuda/src/dynamic_dispatch/mod.rs
@@ -3,40 +3,309 @@
 
 //! Host interface for dynamic CUDA kernel dispatch.
 //!
-//! A [`DynamicDispatchPlan`] is a linear sequence of stages produced by
-//! [`build_plan`], which walks an encoding tree (e.g., `ALP(FoR(BitPacked))`)
-//! and flattens it into input stages followed by a single output stage.
+//! [`DispatchPlan::new`] walks an encoding tree (e.g., `ALP(FoR(BitPacked))`)
+//! in a single pass and returns one of three variants:
 //!
-//! Input stages write intermediate results (dictionary values, run-end
-//! endpoints) into bump-allocated shared memory regions. The output stage
-//! references those regions and writes final results to global memory.
-//!
-//! Shared memory is dynamically sized at launch time via
-//! [`DynamicDispatchPlan::shared_mem_bytes`].
+//! - [`Fused`](DispatchPlan::Fused) — call [`FusedPlan::materialize`].
+//! - [`PartiallyFused`](DispatchPlan::PartiallyFused) — execute pending
+//!   subtrees, then call [`FusedPlan::materialize_with_subtrees`].
+//! - [`Unfused`](DispatchPlan::Unfused) — fall back to single-kernel dispatch.
 
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 #![allow(clippy::cast_possible_truncation)]
 
-use vortex_cuda_macros::cuda_tests;
-
-mod plan_builder;
-pub use plan_builder::build_plan;
+use std::borrow::Borrow;
+use std::mem::size_of;
+use std::sync::Arc;
+
+use cudarc::driver::DevicePtr;
+use cudarc::driver::LaunchConfig;
+use cudarc::driver::PushKernelArg;
+use vortex::array::Canonical;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::buffer::DeviceBufferExt;
+use vortex::array::match_each_unsigned_integer_ptype;
+use vortex::array::validity::Validity;
+use vortex::buffer::Alignment;
+use vortex::buffer::ByteBuffer;
+use vortex::buffer::ByteBufferMut;
+use vortex::dtype::Nullability;
+use vortex::dtype::PType;
+use vortex::error::VortexResult;
+use vortex::error::vortex_bail;
+use vortex::error::vortex_err;
+
+use crate::CudaDeviceBuffer;
+use crate::executor::CudaExecutionCtx;
+
+pub(crate) mod plan_builder;
+pub use plan_builder::DispatchPlan;
+pub use plan_builder::FusedPlan;
+pub use plan_builder::MaterializedPlan;
 
 include!(concat!(env!("OUT_DIR"), "/dynamic_dispatch.rs"));
 
-// SAFETY: C ABI structs with contiguous memory.
-unsafe impl cudarc::driver::DeviceRepr for DynamicDispatchPlan {}
-unsafe impl cudarc::driver::DeviceRepr for Stage {}
+/// Convert a Rust `PType` to the C `PTypeTag` constant.
+pub fn ptype_to_tag(ptype: PType) -> PTypeTag {
+    match ptype {
+        PType::U8 => PTypeTag_PTYPE_U8,
+        PType::U16 => PTypeTag_PTYPE_U16,
+        PType::U32 => PTypeTag_PTYPE_U32,
+        PType::U64 => PTypeTag_PTYPE_U64,
+        PType::I8 => PTypeTag_PTYPE_I8,
+        PType::I16 => PTypeTag_PTYPE_I16,
+        PType::I32 => PTypeTag_PTYPE_I32,
+        PType::I64 => PTypeTag_PTYPE_I64,
+        PType::F16 => unreachable!("F16 is not supported by CUDA dynamic dispatch"),
+        PType::F32 => PTypeTag_PTYPE_F32,
+        PType::F64 => PTypeTag_PTYPE_F64,
+    }
+}
+
+/// Convert a C `PTypeTag` back to a Rust `PType`.
+pub fn tag_to_ptype(tag: PTypeTag) -> PType {
+    match tag {
+        PTypeTag_PTYPE_U8 => PType::U8,
+        PTypeTag_PTYPE_U16 => PType::U16,
+        PTypeTag_PTYPE_U32 => PType::U32,
+        PTypeTag_PTYPE_U64 => PType::U64,
+        PTypeTag_PTYPE_I8 => PType::I8,
+        PTypeTag_PTYPE_I16 => PType::I16,
+        PTypeTag_PTYPE_I32 => PType::I32,
+        PTypeTag_PTYPE_I64 => PType::I64,
+        PTypeTag_PTYPE_F32 => PType::F32,
+        PTypeTag_PTYPE_F64 => PType::F64,
+        _ => unreachable!("unknown PTypeTag {tag}"),
+    }
+}
+
+/// Serialize a `#[repr(C)]` struct to a byte vector for the packed plan.
+///
+/// Copies field data into a pre-zeroed buffer so padding holes are
+/// deterministically zero, avoiding UB from reading uninitialised bytes.
+fn as_bytes<T: Sized>(val: &T) -> Vec<u8> {
+    let n = size_of::<T>();
+    let mut buf = vec![0u8; n];
+    // SAFETY: T is a bindgen-generated #[repr(C)] struct with only
+    // integer/float/enum fields. We overwrite the zeroed buffer with
+    // the struct's bytes; padding holes keep their zero value.
+    unsafe {
+        std::ptr::copy_nonoverlapping(std::ptr::addr_of!(*val).cast::<u8>(), buf.as_mut_ptr(), n);
+    }
+    buf
+}
+
+/// A stage used to build a [`CudaDispatchPlan`] on the host side.
+///
+/// This is NOT a C ABI struct — it exists purely on the Rust side and is
+/// serialized into the packed plan byte buffer by [`CudaDispatchPlan::new`].
+#[derive(Clone)]
+pub struct MaterializedStage {
+    /// Device pointer to the input buffer for this stage.
+    pub input_ptr: u64,
+    /// Byte offset into shared memory where this stage's data is stored.
+    pub smem_byte_offset: u32,
+    /// Number of elements in this stage.
+    pub len: u32,
+    /// PType tag for the source op's output type.
+    pub source_ptype: PTypeTag,
+    /// The source operation that produces the initial values (e.g. load, bitunpack, sequence).
+    pub source: SourceOp,
+    /// Chain of element-wise scalar operations applied after the source (e.g. frame-of-reference, zigzag, ALP).
+    pub scalar_ops: Vec<ScalarOp>,
+}
+
+impl MaterializedStage {
+    pub fn new(
+        input_ptr: u64,
+        smem_byte_offset: u32,
+        len: u32,
+        source_ptype: PTypeTag,
+        source: SourceOp,
+        scalar_ops: &[ScalarOp],
+    ) -> Self {
+        Self {
+            input_ptr,
+            smem_byte_offset,
+            len,
+            source_ptype,
+            source,
+            scalar_ops: scalar_ops.to_vec(),
+        }
+    }
+}
+
+/// Read-only view of a parsed stage from a [`CudaDispatchPlan`].
+///
+/// Returned by [`CudaDispatchPlan::stage`] for test inspection.
+#[derive(Clone)]
+pub struct ParsedStage {
+    pub input_ptr: u64,
+    pub smem_byte_offset: u32,
+    pub len: u32,
+    pub source_ptype: PTypeTag,
+    pub source: SourceOp,
+    pub num_scalar_ops: u8,
+    pub scalar_ops: Vec<ScalarOp>,
+}
+
+/// A dispatch plan serialized as a packed byte buffer.
+///
+/// Matching the C-side `PlanHeader` + `PackedStage` ABI in `dynamic_dispatch.h`:
+///
+/// ```text
+/// [PlanHeader]                            — sizeof(PlanHeader) bytes
+/// [PackedStage 0][ScalarOp × N0]          — variable
+/// [PackedStage 1][ScalarOp × N1]          — variable
+/// ...
+/// ```
+#[derive(Clone)]
+pub struct CudaDispatchPlan {
+    buffer: ByteBuffer,
+}
+
+impl CudaDispatchPlan {
+    /// Build a packed plan from a sequence of stages.
+    ///
+    /// The last stage is the output pipeline; earlier stages are input stages.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `stages` is empty or the serialized plan exceeds 65535 bytes.
+    pub fn new<I>(stages: I, output_ptype: PTypeTag) -> Self
+    where
+        I: IntoIterator,
+        I::Item: Borrow<MaterializedStage>,
+    {
+        let stages: Vec<MaterializedStage> =
+            stages.into_iter().map(|s| s.borrow().clone()).collect();
+        assert!(!stages.is_empty());
+
+        let header_size = size_of::<PlanHeader>();
+        let stage_header_size = size_of::<PackedStage>();
+        let scalar_op_size = size_of::<ScalarOp>();
+
+        // Calculate total size and validate.
+        let mut total_size = header_size;
+        for stage in &stages {
+            total_size += stage_header_size;
+            total_size += stage.scalar_ops.len() * scalar_op_size;
+        }
+        assert!(
+            total_size <= u16::MAX as usize,
+            "packed plan size {total_size} exceeds u16::MAX"
+        );
+
+        let mut buffer = ByteBufferMut::with_capacity_aligned(total_size, Alignment::of::<u32>());
+
+        let header = PlanHeader {
+            num_stages: stages.len() as u8,
+            output_ptype,
+            plan_size_bytes: total_size as u16,
+        };
+        buffer.extend_from_slice(&as_bytes(&header));
+
+        for stage in &stages {
+            let packed_stage = PackedStage {
+                input_ptr: stage.input_ptr,
+                smem_byte_offset: stage.smem_byte_offset,
+                len: stage.len,
+                source: stage.source,
+                num_scalar_ops: stage.scalar_ops.len() as u8,
+                source_ptype: stage.source_ptype,
+            };
+            buffer.extend_from_slice(&as_bytes(&packed_stage));
+            for op in &stage.scalar_ops {
+                buffer.extend_from_slice(&as_bytes(op));
+            }
+        }
+
+        assert_eq!(buffer.len(), total_size);
+        Self {
+            buffer: buffer.freeze(),
+        }
+    }
+
+    /// The raw packed plan bytes, ready for upload to the device.
+    pub fn as_bytes(&self) -> &[u8] {
+        self.buffer.as_ref()
+    }
+
+    /// Number of stages in the plan.
+    pub fn num_stages(&self) -> u8 {
+        self.header().num_stages
+    }
+
+    /// PType of the final output array.
+    pub fn output_ptype(&self) -> PType {
+        tag_to_ptype(self.header().output_ptype)
+    }
+
+    fn header(&self) -> PlanHeader {
+        unsafe { *self.buffer.as_ptr().cast() }
+    }
+
+    /// Parse and return a read-only view of the stage at `index`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `index >= num_stages()`.
+    pub fn stage(&self, index: usize) -> ParsedStage {
+        let header_size = size_of::<PlanHeader>();
+        let stage_header_size = size_of::<PackedStage>();
+        let scalar_op_size = size_of::<ScalarOp>();
+
+        let mut offset = header_size;
+
+        // Skip past stages before `index`.
+        for _ in 0..index {
+            assert!(offset + stage_header_size <= self.buffer.len());
+            let ps: PackedStage = unsafe { *self.buffer.as_ptr().add(offset).cast() };
+            offset += stage_header_size + ps.num_scalar_ops as usize * scalar_op_size;
+        }
+
+        assert!(offset + stage_header_size <= self.buffer.len());
+        let ps: PackedStage = unsafe { *self.buffer.as_ptr().add(offset).cast() };
+        offset += stage_header_size;
+
+        let mut scalar_ops = Vec::with_capacity(ps.num_scalar_ops as usize);
+        for _ in 0..ps.num_scalar_ops {
+            assert!(offset + scalar_op_size <= self.buffer.len());
+            let op: ScalarOp = unsafe { *self.buffer.as_ptr().add(offset).cast() };
+            scalar_ops.push(op);
+            offset += scalar_op_size;
+        }
+
+        ParsedStage {
+            input_ptr: ps.input_ptr,
+            smem_byte_offset: ps.smem_byte_offset,
+            len: ps.len,
+            source_ptype: ps.source_ptype,
+            source: ps.source,
+            num_scalar_ops: ps.num_scalar_ops,
+            scalar_ops,
+        }
+    }
+}
 
 impl SourceOp {
     /// Unpack bit-packed data using FastLanes layout.
-    pub fn bitunpack(bit_width: u8) -> Self {
+    ///
+    /// `element_offset` (0..1023) is the sub-block position within the first
+    /// FastLanes block. The device pointer already accounts for buffer slicing,
+    /// but sub-block alignment cannot be expressed as pointer arithmetic on
+    /// bit-packed data, so it is passed as a kernel parameter.
+    pub fn bitunpack(bit_width: u8, element_offset: u16) -> Self {
         Self {
             op_code: SourceOp_SourceOpCode_BITUNPACK,
             params: SourceParams {
-                bitunpack: SourceParams_BitunpackParams { bit_width },
+                bitunpack: SourceParams_BitunpackParams {
+                    bit_width,
+                    element_offset: u32::from(element_offset),
+                },
             },
         }
     }
@@ -49,11 +318,17 @@ impl SourceOp {
         }
     }
 
-    /// Decode run-end encoding. Offsets reference shared memory regions
-    /// populated by earlier input stages.
+    /// Decode run-end encoding.
+    ///
+    /// # Arguments
+    ///
+    /// * `ends_smem_byte_offset` - byte offset to decoded ends in smem
+    /// * `values_smem_byte_offset` - byte offset to decoded values in smem
+    /// * `num_runs` - number of runs (length of ends/values)
+    /// * `offset` - logical offset for sliced arrays
     pub fn runend(
-        ends_smem_offset: u32,
-        values_smem_offset: u32,
+        ends_smem_byte_offset: u32,
+        values_smem_byte_offset: u32,
         num_runs: u64,
         offset: u64,
     ) -> Self {
@@ -61,21 +336,33 @@ impl SourceOp {
             op_code: SourceOp_SourceOpCode_RUNEND,
             params: SourceParams {
                 runend: SourceParams_RunEndParams {
-                    ends_smem_offset,
-                    values_smem_offset,
+                    ends_smem_byte_offset,
+                    values_smem_byte_offset,
                     num_runs,
                     offset,
                 },
             },
         }
     }
+
+    /// Generate a linear sequence: `value[i] = base + i * multiplier`.
+    /// Used for SequenceArray (e.g. monotonic run-end endpoints).
+    pub fn sequence(base: i64, multiplier: i64) -> Self {
+        Self {
+            op_code: SourceOp_SourceOpCode_SEQUENCE,
+            params: SourceParams {
+                sequence: SourceParams_SequenceParams { base, multiplier },
+            },
+        }
+    }
 }
 
 impl ScalarOp {
     /// Frame-of-reference: add a constant.
-    pub fn frame_of_ref(reference: u64) -> Self {
+    pub fn frame_of_ref(reference: u64, output_ptype: PTypeTag) -> Self {
         Self {
             op_code: ScalarOp_ScalarOpCode_FOR,
+            output_ptype,
             params: ScalarParams {
                 frame_of_ref: ScalarParams_FoRParams { reference },
             },
@@ -83,10 +370,11 @@ impl ScalarOp {
     }
 
     /// Zigzag decode.
-    pub fn zigzag() -> Self {
+    pub fn zigzag(output_ptype: PTypeTag) -> Self {
         // SAFETY: Zigzag has no parameters; zeroed union is valid.
         Self {
             op_code: ScalarOp_ScalarOpCode_ZIGZAG,
+            output_ptype,
             params: unsafe { std::mem::zeroed() },
         }
     }
@@ -95,6 +383,7 @@ impl ScalarOp {
     pub fn alp(f: f32, e: f32) -> Self {
         Self {
             op_code: ScalarOp_ScalarOpCode_ALP,
+            output_ptype: PTypeTag_PTYPE_F32,
             params: ScalarParams {
                 alp: ScalarParams_AlpParams { f, e },
             },
@@ -103,98 +392,94 @@ impl ScalarOp {
 
     /// Dictionary gather: use current value as index into decoded values
     /// in shared memory (populated by an earlier input stage).
-    pub fn dict(values_smem_offset: u32) -> Self {
+    pub fn dict(values_smem_byte_offset: u32, output_ptype: PTypeTag) -> Self {
         Self {
             op_code: ScalarOp_ScalarOpCode_DICT,
+            output_ptype,
             params: ScalarParams {
-                dict: ScalarParams_DictParams { values_smem_offset },
+                dict: ScalarParams_DictParams {
+                    values_smem_byte_offset,
+                },
             },
         }
     }
 }
 
-impl Stage {
-    /// Create an input stage that decodes an input into a shared memory region.
-    /// The output persists at `smem_offset` for the output stage to reference.
-    pub fn input(
-        input_ptr: u64,
-        smem_offset: u32,
-        len: u32,
-        source: SourceOp,
-        scalar_ops: &[ScalarOp],
-    ) -> Self {
-        assert!(scalar_ops.len() <= MAX_SCALAR_OPS as usize);
-        let mut ops: [ScalarOp; MAX_SCALAR_OPS as usize] = unsafe { std::mem::zeroed() };
-        ops[..scalar_ops.len()].copy_from_slice(scalar_ops);
-        Self {
-            input_ptr,
-            smem_offset,
-            len,
-            source,
-            num_scalar_ops: scalar_ops.len() as u8,
-            scalar_ops: ops,
-        }
-    }
-
-    /// Create the output stage. Uses [`SMEM_TILE_SIZE`] as the shared memory
-    /// region size — the kernel tiles `ELEMENTS_PER_BLOCK` elements through
-    /// this smaller region to reduce shared memory usage.
-    pub fn output(
-        input_ptr: u64,
-        smem_offset: u32,
-        source: SourceOp,
-        scalar_ops: &[ScalarOp],
-    ) -> Self {
-        Self::input(input_ptr, smem_offset, SMEM_TILE_SIZE, source, scalar_ops)
+impl MaterializedPlan {
+    pub fn execute(self, len: usize, ctx: &mut CudaExecutionCtx) -> VortexResult<Canonical> {
+        let output_ptype = self.dispatch_plan.output_ptype();
+        // The CUDA kernels are instantiated for unsigned integer types only;
+        // map signed/float ptypes to their same-width unsigned counterpart.
+        let unsigned_ptype = match output_ptype {
+            PType::U8 | PType::I8 => PType::U8,
+            PType::U16 | PType::I16 => PType::U16,
+            PType::U32 | PType::I32 | PType::F32 => PType::U32,
+            PType::U64 | PType::I64 => PType::U64,
+            other => vortex_bail!("dynamic dispatch does not support PType {:?}", other),
+        };
+        match_each_unsigned_integer_ptype!(unsigned_ptype, |T| {
+            self.execute_typed::<T>(output_ptype, len, ctx)
+        })
     }
-}
 
-impl DynamicDispatchPlan {
-    /// Create a dispatch plan from a sequence of stages.
-    /// The last stage is the output pipeline; earlier stages are input stages.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `stages` is empty or exceeds `MAX_STAGES`.
-    pub fn new(stages: impl AsRef<[Stage]>) -> Self {
-        let stages_slice = stages.as_ref();
-        assert!(!stages_slice.is_empty());
-        assert!(stages_slice.len() <= MAX_STAGES as usize);
-        let mut buf: [Stage; MAX_STAGES as usize] = unsafe { std::mem::zeroed() };
-        buf[..stages_slice.len()].copy_from_slice(stages_slice);
-        Self {
-            num_stages: stages_slice.len() as u8,
-            stages: buf,
+    fn execute_typed<T>(
+        self,
+        output_ptype: PType,
+        len: usize,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<Canonical>
+    where
+        T: cudarc::driver::DeviceRepr + vortex::dtype::NativePType,
+    {
+        if len == 0 {
+            return Ok(Canonical::Primitive(PrimitiveArray::empty::<T>(
+                Nullability::NonNullable,
+            )));
         }
-    }
 
-    /// Compute the dynamic shared memory bytes needed for this plan.
-    ///
-    /// All input stage outputs must remain in shared memory simultaneously
-    /// so the output stage can reference them (e.g., dictionary lookups,
-    /// run-end resolution). The total is `max(smem_offset + len)` across
-    /// all stages, multiplied by the element size.
-    pub fn shared_mem_bytes<T>(&self) -> u32 {
-        let elem_size = size_of::<T>() as u32;
-        let mut max_end: u32 = 0;
-        for i in 0..self.num_stages as usize {
-            let end = self.stages[i].smem_offset + self.stages[i].len;
-            if end > max_end {
-                max_end = end;
-            }
-        }
-        max_end * elem_size
+        let output_buf = CudaDeviceBuffer::new(ctx.device_alloc::<T>(len.next_multiple_of(1024))?);
+
+        // Upload the packed plan bytes to the device.
+        let device_plan = Arc::new(
+            ctx.stream()
+                .clone_htod(self.dispatch_plan.as_bytes())
+                .map_err(|e| vortex_err!("copy plan to device: {e}"))?,
+        );
+
+        let cuda_function = ctx.load_function("dynamic_dispatch", &[T::PTYPE])?;
+        let num_blocks = u32::try_from(len.div_ceil(ELEMENTS_PER_BLOCK as usize))?;
+        let config = LaunchConfig {
+            grid_dim: (num_blocks, 1, 1),
+            block_dim: (BLOCK_SIZE, 1, 1),
+            shared_mem_bytes: self.shared_mem_bytes,
+        };
+
+        let output_ptr = output_buf.offset_ptr();
+        let plan_ptr = device_plan.device_ptr(ctx.stream()).0;
+        let array_len_u64 = len as u64;
+
+        ctx.launch_kernel_config(&cuda_function, config, len, |args| {
+            args.arg(&output_ptr);
+            args.arg(&array_len_u64);
+            args.arg(&plan_ptr);
+        })?;
+
+        Ok(Canonical::Primitive(PrimitiveArray::from_buffer_handle(
+            BufferHandle::new_device(output_buf.slice_typed::<T>(0..len)),
+            output_ptype,
+            Validity::NonNullable,
+        )))
     }
 }
 
-#[cuda_tests]
-#[allow(clippy::cast_possible_truncation)]
+#[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
     use cudarc::driver::DevicePtr;
     use cudarc::driver::LaunchConfig;
     use cudarc::driver::PushKernelArg;
+    use rstest::rstest;
     use vortex::array::IntoArray;
     use vortex::array::ToCanonical;
     use vortex::array::arrays::DictArray;
@@ -202,40 +487,52 @@ mod tests {
     use vortex::array::scalar::Scalar;
     use vortex::array::validity::Validity::NonNullable;
     use vortex::buffer::Buffer;
-    use vortex::encodings::alp::ALPArray;
+    use vortex::dtype::PType;
+    use vortex::encodings::alp::ALP;
+    use vortex::encodings::alp::ALPArrayExt;
+    use vortex::encodings::alp::ALPArraySlotsExt;
     use vortex::encodings::alp::ALPFloat;
     use vortex::encodings::alp::Exponents;
     use vortex::encodings::alp::alp_encode;
+    use vortex::encodings::fastlanes::BitPacked;
     use vortex::encodings::fastlanes::BitPackedArray;
-    use vortex::encodings::fastlanes::FoRArray;
-    use vortex::encodings::runend::RunEndArray;
-    use vortex::encodings::zigzag::ZigZagArray;
+    use vortex::encodings::fastlanes::FoR;
+    use vortex::encodings::fastlanes::FoRArrayExt;
+    use vortex::encodings::runend::RunEnd;
+    use vortex::encodings::zigzag::ZigZag;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
     use vortex::session::VortexSession;
 
-    use super::DynamicDispatchPlan;
-    use super::SMEM_TILE_SIZE;
-    use super::ScalarOp;
-    use super::SourceOp;
-    use super::Stage;
-    use super::build_plan;
+    use super::*;
+    use crate::CanonicalCudaExt;
     use crate::CudaBufferExt;
     use crate::CudaDeviceBuffer;
     use crate::CudaExecutionCtx;
+    use crate::hybrid_dispatch::try_gpu_dispatch;
     use crate::session::CudaSession;
 
-    fn make_bitpacked_array_u32(bit_width: u8, len: usize) -> BitPackedArray {
+    fn bitpacked_array_u32(bit_width: u8, len: usize) -> BitPackedArray {
         let max_val = (1u64 << bit_width).saturating_sub(1);
         let values: Vec<u32> = (0..len)
             .map(|i| ((i as u64) % (max_val + 1)) as u32)
             .collect();
         let primitive = PrimitiveArray::new(Buffer::from(values), NonNullable);
-        BitPackedArray::encode(primitive.as_ref(), bit_width)
+        BitPacked::encode(&primitive.into_array(), bit_width)
             .vortex_expect("failed to create BitPacked array")
     }
 
-    #[test]
+    fn dispatch_plan(
+        array: &vortex::array::ArrayRef,
+        ctx: &CudaExecutionCtx,
+    ) -> VortexResult<MaterializedPlan> {
+        match DispatchPlan::new(array)? {
+            DispatchPlan::Fused(plan) => plan.materialize(ctx),
+            _ => vortex_bail!("array encoding not fusable"),
+        }
+    }
+
+    #[crate::test]
     fn test_max_scalar_ops() -> VortexResult<()> {
         let bit_width: u8 = 6;
         let len = 2050;
@@ -247,7 +544,7 @@ mod tests {
             .map(|i| ((i as u64) % (max_val + 1)) as u32 + total_reference)
             .collect();
 
-        let bitpacked = make_bitpacked_array_u32(bit_width, len);
+        let bitpacked = bitpacked_array_u32(bit_width, len);
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
         let packed = bitpacked.packed().clone();
         let device_input = futures::executor::block_on(cuda_ctx.ensure_on_device(packed))?;
@@ -255,57 +552,76 @@ mod tests {
 
         let scalar_ops: Vec<ScalarOp> = references
             .iter()
-            .map(|&r| ScalarOp::frame_of_ref(r as u64))
+            .map(|&r| ScalarOp::frame_of_ref(r as u64, PTypeTag_PTYPE_U32))
             .collect();
 
-        let plan = DynamicDispatchPlan::new([Stage::output(
-            input_ptr,
-            0,
-            SourceOp::bitunpack(bit_width),
-            &scalar_ops,
-        )]);
-        assert_eq!(plan.stages[0].num_scalar_ops, 4);
+        let plan = CudaDispatchPlan::new(
+            [MaterializedStage::new(
+                input_ptr,
+                0,
+                len as u32,
+                PTypeTag_PTYPE_U32,
+                SourceOp::bitunpack(bit_width, 0),
+                &scalar_ops,
+            )],
+            PTypeTag_PTYPE_U32,
+        );
+        assert_eq!(plan.stage(0).num_scalar_ops, 4);
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan, SMEM_TILE_SIZE * 4)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_plan_structure() {
-        // Stage 0: input dict values (BP→FoR) into smem[0..256)
-        // Stage 1: output codes (BP→FoR→DICT) into smem[256..2304), gather from smem[0]
-        let plan = DynamicDispatchPlan::new([
-            Stage::input(
-                0xAAAA,
-                0,
-                256,
-                SourceOp::bitunpack(4),
-                &[ScalarOp::frame_of_ref(10)],
-            ),
-            Stage::output(
-                0xBBBB,
-                256,
-                SourceOp::bitunpack(6),
-                &[ScalarOp::frame_of_ref(42), ScalarOp::dict(0)],
-            ),
-        ]);
-
-        assert_eq!(plan.num_stages, 2);
+        // Stage 0: input dict values (BP→FoR), 256 u32 elements → smem bytes [0..1024)
+        // Stage 1: output codes (BP→FoR→DICT), 1024 elements, gather from smem byte 0
+        let values_smem_bytes: u32 = 256 * 4; // 256 u32 elements × 4 bytes
+        let plan = CudaDispatchPlan::new(
+            [
+                MaterializedStage::new(
+                    0xAAAA,
+                    0,
+                    256,
+                    PTypeTag_PTYPE_U32,
+                    SourceOp::bitunpack(4, 0),
+                    &[ScalarOp::frame_of_ref(10, PTypeTag_PTYPE_U32)],
+                ),
+                MaterializedStage::new(
+                    0xBBBB,
+                    values_smem_bytes,
+                    1024,
+                    PTypeTag_PTYPE_U32,
+                    SourceOp::bitunpack(6, 0),
+                    &[
+                        ScalarOp::frame_of_ref(42, PTypeTag_PTYPE_U32),
+                        ScalarOp::dict(0, PTypeTag_PTYPE_U32),
+                    ],
+                ),
+            ],
+            PTypeTag_PTYPE_U32,
+        );
+
+        assert_eq!(plan.num_stages(), 2);
 
         // Input stage
-        assert_eq!(plan.stages[0].smem_offset, 0);
-        assert_eq!(plan.stages[0].len, 256);
-        assert_eq!(plan.stages[0].input_ptr, 0xAAAA);
+        let s0 = plan.stage(0);
+        assert_eq!(s0.smem_byte_offset, 0);
+        assert_eq!(s0.len, 256);
+        assert_eq!(s0.source_ptype, PTypeTag_PTYPE_U32);
+        assert_eq!(s0.input_ptr, 0xAAAA);
 
         // Output stage
-        assert_eq!(plan.stages[1].smem_offset, 256);
-        assert_eq!(plan.stages[1].len, SMEM_TILE_SIZE);
-        assert_eq!(plan.stages[1].input_ptr, 0xBBBB);
-        assert_eq!(plan.stages[1].num_scalar_ops, 2);
+        let s1 = plan.stage(1);
+        assert_eq!(s1.smem_byte_offset, values_smem_bytes);
+        assert_eq!(s1.len, SMEM_TILE_SIZE);
+        assert_eq!(s1.source_ptype, PTypeTag_PTYPE_U32);
+        assert_eq!(s1.input_ptr, 0xBBBB);
+        assert_eq!(s1.num_scalar_ops, 2);
         assert_eq!(
-            unsafe { plan.stages[1].scalar_ops[1].params.dict.values_smem_offset },
+            unsafe { s1.scalar_ops[1].params.dict.values_smem_byte_offset },
             0
         );
     }
@@ -320,7 +636,7 @@ mod tests {
         Ok((ptr, device_buf))
     }
 
-    #[test]
+    #[crate::test]
     fn test_load_for_zigzag_alp() -> VortexResult<()> {
         // Max scalar ops depth with LOAD source: LOAD → FoR → ZigZag → ALP
         // (Exercises all four scalar op types without DICT)
@@ -343,18 +659,23 @@ mod tests {
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
         let (input_ptr, _di) = copy_raw_to_device(&cuda_ctx, &data)?;
 
-        let plan = DynamicDispatchPlan::new([Stage::output(
-            input_ptr,
-            0,
-            SourceOp::load(),
-            &[
-                ScalarOp::frame_of_ref(reference as u64),
-                ScalarOp::zigzag(),
-                ScalarOp::alp(alp_f, alp_e),
-            ],
-        )]);
+        let plan = CudaDispatchPlan::new(
+            [MaterializedStage::new(
+                input_ptr,
+                0,
+                len as u32,
+                PTypeTag_PTYPE_U32,
+                SourceOp::load(),
+                &[
+                    ScalarOp::frame_of_ref(reference as u64, PTypeTag_PTYPE_U32),
+                    ScalarOp::zigzag(PTypeTag_PTYPE_U32),
+                    ScalarOp::alp(alp_f, alp_e),
+                ],
+            )],
+            PTypeTag_PTYPE_U32,
+        );
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan, SMEM_TILE_SIZE * 4)?;
         assert_eq!(actual, expected);
 
         Ok(())
@@ -364,10 +685,9 @@ mod tests {
     fn run_dynamic_dispatch_plan(
         cuda_ctx: &CudaExecutionCtx,
         output_len: usize,
-        plan: &DynamicDispatchPlan,
+        plan: &CudaDispatchPlan,
+        shared_mem_bytes: u32,
     ) -> VortexResult<Vec<u32>> {
-        let smem_bytes = plan.shared_mem_bytes::<u32>();
-
         let output_slice = cuda_ctx
             .device_alloc::<u32>(output_len)
             .vortex_expect("alloc output");
@@ -378,7 +698,7 @@ mod tests {
         let device_plan = Arc::new(
             cuda_ctx
                 .stream()
-                .clone_htod(std::slice::from_ref(plan))
+                .clone_htod(plan.as_bytes())
                 .expect("copy plan to device"),
         );
         let (plan_ptr, record_plan) = device_plan.device_ptr(cuda_ctx.stream());
@@ -387,18 +707,18 @@ mod tests {
         cuda_ctx.stream().synchronize().expect("sync");
 
         let cuda_function = cuda_ctx
-            .load_function("dynamic_dispatch", &["u32"])
+            .load_function("dynamic_dispatch", &[PType::U32])
             .vortex_expect("load kernel");
         let mut launch_builder = cuda_ctx.launch_builder(&cuda_function);
         launch_builder.arg(&output_ptr);
         launch_builder.arg(&array_len_u64);
         launch_builder.arg(&plan_ptr);
 
-        let num_blocks = u32::try_from(output_len.div_ceil(2048))?;
+        let num_blocks = u32::try_from(output_len.div_ceil(ELEMENTS_PER_BLOCK as usize))?;
         let config = LaunchConfig {
             grid_dim: (num_blocks, 1, 1),
-            block_dim: (64, 1, 1),
-            shared_mem_bytes: smem_bytes,
+            block_dim: (BLOCK_SIZE, 1, 1),
+            shared_mem_bytes,
         };
         unsafe {
             launch_builder.launch(config).expect("kernel launch");
@@ -414,14 +734,15 @@ mod tests {
     fn run_dispatch_plan_f32(
         cuda_ctx: &CudaExecutionCtx,
         output_len: usize,
-        plan: &DynamicDispatchPlan,
+        plan: &CudaDispatchPlan,
+        shared_mem_bytes: u32,
     ) -> VortexResult<Vec<f32>> {
-        let actual = run_dynamic_dispatch_plan(cuda_ctx, output_len, plan)?;
+        let actual = run_dynamic_dispatch_plan(cuda_ctx, output_len, plan, shared_mem_bytes)?;
         // SAFETY: f32 and u32 have identical size and alignment.
         Ok(unsafe { std::mem::transmute::<Vec<u32>, Vec<f32>>(actual) })
     }
 
-    #[test]
+    #[crate::test]
     fn test_bitpacked() -> VortexResult<()> {
         let bit_width: u8 = 10;
         let len = 3000;
@@ -430,17 +751,18 @@ mod tests {
             .map(|i| ((i as u64) % (max_val + 1)) as u32)
             .collect();
 
-        let bp = make_bitpacked_array_u32(bit_width, len);
+        let bp = bitpacked_array_u32(bit_width, len);
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&bp.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&bp.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_for_bitpacked() -> VortexResult<()> {
         let bit_width: u8 = 6;
         let len = 3000;
@@ -452,19 +774,20 @@ mod tests {
             .collect();
         let expected: Vec<u32> = raw.iter().map(|&v| v + reference).collect();
 
-        let bp = make_bitpacked_array_u32(bit_width, len);
-        let for_arr = FoRArray::try_new(bp.into_array(), Scalar::from(reference))?;
+        let bp = bitpacked_array_u32(bit_width, len);
+        let for_arr = FoR::try_new(bp.into_array(), Scalar::from(reference))?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&for_arr.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&for_arr.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_runend() -> VortexResult<()> {
         let ends: Vec<u32> = vec![1000, 2000, 3000];
         let values: Vec<u32> = vec![10, 20, 30];
@@ -478,18 +801,19 @@ mod tests {
 
         let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array();
         let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
-        let re = RunEndArray::new(ends_arr, values_arr);
+        let re = RunEnd::new(ends_arr, values_arr);
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&re.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&re.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_dict_for_bp_values_bp_codes() -> VortexResult<()> {
         // Dict where both codes and values are BitPacked+FoR.
         let dict_reference = 1_000_000u32;
@@ -503,25 +827,26 @@ mod tests {
 
         // BitPack+FoR the dict values
         let dict_prim = PrimitiveArray::new(Buffer::from(dict_residuals), NonNullable);
-        let dict_bp = BitPackedArray::encode(dict_prim.as_ref(), 6)?;
-        let dict_for = FoRArray::try_new(dict_bp.into_array(), Scalar::from(dict_reference))?;
+        let dict_bp = BitPacked::encode(&dict_prim.into_array(), 6)?;
+        let dict_for = FoR::try_new(dict_bp.into_array(), Scalar::from(dict_reference))?;
 
         // BitPack the codes
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), 6)?;
+        let codes_bp = BitPacked::encode(&codes_prim.into_array(), 6)?;
 
         let dict = DictArray::try_new(codes_bp.into_array(), dict_for.into_array())?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&dict.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&dict.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_alp_for_bitpacked() -> VortexResult<()> {
         // ALP(FoR(BitPacked)): encode each layer, then reassemble the tree
         // bottom-up because encode() methods produce flat outputs.
@@ -534,25 +859,26 @@ mod tests {
 
         let alp = alp_encode(&float_prim, Some(exponents))?;
         assert!(alp.patches().is_none());
-        let for_arr = FoRArray::encode(alp.encoded().to_primitive())?;
-        let bp = BitPackedArray::encode(for_arr.encoded(), 6)?;
+        let for_arr = FoR::encode(alp.encoded().to_primitive())?;
+        let bp = BitPacked::encode(for_arr.encoded(), 6)?;
 
-        let tree = ALPArray::new(
-            FoRArray::try_new(bp.into_array(), for_arr.reference_scalar().clone())?.into_array(),
+        let tree = ALP::new(
+            FoR::try_new(bp.into_array(), for_arr.reference_scalar().clone())?.into_array(),
             exponents,
             None,
         );
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&tree.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&tree.into_array(), &cuda_ctx)?;
 
-        let actual = run_dispatch_plan_f32(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dispatch_plan_f32(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, floats);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_zigzag_bitpacked() -> VortexResult<()> {
         // ZigZag(BitPacked): unpack then zigzag-decode.
         let bit_width: u8 = 4;
@@ -568,19 +894,20 @@ mod tests {
             .collect();
 
         let prim = PrimitiveArray::new(Buffer::from(raw), NonNullable);
-        let bp = BitPackedArray::encode(prim.as_ref(), bit_width)?;
-        let zz = ZigZagArray::try_new(bp.into_array())?;
+        let bp = BitPacked::encode(&prim.into_array(), bit_width)?;
+        let zz = ZigZag::try_new(bp.into_array())?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&zz.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&zz.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_for_runend() -> VortexResult<()> {
         // FoR(RunEnd): expand runs then add constant.
         let ends: Vec<u32> = vec![500, 1000, 1500, 2000, 2500, 3000];
@@ -596,19 +923,20 @@ mod tests {
 
         let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array();
         let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
-        let re = RunEndArray::new(ends_arr, values_arr);
-        let for_arr = FoRArray::try_new(re.into_array(), Scalar::from(reference))?;
+        let re = RunEnd::new(ends_arr, values_arr);
+        let for_arr = FoR::try_new(re.into_array(), Scalar::from(reference))?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&for_arr.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&for_arr.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_for_dict() -> VortexResult<()> {
         // FoR(Dict(codes=Primitive, values=Primitive)): gather then add constant.
         let dict_values: Vec<u32> = vec![100, 200, 300, 400];
@@ -625,18 +953,19 @@ mod tests {
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
         let values_prim = PrimitiveArray::new(Buffer::from(dict_values), NonNullable);
         let dict = DictArray::try_new(codes_prim.into_array(), values_prim.into_array())?;
-        let for_arr = FoRArray::try_new(dict.into_array(), Scalar::from(reference))?;
+        let for_arr = FoR::try_new(dict.into_array(), Scalar::from(reference))?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&for_arr.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&for_arr.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_dict_for_bp_codes() -> VortexResult<()> {
         // Dict(codes=FoR(BitPacked), values=primitive)
         let dict_values: Vec<u32> = (0..8).map(|i| i * 1000 + 7).collect();
@@ -648,22 +977,23 @@ mod tests {
         // BitPack codes, then wrap in FoR (reference=0 so values unchanged)
         let bit_width: u8 = 3;
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), bit_width)?;
-        let codes_for = FoRArray::try_new(codes_bp.into_array(), Scalar::from(0u32))?;
+        let codes_bp = BitPacked::encode(&codes_prim.into_array(), bit_width)?;
+        let codes_for = FoR::try_new(codes_bp.into_array(), Scalar::from(0u32))?;
 
         let values_prim = PrimitiveArray::new(Buffer::from(dict_values), NonNullable);
         let dict = DictArray::try_new(codes_for.into_array(), values_prim.into_array())?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&dict.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&dict.into_array(), &cuda_ctx)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
         assert_eq!(actual, expected);
 
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_dict_primitive_values_bp_codes() -> VortexResult<()> {
         let dict_values: Vec<u32> = vec![100, 200, 300, 400];
         let dict_size = dict_values.len();
@@ -673,15 +1003,816 @@ mod tests {
 
         let bit_width: u8 = 2;
         let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), bit_width)?;
+        let codes_bp = BitPacked::encode(&codes_prim.into_array(), bit_width)?;
         let values_prim = PrimitiveArray::new(Buffer::from(dict_values), NonNullable);
 
         let dict = DictArray::try_new(codes_bp.into_array(), values_prim.into_array())?;
 
         let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
-        let (plan, _bufs) = build_plan(&dict.to_array(), &cuda_ctx)?;
+        let plan = dispatch_plan(&dict.into_array(), &cuda_ctx)?;
+
+        let actual =
+            run_dynamic_dispatch_plan(&cuda_ctx, len, &plan.dispatch_plan, plan.shared_mem_bytes)?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_dict_mixed_width_u8_codes_u32_values() -> VortexResult<()> {
+        let dict_values: Vec<u32> = vec![100, 200, 300, 400];
+        let len = 3000;
+        let codes: Vec<u8> = (0..len).map(|i| (i % dict_values.len()) as u8).collect();
+
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes.clone()), NonNullable);
+        let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
+        let dict = DictArray::try_new(codes_prim.into_array(), values_prim.into_array())?;
+        let array = dict.into_array();
+
+        // Mixed-width Dict (u8 codes, u32 values): both are Primitive, so
+        // walk_mixed_width_child grabs the codes buffer directly as a LOAD
+        // source. No pending subtrees → Fused.
+        let plan = DispatchPlan::new(&array)?;
+        assert!(
+            matches!(plan, DispatchPlan::Fused(..)),
+            "expected Fused for mixed-width Dict with primitive codes"
+        );
+
+        // Execute through the hybrid dispatch path (handles widening).
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u32> = codes.iter().map(|&c| dict_values[c as usize]).collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_dict_mixed_width_u16_codes_u32_values() -> VortexResult<()> {
+        let dict_values: Vec<u32> = vec![1000, 2000, 3000, 4000, 5000];
+        let len = 2048;
+        let codes: Vec<u16> = (0..len).map(|i| (i % dict_values.len()) as u16).collect();
+
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes.clone()), NonNullable);
+        let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
+        let dict = DictArray::try_new(codes_prim.into_array(), values_prim.into_array())?;
+        let array = dict.into_array();
+
+        // Mixed-width Dict (u16 codes, u32 values): both are Primitive, so
+        // walk_mixed_width_child grabs the codes buffer directly as a LOAD
+        // source. No pending subtrees → Fused.
+        let plan = DispatchPlan::new(&array)?;
+        assert!(
+            matches!(plan, DispatchPlan::Fused(..)),
+            "expected Fused for mixed-width Dict with primitive codes"
+        );
+
+        // Execute through the hybrid dispatch path (handles widening).
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u32> = codes.iter().map(|&c| dict_values[c as usize]).collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_runend_mixed_width_u64_ends_u32_values() -> VortexResult<()> {
+        let ends: Vec<u64> = vec![1000, 2000, 3000];
+        let values: Vec<u32> = vec![10, 20, 30];
+        let len = 3000;
+
+        let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array();
+        let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
+        let re = RunEnd::new(ends_arr, values_arr);
+        let array = re.into_array();
+
+        // Ends (u64) are wider than values (u32), so the kernel would truncate
+        // ends via load_element<T>. The plan builder rejects this as Unfused.
+        let plan = DispatchPlan::new(&array)?;
+        assert!(
+            matches!(plan, DispatchPlan::Unfused),
+            "expected Unfused for RunEnd with wider ends"
+        );
+
+        // Execute through the non-fused dispatch path.
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u32> = (0..len as u64)
+            .map(|i| {
+                if i < 1000 {
+                    10
+                } else if i < 2000 {
+                    20
+                } else {
+                    30
+                }
+            })
+            .collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_primitive(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let len = 5000;
+        let data: Vec<u32> = (0..len).map(|i| (i * 7) % 1000).collect();
+
+        let prim = PrimitiveArray::new(Buffer::from(data.clone()), NonNullable);
+
+        let sliced = prim.into_array().slice(slice_start..slice_end)?;
+
+        let expected: Vec<u32> = data[slice_start..slice_end].to_vec();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_zigzag_bitpacked(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let bit_width = 10u8;
+        let max_val = (1u32 << bit_width) - 1;
+        let len = 5000;
+
+        let raw: Vec<u32> = (0..len).map(|i| (i as u32) % max_val).collect();
+        let all_decoded: Vec<u32> = raw
+            .iter()
+            .map(|&v| (v >> 1) ^ (0u32.wrapping_sub(v & 1)))
+            .collect();
+
+        let prim = PrimitiveArray::new(Buffer::from(raw), NonNullable);
+        let bp = BitPacked::encode(&prim.into_array(), bit_width)?;
+        let zz = ZigZag::try_new(bp.into_array())?;
+
+        let sliced = zz.into_array().slice(slice_start..slice_end)?;
+        let expected: Vec<u32> = all_decoded[slice_start..slice_end].to_vec();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_dict_with_primitive_codes(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let dict_values: Vec<u32> = vec![100, 200, 300, 400, 500];
+        let dict_size = dict_values.len();
+        let len = 5000;
+        let codes: Vec<u32> = (0..len).map(|i| (i % dict_size) as u32).collect();
+
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes.clone()), NonNullable);
+        let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
+        let dict = DictArray::try_new(codes_prim.into_array(), values_prim.into_array())?;
+
+        let sliced = dict.into_array().slice(slice_start..slice_end)?;
+
+        let expected: Vec<u32> = codes[slice_start..slice_end]
+            .iter()
+            .map(|&c| dict_values[c as usize])
+            .collect();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_bitpacked(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let bit_width = 10u8;
+        let max_val = (1u32 << bit_width) - 1;
+        let len = 5000;
+
+        let data: Vec<u32> = (0..len).map(|i| (i as u32) % max_val).collect();
+        let prim = PrimitiveArray::new(Buffer::from(data.clone()), NonNullable);
+        let bp = BitPacked::encode(&prim.into_array(), bit_width)?;
+
+        let sliced = bp.into_array().slice(slice_start..slice_end)?;
+        let expected: Vec<u32> = data[slice_start..slice_end].to_vec();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_for_bitpacked(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let reference = 100u32;
+        let bit_width = 10u8;
+        let max_val = (1u32 << bit_width) - 1;
+        let len = 5000;
+
+        let encoded_data: Vec<u32> = (0..len).map(|i| (i as u32) % max_val).collect();
+        let prim = PrimitiveArray::new(Buffer::from(encoded_data.clone()), NonNullable);
+        let bp = BitPacked::encode(&prim.into_array(), bit_width)?;
+        let for_arr = FoR::try_new(bp.into_array(), Scalar::from(reference))?;
+
+        let all_decoded: Vec<u32> = encoded_data.iter().map(|&v| v + reference).collect();
+
+        let sliced = for_arr.into_array().slice(slice_start..slice_end)?;
+        let expected: Vec<u32> = all_decoded[slice_start..slice_end].to_vec();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0, 1024)]
+    #[case(0, 3000)]
+    #[case(0, 4096)]
+    #[case(500, 600)]
+    #[case(500, 1024)]
+    #[case(500, 2048)]
+    #[case(500, 4500)]
+    #[case(777, 3333)]
+    #[case(1024, 2048)]
+    #[case(1024, 4096)]
+    #[case(1500, 3500)]
+    #[case(2048, 4096)]
+    #[case(2500, 4500)]
+    #[case(3333, 4444)]
+    #[crate::test]
+    fn test_sliced_dict_for_bp_values_bp_codes(
+        #[case] slice_start: usize,
+        #[case] slice_end: usize,
+    ) -> VortexResult<()> {
+        let dict_reference = 1_000_000u32;
+        let dict_residuals: Vec<u32> = (0..64).collect();
+        let dict_expected: Vec<u32> = dict_residuals.iter().map(|&r| r + dict_reference).collect();
+        let dict_size = dict_residuals.len();
+
+        let len = 5000;
+        let codes: Vec<u32> = (0..len).map(|i| (i % dict_size) as u32).collect();
+        let all_decoded: Vec<u32> = codes.iter().map(|&c| dict_expected[c as usize]).collect();
+
+        // BitPack+FoR the dict values
+        let dict_prim = PrimitiveArray::new(Buffer::from(dict_residuals), NonNullable);
+        let dict_bp = BitPacked::encode(&dict_prim.into_array(), 6)?;
+        let dict_for = FoR::try_new(dict_bp.into_array(), Scalar::from(dict_reference))?;
+
+        // BitPack the codes
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes), NonNullable);
+        let codes_bp = BitPacked::encode(&codes_prim.into_array(), 6)?;
+
+        let dict = DictArray::try_new(codes_bp.into_array(), dict_for.into_array())?;
+
+        let sliced = dict.into_array().slice(slice_start..slice_end)?;
+        let expected: Vec<u32> = all_decoded[slice_start..slice_end].to_vec();
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&sliced, &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0u32, 1u32, 100)]
+    #[case(5u32, 3u32, 2048)]
+    #[case(0u32, 1u32, 4096)]
+    #[case(100u32, 7u32, 5000)]
+    #[crate::test]
+    fn test_sequence_unsigned(
+        #[case] base: u32,
+        #[case] multiplier: u32,
+        #[case] len: usize,
+    ) -> VortexResult<()> {
+        use vortex::dtype::Nullability;
+        use vortex::encodings::sequence::Sequence;
+
+        let expected: Vec<u32> = (0..len).map(|i| base + (i as u32) * multiplier).collect();
+
+        let seq = Sequence::try_new_typed(base, multiplier, Nullability::NonNullable, len)?;
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&seq.into_array(), &cuda_ctx)?;
+
+        let actual = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[rstest]
+    #[case(0i32, 1i32, 100)]
+    #[case(-10i32, 3i32, 2048)]
+    #[case(100i32, -1i32, 100)]
+    #[case(-500i32, -7i32, 50)]
+    #[case(0i32, 1i32, 5000)]
+    #[crate::test]
+    fn test_sequence_signed(
+        #[case] base: i32,
+        #[case] multiplier: i32,
+        #[case] len: usize,
+    ) -> VortexResult<()> {
+        use vortex::dtype::Nullability;
+        use vortex::encodings::sequence::Sequence;
+
+        let expected: Vec<i32> = (0..len).map(|i| base + (i as i32) * multiplier).collect();
+
+        let seq = Sequence::try_new_typed(base, multiplier, Nullability::NonNullable, len)?;
+
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let plan = dispatch_plan(&seq.into_array(), &cuda_ctx)?;
+
+        let actual_u32 = run_dynamic_dispatch_plan(
+            &cuda_ctx,
+            expected.len(),
+            &plan.dispatch_plan,
+            plan.shared_mem_bytes,
+        )?;
+        let actual: Vec<i32> = actual_u32.into_iter().map(|v| v as i32).collect();
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_for_bitpacked_u8() -> VortexResult<()> {
+        let bit_width: u8 = 4;
+        let len = 3000;
+        let reference = 100u8;
+        let max_val = (1u64 << bit_width).saturating_sub(1);
+        let residuals: Vec<u8> = (0..len).map(|i| (i as u64 % (max_val + 1)) as u8).collect();
+        let expected: Vec<u8> = residuals
+            .iter()
+            .map(|&r| r.wrapping_add(reference))
+            .collect();
+
+        let primitive = PrimitiveArray::new(Buffer::from(residuals), NonNullable);
+        let bp = BitPacked::encode(&primitive.into_array(), bit_width).vortex_expect("bitpack u8");
+        let for_arr = FoR::try_new(
+            bp.into_array(),
+            Scalar::primitive(reference, Nullability::NonNullable),
+        )?;
+        let array = for_arr.into_array();
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_for_bitpacked_u16() -> VortexResult<()> {
+        let bit_width: u8 = 10;
+        let len = 3000;
+        let reference = 1000u16;
+        let max_val = (1u64 << bit_width).saturating_sub(1);
+        let residuals: Vec<u16> = (0..len)
+            .map(|i| (i as u64 % (max_val + 1)) as u16)
+            .collect();
+        let expected: Vec<u16> = residuals
+            .iter()
+            .map(|&r| r.wrapping_add(reference))
+            .collect();
+
+        let primitive = PrimitiveArray::new(Buffer::from(residuals), NonNullable);
+        let bp = BitPacked::encode(&primitive.into_array(), bit_width).vortex_expect("bitpack u16");
+        let for_arr = FoR::try_new(
+            bp.into_array(),
+            Scalar::primitive(reference, Nullability::NonNullable),
+        )?;
+        let array = for_arr.into_array();
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_for_bitpacked_u64() -> VortexResult<()> {
+        let bit_width: u8 = 20;
+        let len = 3000;
+        let reference = 100_000u64;
+        let max_val = (1u64 << bit_width).saturating_sub(1);
+        let residuals: Vec<u64> = (0..len).map(|i| i as u64 % (max_val + 1)).collect();
+        let expected: Vec<u64> = residuals
+            .iter()
+            .map(|&r| r.wrapping_add(reference))
+            .collect();
+
+        let primitive = PrimitiveArray::new(Buffer::from(residuals), NonNullable);
+        let bp = BitPacked::encode(&primitive.into_array(), bit_width).vortex_expect("bitpack u64");
+        let for_arr = FoR::try_new(
+            bp.into_array(),
+            Scalar::primitive(reference, Nullability::NonNullable),
+        )?;
+        let array = for_arr.into_array();
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_empty_array() -> VortexResult<()> {
+        let values: Vec<u32> = vec![];
+        let primitive = PrimitiveArray::new(Buffer::from(values), NonNullable);
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&primitive.into_array(), &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+        assert_eq!(result.len(), 0);
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_single_element() -> VortexResult<()> {
+        let values: Vec<u32> = vec![42];
+        let primitive = PrimitiveArray::new(Buffer::from(values.clone()), NonNullable);
+        let bp = BitPacked::encode(&primitive.into_array(), 6).vortex_expect("bitpack");
+        let for_arr = FoR::try_new(
+            bp.into_array(),
+            Scalar::primitive(0u32, Nullability::NonNullable),
+        )?;
+        let array = for_arr.into_array();
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected, result);
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_exactly_elements_per_block() -> VortexResult<()> {
+        // Exactly 2048 elements — one full block, no remainder
+        let bit_width: u8 = 6;
+        let len = 2048;
+        let reference = 1000u32;
+        let max_val = (1u64 << bit_width).saturating_sub(1);
+        let residuals: Vec<u32> = (0..len)
+            .map(|i| (i as u64 % (max_val + 1)) as u32)
+            .collect();
+        let expected: Vec<u32> = residuals.iter().map(|&r| r + reference).collect();
+
+        let primitive = PrimitiveArray::new(Buffer::from(residuals), NonNullable);
+        let bp = BitPacked::encode(&primitive.into_array(), bit_width).vortex_expect("bitpack");
+        let for_arr = FoR::try_new(
+            bp.into_array(),
+            Scalar::primitive(reference, Nullability::NonNullable),
+        )?;
+        let array = for_arr.into_array();
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+        Ok(())
+    }
+
+    #[crate::test]
+    fn test_f64_rejected() {
+        // F64 arrays should be rejected by the plan builder, not silently accepted.
+        let values: Vec<f64> = vec![1.0, 2.0, 3.0];
+        let primitive = PrimitiveArray::new(Buffer::from(values), NonNullable);
+        let plan = DispatchPlan::new(&primitive.into_array())
+            .expect("DispatchPlan::new should not fail for f64");
+        assert!(
+            matches!(plan, DispatchPlan::Unfused),
+            "expected F64 to be classified as Unfused"
+        );
+    }
+
+    #[crate::test]
+    async fn test_runend_u32_ends_u16_values() -> VortexResult<()> {
+        // RunEnd with u32 ends, u16 values. Output type = u16.
+        // Ends (u32) differ from output (u16) → pending subtree.
+        let ends: Vec<u32> = vec![500, 1000, 1500, 2000];
+        let values: Vec<u16> = vec![100, 200, 300, 400];
+        let len = 2000;
+
+        let ends_arr = PrimitiveArray::new(Buffer::from(ends), NonNullable).into_array();
+        let values_arr = PrimitiveArray::new(Buffer::from(values), NonNullable).into_array();
+        let re = RunEnd::new(ends_arr, values_arr);
+        let array = re.into_array();
+
+        // Ends (u32) are wider than values (u16), so the kernel would truncate
+        // ends via load_element<T>. The plan builder rejects this as Unfused.
+        let plan = DispatchPlan::new(&array)?;
+        assert!(
+            matches!(plan, DispatchPlan::Unfused),
+            "expected Unfused for RunEnd with wider ends"
+        );
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u16> = (0..len as u64)
+            .map(|i| {
+                if i < 500 {
+                    100u16
+                } else if i < 1000 {
+                    200
+                } else if i < 1500 {
+                    300
+                } else {
+                    400
+                }
+            })
+            .collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_dict_bitpacked_u8_codes_u32_values() -> VortexResult<()> {
+        // Dict with BitPacked u8 codes (narrower than u32 output) and u32 values.
+        // Codes become a pending subtree, values fuse.
+        let dict_values: Vec<u32> = vec![100, 200, 300, 400];
+        let len = 2048;
+        let codes: Vec<u8> = (0..len).map(|i| (i % dict_values.len()) as u8).collect();
+
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes.clone()), NonNullable);
+        // BitPack the u8 codes at 2 bits (4 values need 2 bits)
+        let codes_bp =
+            BitPacked::encode(&codes_prim.into_array(), 2).vortex_expect("bitpack codes");
+        let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
+        let dict = DictArray::try_new(codes_bp.into_array(), values_prim.into_array())?;
+        let array = dict.into_array();
+
+        let plan = DispatchPlan::new(&array)?;
+        assert!(
+            matches!(plan, DispatchPlan::PartiallyFused { .. }),
+            "expected PartiallyFused for mixed-width Dict with BitPacked codes"
+        );
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&array, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u32> = codes.iter().map(|&c| dict_values[c as usize]).collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_sliced_dict_mixed_width() -> VortexResult<()> {
+        // Sliced Dict with u8 codes and u32 values — combines PartiallyFused + slice handling.
+        let dict_values: Vec<u32> = vec![100, 200, 300, 400];
+        let full_len = 4096;
+        let codes: Vec<u8> = (0..full_len)
+            .map(|i| (i % dict_values.len()) as u8)
+            .collect();
+
+        let codes_prim = PrimitiveArray::new(Buffer::from(codes.clone()), NonNullable);
+        let values_prim = PrimitiveArray::new(Buffer::from(dict_values.clone()), NonNullable);
+        let dict = DictArray::try_new(codes_prim.into_array(), values_prim.into_array())?;
+
+        // Slice from 1000..3000
+        let sliced = dict.into_array().slice(1000..3000)?;
+
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+        let canonical = try_gpu_dispatch(&sliced, &mut cuda_ctx).await?;
+        let result = CanonicalCudaExt::into_host(canonical).await?.into_array();
+
+        let expected: Vec<u32> = codes[1000..3000]
+            .iter()
+            .map(|&c| dict_values[c as usize])
+            .collect();
+        let expected_arr = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        vortex::array::assert_arrays_eq!(expected_arr, result);
+
+        Ok(())
+    }
+
+    /// Verify that `load_element<T>` sign-extends signed narrow types when
+    /// widening to a wider T. E.g. i8(-1) = 0xFF must become u32(0xFFFFFFFF)
+    /// (the bit-pattern for i32(-1)), not u32(0x000000FF) = 255.
+    #[crate::test]
+    fn test_load_element_sign_extends_i8_to_u32() -> VortexResult<()> {
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+
+        let i8_values: Vec<i8> = vec![-1, -2, -3, 127, -128, 0, 1, 42];
+        let len = i8_values.len();
+        let device_buf = Arc::new(cuda_ctx.stream().clone_htod(&i8_values).expect("htod"));
+        let (input_ptr, _) = device_buf.device_ptr(cuda_ctx.stream());
+
+        // Build a single-stage LOAD plan: source ptype = I8, output ptype = U32.
+        // The kernel (instantiated as u32) must sign-extend each i8 element.
+        let plan = CudaDispatchPlan::new(
+            [MaterializedStage::new(
+                input_ptr,
+                0,
+                len as u32,
+                PTypeTag_PTYPE_I8,
+                SourceOp::load(),
+                &[],
+            )],
+            PTypeTag_PTYPE_U32,
+        );
+
+        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan, SMEM_TILE_SIZE * 4)?;
+
+        // Expected: each i8 sign-extended to i32, then viewed as u32.
+        let expected: Vec<u32> = i8_values.iter().map(|&v| (v as i32) as u32).collect();
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    /// Same as above but for i16 → u32 widening.
+    #[crate::test]
+    fn test_load_element_sign_extends_i16_to_u32() -> VortexResult<()> {
+        let cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())?;
+
+        let i16_values: Vec<i16> = vec![-1, -256, -32768, 32767, 0, 1, -100, 12345];
+        let len = i16_values.len();
+        let device_buf = Arc::new(cuda_ctx.stream().clone_htod(&i16_values).expect("htod"));
+        let (input_ptr, _) = device_buf.device_ptr(cuda_ctx.stream());
+
+        let plan = CudaDispatchPlan::new(
+            [MaterializedStage::new(
+                input_ptr,
+                0,
+                len as u32,
+                PTypeTag_PTYPE_I16,
+                SourceOp::load(),
+                &[],
+            )],
+            PTypeTag_PTYPE_U32,
+        );
+
+        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan, SMEM_TILE_SIZE * 4)?;
 
-        let actual = run_dynamic_dispatch_plan(&cuda_ctx, len, &plan)?;
+        let expected: Vec<u32> = i16_values.iter().map(|&v| (v as i32) as u32).collect();
         assert_eq!(actual, expected);
 
         Ok(())
diff --git a/vortex-cuda/src/dynamic_dispatch/plan_builder.rs b/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
index f63e0edc569..c44b7224b7e 100644
--- a/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
+++ b/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
@@ -1,157 +1,437 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Walks an encoding tree and builds a [`DynamicDispatchPlan`].
-//!
-//! The builder recursively inspects the array's encoding, moves leaf buffers
-//! to the device, computes shared memory offsets, and produces a plan that the
-//! dynamic dispatch kernel can execute in a single launch.
-
-use futures::executor::block_on;
-use vortex::array::Array;
+//! Walks an encoding tree and produces a [`DispatchPlan`] for a single GPU
+//! kernel launch. The tree is inspected in a single pass, identifying unfusable
+//! subtrees and computing shared memory requirements upfront — before any
+//! device allocation or kernel work.
+
+use itertools::zip_eq;
+use tracing::trace;
 use vortex::array::ArrayRef;
-use vortex::array::arrays::DictVTable;
-use vortex::array::arrays::PrimitiveArrayParts;
-use vortex::array::arrays::PrimitiveVTable;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::Primitive;
+use vortex::array::arrays::Slice;
+use vortex::array::arrays::dict::DictArraySlotsExt;
+use vortex::array::arrays::slice::SliceArrayExt;
 use vortex::array::buffer::BufferHandle;
 use vortex::dtype::PType;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::ALPArrayExt;
+use vortex::encodings::alp::ALPArraySlotsExt;
 use vortex::encodings::alp::ALPFloat;
-use vortex::encodings::alp::ALPVTable;
-use vortex::encodings::fastlanes::BitPackedArrayParts;
-use vortex::encodings::fastlanes::BitPackedVTable;
-use vortex::encodings::fastlanes::FoRVTable;
-use vortex::encodings::runend::RunEndArrayParts;
-use vortex::encodings::runend::RunEndVTable;
-use vortex::encodings::zigzag::ZigZagVTable;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::BitPackedArrayExt;
+use vortex::encodings::fastlanes::FoR;
+use vortex::encodings::fastlanes::FoRArrayExt;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::runend::RunEndArrayExt;
+use vortex::encodings::sequence::Sequence;
+use vortex::encodings::zigzag::ZigZag;
+use vortex::encodings::zigzag::ZigZagArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
 
-use super::DynamicDispatchPlan;
-use super::MAX_SCALAR_OPS;
-use super::MAX_STAGES;
+use super::CudaDispatchPlan;
+use super::MaterializedStage;
+use super::PTypeTag;
+use super::SMEM_TILE_SIZE;
 use super::ScalarOp;
 use super::SourceOp;
-use super::Stage;
+use super::ptype_to_tag;
+use super::tag_to_ptype;
 use crate::CudaBufferExt;
 use crate::CudaExecutionCtx;
 
-/// The result of walking a subtree: a source op, scalar ops to apply after,
-/// and the device pointer to the leaf buffer.
-struct Pipeline {
+/// A plan whose source buffers have been copied to the device, ready for kernel launch.
+pub struct MaterializedPlan {
+    /// Packed plan byte buffer, to upload to the device.
+    pub dispatch_plan: CudaDispatchPlan,
+    /// Device buffer handles that must be kept alive while the plan is in use.
+    pub device_buffers: Vec<BufferHandle>,
+    /// Dynamic shared memory bytes needed to launch this plan.
+    pub shared_mem_bytes: u32,
+}
+
+/// Checks whether the encoding of an array can be fused into a dynamic-dispatch plan.
+fn is_dyn_dispatch_compatible(array: &ArrayRef) -> bool {
+    // The dynamic dispatch kernel only supports F32 floats (via ALP).
+    // F16 and F64 have no reinterpret path in the kernel.
+    if matches!(PType::try_from(array.dtype()), Ok(PType::F16 | PType::F64)) {
+        return false;
+    }
+
+    let id = array.encoding_id();
+    if id == ALP::ID {
+        let arr = array.as_::<ALP>();
+        return arr.patches().is_none() && arr.dtype().as_ptype() == PType::F32;
+    }
+    if id == BitPacked::ID {
+        return array.as_::<BitPacked>().patches().is_none();
+    }
+    if id == Dict::ID {
+        let arr = array.as_::<Dict>();
+        // Dict codes and values may have different byte widths.
+        // The kernel handles mixed widths via widening input stages,
+        // but only when codes are no wider than values (the output type).
+        // Wider codes would be truncated by load_element<T>().
+        let values_ptype = PType::try_from(arr.values().dtype());
+        let codes_ptype = PType::try_from(arr.codes().dtype());
+        return match (values_ptype, codes_ptype) {
+            (Ok(vp), Ok(cp)) => cp.byte_width() <= vp.byte_width(),
+            _ => false,
+        };
+    }
+    if id == RunEnd::ID {
+        let arr = array.as_::<RunEnd>();
+        // RunEnd ends and values may have different byte widths.
+        // The kernel handles mixed widths via widening input stages,
+        // but only when ends are no wider than values (the output type).
+        // Wider ends would be truncated by load_element<T>().
+        let ends_ptype = PType::try_from(arr.ends().dtype());
+        let values_ptype = PType::try_from(arr.values().dtype());
+        return match (ends_ptype, values_ptype) {
+            (Ok(ep), Ok(vp)) => ep.byte_width() <= vp.byte_width(),
+            _ => false,
+        };
+    }
+    id == FoR::ID
+        || id == ZigZag::ID
+        || id == Primitive::ID
+        || id == Slice::ID
+        || id == Sequence::ID
+}
+
+/// An unmaterialized stage: a source op, scalar ops, and optional source buffer reference.
+struct Stage {
     source: SourceOp,
     scalar_ops: Vec<ScalarOp>,
-    input_ptr: u64,
+    /// Index into `FusedPlan::source_buffers`, or `None`
+    /// for sources that don't read from a device buffer.
+    source_buffer_index: Option<usize>,
+    /// PType tag for the source op's output type.
+    source_ptype: PTypeTag,
 }
 
-/// Walk the encoding tree of `array` and build a [`DynamicDispatchPlan`].
+impl Stage {
+    fn new(source: SourceOp, source_buffer_index: Option<usize>, source_ptype: PTypeTag) -> Self {
+        Self {
+            source,
+            scalar_ops: vec![],
+            source_buffer_index,
+            source_ptype,
+        }
+    }
+}
+
+type SmemByteOffset = u32;
+type OutputLen = u32;
+
+/// A dispatch plan before device materialization.
 ///
-/// Leaf buffers are moved to the device if not already there. The returned
-/// buffer handles must be kept alive while the plan's device pointers are
-/// in use.
+/// Constructed by [`DispatchPlan::new`], which inspects the encoding tree
+/// and determines whether it can be fully fused, partially fused, or not fused at all.
+pub enum DispatchPlan {
+    /// Entire encoding tree is fusable into a single kernel launch.
+    Fused(FusedPlan),
+    /// Some subtrees need separate execution before the fused plan can run.
+    PartiallyFused {
+        /// The fused plan (with placeholder buffer slots for pending subtrees).
+        plan: FusedPlan,
+        /// Unfusable subtree roots that must be executed separately.
+        pending_subtrees: Vec<ArrayRef>,
+    },
+    /// Tree cannot be fused (incompatible root, non-primitive subtree dtypes,
+    /// or shared memory limit exceeded).
+    Unfused,
+}
+
+/// A fused plan: stages, source buffers and shared-memory.
+///
+/// Stages are stored in kernel execution order. There are two phases:
 ///
-/// # Plan construction
+/// 1. All stages except the last run first and decode their output
+///    into shared memory (e.g. all dict values, all run-end endpoints).
+///    This data stays resident for the output stage to index into.
 ///
-/// The builder walks the encoding tree from root to leaf. Single-child
-/// encodings (FoR, ZigZag, ALP) recurse into their child and append an
-/// element-wise transform to the pipeline. Leaf encodings (BitPacked,
-/// Primitive) produce a source op and a device pointer.
+/// 2. The last stage (the output stage) iterates over the input in tiles
+///    of `SMEM_TILE_SIZE` (1024) elements, decoding each tile into a
+///    scratch region of shared memory, applying scalar ops (which may
+///    reference data from the earlier stages), and writing the result to
+///    global memory.
 ///
-/// Encodings with multiple children (Dict, RunEnd) emit an input stage
-/// for each child, writing its output to shared memory. The root of the
-/// tree becomes the final output stage, which writes directly to global
-/// memory instead.
+/// # Per-stage PType tracking
 ///
-/// Shared memory offsets are bump-allocated: each input stage claims
-/// the next available region. Since the output stage may reference any
-/// input stage's output (e.g., dictionary lookup, run-end resolution),
-/// all regions must coexist simultaneously — the total shared memory
-/// is `max(smem_offset + len) * sizeof(T)` across all stages.
+/// Each stage carries a `source_ptype` (`PTypeTag`) that identifies the
+/// primitive type produced by its source op (LOAD, BITUNPACK, etc.).
+/// Scalar ops may change the type (e.g. DICT transforms codes → values,
+/// ALP transforms encoded ints → floats); each `ScalarOp` declares its
+/// `output_ptype`. The kernel uses these tags to dispatch typed memory
+/// operations and cross-stage references at the correct element width.
 ///
-/// # Supported encodings
+/// # Shared memory allocation
 ///
-/// - `PrimitiveArray` → `LOAD` source
-/// - `BitPackedArray` → `BITUNPACK` source (no patches)
-/// - `FoRArray` → recurse + `FoR` scalar op
-/// - `ZigZagArray` → recurse + `ZigZag` scalar op
-/// - `ALPArray` → recurse + `ALP` scalar op (f32 only, no patches)
-/// - `DictArray` → input stage for values + recurse codes + `DICT` scalar op
-/// - `RunEndArray` → input stages for ends/values + `RUNEND` source
+/// Total shared memory = `smem_byte_cursor` + `SMEM_TILE_SIZE` × `output_elem_bytes`.
 ///
-/// # Limitations
+/// `smem_byte_cursor` is tracked in bytes and covers the preceding
+/// fully-decoded stages (dict values, run-end endpoints). Each stage's
+/// shared memory footprint is `len × final_ptype_byte_width`, where the
+/// final ptype is determined by the last scalar op's `output_ptype` (or
+/// `source_ptype` if there are no scalar ops).
 ///
-/// **Nullability**: validity bitmaps are silently ignored. All output elements
-/// receive a value regardless of whether the input was null. Only arrays with
-/// `NonNullable` or `AllValid` validity produce correct results.
+/// All shared memory offsets are byte offsets — the C ABI uses byte
+/// offsets and per-field `PTypeTag` values so that stages with different
+/// element widths can coexist in the same shared memory pool.
 ///
-/// **Slicing**: Not supported.
+/// This is sufficient because:
 ///
-/// **Patches**: `BitPackedArray` with patches and `ALPArray` with patches are
-/// not supported and will return an error.
+/// - Earlier stages only originate from dict (values) and run-end (ends,
+///   values). `push_smem_stage` reserves the appropriate number of bytes
+///   in `smem_byte_cursor`, so each stage's source op has room to decode
+///   the complete input.
 ///
-/// **f64 ALP**: Only f32 ALP is supported. The CUDA kernel's `AlpParams`
-/// stores multipliers as `float`, so f64 ALP arrays will return an error.
-pub fn build_plan(
-    array: &ArrayRef,
-    ctx: &CudaExecutionCtx,
-) -> VortexResult<(DynamicDispatchPlan, Vec<BufferHandle>)> {
-    let mut state = PlanBuilderState {
-        ctx,
-        stages: Vec::new(),
-        smem_cursor: 0,
-        device_buffers: Vec::new(),
-    };
-
-    let pipeline = state.walk(array.clone())?;
-    let output_stage = Stage::output(
-        pipeline.input_ptr,
-        state.smem_cursor,
-        pipeline.source,
-        &pipeline.scalar_ops,
-    );
-    state.stages.push(output_stage);
-
-    assert!(state.stages.len() <= MAX_STAGES as usize);
-    assert!(
-        state
+/// - The output stage (last) tiles at `SMEM_TILE_SIZE` (1024 elements),
+///   so its source op never writes more than 1024 elements into the
+///   scratch region, even though each block is responsible for
+///   `ELEMENTS_PER_BLOCK` (2048) output elements — it processes them in
+///   two passes through the scratch.
+///
+/// Note: `BITUNPACK` writes full FastLanes blocks (1024 elements), which can
+/// exceed `stage.len` by up to 1023 elements. This overflow is absorbed by
+/// the scratch region (`SMEM_TILE_SIZE` ≥ `FL_CHUNK_SIZE`).
+pub struct FusedPlan {
+    /// Stages in kernel execution order; all but the last decode into
+    /// shared memory, the last decodes into global memory.
+    stages: Vec<(Stage, SmemByteOffset, OutputLen)>,
+    /// 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.
+    source_buffers: Vec<Option<BufferHandle>>,
+    /// Bytes per element of the root (output) array.
+    output_elem_bytes: u32,
+    /// PType of the root (output) array, as a C ABI tag.
+    output_ptype: PTypeTag,
+}
+
+impl DispatchPlan {
+    /// Construct a plan by inspecting the encoding tree in a single pass.
+    ///
+    /// # Limitations
+    ///
+    /// - Validity bitmaps are ignored; only `NonNullable`/`AllValid` is supported.
+    /// - `BitPackedArray` and `ALPArray` with patches are not supported.
+    /// - Only f32 ALP is supported (kernel stores multipliers as `float`).
+    pub fn new(array: &ArrayRef) -> VortexResult<Self> {
+        if PType::try_from(array.dtype()).is_err() || !is_dyn_dispatch_compatible(array) {
+            return Ok(Self::Unfused);
+        }
+
+        let (plan, pending_subtrees) = match FusedPlan::build(array) {
+            Ok(result) => result,
+            Err(_) => return Ok(Self::Unfused),
+        };
+
+        if plan.exceeds_shared_mem_limit() {
+            return Ok(Self::Unfused);
+        }
+
+        if pending_subtrees.is_empty() {
+            Ok(Self::Fused(plan))
+        } else {
+            Ok(Self::PartiallyFused {
+                plan,
+                pending_subtrees,
+            })
+        }
+    }
+}
+
+impl FusedPlan {
+    /// Maximum shared memory per block in bytes (48 KB, static + dynamic).
+    ///
+    /// 48 KB is the default per-block shared memory limit across all CUDA
+    /// architectures. Higher limits (up to 227 KB on Hopper) require an
+    /// explicit opt-in via `cuFuncSetAttribute`.
+    const MAX_SHARED_MEM_BYTES: u32 = 48 * 1024;
+
+    /// Fixed shared memory used by the kernel (bytes).
+    /// Sourced from the C header via bindgen.
+    const FIXED_SHARED_MEM_BYTES: u32 = super::KERNEL_FIXED_SHARED_BYTES;
+
+    /// Build a plan by walking the encoding tree from root to leaf.
+    ///
+    /// During the walk, incompatible nodes are discovered and recorded in the
+    /// returned `Vec<ArrayRef>`.
+    fn build(array: &ArrayRef) -> VortexResult<(Self, Vec<ArrayRef>)> {
+        let output_ptype_rust = PType::try_from(array.dtype()).map_err(|_| {
+            vortex_err!(
+                "dyn dispatch requires primitive dtype, got {:?}",
+                array.dtype()
+            )
+        })?;
+        if output_ptype_rust == PType::F64 {
+            vortex_bail!("dynamic dispatch does not support f64 output");
+        }
+        let output_elem_bytes = output_ptype_rust.byte_width() as u32;
+        let output_ptype = ptype_to_tag(output_ptype_rust);
+
+        let mut pending_subtrees: Vec<ArrayRef> = Vec::new();
+        let mut plan = Self {
+            stages: Vec::new(),
+            smem_byte_cursor: 0u32,
+            source_buffers: Vec::new(),
+            output_elem_bytes,
+            output_ptype,
+        };
+
+        let len = array.len() as u32;
+        let output = plan.walk(array.clone(), &mut pending_subtrees)?;
+        plan.stages.push((output, plan.smem_byte_cursor, len));
+
+        Ok((plan, pending_subtrees))
+    }
+
+    /// Dynamic shared memory bytes passed to the CUDA launch config.
+    fn dynamic_shared_mem_bytes(&self) -> u32 {
+        self.smem_byte_cursor + SMEM_TILE_SIZE * self.output_elem_bytes
+    }
+
+    /// Total shared memory (fixed + dynamic) for limit checking.
+    fn total_shared_mem_bytes(&self) -> u32 {
+        Self::FIXED_SHARED_MEM_BYTES + self.dynamic_shared_mem_bytes()
+    }
+
+    /// Returns `true` if this plan's shared memory requirement exceeds
+    /// the per-block limit, logging a trace message when it does.
+    fn exceeds_shared_mem_limit(&self) -> bool {
+        let required = self.total_shared_mem_bytes();
+        if required > Self::MAX_SHARED_MEM_BYTES {
+            trace!(
+                required,
+                limit = Self::MAX_SHARED_MEM_BYTES,
+                "shared memory limit exceeded, falling back to unfused dispatch"
+            );
+            return true;
+        }
+        false
+    }
+
+    /// Copy source buffers to the device, producing a [`MaterializedPlan`].
+    pub fn materialize(self, ctx: &CudaExecutionCtx) -> VortexResult<MaterializedPlan> {
+        let shared_mem_bytes = self.dynamic_shared_mem_bytes();
+
+        let mut device_buffers = Vec::new();
+        let mut device_ptrs: Vec<u64> = Vec::new();
+
+        // Copy each source buffer to the device and record its pointer.
+        for source_buf in self.source_buffers {
+            let source_buf = source_buf.ok_or_else(|| {
+                vortex_err!("all source buffer slots must be filled before materialize")
+            })?;
+            let device_buf = ctx.ensure_on_device_sync(source_buf)?;
+            let ptr = device_buf.cuda_device_ptr()?;
+            device_ptrs.push(ptr);
+            device_buffers.push(device_buf);
+        }
+
+        let resolve_ptr = |stage: &Stage| -> u64 {
+            match stage.source_buffer_index {
+                Some(idx) => device_ptrs[idx],
+                None => 0,
+            }
+        };
+
+        // Byte offsets are passed directly to the C ABI — the kernel now
+        // indexes shared memory by byte offset and casts to the correct type
+        // using source_ptype / output_ptype.
+        let stages: Vec<MaterializedStage> = self
             .stages
             .iter()
-            .all(|&stage| (stage.num_scalar_ops as u32) <= MAX_SCALAR_OPS)
-    );
+            .map(|(stage, smem_byte_offset, len)| {
+                MaterializedStage::new(
+                    resolve_ptr(stage),
+                    *smem_byte_offset,
+                    *len,
+                    stage.source_ptype,
+                    stage.source,
+                    &stage.scalar_ops,
+                )
+            })
+            .collect();
+
+        Ok(MaterializedPlan {
+            dispatch_plan: CudaDispatchPlan::new(stages, self.output_ptype),
+            device_buffers,
+            shared_mem_bytes,
+        })
+    }
 
-    Ok((DynamicDispatchPlan::new(state.stages), state.device_buffers))
-}
+    /// Inject pre-executed subtree buffers into the placeholder (`None`) slots,
+    /// then materialize.
+    ///
+    /// `subtree_buffers` must correspond 1:1 (in DFS order) to the
+    /// `pending_subtrees` returned by `build`.
+    pub fn materialize_with_subtrees(
+        mut self,
+        subtree_buffers: Vec<BufferHandle>,
+        ctx: &CudaExecutionCtx,
+    ) -> VortexResult<MaterializedPlan> {
+        for (slot, buf) in zip_eq(
+            self.source_buffers.iter_mut().filter(|s| s.is_none()),
+            subtree_buffers,
+        ) {
+            *slot = Some(buf);
+        }
+        self.materialize(ctx)
+    }
 
-/// Internal mutable state for the recursive tree walk.
-struct PlanBuilderState<'a> {
-    ctx: &'a CudaExecutionCtx,
-    /// Stages to process in the dynamic dispatch kernel.
-    stages: Vec<Stage>,
-    /// Next available element offset in shared memory.
-    smem_cursor: u32,
-    /// Device buffers to keep alive.
-    device_buffers: Vec<BufferHandle>,
-}
+    /// Walk the encoding tree, producing a [`Stage`] for the root.
+    fn walk(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        if !is_dyn_dispatch_compatible(&array) {
+            // Subtree can't be fused — record it as a deferred LOAD source.
+            // Bail if dtype is non-primitive (can't become a LOAD stage).
+            let ptype = PType::try_from(array.dtype()).map_err(|_| {
+                vortex_err!(
+                    "unfusable subtree has non-primitive dtype {:?}, cannot partially fuse",
+                    array.dtype()
+                )
+            })?;
+            let buf_idx = self.source_buffers.len();
+            self.source_buffers.push(None); // placeholder, filled at materialize time
+            pending_subtrees.push(array);
+            return Ok(Stage::new(
+                SourceOp::load(),
+                Some(buf_idx),
+                ptype_to_tag(ptype),
+            ));
+        }
 
-impl PlanBuilderState<'_> {
-    /// Recursively walk the encoding tree.
-    fn walk(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
         let id = array.encoding_id();
 
-        if id == BitPackedVTable::ID {
+        if id == BitPacked::ID {
             self.walk_bitpacked(array)
-        } else if id == FoRVTable::ID {
-            self.walk_for(array)
-        } else if id == ZigZagVTable::ID {
-            self.walk_zigzag(array)
-        } else if id == ALPVTable::ID {
-            self.walk_alp(array)
-        } else if id == DictVTable::ID {
-            self.walk_dict(array)
-        } else if id == RunEndVTable::ID {
-            self.walk_runend(array)
-        } else if id == PrimitiveVTable::ID {
+        } else if id == FoR::ID {
+            self.walk_for(array, pending_subtrees)
+        } else if id == ZigZag::ID {
+            self.walk_zigzag(array, pending_subtrees)
+        } else if id == ALP::ID {
+            self.walk_alp(array, pending_subtrees)
+        } else if id == Dict::ID {
+            self.walk_dict(array, pending_subtrees)
+        } else if id == RunEnd::ID {
+            self.walk_runend(array, pending_subtrees)
+        } else if id == Primitive::ID {
             self.walk_primitive(array)
+        } else if id == Slice::ID {
+            self.walk_slice(array, pending_subtrees)
+        } else if id == Sequence::ID {
+            self.walk_sequence(array)
         } else {
             vortex_bail!(
                 "Encoding {:?} not supported by dynamic dispatch plan builder",
@@ -160,82 +440,107 @@ impl PlanBuilderState<'_> {
         }
     }
 
-    /// Canonical primitive array → LOAD source op.
-    fn walk_primitive(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let prim = array.to_canonical()?.into_primitive();
-        let PrimitiveArrayParts { buffer, .. } = prim.into_parts();
-        let device_buf = block_on(self.ctx.ensure_on_device(buffer))?;
-        let ptr = device_buf.cuda_device_ptr()?;
-        self.device_buffers.push(device_buf);
-        Ok(Pipeline {
-            source: SourceOp::load(),
-            scalar_ops: vec![],
-            input_ptr: ptr,
-        })
+    /// SliceArray → resolve the slice via reduce/execute rules.
+    ///
+    /// When the plan builder encounters a `SliceArray`, it resolves the slice
+    /// by invoking the child's `reduce_parent`, `execute_parent`.
+    fn walk_slice(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let slice_arr = array.as_::<Slice>();
+        let child = slice_arr.child().clone();
+
+        if let Some(reduced) = child.reduce_parent(&array, 0)? {
+            return self.walk(reduced, pending_subtrees);
+        }
+
+        vortex_bail!(
+            "Cannot resolve SliceArray wrapping {:?} in dynamic dispatch plan builder",
+            child.encoding_id()
+        )
     }
 
-    /// BitPackedArray → BITUNPACK source op.
-    fn walk_bitpacked(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let bp = array
-            .try_into::<BitPackedVTable>()
-            .map_err(|_| vortex_err!("Expected BitPackedArray"))?;
-        let BitPackedArrayParts {
-            offset,
-            bit_width,
-            packed,
-            patches,
-            ..
-        } = bp.into_parts();
-
-        if offset != 0 {
-            vortex_bail!(
-                "Dynamic dispatch does not support sliced BitPackedArray (offset={offset})"
-            );
-        }
-        if patches.is_some() {
+    fn walk_primitive(&mut self, array: ArrayRef) -> VortexResult<Stage> {
+        let prim = array.as_::<Primitive>();
+        let buf_index = self.source_buffers.len();
+        self.source_buffers.push(Some(prim.buffer_handle().clone()));
+        Ok(Stage::new(
+            SourceOp::load(),
+            Some(buf_index),
+            ptype_to_tag(prim.ptype()),
+        ))
+    }
+
+    fn walk_bitpacked(&mut self, array: ArrayRef) -> VortexResult<Stage> {
+        let bp = array.as_::<BitPacked>();
+
+        if bp.patches().is_some() {
             vortex_bail!("Dynamic dispatch does not support BitPackedArray with patches");
         }
 
-        let device_buf = block_on(self.ctx.ensure_on_device(packed))?;
-        let ptr = device_buf.cuda_device_ptr()?;
-        self.device_buffers.push(device_buf);
-        Ok(Pipeline {
-            source: SourceOp::bitunpack(bit_width),
-            scalar_ops: vec![],
-            input_ptr: ptr,
-        })
+        let source_ptype = ptype_to_tag(PType::try_from(bp.dtype()).map_err(|_| {
+            vortex_err!("BitPacked must have primitive dtype, got {:?}", bp.dtype())
+        })?);
+        let buf_index = self.source_buffers.len();
+        self.source_buffers.push(Some(bp.packed().clone()));
+        Ok(Stage::new(
+            SourceOp::bitunpack(bp.bit_width(), bp.offset()),
+            Some(buf_index),
+            source_ptype,
+        ))
     }
 
-    /// FoRArray → recurse into encoded child, add FoR scalar op.
-    fn walk_for(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let for_arr = array
-            .try_into::<FoRVTable>()
-            .map_err(|_| vortex_err!("Expected FoRArray"))?;
-        let ref_u64 = extract_for_reference(&for_arr)?;
+    fn walk_for(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let for_arr = array.as_::<FoR>();
+        let ref_pvalue = for_arr
+            .reference_scalar()
+            .as_primitive()
+            .pvalue()
+            .ok_or_else(|| vortex_err!("FoR reference scalar is null"))?;
         let encoded = for_arr.encoded().clone();
-
-        let mut pipeline = self.walk(encoded)?;
-        pipeline.scalar_ops.push(ScalarOp::frame_of_ref(ref_u64));
+        let output_ptype =
+            ptype_to_tag(PType::try_from(array.dtype()).map_err(|_| {
+                vortex_err!("FoR must have primitive dtype, got {:?}", array.dtype())
+            })?);
+
+        let mut pipeline = self.walk(encoded, pending_subtrees)?;
+        let ref_u64 = ref_pvalue
+            .reinterpret_cast(ref_pvalue.ptype().to_unsigned())
+            .cast::<u64>()?;
+        pipeline
+            .scalar_ops
+            .push(ScalarOp::frame_of_ref(ref_u64, output_ptype));
         Ok(pipeline)
     }
 
-    /// ZigZagArray → recurse into encoded child, add ZigZag scalar op.
-    fn walk_zigzag(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let zz = array
-            .try_into::<ZigZagVTable>()
-            .map_err(|_| vortex_err!("Expected ZigZagArray"))?;
+    fn walk_zigzag(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let zz = array.as_::<ZigZag>();
         let encoded = zz.encoded().clone();
+        let output_ptype = ptype_to_tag(PType::try_from(array.dtype()).map_err(|_| {
+            vortex_err!("ZigZag must have primitive dtype, got {:?}", array.dtype())
+        })?);
 
-        let mut pipeline = self.walk(encoded)?;
-        pipeline.scalar_ops.push(ScalarOp::zigzag());
+        let mut pipeline = self.walk(encoded, pending_subtrees)?;
+        pipeline.scalar_ops.push(ScalarOp::zigzag(output_ptype));
         Ok(pipeline)
     }
 
-    /// ALPArray → recurse into encoded child, add ALP scalar op (f32 only).
-    fn walk_alp(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let alp = array
-            .try_into::<ALPVTable>()
-            .map_err(|_| vortex_err!("Expected ALPArray"))?;
+    fn walk_alp(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let alp = array.as_::<ALP>();
 
         if alp.patches().is_some() {
             vortex_bail!("Dynamic dispatch does not support ALPArray with patches");
@@ -254,75 +559,159 @@ impl PlanBuilderState<'_> {
         let alp_e = <f32 as ALPFloat>::IF10[exponents.e as usize];
         let encoded = alp.encoded().clone();
 
-        let mut pipeline = self.walk(encoded)?;
+        let mut pipeline = self.walk(encoded, pending_subtrees)?;
         pipeline.scalar_ops.push(ScalarOp::alp(alp_f, alp_e));
         Ok(pipeline)
     }
 
-    /// DictArray → add input stage for values, recurse into codes, add DICT scalar op.
-    fn walk_dict(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let dict = array
-            .try_into::<DictVTable>()
-            .map_err(|_| vortex_err!("Expected DictArray"))?;
+    /// Handle a child array whose element width differs from the output type.
+    ///
+    /// If the child is a `Primitive`, its buffer is grabbed directly as a LOAD
+    /// source — no separate kernel launch needed, since `load_element<T>()`
+    /// handles the widening in-kernel. Otherwise, the child is recorded as a
+    /// pending subtree for separate execution.
+    fn walk_mixed_width_child(
+        &mut self,
+        child: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let ptype = PType::try_from(child.dtype())?;
+        if child.encoding_id() == Primitive::ID {
+            return self.walk_primitive(child);
+        }
+        let buf_idx = self.source_buffers.len();
+        self.source_buffers.push(None);
+        pending_subtrees.push(child);
+        Ok(Stage::new(
+            SourceOp::load(),
+            Some(buf_idx),
+            ptype_to_tag(ptype),
+        ))
+    }
+
+    fn walk_dict(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let dict = array.as_::<Dict>();
         let values = dict.values().clone();
         let codes = dict.codes().clone();
 
-        let values_smem_offset = self.add_input_stage(values)?;
+        let values_ptype = PType::try_from(values.dtype())?;
+        let values_elem_bytes = values_ptype.byte_width() as u32;
+        let codes_ptype = PType::try_from(codes.dtype())?;
+        let codes_elem_bytes = codes_ptype.byte_width() as u32;
+
+        // If values have a different width than the output type, they
+        // can't be fused into the same kernel instantiation. Primitives
+        // are handled directly (just grab the buffer); other encodings
+        // become pending subtrees executed by a separate kernel.
+        let values_len = values.len() as u32;
+        let values_spec = if values_elem_bytes != self.output_elem_bytes {
+            self.walk_mixed_width_child(values, pending_subtrees)?
+        } else {
+            self.walk(values, pending_subtrees)?
+        };
+        let values_smem_byte_offset = self.push_smem_stage(values_spec, values_len);
 
-        let mut pipeline = self.walk(codes)?;
-        pipeline.scalar_ops.push(ScalarOp::dict(values_smem_offset));
+        // Same for codes.
+        let mut pipeline = if codes_elem_bytes != self.output_elem_bytes {
+            self.walk_mixed_width_child(codes, pending_subtrees)?
+        } else {
+            self.walk(codes, pending_subtrees)?
+        };
+        // DICT scalar op: pass byte offset directly (C ABI uses byte offsets).
+        // output_ptype is the values' ptype — DICT transforms codes → values.
+        pipeline.scalar_ops.push(ScalarOp::dict(
+            values_smem_byte_offset,
+            ptype_to_tag(values_ptype),
+        ));
         Ok(pipeline)
     }
 
-    /// RunEndArray → add input stages for ends and values, RUNEND source op.
-    fn walk_runend(&mut self, array: ArrayRef) -> VortexResult<Pipeline> {
-        let re = array
-            .try_into::<RunEndVTable>()
-            .map_err(|_| vortex_err!("Expected RunEndArray"))?;
-        let offset = re.offset() as u64;
-        let RunEndArrayParts { ends, values } = re.into_parts();
-        let num_runs = ends.len() as u64;
+    fn walk_sequence(&mut self, array: ArrayRef) -> VortexResult<Stage> {
+        let seq = array.as_::<Sequence>();
 
-        let ends_smem = self.add_input_stage(ends)?;
-        let values_smem = self.add_input_stage(values)?;
-
-        Ok(Pipeline {
-            source: SourceOp::runend(ends_smem, values_smem, num_runs, offset),
-            scalar_ops: vec![],
-            input_ptr: 0,
-        })
+        Ok(Stage::new(
+            SourceOp::sequence(seq.base().cast()?, seq.multiplier().cast()?),
+            None,
+            self.output_ptype,
+        ))
     }
 
-    /// Recursively walk `array` and add it as an input stage in shared memory.
-    /// Claims the next `array.len()` elements from the bump allocator and
-    /// returns the smem element offset where this stage's output begins.
-    fn add_input_stage(&mut self, array: ArrayRef) -> VortexResult<u32> {
-        let smem_offset = self.smem_cursor;
-        let len = array.len() as u32;
-        let pipeline = self.walk(array)?;
-        self.stages.push(Stage::input(
-            pipeline.input_ptr,
-            smem_offset,
-            len,
-            pipeline.source,
-            &pipeline.scalar_ops,
-        ));
-        self.smem_cursor += len;
-        Ok(smem_offset)
+    fn walk_runend(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let re = array.as_::<RunEnd>();
+        let offset = re.offset() as u64;
+        let ends = re.ends().clone();
+        let values = re.values().clone();
+        let num_runs = ends.len() as u32;
+        let num_values = values.len() as u32;
+
+        let ends_ptype = PType::try_from(ends.dtype())?;
+        let ends_elem_bytes = ends_ptype.byte_width() as u32;
+        let values_ptype = PType::try_from(values.dtype())?;
+        let values_elem_bytes = values_ptype.byte_width() as u32;
+
+        // If ends or values have a different width than the output type,
+        // they can't be fused into the same kernel instantiation.
+        // Primitives are handled directly; others become pending subtrees.
+        let ends_spec = if ends_elem_bytes != self.output_elem_bytes {
+            self.walk_mixed_width_child(ends, pending_subtrees)?
+        } else {
+            self.walk(ends, pending_subtrees)?
+        };
+        let ends_smem_byte_offset = self.push_smem_stage(ends_spec, num_runs);
+
+        let values_spec = if values_elem_bytes != self.output_elem_bytes {
+            self.walk_mixed_width_child(values, pending_subtrees)?
+        } else {
+            self.walk(values, pending_subtrees)?
+        };
+        let values_smem_byte_offset = self.push_smem_stage(values_spec, num_values);
+
+        // Pass byte offsets and PTypeTags directly — the C ABI now uses
+        // byte offsets and per-field ptype tags for cross-stage references.
+        Ok(Stage::new(
+            SourceOp::runend(
+                ends_smem_byte_offset,
+                values_smem_byte_offset,
+                num_runs as u64,
+                offset,
+            ),
+            None,
+            self.output_ptype,
+        ))
     }
-}
 
-/// Extract a FoR reference scalar as u64 bits.
-fn extract_for_reference(for_arr: &vortex::encodings::fastlanes::FoRArray) -> VortexResult<u64> {
-    if let Ok(v) = u32::try_from(for_arr.reference_scalar()) {
-        Ok(v as u64)
-    } else if let Ok(v) = i32::try_from(for_arr.reference_scalar()) {
-        Ok(v as u32 as u64)
-    } else if let Ok(v) = u64::try_from(for_arr.reference_scalar()) {
-        Ok(v)
-    } else if let Ok(v) = i64::try_from(for_arr.reference_scalar()) {
-        Ok(v as u64)
-    } else {
-        vortex_bail!("Cannot extract FoR reference as an integer type")
+    /// Add a stage that decodes fully into shared memory before the output
+    /// stage runs. Returns the shared memory byte offset where the data starts.
+    ///
+    /// The smem region is sized at the stage's output ptype width — i.e.
+    /// the ptype after all scalar ops have run. For stages that go through
+    /// type-changing scalar ops (e.g. dict values with FoR→ALP), the final
+    /// smem footprint is `len × final_ptype_byte_width`. If there are no
+    /// scalar ops, the source_ptype determines the width.
+    fn push_smem_stage(&mut self, spec: Stage, len: u32) -> u32 {
+        let smem_byte_offset = self.smem_byte_cursor;
+        // The kernel's execute_input_stage<T> always writes T-wide elements
+        // 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 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
     }
 }
diff --git a/vortex-cuda/src/executor.rs b/vortex-cuda/src/executor.rs
index c073b9bad0a..1d6d1db76c3 100644
--- a/vortex-cuda/src/executor.rs
+++ b/vortex-cuda/src/executor.rs
@@ -9,21 +9,19 @@ use async_trait::async_trait;
 use cudarc::driver::CudaEvent;
 use cudarc::driver::CudaFunction;
 use cudarc::driver::CudaSlice;
-use cudarc::driver::CudaStream;
 use cudarc::driver::DeviceRepr;
 use cudarc::driver::LaunchArgs;
 use cudarc::driver::LaunchConfig;
 use futures::future::BoxFuture;
 use tracing::debug;
 use tracing::trace;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
+use vortex::array::arrays::Struct;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::StructArrayParts;
-use vortex::array::arrays::StructVTable;
+use vortex::array::arrays::struct_::StructDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::dtype::PType;
 use vortex::error::VortexResult;
@@ -31,6 +29,7 @@ use vortex::error::vortex_err;
 
 use crate::CudaSession;
 use crate::ExportDeviceArray;
+use crate::hybrid_dispatch;
 use crate::kernel::DefaultLaunchStrategy;
 use crate::kernel::LaunchStrategy;
 use crate::kernel::LaunchStrategyExt;
@@ -80,6 +79,11 @@ impl CudaExecutionCtx {
         }
     }
 
+    /// Get a mutable handle to the CPU execution context.
+    pub fn execution_ctx(&mut self) -> &mut ExecutionCtx {
+        &mut self.ctx
+    }
+
     /// Set the launch strategy for the execution context.
     ///
     /// This can only be set on setup (an "owned" context) and not from within
@@ -101,7 +105,7 @@ impl CudaExecutionCtx {
     ) -> VortexResult<()> {
         self.strategy
             .as_ref()
-            .with_strategy(&self.stream.0, len, function)
+            .with_strategy(&self.stream, len, function)
     }
 
     /// Launch a Kernel function with args setup done by the provided `build_args` closure.
@@ -123,9 +127,6 @@ impl CudaExecutionCtx {
 
         let events = launch_cuda_kernel_impl(&mut launcher, self.strategy.event_flags(), len)?;
         self.strategy.on_complete(&events, len)?;
-
-        drop(events);
-
         Ok(())
     }
 
@@ -147,9 +148,6 @@ impl CudaExecutionCtx {
         let events =
             launch_cuda_kernel_with_config(&mut launcher, cfg, self.strategy.event_flags())?;
         self.strategy.on_complete(&events, len)?;
-
-        drop(events);
-
         Ok(())
     }
 
@@ -163,13 +161,9 @@ impl CudaExecutionCtx {
     /// # Errors
     ///
     /// Returns an error if kernel loading fails.
-    pub fn load_function_ptype(
-        &self,
-        module_name: &str,
-        ptypes: &[PType],
-    ) -> VortexResult<CudaFunction> {
+    pub fn load_function(&self, module_name: &str, ptypes: &[PType]) -> VortexResult<CudaFunction> {
         let type_suffixes: Vec<String> = ptypes.iter().map(|ptype| ptype.to_string()).collect();
-        self.load_function(
+        self.load_function_with_suffixes(
             module_name,
             type_suffixes
                 .iter()
@@ -181,8 +175,8 @@ impl CudaExecutionCtx {
 
     /// Loads a CUDA kernel function by module name and type suffixes.
     ///
-    /// This is a lower-level version of `load_function` that accepts string suffixes
-    /// directly, useful for types that don't have a `PType` (e.g., i128, i256).
+    /// This is a lower-level version of [`load_function`][Self::load_function] that accepts
+    /// string suffixes directly, useful for types that don't have a `PType` (e.g., i128, i256).
     ///
     /// # Arguments
     ///
@@ -192,7 +186,7 @@ impl CudaExecutionCtx {
     /// # Errors
     ///
     /// Returns an error if kernel loading fails.
-    pub fn load_function(
+    pub(crate) fn load_function_with_suffixes(
         &self,
         module_name: &str,
         type_suffixes: &[&str],
@@ -209,10 +203,10 @@ impl CudaExecutionCtx {
     ///
     /// * `func` - CUDA kernel function to launch
     pub fn launch_builder<'a>(&'a self, func: &'a CudaFunction) -> LaunchArgs<'a> {
-        self.stream.0.launch_builder(func)
+        self.stream.launch_builder(func)
     }
 
-    /// See `VortexCudaStream::device_alloc`.
+    /// Allocates a typed buffer on the GPU.
     pub fn device_alloc<T: DeviceRepr + Send + Sync + 'static>(
         &self,
         len: usize,
@@ -239,7 +233,7 @@ impl CudaExecutionCtx {
     /// Ensures a buffer is resident on the device, copying from host if necessary.
     ///
     /// If the buffer is already on the device it is returned as-is. Otherwise
-    /// delegates to `copy_to_device`.
+    /// copies from host to device.
     pub async fn ensure_on_device(&self, handle: BufferHandle) -> VortexResult<BufferHandle> {
         if handle.is_on_device() {
             return Ok(handle);
@@ -251,9 +245,28 @@ impl CudaExecutionCtx {
         self.stream.copy_to_device(host_buffer)?.await
     }
 
-    /// Returns a reference to the underlying CUDA stream.
-    pub fn stream(&self) -> &Arc<CudaStream> {
-        &self.stream.0
+    /// Synchronous variant of [`ensure_on_device`](Self::ensure_on_device).
+    ///
+    /// Safe to call from within an async executor (no nested `block_on`).
+    /// The copy is enqueued on the stream and completes before any subsequent
+    /// work on the same stream.
+    pub fn ensure_on_device_sync(&self, handle: BufferHandle) -> VortexResult<BufferHandle> {
+        if handle.is_on_device() {
+            return Ok(handle);
+        }
+        let host_buffer = handle
+            .as_host_opt()
+            .ok_or_else(|| vortex_err!("Buffer is not on host"))?
+            .clone();
+        self.stream.copy_to_device_sync(host_buffer.as_ref())
+    }
+
+    /// Returns a reference to the underlying [`VortexCudaStream`].
+    ///
+    /// Through [`Deref`][std::ops::Deref], this also provides access to the
+    /// inner [`Arc<CudaStream>`] and all of cudarc's stream methods.
+    pub fn stream(&self) -> &VortexCudaStream {
+        &self.stream
     }
 
     /// Returns the Vortex session backing this CUDA execution context.
@@ -262,10 +275,21 @@ impl CudaExecutionCtx {
         self.ctx.session()
     }
 
+    /// Returns a reference to the CUDA session.
+    pub(crate) fn cuda_session(&self) -> &CudaSession {
+        &self.cuda_session
+    }
+
     /// Get a handle to the exporter that can convert arrays into `ArrowDeviceArray`.
     pub fn exporter(&self) -> &Arc<dyn ExportDeviceArray> {
         self.cuda_session.export_device_array()
     }
+
+    pub fn synchronize_stream(&self) -> VortexResult<()> {
+        self.stream
+            .synchronize()
+            .map_err(|e| vortex_err!("cuda error: {e}"))
+    }
 }
 
 /// Support trait for CUDA-accelerated decompression of arrays.
@@ -312,7 +336,7 @@ pub trait CudaExecute: 'static + Send + Sync + Debug {
 
 /// Extension trait for executing arrays on CUDA.
 #[async_trait]
-pub trait CudaArrayExt: Array {
+pub trait CudaArrayExt {
     /// Recursively walks the encoding tree, dispatching each layer to its
     /// registered [`CudaExecute`] implementation and returning a canonical array
     /// on the device.
@@ -328,14 +352,14 @@ pub trait CudaArrayExt: Array {
 impl CudaArrayExt for ArrayRef {
     #[allow(clippy::unwrap_in_result, clippy::unwrap_used)]
     async fn execute_cuda(self, ctx: &mut CudaExecutionCtx) -> VortexResult<Canonical> {
-        if self.encoding_id() == StructVTable::ID {
+        if self.encoding_id() == Struct::ID {
             let len = self.len();
-            let StructArrayParts {
+            let StructDataParts {
                 fields,
                 struct_fields,
                 validity,
                 ..
-            } = self.try_into::<StructVTable>().unwrap().into_parts();
+            } = self.try_downcast::<Struct>().unwrap().into_data_parts();
 
             let mut cuda_fields = Vec::with_capacity(fields.len());
             for field in fields.iter() {
@@ -355,29 +379,21 @@ impl CudaArrayExt for ArrayRef {
             return self.execute(&mut ctx.ctx);
         }
 
-        let Some(support) = ctx.cuda_session.kernel(&self.encoding_id()) else {
-            debug!(
-                encoding = %self.encoding_id(),
-                "No CUDA support registered for encoding, falling back to CPU execution"
-            );
-            return self.execute(&mut ctx.ctx);
-        };
-
-        debug!(
-            encoding = %self.encoding_id(),
-            "Executing array on CUDA device"
-        );
-
-        support.execute(self, ctx).await
-    }
-}
+        // Try all GPU execution strategies: fused dynamic dispatch, partial
+        // fusion with subtree fallbacks, and single-kernel fallback.
+        // If none succeed, fall back to CPU execution.
+        match hybrid_dispatch::try_gpu_dispatch(&self, ctx).await {
+            Ok(canonical) => return Ok(canonical),
+            Err(e) => {
+                debug!(
+                    encoding = %self.encoding_id(),
+                    error = %e,
+                    "No GPU execution path available, falling back to CPU"
+                );
+            }
+        }
 
-#[cfg(feature = "_test-harness")]
-impl CudaExecutionCtx {
-    pub fn synchronize_stream(&self) -> VortexResult<()> {
-        self.stream
-            .0
-            .synchronize()
-            .map_err(|e| vortex_err!("cuda error: {e}"))
+        // TODO(0ax1): Double check whether we need to move buffers back to the host explicitly.
+        self.execute(&mut ctx.ctx)
     }
 }
diff --git a/vortex-cuda/src/hybrid_dispatch/mod.rs b/vortex-cuda/src/hybrid_dispatch/mod.rs
new file mode 100644
index 00000000000..0845a46fdc3
--- /dev/null
+++ b/vortex-cuda/src/hybrid_dispatch/mod.rs
@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Hybrid dispatch: fuses dynamic-dispatch plans with single-kernel fallbacks.
+//!
+//! When an array is executed on the GPU, we fuse as much of its encoding
+//! tree as possible into a single kernel launch via [`DispatchPlan`].
+//! Unfusable subtrees are identified automatically by [`DispatchPlan::new`],
+//! executed by their own kernels, and their outputs fed back into the fused
+//! plan as `LOAD` sources via `FusedPlan::materialize_with_subtrees`.
+//!
+//! ```text
+//!   Dict                       <-- fusable
+//!   ├── codes: FoR(BP)         <-- fusable
+//!   └── values: Zstd(FoR(BP)) <-- Zstd is NOT fusable (unfusable node)
+//!                 └── FoR(BP)  <-- fusable (fuses inside the subtree)
+//! ```
+//!
+//! Strategies tried in order:
+//!
+//! 1. Fully fused — no unfusable nodes, entire tree compiles into one
+//!    [`DispatchPlan`] → `MaterializedPlan` → kernel launch.
+//!
+//! 2. Partial fusion — `pending_subtrees` from the `PartiallyFused`
+//!    variant are executed first (sequentially, same stream), their device buffers
+//!    become `LOAD` ops in a fused plan via `FusedPlan::materialize_with_subtrees`.
+//!    Each subtree re-enters [`try_gpu_dispatch`] and may itself fuse.
+//!    When a subtree's ptype differs from the output ptype (e.g. `u8` dict
+//!    codes in a `u32` Dict), widening from the subtree's native width to `T`
+//!    happens in-kernel via `load_element<T>()` in the LOAD source op — no
+//!    separate widen pass is needed.
+//!
+//! 3. Fallback — root is not fusable. Delegate to its registered
+//!    `CudaExecute` kernel; its children re-enter [`try_gpu_dispatch`].
+//!
+//! All three compose recursively to arbitrary depth.
+//!
+//! Zone-map pruning is handled by ZonedReader before chunks reach the plan
+//! builder. Filtering within a chunk is done after decompression, not as push-down.
+//!
+//! ```text
+//!   ZonedReader (zone-map pruning, skips whole chunks)
+//!     └── CudaFlatReader (per chunk)
+//!           └── try_gpu_dispatch
+//!                 └── FilterExecutor (CUB DeviceSelect on full output)
+//! ```
+
+use tracing::trace;
+use vortex::array::ArrayRef;
+use vortex::array::Canonical;
+use vortex::error::VortexResult;
+use vortex::error::vortex_err;
+
+use crate::dynamic_dispatch::plan_builder::DispatchPlan;
+use crate::executor::CudaArrayExt;
+use crate::executor::CudaExecutionCtx;
+
+/// Try to execute `array` on the GPU, attempting three strategies in order:
+///
+/// 1. Fully fused — [`DispatchPlan::new`] + `FusedPlan::materialize`.
+/// 2. Partially fused — pending subtrees executed first, then
+///    `FusedPlan::materialize_with_subtrees`.
+/// 3. Fallback — root encoding's `CudaExecute` kernel; children
+///    re-enter this function recursively.
+///
+/// Returns `Ok(Canonical)` on success. Returns `Err` when the array
+/// cannot be handled (non-primitive output dtype, no registered kernel).
+#[allow(clippy::cognitive_complexity)]
+pub async fn try_gpu_dispatch(
+    array: &ArrayRef,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<Canonical> {
+    trace!(encoding = %array.encoding_id(), dtype = ?array.dtype(), len = array.len(), "try GPU dispatch");
+
+    match DispatchPlan::new(array)? {
+        DispatchPlan::Fused(plan) => {
+            let materialized = plan.materialize(ctx)?;
+            let num_stages = materialized.dispatch_plan.num_stages();
+            trace!(encoding = %array.encoding_id(), num_stages, "fully-fused dispatch");
+            materialized.execute(array.len(), ctx)
+        }
+        DispatchPlan::PartiallyFused {
+            plan,
+            pending_subtrees,
+        } => {
+            let mut subtree_buffers = Vec::with_capacity(pending_subtrees.len());
+
+            // TODO(0ax1): execute subtrees concurrently using separate CUDA streams.
+            for subtree in &pending_subtrees {
+                let canonical = subtree.clone().execute_cuda(ctx).await?;
+                let buffer = canonical.into_primitive().into_data_parts().buffer;
+                subtree_buffers.push(buffer);
+            }
+
+            let num_subtrees = subtree_buffers.len();
+            let materialized = plan.materialize_with_subtrees(subtree_buffers, ctx)?;
+            let num_stages = materialized.dispatch_plan.num_stages();
+            trace!(encoding = %array.encoding_id(), num_stages, num_subtrees, "partially-fused dispatch");
+            materialized.execute(array.len(), ctx)
+        }
+        DispatchPlan::Unfused => {
+            // Unfused kernel dispatch fallback.
+            ctx.cuda_session()
+                .kernel(&array.encoding_id())
+                .ok_or_else(|| {
+                    vortex_err!("No CUDA kernel for encoding {:?}", array.encoding_id())
+                })?
+                .execute(array.clone(), ctx)
+                .await
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex::array::IntoArray;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::assert_arrays_eq;
+    use vortex::array::validity::Validity::NonNullable;
+    use vortex::buffer::Buffer;
+    use vortex::encodings::fastlanes::BitPacked;
+    use vortex::encodings::fastlanes::FoR;
+    use vortex::error::VortexExpect;
+    use vortex::error::VortexResult;
+    use vortex::mask::Mask;
+    use vortex::session::VortexSession;
+
+    use crate::CanonicalCudaExt;
+    use crate::executor::CudaArrayExt;
+    use crate::session::CudaSession;
+
+    /// FoR(BitPacked) u32 — entire tree compiles into a single fused plan.
+    #[crate::test]
+    async fn test_fused() -> VortexResult<()> {
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+        let values: Vec<u32> = (0..2048).map(|i| (i % 128) as u32).collect();
+        let bp = BitPacked::encode(
+            &PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(),
+            7,
+        )
+        .vortex_expect("bp");
+        let arr = FoR::try_new(bp.into_array(), 1000u32.into()).vortex_expect("for");
+
+        let cpu = arr.to_canonical()?.into_array();
+        let gpu = arr
+            .into_array()
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(cpu, gpu);
+        Ok(())
+    }
+
+    /// ALP(FoR(BP)) f32 — fully fused, output is f32 but kernel runs as u32.
+    /// Exercises the unsigned type reinterpretation in CudaDispatchPlan::execute.
+    #[crate::test]
+    async fn test_fused_f32() -> VortexResult<()> {
+        use vortex::encodings::alp::ALP;
+        use vortex::encodings::alp::Exponents;
+
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+        let encoded: Vec<i32> = (0i32..2048).map(|i| i % 500).collect();
+        let bp = BitPacked::encode(
+            &PrimitiveArray::new(Buffer::from(encoded), NonNullable).into_array(),
+            9,
+        )
+        .vortex_expect("bp");
+        let alp = ALP::try_new(
+            FoR::try_new(bp.into_array(), 0i32.into())
+                .vortex_expect("for")
+                .into_array(),
+            Exponents { e: 0, f: 2 },
+            None,
+        )?;
+
+        let cpu = alp.to_canonical()?.into_array();
+        let gpu = alp
+            .into_array()
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(cpu, gpu);
+        Ok(())
+    }
+
+    /// ALP with patches — plan builder rejects it, falls back to ALPExecutor.
+    #[crate::test]
+    async fn test_fallback() -> VortexResult<()> {
+        use vortex::array::patches::Patches;
+        use vortex::array::validity::Validity::NonNullable as NN;
+        use vortex::buffer::buffer;
+        use vortex::encodings::alp::ALP;
+        use vortex::encodings::alp::Exponents;
+
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+        let encoded = PrimitiveArray::new(
+            Buffer::from((0i32..2048).map(|i| i % 500).collect::<Vec<_>>()),
+            NonNullable,
+        )
+        .into_array();
+        let patches = Patches::new(
+            2048,
+            0,
+            PrimitiveArray::new(buffer![0u32, 1024u32], NN).into_array(),
+            PrimitiveArray::new(buffer![99.9f32, 88.8f32], NN).into_array(),
+            None,
+        )
+        .unwrap();
+        let arr = ALP::try_new(encoded, Exponents { e: 0, f: 2 }, Some(patches))?;
+
+        let cpu = arr.to_canonical()?.into_array();
+        let gpu = arr
+            .into_array()
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(cpu, gpu);
+        Ok(())
+    }
+
+    /// Dict(values=ZstdBuffers(FoR(BP)), codes=FoR(BP)) — ZstdBuffers is
+    /// executed separately, then Dict+FoR+BP fuses with its output as a LOAD.
+    /// 3 launches: nvcomp + fused FoR+BP + fused LOAD+FoR+BP+DICT.
+    #[cfg(feature = "unstable_encodings")]
+    #[crate::test]
+    async fn test_partial_fusion() -> VortexResult<()> {
+        use vortex::array::arrays::DictArray;
+        use vortex::array::session::ArraySessionExt;
+        use vortex::encodings::fastlanes;
+        use vortex::encodings::zstd::ZstdBuffers;
+
+        let session = VortexSession::empty();
+        fastlanes::initialize(&session);
+        session.arrays().register(ZstdBuffers);
+        let mut ctx = CudaSession::create_execution_ctx(&session).vortex_expect("ctx");
+
+        let num_values: u32 = 64;
+        let len: u32 = 2048;
+
+        // values = ZstdBuffers(FoR(BitPacked))
+        let vals = PrimitiveArray::new(
+            Buffer::from((0..num_values).collect::<Vec<_>>()),
+            NonNullable,
+        )
+        .into_array();
+        let vals = FoR::try_new(
+            BitPacked::encode(&vals, 6).vortex_expect("bp").into_array(),
+            0u32.into(),
+        )
+        .vortex_expect("for");
+        let vals = ZstdBuffers::compress(&vals.into_array(), 3, &VortexSession::empty())
+            .vortex_expect("zstd");
+
+        // codes = FoR(BitPacked)
+        let codes = PrimitiveArray::new(
+            Buffer::from((0..len).map(|i| i % num_values).collect::<Vec<_>>()),
+            NonNullable,
+        )
+        .into_array();
+        let codes = FoR::try_new(
+            BitPacked::encode(&codes, 6)
+                .vortex_expect("bp")
+                .into_array(),
+            0u32.into(),
+        )
+        .vortex_expect("for");
+
+        let dict = DictArray::try_new(codes.into_array(), vals.into_array()).vortex_expect("dict");
+
+        let cpu = PrimitiveArray::new(
+            Buffer::from((0..len).map(|i| i % num_values).collect::<Vec<_>>()),
+            NonNullable,
+        )
+        .into_array();
+        let gpu = dict
+            .into_array()
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(cpu, gpu);
+        Ok(())
+    }
+
+    /// Filter(FoR(BP), mask) — FoR+BP fuses via dyn dispatch, then CUB filters the result.
+    #[crate::test]
+    async fn test_filter_fused_child() -> VortexResult<()> {
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+
+        let len = 2048u32;
+        let data: Vec<u32> = (0..len).map(|i| i % 128).collect();
+        let bp = BitPacked::encode(
+            &PrimitiveArray::new(Buffer::from(data.clone()), NonNullable).into_array(),
+            7,
+        )
+        .vortex_expect("bp");
+        let for_arr = FoR::try_new(bp.into_array(), 100u32.into()).vortex_expect("for");
+
+        // Keep every other element.
+        let mask = Mask::from_iter((0..len as usize).map(|i| i % 2 == 0));
+        let filtered = for_arr.into_array().filter(mask)?;
+
+        let expected: Vec<u32> = data.iter().step_by(2).map(|v| v + 100).collect();
+        let cpu = PrimitiveArray::new(Buffer::from(expected), NonNullable).into_array();
+        let gpu = filtered
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(cpu, gpu);
+        Ok(())
+    }
+}
diff --git a/vortex-cuda/src/kernel/arrays/constant.rs b/vortex-cuda/src/kernel/arrays/constant.rs
index 2358ddd0c37..2164378b9e9 100644
--- a/vortex-cuda/src/kernel/arrays/constant.rs
+++ b/vortex-cuda/src/kernel/arrays/constant.rs
@@ -10,8 +10,8 @@ use cudarc::driver::PushKernelArg;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
+use vortex::array::arrays::Constant;
 use vortex::array::arrays::ConstantArray;
-use vortex::array::arrays::ConstantVTable;
 use vortex::array::arrays::DecimalArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::buffer::BufferHandle;
@@ -26,7 +26,6 @@ use vortex::dtype::NativePType;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaDeviceBuffer;
 use crate::executor::CudaExecute;
@@ -41,7 +40,7 @@ pub(crate) struct ConstantNumericExecutor;
 
 impl ConstantNumericExecutor {
     fn try_specialize(array: ArrayRef) -> Option<ConstantArray> {
-        array.try_into::<ConstantVTable>().ok()
+        array.try_downcast::<Constant>().ok()
     }
 }
 
@@ -113,7 +112,7 @@ where
 
     // Load kernel function
     let kernel_ptypes = [P::PTYPE];
-    let cuda_function = ctx.load_function_ptype("constant_numeric", &kernel_ptypes)?;
+    let cuda_function = ctx.load_function("constant_numeric", &kernel_ptypes)?;
 
     ctx.launch_kernel(&cuda_function, array_len, |args| {
         args.arg(&output_view);
@@ -169,7 +168,8 @@ where
     let array_len_u64 = array_len as u64;
 
     // Load kernel function
-    let cuda_function = ctx.load_function("constant_numeric", &[&D::DECIMAL_TYPE.to_string()])?;
+    let cuda_function =
+        ctx.load_function_with_suffixes("constant_numeric", &[&D::DECIMAL_TYPE.to_string()])?;
 
     ctx.launch_kernel(&cuda_function, array_len, |args| {
         args.arg(&output_view);
@@ -189,7 +189,7 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -220,7 +220,7 @@ mod tests {
     #[case::i64(make_constant_array(-1000000i64, 2050))]
     #[case::f32(make_constant_array(1.23f32, 2050))]
     #[case::f64(make_constant_array(4.56789f64, 2050))]
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_constant_materialization(
         #[case] constant_array: ConstantArray,
     ) -> VortexResult<()> {
@@ -230,7 +230,7 @@ mod tests {
         let cpu_result = constant_array.to_canonical()?;
 
         let gpu_result = ConstantNumericExecutor
-            .execute(constant_array.to_array(), &mut cuda_ctx)
+            .execute(constant_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU materialization failed")
             .into_host()
@@ -242,7 +242,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_constant_empty_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -251,7 +251,7 @@ mod tests {
         let cpu_result = constant_array.to_canonical()?;
 
         let gpu_result = ConstantNumericExecutor
-            .execute(constant_array.to_array(), &mut cuda_ctx)
+            .execute(constant_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU materialization failed")
             .into_host()
@@ -263,7 +263,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_constant_small_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -273,7 +273,7 @@ mod tests {
         let cpu_result = constant_array.to_canonical()?;
 
         let gpu_result = ConstantNumericExecutor
-            .execute(constant_array.to_array(), &mut cuda_ctx)
+            .execute(constant_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU materialization failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/arrays/dict.rs b/vortex-cuda/src/kernel/arrays/dict.rs
index 26d80e1ea01..ce98c989d88 100644
--- a/vortex-cuda/src/kernel/arrays/dict.rs
+++ b/vortex-cuda/src/kernel/arrays/dict.rs
@@ -9,15 +9,16 @@ use cudarc::driver::PushKernelArg;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
+use vortex::array::IntoArray;
 use vortex::array::arrays::DecimalArray;
-use vortex::array::arrays::DecimalArrayParts;
+use vortex::array::arrays::Dict;
 use vortex::array::arrays::DictArray;
-use vortex::array::arrays::DictArrayParts;
-use vortex::array::arrays::DictVTable;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
 use vortex::array::arrays::VarBinViewArray;
-use vortex::array::arrays::VarBinViewArrayParts;
+use vortex::array::arrays::decimal::DecimalDataParts;
+use vortex::array::arrays::dict::DictArraySlotsExt;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_decimal_value_type;
 use vortex::array::match_each_integer_ptype;
@@ -28,7 +29,6 @@ use vortex::dtype::NativePType;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
@@ -49,7 +49,7 @@ impl CudaExecute for DictExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let dict_array = array
-            .try_into::<DictVTable>()
+            .try_downcast::<Dict>()
             .ok()
             .vortex_expect("Array is not a Dict array");
 
@@ -65,7 +65,8 @@ impl CudaExecute for DictExecutor {
 
 #[expect(clippy::cognitive_complexity)]
 async fn execute_dict_prim(dict: DictArray, ctx: &mut CudaExecutionCtx) -> VortexResult<Canonical> {
-    let DictArrayParts { values, codes, .. } = dict.into_parts();
+    let values = dict.values().clone();
+    let codes = dict.codes().clone();
 
     // Execute both children to get them as primitives on the device
     let values_canonical = values.execute_cuda(ctx).await?;
@@ -93,17 +94,17 @@ async fn execute_dict_prim_typed<V: DeviceRepr + NativePType, I: DeviceRepr + Na
     assert!(!codes.is_empty());
     let codes_len = codes.len();
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         ptype: value_ptype,
         buffer: values_buffer,
         validity: values_validity,
         ..
-    } = values.into_parts();
-    let output_validity = values_validity.take(codes.as_ref())?;
-    let PrimitiveArrayParts {
+    } = values.into_data_parts();
+    let output_validity = values_validity.take(&codes.clone().into_array())?;
+    let PrimitiveDataParts {
         buffer: codes_buffer,
         ..
-    } = codes.into_parts();
+    } = codes.into_data_parts();
 
     // Get device buffers for values and codes
     let values_device = ctx.ensure_on_device(values_buffer).await?;
@@ -120,7 +121,7 @@ async fn execute_dict_prim_typed<V: DeviceRepr + NativePType, I: DeviceRepr + Na
 
     let codes_len_u64 = codes_len as u64;
 
-    let kernel_function = ctx.load_function_ptype("dict", &[value_ptype, I::PTYPE])?;
+    let kernel_function = ctx.load_function("dict", &[value_ptype, I::PTYPE])?;
     ctx.launch_kernel(&kernel_function, codes_len, |args| {
         args.arg(&codes_view)
             .arg(&codes_len_u64)
@@ -143,12 +144,9 @@ async fn execute_dict_decimal(
     dict: DictArray,
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<Canonical> {
-    let DictArrayParts {
-        values,
-        codes,
-        dtype,
-        ..
-    } = dict.into_parts();
+    let dtype = dict.dtype().clone();
+    let values = dict.values().clone();
+    let codes = dict.codes().clone();
 
     // Execute codes to get them as primitives on the device
     let codes_prim = codes.execute_cuda(ctx).await?.into_primitive();
@@ -179,17 +177,17 @@ async fn execute_dict_decimal_typed<
     let codes_len = codes.len();
     let codes_len_u64 = codes_len as u64;
 
-    let DecimalArrayParts {
+    let DecimalDataParts {
         values: values_buffer,
         validity: values_validity,
         ..
-    } = values.into_parts();
-    let output_validity = values_validity.take(codes.as_ref())?;
+    } = values.into_data_parts();
+    let output_validity = values_validity.take(&codes.clone().into_array())?;
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: codes_buffer,
         ..
-    } = codes.into_parts();
+    } = codes.into_data_parts();
 
     // Copy buffers to device if needed
     let values_device = ctx.ensure_on_device(values_buffer).await?;
@@ -205,7 +203,7 @@ async fn execute_dict_decimal_typed<
     let output_view = output_device.as_view::<V>();
 
     // Load kernel function using string suffixes
-    let cuda_function = ctx.load_function(
+    let cuda_function = ctx.load_function_with_suffixes(
         "dict",
         &[&V::DECIMAL_TYPE.to_string(), &C::PTYPE.to_string()],
     )?;
@@ -234,30 +232,27 @@ async fn execute_dict_varbinview(
     dict: DictArray,
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<Canonical> {
-    let DictArrayParts {
-        values,
-        codes,
-        dtype,
-        ..
-    } = dict.into_parts();
+    let dtype = dict.dtype().clone();
+    let values = dict.values().clone();
+    let codes = dict.codes().clone();
 
     let codes_prim = codes.execute_cuda(ctx).await?.into_primitive();
     let codes_ptype = codes_prim.ptype();
     let codes_len = codes_prim.len();
     let values_vbv = values.execute_cuda(ctx).await?.into_varbinview();
 
-    let VarBinViewArrayParts {
+    let VarBinViewDataParts {
         views: values_views_handle,
         buffers: values_data_buffers,
         validity: values_validity,
         ..
-    } = values_vbv.into_parts();
-    let output_validity = values_validity.take(codes_prim.as_ref())?;
+    } = values_vbv.into_data_parts();
+    let output_validity = values_validity.take(&codes_prim.clone().into_array())?;
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: codes_buffer,
         ..
-    } = codes_prim.into_parts();
+    } = codes_prim.into_data_parts();
 
     // Move buffers to device if needed.
     let values_device = ctx.ensure_on_device(values_views_handle).await?;
@@ -275,7 +270,7 @@ async fn execute_dict_varbinview(
         let output_view = output_device.as_view::<i128>();
 
         let codes_ptype_str = C::PTYPE.to_string();
-        let cuda_function = ctx.load_function("dict", &["i128", &codes_ptype_str])?;
+        let cuda_function = ctx.load_function_with_suffixes("dict", &["i128", &codes_ptype_str])?;
 
         let codes_len_u64 = codes_len as u64;
 
@@ -300,7 +295,7 @@ async fn execute_dict_varbinview(
     }))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::DecimalArray;
@@ -328,7 +323,7 @@ mod tests {
         ))
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_u32_values_u8_codes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -348,7 +343,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -360,7 +355,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_u64_values_u16_codes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -383,7 +378,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -395,7 +390,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_i32_values_u32_codes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -415,7 +410,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -426,7 +421,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_large_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -446,7 +441,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -458,7 +453,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_values_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -490,7 +485,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_codes_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -516,7 +511,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -527,7 +522,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_both_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -560,7 +555,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -571,7 +566,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_i64_values_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -605,7 +600,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -616,7 +611,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_all_valid_matches_baseline() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -638,7 +633,7 @@ mod tests {
 
         // Execute on CUDA
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_primitive();
@@ -659,7 +654,7 @@ mod tests {
         ))
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i8_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -677,7 +672,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
@@ -687,7 +682,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i16_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -705,7 +700,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
@@ -715,7 +710,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i32_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -733,7 +728,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
@@ -743,7 +738,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i64_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -764,7 +759,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
@@ -774,7 +769,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i128_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -800,7 +795,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
@@ -818,7 +813,7 @@ mod tests {
             .into_varbinview())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_values_u8_codes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -833,7 +828,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -843,7 +838,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_values_u16_codes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -858,7 +853,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -868,7 +863,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_max_inlined_12_bytes() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -885,7 +880,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -895,7 +890,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_outlined_views() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -915,7 +910,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -925,7 +920,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_empty_strings() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -940,7 +935,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -950,7 +945,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_values_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -966,7 +961,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -976,7 +971,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_string_outlined_with_validity() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -999,7 +994,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_varbinview();
@@ -1009,7 +1004,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_dict_decimal_i256_values() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -1035,7 +1030,7 @@ mod tests {
         let baseline = dict_array.to_canonical()?;
 
         let cuda_result = DictExecutor
-            .execute(dict_array.to_array(), &mut cuda_ctx)
+            .execute(dict_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_decimal();
diff --git a/vortex-cuda/src/kernel/arrays/shared.rs b/vortex-cuda/src/kernel/arrays/shared.rs
index 1b74db694fe..085b30f9057 100644
--- a/vortex-cuda/src/kernel/arrays/shared.rs
+++ b/vortex-cuda/src/kernel/arrays/shared.rs
@@ -5,7 +5,8 @@ use async_trait::async_trait;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
-use vortex::array::arrays::SharedVTable;
+use vortex::array::arrays::Shared;
+use vortex::array::arrays::shared::SharedArrayExt;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 
@@ -26,7 +27,7 @@ impl CudaExecute for SharedExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let shared = array
-            .try_into::<SharedVTable>()
+            .try_downcast::<Shared>()
             .ok()
             .vortex_expect("Array is not a Shared array");
 
diff --git a/vortex-cuda/src/kernel/encodings/alp.rs b/vortex-cuda/src/kernel/encodings/alp.rs
index 916636fb48b..6661e0fed5e 100644
--- a/vortex-cuda/src/kernel/encodings/alp.rs
+++ b/vortex-cuda/src/kernel/encodings/alp.rs
@@ -8,22 +8,22 @@ use async_trait::async_trait;
 use cudarc::driver::DeviceRepr;
 use cudarc::driver::PushKernelArg;
 use tracing::instrument;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_unsigned_integer_ptype;
 use vortex::dtype::NativePType;
+use vortex::encodings::alp::ALP;
 use vortex::encodings::alp::ALPArray;
+use vortex::encodings::alp::ALPArrayExt;
+use vortex::encodings::alp::ALPArraySlotsExt;
 use vortex::encodings::alp::ALPFloat;
-use vortex::encodings::alp::ALPVTable;
 use vortex::encodings::alp::match_each_alp_float_ptype;
 use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
@@ -45,10 +45,12 @@ impl CudaExecute for ALPExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let array = array
-            .try_into::<ALPVTable>()
+            .try_downcast::<ALP>()
             .map_err(|_| vortex_err!("Expected ALPArray"))?;
 
-        match_each_alp_float_ptype!(array.ptype(), |A| { decode_alp::<A>(array, ctx).await })
+        match_each_alp_float_ptype!(array.dtype().as_ptype(), |A| {
+            decode_alp::<A>(array, ctx).await
+        })
     }
 }
 
@@ -68,9 +70,9 @@ where
     // Execute child and copy to device
     let canonical = array.encoded().clone().execute_cuda(ctx).await?;
     let primitive = canonical.into_primitive();
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer, validity, ..
-    } = primitive.into_parts();
+    } = primitive.into_data_parts();
 
     let device_input = ctx.ensure_on_device(buffer).await?;
 
@@ -86,7 +88,7 @@ where
 
     // Load kernel function
     let kernel_ptypes = [A::ALPInt::PTYPE, A::PTYPE];
-    let cuda_function = ctx.load_function_ptype("alp", &kernel_ptypes)?;
+    let cuda_function = ctx.load_function("alp", &kernel_ptypes)?;
 
     ctx.launch_kernel(&cuda_function, array_len, |args| {
         args.arg(&input_view)
@@ -116,7 +118,7 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::PrimitiveArray;
@@ -125,7 +127,7 @@ mod tests {
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
     use vortex::buffer::buffer;
-    use vortex::encodings::alp::ALPArray;
+    use vortex::encodings::alp::ALP;
     use vortex::encodings::alp::Exponents;
     use vortex::error::VortexExpect;
     use vortex::session::VortexSession;
@@ -134,7 +136,7 @@ mod tests {
     use crate::CanonicalCudaExt;
     use crate::session::CudaSession;
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_alp_decompression_f32() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -156,7 +158,7 @@ mod tests {
         )
         .unwrap();
 
-        let alp_array = ALPArray::try_new(
+        let alp_array = ALP::try_new(
             PrimitiveArray::new(Buffer::from(encoded_data.clone()), Validity::NonNullable)
                 .into_array(),
             exponents,
@@ -166,7 +168,7 @@ mod tests {
         let cpu_result = alp_array.to_canonical()?.into_array();
 
         let gpu_result = ALPExecutor
-            .execute(alp_array.to_array(), &mut cuda_ctx)
+            .execute(alp_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/encodings/bitpacked.rs b/vortex-cuda/src/kernel/encodings/bitpacked.rs
index 9db6c71c861..357d444fae4 100644
--- a/vortex-cuda/src/kernel/encodings/bitpacked.rs
+++ b/vortex-cuda/src/kernel/encodings/bitpacked.rs
@@ -2,7 +2,6 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt::Debug;
-use std::sync::Arc;
 
 use async_trait::async_trait;
 use cudarc::driver::CudaFunction;
@@ -16,23 +15,21 @@ use vortex::array::arrays::PrimitiveArray;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::buffer::DeviceBufferExt;
 use vortex::array::match_each_integer_ptype;
-use vortex::array::match_each_unsigned_integer_ptype;
 use vortex::dtype::NativePType;
+use vortex::encodings::fastlanes::BitPacked;
 use vortex::encodings::fastlanes::BitPackedArray;
-use vortex::encodings::fastlanes::BitPackedArrayParts;
-use vortex::encodings::fastlanes::BitPackedVTable;
-use vortex::encodings::fastlanes::unpack_iter::BitPacked;
-use vortex::error::VortexExpect;
+use vortex::encodings::fastlanes::BitPackedDataParts;
+use vortex::encodings::fastlanes::unpack_iter::BitPacked as BitPackedUnpack;
 use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
 use crate::executor::CudaExecute;
 use crate::executor::CudaExecutionCtx;
-use crate::kernel::patches::execute_patches;
+use crate::kernel::patches::gpu::GPUPatches;
+use crate::kernel::patches::types::transpose_patches;
 
 /// CUDA decoder for bit-packed arrays.
 #[derive(Debug)]
@@ -40,7 +37,7 @@ pub(crate) struct BitPackedExecutor;
 
 impl BitPackedExecutor {
     fn try_specialize(array: ArrayRef) -> Option<BitPackedArray> {
-        array.try_into::<BitPackedVTable>().ok()
+        array.try_downcast::<BitPacked>().ok()
     }
 }
 
@@ -55,7 +52,7 @@ impl CudaExecute for BitPackedExecutor {
         let array =
             Self::try_specialize(array).ok_or_else(|| vortex_err!("Expected BitPackedArray"))?;
 
-        match_each_integer_ptype!(array.ptype(), |A| {
+        match_each_integer_ptype!(array.ptype(array.dtype()), |A| {
             decode_bitpacked::<A>(array, A::default(), ctx).await
         })
     }
@@ -74,7 +71,7 @@ pub fn bitpacked_cuda_kernel(
     // bit_unpack_{bits}_{bit_width}bw_{thread_count}t
     let thread_count = bitpacked_thread_count(output_width);
     let suffixes: [&str; _] = [&format!("{bit_width}bw"), &format!("{thread_count}t")];
-    ctx.load_function(&format!("bit_unpack_{}", output_width), &suffixes)
+    ctx.load_function_with_suffixes(&format!("bit_unpack_{}", output_width), &suffixes)
 }
 
 pub fn bitpacked_cuda_launch_config(output_width: usize, len: usize) -> VortexResult<LaunchConfig> {
@@ -87,6 +84,8 @@ pub fn bitpacked_cuda_launch_config(output_width: usize, len: usize) -> VortexRe
     })
 }
 
+unsafe impl DeviceRepr for GPUPatches {}
+
 #[instrument(skip_all)]
 pub(crate) async fn decode_bitpacked<A>(
     array: BitPackedArray,
@@ -94,17 +93,17 @@ pub(crate) async fn decode_bitpacked<A>(
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<Canonical>
 where
-    A: BitPacked + NativePType + DeviceRepr + Send + Sync + 'static,
+    A: BitPackedUnpack + NativePType + DeviceRepr + Send + Sync + 'static,
     A::Physical: DeviceRepr + Send + Sync + 'static,
 {
-    let BitPackedArrayParts {
+    let BitPackedDataParts {
         offset,
         bit_width,
         len,
         packed,
         patches,
         validity,
-    } = array.into_parts();
+    } = BitPacked::into_parts(array);
 
     vortex_ensure!(len > 0, "Non empty array");
     let offset = offset as usize;
@@ -123,28 +122,41 @@ where
     let cuda_function = bitpacked_cuda_kernel(bit_width, output_width, ctx)?;
     let config = bitpacked_cuda_launch_config(output_width, len)?;
 
-    ctx.launch_kernel_config(&cuda_function, config, len, |args| {
-        args.arg(&input_view).arg(&output_view).arg(&reference);
-    })?;
+    // We hold this here to keep the device buffers alive.
+    let device_patches = if let Some(patches) = patches {
+        Some(transpose_patches(&patches, ctx).await?)
+    } else {
+        None
+    };
 
-    let output_handle = match patches {
-        None => BufferHandle::new_device(output_buf.slice_typed::<A>(offset..(offset + len))),
-        Some(p) => {
-            let output_buf = output_buf.slice_typed::<A>(offset..(offset + len));
-            let buf = output_buf
-                .as_any()
-                .downcast_ref::<CudaDeviceBuffer>()
-                .vortex_expect("we created this as CudaDeviceBuffer")
-                .clone();
-
-            let patched_buf = match_each_unsigned_integer_ptype!(p.indices_ptype()?, |I| {
-                execute_patches::<A, I>(p, buf, ctx).await?
-            });
-
-            BufferHandle::new_device(Arc::new(patched_buf))
+    let patches_arg = if let Some(p) = &device_patches {
+        GPUPatches {
+            lane_offsets: p.lane_offsets.cuda_device_ptr()? as _,
+            indices: p.indices.cuda_device_ptr()? as _,
+            values: p.values.cuda_device_ptr()? as _,
+        }
+    } else {
+        // NULL lane_offsets signals no patches to the kernel
+        GPUPatches {
+            lane_offsets: std::ptr::null_mut(),
+            indices: std::ptr::null_mut(),
+            values: std::ptr::null_mut(),
         }
     };
 
+    ctx.launch_kernel_config(&cuda_function, config, len, |args| {
+        args.arg(&input_view)
+            .arg(&output_view)
+            .arg(&reference)
+            .arg(&patches_arg);
+    })?;
+
+    // NOTE: we must synchronize here, as the device patches are only alive for this call.
+    ctx.synchronize_stream()?;
+
+    let output_handle =
+        BufferHandle::new_device(output_buf.slice_typed::<A>(offset..(offset + len)));
+
     // Build result with newly allocated buffer
     Ok(Canonical::Primitive(PrimitiveArray::from_buffer_handle(
         output_handle,
@@ -153,18 +165,17 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use futures::executor::block_on;
     use rstest::rstest;
-    use vortex::array::ExecutionCtx;
     use vortex::array::IntoArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::assert_arrays_eq;
-    use vortex::array::session::ArraySession;
+    use vortex::array::dtype::NativePType;
     use vortex::array::validity::Validity::NonNullable;
-    use vortex::array::vtable::VTable;
     use vortex::buffer::Buffer;
+    use vortex::encodings::fastlanes::BitPackedArrayExt;
     use vortex::error::VortexExpect;
     use vortex::session::VortexSession;
 
@@ -172,22 +183,61 @@ mod tests {
     use crate::CanonicalCudaExt;
     use crate::session::CudaSession;
 
-    #[test]
+    #[rstest]
+    #[case::u8((0u8..128u8).cycle().take(2048), 6)]
+    #[case::u32((0u16..128u16).cycle().take(2048), 6)]
+    #[case::u16((0u32..128u32).cycle().take(2048), 6)]
+    #[case::u16((0u64..128u64).cycle().take(2048), 6)]
+    #[crate::test]
+    fn test_patched<T: NativePType>(
+        #[case] iter: impl Iterator<Item = T>,
+        #[case] bw: u8,
+    ) -> VortexResult<()> {
+        let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = PrimitiveArray::new(iter.collect::<Buffer<_>>(), NonNullable);
+
+        // Last two items should be patched
+        let bp_with_patches = BitPacked::encode(&array.into_array(), bw)?;
+        assert!(bp_with_patches.patches().is_some());
+
+        let cpu_result = bp_with_patches.to_canonical()?.into_array();
+
+        let gpu_result = block_on(async {
+            BitPackedExecutor
+                .execute(bp_with_patches.into_array(), &mut cuda_ctx)
+                .await
+                .vortex_expect("GPU decompression failed")
+                .into_host()
+                .await
+                .map(|a| a.into_array())
+        })?;
+
+        assert_arrays_eq!(cpu_result, gpu_result);
+
+        Ok(())
+    }
+
+    #[crate::test]
     fn test_patches() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let array = PrimitiveArray::new((0u16..=513).collect::<Buffer<_>>(), NonNullable);
+        let array = PrimitiveArray::new(
+            (0u16..=513).cycle().take(3072).collect::<Buffer<_>>(),
+            NonNullable,
+        );
 
         // Last two items should be patched
-        let bp_with_patches = BitPackedArray::encode(array.as_ref(), 9)?;
+        let bp_with_patches = BitPacked::encode(&array.into_array(), 9)?;
         assert!(bp_with_patches.patches().is_some());
 
         let cpu_result = bp_with_patches.to_canonical()?.into_array();
 
         let gpu_result = block_on(async {
             BitPackedExecutor
-                .execute(bp_with_patches.to_array(), &mut cuda_ctx)
+                .execute(bp_with_patches.into_array(), &mut cuda_ctx)
                 .await
                 .vortex_expect("GPU decompression failed")
                 .into_host()
@@ -208,6 +258,7 @@ mod tests {
     #[case::bw_5(5)]
     #[case::bw_6(6)]
     #[case::bw_7(7)]
+    #[crate::test]
     fn test_cuda_bitunpack_u8(#[case] bit_width: u8) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -221,13 +272,13 @@ mod tests {
             NonNullable,
         );
 
-        let bitpacked_array = BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+        let bitpacked_array = BitPacked::encode(&primitive_array.into_array(), bit_width)
             .vortex_expect("operation should succeed in test");
         let cpu_result = bitpacked_array.to_canonical()?;
 
         let gpu_result = block_on(async {
             BitPackedExecutor
-                .execute(bitpacked_array.to_array(), &mut cuda_ctx)
+                .execute(bitpacked_array.into_array(), &mut cuda_ctx)
                 .await
                 .vortex_expect("GPU decompression failed")
                 .into_host()
@@ -256,6 +307,7 @@ mod tests {
     #[case::bw_13(13)]
     #[case::bw_14(14)]
     #[case::bw_15(15)]
+    #[crate::test]
     fn test_cuda_bitunpack_u16(#[case] bit_width: u8) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -269,13 +321,13 @@ mod tests {
             NonNullable,
         );
 
-        let bitpacked_array = BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+        let bitpacked_array = BitPacked::encode(&primitive_array.into_array(), bit_width)
             .vortex_expect("operation should succeed in test");
         let cpu_result = bitpacked_array.to_canonical()?;
 
         let gpu_result = block_on(async {
             BitPackedExecutor
-                .execute(bitpacked_array.to_array(), &mut cuda_ctx)
+                .execute(bitpacked_array.into_array(), &mut cuda_ctx)
                 .await
                 .vortex_expect("GPU decompression failed")
                 .into_host()
@@ -320,6 +372,7 @@ mod tests {
     #[case::bw_29(29)]
     #[case::bw_30(30)]
     #[case::bw_31(31)]
+    #[crate::test]
     fn test_cuda_bitunpack_u32(#[case] bit_width: u8) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -333,13 +386,13 @@ mod tests {
             NonNullable,
         );
 
-        let bitpacked_array = BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+        let bitpacked_array = BitPacked::encode(&primitive_array.into_array(), bit_width)
             .vortex_expect("operation should succeed in test");
         let cpu_result = bitpacked_array.to_canonical()?;
 
         let gpu_result = block_on(async {
             BitPackedExecutor
-                .execute(bitpacked_array.to_array(), &mut cuda_ctx)
+                .execute(bitpacked_array.into_array(), &mut cuda_ctx)
                 .await
                 .vortex_expect("GPU decompression failed")
                 .into_host()
@@ -416,6 +469,7 @@ mod tests {
     #[case::bw_61(61)]
     #[case::bw_62(62)]
     #[case::bw_63(63)]
+    #[crate::test]
     fn test_cuda_bitunpack_u64(#[case] bit_width: u8) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -429,12 +483,12 @@ mod tests {
             NonNullable,
         );
 
-        let bitpacked_array = BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+        let bitpacked_array = BitPacked::encode(&primitive_array.into_array(), bit_width)
             .vortex_expect("operation should succeed in test");
         let cpu_result = bitpacked_array.to_canonical()?;
         let gpu_result = block_on(async {
             BitPackedExecutor
-                .execute(bitpacked_array.to_array(), &mut cuda_ctx)
+                .execute(bitpacked_array.into_array(), &mut cuda_ctx)
                 .await
                 .vortex_expect("GPU decompression failed")
                 .into_host()
@@ -447,7 +501,7 @@ mod tests {
         Ok(())
     }
 
-    #[test]
+    #[crate::test]
     fn test_cuda_bitunpack_sliced() -> VortexResult<()> {
         let bit_width = 32;
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
@@ -462,17 +516,10 @@ mod tests {
             NonNullable,
         );
 
-        let bitpacked_array = BitPackedArray::encode(primitive_array.as_ref(), bit_width)
+        let bitpacked_array = BitPacked::encode(&primitive_array.into_array(), bit_width)
             .vortex_expect("operation should succeed in test");
-        let slice_ref = bitpacked_array.clone().into_array().slice(67..3969)?;
-        let mut exec_ctx = ExecutionCtx::new(VortexSession::empty().with::<ArraySession>());
-        let sliced_array = <BitPackedVTable as VTable>::execute_parent(
-            &bitpacked_array,
-            &slice_ref,
-            0,
-            &mut exec_ctx,
-        )?
-        .expect("expected slice kernel to execute");
+        let sliced_array = bitpacked_array.into_array().slice(67..3969)?;
+        assert!(sliced_array.is::<BitPacked>());
         let cpu_result = sliced_array.to_canonical()?;
         let gpu_result = block_on(async {
             BitPackedExecutor
diff --git a/vortex-cuda/src/kernel/encodings/date_time_parts.rs b/vortex-cuda/src/kernel/encodings/date_time_parts.rs
index 5caf66277f7..421a759e374 100644
--- a/vortex-cuda/src/kernel/encodings/date_time_parts.rs
+++ b/vortex-cuda/src/kernel/encodings/date_time_parts.rs
@@ -12,8 +12,8 @@ use vortex::array::Canonical;
 use vortex::array::IntoArray;
 use vortex::array::arrays::ConstantArray;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
 use vortex::array::arrays::TemporalArray;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_signed_integer_ptype;
 use vortex::array::validity::Validity;
@@ -21,14 +21,14 @@ use vortex::dtype::DType;
 use vortex::dtype::NativePType;
 use vortex::dtype::Nullability;
 use vortex::dtype::PType;
-use vortex::encodings::datetime_parts::DateTimePartsVTable;
+use vortex::encodings::datetime_parts::DateTimeParts;
+use vortex::encodings::datetime_parts::DateTimePartsArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
 use vortex::extension::datetime::TimeUnit;
 use vortex::extension::datetime::Timestamp;
 use vortex::scalar::Scalar;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
@@ -52,7 +52,7 @@ impl CudaExecute for DateTimePartsExecutor {
     ) -> VortexResult<Canonical> {
         let output_len = array.len();
         let array = array
-            .try_into::<DateTimePartsVTable>()
+            .try_downcast::<DateTimeParts>()
             .map_err(|_| vortex_err!("Expected DateTimePartsArray"))?;
 
         // Extract the temporal metadata from the dtype
@@ -66,7 +66,7 @@ impl CudaExecute for DateTimePartsExecutor {
 
         let time_unit = options.unit;
         let time_zone = options.tz.clone();
-        let validity = Validity::copy_from_array(array.as_ref())?;
+        let validity = Validity::copy_from_array(&array.clone().into_array())?;
 
         if output_len == 0 {
             return Ok(Canonical::empty(array.dtype()));
@@ -148,18 +148,18 @@ where
 {
     let output_len = days.len();
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: days_buffer,
         ..
-    } = days.into_parts();
-    let PrimitiveArrayParts {
+    } = days.into_data_parts();
+    let PrimitiveDataParts {
         buffer: seconds_buffer,
         ..
-    } = seconds.into_parts();
-    let PrimitiveArrayParts {
+    } = seconds.into_data_parts();
+    let PrimitiveDataParts {
         buffer: subseconds_buffer,
         ..
-    } = subseconds.into_parts();
+    } = subseconds.into_data_parts();
 
     // Move buffers to device if not already there
     let days_device = ctx.ensure_on_device(days_buffer).await?;
@@ -175,13 +175,10 @@ where
     let subseconds_view = subseconds_device.cuda_view::<SubsecondsT>()?;
     let output_view = output_device.as_view::<i64>();
 
-    let kernel_suffixes = [
-        DaysT::PTYPE.to_string(),
-        SecondsT::PTYPE.to_string(),
-        SubsecondsT::PTYPE.to_string(),
-    ];
-    let kernel_suffix_strs: Vec<&str> = kernel_suffixes.iter().map(|s| s.as_str()).collect();
-    let cuda_function = ctx.load_function("date_time_parts", &kernel_suffix_strs)?;
+    let cuda_function = ctx.load_function(
+        "date_time_parts",
+        &[DaysT::PTYPE, SecondsT::PTYPE, SubsecondsT::PTYPE],
+    )?;
 
     let array_len_u64 = output_len as u64;
 
@@ -202,7 +199,7 @@ where
     ))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -212,6 +209,7 @@ mod tests {
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
     use vortex::buffer::buffer;
+    use vortex::encodings::datetime_parts::DateTimeParts;
     use vortex::encodings::datetime_parts::DateTimePartsArray;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
@@ -241,7 +239,7 @@ mod tests {
             None,
         );
 
-        DateTimePartsArray::try_new(
+        DateTimeParts::try_new(
             temporal.dtype().clone(),
             days_arr,
             seconds_arr,
@@ -275,7 +273,7 @@ mod tests {
         vec![123456789i64, 0, 0],
         TimeUnit::Nanoseconds
     )]
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_datetimeparts_decompression(
         #[case] days: Vec<i32>,
         #[case] seconds: Vec<i32>,
@@ -289,7 +287,7 @@ mod tests {
         let cpu_result = dtp_array.to_canonical()?;
 
         let gpu_result = DateTimePartsExecutor
-            .execute(dtp_array.to_array(), &mut cuda_ctx)
+            .execute(dtp_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -301,7 +299,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_datetimeparts_large_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -315,7 +313,7 @@ mod tests {
         let cpu_result = dtp_array.to_canonical()?;
 
         let gpu_result = DateTimePartsExecutor
-            .execute(dtp_array.to_array(), &mut cuda_ctx)
+            .execute(dtp_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -327,7 +325,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_datetimeparts_with_nulls() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -352,7 +350,7 @@ mod tests {
             None,
         );
 
-        let dtp_array = DateTimePartsArray::try_new(
+        let dtp_array = DateTimeParts::try_new(
             temporal.dtype().clone(),
             days_arr,
             seconds_arr,
@@ -363,7 +361,7 @@ mod tests {
         let cpu_result = dtp_array.to_canonical()?;
 
         let gpu_result = DateTimePartsExecutor
-            .execute(dtp_array.to_array(), &mut cuda_ctx)
+            .execute(dtp_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs b/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs
index 2615f0a67d9..3f4bdb92146 100644
--- a/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs
+++ b/vortex-cuda/src/kernel/encodings/decimal_byte_parts.rs
@@ -8,12 +8,12 @@ use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::arrays::DecimalArray;
-use vortex::array::arrays::PrimitiveArrayParts;
-use vortex::encodings::decimal_byte_parts::DecimalBytePartsArrayParts;
-use vortex::encodings::decimal_byte_parts::DecimalBytePartsVTable;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::encodings::decimal_byte_parts::DecimalByteParts;
+use vortex::encodings::decimal_byte_parts::DecimalBytePartsArrayExt;
+use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaExecutionCtx;
 use crate::executor::CudaArrayExt;
@@ -31,18 +31,25 @@ impl CudaExecute for DecimalBytePartsExecutor {
         array: ArrayRef,
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
-        let Ok(array) = array.try_into::<DecimalBytePartsVTable>() else {
+        let Ok(array) = array.try_downcast::<DecimalByteParts>() else {
             vortex_bail!("cannot downcast to DecimalBytePartsArray")
         };
 
-        let decimal_dtype = *array.decimal_dtype();
-        let DecimalBytePartsArrayParts { msp, .. } = array.into_parts();
-        let PrimitiveArrayParts {
+        let decimal_dtype = *array
+            .dtype()
+            .as_decimal_opt()
+            .vortex_expect("DecimalBytePartsArray dtype must be decimal");
+        let msp = array.msp().clone();
+        let PrimitiveDataParts {
             buffer,
             ptype,
             validity,
             ..
-        } = msp.execute_cuda(ctx).await?.into_primitive().into_parts();
+        } = msp
+            .execute_cuda(ctx)
+            .await?
+            .into_primitive()
+            .into_data_parts();
 
         // SAFETY: The primitive array's buffer is already validated with correct type.
         // The decimal dtype matches the array's dtype, and validity is preserved.
@@ -52,7 +59,7 @@ impl CudaExecute for DecimalBytePartsExecutor {
     }
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -61,7 +68,7 @@ mod tests {
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
     use vortex::dtype::DecimalDType;
-    use vortex::encodings::decimal_byte_parts::DecimalBytePartsArray;
+    use vortex::encodings::decimal_byte_parts::DecimalByteParts;
     use vortex::error::VortexExpect;
     use vortex::session::VortexSession;
 
@@ -73,7 +80,7 @@ mod tests {
     #[case::i16_p10_s2(Buffer::from(vec![100i16, 200, 300, 400, 500]), 10, 2)]
     #[case::i32_p18_s4(Buffer::from(vec![100i32, 200, 300, 400, 500]), 18, 4)]
     #[case::i64_p38_s6(Buffer::from(vec![100i64, 200, 300, 400, 500]), 38, 6)]
-    #[tokio::test]
+    #[crate::test]
     async fn test_decimal_byte_parts_gpu_decode<T: vortex::dtype::NativePType>(
         #[case] encoded: Buffer<T>,
         #[case] precision: u8,
@@ -83,7 +90,7 @@ mod tests {
             .vortex_expect("create execution context");
 
         let decimal_dtype = DecimalDType::new(precision, scale);
-        let dbp_array = DecimalBytePartsArray::try_new(
+        let dbp_array = DecimalByteParts::try_new(
             PrimitiveArray::new(encoded, Validity::NonNullable).into_array(),
             decimal_dtype,
         )
@@ -92,7 +99,7 @@ mod tests {
         let cpu_result = dbp_array.to_canonical().vortex_expect("CPU canonicalize");
 
         let gpu_result = DecimalBytePartsExecutor
-            .execute(dbp_array.to_array(), &mut cuda_ctx)
+            .execute(dbp_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decode");
 
diff --git a/vortex-cuda/src/kernel/encodings/for_.rs b/vortex-cuda/src/kernel/encodings/for_.rs
index bfc4a3ac3a0..490b797b9b8 100644
--- a/vortex-cuda/src/kernel/encodings/for_.rs
+++ b/vortex-cuda/src/kernel/encodings/for_.rs
@@ -7,23 +7,24 @@ use async_trait::async_trait;
 use cudarc::driver::DeviceRepr;
 use cudarc::driver::PushKernelArg;
 use tracing::instrument;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
+use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
-use vortex::array::arrays::SliceVTable;
+use vortex::array::arrays::Slice;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::array::arrays::slice::SliceArrayExt;
 use vortex::array::match_each_integer_ptype;
 use vortex::array::match_each_native_simd_ptype;
 use vortex::dtype::NativePType;
-use vortex::encodings::fastlanes::BitPackedVTable;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::FoR;
 use vortex::encodings::fastlanes::FoRArray;
-use vortex::encodings::fastlanes::FoRVTable;
+use vortex::encodings::fastlanes::FoRArrayExt;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::executor::CudaArrayExt;
@@ -37,7 +38,7 @@ pub(crate) struct FoRExecutor;
 
 impl FoRExecutor {
     fn try_specialize(array: ArrayRef) -> Option<FoRArray> {
-        array.try_into::<FoRVTable>().ok()
+        array.try_downcast::<FoR>().ok()
     }
 }
 
@@ -52,24 +53,28 @@ impl CudaExecute for FoRExecutor {
         let array = Self::try_specialize(array).ok_or_else(|| vortex_err!("Expected FoRArray"))?;
 
         // Fuse FOR + BP => FFOR
-        if let Some(bitpacked) = array.encoded().as_opt::<BitPackedVTable>() {
-            match_each_integer_ptype!(bitpacked.ptype(), |P| {
+        if let Some(bitpacked) = array.encoded().as_opt::<BitPacked>() {
+            match_each_integer_ptype!(bitpacked.ptype(bitpacked.dtype()), |P| {
                 let reference: P = array.reference_scalar().try_into()?;
-                return decode_bitpacked(bitpacked.clone(), reference, ctx).await;
+                return decode_bitpacked(bitpacked.into_owned(), reference, ctx).await;
             })
         }
 
         // Fuse FOR + SLICE + BP => SLICE + FFOR
-        if let Some(slice_array) = array.encoded().as_opt::<SliceVTable>()
-            && let Some(bitpacked) = slice_array.child().as_opt::<BitPackedVTable>()
+        if let Some(slice_array) = array.encoded().as_opt::<Slice>()
+            && let Some(bitpacked) = slice_array.child().as_opt::<BitPacked>()
         {
             let slice_range = slice_array.slice_range().clone();
-            let unpacked = match_each_integer_ptype!(bitpacked.ptype(), |P| {
+            let unpacked = match_each_integer_ptype!(bitpacked.ptype(bitpacked.dtype()), |P| {
                 let reference: P = array.reference_scalar().try_into()?;
-                decode_bitpacked(bitpacked.clone(), reference, ctx).await?
+                decode_bitpacked(bitpacked.into_owned(), reference, ctx).await?
             });
 
-            return unpacked.into_primitive().slice(slice_range)?.to_canonical();
+            return unpacked
+                .into_primitive()
+                .into_array()
+                .slice(slice_range)?
+                .to_canonical();
         }
 
         match_each_native_simd_ptype!(array.ptype(), |P| { decode_for::<P>(array, ctx).await })
@@ -93,9 +98,9 @@ where
     // Execute child and copy to device
     let canonical = array.encoded().clone().execute_cuda(ctx).await?;
     let primitive = canonical.into_primitive();
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer, validity, ..
-    } = primitive.into_parts();
+    } = primitive.into_data_parts();
 
     let device_buffer = ctx.ensure_on_device(buffer).await?;
 
@@ -105,7 +110,7 @@ where
 
     // Load kernel function
     let kernel_ptypes = [P::PTYPE];
-    let cuda_function = ctx.load_function_ptype("for", &kernel_ptypes)?;
+    let cuda_function = ctx.load_function("for", &kernel_ptypes)?;
 
     ctx.launch_kernel(&cuda_function, array_len, |args| {
         args.arg(&cuda_view).arg(&reference).arg(&array_len_u64);
@@ -119,7 +124,7 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -128,7 +133,8 @@ mod tests {
     use vortex::array::validity::Validity::NonNullable;
     use vortex::buffer::Buffer;
     use vortex::dtype::NativePType;
-    use vortex::encodings::fastlanes::BitPackedArray;
+    use vortex::encodings::fastlanes::BitPacked;
+    use vortex::encodings::fastlanes::FoR;
     use vortex::encodings::fastlanes::FoRArray;
     use vortex::error::VortexExpect;
     use vortex::scalar::Scalar;
@@ -139,7 +145,7 @@ mod tests {
     use crate::session::CudaSession;
 
     fn make_for_array<T: NativePType + Into<Scalar>>(input_data: Vec<T>, reference: T) -> FoRArray {
-        FoRArray::try_new(
+        FoR::try_new(
             PrimitiveArray::new(Buffer::from(input_data), NonNullable).into_array(),
             reference.into(),
         )
@@ -151,7 +157,7 @@ mod tests {
     #[case::u16(make_for_array((0..2050).map(|i| (i % 2050) as u16).collect(), 1000u16))]
     #[case::u32(make_for_array((0..2050).map(|i| (i % 2050) as u32).collect(), 100000u32))]
     #[case::u64(make_for_array((0..2050).map(|i| (i % 2050) as u64).collect(), 1000000u64))]
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_for_decompression(#[case] for_array: FoRArray) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -159,7 +165,7 @@ mod tests {
         let cpu_result = for_array.to_canonical()?;
 
         let gpu_result = FoRExecutor
-            .execute(for_array.to_array(), &mut cuda_ctx)
+            .execute(for_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -171,7 +177,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_signed_ffor() {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -181,13 +187,13 @@ mod tests {
             .take(1024)
             .collect::<Buffer<_>>()
             .into_array();
-        let packed = BitPackedArray::encode(&values, 3).unwrap().into_array();
-        let for_array = FoRArray::try_new(packed, (-8i8).into()).unwrap();
+        let packed = BitPacked::encode(&values, 3).unwrap().into_array();
+        let for_array = FoR::try_new(packed, (-8i8).into()).unwrap();
 
         let cpu_result = for_array.to_canonical().unwrap();
 
         let gpu_result = FoRExecutor
-            .execute(for_array.to_array(), &mut cuda_ctx)
+            .execute(for_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/encodings/runend.rs b/vortex-cuda/src/kernel/encodings/runend.rs
index f7027eb5a90..3f3bce2579b 100644
--- a/vortex-cuda/src/kernel/encodings/runend.rs
+++ b/vortex-cuda/src/kernel/encodings/runend.rs
@@ -9,24 +9,24 @@ use cudarc::driver::PushKernelArg;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
+use vortex::array::IntoArray;
 use vortex::array::arrays::ConstantArray;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_native_ptype;
 use vortex::array::match_each_unsigned_integer_ptype;
 use vortex::array::validity::Validity;
 use vortex::dtype::NativePType;
 use vortex::dtype::PType;
+use vortex::encodings::runend::RunEnd;
 use vortex::encodings::runend::RunEndArray;
-use vortex::encodings::runend::RunEndArrayParts;
-use vortex::encodings::runend::RunEndVTable;
+use vortex::encodings::runend::RunEndArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
 use vortex::scalar::Scalar;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
@@ -40,7 +40,7 @@ pub(crate) struct RunEndExecutor;
 
 impl RunEndExecutor {
     fn try_specialize(array: ArrayRef) -> Option<RunEndArray> {
-        array.try_into::<RunEndVTable>().ok()
+        array.try_downcast::<RunEnd>().ok()
     }
 }
 
@@ -61,7 +61,8 @@ impl CudaExecute for RunEndExecutor {
 
         let offset = array.offset();
         let output_len = array.len();
-        let RunEndArrayParts { ends, values } = array.into_parts();
+        let ends = array.ends().clone();
+        let values = array.values().clone();
 
         let values_ptype = PType::try_from(values.dtype())?;
         let ends_ptype = PType::try_from(ends.dtype())?;
@@ -76,6 +77,7 @@ impl CudaExecute for RunEndExecutor {
 
         if matches!(values.validity()?, Validity::AllInvalid) {
             return ConstantArray::new(Scalar::null(values.dtype().clone()), output_len)
+                .into_array()
                 .to_canonical();
         }
 
@@ -104,17 +106,17 @@ async fn decode_runend_typed<V: DeviceRepr + NativePType, E: DeviceRepr + Native
         "run-end output length must be greater than zero"
     );
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         ptype: value_ptype,
         buffer: values_buffer,
         validity: values_validity,
         ..
-    } = values.into_parts();
+    } = values.into_data_parts();
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: ends_buffer,
         ..
-    } = ends.into_parts();
+    } = ends.into_data_parts();
 
     // Set up device buffers.
     let ends_device = ctx.ensure_on_device(ends_buffer).await?;
@@ -128,9 +130,7 @@ async fn decode_runend_typed<V: DeviceRepr + NativePType, E: DeviceRepr + Native
     let output_view = output_device.as_view::<V>();
 
     // Load kernel function
-    let kernel_ptypes = [value_ptype.to_string(), E::PTYPE.to_string()];
-    let kernel_ptype_strs: Vec<&str> = kernel_ptypes.iter().map(|s| s.as_str()).collect();
-    let cuda_function = ctx.load_function("runend", &kernel_ptype_strs)?;
+    let cuda_function = ctx.load_function("runend", &[value_ptype, E::PTYPE])?;
 
     ctx.launch_kernel(&cuda_function, output_len, |args| {
         args.arg(&ends_view)
@@ -159,8 +159,7 @@ async fn decode_runend_typed<V: DeviceRepr + NativePType, E: DeviceRepr + Native
     )))
 }
 
-#[cuda_tests]
-#[allow(clippy::cast_possible_truncation)]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -168,6 +167,7 @@ mod tests {
     use vortex::array::assert_arrays_eq;
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
+    use vortex::encodings::runend::RunEnd;
     use vortex::encodings::runend::RunEndArray;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
@@ -186,7 +186,7 @@ mod tests {
             PrimitiveArray::new(Buffer::from(ends), Validity::NonNullable).into_array();
         let values_array =
             PrimitiveArray::new(Buffer::from(values), Validity::NonNullable).into_array();
-        RunEndArray::new(ends_array, values_array)
+        RunEnd::new(ends_array, values_array)
     }
 
     #[rstest]
@@ -196,7 +196,7 @@ mod tests {
     #[case::u8_ends_i32_values(make_runend_array(vec![2u8, 5, 10], vec![1i32, 2, 3]))]
     #[case::u32_ends_i32_values(make_runend_array(vec![2u32, 5, 10], vec![1i32, 2, 3]))]
     #[case::u64_ends_i32_values(make_runend_array(vec![2u64, 5, 10], vec![1i32, 2, 3]))]
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_runend_types(#[case] runend_array: RunEndArray) -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -204,7 +204,7 @@ mod tests {
         let cpu_result = runend_array.to_canonical()?;
 
         let gpu_result = RunEndExecutor
-            .execute(runend_array.to_array(), &mut cuda_ctx)
+            .execute(runend_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -216,7 +216,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_runend_large_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -226,7 +226,7 @@ mod tests {
         let total_len = num_runs * run_length;
 
         let ends: Vec<u64> = (1..=num_runs).map(|i| (i * run_length) as u64).collect();
-        let values: Vec<i32> = (0..num_runs).map(|i| i as i32).collect();
+        let values: Vec<i32> = (0..num_runs).map(|i| i32::try_from(i).unwrap()).collect();
 
         let runend_array = make_runend_array(ends, values);
         assert_eq!(runend_array.len(), total_len);
@@ -234,7 +234,7 @@ mod tests {
         let cpu_result = runend_array.to_canonical()?;
 
         let gpu_result = RunEndExecutor
-            .execute(runend_array.to_array(), &mut cuda_ctx)
+            .execute(runend_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -246,7 +246,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_runend_single_run() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -256,7 +256,7 @@ mod tests {
         let cpu_result = runend_array.to_canonical()?;
 
         let gpu_result = RunEndExecutor
-            .execute(runend_array.to_array(), &mut cuda_ctx)
+            .execute(runend_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
@@ -268,7 +268,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_runend_many_small_runs() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -283,7 +283,7 @@ mod tests {
         let cpu_result = runend_array.to_canonical()?;
 
         let gpu_result = RunEndExecutor
-            .execute(runend_array.to_array(), &mut cuda_ctx)
+            .execute(runend_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/encodings/sequence.rs b/vortex-cuda/src/kernel/encodings/sequence.rs
index 0e9ce8cf69b..bcc90ec77b7 100644
--- a/vortex-cuda/src/kernel/encodings/sequence.rs
+++ b/vortex-cuda/src/kernel/encodings/sequence.rs
@@ -14,11 +14,10 @@ use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_native_ptype;
 use vortex::dtype::NativePType;
 use vortex::dtype::Nullability;
-use vortex::encodings::sequence::SequenceArrayParts;
-use vortex::encodings::sequence::SequenceVTable;
+use vortex::encodings::sequence::Sequence;
+use vortex::encodings::sequence::SequenceDataParts;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaDeviceBuffer;
 use crate::CudaExecutionCtx;
@@ -37,16 +36,17 @@ impl CudaExecute for SequenceExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let array = array
-            .try_into::<SequenceVTable>()
+            .try_downcast::<Sequence>()
             .map_err(|_| vortex_err!("SequenceExecutor can only accept SequenceArray"))?;
 
-        let SequenceArrayParts {
+        let len = array.len();
+        let nullability = array.dtype().nullability();
+
+        let SequenceDataParts {
             base,
             multiplier,
-            len,
             ptype,
-            nullability,
-        } = array.into_parts();
+        } = array.into_data().into_parts();
 
         match_each_native_ptype!(ptype, |P| {
             let base = base.cast::<P>()?;
@@ -67,7 +67,7 @@ async fn execute_typed<T: NativePType + DeviceRepr>(
 
     let len_u64 = len as u64;
 
-    let kernel_func = ctx.load_function_ptype("sequence", &[T::PTYPE])?;
+    let kernel_func = ctx.load_function("sequence", &[T::PTYPE])?;
 
     ctx.launch_kernel(&kernel_func, len, |args| {
         args.arg(&buffer).arg(&base).arg(&multiplier).arg(&len_u64);
@@ -82,7 +82,7 @@ async fn execute_typed<T: NativePType + DeviceRepr>(
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use futures::executor::block_on;
     use rstest::rstest;
@@ -90,7 +90,7 @@ mod tests {
     use vortex::array::assert_arrays_eq;
     use vortex::dtype::NativePType;
     use vortex::dtype::Nullability;
-    use vortex::encodings::sequence::SequenceArray;
+    use vortex::encodings::sequence::Sequence;
     use vortex::scalar::PValue;
     use vortex::session::VortexSession;
 
@@ -104,6 +104,7 @@ mod tests {
     #[case::u16(10u16, 2u16, 100)]
     #[case::u32(10u32, 2u32, 1000)]
     #[case::u64(100u64, 20u64, 500)]
+    #[crate::test]
     fn test_sequence<T: NativePType + Into<PValue>>(
         #[case] base: T,
         #[case] multiplier: T,
@@ -126,7 +127,7 @@ mod tests {
     ) {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty()).unwrap();
 
-        let array = SequenceArray::typed_new(base, multiplier, nullability, len).unwrap();
+        let array = Sequence::try_new_typed(base, multiplier, nullability, len).unwrap();
 
         let cpu_result = array.to_canonical().unwrap().into_array();
 
diff --git a/vortex-cuda/src/kernel/encodings/zigzag.rs b/vortex-cuda/src/kernel/encodings/zigzag.rs
index f6e556d196d..f13a19bf0e1 100644
--- a/vortex-cuda/src/kernel/encodings/zigzag.rs
+++ b/vortex-cuda/src/kernel/encodings/zigzag.rs
@@ -10,16 +10,16 @@ use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::match_each_unsigned_integer_ptype;
 use vortex::dtype::NativePType;
 use vortex::dtype::PType;
+use vortex::encodings::zigzag::ZigZag;
 use vortex::encodings::zigzag::ZigZagArray;
-use vortex::encodings::zigzag::ZigZagVTable;
+use vortex::encodings::zigzag::ZigZagArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::executor::CudaArrayExt;
@@ -32,7 +32,7 @@ pub(crate) struct ZigZagExecutor;
 
 impl ZigZagExecutor {
     fn try_specialize(array: ArrayRef) -> Option<ZigZagArray> {
-        array.try_into::<ZigZagVTable>().ok()
+        array.try_downcast::<ZigZag>().ok()
     }
 }
 
@@ -71,9 +71,9 @@ where
     // Execute child and copy to device
     let canonical = array.encoded().clone().execute_cuda(ctx).await?;
     let primitive = canonical.into_primitive();
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer, validity, ..
-    } = primitive.into_parts();
+    } = primitive.into_data_parts();
 
     let device_buffer = ctx.ensure_on_device(buffer).await?;
 
@@ -82,7 +82,7 @@ where
     let array_len_u64 = array_len as u64;
 
     // Load kernel function
-    let cuda_function = ctx.load_function_ptype("zigzag", &[U::PTYPE])?;
+    let cuda_function = ctx.load_function("zigzag", &[U::PTYPE])?;
 
     ctx.launch_kernel(&cuda_function, array_len, |args| {
         args.arg(&cuda_view).arg(&array_len_u64);
@@ -96,14 +96,14 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::assert_arrays_eq;
     use vortex::array::validity::Validity::NonNullable;
     use vortex::buffer::Buffer;
-    use vortex::encodings::zigzag::ZigZagArray;
+    use vortex::encodings::zigzag::ZigZag;
     use vortex::error::VortexExpect;
     use vortex::session::VortexSession;
 
@@ -111,7 +111,7 @@ mod tests {
     use crate::CanonicalCudaExt;
     use crate::session::CudaSession;
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zigzag_decompression_u32() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -120,14 +120,14 @@ mod tests {
         // So encoded [0, 2, 4, 1, 3] should decode to [0, 1, 2, -1, -2]
         let encoded_data: Vec<u32> = vec![0, 2, 4, 1, 3];
 
-        let zigzag_array = ZigZagArray::try_new(
+        let zigzag_array = ZigZag::try_new(
             PrimitiveArray::new(Buffer::from(encoded_data), NonNullable).into_array(),
         )?;
 
         let cpu_result = zigzag_array.to_canonical()?;
 
         let gpu_result = ZigZagExecutor
-            .execute(zigzag_array.to_array(), &mut cuda_ctx)
+            .execute(zigzag_array.into_array(), &mut cuda_ctx)
             .await
             .vortex_expect("GPU decompression failed")
             .into_host()
diff --git a/vortex-cuda/src/kernel/encodings/zstd.rs b/vortex-cuda/src/kernel/encodings/zstd.rs
index e70047f61b3..77ade13a6b0 100644
--- a/vortex-cuda/src/kernel/encodings/zstd.rs
+++ b/vortex-cuda/src/kernel/encodings/zstd.rs
@@ -15,23 +15,24 @@ use tracing::debug;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
-use vortex::array::arrays::BinaryView;
 use vortex::array::arrays::VarBinViewArray;
+use vortex::array::arrays::varbinview::BinaryView;
+use vortex::array::arrays::varbinview::build_views::MAX_BUFFER_LEN;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::buffer::DeviceBuffer;
+use vortex::array::vtable::child_to_validity;
 use vortex::buffer::Alignment;
 use vortex::buffer::Buffer;
 use vortex::buffer::ByteBuffer;
 use vortex::dtype::DType;
+use vortex::encodings::zstd::Zstd;
 use vortex::encodings::zstd::ZstdArray;
-use vortex::encodings::zstd::ZstdArrayParts;
+use vortex::encodings::zstd::ZstdDataParts;
 use vortex::encodings::zstd::ZstdMetadata;
-use vortex::encodings::zstd::ZstdVTable;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 use vortex::mask::AllOr;
-use vortex_cuda_macros::cuda_tests;
 use vortex_nvcomp::sys::nvcompStatus_t;
 use vortex_nvcomp::zstd as nvcomp_zstd;
 
@@ -185,7 +186,7 @@ pub(crate) struct ZstdExecutor;
 
 impl ZstdExecutor {
     fn try_specialize(array: ArrayRef) -> Option<ZstdArray> {
-        array.as_opt::<ZstdVTable>().cloned()
+        array.try_downcast::<Zstd>().ok()
     }
 }
 
@@ -199,30 +200,31 @@ impl CudaExecute for ZstdExecutor {
     ) -> VortexResult<Canonical> {
         let zstd = Self::try_specialize(array).ok_or_else(|| vortex_err!("Expected ZstdArray"))?;
 
-        match zstd.as_ref().dtype() {
+        match zstd.dtype() {
             DType::Binary(_) | DType::Utf8(_) => decode_zstd(zstd, ctx).await,
             _other => {
                 debug!(
                     dtype = %_other,
                     "Only Binary/Utf8 ZSTD arrays supported on GPU, falling back to CPU"
                 );
-                zstd.decompress()?.to_canonical()
+                Zstd::decompress(&zstd, ctx.execution_ctx())?.to_canonical()
             }
         }
     }
 }
 
 async fn decode_zstd(array: ZstdArray, ctx: &mut CudaExecutionCtx) -> VortexResult<Canonical> {
-    let ZstdArrayParts {
+    let dtype = array.dtype().clone();
+    let validity = child_to_validity(&array.as_ref().slots()[0], dtype.nullability());
+    let ZstdDataParts {
         frames,
         metadata,
-        dtype,
         validity,
         n_rows,
         dictionary,
         slice_start,
         slice_stop,
-    } = array.into_parts();
+    } = array.into_data().into_parts(validity);
 
     // nvCOMP doesn't support ZSTD dictionaries.
     if dictionary.is_some() {
@@ -314,22 +316,26 @@ async fn decode_zstd(array: ZstdArray, ctx: &mut CudaExecutionCtx) -> VortexResu
         .await?;
 
     let slice_value_indices = validity
-        .to_mask(n_rows)
+        .execute_mask(n_rows, ctx.execution_ctx())?
         .valid_counts_for_indices(&[slice_start, slice_stop]);
     let slice_value_idx_start = slice_value_indices[0];
     let slice_value_idx_stop = slice_value_indices[1];
 
     let sliced_validity = validity.slice(slice_start..slice_stop)?;
 
-    match sliced_validity.to_mask(slice_stop - slice_start).indices() {
+    match sliced_validity
+        .execute_mask(slice_stop - slice_start, ctx.execution_ctx())?
+        .indices()
+    {
         AllOr::All => {
-            let all_views = vortex::encodings::zstd::reconstruct_views(&host_buffer);
+            let (buffers, all_views) =
+                vortex::encodings::zstd::reconstruct_views(&host_buffer, MAX_BUFFER_LEN);
             let sliced_views = all_views.slice(slice_value_idx_start..slice_value_idx_stop);
 
             Ok(Canonical::VarBinView(unsafe {
                 VarBinViewArray::new_unchecked(
                     sliced_views,
-                    Arc::from([host_buffer]),
+                    Arc::from(buffers),
                     dtype,
                     sliced_validity,
                 )
@@ -341,19 +347,19 @@ async fn decode_zstd(array: ZstdArray, ctx: &mut CudaExecutionCtx) -> VortexResu
     }
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::VarBinViewArray;
     use vortex::array::assert_arrays_eq;
-    use vortex::encodings::zstd::ZstdArray;
+    use vortex::encodings::zstd::Zstd;
     use vortex::error::VortexResult;
     use vortex::session::VortexSession;
 
     use super::*;
     use crate::session::CudaSession;
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zstd_decompression_utf8() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -367,9 +373,9 @@ mod tests {
             "baz",
         ]);
 
-        let zstd_array = ZstdArray::from_var_bin_view(&strings, 3, 0)?;
+        let zstd_array = Zstd::from_var_bin_view(&strings, 3, 0)?;
 
-        let cpu_result = zstd_array.decompress()?.to_canonical()?;
+        let cpu_result = Zstd::decompress(&zstd_array, cuda_ctx.execution_ctx())?.to_canonical()?;
         let gpu_result = ZstdExecutor
             .execute(zstd_array.into_array(), &mut cuda_ctx)
             .await?;
@@ -378,7 +384,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zstd_decompression_multiple_frames() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -402,9 +408,9 @@ mod tests {
 
         // Compress with ZSTD using values_per_frame=3 to create multiple frames.
         // 14 strings and 3 values per frame = ceil(14/3) = 5 frames.
-        let zstd_array = ZstdArray::from_var_bin_view(&strings, 3, 3)?;
+        let zstd_array = Zstd::from_var_bin_view(&strings, 3, 3)?;
 
-        let cpu_result = zstd_array.decompress()?.to_canonical()?;
+        let cpu_result = Zstd::decompress(&zstd_array, cuda_ctx.execution_ctx())?.to_canonical()?;
         let gpu_result = ZstdExecutor
             .execute(zstd_array.into_array(), &mut cuda_ctx)
             .await?;
@@ -413,7 +419,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zstd_decompression_sliced() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -431,7 +437,7 @@ mod tests {
             "final test string",
         ]);
 
-        let zstd_array = ZstdArray::from_var_bin_view(&strings, 3, 0)?;
+        let zstd_array = Zstd::from_var_bin_view(&strings, 3, 0)?;
 
         // Slice the array to get a subset (indices 2..7)
         let sliced_zstd = zstd_array.slice(2..7)?;
diff --git a/vortex-cuda/src/kernel/encodings/zstd_buffers.rs b/vortex-cuda/src/kernel/encodings/zstd_buffers.rs
index 6396f73681c..c93cf8aaec9 100644
--- a/vortex-cuda/src/kernel/encodings/zstd_buffers.rs
+++ b/vortex-cuda/src/kernel/encodings/zstd_buffers.rs
@@ -16,11 +16,10 @@ use vortex::array::buffer::BufferHandle;
 use vortex::array::buffer::DeviceBuffer;
 use vortex::buffer::Alignment;
 use vortex::buffer::Buffer;
+use vortex::encodings::zstd::ZstdBuffers;
 use vortex::encodings::zstd::ZstdBuffersArray;
-use vortex::encodings::zstd::ZstdBuffersVTable;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
-use vortex_cuda_macros::cuda_tests;
 use vortex_nvcomp::sys;
 use vortex_nvcomp::sys::nvcompStatus_t;
 use vortex_nvcomp::zstd as nvcomp_zstd;
@@ -42,7 +41,7 @@ impl CudaExecute for ZstdBuffersExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let zstd_buffers = array
-            .try_into::<ZstdBuffersVTable>()
+            .try_downcast::<ZstdBuffers>()
             .map_err(|_| vortex_err!("expected zstd buffers array"))?;
         decode_zstd_buffers(zstd_buffers, ctx).await
     }
@@ -56,7 +55,7 @@ async fn decode_zstd_buffers(
     let compressed_buffers = plan.compressed_buffers();
 
     if compressed_buffers.is_empty() {
-        let inner_array = array.build_inner(&[], ctx.session())?;
+        let inner_array = ZstdBuffers::build_inner(&array, &[], ctx.session())?;
         return inner_array.execute_cuda(ctx).await;
     }
 
@@ -159,7 +158,7 @@ async fn decode_zstd_buffers(
     let output_handle = BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(device_output)));
     let decompressed_buffers = plan.split_output_handle(&output_handle)?;
 
-    let inner_array = array.build_inner(&decompressed_buffers, ctx.session())?;
+    let inner_array = ZstdBuffers::build_inner(&array, &decompressed_buffers, ctx.session())?;
     inner_array.execute_cuda(ctx).await
 }
 
@@ -218,13 +217,12 @@ async fn validate_decompress_results(
     Ok(())
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::VarBinViewArray;
     use vortex::array::assert_arrays_eq;
-    use vortex::encodings::zstd::ZstdBuffersArray;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
     use vortex::session::VortexSession;
@@ -233,13 +231,13 @@ mod tests {
     use crate::CanonicalCudaExt;
     use crate::session::CudaSession;
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zstd_buffers_decompression_primitive() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
         let input = PrimitiveArray::from_iter(0i64..1024).into_array();
-        let compressed = ZstdBuffersArray::compress(&input, 3)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &VortexSession::empty())?;
 
         let cpu_result = compressed.clone().into_array().to_canonical()?;
         let gpu_result = ZstdBuffersExecutor
@@ -252,7 +250,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_cuda_zstd_buffers_decompression_varbinview() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
@@ -266,7 +264,7 @@ mod tests {
             "baz",
         ])
         .into_array();
-        let compressed = ZstdBuffersArray::compress(&input, 3)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &VortexSession::empty())?;
 
         let cpu_result = compressed.clone().into_array().to_canonical()?;
         let gpu_result = ZstdBuffersExecutor
diff --git a/vortex-cuda/src/kernel/filter/decimal.rs b/vortex-cuda/src/kernel/filter/decimal.rs
index a42d51b9f04..cdfc4342fa6 100644
--- a/vortex-cuda/src/kernel/filter/decimal.rs
+++ b/vortex-cuda/src/kernel/filter/decimal.rs
@@ -4,12 +4,11 @@
 use cudarc::driver::DeviceRepr;
 use vortex::array::Canonical;
 use vortex::array::arrays::DecimalArray;
-use vortex::array::arrays::DecimalArrayParts;
+use vortex::array::arrays::decimal::DecimalDataParts;
 use vortex::dtype::NativeDecimalType;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
 use vortex_cub::filter::CubFilterable;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaExecutionCtx;
 use crate::kernel::filter::filter_sized;
@@ -19,12 +18,12 @@ pub(super) async fn filter_decimal<D: NativeDecimalType + DeviceRepr + CubFilter
     mask: Mask,
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<Canonical> {
-    let DecimalArrayParts {
+    let DecimalDataParts {
         values,
         validity,
         decimal_dtype,
         ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     let filtered_validity = validity.filter(&mask)?;
     let filtered_values = filter_sized::<D>(values, mask, ctx).await?;
@@ -37,7 +36,7 @@ pub(super) async fn filter_decimal<D: NativeDecimalType + DeviceRepr + CubFilter
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -85,7 +84,7 @@ mod tests {
         DecimalArray::from_iter([i256::from_i128(1), i256::from_i128(2), i256::from_i128(3), i256::from_i128(4), i256::from_i128(5)], DecimalDType::new(19, 5)),
         Mask::from_iter([false, true, false, true, false])
     )]
-    #[tokio::test]
+    #[crate::test]
     async fn test_gpu_filter_decimal(
         #[case] input: DecimalArray,
         #[case] mask: Mask,
@@ -110,7 +109,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_gpu_filter_decimal_large_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create CUDA execution context");
diff --git a/vortex-cuda/src/kernel/filter/mod.rs b/vortex-cuda/src/kernel/filter/mod.rs
index 37856ee7916..3c504113b11 100644
--- a/vortex-cuda/src/kernel/filter/mod.rs
+++ b/vortex-cuda/src/kernel/filter/mod.rs
@@ -18,8 +18,8 @@ use cudarc::driver::DeviceRepr;
 use tracing::instrument;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
-use vortex::array::arrays::FilterArrayParts;
-use vortex::array::arrays::FilterVTable;
+use vortex::array::arrays::Filter;
+use vortex::array::arrays::filter::FilterArrayExt;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::match_each_decimal_value_type;
 use vortex::array::match_each_native_simd_ptype;
@@ -50,10 +50,11 @@ impl CudaExecute for FilterExecutor {
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
         let filter_array = array
-            .try_into::<FilterVTable>()
+            .try_downcast::<Filter>()
             .map_err(|_| vortex_err!("Expected FilterArray"))?;
 
-        let FilterArrayParts { child, mask } = filter_array.into_parts();
+        let child = filter_array.child().clone();
+        let mask = filter_array.data().filter_mask().clone();
 
         // Early return for trivial cases.
         match mask {
diff --git a/vortex-cuda/src/kernel/filter/primitive.rs b/vortex-cuda/src/kernel/filter/primitive.rs
index 5019ff9b770..c74c56e5b06 100644
--- a/vortex-cuda/src/kernel/filter/primitive.rs
+++ b/vortex-cuda/src/kernel/filter/primitive.rs
@@ -4,12 +4,11 @@
 use cudarc::driver::DeviceRepr;
 use vortex::array::Canonical;
 use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::PrimitiveArrayParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::dtype::NativePType;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
 use vortex_cub::filter::CubFilterable;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaExecutionCtx;
 use crate::kernel::filter::filter_sized;
@@ -23,9 +22,9 @@ pub(super) async fn filter_primitive<T>(
 where
     T: NativePType + DeviceRepr + CubFilterable + Send + Sync + 'static,
 {
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer, validity, ..
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     let filtered_validity = validity.filter(&mask)?;
     let filtered_values = filter_sized::<T>(buffer, mask, ctx).await?;
@@ -37,7 +36,7 @@ where
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -79,7 +78,7 @@ mod tests {
         PrimitiveArray::from_iter([1u32, 2, 3, 4, 5]),
         Mask::from_iter([false, false, false, false, false])
     )]
-    #[tokio::test]
+    #[crate::test]
     async fn test_gpu_filter(
         #[case] input: PrimitiveArray,
         #[case] mask: Mask,
@@ -104,7 +103,7 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_gpu_filter_large_array() -> VortexResult<()> {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create CUDA execution context");
diff --git a/vortex-cuda/src/kernel/filter/varbinview.rs b/vortex-cuda/src/kernel/filter/varbinview.rs
index f5e205f07aa..84632f5cca8 100644
--- a/vortex-cuda/src/kernel/filter/varbinview.rs
+++ b/vortex-cuda/src/kernel/filter/varbinview.rs
@@ -3,10 +3,9 @@
 
 use vortex::array::Canonical;
 use vortex::array::arrays::VarBinViewArray;
-use vortex::array::arrays::VarBinViewArrayParts;
+use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaExecutionCtx;
 use crate::kernel::filter::filter_sized;
@@ -16,12 +15,12 @@ pub(super) async fn filter_varbinview(
     mask: Mask,
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<Canonical> {
-    let VarBinViewArrayParts {
+    let VarBinViewDataParts {
         views,
         buffers,
         validity,
         dtype,
-    } = array.into_parts();
+    } = array.into_data_parts();
 
     let filtered_validity = validity.filter(&mask)?;
 
@@ -37,7 +36,7 @@ pub(super) async fn filter_varbinview(
     )))
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use rstest::rstest;
     use vortex::array::IntoArray;
@@ -65,7 +64,7 @@ mod tests {
         ),
         Mask::from_iter([true, true, true, true, true, true, true, true, false])
     )]
-    #[tokio::test]
+    #[crate::test]
     async fn test_gpu_filter_strings(
         #[case] input: VarBinViewArray,
         #[case] mask: Mask,
diff --git a/vortex-cuda/src/kernel/mod.rs b/vortex-cuda/src/kernel/mod.rs
index 5638ff5f43c..93ffd768df5 100644
--- a/vortex-cuda/src/kernel/mod.rs
+++ b/vortex-cuda/src/kernel/mod.rs
@@ -20,7 +20,6 @@ use tracing::trace;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 use vortex::utils::aliases::dash_map::DashMap;
-use vortex_cuda_macros::cuda_tests;
 
 mod arrays;
 mod encodings;
@@ -35,6 +34,7 @@ pub use encodings::ZstdKernelPrep;
 pub use encodings::zstd_kernel_prepare;
 pub(crate) use encodings::*;
 pub(crate) use filter::FilterExecutor;
+pub use patches::types::transpose_patches;
 pub(crate) use slice::SliceExecutor;
 
 use crate::CudaKernelEvents;
@@ -281,9 +281,8 @@ impl KernelLoader {
     }
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
-    #![allow(clippy::expect_used)]
 
     use cudarc::driver::CudaContext;
     use cudarc::driver::PushKernelArg;
@@ -296,7 +295,7 @@ mod tests {
     /// This test launches a special config_check kernel that reports the kernel-side
     /// constants, then verifies they match the Rust-side constants used in
     /// `launch_cuda_kernel_impl`.
-    #[test]
+    #[crate::test]
     fn test_kernel_config_matches_rust_config() {
         // These must match the constants in launch_cuda_kernel_impl
         const THREADS_PER_BLOCK: u32 = 64;
diff --git a/vortex-cuda/src/kernel/patches/mod.rs b/vortex-cuda/src/kernel/patches/mod.rs
index 7f1ccc6835c..206ac8bc1cd 100644
--- a/vortex-cuda/src/kernel/patches/mod.rs
+++ b/vortex-cuda/src/kernel/patches/mod.rs
@@ -1,17 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+pub mod types;
+
+#[rustfmt::skip]
+#[allow(warnings, clippy::all, clippy::pedantic, clippy::nursery)]
+pub mod gpu {
+    include!(concat!(env!("OUT_DIR"), "/patches.rs"));
+}
+
 use cudarc::driver::DeviceRepr;
 use cudarc::driver::PushKernelArg;
 use tracing::instrument;
-use vortex::array::arrays::PrimitiveArrayParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::patches::Patches;
 use vortex::array::validity::Validity;
-use vortex::array::vtable::ValidityHelper;
 use vortex::dtype::NativePType;
 use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
-use vortex_cuda_macros::cuda_tests;
 
 use crate::CudaBufferExt;
 use crate::CudaDeviceBuffer;
@@ -36,7 +42,7 @@ pub(crate) async fn execute_patches<
     let values = values.execute_cuda(ctx).await?.into_primitive();
 
     let supported = matches!(
-        values.validity(),
+        values.validity()?,
         Validity::NonNullable | Validity::AllValid
     );
     vortex_ensure!(
@@ -61,15 +67,15 @@ pub(crate) async fn execute_patches<
     let patches_len = indices.len();
     let patches_len_u64 = patches_len as u64;
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: indices_buffer,
         ..
-    } = indices.into_parts();
+    } = indices.into_data_parts();
 
-    let PrimitiveArrayParts {
+    let PrimitiveDataParts {
         buffer: values_buffer,
         ..
-    } = values.into_parts();
+    } = values.into_data_parts();
 
     let d_patch_indices = ctx.ensure_on_device(indices_buffer).await?;
     let d_patch_values = ctx.ensure_on_device(values_buffer).await?;
@@ -78,7 +84,7 @@ pub(crate) async fn execute_patches<
     let d_patch_indices_view = d_patch_indices.cuda_view::<IndicesT>()?;
     let d_patch_values_view = d_patch_values.cuda_view::<ValuesT>()?;
 
-    let kernel_func = ctx.load_function_ptype("patches", &[ValuesT::PTYPE, IndicesT::PTYPE])?;
+    let kernel_func = ctx.load_function("patches", &[ValuesT::PTYPE, IndicesT::PTYPE])?;
 
     ctx.launch_kernel(&kernel_func, patches_len, |args| {
         args.arg(&d_target_view)
@@ -90,15 +96,16 @@ pub(crate) async fn execute_patches<
     Ok(target)
 }
 
-#[cuda_tests]
+#[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
     use cudarc::driver::DeviceRepr;
     use vortex::array::IntoArray;
     use vortex::array::ToCanonical;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::PrimitiveArray;
-    use vortex::array::arrays::PrimitiveArrayParts;
+    use vortex::array::arrays::primitive::PrimitiveDataParts;
     use vortex::array::assert_arrays_eq;
     use vortex::array::buffer::BufferHandle;
     use vortex::array::builtins::ArrayBuiltins;
@@ -115,27 +122,25 @@ mod tests {
     use crate::CudaSession;
     use crate::kernel::patches::execute_patches;
 
-    #[tokio::test]
-    async fn test_patches() {
-        test_case::<u8>().await;
-        test_case::<u16>().await;
-        test_case::<u32>().await;
-        test_case::<u64>().await;
-
-        test_case::<i8>().await;
-        test_case::<i16>().await;
-        test_case::<i32>().await;
-        test_case::<i64>().await;
-
-        test_case::<f32>().await;
-        test_case::<f64>().await;
-    }
-
-    async fn test_case<Values: NativePType + DeviceRepr>() {
-        full_test_case::<Values, u8>().await;
-        full_test_case::<Values, u16>().await;
-        full_test_case::<Values, u32>().await;
-        full_test_case::<Values, u64>().await;
+    #[rstest::rstest]
+    #[case::u8(0_u8)]
+    #[case::u16(0_u16)]
+    #[case::u32(0_u32)]
+    #[case::u64(0_u64)]
+    #[case::i8(0_i8)]
+    #[case::i16(0_i16)]
+    #[case::i32(0_i32)]
+    #[case::i64(0_i64)]
+    #[case::f32(0_f32)]
+    #[case::f64(0_f64)]
+    #[crate::test]
+    async fn test_patches<Values: NativePType + DeviceRepr>(#[case] _v: Values) {
+        tokio::join!(
+            full_test_case::<Values, u8>(),
+            full_test_case::<Values, u16>(),
+            full_test_case::<Values, u32>(),
+            full_test_case::<Values, u64>(),
+        );
     }
 
     async fn full_test_case<Values: NativePType + DeviceRepr, Indices: NativePType + DeviceRepr>() {
@@ -154,12 +159,18 @@ mod tests {
         let patches =
             Patches::new(128, 0, patch_idx.into_array(), patch_val.into_array(), None).unwrap();
 
-        let cpu_result = values.clone().patch(&patches).unwrap();
+        let cpu_result = values
+            .clone()
+            .patch(
+                &patches,
+                &mut vortex::array::LEGACY_SESSION.create_execution_ctx(),
+            )
+            .unwrap();
 
-        let PrimitiveArrayParts {
+        let PrimitiveDataParts {
             buffer: cuda_buffer,
             ..
-        } = values.into_parts();
+        } = values.into_data_parts();
 
         let handle = ctx.ensure_on_device(cuda_buffer).await.unwrap();
         let device_buf = handle
@@ -190,7 +201,7 @@ mod tests {
 
     fn force_cast<T: NativePType>(array: PrimitiveArray) -> PrimitiveArray {
         array
-            .to_array()
+            .into_array()
             .cast(DType::Primitive(T::PTYPE, Nullability::NonNullable))
             .unwrap()
             .to_primitive()
diff --git a/vortex-cuda/src/kernel/patches/types.rs b/vortex-cuda/src/kernel/patches/types.rs
new file mode 100644
index 00000000000..78fa0b8429e
--- /dev/null
+++ b/vortex-cuda/src/kernel/patches/types.rs
@@ -0,0 +1,355 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! An implementation of lane-wise patches instead of linear patches. This layout for exception
+//! patching enables fully parallel GPU execution, as outlined by Hepkema et al. in
+//! "G-ALP: Rethinking Light-weight Encodings for GPUs" <https://doi.org/10.1145/3736227.3736242>
+
+use vortex::array::Canonical;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::dtype::IntegerPType;
+use vortex::array::dtype::NativePType;
+use vortex::buffer::Buffer;
+use vortex::buffer::BufferMut;
+use vortex_array::match_each_native_ptype;
+use vortex_array::match_each_unsigned_integer_ptype;
+use vortex_array::patches::Patches;
+use vortex_error::VortexResult;
+
+use crate::CudaExecutionCtx;
+
+/// A set of device-resident patches that live in the GPU.
+///
+/// These are dynamically typed.
+#[repr(C)]
+pub struct DevicePatches {
+    pub(crate) lane_offsets: BufferHandle,
+    pub(crate) indices: BufferHandle,
+    pub(crate) values: BufferHandle,
+}
+
+/// Number of lanes used at patch time for a value of type `V`.
+///
+/// This is *NOT* equal to the number of FastLanes lanes for the type `V`, rather this will
+/// correspond with the number of CUDA threads dedicated to executing each 1024-element vector.
+const fn patch_lanes<V: Sized>() -> usize {
+    // For types 32-bits or smaller, we use a 32 lane configuration, and for 64-bit we use 16 lanes.
+    // This matches up with the number of lanes we use to execute copying results from bit-unpacking
+    // from shared to global memory.
+    if size_of::<V>() < 8 { 32 } else { 16 }
+}
+
+/// A set of patches of values `V` existing in host buffers.
+#[allow(dead_code)]
+pub struct HostPatches<V> {
+    n_chunks: usize,
+    n_lanes: usize,
+    lane_offsets: Buffer<u32>,
+    indices: Buffer<u16>,
+    /// Values. This is a buffer handle which might live on the new buffer type here
+    values: Buffer<V>,
+}
+
+#[cfg(test)]
+struct LanePatches<'a, V> {
+    indices: &'a [u16],
+    values: &'a [V],
+}
+
+impl<V: Copy> HostPatches<V> {
+    /// Get number of patches for a specific lane.
+    #[cfg(test)]
+    fn patch_count(&self, chunk: usize, lane: usize) -> usize {
+        let start = chunk * self.n_lanes + lane;
+        let end = start + 1;
+        let count = self.lane_offsets[end] - self.lane_offsets[start];
+
+        count as usize
+    }
+
+    /// Get an ordered list of patches for the given chunk/lane.
+    #[cfg(test)]
+    fn patches(&self, chunk: usize, lane: usize) -> LanePatches<'_, V> {
+        let start = chunk * self.n_lanes + lane;
+        let end = start + 1;
+
+        let lane_start = self.lane_offsets[start] as usize;
+        let lane_stop = self.lane_offsets[end] as usize;
+
+        LanePatches {
+            indices: &self.indices[lane_start..lane_stop],
+            values: &self.values[lane_start..lane_stop],
+        }
+    }
+
+    /// Apply the patches on top of the other buffer.
+    #[cfg(test)]
+    fn apply(&self, output: &mut BufferMut<V>) {
+        for chunk in 0..self.n_chunks {
+            for lane in 0..self.n_lanes {
+                let patches = self.patches(chunk, lane);
+                for (&index, &value) in std::iter::zip(patches.indices, patches.values) {
+                    let full_index = chunk * 1024 + (index as usize);
+                    output[full_index] = value;
+                }
+            }
+        }
+    }
+
+    /// Export the patches for use on the device associated with the provided execution context.
+    pub async fn export_to_device(
+        mut self,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<DevicePatches> {
+        let lane_offsets = std::mem::take(&mut self.lane_offsets);
+        let indices = std::mem::take(&mut self.indices);
+        let values = std::mem::take(&mut self.values);
+
+        // Convert each into a handle that can be passed around.
+        let lane_offsets_handle = BufferHandle::new_host(lane_offsets.into_byte_buffer());
+        let indices_handle = BufferHandle::new_host(indices.into_byte_buffer());
+        let values_handle = BufferHandle::new_host(values.into_byte_buffer());
+
+        let lane_offsets_handle = ctx.ensure_on_device(lane_offsets_handle).await?;
+        let indices_handle = ctx.ensure_on_device(indices_handle).await?;
+        let values_handle = ctx.ensure_on_device(values_handle).await?;
+
+        Ok(DevicePatches {
+            lane_offsets: lane_offsets_handle,
+            indices: indices_handle,
+            values: values_handle,
+        })
+    }
+}
+
+/// Transpose a set of patches from the default sorted layout into the data parallel layout.
+#[allow(clippy::cognitive_complexity)]
+pub async fn transpose_patches(
+    patches: &Patches,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<DevicePatches> {
+    let array_len = patches.array_len();
+    let offset = patches.offset();
+
+    let indices = patches
+        .indices()
+        .clone()
+        .execute::<Canonical>(ctx.execution_ctx())?
+        .into_primitive();
+
+    let values = patches
+        .values()
+        .clone()
+        .execute::<Canonical>(ctx.execution_ctx())?
+        .into_primitive();
+
+    let indices_ptype = indices.ptype();
+    let values_ptype = values.ptype();
+
+    let indices = indices.buffer_handle().to_host().await;
+    let values = values.buffer_handle().to_host().await;
+
+    match_each_unsigned_integer_ptype!(indices_ptype, |I| {
+        match_each_native_ptype!(values_ptype, |V| {
+            let indices: Buffer<I> = Buffer::from_byte_buffer(indices);
+            let values: Buffer<V> = Buffer::from_byte_buffer(values);
+
+            let host_patches = transpose(indices.as_slice(), values.as_slice(), offset, array_len);
+
+            host_patches.export_to_device(ctx).await
+        })
+    })
+}
+
+#[allow(clippy::cast_possible_truncation)]
+fn transpose<I: IntegerPType, V: NativePType>(
+    indices_in: &[I],
+    values_in: &[V],
+    offset: usize,
+    array_len: usize,
+) -> HostPatches<V> {
+    // Total number of slots is number of chunks times number of lanes.
+    let n_chunks = array_len.div_ceil(1024);
+    assert!(
+        n_chunks <= u32::MAX as usize,
+        "Cannot transpose patches for array with >= 4 trillion elements"
+    );
+
+    let n_lanes = patch_lanes::<V>();
+
+    // We know upfront how many indices and values we'll have.
+    let mut indices_buffer = BufferMut::with_capacity(indices_in.len());
+    let mut values_buffer = BufferMut::with_capacity(values_in.len());
+
+    // number of patches in each chunk.
+    let mut lane_offsets: BufferMut<u32> = BufferMut::zeroed(n_chunks * n_lanes + 1);
+
+    // Scan the index/values once to get chunk/lane counts
+    for index in indices_in {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        lane_offsets[chunk * n_lanes + lane + 1] += 1;
+    }
+
+    // Prefix-sum sizes -> offsets
+    for index in 1..lane_offsets.len() {
+        lane_offsets[index] += lane_offsets[index - 1];
+    }
+
+    // Loop over patches, writing them to final positions
+    let indices_out = indices_buffer.spare_capacity_mut();
+    let values_out = values_buffer.spare_capacity_mut();
+    for (index, &value) in std::iter::zip(indices_in, values_in) {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        let position = &mut lane_offsets[chunk * n_lanes + lane];
+        indices_out[*position as usize].write((index % 1024) as u16);
+        values_out[*position as usize].write(value);
+        *position += 1;
+    }
+
+    // SAFETY: we know there are exactly indices_in.len() indices/values, and we just
+    //  set them to the appropriate values in the loop above.
+    unsafe {
+        indices_buffer.set_len(indices_in.len());
+        values_buffer.set_len(values_in.len());
+    }
+
+    // Now, pass over all the indices and values again and subtract out the position increments.
+    for index in indices_in {
+        let index = index.as_() - offset;
+        let chunk = index / 1024;
+        let lane = index % n_lanes;
+
+        lane_offsets[chunk * n_lanes + lane] -= 1;
+    }
+
+    HostPatches {
+        n_chunks,
+        n_lanes,
+        lane_offsets: lane_offsets.freeze(),
+        indices: indices_buffer.freeze(),
+        values: values_buffer.freeze(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex::array::ExecutionCtx;
+    use vortex::buffer::BufferMut;
+    use vortex::buffer::buffer;
+    use vortex::buffer::buffer_mut;
+    use vortex_array::IntoArray;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
+    use vortex_array::dtype::NativePType;
+    use vortex_array::patches::Patches;
+    use vortex_error::VortexResult;
+
+    use crate::kernel::patches::types::transpose;
+
+    #[crate::test]
+    fn test_transpose_patches() {
+        let patch_values = buffer![0u32, 10, 20, 30, 40, 50, 60, 70, 80];
+
+        let mut patch_indices = BufferMut::empty();
+        // CHUNK 0. patch_values have value type i32, which means there will be 32 lanes.
+        patch_indices.extend_from_slice(&[0, 31, 63, 64]);
+
+        // CHUNK 1.
+        patch_indices.extend_from_slice(&[1024, 1056, 1058]);
+
+        // CHUNK 2: empty
+        patch_indices.extend_from_slice(&[]);
+
+        // CHUNK 3
+        patch_indices.extend_from_slice(&[3073, 3076]);
+
+        let patch_indices = patch_indices.freeze();
+
+        let transposed = transpose(
+            patch_indices.as_slice(),
+            patch_values.as_slice(),
+            0,
+            1024 * 5,
+        );
+
+        // Chunk 0 should have patches in lanes 0, 31
+        assert_eq!(transposed.patches(0, 0).values, &[0, 30]);
+        assert_eq!(transposed.patches(0, 0).indices, &[0, 64]);
+
+        assert_eq!(transposed.patches(0, 31).values, &[10, 20]);
+        assert_eq!(transposed.patches(0, 31).indices, &[31, 63]);
+
+        // Chunk 1 should have patches in lanes 0, 2
+        assert_eq!(transposed.patches(1, 0).values, &[40, 50]);
+        assert_eq!(transposed.patches(1, 0).indices, &[0, 32]);
+        assert_eq!(transposed.patches(1, 2).values, &[60]);
+        assert_eq!(transposed.patches(1, 2).indices, &[34]);
+
+        // Chunk 2 should be empty
+        for lane in 0..transposed.n_lanes {
+            assert_eq!(transposed.patch_count(2, lane), 0);
+        }
+
+        // Chunk 3 contains patches at lanes 1, 4
+        assert_eq!(transposed.patches(3, 1).values, &[70]);
+        assert_eq!(transposed.patches(3, 1).indices, &[1]);
+        assert_eq!(transposed.patches(3, 4).values, &[80]);
+        assert_eq!(transposed.patches(3, 4).indices, &[4]);
+    }
+
+    #[test]
+    #[allow(clippy::cast_possible_truncation)]
+    fn test_transpose_complex() -> VortexResult<()> {
+        test_case(1024, 0, &[0], &[0f32])?;
+        test_case(512, 512, &[512, 513, 514], &[10i8, 20, 30])?;
+        test_case(10_000, 100, &[500, 1_000, 1_001, 1_002], &[1i16, 2, 3, 4])?;
+
+        for len in (1..4096).step_by(10) {
+            let offset = len / 2;
+
+            let indices: Vec<u32> = (offset..len).map(|x| x as u32).collect();
+
+            test_case(len, offset, &indices, &indices)?;
+        }
+
+        Ok(())
+    }
+
+    fn test_case<V: NativePType>(
+        len: usize,
+        offset: usize,
+        patch_indices: &[u32],
+        patch_values: &[V],
+    ) -> VortexResult<()> {
+        let mut data = buffer_mut![V::default(); len];
+        let array = PrimitiveArray::from_iter(data.iter().copied());
+
+        let patches = Patches::new(
+            len,
+            offset,
+            PrimitiveArray::from_iter(patch_indices.iter().copied()).into_array(),
+            PrimitiveArray::from_iter(patch_values.iter().copied()).into_array(),
+            None,
+        )?;
+
+        // Verify that the outputs match between Patches and transpose_patches().
+        let mut ctx = ExecutionCtx::new(LEGACY_SESSION.clone());
+        let patched = array.patch(&patches, &mut ctx)?.into_array();
+
+        let transposed = transpose(patch_indices, patch_values, offset, len);
+        transposed.apply(&mut data);
+
+        let patched_transposed = data.freeze().into_array();
+
+        assert_arrays_eq!(patched, patched_transposed);
+
+        Ok(())
+    }
+}
diff --git a/vortex-cuda/src/kernel/slice/mod.rs b/vortex-cuda/src/kernel/slice/mod.rs
index f541ffcdd5a..647faa64fcd 100644
--- a/vortex-cuda/src/kernel/slice/mod.rs
+++ b/vortex-cuda/src/kernel/slice/mod.rs
@@ -3,11 +3,11 @@
 
 use async_trait::async_trait;
 use tracing::instrument;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
-use vortex::array::arrays::SliceArrayParts;
-use vortex::array::arrays::SliceVTable;
+use vortex::array::IntoArray;
+use vortex::array::arrays::Slice;
+use vortex::array::arrays::slice::SliceArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 
@@ -26,23 +26,31 @@ impl CudaExecute for SliceExecutor {
         array: ArrayRef,
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Canonical> {
-        let slice_array = array.try_into::<SliceVTable>().map_err(|array| {
+        let slice_array = array.try_downcast::<Slice>().map_err(|array| {
             vortex_err!(
                 "SliceExecutor requires input of SliceArray, was {}",
                 array.encoding_id()
             )
         })?;
 
-        let SliceArrayParts { child, range } = slice_array.into_parts();
-        let child = child.execute_cuda(ctx).await?;
+        let range = slice_array.data().slice_range().clone();
+        let child = slice_array.child().clone().execute_cuda(ctx).await?;
 
         match child {
-            Canonical::Null(null_array) => null_array.slice(range)?.to_canonical(),
-            Canonical::Bool(bool_array) => bool_array.slice(range)?.to_canonical(),
-            Canonical::Primitive(prim_array) => prim_array.slice(range)?.to_canonical(),
-            Canonical::Decimal(decimal_array) => decimal_array.slice(range)?.to_canonical(),
-            Canonical::VarBinView(varbinview) => varbinview.slice(range)?.to_canonical(),
-            Canonical::Extension(extension_array) => extension_array.slice(range)?.to_canonical(),
+            Canonical::Null(null_array) => null_array.into_array().slice(range)?.to_canonical(),
+            Canonical::Bool(bool_array) => bool_array.into_array().slice(range)?.to_canonical(),
+            Canonical::Primitive(prim_array) => {
+                prim_array.into_array().slice(range)?.to_canonical()
+            }
+            Canonical::Decimal(decimal_array) => {
+                decimal_array.into_array().slice(range)?.to_canonical()
+            }
+            Canonical::VarBinView(varbinview) => {
+                varbinview.into_array().slice(range)?.to_canonical()
+            }
+            Canonical::Extension(extension_array) => {
+                extension_array.into_array().slice(range)?.to_canonical()
+            }
             c => todo!("Slice kernel not implemented for {}", c.dtype()),
         }
     }
diff --git a/vortex-cuda/src/layout.rs b/vortex-cuda/src/layout.rs
index 48a96bcb00a..516968b8f82 100644
--- a/vortex-cuda/src/layout.rs
+++ b/vortex-cuda/src/layout.rs
@@ -13,25 +13,22 @@ use async_trait::async_trait;
 use futures::FutureExt;
 use futures::StreamExt;
 use futures::future::BoxFuture;
-use vortex::array::Array;
 use vortex::array::ArrayContext;
+use vortex::array::ArrayId;
 use vortex::array::ArrayRef;
-use vortex::array::ArrayVisitor;
-use vortex::array::ArrayVisitorExt;
 use vortex::array::DeserializeMetadata;
 use vortex::array::MaskFuture;
 use vortex::array::ProstMetadata;
 use vortex::array::VortexSessionExecute;
-use vortex::array::arrays::ConstantVTable;
+use vortex::array::arrays::Constant;
 use vortex::array::expr::Expression;
 use vortex::array::expr::stats::Precision;
 use vortex::array::expr::stats::Stat;
 use vortex::array::expr::stats::StatsProvider;
 use vortex::array::normalize::NormalizeOptions;
 use vortex::array::normalize::Operation;
-use vortex::array::serde::ArrayParts;
 use vortex::array::serde::SerializeOptions;
-use vortex::array::session::ArrayRegistry;
+use vortex::array::serde::SerializedArray;
 use vortex::array::stats::StatsSetRef;
 use vortex::buffer::BufferString;
 use vortex::buffer::ByteBuffer;
@@ -64,7 +61,9 @@ use vortex::scalar::ScalarTruncation;
 use vortex::scalar::lower_bound;
 use vortex::scalar::upper_bound;
 use vortex::session::VortexSession;
+use vortex::session::registry::ReadContext;
 use vortex::utils::aliases::hash_map::HashMap;
+use vortex::utils::aliases::hash_set::HashSet;
 
 /// A buffer inlined into layout metadata for host-side access.
 #[derive(Clone, prost::Message)]
@@ -94,7 +93,7 @@ pub struct CudaFlatLayout {
     row_count: u64,
     dtype: DType,
     segment_id: SegmentId,
-    ctx: ArrayContext,
+    ctx: ReadContext,
     array_tree: ByteBuffer,
     /// Small buffers kept on host, keyed by global buffer index.
     host_buffers: Arc<HashMap<u32, ByteBuffer>>,
@@ -107,7 +106,7 @@ impl CudaFlatLayout {
     }
 
     #[inline]
-    pub fn array_ctx(&self) -> &ArrayContext {
+    pub fn array_ctx(&self) -> &ReadContext {
         &self.ctx
     }
 
@@ -122,7 +121,7 @@ impl CudaFlatLayout {
     }
 }
 
-impl VTable for CudaFlatVTable {
+impl VTable for CudaFlat {
     type Layout = CudaFlatLayout;
     type Encoding = CudaFlatLayoutEncoding;
     type Metadata = ProstMetadata<CudaFlatLayoutMetadata>;
@@ -195,7 +194,7 @@ impl VTable for CudaFlatVTable {
         metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         segment_ids: Vec<SegmentId>,
         _children: &dyn LayoutChildren,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         if segment_ids.len() != 1 {
             vortex_bail!("CudaFlatLayout must have exactly one segment ID");
@@ -247,11 +246,11 @@ impl CudaFlatReader {
                 let session = self.session.clone();
                 let dtype = self.layout.dtype.clone();
                 let array_tree = self.layout.array_tree.clone();
-                let host_buffers = self.layout.host_buffers.clone();
+                let host_buffers = Arc::clone(&self.layout.host_buffers);
 
                 async move {
                     let segment = segment_fut.await?;
-                    let parts = ArrayParts::from_flatbuffer_and_segment_with_overrides(
+                    let parts = SerializedArray::from_flatbuffer_and_segment_with_overrides(
                         array_tree,
                         segment,
                         &host_buffers,
@@ -309,7 +308,7 @@ impl LayoutReader for CudaFlatReader {
             .vortex_expect("Row range begin must fit within CudaFlatLayout size")
             ..usize::try_from(row_range.end)
                 .vortex_expect("Row range end must fit within CudaFlatLayout size");
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         let array = self.array_future();
         let expr = expr.clone();
         let session = self.session.clone();
@@ -357,7 +356,7 @@ impl LayoutReader for CudaFlatReader {
             .vortex_expect("Row range begin must fit within CudaFlatLayout size")
             ..usize::try_from(row_range.end)
                 .vortex_expect("Row range end must fit within CudaFlatLayout size");
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         let array = self.array_future();
         let expr = expr.clone();
 
@@ -392,7 +391,7 @@ pub struct CudaFlatLayoutStrategy {
     /// Maximum length of variable length statistics.
     pub max_variable_length_statistics_size: usize,
     /// Optional set of allowed array encodings for normalization.
-    pub allowed_encodings: Option<ArrayRegistry>,
+    pub allowed_encodings: Option<HashSet<ArrayId>>,
 }
 
 impl Default for CudaFlatLayoutStrategy {
@@ -416,7 +415,7 @@ impl CudaFlatLayoutStrategy {
         self
     }
 
-    pub fn with_allow_encodings(mut self, allow_encodings: ArrayRegistry) -> Self {
+    pub fn with_allow_encodings(mut self, allow_encodings: HashSet<ArrayId>) -> Self {
         self.allowed_encodings = Some(allow_encodings);
         self
     }
@@ -446,7 +445,7 @@ impl LayoutStrategy for CudaFlatLayoutStrategy {
         segment_sink: SegmentSinkRef,
         mut stream: SendableSequentialStream,
         _eof: SequencePointer,
-        _handle: vortex::io::runtime::Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let ctx = ctx.clone();
         let options = self.clone();
@@ -506,10 +505,11 @@ impl LayoutStrategy for CudaFlatLayoutStrategy {
         };
 
         // Scan for constant array buffers before serialization (while data is still on host).
-        let host_buffers = extract_constant_buffers(&*chunk);
+        let host_buffers = extract_constant_buffers(&chunk);
 
         let buffers = chunk.serialize(
             &ctx,
+            session,
             &SerializeOptions {
                 offset: 0,
                 include_padding: options.include_padding,
@@ -535,7 +535,7 @@ impl LayoutStrategy for CudaFlatLayoutStrategy {
             row_count,
             dtype: stream.dtype().clone(),
             segment_id,
-            ctx: ctx.clone(),
+            ctx: ReadContext::new(ctx.to_ids()),
             array_tree,
             host_buffers: Arc::new(host_buffer_map),
         }
@@ -546,12 +546,12 @@ impl LayoutStrategy for CudaFlatLayoutStrategy {
 /// Walk the array tree depth-first and extract buffer data for all `ConstantArray` nodes.
 ///
 /// The buffer ordering matches `Array::serialize()` because both use depth-first traversal.
-fn extract_constant_buffers(chunk: &dyn Array) -> Vec<InlinedBuffer> {
+fn extract_constant_buffers(chunk: &ArrayRef) -> Vec<InlinedBuffer> {
     let mut result = Vec::new();
     let mut buffer_idx = 0u32;
     for array in chunk.depth_first_traversal() {
         let n = array.nbuffers();
-        if array.encoding_id() == ConstantVTable::ID {
+        if array.encoding_id() == Constant::ID {
             for buf in array.buffers() {
                 result.push(InlinedBuffer {
                     buffer_index: buffer_idx,
diff --git a/vortex-cuda/src/lib.rs b/vortex-cuda/src/lib.rs
index 12e88de2019..274fe31b18f 100644
--- a/vortex-cuda/src/lib.rs
+++ b/vortex-cuda/src/lib.rs
@@ -13,8 +13,11 @@ mod device_buffer;
 mod device_read_at;
 pub mod dynamic_dispatch;
 pub mod executor;
+pub mod hybrid_dispatch;
 mod kernel;
 pub mod layout;
+mod pinned;
+mod pooled_read_at;
 mod session;
 mod stream;
 mod stream_pool;
@@ -44,26 +47,36 @@ use kernel::ZigZagExecutor;
 use kernel::ZstdBuffersExecutor;
 use kernel::ZstdExecutor;
 pub use kernel::ZstdKernelPrep;
+pub use kernel::transpose_patches;
 pub use kernel::zstd_kernel_prepare;
+pub use pinned::PinnedByteBufferPool;
+pub use pinned::PinnedPoolStats;
+pub use pinned::PooledPinnedBuffer;
+pub use pooled_read_at::PooledByteBufferReadAt;
+pub use pooled_read_at::PooledFileReadAt;
+pub use pooled_read_at::PooledObjectStoreReadAt;
 pub use session::CudaSession;
 pub use session::CudaSessionExt;
+pub use stream::VortexCudaStream;
 pub use stream_pool::VortexCudaStreamPool;
-use vortex::array::arrays::ConstantVTable;
-use vortex::array::arrays::DictVTable;
-use vortex::array::arrays::FilterVTable;
-use vortex::array::arrays::SharedVTable;
-use vortex::array::arrays::SliceVTable;
-use vortex::encodings::alp::ALPVTable;
-use vortex::encodings::datetime_parts::DateTimePartsVTable;
-use vortex::encodings::decimal_byte_parts::DecimalBytePartsVTable;
-use vortex::encodings::fastlanes::BitPackedVTable;
-use vortex::encodings::fastlanes::FoRVTable;
-use vortex::encodings::runend::RunEndVTable;
-use vortex::encodings::sequence::SequenceVTable;
-use vortex::encodings::zigzag::ZigZagVTable;
+use vortex::array::arrays::Constant;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::Filter;
+use vortex::array::arrays::Shared;
+use vortex::array::arrays::Slice;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::datetime_parts::DateTimeParts;
+use vortex::encodings::decimal_byte_parts::DecimalByteParts;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::FoR;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::sequence::Sequence;
+use vortex::encodings::zigzag::ZigZag;
+use vortex::encodings::zstd::Zstd;
 #[cfg(feature = "unstable_encodings")]
-use vortex::encodings::zstd::ZstdBuffersVTable;
-use vortex::encodings::zstd::ZstdVTable;
+use vortex::encodings::zstd::ZstdBuffers;
+#[cfg(test)]
+use vortex_cuda_macros::test;
 pub use vortex_nvcomp as nvcomp;
 
 use crate::kernel::SequenceExecutor;
@@ -80,22 +93,22 @@ pub fn cuda_available() -> bool {
 /// Registers CUDA kernels.
 pub fn initialize_cuda(session: &CudaSession) {
     info!("Registering CUDA kernels");
-    session.register_kernel(ALPVTable::ID, &ALPExecutor);
-    session.register_kernel(BitPackedVTable::ID, &BitPackedExecutor);
-    session.register_kernel(ConstantVTable::ID, &ConstantNumericExecutor);
-    session.register_kernel(DateTimePartsVTable::ID, &DateTimePartsExecutor);
-    session.register_kernel(DecimalBytePartsVTable::ID, &DecimalBytePartsExecutor);
-    session.register_kernel(DictVTable::ID, &DictExecutor);
-    session.register_kernel(SharedVTable::ID, &SharedExecutor);
-    session.register_kernel(FoRVTable::ID, &FoRExecutor);
-    session.register_kernel(RunEndVTable::ID, &RunEndExecutor);
-    session.register_kernel(SequenceVTable::ID, &SequenceExecutor);
-    session.register_kernel(ZigZagVTable::ID, &ZigZagExecutor);
-    session.register_kernel(ZstdVTable::ID, &ZstdExecutor);
+    session.register_kernel(ALP::ID, &ALPExecutor);
+    session.register_kernel(BitPacked::ID, &BitPackedExecutor);
+    session.register_kernel(Constant::ID, &ConstantNumericExecutor);
+    session.register_kernel(DateTimeParts::ID, &DateTimePartsExecutor);
+    session.register_kernel(DecimalByteParts::ID, &DecimalBytePartsExecutor);
+    session.register_kernel(Dict::ID, &DictExecutor);
+    session.register_kernel(Shared::ID, &SharedExecutor);
+    session.register_kernel(FoR::ID, &FoRExecutor);
+    session.register_kernel(RunEnd::ID, &RunEndExecutor);
+    session.register_kernel(Sequence::ID, &SequenceExecutor);
+    session.register_kernel(ZigZag::ID, &ZigZagExecutor);
+    session.register_kernel(Zstd::ID, &ZstdExecutor);
     #[cfg(feature = "unstable_encodings")]
-    session.register_kernel(ZstdBuffersVTable::ID, &ZstdBuffersExecutor);
+    session.register_kernel(ZstdBuffers::ID, &ZstdBuffersExecutor);
 
     // Operation kernels
-    session.register_kernel(FilterVTable::ID, &FilterExecutor);
-    session.register_kernel(SliceVTable::ID, &SliceExecutor);
+    session.register_kernel(Filter::ID, &FilterExecutor);
+    session.register_kernel(Slice::ID, &SliceExecutor);
 }
diff --git a/vortex-cuda/src/pinned.rs b/vortex-cuda/src/pinned.rs
new file mode 100644
index 00000000000..7939bc588ec
--- /dev/null
+++ b/vortex-cuda/src/pinned.rs
@@ -0,0 +1,490 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use cudarc::driver::CudaContext;
+use cudarc::driver::CudaEvent;
+use cudarc::driver::CudaStream;
+use cudarc::driver::HostSlice;
+use cudarc::driver::PinnedHostSlice;
+use cudarc::driver::SyncOnDrop;
+use parking_lot::Mutex;
+use vortex::error::VortexResult;
+use vortex::error::vortex_err;
+use vortex::error::vortex_panic;
+use vortex::utils::aliases::hash_map::HashMap;
+
+use crate::CudaDeviceBuffer;
+use crate::stream::VortexCudaStream;
+
+/// A page-locked host buffer allocated by CUDA.
+///
+/// This is intended as a staging buffer for H2D transfers. Contents are uninitialized after
+/// allocation.
+pub(crate) struct PinnedByteBuffer {
+    inner: PinnedHostSlice<u8>,
+    logical_len: usize,
+}
+
+#[allow(clippy::same_name_method)]
+impl PinnedByteBuffer {
+    /// Allocate a pinned host buffer with a given capacity and logical length.
+    ///
+    /// # Safety
+    /// The returned buffer's contents are uninitialized. The caller must initialize before read.
+    pub(crate) unsafe fn uninit_with_capacity(
+        ctx: &Arc<CudaContext>,
+        capacity: usize,
+        logical_len: usize,
+    ) -> VortexResult<Self> {
+        // alloc_pinned uses CU_MEMHOSTALLOC_WRITECOMBINED: fast for host writes
+        // and H2D transfers, but very slow for host-side reads.
+        let inner = unsafe {
+            ctx.alloc_pinned::<u8>(capacity)
+                .map_err(|e| vortex_err!("failed to allocate pinned host buffer: {e}"))?
+        };
+        Ok(Self { inner, logical_len })
+    }
+
+    /// Returns the length of the buffer in bytes.
+    pub(crate) fn len(&self) -> usize {
+        self.logical_len
+    }
+
+    pub(crate) fn capacity(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns the buffer as a mutable slice.
+    pub(crate) fn as_mut_slice(&mut self) -> VortexResult<&mut [u8]> {
+        self.inner
+            .as_mut_slice()
+            .map(|slice| &mut slice[..self.logical_len])
+            .map_err(|e| vortex_err!("failed to access pinned host buffer: {e}"))
+    }
+
+    fn set_logical_len(&mut self, len: usize) {
+        assert!(len <= self.inner.len());
+        self.logical_len = len;
+    }
+}
+
+#[allow(clippy::same_name_method)]
+impl HostSlice<u8> for PinnedByteBuffer {
+    fn len(&self) -> usize {
+        self.len()
+    }
+
+    unsafe fn stream_synced_slice<'a>(
+        &'a self,
+        stream: &'a CudaStream,
+    ) -> (&'a [u8], SyncOnDrop<'a>) {
+        let (slice, sync) = unsafe {
+            <PinnedHostSlice<u8> as HostSlice<u8>>::stream_synced_slice(&self.inner, stream)
+        };
+        (&slice[..self.logical_len], sync)
+    }
+
+    unsafe fn stream_synced_mut_slice<'a>(
+        &'a mut self,
+        stream: &'a CudaStream,
+    ) -> (&'a mut [u8], SyncOnDrop<'a>) {
+        let (slice, sync) = unsafe {
+            <PinnedHostSlice<u8> as HostSlice<u8>>::stream_synced_mut_slice(&mut self.inner, stream)
+        };
+        (&mut slice[..self.logical_len], sync)
+    }
+}
+
+/// A simple pinned host buffer pool keyed by allocation size.
+///
+/// Requested sizes are rounded up to the next power of two so that buffers are reusable across
+/// similar-but-not-identical request sizes.
+pub struct PinnedByteBufferPool {
+    ctx: Arc<CudaContext>,
+    max_keep_per_size: usize,
+    buckets: Mutex<HashMap<usize, Vec<PinnedByteBuffer>>>,
+    inflight: Mutex<Vec<InflightPinnedBuffer>>,
+    hits: std::sync::atomic::AtomicU64,
+    misses: std::sync::atomic::AtomicU64,
+    allocs: std::sync::atomic::AtomicU64,
+    puts: std::sync::atomic::AtomicU64,
+}
+
+struct InflightPinnedBuffer {
+    event: Arc<CudaEvent>,
+    buffer: PinnedByteBuffer,
+}
+
+impl PinnedByteBufferPool {
+    /// Create a new pool with default limits.
+    pub fn new(ctx: Arc<CudaContext>) -> Self {
+        Self::with_limits(ctx, 256)
+    }
+
+    /// Create a new pool with a maximum number of cached buffers per size class.
+    pub fn with_limits(ctx: Arc<CudaContext>, max_keep_per_size: usize) -> Self {
+        Self {
+            ctx,
+            max_keep_per_size: max_keep_per_size.max(1),
+            buckets: Mutex::new(HashMap::new()),
+            inflight: Mutex::new(Vec::new()),
+            hits: std::sync::atomic::AtomicU64::new(0),
+            misses: std::sync::atomic::AtomicU64::new(0),
+            allocs: std::sync::atomic::AtomicU64::new(0),
+            puts: std::sync::atomic::AtomicU64::new(0),
+        }
+    }
+
+    /// Try to get a pooled pinned buffer without performing expensive allocation.
+    ///
+    /// Returns `Ok(None)` if no buffer is available in the pool for the requested size class.
+    /// Unlike `get`, this will never call `cuMemAllocHost`.
+    pub fn try_get(self: &Arc<Self>, len: usize) -> VortexResult<Option<PooledPinnedBuffer>> {
+        match self.try_get_inner(len)? {
+            Some(inner) => Ok(Some(PooledPinnedBuffer::new(inner, Arc::clone(self)))),
+            None => Ok(None),
+        }
+    }
+
+    /// Acquire a pooled pinned buffer of the given size in bytes.
+    ///
+    /// The buffer is returned to the pool when the [`PooledPinnedBuffer`] is dropped.
+    pub(crate) fn get(self: &Arc<Self>, len: usize) -> VortexResult<PooledPinnedBuffer> {
+        let inner = self.get_inner(len)?;
+        Ok(PooledPinnedBuffer::new(inner, Arc::clone(self)))
+    }
+
+    /// Defer returning a pinned buffer to the pool until the CUDA event completes.
+    pub(crate) fn put_inflight(
+        &self,
+        event: Arc<CudaEvent>,
+        buffer: PinnedByteBuffer,
+    ) -> VortexResult<()> {
+        let mut inflight = self.inflight.lock();
+        inflight.push(InflightPinnedBuffer { event, buffer });
+        Ok(())
+    }
+
+    /// Snapshot pool reuse statistics.
+    pub fn stats(&self) -> PinnedPoolStats {
+        PinnedPoolStats {
+            hits: self.hits.load(std::sync::atomic::Ordering::Relaxed),
+            misses: self.misses.load(std::sync::atomic::Ordering::Relaxed),
+            allocs: self.allocs.load(std::sync::atomic::Ordering::Relaxed),
+            puts: self.puts.load(std::sync::atomic::Ordering::Relaxed),
+        }
+    }
+
+    fn size_class_len(&self, len: usize) -> usize {
+        if len == 0 { 0 } else { len.next_power_of_two() }
+    }
+
+    /// Reclaim inflight pinned buffers whose CUDA completion events have fired.
+    ///
+    /// Completed buffers are moved back into size-class buckets for reuse.
+    fn reclaim_completed(&self) -> VortexResult<()> {
+        let mut inflight = self.inflight.lock();
+        if inflight.is_empty() {
+            return Ok(());
+        }
+        self.ctx
+            .bind_to_thread()
+            .map_err(|e| vortex_err!("Failed to bind CUDA context: {e}"))?;
+        let mut idx = 0usize;
+        while idx < inflight.len() {
+            if !inflight[idx].event.is_complete() {
+                idx += 1;
+                continue;
+            }
+            let completed = inflight.swap_remove(idx);
+            self.put(completed.buffer);
+        }
+        Ok(())
+    }
+
+    fn get_inner(&self, len: usize) -> VortexResult<PinnedByteBuffer> {
+        self.reclaim_completed()?;
+        let key_len = self.size_class_len(len);
+        {
+            let mut buckets = self.buckets.lock();
+            if let Some(bucket) = buckets.get_mut(&key_len)
+                && let Some(buf) = bucket.pop()
+            {
+                self.hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                let mut buf = buf;
+                buf.set_logical_len(len);
+                return Ok(buf);
+            }
+        }
+        self.misses
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        self.allocs
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        unsafe { PinnedByteBuffer::uninit_with_capacity(&self.ctx, key_len, len) }
+    }
+
+    fn put(&self, buf: PinnedByteBuffer) {
+        let len = buf.capacity();
+        let overflow = {
+            let mut buckets = self.buckets.lock();
+            let bucket = buckets.entry(len).or_default();
+            if bucket.len() < self.max_keep_per_size {
+                bucket.push(buf);
+                None
+            } else {
+                Some(buf)
+            }
+        };
+        // If the pool is full, the buffer (cuMemFreeHost) is dropped outside the lock.
+        drop(overflow);
+        self.puts.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    fn try_get_inner(&self, len: usize) -> VortexResult<Option<PinnedByteBuffer>> {
+        self.reclaim_completed()?;
+        let key_len = self.size_class_len(len);
+        let mut buckets = self.buckets.lock();
+        if let Some(bucket) = buckets.get_mut(&key_len)
+            && let Some(mut buf) = bucket.pop()
+        {
+            self.hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            buf.set_logical_len(len);
+            Ok(Some(buf))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+/// Reuse counters for a pinned buffer pool.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct PinnedPoolStats {
+    pub hits: u64,
+    pub misses: u64,
+    pub allocs: u64,
+    pub puts: u64,
+}
+
+/// A pinned buffer that is returned to its pool when dropped.
+///
+/// This wrapper owns a pinned byte buffer and ensures it gets returned to the
+/// [`PinnedByteBufferPool`] when the buffer is no longer needed. This enables efficient
+/// buffer reuse for I/O operations.
+pub struct PooledPinnedBuffer {
+    inner: Option<PinnedByteBuffer>,
+    pool: Arc<PinnedByteBufferPool>,
+}
+
+#[allow(clippy::same_name_method)]
+impl PooledPinnedBuffer {
+    /// Create a new pooled buffer.
+    pub(crate) fn new(inner: PinnedByteBuffer, pool: Arc<PinnedByteBufferPool>) -> Self {
+        Self {
+            inner: Some(inner),
+            pool,
+        }
+    }
+
+    /// Returns the buffer as a mutable slice.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the buffer has already been consumed or if the CUDA context is invalid.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        let inner = self
+            .inner
+            .as_mut()
+            .unwrap_or_else(|| vortex_panic!("buffer already consumed"));
+        inner
+            .as_mut_slice()
+            .unwrap_or_else(|e| vortex_panic!("failed to access pinned host buffer: {e}"))
+    }
+
+    /// Submits a non-blocking H2D DMA transfer and returns a device buffer.
+    ///
+    /// The pinned buffer is placed in the pool's inflight queue, gated on a `CudaEvent` marking
+    /// the transfer completion. The pool reclaims it once the event fires.
+    pub fn transfer_to_device(
+        mut self,
+        stream: &VortexCudaStream,
+    ) -> VortexResult<CudaDeviceBuffer> {
+        let pinned = self
+            .inner
+            .as_ref()
+            .unwrap_or_else(|| vortex_panic!("buffer already consumed"));
+        let len = pinned.len();
+
+        let mut cuda_slice = stream.device_alloc::<u8>(len)?;
+
+        // Async because the pinned buffer is page-locked: memcpy_htod returns a
+        // SyncOnDrop::Record (non-blocking) rather than SyncOnDrop::Sync.
+        stream
+            .memcpy_htod(pinned, &mut cuda_slice)
+            .map_err(|e| vortex_err!("Failed to schedule H2D copy: {}", e))?;
+
+        let event = Arc::new(
+            stream
+                .record_event(None)
+                .map_err(|e| vortex_err!("Failed to record CUDA event: {}", e))?,
+        );
+
+        // Take ownership only after all fallible ops succeed. Before this point,
+        // errors cause `self` to drop, returning the buffer to the pool.
+        let inner = self
+            .inner
+            .take()
+            .unwrap_or_else(|| vortex_panic!("buffer already consumed"));
+        self.pool.put_inflight(event, inner)?;
+
+        Ok(CudaDeviceBuffer::new(cuda_slice))
+    }
+}
+
+impl Drop for PooledPinnedBuffer {
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
+            self.pool.put(inner);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use cudarc::driver::CudaContext;
+    use vortex::array::buffer::DeviceBuffer;
+    use vortex::buffer::Alignment;
+    use vortex::error::VortexResult;
+
+    use super::*;
+
+    fn setup() -> VortexResult<(Arc<PinnedByteBufferPool>, VortexCudaStream)> {
+        let ctx = CudaContext::new(0).map_err(|e| vortex_err!("Failed to initialize CUDA: {e}"))?;
+        let pool = Arc::new(PinnedByteBufferPool::new(Arc::clone(&ctx)));
+        let stream = VortexCudaStream(
+            ctx.new_stream()
+                .map_err(|e| vortex_err!("Failed to create stream: {e}"))?,
+        );
+        Ok((pool, stream))
+    }
+
+    #[crate::test]
+    fn transfer_to_device_round_trip() -> VortexResult<()> {
+        let (pool, stream) = setup()?;
+        let data: Vec<u8> = (0..=255u8).collect();
+
+        let mut pinned = pool.get(data.len())?;
+        pinned.as_mut_slice().copy_from_slice(&data);
+
+        let device_buf = pinned.transfer_to_device(&stream)?;
+
+        let host_buf = device_buf.copy_to_host_sync(Alignment::of::<u8>())?;
+        assert_eq!(host_buf.as_ref(), &data[..]);
+        Ok(())
+    }
+
+    #[crate::test]
+    fn transfer_puts_buffer_inflight() -> VortexResult<()> {
+        let (pool, stream) = setup()?;
+
+        let mut pinned = pool.get(1024)?;
+        pinned.as_mut_slice().fill(0xAB);
+
+        let stats_before = pool.stats();
+        assert_eq!(stats_before.allocs, 1);
+        assert_eq!(stats_before.puts, 0);
+        assert_eq!(stats_before.hits, 0);
+
+        let _device_buf = pinned.transfer_to_device(&stream)?;
+
+        // put_inflight does not increment the puts counter
+        let stats_after = pool.stats();
+        assert_eq!(stats_after.puts, 0);
+
+        // The buffer is in the inflight queue, not yet in a bucket
+        assert_eq!(pool.inflight.lock().len(), 1);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    fn pool_reclaims_after_transfer_completes() -> VortexResult<()> {
+        let (pool, stream) = setup()?;
+
+        let mut pinned = pool.get(1024)?;
+        pinned.as_mut_slice().fill(0xCD);
+
+        let _device_buf = pinned.transfer_to_device(&stream)?;
+
+        // Sync the stream so the recorded event completes.
+        stream
+            .synchronize()
+            .map_err(|e| vortex_err!("Failed to sync stream: {e}"))?;
+
+        assert_eq!(pool.stats().hits, 0);
+        assert_eq!(pool.stats().allocs, 1);
+
+        // get_inner calls reclaim_completed, which finds the completed event
+        // and moves the buffer back into a bucket before serving the request.
+        let _pinned2 = pool.get(1024)?;
+
+        let stats = pool.stats();
+        assert_eq!(stats.hits, 1);
+        // reclaim_completed called put once for the completed buffer
+        assert_eq!(stats.puts, 1);
+        // No additional allocation was needed
+        assert_eq!(stats.allocs, 1);
+        // Inflight queue is now drained
+        assert_eq!(pool.inflight.lock().len(), 0);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    fn drop_returns_buffer_to_pool() -> VortexResult<()> {
+        let (pool, _stream) = setup()?;
+
+        {
+            let mut pinned = pool.get(512)?;
+            pinned.as_mut_slice().fill(0);
+        }
+
+        let stats = pool.stats();
+        assert_eq!(stats.puts, 1);
+        assert_eq!(stats.allocs, 1);
+
+        // Getting again should be a pool hit, not a new allocation.
+        let _pinned2 = pool.get(512)?;
+        let stats = pool.stats();
+        assert_eq!(stats.hits, 1);
+        assert_eq!(stats.allocs, 1);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    fn transfer_consumes_inner_so_drop_is_noop() -> VortexResult<()> {
+        let (pool, stream) = setup()?;
+
+        let mut pinned = pool.get(256)?;
+        pinned.as_mut_slice().fill(0xFF);
+
+        // transfer_to_device takes self and moves inner into inflight.
+        // The PooledPinnedBuffer's Drop should not double-return the buffer.
+        let _device_buf = pinned.transfer_to_device(&stream)?;
+
+        // Sync and reclaim so the single inflight buffer returns.
+        stream
+            .synchronize()
+            .map_err(|e| vortex_err!("Failed to sync stream: {e}"))?;
+        pool.reclaim_completed()?;
+
+        // Exactly one put from reclaim, zero from Drop.
+        assert_eq!(pool.stats().puts, 1);
+
+        Ok(())
+    }
+}
diff --git a/vortex-cuda/src/pooled_read_at.rs b/vortex-cuda/src/pooled_read_at.rs
new file mode 100644
index 00000000000..1b5ec4fb31a
--- /dev/null
+++ b/vortex-cuda/src/pooled_read_at.rs
@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fs::File;
+use std::io;
+use std::path::Path;
+use std::sync::Arc;
+
+use futures::FutureExt;
+use futures::StreamExt;
+use futures::future::BoxFuture;
+use object_store::GetOptions;
+use object_store::GetRange;
+use object_store::GetResultPayload;
+use object_store::ObjectStore;
+use object_store::ObjectStoreExt;
+use object_store::path::Path as ObjectPath;
+use vortex::array::buffer::BufferHandle;
+use vortex::buffer::Alignment;
+use vortex::buffer::ByteBuffer;
+use vortex::error::VortexError;
+use vortex::error::VortexResult;
+use vortex::error::vortex_ensure;
+use vortex::error::vortex_err;
+use vortex::io::CoalesceConfig;
+use vortex::io::VortexReadAt;
+use vortex::io::runtime::Handle;
+use vortex::io::std_file::read_exact_at;
+
+use crate::pinned::PinnedByteBufferPool;
+use crate::stream::VortexCudaStream;
+
+/// Default number of concurrent requests to allow for local file I/O.
+pub const DEFAULT_FILE_CONCURRENCY: usize = 32;
+/// Default number of concurrent requests to allow for object store I/O.
+pub const DEFAULT_OBJECT_STORE_CONCURRENCY: usize = 192;
+
+/// File reader that uses CUDA pinned host memory for I/O buffers and transfers
+/// directly to the GPU.
+///
+/// Reads into a pooled pinned (page-locked) buffer, then submits a non-blocking
+/// H2D DMA transfer and returns a device `BufferHandle`.
+#[derive(Clone)]
+pub struct PooledFileReadAt {
+    uri: Arc<str>,
+    file: Arc<File>,
+    handle: Handle,
+    pool: Arc<PinnedByteBufferPool>,
+    stream: VortexCudaStream,
+}
+
+impl PooledFileReadAt {
+    /// Open a file for pooled reading with direct device transfer.
+    pub fn open(
+        path: impl AsRef<Path>,
+        handle: Handle,
+        pool: Arc<PinnedByteBufferPool>,
+        stream: VortexCudaStream,
+    ) -> VortexResult<Self> {
+        let path = path.as_ref();
+        let uri = Arc::from(path.to_string_lossy().to_string());
+        let file = Arc::new(File::open(path)?);
+        Ok(Self {
+            uri,
+            file,
+            handle,
+            pool,
+            stream,
+        })
+    }
+}
+
+impl VortexReadAt for PooledFileReadAt {
+    fn uri(&self) -> Option<&Arc<str>> {
+        Some(&self.uri)
+    }
+
+    fn coalesce_config(&self) -> Option<CoalesceConfig> {
+        Some(CoalesceConfig::file())
+    }
+
+    fn concurrency(&self) -> usize {
+        DEFAULT_FILE_CONCURRENCY
+    }
+
+    fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
+        let file = Arc::clone(&self.file);
+        async move {
+            let metadata = file.metadata()?;
+            Ok(metadata.len())
+        }
+        .boxed()
+    }
+
+    fn read_at(
+        &self,
+        offset: u64,
+        length: usize,
+        _alignment: Alignment,
+    ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
+        let file = Arc::clone(&self.file);
+        let handle = self.handle.clone();
+        let stream = self.stream.clone();
+        let pool = Arc::clone(&self.pool);
+
+        async move {
+            let mut target = pool.get(length)?;
+            let target = handle
+                .spawn_blocking(move || {
+                    read_exact_at(&file, target.as_mut_slice(), offset)?;
+                    Ok::<_, io::Error>(target)
+                })
+                .await
+                .map_err(VortexError::from)?;
+
+            let cuda_buf = target.transfer_to_device(&stream)?;
+            Ok(BufferHandle::new_device(Arc::new(cuda_buf)))
+        }
+        .boxed()
+    }
+}
+
+/// Object store reader that uses CUDA pinned host memory for I/O buffers and
+/// transfers directly to the GPU.
+///
+/// Reads into a pooled pinned (page-locked) buffer, then submits a non-blocking
+/// H2D DMA transfer and returns a device `BufferHandle`.
+#[derive(Clone)]
+pub struct PooledObjectStoreReadAt {
+    store: Arc<dyn ObjectStore>,
+    path: ObjectPath,
+    uri: Arc<str>,
+    handle: Handle,
+    pool: Arc<PinnedByteBufferPool>,
+    stream: VortexCudaStream,
+    concurrency: usize,
+    coalesce_config: Option<CoalesceConfig>,
+}
+
+impl PooledObjectStoreReadAt {
+    /// Create a new object-store source with pinned host-buffer allocations and direct device transfer.
+    pub fn new(
+        store: Arc<dyn ObjectStore>,
+        path: ObjectPath,
+        handle: Handle,
+        pool: Arc<PinnedByteBufferPool>,
+        stream: VortexCudaStream,
+    ) -> Self {
+        let uri = Arc::from(path.to_string());
+        Self {
+            store,
+            path,
+            uri,
+            handle,
+            pool,
+            stream,
+            concurrency: DEFAULT_OBJECT_STORE_CONCURRENCY,
+            coalesce_config: Some(CoalesceConfig::object_storage()),
+        }
+    }
+
+    /// Set the concurrency for this source.
+    pub fn with_concurrency(mut self, concurrency: usize) -> Self {
+        self.concurrency = concurrency;
+        self
+    }
+
+    /// Set the coalesce config for this source.
+    pub fn with_coalesce_config(mut self, config: CoalesceConfig) -> Self {
+        self.coalesce_config = Some(config);
+        self
+    }
+}
+
+impl VortexReadAt for PooledObjectStoreReadAt {
+    fn uri(&self) -> Option<&Arc<str>> {
+        Some(&self.uri)
+    }
+
+    fn coalesce_config(&self) -> Option<CoalesceConfig> {
+        self.coalesce_config
+    }
+
+    fn concurrency(&self) -> usize {
+        self.concurrency
+    }
+
+    fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
+        let store = Arc::clone(&self.store);
+        let path = self.path.clone();
+        async move {
+            store
+                .head(&path)
+                .await
+                .map(|h| h.size)
+                .map_err(VortexError::from)
+        }
+        .boxed()
+    }
+
+    fn read_at(
+        &self,
+        offset: u64,
+        length: usize,
+        _alignment: Alignment,
+    ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
+        let store = Arc::clone(&self.store);
+        let path = self.path.clone();
+        let handle = self.handle.clone();
+        let stream = self.stream.clone();
+        let pool = Arc::clone(&self.pool);
+
+        async move {
+            let end = offset.checked_add(length as u64).ok_or_else(|| {
+                vortex_err!(
+                    "Object store read range overflow: offset={}, length={}",
+                    offset,
+                    length
+                )
+            })?;
+            let range = offset..end;
+            let mut target = pool.get(length)?;
+            let response = store
+                .get_opts(
+                    &path,
+                    GetOptions {
+                        range: Some(GetRange::Bounded(range.clone())),
+                        ..Default::default()
+                    },
+                )
+                .await?;
+
+            match response.payload {
+                #[cfg(not(target_arch = "wasm32"))]
+                GetResultPayload::File(file, _) => {
+                    target = handle
+                        .spawn_blocking(move || {
+                            read_exact_at(&file, target.as_mut_slice(), range.start)?;
+                            Ok::<_, io::Error>(target)
+                        })
+                        .await
+                        .map_err(VortexError::from)?;
+                }
+                #[cfg(target_arch = "wasm32")]
+                GetResultPayload::File(..) => {
+                    unreachable!("File payload not supported on wasm32")
+                }
+                GetResultPayload::Stream(mut byte_stream) => {
+                    let mut filled = 0usize;
+                    while let Some(bytes) = byte_stream.next().await {
+                        let bytes = bytes?;
+                        let end = filled + bytes.len();
+                        vortex_ensure!(
+                            end <= length,
+                            "Object store stream returned more bytes than expected (expected {} bytes, got at least {} bytes, range: {:?})",
+                            length,
+                            end,
+                            range
+                        );
+                        target.as_mut_slice()[filled..end].copy_from_slice(&bytes);
+                        filled = end;
+                    }
+
+                    vortex_ensure!(
+                        filled == length,
+                        "Object store stream returned {} bytes but expected {} bytes (range: {:?})",
+                        filled,
+                        length,
+                        range
+                    );
+                }
+            }
+
+            let cuda_buf = target.transfer_to_device(&stream)?;
+            Ok(BufferHandle::new_device(Arc::new(cuda_buf)))
+        }
+        .boxed()
+    }
+}
+
+/// Default number of concurrent requests to allow for in-memory byte buffer I/O.
+pub const DEFAULT_BYTE_BUFFER_CONCURRENCY: usize = 16;
+
+/// In-memory byte buffer reader that uses CUDA pinned host memory for staging
+/// and transfers directly to the GPU.
+///
+/// Slices the source `ByteBuffer`, copies into a pooled pinned (page-locked)
+/// buffer, then submits a non-blocking H2D DMA transfer and returns a device
+/// `BufferHandle`.
+#[derive(Clone)]
+pub struct PooledByteBufferReadAt {
+    buffer: ByteBuffer,
+    pool: Arc<PinnedByteBufferPool>,
+    stream: VortexCudaStream,
+}
+
+impl PooledByteBufferReadAt {
+    /// Create a new in-memory reader with pinned host-buffer allocations and direct device transfer.
+    pub fn new(
+        buffer: ByteBuffer,
+        pool: Arc<PinnedByteBufferPool>,
+        stream: VortexCudaStream,
+    ) -> Self {
+        Self {
+            buffer,
+            pool,
+            stream,
+        }
+    }
+}
+
+impl VortexReadAt for PooledByteBufferReadAt {
+    fn coalesce_config(&self) -> Option<CoalesceConfig> {
+        Some(CoalesceConfig::in_memory())
+    }
+
+    fn concurrency(&self) -> usize {
+        DEFAULT_BYTE_BUFFER_CONCURRENCY
+    }
+
+    fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
+        let len = self.buffer.len() as u64;
+        async move { Ok(len) }.boxed()
+    }
+
+    fn read_at(
+        &self,
+        offset: u64,
+        length: usize,
+        _alignment: Alignment,
+    ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
+        let buffer = self.buffer.clone();
+        let stream = self.stream.clone();
+        let pool = Arc::clone(&self.pool);
+
+        async move {
+            let offset = usize::try_from(offset)
+                .map_err(|_| vortex_err!("Byte buffer read offset overflow: offset={}", offset))?;
+            let src = &buffer.as_ref()[offset..offset + length];
+
+            let mut target = pool.get(length)?;
+            target.as_mut_slice().copy_from_slice(src);
+
+            let cuda_buf = target.transfer_to_device(&stream)?;
+            Ok(BufferHandle::new_device(Arc::new(cuda_buf)))
+        }
+        .boxed()
+    }
+}
diff --git a/vortex-cuda/src/session.rs b/vortex-cuda/src/session.rs
index 1da99eb07d6..e6bf4710dda 100644
--- a/vortex-cuda/src/session.rs
+++ b/vortex-cuda/src/session.rs
@@ -5,8 +5,8 @@ use std::fmt::Debug;
 use std::sync::Arc;
 
 use cudarc::driver::CudaContext;
+use vortex::array::ArrayId;
 use vortex::array::VortexSessionExecute;
-use vortex::array::vtable::ArrayId;
 use vortex::error::VortexResult;
 use vortex::session::Ref;
 use vortex::session::SessionExt;
@@ -65,18 +65,18 @@ impl CudaSession {
     pub fn create_execution_ctx(
         vortex_session: &vortex::session::VortexSession,
     ) -> VortexResult<CudaExecutionCtx> {
-        let stream = vortex_session.cuda_session().new_stream()?;
+        let stream = vortex_session.cuda_session().stream()?;
         Ok(CudaExecutionCtx::new(
             stream,
             vortex_session.create_execution_ctx(),
         ))
     }
 
-    /// Gets a CUDA stream from the pool.
+    /// Returns a CUDA stream from the pool.
     ///
     /// The pool reuses existing streams in round-robin fashion.
-    pub fn new_stream(&self) -> VortexResult<VortexCudaStream> {
-        self.stream_pool.get_stream()
+    pub fn stream(&self) -> VortexResult<VortexCudaStream> {
+        self.stream_pool.stream()
     }
 
     /// Registers CUDA support for an array encoding.
diff --git a/vortex-cuda/src/stream.rs b/vortex-cuda/src/stream.rs
index 3d7002f776a..1b7c99c54a9 100644
--- a/vortex-cuda/src/stream.rs
+++ b/vortex-cuda/src/stream.rs
@@ -4,13 +4,12 @@
 //! CUDA stream utility functions.
 
 use std::fmt::Debug;
+use std::ops::Deref;
 use std::sync::Arc;
 
 use cudarc::driver::CudaSlice;
 use cudarc::driver::CudaStream;
-use cudarc::driver::DevicePtrMut;
 use cudarc::driver::DeviceRepr;
-use cudarc::driver::result::memcpy_htod_async;
 use cudarc::driver::result::stream;
 use futures::future::BoxFuture;
 use kanal::Sender;
@@ -24,6 +23,14 @@ use crate::CudaDeviceBuffer;
 #[derive(Clone)]
 pub struct VortexCudaStream(pub(crate) Arc<CudaStream>);
 
+impl Deref for VortexCudaStream {
+    type Target = Arc<CudaStream>;
+
+    fn deref(&self) -> &Arc<CudaStream> {
+        &self.0
+    }
+}
+
 impl VortexCudaStream {
     /// Allocates a typed buffer on the GPU.
     ///
@@ -40,8 +47,7 @@ impl VortexCudaStream {
     ) -> VortexResult<CudaSlice<T>> {
         // SAFETY: No safety guarantees for allocations on the GPU.
         unsafe {
-            self.0
-                .alloc::<T>(len)
+            self.alloc::<T>(len)
                 .map_err(|e| vortex_err!("Failed to allocate device memory: {}", e))
         }
     }
@@ -65,24 +71,11 @@ impl VortexCudaStream {
         D: AsRef<[T]> + Send + 'static,
     {
         let host_slice: &[T] = data.as_ref();
+        // `device_alloc` binds the CUDA context to the current thread.
         let mut cuda_slice: CudaSlice<T> = self.device_alloc(host_slice.len())?;
-        let (device_ptr, record_write) = cuda_slice.device_ptr_mut(&self.0);
-
-        // calling the unsafe memcpy_htod_async expects the cuda context thread local
-        // to be set. To avoid invalid context error from the cuda call we set it
-        // explicitly here.
-        // TODO(os): wrap calling unsafe cudarc functions with something that binds always
-        //           so we don't forget
-        self.0
-            .context()
-            .bind_to_thread()
-            .map_err(|e| vortex_err!("Failed to bind CUDA context: {}", e))?;
 
-        unsafe {
-            memcpy_htod_async(device_ptr, host_slice, self.0.cu_stream())
-                .map_err(|e| vortex_err!("Failed to schedule async copy to device: {}", e))?;
-        }
-        drop(record_write);
+        self.memcpy_htod(host_slice, &mut cuda_slice)
+            .map_err(|e| vortex_err!("Failed to schedule H2D copy: {}", e))?;
 
         let cuda_buf = CudaDeviceBuffer::new(cuda_slice);
         let stream = Arc::clone(&self.0);
@@ -96,6 +89,28 @@ impl VortexCudaStream {
             Ok(BufferHandle::new_device(Arc::new(cuda_buf)))
         }))
     }
+
+    /// Synchronous variant of [`copy_to_device`](Self::copy_to_device).
+    ///
+    /// Allocates device memory, enqueues the H2D copy on the stream, and
+    /// returns immediately. The device pointer is valid as soon as this call
+    /// returns; the copy completes before any later work on the same stream.
+    ///
+    /// For **pageable** host memory (the common case), `memcpy_htod` stages
+    /// the source into a driver-managed pinned buffer before returning, so
+    /// the source data is safe to drop after this call.
+    pub(crate) fn copy_to_device_sync<T>(&self, data: &[T]) -> VortexResult<BufferHandle>
+    where
+        T: DeviceRepr + Debug + Send + Sync + 'static,
+    {
+        let mut cuda_slice: CudaSlice<T> = self.device_alloc(data.len())?;
+
+        self.memcpy_htod(data, &mut cuda_slice)
+            .map_err(|e| vortex_err!("Failed to schedule H2D copy: {}", e))?;
+
+        let cuda_buf = CudaDeviceBuffer::new(cuda_slice);
+        Ok(BufferHandle::new_device(Arc::new(cuda_buf)))
+    }
 }
 
 /// Registers a callback and asynchronously waits for its completion.
diff --git a/vortex-cuda/src/stream_pool.rs b/vortex-cuda/src/stream_pool.rs
index 776d73d9059..6f8e66798c5 100644
--- a/vortex-cuda/src/stream_pool.rs
+++ b/vortex-cuda/src/stream_pool.rs
@@ -57,12 +57,12 @@ impl VortexCudaStreamPool {
         }
     }
 
-    /// Gets a stream from the pool.
+    /// Returns a stream from the pool.
     ///
     /// Uses round-robin slot selection. If the selected slot has a stream,
     /// it is reused. Otherwise, a new stream is created for that slot.
     /// All operations are lock-free.
-    pub fn get_stream(&self) -> VortexResult<VortexCudaStream> {
+    pub fn stream(&self) -> VortexResult<VortexCudaStream> {
         let slot_idx = self.next_index.fetch_add(1, Ordering::Relaxed) % self.slots.len();
         let slot = &self.slots[slot_idx];
 
diff --git a/vortex-cxx/.clang-tidy b/vortex-cxx/.clang-tidy
index b0ef3150b91..80c94310cbc 100644
--- a/vortex-cxx/.clang-tidy
+++ b/vortex-cxx/.clang-tidy
@@ -43,7 +43,7 @@ Checks: |
   -bugprone-unused-local-non-trivial-variable,
   -bugprone-empty-catch,
 WarningsAsErrors: '*'
-HeaderFilterRegex: 'include/.*'
+HeaderFilterRegex: '(cpp|examples)/.*\.(cpp|hpp)$'
 FormatStyle:     none
 CheckOptions:
   - key:             readability-identifier-naming.ClassCase
diff --git a/vortex-cxx/CMakeLists.txt b/vortex-cxx/CMakeLists.txt
index 557b8acdbd7..ab5474d0617 100644
--- a/vortex-cxx/CMakeLists.txt
+++ b/vortex-cxx/CMakeLists.txt
@@ -8,8 +8,9 @@ cmake_policy(SET CMP0135 NEW)
 
 project(vortex)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 find_program(SCCACHE_PROGRAM sccache)
 if (SCCACHE_PROGRAM)
@@ -24,7 +25,7 @@ if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wpedantic -Wno-dollar-in-identifier-extension")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -Wno-dollar-in-identifier-extension")
 
 option(VORTEX_ENABLE_TESTING "Enable building test binary for vortex-cxx" OFF)
 option(VORTEX_ENABLE_ASAN "Enable address sanitizer" OFF)
@@ -72,17 +73,17 @@ set(CPP_PRIVATE_INCLUDE_DIRS
 
 # Create the main library combining C++ and Rust code
 add_library(vortex STATIC ${CPP_SOURCE_FILE})
-target_include_directories(vortex PUBLIC ${CPP_INCLUDE_DIRS} 
+target_include_directories(vortex PUBLIC ${CPP_INCLUDE_DIRS}
     ${CMAKE_CURRENT_BINARY_DIR}/corrosion_generated/cxxbridge/vortex_cxx_bridge/include)
-target_include_directories(vortex PRIVATE 
+target_include_directories(vortex PRIVATE
     ${CPP_PRIVATE_INCLUDE_DIRS}
 )
-target_link_libraries(vortex 
+target_link_libraries(vortex
     PUBLIC nanoarrow_static
     PRIVATE vortex_cxx_bridge
 )
 
-if (VORTEX_ENABLE_ASAN) 
+if (VORTEX_ENABLE_ASAN)
     target_compile_options(vortex PRIVATE -fsanitize=leak,address,undefined -fno-omit-frame-pointer -fno-common -O1)
     target_link_options(vortex PRIVATE -fsanitize=leak,address,undefined)
 endif()
@@ -102,7 +103,7 @@ if (VORTEX_ENABLE_TESTING)
     target_include_directories(vortex_cxx_test PUBLIC ${CPP_INCLUDE_DIRS})
     target_include_directories(vortex_cxx_test PRIVATE cpp/tests)
     target_link_libraries(vortex_cxx_test PRIVATE gtest_main vortex nanoarrow_static)
-    target_include_directories(vortex_cxx_test PRIVATE 
+    target_include_directories(vortex_cxx_test PRIVATE
         ${CMAKE_CURRENT_BINARY_DIR}/corrosion_generated/cxxbridge/vortex_cxx_bridge/include
     )
     # Platform-specific configuration
@@ -110,7 +111,7 @@ if (VORTEX_ENABLE_TESTING)
         set(APPLE_LINK_FLAGS "-framework CoreFoundation -framework Security")
     endif()
     target_link_libraries(vortex_cxx_test PRIVATE vortex_cxx_bridge ${APPLE_LINK_FLAGS})
-    if (VORTEX_ENABLE_ASAN) 
+    if (VORTEX_ENABLE_ASAN)
         target_compile_options(vortex_cxx_test PRIVATE -fsanitize=leak,address,undefined -fno-omit-frame-pointer -fno-common -O1)
         target_link_options(vortex_cxx_test PRIVATE -fsanitize=leak,address,undefined)
     endif()
diff --git a/vortex-cxx/README.md b/vortex-cxx/README.md
index e413ec15142..aa761f98b1a 100644
--- a/vortex-cxx/README.md
+++ b/vortex-cxx/README.md
@@ -7,7 +7,7 @@ This directory contains C++ bindings for Vortex using the [cxx](https://cxx.rs/)
 ### Requirements
 
 - CMake 3.22 or higher
-- C++17 compatible compiler
+- C++20 compatible compiler
 - Rust toolchain (for building the Rust components)
 - (optional) Ninja (`ninja-build`)
 
diff --git a/vortex-cxx/cpp/src/expr.cpp b/vortex-cxx/cpp/src/expr.cpp
index 19a8aae8ec4..0e2d67395c1 100644
--- a/vortex-cxx/cpp/src/expr.cpp
+++ b/vortex-cxx/cpp/src/expr.cpp
@@ -50,7 +50,8 @@ DEFINE_BINARY_OP(checked_add)
 
 Expr select(const std::vector<std::string_view> &fields, Expr child) {
     ::rust::Vec<::rust::String> rs_fields;
-    for (auto f : fields) {
+    rs_fields.reserve(fields.size());
+    for (std::string_view f : fields) {
         rs_fields.emplace_back(f.data(), f.length());
     }
     return Expr(ffi::select(rs_fields, std::move(child).IntoImpl()));
diff --git a/vortex-cxx/cpp/tests/basic_test.cpp b/vortex-cxx/cpp/tests/basic_test.cpp
index f029d79f740..eb44715285a 100644
--- a/vortex-cxx/cpp/tests/basic_test.cpp
+++ b/vortex-cxx/cpp/tests/basic_test.cpp
@@ -7,6 +7,8 @@
 #include <fstream>
 #include <thread>
 #include <iostream>
+#include <random>
+#include <sstream>
 
 #include "vortex/file.hpp"
 #include "vortex/scan.hpp"
@@ -19,19 +21,9 @@
 #include <nanoarrow/nanoarrow.h>
 
 class VortexTest : public ::testing::Test {
-public:
-    static void SetUpTestSuite() {
-        std::string test_data_path = GetTestDataPath("test_data.vortex");
-        auto stream = vortex::testing::CreateTestDataStream();
-        auto write_options = vortex::ffi::write_options_new();
-        vortex::ffi::write_array_stream(std::move(write_options),
-                                        reinterpret_cast<uint8_t *>(&stream),
-                                        test_data_path.c_str());
-    }
-
 protected:
-    // Helper function to construct file paths in system temp directory
-    static std::string GetTestDataPath(const std::string &filename) {
+    // Helper function to create unique temporary files for each test
+    static std::string GetUniqueTempFile(const std::string &suffix = "vortex") {
         std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
         std::filesystem::path vortex_test_dir = temp_dir / "vortex_test";
 
@@ -39,8 +31,20 @@ class VortexTest : public ::testing::Test {
             std::filesystem::create_directories(vortex_test_dir);
         }
 
-        std::filesystem::path target_path = vortex_test_dir / filename;
-        return target_path.string();
+        // Use a unique random filename to prevent races between parallel test runs
+        std::string unique_name = "test_" + std::to_string(std::random_device {}()) + "_" + suffix;
+        return (vortex_test_dir / unique_name).string();
+    }
+
+    // Write test data to a unique temporary file and return the path
+    static std::string WriteTestData(const std::string &suffix = "test_data.vortex") {
+        std::string path = GetUniqueTempFile(suffix);
+        auto stream = vortex::testing::CreateTestDataStream();
+        auto write_options = vortex::ffi::write_options_new();
+        vortex::ffi::write_array_stream(std::move(write_options),
+                                        reinterpret_cast<uint8_t *>(&stream),
+                                        path.c_str());
+        return path;
     }
 
     // Helper function to create and initialize array view
@@ -153,7 +157,8 @@ class VortexTest : public ::testing::Test {
     // Helper to execute scan builder and get array+schema
     std::pair<nanoarrow::UniqueArray, nanoarrow::UniqueSchema> ScanFirstArrayFromTestData(
         const std::function<ArrowArrayStream(vortex::ScanBuilder &)> &configureScanBuilder) {
-        auto file = vortex::VortexFile::Open(GetTestDataPath("test_data.vortex"));
+        auto test_data_path = WriteTestData();
+        auto file = vortex::VortexFile::Open(test_data_path);
         auto scan_builder = file.CreateScanBuilder();
         auto stream = configureScanBuilder(scan_builder);
 
@@ -260,15 +265,17 @@ TEST_F(VortexTest, ScanBuilderWithRowRangeWithIncludeByIndex) {
 }
 
 TEST_F(VortexTest, WriteArrayStream) {
-    auto file = vortex::VortexFile::Open(GetTestDataPath("test_data.vortex"));
+    auto test_data_path = WriteTestData();
+    auto file = vortex::VortexFile::Open(test_data_path);
     auto stream = file.CreateScanBuilder().IntoStream();
 
     // Write the stream to a new Vortex file
+    std::string test_output_path = GetUniqueTempFile("write_output.vortex");
     vortex::VortexWriteOptions write_options;
-    ASSERT_NO_THROW(write_options.WriteArrayStream(stream, GetTestDataPath("test_output.vortex")));
+    ASSERT_NO_THROW(write_options.WriteArrayStream(stream, test_output_path));
 
     // Verify the written file
-    auto written_file = vortex::VortexFile::Open(GetTestDataPath("test_output.vortex"));
+    auto written_file = vortex::VortexFile::Open(test_output_path);
     ASSERT_EQ(written_file.RowCount(), 5);
 
     // Verify data integrity by reading from the written file
@@ -280,7 +287,7 @@ TEST_F(VortexTest, WriteArrayStream) {
 }
 
 TEST_F(VortexTest, ConcurrentMultiStreamRead) {
-    std::string test_data_path_1m = GetTestDataPath("test_data_1m.vortex");
+    std::string test_data_path_1m = GetUniqueTempFile("concurrent_1m.vortex");
     auto stream_1m = vortex::testing::CreateTestData1MStream();
     auto write_options = vortex::ffi::write_options_new();
     vortex::ffi::write_array_stream(std::move(write_options),
@@ -473,7 +480,7 @@ TEST_F(VortexTest, ScanBuilderWithProjectionSingleColumn) {
 }
 
 TEST_F(VortexTest, OpenFromBuffer) {
-    std::string test_file_path = GetTestDataPath("test_buffer.vortex");
+    std::string test_file_path = GetUniqueTempFile("buffer.vortex");
     auto stream = vortex::testing::CreateTestDataStream();
     auto write_options = vortex::ffi::write_options_new();
     vortex::ffi::write_array_stream(std::move(write_options),
diff --git a/vortex-cxx/examples/CMakeLists.txt b/vortex-cxx/examples/CMakeLists.txt
index 40bb44dde71..348d80e1547 100644
--- a/vortex-cxx/examples/CMakeLists.txt
+++ b/vortex-cxx/examples/CMakeLists.txt
@@ -5,10 +5,9 @@ cmake_minimum_required(VERSION 3.22)
 
 project(vortex-examples)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-
 find_program(SCCACHE_PROGRAM sccache)
 if (SCCACHE_PROGRAM)
     set(CMAKE_C_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
@@ -32,6 +31,4 @@ if(APPLE)
     set(APPLE_LINK_FLAGS "-framework CoreFoundation -framework Security")
 endif()
 
-
 target_link_libraries(hello-vortex PRIVATE vortex ${APPLE_LINK_FLAGS})
-
diff --git a/vortex-cxx/src/read.rs b/vortex-cxx/src/read.rs
index b7db2c222dc..1ef4aec2734 100644
--- a/vortex-cxx/src/read.rs
+++ b/vortex-cxx/src/read.rs
@@ -19,8 +19,9 @@ use vortex::array::arrow::IntoArrowArray;
 use vortex::buffer::Buffer;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::io::runtime::BlockingRuntime;
-use vortex::scan::ScanBuilder;
-use vortex::scan::arrow::RecordBatchIteratorAdapter;
+use vortex::layout::scan::arrow::RecordBatchIteratorAdapter;
+use vortex::layout::scan::scan_builder::ScanBuilder;
+use vortex::scan::selection::Selection;
 
 use crate::RUNTIME;
 use crate::SESSION;
@@ -89,8 +90,7 @@ impl VortexScanBuilder {
     }
 
     pub(crate) fn with_include_by_index(&mut self, include_by_index: &[u64]) {
-        let selection =
-            vortex::scan::Selection::IncludeByIndex(Buffer::copy_from(include_by_index));
+        let selection = Selection::IncludeByIndex(Buffer::copy_from(include_by_index));
         take_mut::take(&mut self.inner, |inner| inner.with_selection(selection));
     }
 
diff --git a/vortex-datafusion/examples/vortex_table.rs b/vortex-datafusion/examples/vortex_table.rs
index cbd138baa0a..2570fc47afd 100644
--- a/vortex-datafusion/examples/vortex_table.rs
+++ b/vortex-datafusion/examples/vortex_table.rs
@@ -58,7 +58,7 @@ async fn main() -> anyhow::Result<()> {
 
     session
         .write_options()
-        .write(&mut f, st.to_array_stream())
+        .write(&mut f, st.into_array().to_array_stream())
         .await?;
 
     // [register]
diff --git a/vortex-datafusion/public-api.lock b/vortex-datafusion/public-api.lock
index 0dd1d1d14b6..c51d60ac700 100644
--- a/vortex-datafusion/public-api.lock
+++ b/vortex-datafusion/public-api.lock
@@ -18,13 +18,37 @@ pub type vortex_datafusion::metrics::VortexMetricsFinder::Error = core::convert:
 
 pub fn vortex_datafusion::metrics::VortexMetricsFinder::pre_visit(&mut self, plan: &dyn datafusion_physical_plan::execution_plan::ExecutionPlan) -> core::result::Result<bool, Self::Error>
 
+pub mod vortex_datafusion::reader
+
+pub struct vortex_datafusion::reader::DefaultVortexReaderFactory
+
+impl vortex_datafusion::reader::DefaultVortexReaderFactory
+
+pub fn vortex_datafusion::reader::DefaultVortexReaderFactory::new(object_store: alloc::sync::Arc<dyn object_store::ObjectStore>) -> Self
+
+impl core::fmt::Debug for vortex_datafusion::reader::DefaultVortexReaderFactory
+
+pub fn vortex_datafusion::reader::DefaultVortexReaderFactory::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_datafusion::reader::VortexReaderFactory for vortex_datafusion::reader::DefaultVortexReaderFactory
+
+pub fn vortex_datafusion::reader::DefaultVortexReaderFactory::create_reader(&self, file: &datafusion_datasource::PartitionedFile, session: &vortex_session::VortexSession) -> datafusion_common::error::Result<alloc::sync::Arc<dyn vortex_io::read_at::VortexReadAt>>
+
+pub trait vortex_datafusion::reader::VortexReaderFactory: core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static
+
+pub fn vortex_datafusion::reader::VortexReaderFactory::create_reader(&self, file: &datafusion_datasource::PartitionedFile, session: &vortex_session::VortexSession) -> datafusion_common::error::Result<alloc::sync::Arc<dyn vortex_io::read_at::VortexReadAt>>
+
+impl vortex_datafusion::reader::VortexReaderFactory for vortex_datafusion::reader::DefaultVortexReaderFactory
+
+pub fn vortex_datafusion::reader::DefaultVortexReaderFactory::create_reader(&self, file: &datafusion_datasource::PartitionedFile, session: &vortex_session::VortexSession) -> datafusion_common::error::Result<alloc::sync::Arc<dyn vortex_io::read_at::VortexReadAt>>
+
 pub mod vortex_datafusion::v2
 
 pub struct vortex_datafusion::v2::VortexDataSource
 
 impl vortex_datafusion::v2::VortexDataSource
 
-pub fn vortex_datafusion::v2::VortexDataSource::builder(data_source: vortex_scan::api::DataSourceRef, session: vortex_session::VortexSession) -> vortex_datafusion::v2::source::VortexDataSourceBuilder
+pub fn vortex_datafusion::v2::VortexDataSource::builder(data_source: vortex_scan::DataSourceRef, session: vortex_session::VortexSession) -> vortex_datafusion::v2::source::VortexDataSourceBuilder
 
 impl core::clone::Clone for vortex_datafusion::v2::VortexDataSource
 
@@ -62,7 +86,7 @@ pub struct vortex_datafusion::v2::VortexTable
 
 impl vortex_datafusion::v2::VortexTable
 
-pub fn vortex_datafusion::v2::VortexTable::new(data_source: vortex_scan::api::DataSourceRef, session: vortex_session::VortexSession, arrow_schema: arrow_schema::schema::SchemaRef) -> Self
+pub fn vortex_datafusion::v2::VortexTable::new(data_source: vortex_scan::DataSourceRef, session: vortex_session::VortexSession, arrow_schema: arrow_schema::schema::SchemaRef) -> Self
 
 impl core::fmt::Debug for vortex_datafusion::v2::VortexTable
 
@@ -80,11 +104,27 @@ pub fn vortex_datafusion::v2::VortexTable::statistics(&self) -> core::option::Op
 
 pub fn vortex_datafusion::v2::VortexTable::table_type(&self) -> datafusion_expr::table_source::TableType
 
+pub struct vortex_datafusion::DefaultExpressionConvertor
+
+impl core::default::Default for vortex_datafusion::DefaultExpressionConvertor
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::default() -> vortex_datafusion::DefaultExpressionConvertor
+
+impl vortex_datafusion::ExpressionConvertor for vortex_datafusion::DefaultExpressionConvertor
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::can_be_pushed_down(&self, expr: &alloc::sync::Arc<dyn datafusion_physical_expr_common::physical_expr::PhysicalExpr>, schema: &arrow_schema::schema::Schema) -> bool
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::convert(&self, df: &dyn datafusion_physical_expr_common::physical_expr::PhysicalExpr) -> datafusion_common::error::Result<vortex_array::expr::expression::Expression>
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::no_pushdown_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::split_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema, output_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
+
 pub struct vortex_datafusion::VortexAccessPlan
 
 impl vortex_datafusion::VortexAccessPlan
 
-pub fn vortex_datafusion::VortexAccessPlan::apply_to_builder<A>(&self, scan_builder: vortex_scan::scan_builder::ScanBuilder<A>) -> vortex_scan::scan_builder::ScanBuilder<A> where A: 'static + core::marker::Send
+pub fn vortex_datafusion::VortexAccessPlan::apply_to_builder<A>(&self, scan_builder: vortex_layout::scan::scan_builder::ScanBuilder<A>) -> vortex_layout::scan::scan_builder::ScanBuilder<A> where A: 'static + core::marker::Send
 
 pub fn vortex_datafusion::VortexAccessPlan::selection(&self) -> core::option::Option<&vortex_scan::selection::Selection>
 
@@ -176,7 +216,7 @@ pub fn vortex_datafusion::VortexSource::with_projection_pushdown(self, enabled:
 
 pub fn vortex_datafusion::VortexSource::with_scan_concurrency(self, scan_concurrency: usize) -> Self
 
-pub fn vortex_datafusion::VortexSource::with_vortex_reader_factory(self, vortex_reader_factory: alloc::sync::Arc<dyn vortex_datafusion::persistent::reader::VortexReaderFactory>) -> Self
+pub fn vortex_datafusion::VortexSource::with_vortex_reader_factory(self, vortex_reader_factory: alloc::sync::Arc<dyn vortex_datafusion::reader::VortexReaderFactory>) -> Self
 
 impl core::clone::Clone for vortex_datafusion::VortexSource
 
@@ -216,6 +256,8 @@ pub vortex_datafusion::VortexTableOptions::projection_pushdown: bool
 
 pub vortex_datafusion::VortexTableOptions::scan_concurrency: core::option::Option<usize>
 
+pub vortex_datafusion::VortexTableOptions::target_file_size_mb: usize
+
 impl core::clone::Clone for vortex_datafusion::VortexTableOptions
 
 pub fn vortex_datafusion::VortexTableOptions::clone(&self) -> vortex_datafusion::VortexTableOptions
@@ -253,3 +295,13 @@ pub fn vortex_datafusion::ExpressionConvertor::convert(&self, expr: &dyn datafus
 pub fn vortex_datafusion::ExpressionConvertor::no_pushdown_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
 
 pub fn vortex_datafusion::ExpressionConvertor::split_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema, output_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
+
+impl vortex_datafusion::ExpressionConvertor for vortex_datafusion::DefaultExpressionConvertor
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::can_be_pushed_down(&self, expr: &alloc::sync::Arc<dyn datafusion_physical_expr_common::physical_expr::PhysicalExpr>, schema: &arrow_schema::schema::Schema) -> bool
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::convert(&self, df: &dyn datafusion_physical_expr_common::physical_expr::PhysicalExpr) -> datafusion_common::error::Result<vortex_array::expr::expression::Expression>
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::no_pushdown_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
+
+pub fn vortex_datafusion::DefaultExpressionConvertor::split_projection(&self, source_projection: datafusion_physical_expr::projection::ProjectionExprs, input_schema: &arrow_schema::schema::Schema, output_schema: &arrow_schema::schema::Schema) -> datafusion_common::error::Result<vortex_datafusion::convert::exprs::ProcessedProjection>
diff --git a/vortex-datafusion/src/convert/exprs.rs b/vortex-datafusion/src/convert/exprs.rs
index 9b634e02794..e5142b50ed1 100644
--- a/vortex-datafusion/src/convert/exprs.rs
+++ b/vortex-datafusion/src/convert/exprs.rs
@@ -28,10 +28,10 @@ use vortex::expr::get_item;
 use vortex::expr::is_null;
 use vortex::expr::list_contains;
 use vortex::expr::lit;
+use vortex::expr::nested_case_when;
 use vortex::expr::not;
 use vortex::expr::pack;
 use vortex::expr::root;
-use vortex::expr::zip_expr;
 use vortex::scalar::Scalar;
 use vortex::scalar_fn::ScalarFnVTableExt;
 use vortex::scalar_fn::fns::binary::Binary;
@@ -148,35 +148,38 @@ impl DefaultExpressionConvertor {
         ))
     }
 
+    /// Attempts to convert a DataFusion CaseExpr to a Vortex expression.
     fn try_convert_case_expr(&self, case_expr: &df_expr::CaseExpr) -> DFResult<Expression> {
-        let mut else_expr = if let Some(else_expr) = case_expr.else_expr() {
-            self.convert(else_expr.as_ref())?
-        } else {
+        let when_then_pairs = case_expr.when_then_expr();
+        if when_then_pairs.is_empty() {
             return Err(exec_datafusion_err!(
-                "CASE expression without ELSE is not supported for pushdown"
+                "CASE expression must have at least one WHEN clause"
             ));
-        };
-
-        if let Some(base_expr) = case_expr.expr() {
-            let base_expr = self.convert(base_expr.as_ref())?;
-            for (when_expr, then_expr) in case_expr.when_then_expr().iter().rev() {
-                let when_expr = self.convert(when_expr.as_ref())?;
-                let then_expr = self.convert(then_expr.as_ref())?;
-                else_expr = zip_expr(
-                    then_expr,
-                    else_expr,
-                    Binary.new_expr(Operator::Eq, [base_expr.clone(), when_expr]),
-                );
-            }
-        } else {
-            for (when_expr, then_expr) in case_expr.when_then_expr().iter().rev() {
-                let when_expr = self.convert(when_expr.as_ref())?;
-                let then_expr = self.convert(then_expr.as_ref())?;
-                else_expr = zip_expr(then_expr, else_expr, when_expr);
-            }
         }
 
-        Ok(else_expr)
+        let base_expr = case_expr
+            .expr()
+            .map(|expr| self.convert(expr.as_ref()))
+            .transpose()?;
+
+        let mut pairs = Vec::with_capacity(when_then_pairs.len());
+        for (when_expr, then_expr) in when_then_pairs {
+            let when_expr = self.convert(when_expr.as_ref())?;
+            let condition = if let Some(base_expr) = &base_expr {
+                Binary.new_expr(Operator::Eq, [base_expr.clone(), when_expr])
+            } else {
+                when_expr
+            };
+            let value = self.convert(then_expr.as_ref())?;
+            pairs.push((condition, value));
+        }
+
+        let else_value = case_expr
+            .else_expr()
+            .map(|e| self.convert(e.as_ref()))
+            .transpose()?;
+
+        Ok(nested_case_when(pairs, else_value))
     }
 }
 
@@ -389,7 +392,8 @@ fn try_operator_from_df(value: &DFOperator) -> DFResult<Operator> {
         | DFOperator::AtQuestion
         | DFOperator::Question
         | DFOperator::QuestionAnd
-        | DFOperator::QuestionPipe => {
+        | DFOperator::QuestionPipe
+        | DFOperator::Colon => {
             tracing::debug!(operator = %value, "Can't pushdown binary_operator operator");
             Err(exec_datafusion_err!(
                 "Unsupported datafusion operator {value}"
@@ -477,19 +481,31 @@ fn can_binary_be_pushed_down(binary: &df_expr::BinaryExpr, schema: &Schema) -> b
 }
 
 fn can_case_be_pushed_down(case_expr: &df_expr::CaseExpr, schema: &Schema) -> bool {
-    case_expr
-        .expr()
-        .is_none_or(|base_expr| can_be_pushed_down_impl(base_expr, schema))
-        && case_expr
-            .when_then_expr()
-            .iter()
-            .all(|(when_expr, then_expr)| {
-                can_be_pushed_down_impl(when_expr, schema)
-                    && can_be_pushed_down_impl(then_expr, schema)
-            })
-        && case_expr
-            .else_expr()
-            .is_some_and(|else_expr| can_be_pushed_down_impl(else_expr, schema))
+    if case_expr.when_then_expr().is_empty() {
+        return false;
+    }
+
+    if let Some(base_expr) = case_expr.expr()
+        && !can_be_pushed_down_impl(base_expr, schema)
+    {
+        return false;
+    }
+
+    for (when_expr, then_expr) in case_expr.when_then_expr() {
+        if !can_be_pushed_down_impl(when_expr, schema)
+            || !can_be_pushed_down_impl(then_expr, schema)
+        {
+            return false;
+        }
+    }
+
+    if let Some(else_expr) = case_expr.else_expr()
+        && !can_be_pushed_down_impl(else_expr, schema)
+    {
+        return false;
+    }
+
+    true
 }
 
 fn supported_data_types(dt: &DataType) -> bool {
@@ -735,16 +751,16 @@ mod tests {
             .unwrap();
 
         assert_snapshot!(result.display_tree().to_string(), @r#"
-        vortex.zip()
-        ├── if_true: vortex.literal("yes")
-        ├── if_false: vortex.literal("no")
-        └── mask: vortex.get_item(active)
-            └── input: vortex.root()
+        vortex.case_when(case_when(pairs=1, else=true))
+        ├── when_0: vortex.get_item(active)
+        │   └── input: vortex.root()
+        ├── then_0: vortex.literal("yes")
+        └── else: vortex.literal("no")
         "#);
     }
 
     #[test]
-    fn test_expr_from_df_case_when_without_else_not_pushable() {
+    fn test_expr_from_df_case_when_without_else_pushable() {
         let when_then_expr = vec![(
             Arc::new(df_expr::Column::new("active", 0)) as Arc<dyn PhysicalExpr>,
             Arc::new(df_expr::Literal::new(ScalarValue::Utf8(Some(
@@ -755,7 +771,7 @@ mod tests {
             as Arc<dyn PhysicalExpr>;
 
         let schema = Schema::new(vec![Field::new("active", DataType::Boolean, false)]);
-        assert!(!can_be_pushed_down_impl(&case_expr, &schema));
+        assert!(can_be_pushed_down_impl(&case_expr, &schema));
     }
 
     #[rstest]
@@ -944,4 +960,96 @@ mod tests {
 
         Ok(())
     }
+
+    /// Test that applying a CASE expression to an Arrow RecordBatch using DataFusion
+    /// matches the result of applying the converted Vortex expression.
+    #[test]
+    fn test_case_when_datafusion_vortex_equivalence() {
+        use datafusion::arrow::array::Int32Array;
+        use datafusion::arrow::array::RecordBatch;
+        use datafusion_physical_expr::expressions::CaseExpr;
+        use vortex::VortexSessionDefault;
+        use vortex::array::ArrayRef;
+        use vortex::array::Canonical;
+        use vortex::array::VortexSessionExecute as _;
+        use vortex::array::arrow::FromArrowArray;
+        use vortex::session::VortexSession;
+
+        // Create test data
+        let values = Arc::new(Int32Array::from(vec![1, 5, 10, 15, 20]));
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "value",
+            DataType::Int32,
+            false,
+        )]));
+        let batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+
+        // Build a DataFusion CASE expression:
+        // CASE WHEN value > 10 THEN 100 WHEN value > 5 THEN 50 ELSE 0 END
+        let col_value = Arc::new(df_expr::Column::new("value", 0)) as Arc<dyn PhysicalExpr>;
+        let lit_10 =
+            Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(10)))) as Arc<dyn PhysicalExpr>;
+        let lit_5 =
+            Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(5)))) as Arc<dyn PhysicalExpr>;
+        let lit_100 =
+            Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(100)))) as Arc<dyn PhysicalExpr>;
+        let lit_50 =
+            Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(50)))) as Arc<dyn PhysicalExpr>;
+        let lit_0 =
+            Arc::new(df_expr::Literal::new(ScalarValue::Int32(Some(0)))) as Arc<dyn PhysicalExpr>;
+
+        // WHEN value > 10 THEN 100
+        let when1 = Arc::new(df_expr::BinaryExpr::new(
+            Arc::clone(&col_value),
+            DFOperator::Gt,
+            lit_10,
+        )) as Arc<dyn PhysicalExpr>;
+        // WHEN value > 5 THEN 50
+        let when2 = Arc::new(df_expr::BinaryExpr::new(col_value, DFOperator::Gt, lit_5))
+            as Arc<dyn PhysicalExpr>;
+
+        let case_expr =
+            CaseExpr::try_new(None, vec![(when1, lit_100), (when2, lit_50)], Some(lit_0)).unwrap();
+
+        // Apply DataFusion expression
+        let df_result = case_expr.evaluate(&batch).unwrap();
+        let df_array = df_result.into_array(batch.num_rows()).unwrap();
+
+        // Convert to Vortex expression
+        let expr_convertor = DefaultExpressionConvertor::default();
+        let vortex_expr = expr_convertor.try_convert_case_expr(&case_expr).unwrap();
+
+        // Convert batch to Vortex array
+        let vortex_array: ArrayRef = ArrayRef::from_arrow(&batch, false).unwrap();
+
+        // Apply Vortex expression
+        let session = VortexSession::default();
+        let mut ctx = session.create_execution_ctx();
+        let vortex_result = vortex_array
+            .apply(&vortex_expr)
+            .unwrap()
+            .execute::<Canonical>(&mut ctx)
+            .unwrap();
+
+        // Convert back to Arrow for comparison
+        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();
+
+        // Compare results
+        // Expected: [0, 0, 50, 100, 100] for values [1, 5, 10, 15, 20]
+        // value=1: not > 10, not > 5 -> ELSE 0
+        // value=5: not > 10, not > 5 -> ELSE 0
+        // value=10: not > 10, > 5 -> 50
+        // value=15: > 10 -> 100
+        // value=20: > 10 -> 100
+        assert_eq!(df_as_arrow, vec![0, 0, 50, 100, 100]);
+        assert_eq!(vortex_as_arrow, df_as_arrow);
+    }
 }
diff --git a/vortex-datafusion/src/convert/scalars.rs b/vortex-datafusion/src/convert/scalars.rs
index c2a5d9d16c8..a9b9649fd59 100644
--- a/vortex-datafusion/src/convert/scalars.rs
+++ b/vortex-datafusion/src/convert/scalars.rs
@@ -160,6 +160,7 @@ impl TryToDataFusion<ScalarValue> for Scalar {
                     },
                 }
             }
+            DType::Variant(_) => vortex_bail!("Variant scalars aren't supported with DF"),
         })
     }
 }
diff --git a/vortex-datafusion/src/lib.rs b/vortex-datafusion/src/lib.rs
index 0e09886c07c..ce266fbacd1 100644
--- a/vortex-datafusion/src/lib.rs
+++ b/vortex-datafusion/src/lib.rs
@@ -107,7 +107,10 @@ mod common_tests {
                     factory.get_ext().to_uppercase(),
                     Arc::new(DefaultTableFactory::new()),
                 )
-                .with_object_store(&Url::try_from("file://").unwrap(), store.clone());
+                .with_object_store(
+                    &Url::try_from("file://").unwrap(),
+                    Arc::<InMemory>::clone(&store),
+                );
 
             if let Some(file_formats) = session_state_builder.file_formats() {
                 file_formats.push(factory as _);
@@ -125,7 +128,7 @@ mod common_tests {
             P: Into<object_store::path::Path>,
         {
             let array = ArrayRef::from_arrow(batch, false)?;
-            let mut write = ObjectStoreWrite::new(self.store.clone(), &path.into()).await?;
+            let mut write = ObjectStoreWrite::new(Arc::clone(&self.store), &path.into()).await?;
             VX_SESSION
                 .write_options()
                 .write(&mut write, array.to_array_stream())
diff --git a/vortex-datafusion/src/persistent/access_plan.rs b/vortex-datafusion/src/persistent/access_plan.rs
index 9cf4a5824d6..78f81d01b05 100644
--- a/vortex-datafusion/src/persistent/access_plan.rs
+++ b/vortex-datafusion/src/persistent/access_plan.rs
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use vortex::scan::ScanBuilder;
-use vortex::scan::Selection;
+use vortex::layout::scan::scan_builder::ScanBuilder;
+use vortex::scan::selection::Selection;
 
 /// Custom Vortex-specific information that can be provided by external indexes or other sources.
 ///
diff --git a/vortex-datafusion/src/persistent/format.rs b/vortex-datafusion/src/persistent/format.rs
index befbc94d07d..1c33063a4f8 100644
--- a/vortex-datafusion/src/persistent/format.rs
+++ b/vortex-datafusion/src/persistent/format.rs
@@ -32,6 +32,7 @@ use datafusion_datasource::file_scan_config::FileScanConfigBuilder;
 use datafusion_datasource::file_sink_config::FileSinkConfig;
 use datafusion_datasource::sink::DataSinkExec;
 use datafusion_datasource::source::DataSourceExec;
+use datafusion_execution::cache::cache_manager::CachedFileMetadataEntry;
 use datafusion_expr::dml::InsertOp;
 use datafusion_physical_expr::LexRequirement;
 use datafusion_physical_plan::ExecutionPlan;
@@ -44,6 +45,7 @@ use futures::stream;
 use object_store::ObjectMeta;
 use object_store::ObjectStore;
 use vortex::VortexSessionDefault;
+use vortex::array::memory::MemorySessionExt;
 use vortex::dtype::DType;
 use vortex::dtype::Nullability;
 use vortex::dtype::PType;
@@ -254,26 +256,30 @@ impl FileFormat for VortexFormat {
 
         let mut file_schemas = stream::iter(objects.iter().cloned())
             .map(|object| {
-                let store = store.clone();
+                let store = Arc::clone(store);
                 let session = self.session.clone();
                 let opts = self.opts.clone();
-                let cache = file_metadata_cache.clone();
+                let cache = Arc::clone(&file_metadata_cache);
 
                 SpawnedTask::spawn(async move {
-                    // Check if we have cached metadata for this file
-                    if let Some(cached) = cache.get(&object)
-                        && let Some(cached_vortex) =
-                            cached.as_any().downcast_ref::<CachedVortexMetadata>()
+                    // Check if we have entry metadata for this file
+                    if let Some(entry) = cache.get(&object.location)
+                        && entry.is_valid_for(&object)
+                        && let Some(cached_vortex) = entry
+                            .file_metadata
+                            .as_any()
+                            .downcast_ref::<CachedVortexMetadata>()
                     {
                         let inferred_schema = cached_vortex.footer().dtype().to_arrow_schema()?;
                         return VortexResult::Ok((object.location, inferred_schema));
                     }
 
-                    // Not cached or invalid - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new(
+                    // Not entry or invalid - open the file
+                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
                         store,
                         object.location.clone(),
                         session.handle(),
+                        session.allocator(),
                     ));
 
                     let vxf = session
@@ -285,7 +291,8 @@ impl FileFormat for VortexFormat {
 
                     // Cache the metadata
                     let cached_metadata = Arc::new(CachedVortexMetadata::new(&vxf));
-                    cache.put(&object, cached_metadata);
+                    let entry = CachedFileMetadataEntry::new(object.clone(), cached_metadata);
+                    cache.put(&object.location, entry);
 
                     let inferred_schema = vxf.dtype().to_arrow_schema()?;
                     VortexResult::Ok((object.location, inferred_schema))
@@ -313,34 +320,39 @@ impl FileFormat for VortexFormat {
         object: &ObjectMeta,
     ) -> DFResult<Statistics> {
         let object = object.clone();
-        let store = store.clone();
+        let store = Arc::clone(store);
         let session = self.session.clone();
         let opts = self.opts.clone();
         let file_metadata_cache = state.runtime_env().cache_manager.get_file_metadata_cache();
 
         SpawnedTask::spawn(async move {
-            // Try to get cached metadata first
-            let cached_metadata = file_metadata_cache.get(&object).and_then(|cached| {
-                cached
-                    .as_any()
-                    .downcast_ref::<CachedVortexMetadata>()
-                    .map(|m| {
-                        (
-                            m.footer().dtype().clone(),
-                            m.footer().statistics().cloned(),
-                            m.footer().row_count(),
-                        )
-                    })
-            });
+            // Try to get entry metadata first
+            let cached_metadata = file_metadata_cache
+                .get(&object.location)
+                .filter(|entry| entry.is_valid_for(&object))
+                .and_then(|entry| {
+                    entry
+                        .file_metadata
+                        .as_any()
+                        .downcast_ref::<CachedVortexMetadata>()
+                        .map(|m| {
+                            (
+                                m.footer().dtype().clone(),
+                                m.footer().statistics().cloned(),
+                                m.footer().row_count(),
+                            )
+                        })
+                });
 
             let (dtype, file_stats, row_count) = match cached_metadata {
                 Some(metadata) => metadata,
                 None => {
-                    // Not cached - open the file
-                    let reader = Arc::new(ObjectStoreReadAt::new(
+                    // Not entry - open the file
+                    let reader = Arc::new(ObjectStoreReadAt::new_with_allocator(
                         store,
                         object.location.clone(),
                         session.handle(),
+                        session.allocator(),
                     ));
 
                     let vxf = session
@@ -357,8 +369,9 @@ impl FileFormat for VortexFormat {
                         })?;
 
                     // Cache the metadata
-                    let cached = Arc::new(CachedVortexMetadata::new(&vxf));
-                    file_metadata_cache.put(&object, cached);
+                    let file_metadata = Arc::new(CachedVortexMetadata::new(&vxf));
+                    let entry = CachedFileMetadataEntry::new(object.clone(), file_metadata);
+                    file_metadata_cache.put(&object.location, entry);
 
                     (
                         vxf.dtype().clone(),
@@ -544,7 +557,7 @@ impl FileFormat for VortexFormat {
             input
         };
 
-        let schema = conf.output_schema().clone();
+        let schema = Arc::clone(conf.output_schema());
         let sink = Arc::new(VortexSink::new(
             conf,
             schema,
diff --git a/vortex-datafusion/src/persistent/mod.rs b/vortex-datafusion/src/persistent/mod.rs
index 29488d4f7dd..c8560cfb7a8 100644
--- a/vortex-datafusion/src/persistent/mod.rs
+++ b/vortex-datafusion/src/persistent/mod.rs
@@ -7,7 +7,7 @@ mod cache;
 mod format;
 pub mod metrics;
 mod opener;
-mod reader;
+pub mod reader;
 mod sink;
 mod source;
 mod stream;
@@ -21,6 +21,8 @@ pub use source::VortexSource;
 #[cfg(test)]
 mod tests {
 
+    use std::sync::Arc;
+
     use datafusion::arrow::util::pretty::pretty_format_batches;
     use datafusion_physical_plan::display::DisplayableExecutionPlan;
     use insta::assert_snapshot;
@@ -65,11 +67,12 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let mut writer = ObjectStoreWrite::new(ctx.store.clone(), &"test.vortex".into()).await?;
+        let mut writer =
+            ObjectStoreWrite::new(Arc::clone(&ctx.store), &"test.vortex".into()).await?;
 
         let summary = session
             .write_options()
-            .write(&mut writer, st.to_array_stream())
+            .write(&mut writer, st.into_array().to_array_stream())
             .await?;
 
         writer.shutdown().await?;
diff --git a/vortex-datafusion/src/persistent/opener.rs b/vortex-datafusion/src/persistent/opener.rs
index aa22afd39b0..db3cc475d75 100644
--- a/vortex-datafusion/src/persistent/opener.rs
+++ b/vortex-datafusion/src/persistent/opener.rs
@@ -39,9 +39,9 @@ use vortex::error::VortexError;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::io::InstrumentedReadAt;
 use vortex::layout::LayoutReader;
+use vortex::layout::scan::scan_builder::ScanBuilder;
 use vortex::metrics::Label;
 use vortex::metrics::MetricsRegistry;
-use vortex::scan::ScanBuilder;
 use vortex::session::VortexSession;
 use vortex_utils::aliases::dash_map::DashMap;
 use vortex_utils::aliases::dash_map::Entry;
@@ -101,7 +101,7 @@ pub(crate) struct VortexOpener {
 impl FileOpener for VortexOpener {
     fn open(&self, file: PartitionedFile) -> DFResult<FileOpenFuture> {
         let session = self.session.clone();
-        let metrics_registry = self.metrics_registry.clone();
+        let metrics_registry = Arc::clone(&self.metrics_registry);
         let labels = vec![
             Label::new(PATH_LABEL, file.path().to_string()),
             Label::new(PARTITION_LABEL, self.partition.to_string()),
@@ -110,25 +110,23 @@ impl FileOpener for VortexOpener {
         let mut projection = self.projection.clone();
         let mut filter = self.filter.clone();
 
-        let reader = self
-            .vortex_reader_factory
-            .create_reader(file.path().as_ref(), &session)?;
+        let reader = self.vortex_reader_factory.create_reader(&file, &session)?;
 
         let reader =
             InstrumentedReadAt::new_with_labels(reader, metrics_registry.as_ref(), labels.clone());
 
         let file_pruning_predicate = self.file_pruning_predicate.clone();
-        let expr_adapter_factory = self.expr_adapter_factory.clone();
+        let expr_adapter_factory = Arc::clone(&self.expr_adapter_factory);
         let file_metadata_cache = self.file_metadata_cache.clone();
 
-        let unified_file_schema = self.table_schema.file_schema().clone();
+        let unified_file_schema = Arc::clone(self.table_schema.file_schema());
         let batch_size = self.batch_size;
         let limit = self.limit;
-        let layout_reader = self.layout_readers.clone();
+        let layout_reader = Arc::clone(&self.layout_readers);
         let has_output_ordering = self.has_output_ordering;
         let scan_concurrency = self.scan_concurrency;
 
-        let expr_convertor = self.expression_convertor.clone();
+        let expr_convertor = Arc::clone(&self.expression_convertor);
         let projection_pushdown = self.projection_pushdown;
 
         // Replace column access for partition columns with literals
@@ -165,7 +163,7 @@ impl FileOpener for VortexOpener {
                 })
                 .and_then(|predicate| {
                     FilePruner::try_new(
-                        predicate.clone(),
+                        Arc::clone(&predicate),
                         &unified_file_schema,
                         &file,
                         Count::default(),
@@ -183,12 +181,14 @@ impl FileOpener for VortexOpener {
             let mut open_opts = session
                 .open_options()
                 .with_file_size(file.object_meta.size)
-                .with_metrics_registry(metrics_registry.clone())
+                .with_metrics_registry(Arc::clone(&metrics_registry))
                 .with_labels(labels);
 
             if let Some(file_metadata_cache) = file_metadata_cache
-                && let Some(file_metadata) = file_metadata_cache.get(&file.object_meta)
-                && let Some(vortex_metadata) = file_metadata
+                && 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>()
             {
@@ -200,6 +200,12 @@ impl FileOpener for VortexOpener {
                 .await
                 .map_err(|e| exec_datafusion_err!("Failed to open Vortex file {e}"))?;
 
+            // 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 {
+                return Ok(stream::empty().boxed());
+            }
+
             // This is the expected arrow types of the actual columns in the file, which might have different types
             // from the unified logical schema or miss
             let this_file_schema = Arc::new(calculate_physical_schema(
@@ -212,7 +218,7 @@ impl FileOpener for VortexOpener {
             let expr_adapter = expr_adapter_factory.create(
                 Arc::clone(&unified_file_schema),
                 Arc::clone(&this_file_schema),
-            );
+            )?;
 
             let simplifier = PhysicalExprSimplifier::new(&this_file_schema);
 
@@ -432,6 +438,8 @@ fn apply_byte_range(
 }
 
 fn byte_range_to_row_range(byte_range: Range<u64>, row_count: u64, total_size: u64) -> Range<u64> {
+    debug_assert!(row_count > 0); // Asserted by an early exit check in VortexOpener::open
+
     let average_row = total_size / row_count;
     assert!(average_row > 0, "A row must always have at least one byte");
 
@@ -474,13 +482,14 @@ mod tests {
     use object_store::memory::InMemory;
     use rstest::rstest;
     use vortex::VortexSessionDefault;
+    use vortex::array::ArrayRef;
     use vortex::array::arrow::FromArrowArray;
     use vortex::buffer::Buffer;
     use vortex::file::WriteOptionsSessionExt;
     use vortex::io::VortexWrite;
     use vortex::io::object_store::ObjectStoreWrite;
     use vortex::metrics::DefaultMetricsRegistry;
-    use vortex::scan::Selection;
+    use vortex::scan::selection::Selection;
     use vortex::session::VortexSession;
 
     use super::*;
@@ -582,14 +591,14 @@ mod tests {
         let file_path = "part=1/file.vortex";
         let batch = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let file_schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
         file.partition_values = vec![ScalarValue::Int32(Some(1))];
 
         let table_schema = TableSchema::new(
-            file_schema.clone(),
+            Arc::clone(&file_schema),
             vec![Arc::new(Field::new("part", DataType::Int32, false))],
         );
 
@@ -597,7 +606,11 @@ mod tests {
         let filter = col("part").eq(lit(1));
         let filter = logical2physical(&filter, table_schema.table_schema());
 
-        let opener = make_opener(object_store.clone(), table_schema.clone(), Some(filter));
+        let opener = make_opener(
+            Arc::clone(&object_store),
+            table_schema.clone(),
+            Some(filter),
+        );
         let stream = opener.open(file.clone()).unwrap().await.unwrap();
 
         let data = stream.try_collect::<Vec<_>>().await?;
@@ -610,7 +623,11 @@ mod tests {
         let filter = col("part").eq(lit(2));
         let filter = logical2physical(&filter, table_schema.table_schema());
 
-        let opener = make_opener(object_store.clone(), table_schema.clone(), Some(filter));
+        let opener = make_opener(
+            Arc::clone(&object_store),
+            table_schema.clone(),
+            Some(filter),
+        );
         let stream = opener.open(file.clone()).unwrap().await.unwrap();
 
         let data = stream.try_collect::<Vec<_>>().await?;
@@ -621,6 +638,33 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn test_open_empty_file() -> anyhow::Result<()> {
+        use futures::TryStreamExt;
+
+        let object_store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
+        let data_batch = record_batch!(("a", Int32, Vec::<i32>::new())).unwrap();
+        let file_path = "part=1/empty.vortex";
+        let file_size =
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, data_batch.clone()).await?;
+
+        let file_schema = data_batch.schema();
+        // Parallel scans may attach a byte range even for empty files; the
+        // opener must not call byte_range_to_row_range when the row_count is 0.
+        let file =
+            PartitionedFile::new_with_range(file_path.to_string(), file_size, 0, file_size as i64);
+
+        let table_schema = TableSchema::from_file_schema(Arc::clone(&file_schema));
+
+        let opener = make_opener(object_store, table_schema, None);
+        let stream = opener.open(file)?.await?;
+        let data = stream.try_collect::<Vec<_>>().await?;
+
+        assert_eq!(data.len(), 0);
+
+        Ok(())
+    }
+
     #[rstest]
     #[tokio::test]
     async fn test_open_files_different_table_schema() -> anyhow::Result<()> {
@@ -630,7 +674,7 @@ mod tests {
             let file1_path = "/path/file1.vortex";
             let batch1 = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap();
             let data_size1 =
-                write_arrow_to_vortex(object_store.clone(), file1_path, batch1).await?;
+                write_arrow_to_vortex(Arc::clone(&object_store), file1_path, batch1).await?;
             PartitionedFile::new(file1_path.to_string(), data_size1)
         };
 
@@ -638,7 +682,7 @@ mod tests {
             let file2_path = "/path/file2.vortex";
             let batch2 = record_batch!(("a", Int16, vec![Some(-1), Some(-2), Some(-3)])).unwrap();
             let data_size2 =
-                write_arrow_to_vortex(object_store.clone(), file2_path, batch2).await?;
+                write_arrow_to_vortex(Arc::clone(&object_store), file2_path, batch2).await?;
             PartitionedFile::new(file2_path.to_string(), data_size2)
         };
 
@@ -652,7 +696,9 @@ mod tests {
         let make_opener = |filter| VortexOpener {
             partition: 1,
             session: SESSION.clone(),
-            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
+            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone(
+                &object_store,
+            ))),
             projection: ProjectionExprs::from_indices(&[0], table_schema.file_schema()),
             filter: Some(filter),
             file_pruning_predicate: None,
@@ -672,7 +718,7 @@ mod tests {
         let filter = col("a").lt(lit(100_i32));
         let filter = logical2physical(&filter, table_schema.table_schema());
 
-        let opener1 = make_opener(filter.clone());
+        let opener1 = make_opener(Arc::clone(&filter));
         let stream = opener1.open(file1)?.await?;
 
         let format_opts = FormatOptions::new().with_types_info(true);
@@ -689,7 +735,7 @@ mod tests {
         +-------+
         ");
 
-        let opener2 = make_opener(filter.clone());
+        let opener2 = make_opener(Arc::clone(&filter));
         let stream = opener2.open(file2)?.await?;
 
         let data = stream.try_collect::<Vec<_>>().await?;
@@ -725,7 +771,7 @@ mod tests {
             ("a", Int32, vec![Some(100), Some(101), Some(102)])
         )
         .unwrap();
-        let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?;
+        let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?;
         let file = PartitionedFile::new(file_path.to_string(), data_size);
 
         // Table schema has columns in different order: a, b, c
@@ -743,7 +789,7 @@ mod tests {
             filter: None,
             file_pruning_predicate: None,
             expr_adapter_factory: Arc::new(DefaultPhysicalExprAdapterFactory),
-            table_schema: TableSchema::from_file_schema(table_schema.clone()),
+            table_schema: TableSchema::from_file_schema(Arc::clone(&table_schema)),
             batch_size: 100,
             limit: None,
             metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
@@ -803,7 +849,7 @@ mod tests {
             )])),
             vec![Arc::new(struct_array)],
         )?;
-        let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?;
+        let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?;
 
         // Table schema has an extra utf8 field.
         let table_schema = TableSchema::from_file_schema(Arc::new(Schema::new(vec![Field::new(
@@ -825,7 +871,7 @@ mod tests {
         )])));
 
         let opener = make_opener(
-            object_store.clone(),
+            Arc::clone(&object_store),
             table_schema.clone(),
             // expression references my_struct column which has different fields in each
             // field.
@@ -864,7 +910,7 @@ mod tests {
             ("c", Int32, vec![Some(2)])
         )
         .unwrap();
-        let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?;
+        let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?;
 
         // Table schema has columns in DIFFERENT order: c, a, b
         // and different types that require casting (Utf8 -> Dictionary)
@@ -889,7 +935,9 @@ mod tests {
         let opener = VortexOpener {
             partition: 1,
             session: SESSION.clone(),
-            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
+            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone(
+                &object_store,
+            ))),
             projection: ProjectionExprs::from_indices(
                 projection.as_ref(),
                 table_schema.file_schema(),
@@ -974,14 +1022,14 @@ mod tests {
     async fn test_selection_include_by_index() -> anyhow::Result<()> {
         use datafusion::arrow::util::pretty::pretty_format_batches_with_options;
         use vortex::buffer::Buffer;
-        use vortex::scan::Selection;
+        use vortex::scan::selection::Selection;
 
         let object_store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
         let file_path = "/path/file.vortex";
 
         let batch = make_test_batch_with_10_rows();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
@@ -990,8 +1038,8 @@ mod tests {
         )));
 
         let opener = make_test_opener(
-            object_store.clone(),
-            schema.clone(),
+            Arc::clone(&object_store),
+            Arc::clone(&schema),
             ProjectionExprs::from_indices(&[0, 1], &schema),
         );
 
@@ -1022,7 +1070,7 @@ mod tests {
 
         let batch = make_test_batch_with_10_rows();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
@@ -1031,8 +1079,8 @@ mod tests {
         )));
 
         let opener = make_test_opener(
-            object_store.clone(),
-            schema.clone(),
+            Arc::clone(&object_store),
+            Arc::clone(&schema),
             ProjectionExprs::from_indices(&[0, 1], &schema),
         );
 
@@ -1059,14 +1107,14 @@ mod tests {
     #[tokio::test]
     // Test that Selection::All returns all rows.
     async fn test_selection_all() -> anyhow::Result<()> {
-        use vortex::scan::Selection;
+        use vortex::scan::selection::Selection;
 
         let object_store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
         let file_path = "/path/file.vortex";
 
         let batch = make_test_batch_with_10_rows();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
@@ -1075,8 +1123,8 @@ mod tests {
         ));
 
         let opener = make_test_opener(
-            object_store.clone(),
-            schema.clone(),
+            Arc::clone(&object_store),
+            Arc::clone(&schema),
             ProjectionExprs::from_indices(&[0], &schema),
         );
 
@@ -1097,15 +1145,15 @@ mod tests {
 
         let batch = make_test_batch_with_10_rows();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let schema = batch.schema();
         let file = PartitionedFile::new(file_path.to_string(), data_size);
         // file.extensions is None by default
 
         let opener = make_test_opener(
-            object_store.clone(),
-            schema.clone(),
+            Arc::clone(&object_store),
+            Arc::clone(&schema),
             ProjectionExprs::from_indices(&[0], &schema),
         );
 
@@ -1129,10 +1177,10 @@ mod tests {
         )
         .unwrap();
         let data_size =
-            write_arrow_to_vortex(object_store.clone(), file_path, batch.clone()).await?;
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
 
         let file_schema = batch.schema();
-        let table_schema = TableSchema::from_file_schema(file_schema.clone());
+        let table_schema = TableSchema::from_file_schema(Arc::clone(&file_schema));
 
         // Create a projection that includes an arithmetic expression: a + b * 2
         let col_a = df_expr::col("a", &file_schema)?;
@@ -1152,7 +1200,9 @@ mod tests {
         let opener = VortexOpener {
             partition: 1,
             session: SESSION.clone(),
-            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
+            vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(Arc::clone(
+                &object_store,
+            ))),
             projection,
             filter: None,
             file_pruning_predicate: None,
@@ -1215,14 +1265,14 @@ mod tests {
             DataType::Struct(struct_fields.clone()),
             false,
         )]));
-        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(struct_array)])?;
+        let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(struct_array)])?;
 
         let file_path = "/test.vortex";
-        let data_size = write_arrow_to_vortex(object_store.clone(), file_path, batch).await?;
+        let data_size = write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch).await?;
 
         let opener = make_test_opener(
-            object_store.clone(),
-            schema.clone(),
+            Arc::clone(&object_store),
+            Arc::clone(&schema),
             ProjectionExprs::from_indices(&[0], &schema),
         );
         let data: Vec<_> = opener
diff --git a/vortex-datafusion/src/persistent/reader.rs b/vortex-datafusion/src/persistent/reader.rs
index a6f40314ba3..34ff646722c 100644
--- a/vortex-datafusion/src/persistent/reader.rs
+++ b/vortex-datafusion/src/persistent/reader.rs
@@ -1,11 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Factory for creating [`VortexReadAt`][vortex::io::VortexReadAt] instances
+//! from [`PartitionedFile`]s.
+
 use std::fmt::Debug;
 use std::sync::Arc;
 
 use datafusion_common::Result as DFResult;
+use datafusion_datasource::PartitionedFile;
 use object_store::ObjectStore;
+use vortex::array::memory::MemorySessionExt;
 use vortex::io::VortexReadAt;
 use vortex::io::object_store::ObjectStoreReadAt;
 use vortex::io::session::RuntimeSessionExt;
@@ -14,8 +19,11 @@ use vortex::session::VortexSession;
 /// Factory to create [`VortexReadAt`] instances to read the target file.
 pub trait VortexReaderFactory: Debug + Send + Sync + 'static {
     /// Create a reader for a target object.
-    fn create_reader(&self, path: &str, session: &VortexSession)
-    -> DFResult<Arc<dyn VortexReadAt>>;
+    fn create_reader(
+        &self,
+        file: &PartitionedFile,
+        session: &VortexSession,
+    ) -> DFResult<Arc<dyn VortexReadAt>>;
 }
 
 /// Default factory, creates [`ObjectStore`] backed readers for files,
@@ -35,13 +43,14 @@ impl DefaultVortexReaderFactory {
 impl VortexReaderFactory for DefaultVortexReaderFactory {
     fn create_reader(
         &self,
-        path: &str,
+        file: &PartitionedFile,
         session: &VortexSession,
     ) -> DFResult<Arc<dyn VortexReadAt>> {
-        Ok(Arc::new(ObjectStoreReadAt::new(
-            self.object_store.clone(),
-            path.into(),
+        Ok(Arc::new(ObjectStoreReadAt::new_with_allocator(
+            Arc::clone(&self.object_store),
+            file.path().as_ref().into(),
             session.handle(),
+            session.allocator(),
         )) as _)
     }
 }
diff --git a/vortex-datafusion/src/persistent/sink.rs b/vortex-datafusion/src/persistent/sink.rs
index c418247e026..9ee9d4621b9 100644
--- a/vortex-datafusion/src/persistent/sink.rs
+++ b/vortex-datafusion/src/persistent/sink.rs
@@ -23,6 +23,7 @@ use datafusion_physical_plan::metrics::MetricsSet;
 use futures::SinkExt;
 use futures::StreamExt;
 use object_store::ObjectStore;
+use object_store::ObjectStoreExt;
 use object_store::path::Path;
 use tokio::task::JoinHandle;
 use uuid::Uuid;
@@ -261,7 +262,7 @@ async fn write_record_batch_stream_to_files(
                 );
                 active_writer = Some(start_file_writer(
                     &session,
-                    object_store.clone(),
+                    Arc::clone(&object_store),
                     file_path,
                     dtype.clone(),
                 ));
@@ -602,7 +603,7 @@ mod tests {
         let logical_plan = LogicalPlanBuilder::insert_into(
             LogicalPlan::Values(values.clone()),
             "my_tbl",
-            Arc::new(DefaultTableSource::new(tbl_provider.clone())),
+            Arc::new(DefaultTableSource::new(Arc::clone(&tbl_provider))),
             datafusion::logical_expr::dml::InsertOp::Append,
         )?
         .build()?;
@@ -1000,12 +1001,12 @@ mod tests {
         for i in 0..num_batches {
             let values = pseudo_random_i64s(batch_rows, (i * batch_rows) as i64);
             batches.push(RecordBatch::try_new(
-                schema.clone(),
+                Arc::clone(&schema),
                 vec![Arc::new(Int64Array::from(values))],
             )?);
         }
 
-        let table = MemTable::try_new(schema.clone(), vec![batches])?;
+        let table = MemTable::try_new(Arc::clone(&schema), vec![batches])?;
         ctx.session.register_table("source", Arc::new(table))?;
 
         let source = ctx.session.table("source").await?;
@@ -1108,12 +1109,12 @@ mod tests {
                 .map(|j| ((i * batch_rows + j) % 256) as i64)
                 .collect();
             batches.push(RecordBatch::try_new(
-                schema.clone(),
+                Arc::clone(&schema),
                 vec![Arc::new(Int64Array::from(values))],
             )?);
         }
 
-        let table = MemTable::try_new(schema.clone(), vec![batches])?;
+        let table = MemTable::try_new(Arc::clone(&schema), vec![batches])?;
         ctx.session.register_table("source", Arc::new(table))?;
 
         let source = ctx.session.table("source").await?;
@@ -1198,7 +1199,7 @@ mod tests {
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
             partitions.push(vec![RecordBatch::try_new(
-                schema.clone(),
+                Arc::clone(&schema),
                 vec![Arc::new(Int64Array::from(values))],
             )?]);
         }
@@ -1301,7 +1302,7 @@ mod tests {
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
             partitions.push(vec![RecordBatch::try_new(
-                schema.clone(),
+                Arc::clone(&schema),
                 vec![Arc::new(Int64Array::from(values))],
             )?]);
         }
@@ -1402,7 +1403,7 @@ mod tests {
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
             partitions.push(vec![RecordBatch::try_new(
-                schema.clone(),
+                Arc::clone(&schema),
                 vec![Arc::new(Int64Array::from(values))],
             )?]);
         }
@@ -1513,11 +1514,13 @@ mod tests {
         let mut partitions: Vec<Arc<dyn PartitionStream>> = Vec::new();
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
-            let batch =
-                RecordBatch::try_new(schema.clone(), vec![Arc::new(Int64Array::from(values))])?;
+            let batch = RecordBatch::try_new(
+                Arc::clone(&schema),
+                vec![Arc::new(Int64Array::from(values))],
+            )?;
 
             partitions.push(Arc::new(StaticPartitionStream {
-                schema: schema.clone(),
+                schema: Arc::clone(&schema),
                 batch,
             }));
         }
@@ -1630,11 +1633,13 @@ mod tests {
         let mut partitions: Vec<Arc<dyn PartitionStream>> = Vec::new();
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
-            let batch =
-                RecordBatch::try_new(schema.clone(), vec![Arc::new(Int64Array::from(values))])?;
+            let batch = RecordBatch::try_new(
+                Arc::clone(&schema),
+                vec![Arc::new(Int64Array::from(values))],
+            )?;
 
             partitions.push(Arc::new(StaticPartitionStream {
-                schema: schema.clone(),
+                schema: Arc::clone(&schema),
                 batch,
             }));
         }
@@ -1751,11 +1756,13 @@ mod tests {
         let mut partitions: Vec<Arc<dyn PartitionStream>> = Vec::new();
         for p in 0..num_partitions {
             let values = pseudo_random_i64s(rows_per_partition, (p * rows_per_partition) as i64);
-            let batch =
-                RecordBatch::try_new(schema.clone(), vec![Arc::new(Int64Array::from(values))])?;
+            let batch = RecordBatch::try_new(
+                Arc::clone(&schema),
+                vec![Arc::new(Int64Array::from(values))],
+            )?;
 
             partitions.push(Arc::new(StaticPartitionStream {
-                schema: schema.clone(),
+                schema: Arc::clone(&schema),
                 batch,
             }));
         }
diff --git a/vortex-datafusion/src/persistent/source.rs b/vortex-datafusion/src/persistent/source.rs
index bac7fe2b39a..537e6162d0b 100644
--- a/vortex-datafusion/src/persistent/source.rs
+++ b/vortex-datafusion/src/persistent/source.rs
@@ -186,8 +186,8 @@ impl FileSource for VortexSource {
             table_schema: self.table_schema.clone(),
             batch_size,
             limit: base_config.limit.map(|l| l as u64),
-            metrics_registry: self.vx_metrics_registry.clone(),
-            layout_readers: self.layout_readers.clone(),
+            metrics_registry: Arc::clone(&self.vx_metrics_registry),
+            layout_readers: Arc::clone(&self.layout_readers),
             has_output_ordering: !base_config.output_ordering.is_empty(),
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
             file_metadata_cache: self.file_metadata_cache.clone(),
diff --git a/vortex-datafusion/src/tests/schema_evolution.rs b/vortex-datafusion/src/tests/schema_evolution.rs
index 02254ef6afd..093fed6c148 100644
--- a/vortex-datafusion/src/tests/schema_evolution.rs
+++ b/vortex-datafusion/src/tests/schema_evolution.rs
@@ -236,7 +236,7 @@ async fn test_filter_schema_evolution_struct_fields(
     let read_schema = host02.schema();
 
     let provider = ctx
-        .table_provider("tbl", "/files/", read_schema.clone())
+        .table_provider("tbl", "/files/", Arc::clone(&read_schema))
         .await?;
 
     let table = ctx.session.read_table(provider)?;
@@ -359,7 +359,7 @@ async fn test_schema_evolution_struct_of_dict(
     let read_schema = batch.schema();
 
     let provider = ctx
-        .table_provider("tbl", "/files/", read_schema.clone())
+        .table_provider("tbl", "/files/", Arc::clone(&read_schema))
         .await?;
 
     let table = ctx.session.read_table(provider)?;
@@ -582,7 +582,7 @@ async fn test_dictionary_column_type_preservation(
     // Create table with explicit schema that expects Dictionary types
     let table_schema = batch.schema();
     let provider = ctx
-        .table_provider("tbl", "/files/", table_schema.clone())
+        .table_provider("tbl", "/files/", Arc::clone(&table_schema))
         .await?;
 
     let table = ctx.session.read_table(provider)?;
@@ -652,13 +652,15 @@ async fn test_nested_struct_dictionary_type_preservation(
     ]));
 
     let batch = RecordBatch::try_new(
-        schema.clone(),
+        Arc::clone(&schema),
         vec![Arc::new(labels_struct), value_array, producer_array],
     )?;
 
     ctx.write_arrow_batch("files/data.vortex", &batch).await?;
 
-    let provider = ctx.table_provider("tbl", "/files/", schema.clone()).await?;
+    let provider = ctx
+        .table_provider("tbl", "/files/", Arc::clone(&schema))
+        .await?;
     let table = ctx.session.read_table(provider)?;
 
     // Query that projects a nested struct field (like in polarsignals Q0)
@@ -740,7 +742,7 @@ async fn test_polarsignals_like_schema(
     ]));
 
     let batch = RecordBatch::try_new(
-        schema.clone(),
+        Arc::clone(&schema),
         vec![
             Arc::new(labels_struct),
             value_array,
@@ -754,7 +756,9 @@ async fn test_polarsignals_like_schema(
 
     ctx.write_arrow_batch("files/data.vortex", &batch).await?;
 
-    let provider = ctx.table_provider("tbl", "/files/", schema.clone()).await?;
+    let provider = ctx
+        .table_provider("tbl", "/files/", Arc::clone(&schema))
+        .await?;
     let table = ctx.session.read_table(provider)?;
 
     // Query like polarsignals Q0: filter on multiple dictionary columns, project value and labels.comm
@@ -815,7 +819,7 @@ async fn test_external_table_dictionary_columns(
     ]));
 
     let batch = RecordBatch::try_new(
-        schema.clone(),
+        Arc::clone(&schema),
         vec![producer_array, sample_type_array, value_array],
     )?;
 
@@ -901,7 +905,7 @@ async fn test_sql_struct_field_dictionary_type(
     ]));
 
     let batch = RecordBatch::try_new(
-        schema.clone(),
+        Arc::clone(&schema),
         vec![
             Arc::new(labels_struct),
             value_array,
diff --git a/vortex-datafusion/src/v2/source.rs b/vortex-datafusion/src/v2/source.rs
index 53dd9939a16..b2530c445bb 100644
--- a/vortex-datafusion/src/v2/source.rs
+++ b/vortex-datafusion/src/v2/source.rs
@@ -53,8 +53,8 @@ use vortex::expr::root;
 use vortex::expr::stats::Precision;
 use vortex::expr::transform::replace;
 use vortex::io::session::RuntimeSessionExt;
-use vortex::scan::api::DataSourceRef;
-use vortex::scan::api::ScanRequest;
+use vortex::scan::DataSourceRef;
+use vortex::scan::ScanRequest;
 use vortex::session::VortexSession;
 
 use crate::convert::exprs::DefaultExpressionConvertor;
@@ -162,11 +162,11 @@ impl VortexDataSourceBuilder {
         Ok(VortexDataSource {
             data_source: self.data_source,
             session: self.session,
-            initial_schema: arrow_schema.clone(),
+            initial_schema: Arc::clone(&arrow_schema),
             initial_projection: projection.clone(),
             initial_statistics: statistics.clone(),
             projected_projection: projection.clone(),
-            projected_schema: arrow_schema.clone(),
+            projected_schema: Arc::clone(&arrow_schema),
             projected_statistics: statistics.clone(),
             leftover_projection: None,
             leftover_schema: arrow_schema,
@@ -285,8 +285,8 @@ impl DataSource for VortexDataSource {
             ..Default::default()
         };
 
-        let data_source = self.data_source.clone();
-        let projected_schema = self.projected_schema.clone();
+        let data_source = Arc::clone(&self.data_source);
+        let projected_schema = Arc::clone(&self.projected_schema);
         let session = self.session.clone();
         let num_partitions = self.num_partitions;
 
@@ -318,7 +318,7 @@ impl DataSource for VortexDataSource {
                 .try_flatten_unordered(Some(num_partitions.get() * 2))
                 .map(move |result| {
                     let session = session.clone();
-                    let schema = projected_schema.clone();
+                    let schema = Arc::clone(&projected_schema);
                     handle.spawn_cpu(move || {
                         let mut ctx = session.create_execution_ctx();
                         result.and_then(|chunk| chunk.execute_record_batch(&schema, &mut ctx))
@@ -343,7 +343,7 @@ impl DataSource for VortexDataSource {
         .try_flatten();
 
         Ok(Box::pin(RecordBatchStreamAdapter::new(
-            self.leftover_schema.clone(),
+            Arc::clone(&self.leftover_schema),
             stream,
         )))
     }
@@ -386,7 +386,7 @@ impl DataSource for VortexDataSource {
     }
 
     fn eq_properties(&self) -> EquivalenceProperties {
-        EquivalenceProperties::new(self.leftover_schema.clone())
+        EquivalenceProperties::new(Arc::clone(&self.leftover_schema))
     }
 
     fn partition_statistics(&self, _partition: Option<usize>) -> DFResult<Statistics> {
@@ -467,11 +467,11 @@ impl DataSource for VortexDataSource {
 
         let mut this = self.clone();
         this.projected_projection = scan_projection;
-        this.projected_schema = scan_output_schema.clone();
+        this.projected_schema = Arc::clone(&scan_output_schema);
         this.projected_statistics =
             vec![ColumnStatistics::new_unknown(); scan_output_schema.fields().len()];
         this.leftover_projection = Some(leftover_projection);
-        this.leftover_schema = final_schema.clone();
+        this.leftover_schema = Arc::clone(&final_schema);
         this.leftover_statistics =
             vec![ColumnStatistics::new_unknown(); final_schema.fields().len()];
 
@@ -517,7 +517,7 @@ impl DataSource for VortexDataSource {
             .iter()
             .zip(pushdown_results.iter())
             .filter_map(|(expr, pushed)| match pushed {
-                PushedDown::Yes => Some(expr.clone()),
+                PushedDown::Yes => Some(Arc::clone(expr)),
                 PushedDown::No => None,
             })
             .collect();
diff --git a/vortex-datafusion/src/v2/table.rs b/vortex-datafusion/src/v2/table.rs
index 5583a6fa270..05edc0f27d8 100644
--- a/vortex-datafusion/src/v2/table.rs
+++ b/vortex-datafusion/src/v2/table.rs
@@ -21,7 +21,7 @@ use datafusion_datasource::source::DataSourceExec;
 use datafusion_expr::Expr;
 use datafusion_expr::TableType;
 use datafusion_physical_plan::ExecutionPlan;
-use vortex::scan::api::DataSourceRef;
+use vortex::scan::DataSourceRef;
 use vortex::session::VortexSession;
 
 use crate::v2::source::VortexDataSource;
@@ -66,7 +66,7 @@ impl TableProvider for VortexTable {
     }
 
     fn schema(&self) -> SchemaRef {
-        self.arrow_schema.clone()
+        Arc::clone(&self.arrow_schema)
     }
 
     fn table_type(&self) -> TableType {
@@ -81,22 +81,23 @@ impl TableProvider for VortexTable {
         _limit: Option<usize>,
     ) -> DFResult<Arc<dyn ExecutionPlan>> {
         // Construct the physical node representing this table.
-        let data_source = VortexDataSource::builder(self.data_source.clone(), self.session.clone())
-            .with_arrow_schema(self.arrow_schema.clone())
-            // We push down the projection now since it can make building the physical plan a lot
-            // cheaper, e.g. by only computing stats for the projected columns.
-            .with_some_projection(projection.cloned())
-            // We don't push down filters for two reasons:
-            //  1. Vortex requires a physical expression, not logical. DataFusion will try to push
-            //     the physical filters later.
-            //  2. There's nothing useful we can do with filters now to reduce the amount of work
-            //     we have to do.
-            //
-            // We also don't push down the limit for the same reason, there's nothing useful we
-            // can do with it.
-            .build()
-            .await
-            .map_err(|e| DataFusionError::External(Box::new(e)))?;
+        let data_source =
+            VortexDataSource::builder(Arc::clone(&self.data_source), self.session.clone())
+                .with_arrow_schema(Arc::clone(&self.arrow_schema))
+                // We push down the projection now since it can make building the physical plan a lot
+                // cheaper, e.g. by only computing stats for the projected columns.
+                .with_some_projection(projection.cloned())
+                // We don't push down filters for two reasons:
+                //  1. Vortex requires a physical expression, not logical. DataFusion will try to push
+                //     the physical filters later.
+                //  2. There's nothing useful we can do with filters now to reduce the amount of work
+                //     we have to do.
+                //
+                // We also don't push down the limit for the same reason, there's nothing useful we
+                // can do with it.
+                .build()
+                .await
+                .map_err(|e| DataFusionError::External(Box::new(e)))?;
 
         Ok(DataSourceExec::from_data_source(data_source))
     }
diff --git a/vortex-duckdb/Cargo.toml b/vortex-duckdb/Cargo.toml
index e5955981400..2d095c1c3e5 100644
--- a/vortex-duckdb/Cargo.toml
+++ b/vortex-duckdb/Cargo.toml
@@ -24,7 +24,6 @@ path = "src/lib.rs"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
 [dependencies]
-anyhow = { workspace = true }
 async-fs = { workspace = true }
 async-trait = { workspace = true }
 bitvec = { workspace = true }
@@ -36,15 +35,16 @@ num-traits = { workspace = true }
 object_store = { workspace = true, features = ["aws"] }
 parking_lot = { workspace = true }
 paste = { workspace = true }
-tempfile = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
 vortex = { workspace = true, features = ["files", "tokio", "object_store"] }
 vortex-utils = { workspace = true, features = ["dashmap"] }
 
 [dev-dependencies]
+anyhow = { 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 }
@@ -56,7 +56,5 @@ workspace = true
 bindgen = { workspace = true }
 cbindgen = { workspace = true }
 cc = { workspace = true }
-once_cell = { workspace = true }
 reqwest = { workspace = true }
-walkdir = { workspace = true }
 zip = { workspace = true }
diff --git a/vortex-duckdb/README.md b/vortex-duckdb/README.md
index 25fbdab509c..416bbac7fcb 100644
--- a/vortex-duckdb/README.md
+++ b/vortex-duckdb/README.md
@@ -6,7 +6,7 @@ Rust bindings for DuckDB. Supports DuckDB precompiled libraries for fast builds
 
 - **Ninja**: `brew install ninja` (macOS) | `apt-get install ninja-build` (Ubuntu)
 - **CMake**: `brew install cmake` (macOS) | `apt-get install cmake` (Ubuntu)
-- **C++17 compatible compiler**: GCC or Clang
+- **C++20 compatible compiler**: GCC or Clang
 
 ## Build Modes
 
diff --git a/vortex-duckdb/build.rs b/vortex-duckdb/build.rs
index b16a1a15f02..a96bd1cbaca 100644
--- a/vortex-duckdb/build.rs
+++ b/vortex-duckdb/build.rs
@@ -2,65 +2,64 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
-#![allow(clippy::panic)]
+// exit(1) + cargo:error= doesn't provide a double-traceback like panic!()
+#![allow(clippy::exit)]
 
-use std::borrow::ToOwned;
 use std::env;
 use std::fs;
-use std::io::ErrorKind;
 use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
+use std::process::exit;
 
 use bindgen::Abi;
-use once_cell::sync::Lazy;
-
-static DUCKDB_VERSION: Lazy<DuckDBVersion> = Lazy::new(|| {
-    // Override the DuckDB version via environment variable in case of an extension build.
-    // `DUCKDB_VERSION` is set by the extension build in the `duckdb-vortex` repo.
-    //
-    // This is to ensure that 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.
-    if let Ok(version) = env::var("DUCKDB_VERSION") {
-        // DUCKDB_VERSION env var can be set by:
-        // - The extension build in `vortex-data/duckdb-vortex` repo
-        // - Developers who want to test against a specific version/commit
-        parse_version(&version)
-    } else {
-        // The default DuckDB version to use when DUCKDB_VERSION env var is not set.
-        DuckDBVersion::Release("1.4.2".to_owned())
-    }
-});
 
 const DUCKDB_RELEASES_URL: &str = "https://github.com/duckdb/duckdb/releases/download";
+const DUCKDB_SOURCE_RELEASE_URL: &str = "https://github.com/duckdb/duckdb/archive/refs/tags";
+const DUCKDB_SOURCE_COMMIT_URL: &str = "https://github.com/duckdb/duckdb/archive";
+
+const BUILD_ARTIFACTS: [&str; 3] = ["libduckdb.dylib", "libduckdb.so", "libduckdb_static.a"];
+
+const SOURCE_FILES: [&str; 18] = [
+    "cpp/client_context.cpp",
+    "cpp/config.cpp",
+    "cpp/copy_function.cpp",
+    "cpp/data.cpp",
+    "cpp/data_chunk.cpp",
+    "cpp/error.cpp",
+    "cpp/expr.cpp",
+    "cpp/file_system.cpp",
+    "cpp/logical_type.cpp",
+    "cpp/object_cache.cpp",
+    "cpp/replacement_scan.cpp",
+    "cpp/reusable_dict.cpp",
+    "cpp/scalar_function.cpp",
+    "cpp/table_filter.cpp",
+    "cpp/table_function.cpp",
+    "cpp/value.cpp",
+    "cpp/vector.cpp",
+    "cpp/vector_buffer.cpp",
+];
+
+const DOWNLOAD_MAX_RETRIES: i32 = 3;
+const DOWNLOAD_TIMEOUT: u64 = 90;
 
-/// Represents either a released DuckDB version or a specific commit hash.
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 enum DuckDBVersion {
-    /// A released DuckDB version of the form "X.Y.Z".
-    /// This mode will download pre-compiled dynamic libraries from GitHub releases.
-    Release(String),
-    /// A commit hash from `github.com/duckdb/duckdb`.
-    /// This mode will download source and build DuckDB from scratch.
-    Commit(String),
+    Release(String), // i.e. X.Y.Z. Download pre-compiled libraries from GitHub releases.
+    Commit(String),  // Download source and build DuckDB from scratch.
 }
 
-impl DuckDBVersion {
-    /// Returns the directory name suffix for this version.
-    fn dir_suffix(&self) -> String {
+impl std::fmt::Display for DuckDBVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            DuckDBVersion::Release(v) => format!("v{v}"),
-            DuckDBVersion::Commit(c) => c.clone(),
+            DuckDBVersion::Release(v) => write!(f, "v{v}"),
+            DuckDBVersion::Commit(c) => write!(f, "{c}"),
         }
     }
+}
 
-    /// Returns true if this is a release version (not a commit).
-    fn is_release(&self) -> bool {
-        matches!(self, DuckDBVersion::Release(_))
-    }
-
+impl DuckDBVersion {
     /// Returns the name of the extracted source directory inside the zip archive.
     /// GitHub archives extract to `duckdb-{version}` for tags and `duckdb-{commit}` for commits.
     fn archive_inner_dir_name(&self) -> String {
@@ -71,329 +70,219 @@ impl DuckDBVersion {
     }
 }
 
-/// Parse a version string into a DuckDBVersion.
-/// - Strings starting with "v" followed by semver are treated as releases
-/// - Pure semver strings (X.Y.Z) are treated as releases
-/// - Everything else (e.g., commit hashes) are treated as commits
-fn parse_version(s: &str) -> DuckDBVersion {
-    let s = s.trim();
-
-    // Strip leading 'v' if present
-    let version_str = s.strip_prefix('v').unwrap_or(s);
-
-    // Check if it looks like a semver release (X.Y.Z pattern)
-    let parts: Vec<&str> = version_str.split('.').collect();
-    if parts.len() >= 2 && parts.iter().all(|p| p.chars().all(|c| c.is_ascii_digit())) {
-        DuckDBVersion::Release(version_str.to_owned())
-    } else {
-        panic!("Invalid DuckDB version: {s}");
+impl From<&String> for DuckDBVersion {
+    fn from(s: &String) -> Self {
+        let s = s.trim();
+        let version_str = s.strip_prefix('v').unwrap_or(s);
+        let parts: Vec<&str> = version_str.split('.').collect();
+        if parts.len() >= 2 && parts.iter().all(|p| p.chars().all(|c| c.is_ascii_digit())) {
+            DuckDBVersion::Release(version_str.to_owned())
+        } else {
+            DuckDBVersion::Commit(version_str.to_owned())
+        }
     }
 }
 
-/// Create an HTTP client with appropriate timeout settings.
-fn http_client() -> Result<reqwest::blocking::Client, Box<dyn std::error::Error>> {
+fn download_url(url: &str, path: &Path) {
+    if path.exists() {
+        return;
+    }
+    println!("cargo:info=Downloading DuckDB from {url}");
+
     let timeout_secs = env::var("CARGO_HTTP_TIMEOUT")
         .or_else(|_| env::var("HTTP_TIMEOUT"))
         .ok()
         .and_then(|s| s.parse().ok())
-        .unwrap_or(90);
-
+        .unwrap_or(DOWNLOAD_TIMEOUT);
     let client = reqwest::blocking::Client::builder()
         .timeout(std::time::Duration::from_secs(timeout_secs))
-        .build()?;
-    Ok(client)
-}
-
-/// Get the target-specific platform and architecture for downloading prebuilt libraries.
-fn platform_arch() -> Result<(&'static str, &'static str), Box<dyn std::error::Error>> {
-    let target = env::var("TARGET")?;
-    match target.as_str() {
-        "aarch64-apple-darwin" | "x86_64-apple-darwin" => Ok(("osx", "universal")),
-        "x86_64-unknown-linux-gnu" => Ok(("linux", "amd64")),
-        "aarch64-unknown-linux-gnu" => Ok(("linux", "arm64")),
-        _ => Err(format!("Unsupported target: {target}").into()),
-    }
-}
-
-/// Get the base target directory for DuckDB artifacts.
-fn target_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
-    Ok(manifest_dir.parent().unwrap().join("target"))
-}
-
-/// Download prebuilt DuckDB libraries from GitHub releases.
-/// Only valid for release versions.
-fn download_duckdb_lib_archive() -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let version = match &*DUCKDB_VERSION {
-        DuckDBVersion::Release(v) => v,
-        DuckDBVersion::Commit(_) => {
-            return Err("Cannot download prebuilt libraries for commit hashes".into());
+        .build()
+        .unwrap();
+
+    for attempt in 1..=DOWNLOAD_MAX_RETRIES {
+        match client.get(url).send() {
+            Ok(response) if response.status().is_success() => {
+                let bytes = response.bytes().unwrap().to_vec();
+                fs::write(path, bytes).unwrap();
+                println!("cargo:info=Downloaded to {url}");
+                return;
+            }
+            Ok(response) if response.status().is_server_error() => {
+                let status = response.status();
+                println!(
+                    "cargo:warning=Download attempt \
+                    {attempt}/{DOWNLOAD_MAX_RETRIES} failed: HTTP {status} for {url}"
+                );
+            }
+            Err(e) => {
+                println!(
+                    "cargo:warning=Download attempt \
+                    {attempt}/{DOWNLOAD_MAX_RETRIES} failed: {e}"
+                );
+            }
+            // Client errors (4xx) are not retryable
+            Ok(response) => {
+                let status = response.status();
+                println!("cargo:error=Failed to download {url}: HTTP {status}");
+                exit(1);
+            }
         }
-    };
 
-    let target_dir = target_dir()?;
-    let duckdb_lib_dir = target_dir.join(format!("duckdb-lib-v{version}"));
-
-    let (platform, arch) = platform_arch()?;
-    let archive_name = format!("libduckdb-{platform}-{arch}.zip");
-    let url = format!("{DUCKDB_RELEASES_URL}/v{version}/{archive_name}");
-    let archive_path = duckdb_lib_dir.join(&archive_name);
-
-    // Create directory if it doesn't exist
-    fs::create_dir_all(&duckdb_lib_dir)?;
-
-    // Download if archive doesn't exist
-    if !archive_path.exists() {
-        println!("cargo:info=Downloading DuckDB libraries from {url}");
-        let response = http_client()?.get(&url).send()?;
-        if !response.status().is_success() {
-            return Err(format!(
-                "Failed to download DuckDB libraries: HTTP {}",
-                response.status()
-            )
-            .into());
+        if attempt < DOWNLOAD_MAX_RETRIES {
+            let delay = std::time::Duration::from_secs(2u64.pow(attempt as u32));
+            println!("cargo:warning=Retrying in {}s...", delay.as_secs());
+            std::thread::sleep(delay);
         }
-        fs::write(&archive_path, &response.bytes()?)?;
-        println!("cargo:info=Downloaded to {}", archive_path.display());
     }
 
-    Ok(archive_path)
+    println!("cargo:error=Failed to download {url} after {DOWNLOAD_MAX_RETRIES} attempts");
+    exit(1);
 }
 
-/// Extract DuckDB libraries from the downloaded archive.
-fn extract_duckdb_libraries(archive_path: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let duckdb_lib_dir = archive_path
-        .parent()
-        .ok_or("Invalid archive path")?
-        .to_path_buf();
-
-    // Check if already extracted (check for both .dylib and .so)
-    let dylib_exists = duckdb_lib_dir.join("libduckdb.dylib").exists();
-    let so_exists = duckdb_lib_dir.join("libduckdb.so").exists();
-
-    if dylib_exists || so_exists {
-        println!("cargo:info=DuckDB libraries already extracted, skipping");
-        return Ok(duckdb_lib_dir);
-    }
-
+fn extract(archive: &Path, dest: &Path) {
     println!(
-        "cargo:info=Extracting DuckDB libraries to {}",
-        duckdb_lib_dir.display()
+        "cargo:info=Extracting {} to {}",
+        archive.display(),
+        dest.display()
     );
-    let file = fs::File::open(archive_path)?;
-    let mut archive = zip::ZipArchive::new(file)?;
-    archive.extract(&duckdb_lib_dir)?;
-
-    Ok(duckdb_lib_dir)
+    let file = fs::File::open(archive).unwrap();
+    zip::ZipArchive::new(file).unwrap().extract(dest).unwrap();
 }
 
-/// Download DuckDB source code archive from GitHub.
-/// Works for both release versions and commit hashes.
-fn download_duckdb_source_archive() -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let target_dir = target_dir()?;
-    let source_dir = target_dir.join(format!("duckdb-source-{}", DUCKDB_VERSION.dir_suffix()));
-
-    let url = match &*DUCKDB_VERSION {
-        DuckDBVersion::Release(v) => {
-            format!("https://github.com/duckdb/duckdb/archive/refs/tags/v{v}.zip")
-        }
-        DuckDBVersion::Commit(c) => {
-            format!("https://github.com/duckdb/duckdb/archive/{c}.zip")
+fn download(version: &DuckDBVersion, library_dir: &Path) {
+    let target = env::var("TARGET").unwrap();
+    let (platform, arch) = match target.as_str() {
+        "aarch64-apple-darwin" | "x86_64-apple-darwin" => ("osx", "universal"),
+        "x86_64-unknown-linux-gnu" => ("linux", "amd64"),
+        "aarch64-unknown-linux-gnu" => ("linux", "arm64"),
+        _ => {
+            println!("cargo:error=Unsupported target {target}");
+            exit(1);
         }
     };
 
-    let archive_path = source_dir.with_extension("zip");
-
-    // Create directory if it doesn't exist
-    fs::create_dir_all(&source_dir)?;
-
-    // Download if archive doesn't exist
-    if !archive_path.exists() {
-        println!("cargo:info=Downloading DuckDB source code from {url}");
-        let response = http_client()?.get(&url).send()?;
-        if !response.status().is_success() {
-            return Err(format!(
-                "Failed to download DuckDB source: HTTP {}",
-                response.status()
-            )
-            .into());
+    let archive_name = format!("libduckdb-{platform}-{arch}.zip");
+    let url = format!("{DUCKDB_RELEASES_URL}/{version}/{archive_name}");
+    let archive_path = library_dir.join(&archive_name);
+
+    fs::create_dir_all(library_dir).unwrap();
+    download_url(&url, &archive_path);
+
+    let duckdb_lib_dir = archive_path.parent().unwrap().to_path_buf();
+    for artifact in BUILD_ARTIFACTS {
+        if duckdb_lib_dir.join(artifact).exists() {
+            return;
         }
-        fs::write(&archive_path, &response.bytes()?)?;
-        println!("cargo:info=Downloaded to {}", archive_path.display());
     }
-
-    Ok(source_dir)
+    extract(&archive_path, &duckdb_lib_dir);
 }
 
-/// Extract DuckDB source code from the downloaded archive.
-fn extract_duckdb_source(source_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let archive_path = source_dir.with_extension("zip");
-
-    // Check if already extracted by looking for CMakeLists.txt
-    let inner_dir_name = DUCKDB_VERSION.archive_inner_dir_name();
-    let cmake_file = source_dir.join(&inner_dir_name).join("CMakeLists.txt");
-
-    if cmake_file.exists() {
-        println!("cargo:info=DuckDB source already extracted, skipping");
-        return Ok(source_dir.to_path_buf());
+fn build_duckdb(version: &DuckDBVersion, duckdb_repo_dir: &Path) {
+    if let Err(e) = Command::new("make").arg("--version").output() {
+        println!("cargo:error=make is required to build DuckDB: {e}");
+        exit(1);
+    }
+    if let Err(e) = Command::new("ninja").arg("--version").output() {
+        println!("cargo:error=ninja is required to build DuckDB: {e}");
+        exit(1);
     }
 
-    println!(
-        "cargo:info=Extracting DuckDB source to {}",
-        source_dir.display()
-    );
-    let file = fs::File::open(&archive_path)?;
-    let mut archive = zip::ZipArchive::new(file)?;
+    println!("cargo:info=Building DuckDB from source (this may take a while)...");
+    let (asan_option, tsan_option) =
+        if env::var("VX_DUCKDB_SAN").is_ok_and(|v| matches!(v.as_str(), "1" | "true")) {
+            ("0", "1") // DISABLE_SANITIZER=0 enables ASAN, THREADSAN=1 enables TSAN
+        } else {
+            ("1", "0")
+        };
+
+    // If we're building from a commit  we need to build httpfs and benchmark
+    // extensions statically, otherwise DuckDB tries to load them from an http
+    // endpoint with version 0.0.1 (all non-tagged builds) which doesn't exist.
+    // httpfs static build also requires CURL dev headers
+    let static_extensions = match version {
+        DuckDBVersion::Release(_) => "parquet;jemalloc",
+        DuckDBVersion::Commit(_) => "parquet;jemalloc;httpfs;tpch;tpcds",
+    };
 
-    // Extract all files, the archive contains a root directory like `duckdb-{version}/`
-    archive.extract(source_dir)?;
+    let envs = [
+        ("GEN", "ninja"),
+        ("DISABLE_SANITIZER", asan_option),
+        ("THREADSAN", tsan_option),
+        ("BUILD_SHELL", "false"),
+        ("BUILD_UNITTESTS", "false"),
+        ("ENABLE_UNITTEST_CPP_TESTS", "false"),
+        ("BUILD_EXTENSIONS", static_extensions),
+    ];
+
+    let output = Command::new("make")
+        .current_dir(duckdb_repo_dir)
+        .envs(envs)
+        .output()
+        .unwrap();
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        println!("cargo:error=Failed to build DuckDB:\nstdout: {stdout}\nstderr: {stderr}");
+        exit(1);
+    }
 
-    Ok(source_dir.to_path_buf())
+    println!("cargo:info=DuckDB build completed");
 }
 
-/// Build DuckDB from source. Used for commit hashes or when VX_DUCKDB_DEBUG is set.
-fn build_duckdb(duckdb_source_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    // Check for ninja
-    if Command::new("ninja").arg("--version").output().is_err() {
-        return Err(
-            "'ninja' is required to build DuckDB. Install it via your package manager.".into(),
-        );
-    }
-
-    let inner_dir_name = DUCKDB_VERSION.archive_inner_dir_name();
-    let duckdb_repo_dir = duckdb_source_dir.join(&inner_dir_name);
-    let build_dir = duckdb_repo_dir.join("build").join("debug");
-
-    // Check if already built
-    let lib_dir = build_dir.join("src");
-    let already_built = lib_dir.join("libduckdb.dylib").exists()
-        || lib_dir.join("libduckdb.so").exists()
-        || lib_dir
-            .read_dir()
-            .map(|mut d| {
-                d.any(|e| e.is_ok_and(|e| e.file_name().to_string_lossy().starts_with("libduckdb")))
-            })
-            .unwrap_or(false);
-
-    if !already_built {
-        println!("cargo:info=Building DuckDB from source (this may take a while)...");
-
-        // Build with ASAN/TSAN if VX_DUCKDB_SAN=1
-        let (asan_option, tsan_option) =
-            if env::var("VX_DUCKDB_SAN").is_ok_and(|v| matches!(v.as_str(), "1" | "true")) {
-                ("0", "1") // DISABLE_SANITIZER=0 enables ASAN, THREADSAN=1 enables TSAN
-            } else {
-                ("1", "0")
-            };
-
-        let output = Command::new("make")
-            .current_dir(&duckdb_repo_dir)
-            .env("GEN", "ninja")
-            .env("DISABLE_SANITIZER", asan_option)
-            .env("THREADSAN", tsan_option)
-            .arg("debug")
-            .output()?;
-
-        if !output.status.success() {
-            return Err(format!(
-                "Failed to build DuckDB:\nstdout: {}\nstderr: {}",
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr)
-            )
-            .into());
+fn try_build_duckdb(
+    source_dir: &Path,
+    library_dir: &Path,
+    version: &DuckDBVersion,
+    build_type: &str,
+) {
+    let inner_dir_name = version.archive_inner_dir_name();
+    let repo_dir = source_dir.join(&inner_dir_name);
+    let build_dir = repo_dir.join("build").join(build_type);
+    let build_src_dir = build_dir.join("src");
+
+    let mut build = true;
+    for artifact in BUILD_ARTIFACTS {
+        let path = build_src_dir.join(artifact);
+        if path.exists() {
+            println!("cargo:info=Found {artifact} in {}", path.display());
+            build = false;
+            break;
         }
-
-        println!("cargo:info=DuckDB build completed successfully");
-    } else {
-        println!("cargo:info=DuckDB already built, skipping build");
     }
 
-    // Copy libraries to a stable location
-    let target_dir = target_dir()?;
-    let duckdb_library_dir = target_dir.join(format!("duckdb-lib-{}", DUCKDB_VERSION.dir_suffix()));
+    if build {
+        build_duckdb(version, &repo_dir);
+    }
 
-    // Only copy if the destination doesn't have the libraries
-    if !(duckdb_library_dir.join("libduckdb.dylib").exists()
-        || duckdb_library_dir.join("libduckdb.so").exists())
+    let library_dir_str = library_dir.display();
+    if let Err(err) = fs::remove_dir_all(library_dir)
+        && err.kind() != std::io::ErrorKind::NotFound
     {
-        // Clean and recreate destination
-        match fs::remove_dir_all(&duckdb_library_dir) {
-            Err(err) if err.kind() == ErrorKind::NotFound => (),
-            otherwise => otherwise?,
-        }
-        fs::create_dir_all(&duckdb_library_dir)?;
-
-        // Copy .dylib and .so files
-        for entry in fs::read_dir(lib_dir)? {
-            let entry = entry?;
-            let path = entry.path();
-
-            if path
-                .file_name()
-                .and_then(|name| name.to_str())
-                .is_some_and(|name| name.starts_with("libduckdb"))
-            {
-                let dest = duckdb_library_dir.join(entry.file_name());
-                fs::copy(&path, &dest)?;
-            }
+        println!("cargo:error=Failed to remove {library_dir_str}: {err}");
+        exit(1);
+    };
+    fs::create_dir_all(library_dir).unwrap();
+
+    let mut found_artifact = false;
+    for artifact in BUILD_ARTIFACTS {
+        let src = build_src_dir.join(artifact);
+        if !src.exists() {
+            continue;
         }
+        let dest = library_dir.join(artifact);
+        fs::copy(&src, &dest).unwrap();
+        found_artifact = true;
     }
 
-    Ok(duckdb_library_dir)
-}
-
-/// Get the path to the DuckDB include directory within the source tree.
-fn duckdb_include_path(source_dir: &Path) -> PathBuf {
-    let inner_dir_name = DUCKDB_VERSION.archive_inner_dir_name();
-    source_dir.join(inner_dir_name).join("src").join("include")
-}
-
-fn main() {
-    // Emit rerun-if-env-changed for all relevant environment variables
-    println!("cargo:rerun-if-env-changed=DUCKDB_VERSION");
-    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");
-
-    let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
-    let duckdb_symlink = crate_dir.join("duckdb");
-
-    match &*DUCKDB_VERSION {
-        DuckDBVersion::Release(v) => println!("cargo:info=Using DuckDB release version: {v}"),
-        DuckDBVersion::Commit(c) => println!("cargo:info=Using DuckDB commit: {c}"),
+    if !found_artifact {
+        let artifacts = BUILD_ARTIFACTS.join(",");
+        println!("cargo:error=Failed to find any of {artifacts} after build");
+        exit(1);
     }
+}
 
-    // Always download and extract source (needed for headers)
-    let source_dir = download_duckdb_source_archive().unwrap();
-    let extracted_source_path = extract_duckdb_source(&source_dir).unwrap();
-
-    // Create/update symlink to source directory
-    // Remove existing symlink/directory first (ignore errors if they don't exist)
-    drop(fs::remove_file(&duckdb_symlink));
-    drop(fs::remove_dir_all(&duckdb_symlink));
-    std::os::unix::fs::symlink(&extracted_source_path, &duckdb_symlink).unwrap();
-
-    // Determine whether to build from source or use prebuilt libraries
-    let use_debug_build =
-        env::var("VX_DUCKDB_DEBUG").is_ok_and(|v| matches!(v.as_str(), "1" | "true"));
-
-    let library_path = if use_debug_build || !DUCKDB_VERSION.is_release() {
-        // Build from source for:
-        // - Commit hashes (no prebuilt available)
-        // - When VX_DUCKDB_DEBUG=1 (user wants debug build)
-        build_duckdb(&extracted_source_path).unwrap()
-    } else {
-        // Download prebuilt libraries for release versions
-        let archive_path = download_duckdb_lib_archive().unwrap();
-        extract_duckdb_libraries(&archive_path).unwrap()
-    };
-
-    let duckdb_include_path = duckdb_include_path(&extracted_source_path);
-
-    // Generate the _imported_ bindings from our C++ code.
-    bindgen::Builder::default()
+fn c2rust(crate_dir: &Path, duckdb_include_dir: &Path) {
+    let bindings = bindgen::Builder::default()
         .header("cpp/include/duckdb_vx.h")
         .override_abi(Abi::CUnwind, ".*")
         // Allow for auto-generated cpp.rs code.
@@ -412,105 +301,155 @@ fn main() {
         .rustified_enum("DUCKDB_VX_VECTOR_TYPE")
         .rustified_non_exhaustive_enum("DUCKDB_TYPE")
         .size_t_is_usize(true)
-        .clang_arg(format!("-I{}", duckdb_include_path.display()))
+        .clang_arg(format!("-I{}", duckdb_include_dir.display()))
         .clang_arg(format!("-I{}", crate_dir.join("cpp/include").display()))
+        .generate_comments(true)
         // Tell cargo to invalidate the built crate whenever any of the
         // included header files changed.
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
-        // Finish the builder and generate the bindings.
-        .generate()
-        .expect("Unable to generate bindings")
-        .write_to_file(crate_dir.join("src/cpp.rs"))
-        .expect("Couldn't write bindings!");
-
-    // Link against DuckDB dylib.
-    println!("cargo:rustc-link-search=native={}", library_path.display());
-    println!("cargo:rustc-link-lib=dylib=duckdb");
-
-    // Set rpath for binaries built directly from this crate (this is not inherited by downstream crates).
-    println!("cargo:rustc-link-arg=-Wl,-rpath,{}", library_path.display());
+        .generate();
 
-    // Export the library path for downstream crates via the `links` manifest key.
-    // Downstream crates can access this via `env::var("DEP_DUCKDB_LIB_DIR")` in their build.rs
-    // and add their own rpath:
-    //
-    //   if let Ok(duckdb_lib) = env::var("DEP_DUCKDB_LIB_DIR") {
-    //       println!("cargo:rustc-link-arg=-Wl,-rpath,{duckdb_lib}");
-    //   }
-    //
-    // Alternatively, set LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) at runtime:
-    //   LD_LIBRARY_PATH=/path/to/target/duckdb-lib-vX.Y.Z cargo run --bin ...
-    //
-    println!("cargo:lib_dir={}", library_path.display());
+    let bindings = match bindings {
+        Ok(b) => b,
+        Err(e) => {
+            println!("cargo:error=Failed to generate Rust bindings: {e}");
+            exit(1);
+        }
+    };
+    let out_path = crate_dir.join("src/cpp.rs");
+    let new_contents = bindings.to_string();
+    let write = match fs::read_to_string(&out_path) {
+        Ok(existing) => existing != new_contents,
+        Err(_) => true,
+    };
+    if write && let Err(e) = fs::write(&out_path, new_contents) {
+        println!("cargo:error=Failed to write Rust bindings: {e}");
+        exit(1);
+    }
+}
 
-    // Compile our C++ code that exposes additional DuckDB functionality.
+fn cpp(duckdb_include_dir: &Path) {
     cc::Build::new()
-        .std("c++17")
-        // Enable compiler warnings.
-        .flag("-Wall")
-        .flag("-Wextra")
-        .flag("-Wpedantic")
-        // Allow C++20 designator syntax even with C++17 std
-        .flag("-Wno-c++20-designator")
-        // Enable C++20 extensions
-        .flag("-Wno-c++20-extensions")
-        // Unused parameter warnings are disabled as we include DuckDB
-        // headers with implementations that have unused parameters.
-        .flag("-Wno-unused-parameter")
+        .std("c++20")
+        .flags(["-Wall", "-Wextra", "-Wpedantic"])
         .cpp(true)
-        .include(&duckdb_include_path)
+        .include(duckdb_include_dir)
         .include("cpp/include")
-        .file("cpp/client_context.cpp")
-        .file("cpp/config.cpp")
-        .file("cpp/copy_function.cpp")
-        .file("cpp/data.cpp")
-        .file("cpp/data_chunk.cpp")
-        .file("cpp/error.cpp")
-        .file("cpp/expr.cpp")
-        .file("cpp/file_system.cpp")
-        .file("cpp/logical_type.cpp")
-        .file("cpp/object_cache.cpp")
-        .file("cpp/replacement_scan.cpp")
-        .file("cpp/scalar_function.cpp")
-        .file("cpp/table_filter.cpp")
-        .file("cpp/table_function.cpp")
-        .file("cpp/value.cpp")
-        .file("cpp/vector.cpp")
-        .file("cpp/vector_buffer.cpp")
+        .files(SOURCE_FILES)
         .compile("vortex-duckdb-extras");
+    // bindgen generates rerun-if-changed for .h/.hpp files
+    for e in SOURCE_FILES {
+        println!("cargo:rerun-if-changed={e}");
+    }
+}
 
-    // Generate the _exported_ bindings from our Rust code.
-    let generated_header = crate_dir.join("include/vortex.h");
-    cbindgen::Builder::new()
+fn rust2c(crate_dir: &Path) {
+    let header = crate_dir.join("include/vortex.h");
+    let output = cbindgen::Builder::new()
         .with_config(cbindgen::Config::from_file(crate_dir.join("cbindgen.toml")).unwrap())
-        .with_crate(&crate_dir)
+        .with_crate(crate_dir)
         .with_no_includes()
-        .generate()
-        .expect("error: Unable to generate bindings for vortex.h")
-        .write_to_file(&generated_header);
-
-    // Run clang-format on the generated header.
-    if let Ok(status) = Command::new("clang-format")
-        .arg("-i")
-        .arg("--style=file")
-        .arg(&generated_header)
-        .status()
-    {
+        .generate();
+    match output {
+        Ok(bindings) => bindings.write_to_file(&header),
+        Err(e) => {
+            println!("cargo:error=Failed to generate cbindgen bindings for vortex.h: {e}");
+            exit(1);
+        }
+    };
+
+    let mut cmd = Command::new("clang-format");
+    let format = cmd.arg("-i").arg("--style=file").arg(&header);
+    if let Ok(status) = format.status() {
         if !status.success() {
             println!("cargo:warning=clang-format exited with status {status}");
         }
     } else {
         println!("cargo:warning=clang-format not found, skipping formatting of generated header");
     }
+}
 
-    // Watch C/C++ source files for changes.
-    for entry in walkdir::WalkDir::new("cpp/").into_iter().flatten() {
-        if entry
-            .path()
-            .extension()
-            .is_some_and(|ext| ext == "cpp" || ext == "h" || ext == "hpp")
-        {
-            println!("cargo:rerun-if-changed={}", entry.path().display());
-        }
+fn main() {
+    println!("cargo:rerun-if-env-changed=DUCKDB_VERSION");
+    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.
+    let version = env::var("DUCKDB_VERSION")
+        // You can also change this version to a commit hash
+        .unwrap_or_else(|_| "1.5.0".to_owned());
+    let version = DuckDBVersion::from(&version);
+    match &version {
+        DuckDBVersion::Release(v) => println!("cargo:info=Using DuckDB release version: {v}"),
+        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 target_dir = crate_dir.parent().unwrap().join("target");
+    let library_dir = target_dir.join(format!("duckdb-lib-{version}"));
+
+    let library_dir_str = library_dir.display();
+    println!("cargo:rustc-link-search=native={library_dir_str}");
+    println!("cargo:rustc-link-lib=dylib=duckdb");
+
+    // Set rpath for binaries built directly from this crate. This is not
+    // inherited by downstream crates.
+    println!("cargo:rustc-link-arg=-Wl,-rpath,{library_dir_str}");
+
+    // Export the library path for downstream crates via the `links` manifest key.
+    // Downstream crates can access this via `env::var("DEP_DUCKDB_LIB_DIR")` in their build.rs
+    // and add their own rpath:
+    //
+    //   if let Ok(duckdb_lib) = env::var("DEP_DUCKDB_LIB_DIR") {
+    //       println!("cargo:rustc-link-arg=-Wl,-rpath,{duckdb_lib}");
+    //   }
+    //
+    // Alternatively, set LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) at runtime:
+    //   LD_LIBRARY_PATH=/path/to/target/duckdb-lib-vX.Y.Z cargo run --bin ...
+    println!("cargo:lib_dir={library_dir_str}");
+
+    let source_dir = target_dir.join(format!("duckdb-source-{version}"));
+    let source_archive_url = match &version {
+        DuckDBVersion::Release(v) => format!("{DUCKDB_SOURCE_RELEASE_URL}/v{v}.zip"),
+        DuckDBVersion::Commit(c) => format!("{DUCKDB_SOURCE_COMMIT_URL}/{c}.zip"),
+    };
+
+    fs::create_dir_all(&source_dir).unwrap();
+    let source_archive_path = source_dir.with_extension("zip");
+    download_url(&source_archive_url, &source_archive_path);
+
+    let inner_dir = source_dir.join(version.archive_inner_dir_name());
+    if !inner_dir.join("CMakeLists.txt").exists() {
+        extract(&source_archive_path, &source_dir);
     }
+
+    drop(fs::remove_file(&duckdb_dir));
+    drop(fs::remove_dir_all(&duckdb_dir));
+    std::os::unix::fs::symlink(&source_dir, &duckdb_dir).unwrap();
+
+    let has_debug_env =
+        env::var("VX_DUCKDB_DEBUG").is_ok_and(|v| matches!(v.as_str(), "1" | "true"));
+    let build_type = match has_debug_env {
+        true => "debug",
+        false => "release",
+    };
+    println!("cargo:info=building DuckDB in {build_type} mode");
+
+    if has_debug_env || matches!(version, DuckDBVersion::Commit(_)) {
+        try_build_duckdb(&source_dir, &library_dir, &version, build_type);
+    } else {
+        download(&version, &library_dir);
+    };
+
+    let duckdb_include_dir = inner_dir.join("src").join("include");
+    c2rust(&crate_dir, &duckdb_include_dir);
+    cpp(&duckdb_include_dir);
+    rust2c(&crate_dir);
 }
diff --git a/vortex-duckdb/cpp/CMakeLists.txt b/vortex-duckdb/cpp/CMakeLists.txt
index 33de88deb2b..9671d93dd6d 100644
--- a/vortex-duckdb/cpp/CMakeLists.txt
+++ b/vortex-duckdb/cpp/CMakeLists.txt
@@ -10,20 +10,20 @@
 # If your editor relies on a compilation database to enable LSP functionality,
 # you can generate it by running `cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON` or
 # `bear -- cargo build` (https://github.com/rizsotto/Bear).
-
-cmake_minimum_required(VERSION 3.20)
+cmake_minimum_required(VERSION 3.22)
 project(vortex_duckdb_cpp)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # Default to debug if build config is not explicitly set.
 if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
-endif ()
+endif()
 
 # Enable compiler warnings (matching build.rs flags).
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -Wno-unused-parameter -Wno-c++20-designator -Wno-c++20-extensions")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
 
 # Find DuckDB include directory via the symlink created by build.rs.
 # The symlink points to target/duckdb-source-vX.Y.Z which contains duckdb-X.Y.Z/
diff --git a/vortex-duckdb/cpp/client_context.cpp b/vortex-duckdb/cpp/client_context.cpp
index c683229bc9e..181a42ff392 100644
--- a/vortex-duckdb/cpp/client_context.cpp
+++ b/vortex-duckdb/cpp/client_context.cpp
@@ -3,9 +3,12 @@
 
 #include "duckdb_vx.h"
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include <duckdb/main/client_context.hpp>
 #include <duckdb/main/connection.hpp>
 #include <duckdb/storage/object_cache.hpp>
+DUCKDB_INCLUDES_END
 
 extern "C" duckdb_client_context duckdb_vx_connection_get_client_context(duckdb_connection conn) {
     try {
diff --git a/vortex-duckdb/cpp/config.cpp b/vortex-duckdb/cpp/config.cpp
index 126d7dba3d6..c2d2c72169f 100644
--- a/vortex-duckdb/cpp/config.cpp
+++ b/vortex-duckdb/cpp/config.cpp
@@ -2,9 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #include "include/duckdb_vx/config.h"
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/config.hpp"
+DUCKDB_INCLUDES_END
+
 #include <string>
 #include <memory>
 #include <cstdlib>
@@ -40,17 +45,16 @@ duckdb_state duckdb_vx_get_config_value(duckdb_config config, const char *key, d
 
         std::string key_str(key);
 
-        // First check set_variables (the primary location for config values)
-        auto set_it = db_config->options.set_variables.find(key_str);
-        if (set_it != db_config->options.set_variables.end()) {
-            *out_value = reinterpret_cast<duckdb_value>(new Value(set_it->second));
+        // First check set_variable_defaults (the primary location for config values)
+        if (db_config->options.set_variable_defaults.contains(key_str)) {
+            *out_value =
+                reinterpret_cast<duckdb_value>(new Value(db_config->options.set_variable_defaults[key_str]));
             return DuckDBSuccess;
         }
 
         // Then check user_options
-        auto user_it = db_config->options.user_options.find(key_str);
-        if (user_it != db_config->options.user_options.end()) {
-            *out_value = reinterpret_cast<duckdb_value>(new Value(user_it->second));
+        if (db_config->options.user_options.contains(key_str)) {
+            *out_value = reinterpret_cast<duckdb_value>(new Value(db_config->options.user_options[key_str]));
             return DuckDBSuccess;
         }
 
@@ -75,13 +79,13 @@ int duckdb_vx_config_has_key(duckdb_config config, const char *key) {
 
         std::string key_str(key);
 
-        // Check if the key exists in set_variables (primary location)
-        if (db_config->options.set_variables.find(key_str) != db_config->options.set_variables.end()) {
+        // Check if the key exists in set_variable_defaults (primary location)
+        if (db_config->options.set_variable_defaults.contains(key_str)) {
             return 1;
         }
 
         // Check if the key exists in user_options
-        if (db_config->options.user_options.find(key_str) != db_config->options.user_options.end()) {
+        if (db_config->options.user_options.contains(key_str)) {
             return 1;
         }
 
diff --git a/vortex-duckdb/cpp/copy_function.cpp b/vortex-duckdb/cpp/copy_function.cpp
index 6b36d0f6a09..e05aa942189 100644
--- a/vortex-duckdb/cpp/copy_function.cpp
+++ b/vortex-duckdb/cpp/copy_function.cpp
@@ -3,12 +3,16 @@
 
 #include "duckdb_vx.h"
 #include "duckdb_vx/data.hpp"
+#include "duckdb_vx/error.hpp"
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/connection.hpp"
 #include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb_vx/error.hpp"
+DUCKDB_INCLUDES_END
 
 using namespace duckdb;
 
@@ -39,7 +43,7 @@ struct CCopyLocalData final : LocalFunctionData {
 
 static duckdb_vx_copy_func_vtab_t copy_vtab_one;
 
-unique_ptr<FunctionData> c_bind_one(ClientContext &context,
+unique_ptr<FunctionData> c_bind_one(ClientContext & /*context*/,
                                     CopyFunctionBindInput &info,
                                     const vector<string> &column_names,
                                     const vector<LogicalType> &column_types) {
@@ -90,7 +94,7 @@ c_init_global(ClientContext &context, FunctionData &bind_data, const string &fil
     return make_uniq<CCopyGlobalData>(unique_ptr<CData>(reinterpret_cast<CData *>(global_data)));
 }
 
-unique_ptr<LocalFunctionData> c_init_local(ExecutionContext &context, FunctionData &bind_data) {
+unique_ptr<LocalFunctionData> c_init_local(ExecutionContext & /*context*/, FunctionData &bind_data) {
     auto &bind = bind_data.Cast<CCopyBindData>();
     duckdb_vx_error error_out = nullptr;
     auto data = bind.vtab.init_local(bind.ffi_data->DataPtr(), &error_out);
@@ -101,7 +105,7 @@ unique_ptr<LocalFunctionData> c_init_local(ExecutionContext &context, FunctionDa
     return make_uniq<CCopyLocalData>(unique_ptr<CData>(reinterpret_cast<CData *>(data)));
 }
 
-void c_copy_to_sink(ExecutionContext &context,
+void c_copy_to_sink(ExecutionContext & /*context*/,
                     FunctionData &bind_data,
                     GlobalFunctionData &gstate,
                     LocalFunctionData &lstate,
@@ -120,7 +124,7 @@ void c_copy_to_sink(ExecutionContext &context,
     }
 }
 
-void copy_to_finalize(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate) {
+void copy_to_finalize(ClientContext & /*context*/, FunctionData &bind_data, GlobalFunctionData &gstate) {
     auto &bind = bind_data.Cast<CCopyBindData>();
     auto &global = gstate.Cast<CCopyGlobalData>();
     duckdb_vx_error error_out = nullptr;
@@ -152,7 +156,7 @@ extern "C" duckdb_state duckdb_vx_copy_func_register_vtab_one(duckdb_database ff
     copy_function.extension = copy_vtab_one.extension;
 
     // TODO(joe): expose this via c our api
-    copy_function.execution_mode = [](bool preserve_insertion_order, bool supports_batch_index) {
+    copy_function.execution_mode = [](bool /*preserve_insertion_order*/, bool /*supports_batch_index*/) {
         return CopyFunctionExecutionMode::REGULAR_COPY_TO_FILE;
     };
     // TODO(joe): handle parameters as in table_function
diff --git a/vortex-duckdb/cpp/data.cpp b/vortex-duckdb/cpp/data.cpp
index 5d7e37b7667..2b5e4d402cc 100644
--- a/vortex-duckdb/cpp/data.cpp
+++ b/vortex-duckdb/cpp/data.cpp
@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx/data.hpp"
 
diff --git a/vortex-duckdb/cpp/data_chunk.cpp b/vortex-duckdb/cpp/data_chunk.cpp
index 21f0aea5f7e..3829a6eaf24 100644
--- a/vortex-duckdb/cpp/data_chunk.cpp
+++ b/vortex-duckdb/cpp/data_chunk.cpp
@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/types/data_chunk.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 
diff --git a/vortex-duckdb/cpp/error.cpp b/vortex-duckdb/cpp/error.cpp
index 111a6d22f2f..4e14b34a76d 100644
--- a/vortex-duckdb/cpp/error.cpp
+++ b/vortex-duckdb/cpp/error.cpp
@@ -4,9 +4,12 @@
 #include <cassert>
 #include <exception>
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/vector_buffer.hpp"
 #include "duckdb/common/types/vector.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 
diff --git a/vortex-duckdb/cpp/expr.cpp b/vortex-duckdb/cpp/expr.cpp
index ae953a52ccd..85629a904da 100644
--- a/vortex-duckdb/cpp/expr.cpp
+++ b/vortex-duckdb/cpp/expr.cpp
@@ -2,6 +2,9 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #include "duckdb_vx.h"
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/planner/expression/bound_between_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
@@ -9,6 +12,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
+DUCKDB_INCLUDES_END
 
 using namespace duckdb;
 
diff --git a/vortex-duckdb/cpp/file_system.cpp b/vortex-duckdb/cpp/file_system.cpp
index f3bcee7e971..43c2f3e9907 100644
--- a/vortex-duckdb/cpp/file_system.cpp
+++ b/vortex-duckdb/cpp/file_system.cpp
@@ -4,10 +4,13 @@
 #include "duckdb_vx.h"
 #include "duckdb_vx/error.hpp"
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
 #include <duckdb/common/exception.hpp>
 #include <duckdb/common/file_system.hpp>
 #include <duckdb/common/helper.hpp>
 #include <duckdb/main/client_context.hpp>
+DUCKDB_INCLUDES_END
 
 #include <memory>
 #include <string>
diff --git a/vortex-duckdb/cpp/include/duckdb_vx.h b/vortex-duckdb/cpp/include/duckdb_vx.h
index 9882afbb310..d1396477320 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx.h
@@ -13,6 +13,7 @@
 #include "duckdb_vx/file_system.h"
 #include "duckdb_vx/logical_type.h"
 #include "duckdb_vx/object_cache.h"
+#include "duckdb_vx/reusable_dict.h"
 #include "duckdb_vx/replacement_scan.h"
 #include "duckdb_vx/scalar_function.h"
 #include "duckdb_vx/table_filter.h"
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/client_context.h b/vortex-duckdb/cpp/include/duckdb_vx/client_context.h
index 2443eb541b4..8fe51743188 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/client_context.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/client_context.h
@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
 extern "C" {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/config.h b/vortex-duckdb/cpp/include/duckdb_vx/config.h
index 86e0135652e..c541a6ce1d7 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/config.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/config.h
@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/data.h b/vortex-duckdb/cpp/include/duckdb_vx/data.h
index 88d45d82a45..f01de4e2d12 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/data.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/data.h
@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
 extern "C" {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/data_chunk.h b/vortex-duckdb/cpp/include/duckdb_vx/data_chunk.h
index e3a5f3c2427..ddbca51c4cb 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/data_chunk.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/data_chunk.h
@@ -3,7 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "error.h"
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/duckdb_diagnostics.h b/vortex-duckdb/cpp/include/duckdb_vx/duckdb_diagnostics.h
new file mode 100644
index 00000000000..5c2e3bb3979
--- /dev/null
+++ b/vortex-duckdb/cpp/include/duckdb_vx/duckdb_diagnostics.h
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+// Suppress warnings from DuckDB headers that we include but do not own.
+//
+// Usage:
+//   DUCKDB_INCLUDES_BEGIN
+//   #include "duckdb.h"
+//   #include "duckdb/main/client_context.hpp"
+//   DUCKDB_INCLUDES_END
+
+#pragma once
+
+// clang-format off
+#if defined(__clang__) || defined(__GNUC__)
+#define DUCKDB_INCLUDES_BEGIN                                                  \
+    _Pragma("GCC diagnostic push")                                             \
+    _Pragma("GCC diagnostic ignored \"-Wall\"")                                \
+    _Pragma("GCC diagnostic ignored \"-Wextra\"")                              \
+    _Pragma("GCC diagnostic ignored \"-Wpedantic\"")                           \
+    _Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")                   \
+    _Pragma("GCC diagnostic ignored \"-Wtype-limits\"")
+#define DUCKDB_INCLUDES_END _Pragma("GCC diagnostic pop")
+#else
+#define DUCKDB_INCLUDES_BEGIN
+#define DUCKDB_INCLUDES_END
+#endif
+// clang-format on
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/error.hpp b/vortex-duckdb/cpp/include/duckdb_vx/error.hpp
index fd14fcbe773..fc4b185ac69 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/error.hpp
+++ b/vortex-duckdb/cpp/include/duckdb_vx/error.hpp
@@ -6,7 +6,12 @@
 #include <exception>
 #include <string>
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "duckdb_vx/error.h"
 
 namespace vortex {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/file_system.h b/vortex-duckdb/cpp/include/duckdb_vx/file_system.h
index 7e9f72a8b47..bfe31b12aff 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/file_system.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/file_system.h
@@ -3,7 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "duckdb_vx/client_context.h"
 #include "duckdb_vx/error.h"
 
@@ -39,7 +44,7 @@ duckdb_state duckdb_vx_fs_read(duckdb_vx_file_handle handle,
 
 /// Callback invoked for each entry returned by `duckdb_vx_fs_list_files`.
 ///
-/// @param name  The entry name (not a full path).
+/// @param name  The entry's path, full for remote files, relative for local files
 /// @param is_dir  Whether the entry is a directory.
 /// @param user_data  Opaque pointer forwarded from the caller.
 typedef void (*duckdb_vx_list_files_callback)(const char *name, bool is_dir, void *user_data);
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h b/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
index 66d721effb7..2dcc91350ba 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
 extern "C" {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/object_cache.h b/vortex-duckdb/cpp/include/duckdb_vx/object_cache.h
index 00d1a0437de..a96d62fde9a 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/object_cache.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/object_cache.h
@@ -20,6 +20,7 @@ typedef void (*duckdb_vx_deleter_fn)(void *ptr);
 void duckdb_vx_object_cache_put(duckdb_vx_object_cache object_cache,
                                 const char *key,
                                 void *value,
+                                uint64_t estimated_size,
                                 duckdb_vx_deleter_fn deleter);
 
 // Fetches the key from the object cache, returning nullptr if the key is not present.
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/reusable_dict.h b/vortex-duckdb/cpp/include/duckdb_vx/reusable_dict.h
new file mode 100644
index 00000000000..25b0a10d8ac
--- /dev/null
+++ b/vortex-duckdb/cpp/include/duckdb_vx/reusable_dict.h
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#pragma once
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
+#include "duckdb.h"
+DUCKDB_INCLUDES_END
+
+#include "duckdb_vx/error.h"
+
+#ifdef __cplusplus /* If compiled as C++, use C ABI */
+extern "C" {
+#endif
+
+typedef struct duckdb_vx_reusable_dict_ *duckdb_vx_reusable_dict;
+
+/// Creates a new reusable dictionary from a logical type and size.
+/// The returned dictionary can be used with duckdb_vx_vector_dictionary_reusable.
+duckdb_vx_reusable_dict duckdb_vx_reusable_dict_create(duckdb_logical_type logical_type, idx_t size);
+
+/// Destroys the reusable dictionary.
+void duckdb_vx_reusable_dict_destroy(duckdb_vx_reusable_dict *dict);
+
+/// Clones the reusable dictionary.
+duckdb_vx_reusable_dict duckdb_vx_reusable_dict_clone(duckdb_vx_reusable_dict dict);
+
+/// Get the internal vector of the reusable dictionary.
+void duckdb_vx_reusable_dict_set_vector(duckdb_vx_reusable_dict reusable, duckdb_vector *out_vector);
+
+/// Creates a dictionary vector using a reusable dictionary and a selection vector.
+void duckdb_vx_vector_dictionary_reusable(duckdb_vector vector,
+                                          duckdb_vx_reusable_dict reusable,
+                                          duckdb_selection_vector sel_vec);
+
+#ifdef __cplusplus /* End C ABI */
+}
+#endif
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/scalar_function.h b/vortex-duckdb/cpp/include/duckdb_vx/scalar_function.h
index fb20812a961..62ebcd5157b 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/scalar_function.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/scalar_function.h
@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
 extern "C" {
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/table_filter.h b/vortex-duckdb/cpp/include/duckdb_vx/table_filter.h
index 936a3ff171c..df4b9d47c8b 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/table_filter.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/table_filter.h
@@ -3,7 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "duckdb_vx/expr.h"
 
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
@@ -20,7 +25,9 @@ typedef enum DUCKDB_VX_TABLE_FILTER_TYPE {
     DUCKDB_VX_TABLE_FILTER_TYPE_OPTIONAL_FILTER = 6, // executing filter is not required for query correctness
     DUCKDB_VX_TABLE_FILTER_TYPE_IN_FILTER = 7,       // col IN (C1, C2, C3, ...)
     DUCKDB_VX_TABLE_FILTER_TYPE_DYNAMIC_FILTER = 8,  // dynamic filters can be updated at run-time
-    DUCKDB_VX_TABLE_FILTER_TYPE_EXPRESSION_FILTER = 9 // an arbitrary expression
+    DUCKDB_VX_TABLE_FILTER_TYPE_EXPRESSION_FILTER = 9, // an arbitrary expression
+    DUCKDB_VX_TABLE_FILTER_TYPE_BLOOM_FILTER =
+        10 // a probabilistic filter that can test whether a value is in a set of other value
 } duckdb_vx_table_filter_type;
 
 typedef struct duckdb_vx_table_filter_set_ *duckdb_vx_table_filter_set;
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/table_function.h b/vortex-duckdb/cpp/include/duckdb_vx/table_function.h
index 5299d773271..e8f483514a5 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/table_function.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/table_function.h
@@ -62,22 +62,38 @@ void duckdb_vx_string_map_free(duckdb_vx_string_map map);
 // Input data passed into the init_global and init_local callbacks.
 typedef struct {
     const void *bind_data;
+
+    /**
+     * Projected columns that are requested to be read. These are not
+     * all columns, only the ones DuckDB optimizer thinks we should read.
+     */
     idx_t *column_ids;
     size_t column_ids_count;
-    // uint64_t *column_indexes;
-    // size_t column_indexes_count;
+
+    /**
+     * Post filter projected columns. Our table function implements filter
+     * pushdown so this list is a subset of columns referenced in column_ids
+     * after filter pushdown and filter pruning. May be empty, in which case
+     * column_ids should be used.
+     * Indices in this list reference values from column_ids. I.e. if
+     * column_ids=[1,5,6], projection_ids=[1], output column should be
+     * column_ids[1] = 5
+     *
+     * Example usage:
+     * https://github.com/duckdb/duckdb/blob/dc11eadd8f0a7c600f0034810706605ebe10d5b9/src/include/duckdb/function/table_function.hpp#L147
+     */
     const idx_t *projection_ids;
     size_t projection_ids_count;
+
     duckdb_vx_table_filter_set filters;
     duckdb_client_context client_context;
-    // void *sample_options;
 } duckdb_vx_tfunc_init_input;
 
 // Result data returned from the cardinality callback.
 typedef struct {
     idx_t estimated_cardinality;
-    bool has_estimated_cardinality;
     idx_t max_cardinality;
+    bool has_estimated_cardinality;
     bool has_max_cardinality;
 } duckdb_vx_node_statistics;
 
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/vector.h b/vortex-duckdb/cpp/include/duckdb_vx/vector.h
index 3edbe5461a1..ea3e49184f7 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/vector.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/vector.h
@@ -3,7 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "duckdb_vx/data.h"
 #include "duckdb_vx/error.h"
 #include "duckdb_vx/vector_buffer.h"
@@ -32,8 +37,6 @@ void duckdb_vx_vector_dictionary(duckdb_vector ffi_vector,
                                  duckdb_selection_vector ffi_sel_vec,
                                  idx_t count);
 
-void duckdb_vx_set_dictionary_vector_id(duckdb_vector dict, const char *id, unsigned int id_len);
-
 void duckdb_vx_set_dictionary_vector_length(duckdb_vector dict, unsigned int len);
 
 // Add the buffer to the string vector (basically, keep it alive as long as the vector).
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.h b/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.h
index a5148f07749..91e624dd16d 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.h
@@ -3,7 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
+DUCKDB_INCLUDES_END
+
 #include "duckdb_vx/data.h"
 #include "duckdb_vx/error.h"
 
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.hpp b/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.hpp
index 0ce107cec3f..605a4a9a04f 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.hpp
+++ b/vortex-duckdb/cpp/include/duckdb_vx/vector_buffer.hpp
@@ -3,8 +3,12 @@
 
 #pragma once
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/types/vector.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx/data.hpp"
 
diff --git a/vortex-duckdb/cpp/logical_type.cpp b/vortex-duckdb/cpp/logical_type.cpp
index 57728cc5ce5..f4385af6f42 100644
--- a/vortex-duckdb/cpp/logical_type.cpp
+++ b/vortex-duckdb/cpp/logical_type.cpp
@@ -1,12 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/types.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 #include "duckdb_vx/logical_type.h"
 
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/types.hpp"
+DUCKDB_INCLUDES_END
 #include <cassert>
 
 duckdb_logical_type duckdb_vx_logical_type_copy(duckdb_logical_type ty) {
diff --git a/vortex-duckdb/cpp/object_cache.cpp b/vortex-duckdb/cpp/object_cache.cpp
index ffa315385eb..e2ddb34d510 100644
--- a/vortex-duckdb/cpp/object_cache.cpp
+++ b/vortex-duckdb/cpp/object_cache.cpp
@@ -2,7 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #include "duckdb_vx.h"
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/storage/object_cache.hpp"
+DUCKDB_INCLUDES_END
 
 #include <iostream>
 
@@ -12,11 +16,17 @@ namespace vortex {
 class OpaqueWrapper : public duckdb::ObjectCacheEntry {
 public:
     duckdb::unique_ptr<void, duckdb_vx_deleter_fn> ptr;
+    duckdb::optional_idx estimated_size;
 
-    explicit OpaqueWrapper(void *p, duckdb_vx_deleter_fn del) : ptr(p, del) {
+    explicit OpaqueWrapper(void *p, duckdb::optional_idx estimated_size, duckdb_vx_deleter_fn del)
+        : ptr(p, del), estimated_size(estimated_size) {
     }
     ~OpaqueWrapper() override = default;
 
+    duckdb::optional_idx GetEstimatedCacheMemory() const override {
+        return estimated_size;
+    }
+
     duckdb::string GetObjectType() override {
         return "vortex_opaque_wrapper";
     }
@@ -32,9 +42,11 @@ class OpaqueWrapper : public duckdb::ObjectCacheEntry {
 extern "C" void duckdb_vx_object_cache_put(duckdb_vx_object_cache cache,
                                            const char *key,
                                            void *value,
+                                           uint64_t estimated_size,
                                            duckdb_vx_deleter_fn deleter) {
     auto object_cache = reinterpret_cast<duckdb::ObjectCache *>(cache);
-    auto wrapper = duckdb::make_shared_ptr<vortex::OpaqueWrapper>(value, deleter);
+    auto wrapper =
+        duckdb::make_shared_ptr<vortex::OpaqueWrapper>(value, duckdb::optional_idx(estimated_size), deleter);
     object_cache->Put(std::string(key), wrapper);
 }
 
diff --git a/vortex-duckdb/cpp/replacement_scan.cpp b/vortex-duckdb/cpp/replacement_scan.cpp
index 14562091243..62553f1ce4c 100644
--- a/vortex-duckdb/cpp/replacement_scan.cpp
+++ b/vortex-duckdb/cpp/replacement_scan.cpp
@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 
@@ -13,7 +17,7 @@ namespace vortex {
 static duckdb::unique_ptr<duckdb::TableRef>
 VortexScanReplacement(duckdb::ClientContext &context,
                       duckdb::ReplacementScanInput &input,
-                      duckdb::optional_ptr<duckdb::ReplacementScanData> data) {
+                      duckdb::optional_ptr<duckdb::ReplacementScanData> /*data*/) {
     auto table_name = duckdb::ReplacementScan::GetFullPath(input);
     if (!duckdb::ReplacementScan::CanReplace(table_name, {"vortex"})) {
         return nullptr;
diff --git a/vortex-duckdb/cpp/reusable_dict.cpp b/vortex-duckdb/cpp/reusable_dict.cpp
new file mode 100644
index 00000000000..9e905104813
--- /dev/null
+++ b/vortex-duckdb/cpp/reusable_dict.cpp
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+DUCKDB_INCLUDES_BEGIN
+#include "duckdb/common/types/vector.hpp"
+DUCKDB_INCLUDES_END
+#include "duckdb_vx.h"
+
+using namespace duckdb;
+
+// buffer_ptr is shared_ptr, two pointers long, but duckdb_vx_reusable_dict is
+// one pointer long, so we need a wrapper.
+using Buffer = buffer_ptr<VectorChildBuffer>;
+struct ReusableDict {
+    Buffer buffer;
+    ReusableDict(Buffer buffer) : buffer(std::move(buffer)) {
+    }
+};
+
+extern "C" duckdb_vx_reusable_dict duckdb_vx_reusable_dict_create(duckdb_logical_type ffi_type, idx_t size) {
+    const LogicalType &type = *reinterpret_cast<LogicalType *>(ffi_type);
+    auto buffer = DictionaryVector::CreateReusableDictionary(type, size);
+    auto ptr = std::make_unique<ReusableDict>(std::move(buffer));
+    return reinterpret_cast<duckdb_vx_reusable_dict>(ptr.release());
+}
+
+extern "C" void duckdb_vx_reusable_dict_destroy(duckdb_vx_reusable_dict *dict) {
+    if (dict && *dict) {
+        delete reinterpret_cast<ReusableDict *>(*dict);
+    }
+}
+
+extern "C" duckdb_vx_reusable_dict duckdb_vx_reusable_dict_clone(duckdb_vx_reusable_dict dict) {
+    ReusableDict *wrapper = reinterpret_cast<ReusableDict *>(dict);
+    auto ptr = std::make_unique<ReusableDict>(wrapper->buffer);
+    return reinterpret_cast<duckdb_vx_reusable_dict>(ptr.release());
+}
+
+extern "C" void duckdb_vx_reusable_dict_set_vector(duckdb_vx_reusable_dict reusable,
+                                                   duckdb_vector *out_vector) {
+    auto *wrapper = reinterpret_cast<ReusableDict *>(reusable);
+    *out_vector = reinterpret_cast<duckdb_vector>(&wrapper->buffer->data);
+}
+
+extern "C" void duckdb_vx_vector_dictionary_reusable(duckdb_vector ffi_vector,
+                                                     duckdb_vx_reusable_dict reusable,
+                                                     duckdb_selection_vector ffi_sel_vec) {
+    auto vector = reinterpret_cast<Vector *>(ffi_vector);
+    auto *wrapper = reinterpret_cast<ReusableDict *>(reusable);
+    auto sel_vec = reinterpret_cast<SelectionVector *>(ffi_sel_vec);
+    vector->Dictionary(wrapper->buffer, *sel_vec);
+}
diff --git a/vortex-duckdb/cpp/scalar_function.cpp b/vortex-duckdb/cpp/scalar_function.cpp
index 5c692e1b090..6979ccd6e60 100644
--- a/vortex-duckdb/cpp/scalar_function.cpp
+++ b/vortex-duckdb/cpp/scalar_function.cpp
@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/function/scalar_function.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 
diff --git a/vortex-duckdb/cpp/table_filter.cpp b/vortex-duckdb/cpp/table_filter.cpp
index da39a884672..5de7776c3a7 100644
--- a/vortex-duckdb/cpp/table_filter.cpp
+++ b/vortex-duckdb/cpp/table_filter.cpp
@@ -1,14 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-#include "duckdb/planner/table_filter.hpp"
 #include "duckdb_vx.h"
+
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
+#include "duckdb/planner/table_filter.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/planner/filter/dynamic_filter.hpp"
 #include "duckdb/planner/filter/optional_filter.hpp"
 #include "duckdb/planner/filter/expression_filter.hpp"
 #include "duckdb/planner/filter/struct_filter.hpp"
 #include "duckdb/planner/filter/in_filter.hpp"
+DUCKDB_INCLUDES_END
 
 using namespace duckdb;
 
diff --git a/vortex-duckdb/cpp/table_function.cpp b/vortex-duckdb/cpp/table_function.cpp
index d8f96287f7d..fc4ac1b66da 100644
--- a/vortex-duckdb/cpp/table_function.cpp
+++ b/vortex-duckdb/cpp/table_function.cpp
@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb.h"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/insertion_order_preserving_map.hpp"
+#include "duckdb/function/table_function.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/connection.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/insertion_order_preserving_map.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb_vx/data.hpp"
 #include "duckdb_vx/error.hpp"
 
@@ -180,8 +184,8 @@ void c_function(ClientContext &context, TableFunctionInput &input, DataChunk &ou
     }
 }
 
-void c_pushdown_complex_filter(ClientContext &context,
-                               LogicalGet &get,
+void c_pushdown_complex_filter(ClientContext & /*context*/,
+                               LogicalGet & /*get*/,
                                FunctionData *bind_data,
                                vector<unique_ptr<Expression>> &filters) {
     if (filters.empty()) {
@@ -200,22 +204,18 @@ void c_pushdown_complex_filter(ClientContext &context,
             throw BinderException(IntoErrString(error_out));
         }
 
-        if (pushed) {
-            // If the pushdown complex filter returns true, we can remove the filter from the list.
-            iter = filters.erase(iter);
-        } else {
-            ++iter;
-        }
+        // If the pushdown complex filter returns true, we can remove the filter from the list.
+        iter = pushed ? filters.erase(iter) : std::next(iter);
     }
 }
 
-unique_ptr<NodeStatistics> c_cardinality(ClientContext &context, const FunctionData *bind_data) {
+unique_ptr<NodeStatistics> c_cardinality(ClientContext & /*context*/, const FunctionData *bind_data) {
     auto &bind = bind_data->Cast<CTableBindData>();
 
     duckdb_vx_node_statistics node_stats_out = {
         .estimated_cardinality = 0,
-        .has_estimated_cardinality = false,
         .max_cardinality = 0,
+        .has_estimated_cardinality = false,
         .has_max_cardinality = false,
     };
     bind.info->vtab.cardinality(bind_data->Cast<CTableBindData>().ffi_data->DataPtr(), &node_stats_out);
@@ -253,11 +253,10 @@ extern "C" duckdb_value duckdb_vx_tfunc_bind_input_get_named_parameter(duckdb_vx
     }
     const auto info = reinterpret_cast<TableFunctionBindInput *>(ffi_input);
 
-    auto t = info->named_parameters.find(name);
-    if (t == info->named_parameters.end()) {
+    if (!info->named_parameters.contains(name)) {
         return nullptr;
     }
-    auto value = duckdb::make_uniq<Value>(t->second);
+    auto value = duckdb::make_uniq<Value>(info->named_parameters.at(name));
     return reinterpret_cast<duckdb_value>(value.release());
 }
 
@@ -275,7 +274,8 @@ extern "C" void duckdb_vx_tfunc_bind_result_add_column(duckdb_vx_tfunc_bind_resu
     result->return_types.emplace_back(*logical_type);
 }
 
-virtual_column_map_t c_get_virtual_columns(ClientContext &context, optional_ptr<FunctionData> bind_data) {
+virtual_column_map_t c_get_virtual_columns(ClientContext & /*context*/,
+                                           optional_ptr<FunctionData> bind_data) {
     auto &bind = bind_data->Cast<CTableBindData>();
 
     auto result = virtual_column_map_t();
@@ -301,7 +301,8 @@ extern "C" void duckdb_vx_tfunc_virtual_columns_push(duckdb_vx_tfunc_virtual_col
     result->emplace(column_idx, std::move(table_col));
 }
 
-OperatorPartitionData c_get_partition_data(ClientContext &context, TableFunctionGetPartitionInput &input) {
+OperatorPartitionData c_get_partition_data(ClientContext & /*context*/,
+                                           TableFunctionGetPartitionInput &input) {
     if (input.partition_info.RequiresPartitionColumns()) {
         throw InternalException("TableScan::GetPartitionData: partition columns not supported");
     }
diff --git a/vortex-duckdb/cpp/value.cpp b/vortex-duckdb/cpp/value.cpp
index 8a0772a2650..61e96131aff 100644
--- a/vortex-duckdb/cpp/value.cpp
+++ b/vortex-duckdb/cpp/value.cpp
@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/types/value.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 
diff --git a/vortex-duckdb/cpp/vector.cpp b/vortex-duckdb/cpp/vector.cpp
index 261bb9ac672..3b6439f4c95 100644
--- a/vortex-duckdb/cpp/vector.cpp
+++ b/vortex-duckdb/cpp/vector.cpp
@@ -1,9 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/types/vector.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 #include "duckdb_vx/vector_buffer.hpp"
@@ -29,11 +33,6 @@ extern "C" void duckdb_vx_vector_dictionary(duckdb_vector ffi_vector,
     vector->Dictionary(*dict, dictionary_size, *sel_vec, count);
 }
 
-extern "C" void duckdb_vx_set_dictionary_vector_id(duckdb_vector dict, const char *id, unsigned int id_len) {
-    auto ddict = reinterpret_cast<duckdb::Vector *>(dict);
-    DictionaryVector::SetDictionaryId(*ddict, std::string(id, id_len));
-}
-
 extern "C" void duckdb_vx_set_dictionary_vector_length(duckdb_vector dict, unsigned int len) {
     auto ddict = reinterpret_cast<duckdb::Vector *>(dict);
     ddict->GetBuffer()->Cast<DictionaryBuffer>().SetDictionarySize(len);
diff --git a/vortex-duckdb/cpp/vector_buffer.cpp b/vortex-duckdb/cpp/vector_buffer.cpp
index 908db60b467..75abf0daff9 100644
--- a/vortex-duckdb/cpp/vector_buffer.cpp
+++ b/vortex-duckdb/cpp/vector_buffer.cpp
@@ -1,8 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb_vx/duckdb_diagnostics.h"
+
+DUCKDB_INCLUDES_BEGIN
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/types/vector.hpp"
+DUCKDB_INCLUDES_END
 
 #include "duckdb_vx.h"
 #include "duckdb_vx/data.hpp"
diff --git a/vortex-duckdb/include/vortex.h b/vortex-duckdb/include/vortex.h
index 988ed343b75..7148c4d9799 100644
--- a/vortex-duckdb/include/vortex.h
+++ b/vortex-duckdb/include/vortex.h
@@ -14,8 +14,6 @@ extern "C" {
 #include "duckdb.h"
 
 
-#define DUCKDB_STANDARD_VECTOR_SIZE 2048
-
 /**
  * Global symbol visibility in the Vortex extension:
  * - Rust functions use C ABI with "_rust" suffix (e.g., vortex_init_rust)
diff --git a/vortex-duckdb/src/convert/dtype.rs b/vortex-duckdb/src/convert/dtype.rs
index aeffa40140b..ad66787f02e 100644
--- a/vortex-duckdb/src/convert/dtype.rs
+++ b/vortex-duckdb/src/convert/dtype.rs
@@ -236,6 +236,9 @@ impl TryFrom<&DType> for LogicalType {
                 let element_logical_type = LogicalType::try_from(element_dtype.as_ref())?;
                 return LogicalType::array_type(element_logical_type, *list_size);
             }
+            DType::Variant(_) => {
+                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());
@@ -591,18 +594,12 @@ mod tests {
                 Ok(EmptyMetadata)
             }
 
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
+            fn validate_dtype(_ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
                 Ok(())
             }
 
             fn unpack_native<'a>(
-                &self,
-                _metadata: &'a Self::Metadata,
-                _storage_dtype: &'a DType,
+                _ext_dtype: &'a ExtDType<Self>,
                 _storage_value: &'a ScalarValue,
             ) -> VortexResult<Self::NativeValue<'a>> {
                 Ok("")
diff --git a/vortex-duckdb/src/convert/expr.rs b/vortex-duckdb/src/convert/expr.rs
index c2d5a37813d..80d92ede449 100644
--- a/vortex-duckdb/src/convert/expr.rs
+++ b/vortex-duckdb/src/convert/expr.rs
@@ -3,7 +3,6 @@
 
 use std::sync::Arc;
 
-use itertools::Itertools;
 use tracing::debug;
 use vortex::dtype::Nullability;
 use vortex::error::VortexError;
@@ -97,7 +96,7 @@ pub fn try_from_bound_expression(
             DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_OPERATOR_NOT
             | DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_OPERATOR_IS_NULL
             | DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_OPERATOR_IS_NOT_NULL => {
-                let children = operator.children().collect_vec();
+                let children: Vec<_> = operator.children().collect();
                 assert_eq!(children.len(), 1);
                 let Some(child) = try_from_bound_expression(children[0])? else {
                     return Ok(None);
@@ -113,7 +112,7 @@ pub fn try_from_bound_expression(
             }
             DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_COMPARE_IN => {
                 // First child is element, rest form the list.
-                let children = operator.children().collect_vec();
+                let children: Vec<_> = operator.children().collect();
                 assert!(children.len() >= 2);
                 let Some(element) = try_from_bound_expression(children[0])? else {
                     return Ok(None);
@@ -153,7 +152,7 @@ pub fn try_from_bound_expression(
         },
         duckdb::ExpressionClass::BoundFunction(func) => match func.scalar_function.name() {
             DUCKDB_FUNCTION_NAME_CONTAINS => {
-                let children = func.children().collect_vec();
+                let children: Vec<_> = func.children().collect();
                 assert_eq!(children.len(), 2);
                 let Some(value) = try_from_bound_expression(children[0])? else {
                     return Ok(None);
diff --git a/vortex-duckdb/src/convert/scalar.rs b/vortex-duckdb/src/convert/scalar.rs
index 97f788dd39d..8a9da564127 100644
--- a/vortex-duckdb/src/convert/scalar.rs
+++ b/vortex-duckdb/src/convert/scalar.rs
@@ -79,6 +79,9 @@ impl ToDuckDBScalar for Scalar {
             DType::Utf8(_) => self.as_utf8().try_to_duckdb_scalar(),
             DType::Binary(_) => self.as_binary().try_to_duckdb_scalar(),
             DType::Struct(..) | DType::List(..) | DType::FixedSizeList(..) => todo!(),
+            DType::Variant(_) => {
+                vortex_bail!("Vortex Variant scalars aren't supported in DuckDB")
+            }
         }
     }
 }
@@ -253,6 +256,9 @@ impl<'a> TryFrom<&'a ValueRef> for Scalar {
             ExtractedValue::HugeInt(_) => {
                 vortex_bail!("DuckDB HugeInt is not yet supported in Vortex");
             }
+            ExtractedValue::UHugeInt(_) => {
+                vortex_bail!("DuckDB UHugeInt is not yet supported in Vortex");
+            }
             ExtractedValue::UTinyInt(v) => Ok(Scalar::primitive(v, Nullable)),
             ExtractedValue::USmallInt(v) => Ok(Scalar::primitive(v, Nullable)),
             ExtractedValue::UInteger(v) => Ok(Scalar::primitive(v, Nullable)),
diff --git a/vortex-duckdb/src/convert/table_filter.rs b/vortex-duckdb/src/convert/table_filter.rs
index 702cdef695e..7741fd64d0a 100644
--- a/vortex-duckdb/src/convert/table_filter.rs
+++ b/vortex-duckdb/src/convert/table_filter.rs
@@ -120,5 +120,8 @@ pub fn try_from_table_filter(
             // TODO(ngates): figure out which column ID DuckDB is using for the expression.
             vortex_bail!("expression table filter is not supported: {}", expr);
         }
+        TableFilterClass::Bloom => {
+            vortex_bail!("bloom filter table filter is not supported")
+        }
     }))
 }
diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs
index 437fcde2089..029a5ae0638 100644
--- a/vortex-duckdb/src/convert/vector.rs
+++ b/vortex-duckdb/src/convert/vector.rs
@@ -29,6 +29,7 @@ use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::extension::datetime::TimeUnit;
+use vortex::mask::Mask;
 
 use crate::cpp::DUCKDB_TYPE;
 use crate::cpp::duckdb_date;
@@ -149,14 +150,14 @@ fn convert_valid_list_entry(
 ///    downstream operations like converting `ListView` to `List`.
 fn process_duckdb_lists(
     entries: &[duckdb_list_entry],
-    validity: &Validity,
-) -> (Buffer<i64>, Buffer<i64>, usize) {
+    validity: &Mask,
+) -> VortexResult<(Buffer<i64>, Buffer<i64>, usize)> {
     let len = entries.len();
     let mut offsets = BufferMut::with_capacity(len);
     let mut sizes = BufferMut::with_capacity(len);
 
     match validity {
-        Validity::NonNullable | Validity::AllValid => {
+        Mask::AllTrue(_) => {
             // All entries are valid, so there is no need to check the validity.
             let mut child_min_length = 0;
             let mut previous_end = 0;
@@ -170,41 +171,37 @@ fn process_duckdb_lists(
                     sizes.push_unchecked(size);
                 }
             }
-            (offsets.freeze(), sizes.freeze(), child_min_length)
+            Ok((offsets.freeze(), sizes.freeze(), child_min_length))
         }
-        Validity::AllInvalid => {
+        Mask::AllFalse(_) => {
             // All entries are null, so we can just set offset=0 and size=0.
             // SAFETY: We allocated enough capacity above.
             unsafe {
                 offsets.push_n_unchecked(0, len);
                 sizes.push_n_unchecked(0, len);
             }
-            (offsets.freeze(), sizes.freeze(), 0)
+            Ok((offsets.freeze(), sizes.freeze(), 0))
         }
-        Validity::Array(_) => {
+        Mask::Values(values) => {
             // We have some number of nulls, so make sure to check validity before updating info.
-            let mask = validity.to_mask(len);
-            let child_min_length = mask.iter_bools(|validity_iter| {
-                let mut child_min_length = 0;
-                let mut previous_end = 0;
-
-                for (entry, is_valid) in entries.iter().zip(validity_iter) {
-                    let (offset, size) = if is_valid {
-                        convert_valid_list_entry(entry, &mut child_min_length, &mut previous_end)
-                    } else {
-                        (previous_end, 0)
-                    };
-
-                    // SAFETY: We allocated enough capacity above.
-                    unsafe {
-                        offsets.push_unchecked(offset);
-                        sizes.push_unchecked(size);
-                    }
+            let mut child_min_length = 0;
+            let mut previous_end = 0;
+
+            for (entry, is_valid) in entries.iter().zip(values.bit_buffer().iter()) {
+                let (offset, size) = if is_valid {
+                    convert_valid_list_entry(entry, &mut child_min_length, &mut previous_end)
+                } else {
+                    (previous_end, 0)
+                };
+
+                // SAFETY: We allocated enough capacity above.
+                unsafe {
+                    offsets.push_unchecked(offset);
+                    sizes.push_unchecked(size);
                 }
+            }
 
-                child_min_length
-            });
-            (offsets.freeze(), sizes.freeze(), child_min_length)
+            Ok((offsets.freeze(), sizes.freeze(), child_min_length))
         }
     }
 }
@@ -321,10 +318,10 @@ pub fn flat_vector_to_vortex(vector: &VectorRef, len: usize) -> VortexResult<Arr
             .map(|a| a.into_array())
         }
         DUCKDB_TYPE::DUCKDB_TYPE_LIST => {
-            let validity = vector.validity_ref(len).to_validity();
+            let validity = vector.validity_ref(len).to_mask();
             let entries = vector.as_slice_with_len::<duckdb_list_entry>(len);
 
-            let (offsets, sizes, child_min_length) = process_duckdb_lists(entries, &validity);
+            let (offsets, sizes, child_min_length) = process_duckdb_lists(entries, &validity)?;
             let child_data =
                 flat_vector_to_vortex(vector.list_vector_get_child(), child_min_length)?;
 
@@ -332,7 +329,7 @@ pub fn flat_vector_to_vortex(vector: &VectorRef, len: usize) -> VortexResult<Arr
                 child_data,
                 offsets.into_array(),
                 sizes.into_array(),
-                validity,
+                Validity::from_mask(validity, Nullability::Nullable),
             )
             .map(|a| a.into_array())
         }
@@ -348,7 +345,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())
         }
-        _ => todo!("missing impl for {type_id:?}"),
+        _ => unimplemented!("missing impl for {type_id:?}"),
     }
 }
 
@@ -371,7 +368,7 @@ pub fn data_chunk_to_vortex(
         len.as_(),
         Validity::NonNullable,
     )
-    .map(|a| a.to_array())
+    .map(|a| a.into_array())
 }
 
 #[cfg(test)]
@@ -380,9 +377,12 @@ mod tests {
 
     use vortex::array::ToCanonical;
     use vortex::array::arrays::BoolArray;
+    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_array::assert_arrays_eq;
 
     use super::*;
     use crate::cpp::DUCKDB_TYPE;
@@ -689,7 +689,7 @@ mod tests {
         let vortex_array = result.to_struct();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(vortex_array.unmasked_fields().len(), 0);
+        assert_eq!(vortex_array.struct_fields().nfields(), 0);
     }
 
     #[test]
@@ -724,13 +724,13 @@ mod tests {
         let vortex_array = result.to_struct();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(vortex_array.unmasked_fields().len(), 2);
+        assert_eq!(vortex_array.struct_fields().nfields(), 2);
         assert_arrays_eq!(
-            &vortex_array.unmasked_fields()[0],
+            vortex_array.unmasked_field(0),
             PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)])
         );
         assert_arrays_eq!(
-            &vortex_array.unmasked_fields()[1],
+            vortex_array.unmasked_field(1),
             PrimitiveArray::from_option_iter([Some(5i32), Some(6), Some(7), Some(8)])
         );
     }
diff --git a/vortex-duckdb/src/copy.rs b/vortex-duckdb/src/copy.rs
index 886d2517340..c1af6869d39 100644
--- a/vortex-duckdb/src/copy.rs
+++ b/vortex-duckdb/src/copy.rs
@@ -95,7 +95,7 @@ impl CopyFunction for VortexCopyFunction {
             .clone();
         RUNTIME
             .block_on(sink.send(chunk))
-            .map_err(|e| vortex_err!("send error {}", e.to_string()))?;
+            .map_err(|e| vortex_err!("send error {e}"))?;
         Ok(())
     }
 
@@ -130,13 +130,13 @@ impl CopyFunction for VortexCopyFunction {
         // SAFETY: The ClientContext is owned by the Connection and lives for the duration of
         // query execution. DuckDB keeps the connection alive while this copy function runs.
         let ctx = unsafe { client_context.erase_lifetime() };
-        let write_task = handle.spawn(async move {
-            // Use DuckDB FS exclusively to match the DuckDB client context configuration.
-            let writer = DuckDbFsWriter::new(ctx, &file_path).map_err(|e| {
-                vortex_err!("Failed to create DuckDB FS writer for {file_path}: {e}")
-            })?;
-            SESSION.write_options().write(writer, array_stream).await
-        });
+
+        // Use DuckDB FS exclusively to match the DuckDB client context configuration.
+        let writer = DuckDbFsWriter::new(ctx, &file_path)
+            .map_err(|e| vortex_err!("Failed to create DuckDB FS writer for {file_path}: {e}"))?;
+
+        let write_task =
+            handle.spawn(async move { SESSION.write_options().write(writer, array_stream).await });
 
         let worker_pool = RUNTIME.new_pool();
         worker_pool.set_workers_to_available_parallelism();
diff --git a/vortex-duckdb/src/datasource.rs b/vortex-duckdb/src/datasource.rs
index b958e247f3d..fe6336d3856 100644
--- a/vortex-duckdb/src/datasource.rs
+++ b/vortex-duckdb/src/datasource.rs
@@ -17,12 +17,14 @@ use custom_labels::CURRENT_LABELSET;
 use futures::StreamExt;
 use itertools::Itertools;
 use num_traits::AsPrimitive;
+use tracing::debug;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::ScalarFnVTable;
+use vortex::array::arrays::Struct;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::StructVTable;
+use vortex::array::arrays::scalar_fn::ScalarFnArrayExt;
 use vortex::array::optimizer::ArrayOptimizer;
 use vortex::dtype::DType;
 use vortex::dtype::FieldNames;
@@ -40,8 +42,8 @@ use vortex::io::runtime::BlockingRuntime;
 use vortex::io::runtime::current::ThreadSafeIterator;
 use vortex::metrics::tracing::get_global_labels;
 use vortex::scalar_fn::fns::pack::Pack;
-use vortex::scan::api::DataSourceRef;
-use vortex::scan::api::ScanRequest;
+use vortex::scan::DataSourceRef;
+use vortex::scan::ScanRequest;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::RUNTIME;
@@ -62,10 +64,19 @@ use crate::duckdb::VirtualColumnsResultRef;
 use crate::exporter::ArrayExporter;
 use crate::exporter::ConversionCache;
 
-// taken from duckdb/common/constants.h COLUMN_IDENTIFIER_EMPTY
-// This is used by duckdb whenever there is no projection id in a logical_get node.
-// For some reason we cannot return an empty DataChunk and duckdb will look for the virtual column
-// with this index and create a data chunk with a single vector of that type.
+/// Taken from
+/// https://github.com/duckdb/duckdb/blob/dc11eadd8f0a7c600f0034810706605ebe10d5b9/src/include/duckdb/common/constants.hpp#L44
+///
+/// If DuckDB requests a zero-column projection from read_vortex like count(*),
+/// its planner tries to get any column:
+/// https://github.com/duckdb/duckdb/blob/dc11eadd8f0a7c600f0034810706605ebe10d5b9/src/planner/operator/logical_get.cpp#L149
+///
+/// If you define COLUMN_IDENTIFIER_EMPTY, planner takes it, otherwise the
+/// first column. As we don't want to fill the output chunk and we can leave
+/// it uninitialized in this case, we define COLUMN_IDENTIFIER_EMPTY as a
+/// virtual column in our table function vtab's get_virtual_columns.
+/// See vortex-duckdb/cpp/include/duckdb_vx/table_function.h
+/// See virtual_columns in this file
 static EMPTY_COLUMN_IDX: u64 = 18446744073709551614;
 static EMPTY_COLUMN_NAME: &str = "";
 
@@ -100,7 +111,7 @@ pub struct DataSourceBindData {
 impl Clone for DataSourceBindData {
     fn clone(&self) -> Self {
         Self {
-            data_source: self.data_source.clone(),
+            data_source: Arc::clone(&self.data_source),
             // filter_exprs are consumed once in `init_global`.
             filter_exprs: vec![],
             column_names: self.column_names.clone(),
@@ -120,15 +131,17 @@ impl Debug for DataSourceBindData {
                     .filter_exprs
                     .iter()
                     .map(|e| e.to_string())
-                    .collect_vec(),
+                    .collect::<Vec<String>>(),
             )
             .finish()
     }
 }
 
+type DataSourceIterator = ThreadSafeIterator<VortexResult<(ArrayRef, Arc<ConversionCache>)>>;
+
 /// Global scan state for driving a `DataSource` scan through DuckDB.
 pub struct DataSourceGlobal {
-    iterator: ThreadSafeIterator<VortexResult<(ArrayRef, Arc<ConversionCache>)>>,
+    iterator: DataSourceIterator,
     batch_id: AtomicU64,
     bytes_total: Arc<AtomicU64>,
     bytes_read: AtomicU64,
@@ -136,7 +149,7 @@ pub struct DataSourceGlobal {
 
 /// Per-thread local scan state.
 pub struct DataSourceLocal {
-    iterator: ThreadSafeIterator<VortexResult<(ArrayRef, Arc<ConversionCache>)>>,
+    iterator: DataSourceIterator,
     exporter: Option<ArrayExporter>,
     /// The unique batch id of the last chunk exported via scan().
     batch_id: Option<u64>,
@@ -193,9 +206,11 @@ impl<T: DataSourceTableFunction> TableFunction for T {
     }
 
     fn init_global(init_input: &TableInitInput<Self>) -> VortexResult<Self::GlobalState> {
+        debug!("table init input: {init_input:?}");
+
         let bind_data = init_input.bind_data();
-        let projection_ids = init_input.projection_ids().unwrap_or(&[]);
         let column_ids = init_input.column_ids();
+        let projection_ids = init_input.projection_ids();
 
         let projection_expr =
             extract_projection_expr(projection_ids, column_ids, &bind_data.column_names);
@@ -207,13 +222,10 @@ impl<T: DataSourceTableFunction> TableFunction for T {
             bind_data.data_source.dtype(),
         )?;
 
-        tracing::debug!(
-            "Global init Vortex scan SELECT {} WHERE {}",
-            &projection_expr,
-            filter_expr
-                .as_ref()
-                .map_or_else(|| "true".to_string(), |f| f.to_string())
-        );
+        let filter_expr_str = filter_expr
+            .as_ref()
+            .map_or_else(|| "true".to_string(), |f| f.to_string());
+        debug!("Global init Vortex scan SELECT {projection_expr} WHERE {filter_expr_str}");
 
         let request = ScanRequest {
             projection: projection_expr,
@@ -253,7 +265,11 @@ impl<T: DataSourceTableFunction> TableFunction for T {
                         }
                     };
                     while let Some(item) = stream.next().await {
-                        if tx.send(item.map(|a| (a, cache.clone()))).await.is_err() {
+                        if tx
+                            .send(item.map(|a| (a, Arc::clone(&cache))))
+                            .await
+                            .is_err()
+                        {
                             // Exit early if the receiver has been dropped, which happens when the
                             // scan is complete or if an error has occurred in another partition.
                             return;
@@ -316,10 +332,11 @@ impl<T: DataSourceTableFunction> TableFunction for T {
                     return Ok(());
                 };
                 let (array_result, conversion_cache) = result?;
-
                 let array_result = array_result.optimize_recursive()?;
-                let array_result = if let Some(array) = array_result.as_opt::<StructVTable>() {
-                    array.clone()
+
+                let array_result: StructArray = if let Some(array) = array_result.as_opt::<Struct>()
+                {
+                    array.into_owned()
                 } else if let Some(array) = array_result.as_opt::<ScalarFnVTable>()
                     && let Some(pack_options) = array.scalar_fn().as_opt::<Pack>()
                 {
@@ -455,27 +472,36 @@ fn extract_schema_from_dtype(dtype: &DType) -> VortexResult<(Vec<String>, Vec<Lo
 
 /// Creates a projection expression from raw projection/column ID slices and column names.
 fn extract_projection_expr(
-    projection_ids: &[u64],
+    projection_ids: Option<&[u64]>,
     column_ids: &[u64],
     column_names: &[String],
 ) -> Expression {
-    select(
-        projection_ids
-            .iter()
-            .map(|p| {
-                let idx: usize = p.as_();
-                let val: usize = column_ids[idx].as_();
-                val
-            })
-            .map(|idx| {
-                column_names
-                    .get(idx)
-                    .vortex_expect("prune idx in column names")
-            })
-            .map(|s| Arc::from(s.as_str()))
-            .collect::<FieldNames>(),
-        root(),
-    )
+    // Projection ids may be empty, in which case you need to use projection_ids
+    // https://github.com/duckdb/duckdb/blob/6e211da91657a94803c465fd0ce585f4c6754b54/src/planner/operator/logical_get.cpp#L168
+    let (projection_ids, has_projection_ids) = match projection_ids {
+        Some(ids) => (ids, true),
+        None => (column_ids, false),
+    };
+
+    // duckdb index is u64 (size_t) but in Rust u64 and usize are different things.
+    #[allow(clippy::cast_possible_truncation)]
+    let names = projection_ids
+        .iter()
+        .filter(|p| **p != EMPTY_COLUMN_IDX)
+        .map(|mut idx| {
+            if has_projection_ids {
+                idx = &column_ids[*idx as usize];
+            }
+
+            #[allow(clippy::cast_possible_truncation)]
+            column_names
+                .get(*idx as usize)
+                .vortex_expect("prune idx in column names")
+        })
+        .map(|s| Arc::from(s.as_str()))
+        .collect::<FieldNames>();
+
+    select(names, root())
 }
 
 /// Creates a table filter expression from the table filter set, column metadata, additional
@@ -503,7 +529,7 @@ fn extract_table_filter_expr(
     };
 
     table_filter_exprs.extend(additional_filters.iter().cloned());
-    Ok(and_collect(table_filter_exprs.into_iter().collect_vec()))
+    Ok(and_collect(table_filter_exprs))
 }
 
 #[cfg(test)]
diff --git a/vortex-duckdb/src/duckdb/copy_function/callback.rs b/vortex-duckdb/src/duckdb/copy_function/callback.rs
index 9b6360ae792..0bc303fe1cb 100644
--- a/vortex-duckdb/src/duckdb/copy_function/callback.rs
+++ b/vortex-duckdb/src/duckdb/copy_function/callback.rs
@@ -6,7 +6,6 @@ use std::os::raw::c_char;
 use std::os::raw::c_ulong;
 use std::os::raw::c_void;
 
-use itertools::Itertools;
 use num_traits::AsPrimitive;
 use vortex::error::VortexExpect;
 
@@ -39,12 +38,12 @@ pub(crate) unsafe extern "C-unwind" fn bind_callback<T: CopyFunction>(
                 .to_string_lossy()
                 .into_owned()
         })
-        .collect_vec();
+        .collect();
 
     let column_types = unsafe { std::slice::from_raw_parts(column_types, column_type_count.as_()) }
         .iter()
         .map(|c| unsafe { LogicalType::borrow(*c) })
-        .collect_vec();
+        .collect();
 
     try_or_null(error_out, || {
         let bind_data = T::bind(column_names, column_types)?;
diff --git a/vortex-duckdb/src/duckdb/data_chunk.rs b/vortex-duckdb/src/duckdb/data_chunk.rs
index ff3d0b259f3..dce2a5637bf 100644
--- a/vortex-duckdb/src/duckdb/data_chunk.rs
+++ b/vortex-duckdb/src/duckdb/data_chunk.rs
@@ -44,6 +44,10 @@ impl DataChunkRef {
             .vortex_expect("Column count exceeds usize")
     }
 
+    pub fn reset(&mut self) {
+        unsafe { cpp::duckdb_data_chunk_reset(self.as_ptr()) }
+    }
+
     /// Set the length of the data chunk.
     pub fn set_len(&mut self, len: usize) {
         unsafe { cpp::duckdb_data_chunk_set_size(self.as_ptr(), len as _) }
diff --git a/vortex-duckdb/src/duckdb/file_system.rs b/vortex-duckdb/src/duckdb/file_system.rs
index 6de8079d17f..a3c76af633d 100644
--- a/vortex-duckdb/src/duckdb/file_system.rs
+++ b/vortex-duckdb/src/duckdb/file_system.rs
@@ -39,14 +39,15 @@ pub(crate) fn fs_error(err: cpp::duckdb_vx_error) -> VortexError {
 
 /// An entry returned by [`duckdb_fs_list_dir`].
 pub(crate) struct DirEntry {
+    /// Full path for S3 files, relative path for local files
     pub name: String,
     pub is_dir: bool,
 }
 
 /// Non-recursively list entries in `directory` via DuckDB's filesystem.
 ///
-/// Returns file and subdirectory names (not full paths). The caller is
-/// responsible for joining paths and recursing into subdirectories.
+/// Returns full paths. The caller is responsible for joining paths and
+/// recursing into subdirectories.
 pub(crate) fn duckdb_fs_list_dir(
     ctx: &ClientContextRef,
     directory: &str,
@@ -113,7 +114,7 @@ impl VortexWrite for DuckDbFsWriter {
     async fn write_all<B: IoBuf>(&mut self, buffer: B) -> std::io::Result<B> {
         let len = buffer.bytes_init();
         let offset = self.pos;
-        let handle = self.handle.clone();
+        let handle = Arc::clone(&self.handle);
 
         let runtime = RUNTIME.handle();
         let buffer = runtime
@@ -144,7 +145,7 @@ impl VortexWrite for DuckDbFsWriter {
     }
 
     async fn flush(&mut self) -> std::io::Result<()> {
-        let handle = self.handle.clone();
+        let handle = Arc::clone(&self.handle);
 
         let runtime = RUNTIME.handle();
         runtime
diff --git a/vortex-duckdb/src/duckdb/logical_type.rs b/vortex-duckdb/src/duckdb/logical_type.rs
index 87254348052..851ea2824c3 100644
--- a/vortex-duckdb/src/duckdb/logical_type.rs
+++ b/vortex-duckdb/src/duckdb/logical_type.rs
@@ -166,6 +166,10 @@ impl LogicalType {
     pub fn timestamp_tz() -> Self {
         Self::new(DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_TZ)
     }
+
+    pub fn date() -> Self {
+        Self::new(DUCKDB_TYPE::DUCKDB_TYPE_DATE)
+    }
 }
 
 impl LogicalTypeRef {
@@ -182,6 +186,10 @@ impl LogicalTypeRef {
         }
     }
 
+    pub fn is_decimal(&self) -> bool {
+        matches!(self.as_type_id(), DUCKDB_TYPE::DUCKDB_TYPE_DECIMAL)
+    }
+
     pub fn array_child_type(&self) -> LogicalType {
         unsafe { LogicalType::own(duckdb_array_type_child_type(self.as_ptr())) }
     }
diff --git a/vortex-duckdb/src/duckdb/mod.rs b/vortex-duckdb/src/duckdb/mod.rs
index ec82613fd85..b444a3326da 100644
--- a/vortex-duckdb/src/duckdb/mod.rs
+++ b/vortex-duckdb/src/duckdb/mod.rs
@@ -15,6 +15,7 @@ mod logical_type;
 mod macro_;
 mod object_cache;
 mod query_result;
+mod reusable_dict;
 mod scalar_function;
 mod selection_vector;
 mod table_filter;
@@ -39,6 +40,7 @@ pub use file_system::*;
 pub use logical_type::*;
 pub use object_cache::*;
 pub use query_result::*;
+pub use reusable_dict::*;
 pub use scalar_function::*;
 pub use selection_vector::*;
 pub use table_filter::*;
@@ -51,7 +53,6 @@ use vortex::error::VortexResult;
 use crate::cpp;
 
 /// Try to execute a Rust function, or else return a null pointer and set the error.
-#[inline]
 pub(crate) fn try_or_null<T>(
     error_out: *mut cpp::duckdb_vx_error,
     function: impl FnOnce() -> VortexResult<*mut T>,
@@ -71,7 +72,6 @@ pub(crate) fn try_or_null<T>(
 }
 
 /// Try to execute a Rust function, or else return the default value and set the error.
-#[inline]
 pub(crate) fn try_or<T: Default>(
     error_out: *mut cpp::duckdb_vx_error,
     function: impl FnOnce() -> VortexResult<T>,
diff --git a/vortex-duckdb/src/duckdb/object_cache.rs b/vortex-duckdb/src/duckdb/object_cache.rs
index 89bf6a013e1..4238be061da 100644
--- a/vortex-duckdb/src/duckdb/object_cache.rs
+++ b/vortex-duckdb/src/duckdb/object_cache.rs
@@ -45,11 +45,16 @@ impl ObjectCacheRef {
             .vortex_expect("object cache key should be valid C string");
         let opaque_ptr = Box::into_raw(Box::new(entry));
 
+        // Pass 0 to allow eviction by DuckDB, u64::MAX to prevent eviction, otherwise provide an
+        // estimate of the size of the object in bytes.
+        let estimated_size: u64 = 0;
+
         unsafe {
             cpp::duckdb_vx_object_cache_put(
                 self.as_ptr(),
                 key_cstr.as_ptr(),
-                opaque_ptr.cast(),
+                opaque_ptr as *mut c_void,
+                estimated_size,
                 Some(rust_box_deleter::<T>),
             );
         }
diff --git a/vortex-duckdb/src/duckdb/query_result.rs b/vortex-duckdb/src/duckdb/query_result.rs
index 8c45a37e8ff..02f24c8097d 100644
--- a/vortex-duckdb/src/duckdb/query_result.rs
+++ b/vortex-duckdb/src/duckdb/query_result.rs
@@ -3,11 +3,13 @@
 
 use std::ffi::CStr;
 
+use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
 
 use crate::cpp;
+use crate::cpp::DUCKDB_TYPE;
 use crate::duckdb::DataChunk;
 use crate::lifetime_wrapper;
 
@@ -71,7 +73,15 @@ impl QueryResultRef {
     /// Get the type of a column by index.
     pub fn column_type(&self, col_idx: usize) -> LogicalType {
         let dtype = unsafe { cpp::duckdb_column_type(self.as_ptr(), col_idx as u64) };
-        LogicalType::new(dtype)
+        if dtype == DUCKDB_TYPE::DUCKDB_TYPE_DECIMAL {
+            let lt = unsafe { cpp::duckdb_column_logical_type(self.as_ptr(), col_idx as u64) };
+            let precision = unsafe { cpp::duckdb_decimal_width(lt) };
+            let scale = unsafe { cpp::duckdb_decimal_scale(lt) };
+
+            LogicalType::decimal_type(precision, scale).vortex_expect("valid decimal")
+        } else {
+            LogicalType::new(dtype)
+        }
     }
 }
 
diff --git a/vortex-duckdb/src/duckdb/reusable_dict.rs b/vortex-duckdb/src/duckdb/reusable_dict.rs
new file mode 100644
index 00000000000..a4ce9f77947
--- /dev/null
+++ b/vortex-duckdb/src/duckdb/reusable_dict.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use crate::cpp;
+use crate::duckdb::LogicalType;
+use crate::duckdb::SelectionVector;
+use crate::duckdb::Vector;
+use crate::duckdb::VectorRef;
+use crate::lifetime_wrapper;
+
+lifetime_wrapper!(
+    /// A reusable dictionary buffer that can be used to efficiently create dictionary vectors.
+    ///
+    /// This wraps DuckDB's `buffer_ptr<VectorChildBuffer>` which is created by
+    /// `DictionaryVector::CreateReusableDictionary` and can be reused with
+    /// `Vector::Dictionary` to create dictionary vectors without copying the values.
+    ReusableDict,
+    cpp::duckdb_vx_reusable_dict,
+    cpp::duckdb_vx_reusable_dict_destroy
+);
+
+impl ReusableDict {
+    /// Create a new reusable dictionary from a logical type and size.
+    ///
+    /// The dictionary buffer can be reused with multiple selection vectors
+    /// using `Vector::dictionary_reusable`.
+    pub fn new(logical_type: LogicalType, size: usize) -> Self {
+        unsafe {
+            Self::own(cpp::duckdb_vx_reusable_dict_create(
+                logical_type.as_ptr(),
+                size as _,
+            ))
+        }
+    }
+
+    /// Get the internal vector of the reusable dictionary.
+    ///
+    /// The returned vector is borrowed from this reusable dictionary and can be used
+    /// to populate the dictionary values.
+    pub fn vector(&mut self) -> &mut VectorRef {
+        let mut out_vector = std::ptr::null_mut();
+        unsafe {
+            cpp::duckdb_vx_reusable_dict_set_vector(self.as_ptr(), &raw mut out_vector);
+            Vector::borrow_mut(out_vector)
+        }
+    }
+}
+
+impl Clone for ReusableDict {
+    fn clone(&self) -> Self {
+        unsafe { Self::own(cpp::duckdb_vx_reusable_dict_clone(self.as_ptr())) }
+    }
+}
+
+/// Safety: ReusableDict wraps a DuckDB buffer_ptr which is reference-counted
+/// and thread-safe.
+unsafe impl Send for ReusableDict {}
+unsafe impl Sync for ReusableDict {}
+
+impl VectorRef {
+    /// Creates a dictionary vector using a reusable dictionary and a selection vector.
+    ///
+    /// This is more efficient than `dictionary` when the same dictionary values are
+    /// used multiple times with different selection vectors.
+    pub fn reuse_dictionary(&mut self, reusable: &ReusableDict, sel_vec: &SelectionVector) {
+        unsafe {
+            cpp::duckdb_vx_vector_dictionary_reusable(
+                self.as_ptr(),
+                reusable.as_ptr(),
+                sel_vec.as_ptr(),
+            )
+        }
+    }
+}
diff --git a/vortex-duckdb/src/duckdb/table_filter.rs b/vortex-duckdb/src/duckdb/table_filter.rs
index b34c8bf9b36..c8c8f0c1a68 100644
--- a/vortex-duckdb/src/duckdb/table_filter.rs
+++ b/vortex-duckdb/src/duckdb/table_filter.rs
@@ -173,6 +173,10 @@ impl TableFilterRef {
                 };
                 TableFilterClass::ExpressionRef(expr)
             }
+            cpp::DUCKDB_VX_TABLE_FILTER_TYPE::DUCKDB_VX_TABLE_FILTER_TYPE_BLOOM_FILTER => {
+                // TODO(aduffy): actually extract these parameters
+                TableFilterClass::Bloom
+            }
         }
     }
 }
@@ -198,6 +202,7 @@ pub enum TableFilterClass<'a> {
     InFilter(Values<'a>),
     Dynamic(DynamicFilter),
     ExpressionRef(&'a ExpressionRef),
+    Bloom,
 }
 
 pub struct ConstantComparison<'a> {
diff --git a/vortex-duckdb/src/duckdb/table_function/init.rs b/vortex-duckdb/src/duckdb/table_function/init.rs
index fc9e310d0ab..edfd8e324b6 100644
--- a/vortex-duckdb/src/duckdb/table_function/init.rs
+++ b/vortex-duckdb/src/duckdb/table_function/init.rs
@@ -93,12 +93,10 @@ impl<'a, T: TableFunction> TableInitInput<'a, T> {
         unsafe { &*self.input.bind_data.cast::<T::BindData>() }
     }
 
-    /// Returns the column_ids for the table function.
     pub fn column_ids(&self) -> &[u64] {
         unsafe { std::slice::from_raw_parts(self.input.column_ids, self.input.column_ids_count) }
     }
 
-    /// Returns the projection_ids for the table function.
     pub fn projection_ids(&self) -> Option<&[u64]> {
         if self.input.projection_ids.is_null() {
             return None;
diff --git a/vortex-duckdb/src/duckdb/value.rs b/vortex-duckdb/src/duckdb/value.rs
index ed977e7ee81..d79c802a625 100644
--- a/vortex-duckdb/src/duckdb/value.rs
+++ b/vortex-duckdb/src/duckdb/value.rs
@@ -59,6 +59,10 @@ impl ValueRef {
             DUCKDB_TYPE::DUCKDB_TYPE_BIGINT => {
                 ExtractedValue::BigInt(unsafe { cpp::duckdb_get_int64(self.as_ptr()) })
             }
+            DUCKDB_TYPE::DUCKDB_TYPE_HUGEINT => {
+                let huge_int = unsafe { cpp::duckdb_get_hugeint(self.as_ptr()) };
+                ExtractedValue::HugeInt(i128_from_parts(huge_int.upper, huge_int.lower))
+            }
             DUCKDB_TYPE::DUCKDB_TYPE_UTINYINT => {
                 ExtractedValue::UTinyInt(unsafe { cpp::duckdb_get_uint8(self.as_ptr()) })
             }
@@ -71,6 +75,10 @@ impl ValueRef {
             DUCKDB_TYPE::DUCKDB_TYPE_UBIGINT => {
                 ExtractedValue::UBigInt(unsafe { cpp::duckdb_get_uint64(self.as_ptr()) })
             }
+            DUCKDB_TYPE::DUCKDB_TYPE_UHUGEINT => {
+                let huge_uint = unsafe { cpp::duckdb_get_uhugeint(self.as_ptr()) };
+                ExtractedValue::UHugeInt(u128_from_parts(huge_uint.upper, huge_uint.lower))
+            }
             DUCKDB_TYPE::DUCKDB_TYPE_FLOAT => {
                 ExtractedValue::Float(unsafe { cpp::duckdb_get_float(self.as_ptr()) })
             }
@@ -149,7 +157,7 @@ impl ValueRef {
                     .collect::<Vec<_>>(),
             ),
             // ...other types remain unimplemented..
-            _ => vortex_panic!("Unsupported DuckDB value type {:?}", self),
+            other => vortex_panic!("Unsupported DuckDB value type {other:?}"),
         }
     }
 }
@@ -264,6 +272,11 @@ pub fn i128_from_parts(high: i64, low: u64) -> i128 {
     ((high as i128) << 64) | (low as i128)
 }
 
+#[inline]
+pub fn u128_from_parts(high: u64, low: u64) -> u128 {
+    ((high as u128) << 64) | (low as u128)
+}
+
 impl<T> TryFrom<Option<T>> for Value
 where
     T: Into<Value> + NativeDType,
@@ -376,6 +389,7 @@ pub enum ExtractedValue {
     USmallInt(u16),
     UInteger(u32),
     UBigInt(u64),
+    UHugeInt(u128),
     Float(f32),
     Double(f64),
     Boolean(bool),
@@ -394,6 +408,7 @@ pub enum ExtractedValue {
 #[cfg(test)]
 mod tests {
     use crate::duckdb::i128_from_parts;
+    use crate::duckdb::u128_from_parts;
 
     #[test]
     fn test_huge_int_from_parts() {
@@ -408,4 +423,17 @@ mod tests {
             (1i128 << 64) + (u64::MAX as i128)
         );
     }
+
+    #[test]
+    fn test_uhuge_int_from_parts() {
+        assert_eq!(u128_from_parts(0, 0), 0u128);
+        assert_eq!(u128_from_parts(0, 34534912), 34534912u128);
+        assert_eq!(u128_from_parts(0, u64::MAX), u64::MAX as u128);
+        assert_eq!(u128_from_parts(u64::MAX, u64::MAX), u128::MAX);
+        assert_eq!(
+            u128_from_parts(1, u64::MAX),
+            (1u128 << 64) + (u64::MAX as u128)
+        );
+        assert_eq!(u128_from_parts(1, 0), 1u128 << 64);
+    }
 }
diff --git a/vortex-duckdb/src/duckdb/vector.rs b/vortex-duckdb/src/duckdb/vector.rs
index daf1ac00480..4a822629980 100644
--- a/vortex-duckdb/src/duckdb/vector.rs
+++ b/vortex-duckdb/src/duckdb/vector.rs
@@ -2,20 +2,19 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::ffi::CStr;
-use std::ffi::CString;
 use std::ffi::c_void;
 use std::ptr;
 
 use bitvec::macros::internal::funty::Fundamental;
 use bitvec::slice::BitSlice;
 use bitvec::view::BitView;
+use vortex::array::dtype::Nullability;
 use vortex::array::validity::Validity;
 use vortex::buffer::BitBuffer;
 use vortex::buffer::Buffer;
-use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
-use vortex::error::vortex_err;
+use vortex::mask::Mask;
 
 use crate::cpp;
 use crate::cpp::duckdb_vx_error;
@@ -28,7 +27,14 @@ use crate::duckdb::ValueRef;
 use crate::duckdb::VectorBufferRef;
 use crate::lifetime_wrapper;
 
-pub const DUCKDB_STANDARD_VECTOR_SIZE: usize = 2048;
+/// Returns the internal vector size used by DuckDB at runtime.
+#[expect(
+    clippy::cast_possible_truncation,
+    reason = "DuckDB vector size always fits in usize"
+)]
+pub fn duckdb_vector_size() -> usize {
+    unsafe { cpp::duckdb_vector_size() as usize }
+}
 
 lifetime_wrapper!(Vector, cpp::duckdb_vector, cpp::duckdb_destroy_vector);
 
@@ -91,20 +97,6 @@ impl VectorRef {
         unsafe { cpp::duckdb_vx_set_dictionary_vector_length(self.as_ptr(), len) }
     }
 
-    // A operator-scoped id to assert dictionary vector value uniqueness
-    pub fn set_dictionary_id(&mut self, dict_id: String) {
-        let dict_id = CString::new(dict_id)
-            .map_err(|e| vortex_err!("cstr creation error {e}"))
-            .vortex_expect("dictionary ID should be valid C string");
-        unsafe {
-            cpp::duckdb_vx_set_dictionary_vector_id(
-                self.as_ptr(),
-                dict_id.as_ptr(),
-                dict_id.as_bytes().len().as_u32(),
-            )
-        }
-    }
-
     pub fn to_sequence(&mut self, start: i64, stop: i64, capacity: u64) {
         unsafe { cpp::duckdb_vx_sequence_vector(self.as_ptr(), start, stop, capacity) }
     }
@@ -331,23 +323,29 @@ impl ValidityRef<'_> {
         (validity_entry & (1u64 << idx_in_entry)) != 0
     }
 
-    /// Creates a Validity directly from the DuckDB validity mask for optimal performance.
-    pub fn to_validity(&self) -> Validity {
+    /// Creates a mask directly from the DuckDB validity mask for optimal performance.
+    pub fn to_mask(&self) -> Mask {
         let Some(validity) = self.validity else {
             // All values are valid
-            return Validity::AllValid;
+            return Mask::AllTrue(self.len);
         };
 
-        Validity::from(BitBuffer::new(
+        Mask::from_buffer(BitBuffer::new(
             Buffer::<u64>::copy_from(validity).into_byte_buffer(),
             self.len,
         ))
     }
+
+    pub fn to_validity(&self) -> Validity {
+        Validity::from_mask(self.to_mask(), Nullability::Nullable)
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use vortex::array::LEGACY_SESSION;
     use vortex::mask::Mask;
+    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::cpp::DUCKDB_TYPE;
@@ -361,9 +359,8 @@ mod tests {
 
         let validity = vector.validity_ref(len);
         let validity = validity.to_validity();
-        assert_eq!(
-            validity,
-            Validity::AllValid,
+        assert!(
+            matches!(validity, Validity::AllValid),
             "Expected None for all-valid vector"
         );
     }
@@ -383,8 +380,9 @@ mod tests {
         let validity = validity.to_validity();
         assert_eq!(validity.maybe_len(), Some(len));
 
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         assert_eq!(
-            validity.to_mask(len),
+            validity.execute_mask(len, &mut ctx).unwrap(),
             Mask::from_indices(len, vec![0, 2, 4, 5, 6, 8, 9])
         );
     }
@@ -424,7 +422,7 @@ mod tests {
 
         let validity = vector.validity_ref(len);
         let validity = validity.to_validity();
-        assert_eq!(validity, Validity::AllValid);
+        assert!(matches!(validity, Validity::AllValid));
     }
 
     #[test]
@@ -440,7 +438,7 @@ mod tests {
 
         let validity = vector.validity_ref(len);
         let validity = validity.to_validity();
-        assert_eq!(validity, Validity::AllInvalid);
+        assert!(matches!(validity, Validity::AllInvalid));
     }
 
     #[test]
diff --git a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
index f2191fcbb6f..4e03cd07cd7 100644
--- a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
+++ b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
@@ -36,8 +36,8 @@ use vortex::file::WriteOptionsSessionExt;
 use vortex::io::runtime::BlockingRuntime;
 use vortex::scalar::PValue;
 use vortex::scalar::Scalar;
-use vortex_runend::RunEndArray;
-use vortex_sequence::SequenceArray;
+use vortex_runend::RunEnd;
+use vortex_sequence::Sequence;
 
 use crate::RUNTIME;
 use crate::SESSION;
@@ -71,7 +71,7 @@ async fn write_vortex_file(
     let mut file = async_fs::File::create(&temp_file_path).await.unwrap();
     SESSION
         .write_options()
-        .write(&mut file, struct_array.to_array_stream())
+        .write(&mut file, struct_array.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -167,7 +167,7 @@ async fn write_vortex_file_to_dir(
     let mut file = async_fs::File::create(&temp_file_path).await.unwrap();
     SESSION
         .write_options()
-        .write(&mut file, struct_array.to_array_stream())
+        .write(&mut file, struct_array.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -310,9 +310,9 @@ fn test_vortex_multi_column() {
             vec![true, false, true, true, false].into(),
             Validity::NonNullable,
         )
-        .to_array();
-        let f2 = (0..5).collect::<PrimitiveArray>().to_array();
-        let f3 = (100..105).collect::<PrimitiveArray>().to_array();
+        .into_array();
+        let f2 = (0..5).collect::<PrimitiveArray>().into_array();
+        let f3 = (100..105).collect::<PrimitiveArray>().into_array();
         write_vortex_file([("f1", f1), ("f2", f2), ("f3", f3)].into_iter()).await
     });
 
@@ -789,10 +789,10 @@ async fn write_vortex_file_with_encodings() -> NamedTempFile {
     // 4. Run-End
     let run_ends = buffer![3u32, 5];
     let run_values = buffer![100i32, 200];
-    let rle_array = RunEndArray::try_new(run_ends.into_array(), run_values.into_array()).unwrap();
+    let rle_array = RunEnd::try_new(run_ends.into_array(), run_values.into_array()).unwrap();
 
     // 5. Sequence array
-    let sequence_array = SequenceArray::new(
+    let sequence_array = Sequence::try_new(
         PValue::I64(0),
         PValue::I64(10),
         PType::I64,
@@ -844,7 +844,7 @@ async fn write_vortex_file_with_encodings() -> NamedTempFile {
     let mut file = async_fs::File::create(&temp_file_path).await.unwrap();
     SESSION
         .write_options()
-        .write(&mut file, struct_array.to_array_stream())
+        .write(&mut file, struct_array.into_array().to_array_stream())
         .await
         .unwrap();
 
diff --git a/vortex-duckdb/src/exporter/all_invalid.rs b/vortex-duckdb/src/exporter/all_invalid.rs
index 104db72407b..873dde3c089 100644
--- a/vortex-duckdb/src/exporter/all_invalid.rs
+++ b/vortex-duckdb/src/exporter/all_invalid.rs
@@ -42,8 +42,8 @@ impl ColumnExporter for AllInvalidExporter {
 
 #[cfg(test)]
 mod tests {
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::PrimitiveArray;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/bool.rs b/vortex-duckdb/src/exporter/bool.rs
index 39a4a456822..cb488ce5297 100644
--- a/vortex-duckdb/src/exporter/bool.rs
+++ b/vortex-duckdb/src/exporter/bool.rs
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use itertools::Itertools;
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::BoolArray;
+use vortex::array::arrays::bool::BoolArrayExt;
 use vortex::buffer::BitBuffer;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
@@ -51,7 +51,7 @@ impl ColumnExporter for BoolExporter {
                 .bit_buffer
                 .slice(offset..(offset + len))
                 .iter()
-                .collect_vec(),
+                .collect::<Vec<bool>>(),
         );
 
         Ok(())
@@ -109,7 +109,7 @@ mod tests {
                 r#"Chunk - [1 Columns]
 - FLAT BOOLEAN: 65 = [ {}]
 "#,
-                iter::repeat_n("true", 65).join(", ")
+                iter::repeat_n("true", 65).collect::<Vec<&str>>().join(", ")
             )
         );
     }
diff --git a/vortex-duckdb/src/exporter/cache.rs b/vortex-duckdb/src/exporter/cache.rs
index d7e49845bd5..3b0fd496360 100644
--- a/vortex-duckdb/src/exporter/cache.rs
+++ b/vortex-duckdb/src/exporter/cache.rs
@@ -8,6 +8,7 @@ use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex_utils::aliases::dash_map::DashMap;
 
+use crate::duckdb::ReusableDict;
 use crate::duckdb::Vector;
 
 /// Cache for array conversions from Vortex to DuckDB.
@@ -17,6 +18,7 @@ use crate::duckdb::Vector;
 /// We hold on to the `ArrayRef` to ensure that the key (ptr addr) doesn't get reused.
 #[derive(Default)]
 pub struct ConversionCache {
+    pub dict_cache: DashMap<usize, (ArrayRef, ReusableDict)>,
     pub values_cache: DashMap<usize, (ArrayRef, Arc<Mutex<Vector>>)>,
     pub canonical_cache: DashMap<usize, (ArrayRef, Canonical)>,
 }
diff --git a/vortex-duckdb/src/exporter/decimal.rs b/vortex-duckdb/src/exporter/decimal.rs
index c3800557a83..2fe226b7f31 100644
--- a/vortex-duckdb/src/exporter/decimal.rs
+++ b/vortex-duckdb/src/exporter/decimal.rs
@@ -6,7 +6,7 @@ use std::marker::PhantomData;
 use num_traits::ToPrimitive;
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::DecimalArray;
-use vortex::array::arrays::DecimalArrayParts;
+use vortex::array::arrays::decimal::DecimalDataParts;
 use vortex::array::match_each_decimal_value_type;
 use vortex::buffer::Buffer;
 use vortex::dtype::BigCast;
@@ -42,12 +42,12 @@ pub(crate) fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let len = array.len();
-    let DecimalArrayParts {
+    let DecimalDataParts {
         validity,
         decimal_dtype,
         values_type,
         values,
-    } = array.into_parts();
+    } = array.into_data_parts();
     let dest_values_type = precision_to_duckdb_storage_size(&decimal_dtype)?;
     let nullability = validity.nullability();
     let validity = validity.to_array(len).execute::<Mask>(ctx)?;
@@ -138,10 +138,10 @@ pub fn precision_to_duckdb_storage_size(decimal_dtype: &DecimalDType) -> VortexR
 
 #[cfg(test)]
 mod tests {
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::DecimalArray;
     use vortex::dtype::DecimalDType;
     use vortex::error::VortexExpect;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/dict.rs b/vortex-duckdb/src/exporter/dict.rs
index e9d0ff60886..961c7e35b84 100644
--- a/vortex-duckdb/src/exporter/dict.rs
+++ b/vortex-duckdb/src/exporter/dict.rs
@@ -2,28 +2,24 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::marker::PhantomData;
-use std::sync::Arc;
 
-use bitvec::macros::internal::funty::Fundamental;
 use num_traits::AsPrimitive;
-use parking_lot::Mutex;
-use vortex::array::Array;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
-use vortex::array::ToCanonical;
+use vortex::array::arrays::Constant;
 use vortex::array::arrays::ConstantArray;
-use vortex::array::arrays::ConstantVTable;
 use vortex::array::arrays::DictArray;
 use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::dict::DictArraySlotsExt;
 use vortex::array::match_each_integer_ptype;
 use vortex::dtype::IntegerPType;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
 
 use crate::duckdb::LogicalType;
+use crate::duckdb::ReusableDict;
 use crate::duckdb::SelectionVector;
-use crate::duckdb::Vector;
 use crate::duckdb::VectorRef;
 use crate::exporter::ColumnExporter;
 use crate::exporter::all_invalid;
@@ -33,11 +29,9 @@ use crate::exporter::new_array_exporter;
 
 struct DictExporter<I: IntegerPType> {
     // Store the dictionary values once and export the same dictionary with each codes chunk.
-    values_vector: Arc<Mutex<Vector>>, // NOTE(ngates): not actually flat...
-    values_len: u32,
+    values: ReusableDict,
     codes: PrimitiveArray,
     codes_type: PhantomData<I>,
-    value_id: usize,
 }
 
 pub(crate) fn new_exporter_with_flatten(
@@ -50,7 +44,7 @@ pub(crate) fn new_exporter_with_flatten(
     // Grab the cache dictionary values.
     let values = array.values();
     let values_type: LogicalType = values.dtype().try_into()?;
-    if let Some(constant) = values.as_opt::<ConstantVTable>() {
+    if let Some(constant) = values.as_opt::<Constant>() {
         return constant::new_exporter_with_mask(
             ConstantArray::new(constant.scalar().clone(), array.codes().len()),
             array.codes().validity_mask()?,
@@ -71,10 +65,10 @@ pub(crate) fn new_exporter_with_flatten(
         }
     }
 
-    let values_key = Arc::as_ptr(values).addr();
-    let codes = array.codes().to_primitive();
+    let values_key = values.addr();
+    let codes = array.codes().clone().execute::<PrimitiveArray>(ctx)?;
 
-    let exporter_values = if flatten {
+    let reusable_dict = if flatten {
         let canonical = cache
             .canonical_cache
             .get(&values_key)
@@ -99,41 +93,37 @@ pub(crate) fn new_exporter_with_flatten(
         );
     } else {
         // Check if we have a cached vector and extract it if we do.
-        let cached_vector = cache
-            .values_cache
+        let reusable_dict = cache
+            .dict_cache
             .get(&values_key)
             .map(|entry| entry.value().1.clone());
 
-        match cached_vector {
-            Some(vector) => vector,
+        match reusable_dict {
+            Some(reusable_dict) => reusable_dict,
             None => {
-                // Create a new DuckDB vector for the values.
-                let values_type: LogicalType = values.dtype().try_into()?;
-                let mut vector = Vector::with_capacity(&values_type, values.len());
+                // Create a new reusable dictionary for the values.
+                let mut reusable_dict = ReusableDict::new(values.dtype().try_into()?, values.len());
                 new_array_exporter(values.clone(), cache, ctx)?.export(
                     0,
                     values.len(),
-                    &mut vector,
+                    reusable_dict.vector(),
                     ctx,
                 )?;
 
-                let vector = Arc::new(Mutex::new(vector));
                 cache
-                    .values_cache
-                    .insert(values_key, (values.clone(), vector.clone()));
+                    .dict_cache
+                    .insert(values_key, (values.clone(), reusable_dict.clone()));
 
-                vector
+                reusable_dict
             }
         }
     };
 
     match_each_integer_ptype!(codes.ptype(), |I| {
         Ok(Box::new(DictExporter {
-            values_vector: exporter_values,
-            values_len: values.len().as_u32(),
+            values: reusable_dict,
             codes,
             codes_type: PhantomData::<I>,
-            value_id: values_key,
         }))
     })
 }
@@ -157,22 +147,7 @@ impl<I: IntegerPType + AsPrimitive<u32>> ColumnExporter for DictExporter<I> {
             *dst = src
         }
 
-        // DuckDB requires the value vector which references the data to be
-        // unique. Otherwise, DuckDB races on the values vector passed to the
-        // dictionary.
-        let new_values_vector = {
-            let values_vector = self.values_vector.lock();
-            let mut new_values_vector = Vector::new(&values_vector.logical_type());
-            // Shares the underlying data which determines the vectors length.
-            new_values_vector.reference(&values_vector);
-            new_values_vector
-        };
-
-        vector.dictionary(&new_values_vector, self.values_len as usize, &sel_vec, len);
-
-        // Use a unique id for each dictionary data array -- telling duckdb that
-        // the dict value vector is the same as reuse the hash in a join.
-        vector.set_dictionary_id(format!("{}", self.value_id));
+        vector.reuse_dictionary(&self.values, &sel_vec);
 
         Ok(())
     }
@@ -183,13 +158,13 @@ mod tests {
     use vortex::VortexSessionDefault;
     use vortex::array::ExecutionCtx;
     use vortex::array::IntoArray;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::ConstantArray;
     use vortex::array::arrays::DictArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::buffer::Buffer;
     use vortex::error::VortexResult;
     use vortex::session::VortexSession;
-    use vortex_array::VortexSessionExecute;
 
     use crate::SESSION;
     use crate::cpp;
@@ -208,7 +183,7 @@ mod tests {
     }
 
     #[test]
-    fn test_constant_dict() {
+    fn test_constant_dict() -> VortexResult<()> {
         let arr = DictArray::new(
             PrimitiveArray::from_option_iter([None, Some(0u32)]).into_array(),
             ConstantArray::new(10, 1).into_array(),
@@ -228,15 +203,17 @@ mod tests {
         chunk.set_len(2);
 
         assert_eq!(
-            format!("{}", String::try_from(&*chunk).unwrap()),
+            format!("{}", String::try_from(&*chunk)?),
             r#"Chunk - [1 Columns]
 - FLAT INTEGER: 2 = [ NULL, 10]
 "#
         );
+
+        Ok(())
     }
 
     #[test]
-    fn test_constant_dict_null() {
+    fn test_constant_dict_null() -> VortexResult<()> {
         let arr = DictArray::new(
             PrimitiveArray::from_option_iter([None::<u32>, None]).into_array(),
             ConstantArray::new(10, 1).into_array(),
@@ -252,15 +229,17 @@ mod tests {
         chunk.set_len(2);
 
         assert_eq!(
-            format!("{}", String::try_from(&*chunk).unwrap()),
+            format!("{}", String::try_from(&*chunk)?),
             r#"Chunk - [1 Columns]
 - CONSTANT INTEGER: 2 = [ NULL]
 "#
         );
+
+        Ok(())
     }
 
     #[test]
-    fn test_nullable_dict() {
+    fn test_nullable_dict() -> VortexResult<()> {
         let arr = DictArray::new(
             PrimitiveArray::from_option_iter([None, Some(0u32), Some(1)]).into_array(),
             PrimitiveArray::from_option_iter([Some(10), None]).into_array(),
@@ -281,7 +260,7 @@ mod tests {
 
         // some-invalid codes cannot be exported as a dictionary.
         assert_eq!(
-            format!("{}", String::try_from(&*chunk).unwrap()),
+            format!("{}", String::try_from(&*chunk)?),
             r#"Chunk - [1 Columns]
 - FLAT INTEGER: 3 = [ NULL, 10, NULL]
 "#
@@ -298,16 +277,18 @@ mod tests {
         flat_chunk.set_len(3);
 
         assert_eq!(
-            format!("{}", String::try_from(&*flat_chunk).unwrap()),
+            format!("{}", String::try_from(&*flat_chunk)?),
             r#"Chunk - [1 Columns]
 - FLAT INTEGER: 3 = [ NULL, 10, NULL]
 "#
-        )
+        );
+
+        Ok(())
     }
 
     #[ignore = "TODO(connor)[4809]: Exporters do not correctly handle empty vectors"]
     #[test]
-    fn test_export_empty_dict() {
+    fn test_export_empty_dict() -> VortexResult<()> {
         let arr = DictArray::new(
             Buffer::<u32>::empty().into_array(),
             Buffer::<u32>::empty().into_array(),
@@ -327,10 +308,12 @@ mod tests {
         chunk.set_len(0);
 
         assert_eq!(
-            format!("{}", String::try_from(&*chunk).unwrap()),
+            format!("{}", String::try_from(&*chunk)?),
             r#"Chunk - [1 Columns]
 - FLAT INTEGER: 0 = [ ]
 "#
         );
+
+        Ok(())
     }
 }
diff --git a/vortex-duckdb/src/exporter/fixed_size_list.rs b/vortex-duckdb/src/exporter/fixed_size_list.rs
index bfea0df2034..d7fbfa64647 100644
--- a/vortex-duckdb/src/exporter/fixed_size_list.rs
+++ b/vortex-duckdb/src/exporter/fixed_size_list.rs
@@ -10,6 +10,7 @@
 //! [`DType::FixedSizeList`]: vortex_array::dtype::DType::FixedSizeList
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::FixedSizeListArray;
+use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
 
@@ -38,7 +39,10 @@ pub(crate) fn new_exporter(
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let list_size = array.list_size();
     let len = array.len();
-    let (elements, validity, dtype) = array.into_parts();
+    let parts = array.into_data_parts();
+    let elements = parts.elements;
+    let validity = parts.validity;
+    let dtype = parts.dtype;
     let mask = validity.to_array(len).execute::<Mask>(ctx)?;
     let elements_exporter = new_array_exporter_with_flatten(elements, cache, ctx, true)?;
 
@@ -96,10 +100,10 @@ impl ColumnExporter for FixedSizeListExporter {
 #[cfg(test)]
 mod tests {
     use vortex::array::IntoArray as _;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::validity::Validity;
     use vortex::buffer::buffer;
     use vortex::error::VortexExpect;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/list.rs b/vortex-duckdb/src/exporter/list.rs
index e9b635901ae..1ae14869908 100644
--- a/vortex-duckdb/src/exporter/list.rs
+++ b/vortex-duckdb/src/exporter/list.rs
@@ -5,11 +5,10 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 
 use parking_lot::Mutex;
-use vortex::array::Array;
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::ListArray;
-use vortex::array::arrays::ListArrayParts;
 use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::list::ListDataParts;
 use vortex::array::match_each_integer_ptype;
 use vortex::dtype::IntegerPType;
 use vortex::error::VortexResult;
@@ -46,12 +45,12 @@ pub(crate) fn new_exporter(
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let array_len = array.len();
     // Cache an `elements` vector up front so that future exports can reference it.
-    let ListArrayParts {
+    let ListDataParts {
         elements,
         offsets,
         validity,
         dtype,
-    } = array.into_parts();
+    } = array.into_data_parts();
     let num_elements = elements.len();
     let validity = validity.to_array(array_len).execute::<Mask>(ctx)?;
 
@@ -60,12 +59,12 @@ pub(crate) fn new_exporter(
         return Ok(all_invalid::new_exporter(array_len, &ltype));
     }
 
-    let values_key = Arc::as_ptr(&elements).addr();
+    let values_key = elements.addr();
     // Check if we have a cached vector and extract it if we do.
     let cached_elements = cache
         .values_cache
         .get(&values_key)
-        .map(|entry| entry.value().1.clone());
+        .map(|entry| Arc::clone(&entry.value().1));
 
     let shared_elements = match cached_elements {
         Some(elements) => elements,
@@ -83,7 +82,7 @@ pub(crate) fn new_exporter(
             let shared_elements = Arc::new(Mutex::new(duckdb_elements));
             cache
                 .values_cache
-                .insert(values_key, (elements, shared_elements.clone()));
+                .insert(values_key, (elements, Arc::clone(&shared_elements)));
 
             shared_elements
         }
@@ -160,12 +159,12 @@ impl<O: IntegerPType> ColumnExporter for ListExporter<O> {
 #[cfg(test)]
 mod tests {
     use vortex::array::IntoArray as _;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::VarBinArray;
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
     use vortex::buffer::buffer;
     use vortex::error::VortexExpect;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/list_view.rs b/vortex-duckdb/src/exporter/list_view.rs
index 247a9262645..dcc7c66ce31 100644
--- a/vortex-duckdb/src/exporter/list_view.rs
+++ b/vortex-duckdb/src/exporter/list_view.rs
@@ -5,11 +5,10 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 
 use parking_lot::Mutex;
-use vortex::array::Array;
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::ListViewArray;
-use vortex::array::arrays::ListViewArrayParts;
 use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::listview::ListViewDataParts;
 use vortex::array::match_each_integer_ptype;
 use vortex::dtype::DType;
 use vortex::dtype::IntegerPType;
@@ -48,13 +47,13 @@ pub(crate) fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let len = array.len();
-    let ListViewArrayParts {
+    let ListViewDataParts {
         elements_dtype,
         elements,
         offsets,
         sizes,
         validity,
-    } = array.into_parts();
+    } = array.into_data_parts();
     // Cache an `elements` vector up front so that future exports can reference it.
     let num_elements = elements.len();
     let nullability = validity.nullability();
@@ -65,12 +64,12 @@ pub(crate) fn new_exporter(
         return Ok(all_invalid::new_exporter(len, &ltype));
     }
 
-    let values_key = Arc::as_ptr(&elements).addr();
+    let values_key = elements.addr();
     // Check if we have a cached vector and extract it if we do.
     let cached_elements = cache
         .values_cache
         .get(&values_key)
-        .map(|entry| entry.value().1.clone());
+        .map(|entry| Arc::clone(&entry.value().1));
 
     let shared_elements = match cached_elements {
         Some(elements) => elements,
@@ -88,14 +87,14 @@ pub(crate) fn new_exporter(
             let shared_elements = Arc::new(Mutex::new(duckdb_elements));
             cache
                 .values_cache
-                .insert(values_key, (elements.clone(), shared_elements.clone()));
+                .insert(values_key, (elements, Arc::clone(&shared_elements)));
 
             shared_elements
         }
     };
 
     let offsets = offsets.execute::<PrimitiveArray>(ctx)?;
-    let sizes = sizes.clone().execute::<PrimitiveArray>(ctx)?;
+    let sizes = sizes.execute::<PrimitiveArray>(ctx)?;
 
     let boxed = match_each_integer_ptype!(offsets.ptype(), |O| {
         match_each_integer_ptype!(sizes.ptype(), |S| {
@@ -172,12 +171,12 @@ impl<O: IntegerPType, S: IntegerPType> ColumnExporter for ListViewExporter<O, S>
 #[cfg(test)]
 mod tests {
     use vortex::array::IntoArray as _;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::VarBinArray;
     use vortex::array::validity::Validity;
     use vortex::buffer::Buffer;
     use vortex::buffer::buffer;
     use vortex::error::VortexExpect;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/mod.rs b/vortex-duckdb/src/exporter/mod.rs
index 10d2445f23a..502038b858c 100644
--- a/vortex-duckdb/src/exporter/mod.rs
+++ b/vortex-duckdb/src/exporter/mod.rs
@@ -26,24 +26,26 @@ pub use decimal::precision_to_duckdb_storage_size;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
-use vortex::array::arrays::ConstantVTable;
-use vortex::array::arrays::DictVTable;
-use vortex::array::arrays::ListVTable;
+use vortex::array::arrays::Constant;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::List;
 use vortex::array::arrays::StructArray;
 use vortex::array::arrays::TemporalArray;
-use vortex::array::vtable::ValidityHelper;
-use vortex::encodings::runend::RunEndVTable;
-use vortex::encodings::sequence::SequenceVTable;
+use vortex::array::arrays::struct_::StructArrayExt;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::sequence::Sequence;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 
-use crate::duckdb::DUCKDB_STANDARD_VECTOR_SIZE;
 use crate::duckdb::DataChunkRef;
 use crate::duckdb::LogicalType;
 use crate::duckdb::VectorRef;
+use crate::duckdb::duckdb_vector_size;
 
 pub struct ArrayExporter {
     ctx: ExecutionCtx,
+    /// Columns DuckDB requested to read from file. If empty, it's a zero-column
+    /// projection and should be handled accordingly, see ArrayExporter::export.
     fields: Vec<Box<dyn ColumnExporter>>,
     array_len: usize,
     remaining: usize,
@@ -55,13 +57,14 @@ impl ArrayExporter {
         cache: &ConversionCache,
         mut ctx: ExecutionCtx,
     ) -> VortexResult<Self> {
-        let all_valid = array.validity().all_valid(array.len())?;
-        assert!(all_valid);
+        let validity = array.validity()?.execute_mask(array.len(), &mut ctx)?;
+        assert!(validity.all_true());
+
         let fields = array
-            .unmasked_fields()
-            .iter()
+            .iter_unmasked_fields()
             .map(|field| new_array_exporter(field.clone(), cache, &mut ctx))
             .collect::<VortexResult<Vec<_>>>()?;
+
         Ok(Self {
             ctx,
             fields,
@@ -74,26 +77,30 @@ impl ArrayExporter {
     ///
     /// Returns `true` if a chunk was exported, `false` if all rows have been exported.
     pub fn export(&mut self, chunk: &mut DataChunkRef) -> VortexResult<bool> {
+        chunk.reset();
         if self.remaining == 0 {
             return Ok(false);
         }
 
-        if self.fields.is_empty() {
-            // In the case of a projection pushdown with zero columns duckdb will ask us for the
-            // `EMPTY_COLUMN_IDX`, which we define as a bool column, we can leave the vector as
-            // uninitialized and just return a DataChunk with the correct length.
-            // One place no fields can occur is in count(*) queries.
-            chunk.set_len(self.remaining);
-            self.remaining = 0;
-
-            return Ok(true);
+        let expected_cols = self.fields.len();
+        let chunk_cols = chunk.column_count();
+        let zero_projection = expected_cols == 0;
+        if !zero_projection && chunk_cols != expected_cols {
+            vortex_bail!("Expected {expected_cols} columns in output chunk, got {chunk_cols}");
         }
 
-        let chunk_len = DUCKDB_STANDARD_VECTOR_SIZE.min(self.remaining);
+        let chunk_len = duckdb_vector_size().min(self.remaining);
         let position = self.array_len - self.remaining;
         self.remaining -= chunk_len;
         chunk.set_len(chunk_len);
 
+        // DuckDB asked us for zero columns. This may happen with aggregation
+        // functions like count(*). In such case we can leave chunk contents
+        // uninitialized. See EMPTY_COLUMN_IDX comment why this works.
+        if zero_projection {
+            return Ok(true);
+        }
+
         for (i, field) in self.fields.iter_mut().enumerate() {
             field.export(position, chunk_len, chunk.get_vector_mut(i), &mut self.ctx)?;
         }
@@ -133,25 +140,27 @@ fn new_array_exporter_with_flatten(
     ctx: &mut ExecutionCtx,
     flatten: bool,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
-    let array = match array.try_into::<ConstantVTable>() {
+    let array = match array.try_downcast::<Constant>() {
         Ok(array) => return constant::new_exporter(array),
         Err(array) => array,
     };
 
-    if let Some(array) = array.as_opt::<SequenceVTable>() {
-        return sequence::new_exporter(array);
-    }
+    let array = match array.try_downcast::<Sequence>() {
+        Ok(array) => return sequence::new_exporter(&array),
+        Err(array) => array,
+    };
 
-    let array = match array.try_into::<RunEndVTable>() {
+    let array = match array.try_downcast::<RunEnd>() {
         Ok(array) => return run_end::new_exporter(array, cache, ctx),
         Err(array) => array,
     };
 
-    if let Some(array) = array.as_opt::<DictVTable>() {
-        return dict::new_exporter_with_flatten(array, cache, ctx, flatten);
-    }
+    let array = match array.try_downcast::<Dict>() {
+        Ok(array) => return dict::new_exporter_with_flatten(&array, cache, ctx, flatten),
+        Err(array) => array,
+    };
 
-    let array = match array.try_into::<ListVTable>() {
+    let array = match array.try_downcast::<List>() {
         Ok(array) => return list::new_exporter(array, cache, ctx),
         Err(array) => array,
     };
@@ -172,6 +181,9 @@ fn new_array_exporter_with_flatten(
             }
             vortex_bail!("no non-temporal extension exporter")
         }
+        Canonical::Variant(_) => {
+            vortex_bail!("Variant arrays can't be exported to DuckDB")
+        }
     }
 }
 
diff --git a/vortex-duckdb/src/exporter/primitive.rs b/vortex-duckdb/src/exporter/primitive.rs
index 274dc0a6f36..7506cbdb93c 100644
--- a/vortex-duckdb/src/exporter/primitive.rs
+++ b/vortex-duckdb/src/exporter/primitive.rs
@@ -6,7 +6,6 @@ use std::marker::PhantomData;
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::match_each_native_ptype;
-use vortex::array::vtable::ValidityHelper;
 use vortex::dtype::NativePType;
 use vortex::error::VortexResult;
 use vortex::mask::Mask;
@@ -30,7 +29,7 @@ pub fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let validity = array
-        .validity()
+        .validity()?
         .to_array(array.len())
         .execute::<Mask>(ctx)?;
 
@@ -72,16 +71,14 @@ impl<T: NativePType> ColumnExporter for PrimitiveExporter<T> {
 
 #[cfg(test)]
 mod tests {
-    use itertools::Itertools;
-    use vortex::error::VortexExpect;
     use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
     use crate::cpp;
-    use crate::duckdb::DUCKDB_STANDARD_VECTOR_SIZE;
     use crate::duckdb::DataChunk;
     use crate::duckdb::LogicalType;
+    use crate::duckdb::duckdb_vector_size;
 
     #[test]
     fn test_primitive_exporter() {
@@ -106,36 +103,39 @@ mod tests {
 
     #[test]
     fn test_long_primitive_exporter() {
+        let vector_size = duckdb_vector_size();
         const ARRAY_COUNT: usize = 2;
-        const LEN: usize = DUCKDB_STANDARD_VECTOR_SIZE * ARRAY_COUNT;
-        let arr = PrimitiveArray::from_iter(0..i32::try_from(LEN).vortex_expect(""));
+        let len = vector_size * ARRAY_COUNT;
+        #[expect(clippy::cast_possible_truncation, reason = "test data fits in i32")]
+        let arr = PrimitiveArray::from_iter(0..len as i32);
 
         {
-            let mut chunk = (0..ARRAY_COUNT)
+            let mut chunk: Vec<DataChunk> = (0..ARRAY_COUNT)
                 .map(|_| DataChunk::new([LogicalType::new(cpp::duckdb_type::DUCKDB_TYPE_INTEGER)]))
-                .collect_vec();
+                .collect();
 
             for i in 0..ARRAY_COUNT {
                 let mut ctx = SESSION.create_execution_ctx();
                 new_exporter(arr.clone(), &mut ctx)
                     .unwrap()
                     .export(
-                        i * DUCKDB_STANDARD_VECTOR_SIZE,
-                        DUCKDB_STANDARD_VECTOR_SIZE,
+                        i * vector_size,
+                        vector_size,
                         chunk[i].get_vector_mut(0),
                         &mut ctx,
                     )
                     .unwrap();
-                chunk[i].set_len(DUCKDB_STANDARD_VECTOR_SIZE);
+                chunk[i].set_len(vector_size);
 
                 assert_eq!(
                     format!("{}", String::try_from(&*chunk[i]).unwrap()),
                     format!(
                         r#"Chunk - [1 Columns]
-- FLAT INTEGER: {DUCKDB_STANDARD_VECTOR_SIZE} = [ {}]
+- FLAT INTEGER: {vector_size} = [ {}]
 "#,
-                        &(i * DUCKDB_STANDARD_VECTOR_SIZE..(i + 1) * DUCKDB_STANDARD_VECTOR_SIZE)
+                        &(i * vector_size..(i + 1) * vector_size)
                             .map(|i| i.to_string())
+                            .collect::<Vec<String>>()
                             .join(", ")
                     )
                 );
diff --git a/vortex-duckdb/src/exporter/run_end.rs b/vortex-duckdb/src/exporter/run_end.rs
index 2a27af64940..fa62388cf57 100644
--- a/vortex-duckdb/src/exporter/run_end.rs
+++ b/vortex-duckdb/src/exporter/run_end.rs
@@ -11,7 +11,7 @@ use vortex::array::search_sorted::SearchSorted;
 use vortex::array::search_sorted::SearchSortedSide;
 use vortex::dtype::IntegerPType;
 use vortex::encodings::runend::RunEndArray;
-use vortex::encodings::runend::RunEndArrayParts;
+use vortex::encodings::runend::RunEndArrayExt;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 
@@ -38,7 +38,8 @@ pub(crate) fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let offset = array.offset();
-    let RunEndArrayParts { ends, values } = array.into_parts();
+    let ends = array.ends().clone();
+    let values = array.values().clone();
     let ends = ends.execute::<PrimitiveArray>(ctx)?;
     let values_exporter = new_array_exporter(values.clone(), cache, ctx)?;
 
diff --git a/vortex-duckdb/src/exporter/sequence.rs b/vortex-duckdb/src/exporter/sequence.rs
index 55537635e35..a9a569d2a06 100644
--- a/vortex-duckdb/src/exporter/sequence.rs
+++ b/vortex-duckdb/src/exporter/sequence.rs
@@ -43,8 +43,9 @@ impl ColumnExporter for SequenceExporter {
 
 #[cfg(test)]
 mod tests {
+    use vortex::array::VortexSessionExecute;
     use vortex::dtype::Nullability;
-    use vortex_array::VortexSessionExecute;
+    use vortex::encodings::sequence::Sequence;
 
     use super::*;
     use crate::SESSION;
@@ -54,7 +55,7 @@ mod tests {
 
     #[test]
     fn test_sequence() {
-        let arr = SequenceArray::typed_new(2, 5, Nullability::NonNullable, 100).unwrap();
+        let arr = Sequence::try_new_typed(2, 5, Nullability::NonNullable, 100).unwrap();
         let mut chunk = DataChunk::new([LogicalType::new(cpp::duckdb_type::DUCKDB_TYPE_INTEGER)]);
 
         new_exporter(&arr)
diff --git a/vortex-duckdb/src/exporter/struct_.rs b/vortex-duckdb/src/exporter/struct_.rs
index 48b12e3153d..f53ec437bf2 100644
--- a/vortex-duckdb/src/exporter/struct_.rs
+++ b/vortex-duckdb/src/exporter/struct_.rs
@@ -5,7 +5,8 @@ use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
 use vortex::array::arrays::BoolArray;
 use vortex::array::arrays::StructArray;
-use vortex::array::arrays::StructArrayParts;
+use vortex::array::arrays::bool::BoolArrayExt;
+use vortex::array::arrays::struct_::StructDataParts;
 use vortex::array::builtins::ArrayBuiltins;
 use vortex::error::VortexResult;
 
@@ -27,12 +28,12 @@ pub(crate) fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let len = array.len();
-    let StructArrayParts {
+    let StructDataParts {
         validity,
         struct_fields,
         fields,
         ..
-    } = array.into_parts();
+    } = array.into_data_parts();
     let validity = validity.to_array(len).execute::<BoolArray>(ctx)?;
 
     if validity.to_bit_buffer().true_count() == 0 {
@@ -45,7 +46,11 @@ pub(crate) fn new_exporter(
         .map(|child| {
             if validity.to_bit_buffer().true_count() != validity.len() {
                 // TODO(joe): use new mask.
-                new_array_exporter(child.clone().mask(validity.to_array())?, cache, ctx)
+                new_array_exporter(
+                    child.clone().mask(validity.clone().into_array())?,
+                    cache,
+                    ctx,
+                )
             } else {
                 new_array_exporter(child.clone().into_array(), cache, ctx)
             }
@@ -77,6 +82,7 @@ mod tests {
     use std::ffi::CString;
 
     use vortex::array::IntoArray;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::ConstantArray;
     use vortex::array::arrays::DictArray;
     use vortex::array::arrays::PrimitiveArray;
@@ -85,7 +91,6 @@ mod tests {
     use vortex::buffer::BitBuffer;
     use vortex::buffer::buffer;
     use vortex::error::VortexExpect;
-    use vortex_array::VortexSessionExecute;
 
     use super::*;
     use crate::SESSION;
diff --git a/vortex-duckdb/src/exporter/temporal.rs b/vortex-duckdb/src/exporter/temporal.rs
index c1d321d78ff..30165a55973 100644
--- a/vortex-duckdb/src/exporter/temporal.rs
+++ b/vortex-duckdb/src/exporter/temporal.rs
@@ -46,11 +46,11 @@ pub(crate) fn new_exporter(
 #[cfg(test)]
 mod tests {
     use vortex::array::IntoArray as _;
+    use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::TemporalArray;
     use vortex::buffer::buffer;
     use vortex::extension::datetime::TimeUnit;
-    use vortex_array::VortexSessionExecute;
 
     use crate::SESSION;
     use crate::cpp;
@@ -87,7 +87,7 @@ mod tests {
     fn test_timestamp_us() {
         let arr = TemporalArray::new_timestamp(
             PrimitiveArray::from_iter((0..10).map(|i| 1_000_000 * i + 1750265188000001i64))
-                .to_array(),
+                .into_array(),
             TimeUnit::Microseconds,
             None,
         );
@@ -111,7 +111,7 @@ mod tests {
     #[test]
     fn test_timestamp_time_us() {
         let arr = TemporalArray::new_time(
-            PrimitiveArray::from_iter((1i64..10).map(|i| 1_000_000 * i)).to_array(),
+            PrimitiveArray::from_iter((1i64..10).map(|i| 1_000_000 * i)).into_array(),
             TimeUnit::Microseconds,
         );
 
diff --git a/vortex-duckdb/src/exporter/varbinview.rs b/vortex-duckdb/src/exporter/varbinview.rs
index cd0c442e456..8067b08a856 100644
--- a/vortex-duckdb/src/exporter/varbinview.rs
+++ b/vortex-duckdb/src/exporter/varbinview.rs
@@ -4,12 +4,11 @@
 use std::ffi::c_char;
 use std::sync::Arc;
 
-use itertools::Itertools;
 use vortex::array::ExecutionCtx;
-use vortex::array::arrays::BinaryView;
-use vortex::array::arrays::Inlined;
 use vortex::array::arrays::VarBinViewArray;
-use vortex::array::arrays::VarBinViewArrayParts;
+use vortex::array::arrays::varbinview::BinaryView;
+use vortex::array::arrays::varbinview::Inlined;
+use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::buffer::Buffer;
 use vortex::buffer::ByteBuffer;
 use vortex::error::VortexResult;
@@ -33,31 +32,26 @@ pub(crate) fn new_exporter(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Box<dyn ColumnExporter>> {
     let len = array.len();
-    let VarBinViewArrayParts {
+    let VarBinViewDataParts {
         validity,
         dtype,
         views,
         buffers,
-    } = array.into_parts();
+    } = array.into_data_parts();
     let validity = validity.to_array(len).execute::<Mask>(ctx)?;
     if validity.all_false() {
         let ltype = LogicalType::try_from(dtype)?;
         return Ok(all_invalid::new_exporter(len, &ltype));
     }
 
-    let buffers = buffers
-        .iter()
-        .cloned()
-        .map(|b| b.unwrap_host())
-        .collect_vec();
-
+    let buffers: Vec<_> = buffers.iter().cloned().map(|b| b.unwrap_host()).collect();
     let buffers: Arc<[ByteBuffer]> = Arc::from(buffers);
 
     Ok(validity::new_exporter(
         validity,
         Box::new(VarBinViewExporter {
             views: Buffer::<BinaryView>::from_byte_buffer(views.unwrap_host()),
-            vector_buffers: buffers.iter().cloned().map(VectorBuffer::new).collect_vec(),
+            vector_buffers: buffers.iter().cloned().map(VectorBuffer::new).collect(),
             buffers,
         }),
     ))
@@ -145,10 +139,10 @@ fn to_ptr_binary_view<'a>(
 #[cfg(test)]
 mod tests {
     use Nullability::Nullable;
+    use vortex::array::VortexSessionExecute;
     use vortex::dtype::DType;
     use vortex::dtype::Nullability;
     use vortex::error::VortexResult;
-    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::VarBinViewArray;
 
     use crate::SESSION;
diff --git a/vortex-duckdb/src/filesystem.rs b/vortex-duckdb/src/filesystem.rs
index 714e11470c6..e6d5c7c9750 100644
--- a/vortex-duckdb/src/filesystem.rs
+++ b/vortex-duckdb/src/filesystem.rs
@@ -53,7 +53,7 @@ pub(super) fn resolve_filesystem(
     let fs_config = fs_config.as_string();
 
     Ok(if fs_config.as_str() == "duckdb" {
-        tracing::info!(
+        tracing::debug!(
             "Using DuckDB's built-in filesystem for URL scheme '{}'",
             base_url.scheme()
         );
@@ -63,7 +63,7 @@ pub(super) fn resolve_filesystem(
             ctx.erase_lifetime()
         }))
     } else if fs_config.as_str() == "vortex" {
-        tracing::info!(
+        tracing::debug!(
             "Using Vortex's object store filesystem for URL scheme '{}'",
             base_url.scheme()
         );
@@ -127,27 +127,13 @@ impl FileSystem for DuckDbFileSystem {
             directory_url.set_path(prefix);
         }
 
-        // DuckDB's ListFiles expects bare paths for local files, but full URLs
-        // for remote schemes (s3://, etc.).
-        let directory = if directory_url.scheme() == "file" {
-            directory_url.path().to_string()
-        } else {
-            directory_url.to_string()
-        };
-
-        tracing::debug!(
-            "Listing files from {} with prefix {}",
-            self.base_url,
-            directory
-        );
-
         let ctx = self.ctx;
-        let base_path = self.base_url.path().to_string();
 
+        let base_url = self.base_url.clone();
         stream::once(async move {
             RUNTIME
                 .handle()
-                .spawn_blocking(move || list_recursive(ctx, &directory, &base_path))
+                .spawn_blocking(move || list_recursive(ctx, &directory_url, &base_url))
                 .await
         })
         .flat_map(|result| match result {
@@ -169,20 +155,46 @@ impl FileSystem for DuckDbFileSystem {
 /// returned URL to produce relative paths.
 fn list_recursive(
     ctx: &ClientContextRef,
-    directory: &str,
-    base_path: &str,
+    directory_url: &Url,
+    base_url: &Url,
 ) -> VortexResult<Vec<FileListing>> {
+    // DuckDB's ListFiles expects bare paths for local files, but full URLs
+    // for remote schemes (s3://, etc.).
+    let directory = if directory_url.scheme() == "file" {
+        directory_url.path().to_string()
+    } else {
+        directory_url.to_string()
+    };
+
+    let (base_path, is_remote_path) = if base_url.scheme() == "file" {
+        (base_url.path().to_string(), false)
+    } else {
+        // This is really ugly. As we operate on Strings and not on urls, we
+        // must produce a base path with / so as relative url would not have
+        // the / and thus match the glob
+        (format!("{base_url}/"), true)
+    };
+
     let mut results = Vec::new();
-    let mut stack = vec![directory.to_string()];
+    let mut stack = vec![directory];
 
     while let Some(dir) = stack.pop() {
+        // TODO(myrrc) this doesn't work with curl backend in v1.4, producing
+        // "URL using bad/illegal format or missing URL error", see
+        // https://github.com/duckdb/duckdb-httpfs/pull/265
         for entry in duckdb_fs_list_dir(ctx, &dir)? {
-            let full_path = format!("{}/{}", dir.trim_end_matches('/'), entry.name);
+            // duckdb_fs_list_dir returns relative paths for local files but full
+            // paths for s3 files.
+            let full_path = if is_remote_path {
+                entry.name
+            } else {
+                format!("{}/{}", dir.trim_end_matches('/'), entry.name)
+            };
             if entry.is_dir {
                 stack.push(full_path);
             } else {
                 let relative_path = full_path
-                    .strip_prefix(base_path)
+                    .strip_prefix(&base_path)
                     .unwrap_or_else(|| &full_path)
                     .to_string();
                 results.push(FileListing {
@@ -234,7 +246,7 @@ impl VortexReadAt for DuckDbFsReader {
 
     fn coalesce_config(&self) -> Option<CoalesceConfig> {
         Some(if self.is_local {
-            CoalesceConfig::local()
+            CoalesceConfig::file()
         } else {
             CoalesceConfig::object_storage()
         })
@@ -249,8 +261,8 @@ impl VortexReadAt for DuckDbFsReader {
     }
 
     fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
-        let handle = self.handle.clone();
-        let size_cell = self.size.clone();
+        let handle = Arc::clone(&self.handle);
+        let size_cell = Arc::clone(&self.size);
 
         async move {
             if let Some(size) = size_cell.get() {
@@ -284,7 +296,7 @@ impl VortexReadAt for DuckDbFsReader {
         length: usize,
         alignment: Alignment,
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
-        let handle = self.handle.clone();
+        let handle = Arc::clone(&self.handle);
 
         async move {
             let runtime = RUNTIME.handle();
diff --git a/vortex-duckdb/src/multi_file.rs b/vortex-duckdb/src/multi_file.rs
index 3ce2ed3856e..e0d04d6c2b9 100644
--- a/vortex-duckdb/src/multi_file.rs
+++ b/vortex-duckdb/src/multi_file.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::path::Path;
+use std::path::absolute;
 use std::sync::Arc;
 
 use url::Url;
@@ -9,7 +10,7 @@ use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 use vortex::file::multi::MultiFileDataSource;
 use vortex::io::runtime::BlockingRuntime;
-use vortex::scan::api::DataSourceRef;
+use vortex::scan::DataSourceRef;
 
 use crate::RUNTIME;
 use crate::SESSION;
@@ -19,6 +20,38 @@ use crate::duckdb::ClientContextRef;
 use crate::duckdb::LogicalType;
 use crate::filesystem::resolve_filesystem;
 
+/// Parse a glob string into a [`Url`].
+///
+/// Accepts full URLs (e.g. `s3://bucket/prefix/*.vortex`, `file:///data/*.vortex`) as well as
+/// bare file paths. For bare paths, the path is made absolute (without requiring it to exist)
+/// so that relative paths such as `./data/*.vortex` or `../data/*.vortex` are resolved correctly.
+fn parse_glob_url(glob_url_str: &str) -> VortexResult<Url> {
+    Url::parse(glob_url_str).or_else(|_| {
+        let path = absolute(Path::new(glob_url_str))
+            .map_err(|e| vortex_err!("Failed making {glob_url_str} absolute: {e}"))?;
+        // `absolute()` does not normalize `..` components, so `/a/b/../c` stays as-is.
+        // Normalizing manually avoids `..` being percent-encoded in the resulting URL.
+        let path = normalize_path(path);
+        Url::from_file_path(path).map_err(|_| vortex_err!("Neither URL nor path: {glob_url_str}"))
+    })
+}
+
+/// Normalize a path by resolving `.` and `..` components without accessing the filesystem.
+fn normalize_path(path: std::path::PathBuf) -> std::path::PathBuf {
+    use std::path::Component;
+    let mut normalized = std::path::PathBuf::new();
+    for component in path.components() {
+        match component {
+            Component::CurDir => {}
+            Component::ParentDir => {
+                normalized.pop();
+            }
+            c => normalized.push(c),
+        }
+    }
+    normalized
+}
+
 /// Vortex multi-file scan table function (`vortex_scan` / `read_vortex`).
 ///
 /// Takes a file glob parameter and resolves it into a [`MultiFileDataSource`].
@@ -38,12 +71,9 @@ impl DataSourceTableFunction for VortexMultiFileScan {
             .ok_or_else(|| vortex_err!("Missing file glob parameter"))?;
 
         // Parse the URL and separate the base URL (keep scheme, host, etc.) from the path.
-        let glob_url_str = glob_url_parameter.as_string();
-        let glob_url = match Url::parse(glob_url_str.as_str()) {
-            Ok(url) => Ok(url),
-            Err(_) => Url::from_file_path(Path::new(glob_url_str.as_str()))
-                .map_err(|_| vortex_err!("Neither URL nor path: '{}' ", glob_url_str.as_str())),
-        }?;
+        let glob_url_string = glob_url_parameter.as_string();
+        let glob_url_str = glob_url_string.as_str();
+        let glob_url = parse_glob_url(glob_url_str)?;
 
         let mut base_url = glob_url.clone();
         base_url.set_path("");
@@ -59,3 +89,130 @@ impl DataSourceTableFunction for VortexMultiFileScan {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[allow(clippy::wildcard_imports)]
+    use rstest::rstest;
+
+    use super::*;
+
+    #[test]
+    fn test_parse_glob_url_s3() -> VortexResult<()> {
+        let url = parse_glob_url("s3://my-bucket/prefix/*.vortex")?;
+        assert_eq!(url.scheme(), "s3");
+        assert_eq!(url.host_str(), Some("my-bucket"));
+        assert_eq!(url.path(), "/prefix/*.vortex");
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_file_scheme() -> VortexResult<()> {
+        let url = parse_glob_url("file:///absolute/path/data.vortex")?;
+        assert_eq!(url.scheme(), "file");
+        assert_eq!(url.path(), "/absolute/path/data.vortex");
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_absolute_glob_path() -> VortexResult<()> {
+        let tmpdir = tempfile::tempdir().unwrap();
+        let glob = format!("{}/*.vortex", tmpdir.path().display());
+        let url = parse_glob_url(&glob)?;
+        assert_eq!(url.scheme(), "file");
+        assert!(url.path().ends_with("/*.vortex"));
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_absolute_existing_path() -> VortexResult<()> {
+        let tmpfile = tempfile::NamedTempFile::new().unwrap();
+        let canonical = std::fs::canonicalize(tmpfile.path()).unwrap();
+        let path_str = canonical.to_str().unwrap();
+        let url = parse_glob_url(path_str)?;
+        assert_eq!(url.scheme(), "file");
+        assert_eq!(url.path(), path_str);
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_relative_path() -> VortexResult<()> {
+        // Create a tempfile in the current working directory so we can refer to it
+        // by a relative name (just the filename, without any directory component).
+        let tmpfile = tempfile::NamedTempFile::new_in(".").unwrap();
+        let filename = tmpfile.path().file_name().unwrap().to_str().unwrap();
+
+        let url = parse_glob_url(filename)?;
+        assert_eq!(url.scheme(), "file");
+        // The relative name must have been resolved to an absolute path.
+        assert!(url.path().ends_with(filename));
+        assert!(url.path().starts_with('/'));
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_relative_glob_path() -> VortexResult<()> {
+        // A relative path with a glob character (e.g. `./data/*.vortex`) must also resolve
+        // correctly.
+        let tmpdir = tempfile::tempdir_in(".").unwrap();
+        let dir_name = tmpdir.path().file_name().unwrap().to_str().unwrap();
+        let glob = format!("./{dir_name}/*.vortex");
+        let url = parse_glob_url(&glob)?;
+        assert_eq!(url.scheme(), "file");
+        assert!(url.path().starts_with('/'));
+        assert!(url.path().ends_with("/*.vortex"));
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_nonexistent_path() -> VortexResult<()> {
+        // absolute() does not require the path to exist, so a non-existent path succeeds.
+        let url = parse_glob_url("/nonexistent/path/file.vortex")?;
+        assert_eq!(url.scheme(), "file");
+        assert_eq!(url.path(), "/nonexistent/path/file.vortex");
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_glob_url_parent_relative_path() -> VortexResult<()> {
+        // A path starting with `..` must be resolved to an absolute path without
+        // percent-encoding the `..` component in the resulting URL.
+        let tmpfile = tempfile::NamedTempFile::new_in("..").unwrap();
+        let filename = tmpfile.path().file_name().unwrap().to_str().unwrap();
+        let relative = format!("../{filename}");
+
+        let url = parse_glob_url(&relative)?;
+        assert_eq!(url.scheme(), "file");
+        // The resolved path must be absolute and must not contain encoded dots.
+        assert!(url.path().starts_with('/'));
+        assert!(
+            !url.path().contains("%2E"),
+            "path must not contain percent-encoded dots"
+        );
+        assert!(url.path().ends_with(filename));
+        Ok(())
+    }
+
+    // Use absolute paths so the expected result is cwd-independent.
+    #[rstest]
+    #[case("/a/./b", "/a/b")]
+    #[case("/a/b/./c", "/a/b/c")]
+    #[case("/a/../b", "/b")]
+    #[case("/a/b/../c", "/a/c")]
+    #[case("/a/b/../../c", "/c")]
+    #[case("/a/./b/.././c", "/a/c")]
+    #[case("/a/b/../..", "/")]
+    fn test_parse_glob_url_dot_normalization(
+        #[case] input: &str,
+        #[case] expected_path: &str,
+    ) -> VortexResult<()> {
+        let url = parse_glob_url(input)?;
+        assert_eq!(url.scheme(), "file");
+        assert_eq!(
+            url.path(),
+            expected_path,
+            "input {input:?} should normalize to {expected_path:?}"
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-ffi/CMakeLists.txt b/vortex-ffi/CMakeLists.txt
new file mode 100644
index 00000000000..7bac7537211
--- /dev/null
+++ b/vortex-ffi/CMakeLists.txt
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+cmake_minimum_required(VERSION 3.10)
+
+project(VortexFFI
+    VERSION 0.0.1
+    LANGUAGES C)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_C_STANDARD 17)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wextra -Wpedantic")
+
+option(BUILD_TESTS "Build tests" OFF)
+
+set(SANITIZER "" CACHE STRING "Build with sanitizers")
+set(TARGET_TRIPLE "" CACHE STRING "Rust target triple for FFI library")
+set(RUST_BUILD_PROFILE "" CACHE STRING "Cargo profile name for the Rust FFI library")
+
+if (NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+if (NOT SANITIZER STREQUAL "")
+    message(NOTICE "Sanitizer: ${SANITIZER}")
+    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        message(FATAL_ERROR "Only debug build is supported for sanitizer builds")
+    endif()
+
+    if (SANITIZER STREQUAL "asan")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address,undefined,leak")
+        if (BUILD_TESTS)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined,leak")
+        endif()
+    elseif (SANITIZER STREQUAL "tsan")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread")
+        if (BUILD_TESTS)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
+        endif()
+    else()
+        message(FATAL_ERROR "Unknown sanitizer ${SANITIZER}")
+    endif()
+endif()
+
+message(NOTICE "Build type: ${CMAKE_BUILD_TYPE}")
+if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" AND
+    NOT CMAKE_BUILD_TYPE STREQUAL "Release" AND
+    NOT CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+    message(FATAL_ERROR "vortex-ffi can only be built in Release, Debug, or RelWithDebInfo mode")
+endif()
+
+if (RUST_BUILD_PROFILE STREQUAL "")
+    if (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        set(RUST_BUILD_PROFILE "release_debug")
+    else()
+        string(TOLOWER ${CMAKE_BUILD_TYPE} RUST_BUILD_PROFILE)
+    endif()
+endif()
+set(LIBRARY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../target/${TARGET_TRIPLE}/${RUST_BUILD_PROFILE}")
+
+if(WIN32)
+    set(LIBRARY_PATH "${LIBRARY_DIR}/libvortex_ffi.lib")
+    set(LIBRARY_PATH_SHARED "${LIBRARY_DIR}/libvortex_ffi.dll")
+elseif(APPLE)
+    set(LIBRARY_PATH "${LIBRARY_DIR}/libvortex_ffi.a")
+    set(LIBRARY_PATH_SHARED "${LIBRARY_DIR}/libvortex_ffi.dylib")
+else()
+    set(LIBRARY_PATH "${LIBRARY_DIR}/libvortex_ffi.a")
+    set(LIBRARY_PATH_SHARED "${LIBRARY_DIR}/libvortex_ffi.so")
+endif()
+
+set(LIBRARY_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/cinclude")
+
+message(NOTICE "
+Library dir ${LIBRARY_DIR}
+Shared library path ${LIBRARY_PATH_SHARED}
+Static library path ${LIBRARY_PATH}
+Headers path ${LIBRARY_HEADERS}")
+
+if (NOT EXISTS "${LIBRARY_PATH_SHARED}")
+    message(FATAL_ERROR "Shared library not found")
+endif()
+if (NOT EXISTS "${LIBRARY_PATH}")
+    message(FATAL_ERROR "Static library not found")
+endif()
+
+add_library(vortex_ffi STATIC IMPORTED)
+set_target_properties(vortex_ffi PROPERTIES
+    IMPORTED_LOCATION "${LIBRARY_PATH}"
+    INTERFACE_INCLUDE_DIRECTORIES "${LIBRARY_HEADERS}"
+)
+
+add_library(vortex_ffi_shared SHARED IMPORTED)
+set_target_properties(vortex_ffi_shared PROPERTIES
+    IMPORTED_LOCATION "${LIBRARY_PATH_SHARED}"
+    INTERFACE_INCLUDE_DIRECTORIES "${LIBRARY_HEADERS}"
+    INTERFACE_LINK_OPTIONS "LINKER:-rpath,${LIBRARY_DIR}"
+)
+
+if (BUILD_TESTS)
+    enable_language(CXX)
+    set(CMAKE_CXX_STANDARD 20)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -Wpedantic")
+
+    enable_testing()
+    add_subdirectory(test)
+endif()
diff --git a/vortex-ffi/Cargo.toml b/vortex-ffi/Cargo.toml
index 377e1125dc1..27f2c7b6140 100644
--- a/vortex-ffi/Cargo.toml
+++ b/vortex-ffi/Cargo.toml
@@ -34,12 +34,12 @@ vortex = { workspace = true, features = ["object_store"] }
 
 [dev-dependencies]
 tempfile = { workspace = true }
+vortex-array = { workspace = true, features = ["_test-harness"] }
 
 [build-dependencies]
 cbindgen = { workspace = true }
 
 [features]
-default = ["mimalloc"]
 mimalloc = ["dep:mimalloc"]
 
 [lib]
diff --git a/vortex-ffi/README.md b/vortex-ffi/README.md
index fb00c084681..35911ccccc2 100644
--- a/vortex-ffi/README.md
+++ b/vortex-ffi/README.md
@@ -26,17 +26,91 @@ item cannot be referenced in the documentation if it does not have a documentati
 
 ## Updating Headers
 
-To rebuild the header file (requires nightly toolchain):
+To rebuild the header file:
 
-```shell
+```sh
 cargo +nightly build -p vortex-ffi
 ```
 
 The header generation uses cbindgen's macro expansion feature which requires nightly.
 Stable builds use the checked-in header file at `cinclude/vortex.h`.
 
-### Development Workflow
+### Testing C part
 
-- **For header changes**: Use nightly toolchain to regenerate headers after modifying FFI code
-- **For regular development**: Stable toolchain builds work with existing checked-in headers
-- **CI validation**: Automated checks verify header freshness using nightly toolchain
+Build the test library
+
+```sh
+cmake -Bbuild
+cmake --build build -j $(nproc)
+```
+
+Run the tests
+
+```sh
+ctest --test-dir build -j $(nproc)
+```
+
+You would need C++ compiler toolchain to run the tests since they use Catch2.
+
+### Testing Rust part with sanitizers
+
+AddressSanitizer:
+
+```sh
+# inside vortex-ffi
+RUSTFLAGS="-Z sanitizer=address" \
+cargo +nightly test -Zbuild-std \
+    --no-default-features --target <target triple> \
+    -- --no-capture
+```
+
+MemorySanitizer:
+
+```sh
+RUSTFLAGS="-Z sanitizer=memory -Cunsafe-allow-abi-mismatch=sanitizer" \
+cargo +nightly test -Zbuild-std \
+    --no-default-features --target <target triple> \
+    -- --no-capture
+```
+
+ThreadSanitizer:
+
+```sh
+TSAN_OPTIONS="suppressions=$HOME/vortex/vortex-ffi/tsan_suppressions.txt" \
+RUSTFLAGS="-Z sanitizer=thread -Cunsafe-allow-abi-mismatch=sanitizer" \
+cargo +nightly test -Zbuild-std \
+    --no-default-features --target <target triple> \
+    -- --no-capture
+```
+
+- `-Zbuild-std` is needed as memory and thread sanitizers report std errors
+  otherwise.
+- `--no-default-features` is needed as we use Mimalloc otherwise which interferes
+with sanitizers.
+- `allow-abi-mismatch` is safe because in our dependency graph only crates like
+  `compiler_builtins` unset sanitization, and they do it on purpose.
+- Make sure to use `cargo test` and not `cargo nextest` as nextest reports less
+leaks.
+- If you want stack trace symbolization, install `llvm-symbolizer`.
+
+### Testing Rust and C with sanitizers
+
+1. Build FFI library with external sanitizer runtime:
+
+```sh
+RUSTFLAGS="-Zsanitizer=address -Zexternal-clangrt" \
+cargo +nightly build -Zbuild-std --target=<target triple> \
+--no-default-features -p vortex-ffi
+```
+
+2. Build tests with target triple
+
+```sh
+cmake -Bbuild -DWITH_ASAN=1 -DTARGET_TRIPLE=<target triple>
+```
+
+3. Run the tests (ctest doesn't output failures in detail):
+
+```
+./build/test/vortex_ffi_test 2>& 1 | rustfilt -i-
+```
diff --git a/vortex-ffi/build.rs b/vortex-ffi/build.rs
index 8c14001790f..c9869522788 100644
--- a/vortex-ffi/build.rs
+++ b/vortex-ffi/build.rs
@@ -2,31 +2,42 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #![allow(clippy::unwrap_used)]
-#![allow(clippy::panic)]
+#![allow(clippy::exit)]
 use std::env;
 use std::path::PathBuf;
 use std::process::Command;
+use std::process::exit;
 
 fn main() {
-    // Set up dependency tracking
-    println!("cargo:rerun-if-changed=src/");
+    println!("cargo:rerun-if-changed=src");
     println!("cargo:rerun-if-changed=cbindgen.toml");
     println!("cargo:rerun-if-changed=Cargo.toml");
     println!("cargo:rerun-if-changed=build.rs");
+    for env in ["MIRI", "MIRIFLAGS", "RUSTFLAGS"] {
+        println!("cargo:rerun-if-env-changed={env}");
+    }
 
-    // Skip header generation in environments where cbindgen macro expansion fails
     if env::var("MIRI").is_ok() || env::var("MIRIFLAGS").is_ok() {
-        println!("cargo:warning=Skipping header generation under miri (cbindgen incompatible)");
+        println!("cargo:info=Skipping header generation under miri (cbindgen incompatible)");
+        return;
+    }
+
+    if env::var("RUSTFLAGS")
+        .unwrap_or_default()
+        .contains("sanitizer")
+    {
+        println!("cargo:info=Skipping header generation due to sanitizers");
         return;
     }
 
-    // We require the macro expansion feature of cbindgen to generate the header, which is only available on nightly.
+    // cbindgen macro expansion is only available on nightly
     let is_nightly = Command::new("rustc")
         .arg("-V")
         .output()
         .map(|output| String::from_utf8_lossy(&output.stdout).contains("nightly"))
         .unwrap_or(false);
     if !is_nightly {
+        println!("cargo:info=Skipping header generation as we're not on nightly");
         return;
     }
 
@@ -65,21 +76,13 @@ fn main() {
                 );
             }
         }
-        Err(e) => {
-            // Check if this might be a sanitizer-related incompatibility
-            let error_msg = e.to_string();
-            let rustflags = env::var("RUSTFLAGS").unwrap_or_default();
-
-            if rustflags.contains("sanitizer") || error_msg.contains("sanitizer") {
-                println!(
-                    "cargo:warning=Skipping header generation due to sanitizer incompatibility"
-                );
-                println!("cargo:warning=Error: {}", e);
+        Err(err) => {
+            if err.to_string().contains("sanitizer") {
+                println!("cargo:info=Skipping header generation due to sanitizers");
                 return;
             }
-
-            // For non-sanitizer errors, fail hard as these indicate real problems
-            panic!("Failed to generate header with cbindgen: {}", e);
+            println!("cargo:error=Failed to generate header with cbindgen: {err}");
+            exit(1);
         }
     }
 }
diff --git a/vortex-ffi/cinclude/vortex.h b/vortex-ffi/cinclude/vortex.h
index b4f9f37ef16..f1f25491b98 100644
--- a/vortex-ffi/cinclude/vortex.h
+++ b/vortex-ffi/cinclude/vortex.h
@@ -18,6 +18,52 @@
  */
 #define BinaryView_MAX_INLINED_SIZE 12
 
+/**
+ * The variant tag for a Vortex data type.
+ */
+typedef enum {
+    /**
+     * Null type.
+     */
+    DTYPE_NULL = 0,
+    /**
+     * Boolean type.
+     */
+    DTYPE_BOOL = 1,
+    /**
+     * Primitive types (e.g., u8, i16, f32, etc.).
+     */
+    DTYPE_PRIMITIVE = 2,
+    /**
+     * Variable-length UTF-8 string type.
+     */
+    DTYPE_UTF8 = 3,
+    /**
+     * Variable-length binary data type.
+     */
+    DTYPE_BINARY = 4,
+    /**
+     * Nested struct type.
+     */
+    DTYPE_STRUCT = 5,
+    /**
+     * Nested list type.
+     */
+    DTYPE_LIST = 6,
+    /**
+     * User-defined extension type.
+     */
+    DTYPE_EXTENSION = 7,
+    /**
+     * Decimal type with fixed precision and scale.
+     */
+    DTYPE_DECIMAL = 8,
+    /**
+     * Nested fixed-size list type.
+     */
+    DTYPE_FIXED_SIZE_LIST = 9,
+} vx_dtype_variant;
+
 /**
  * Variant enum for Vortex primitive types.
  */
@@ -68,51 +114,85 @@ typedef enum {
     PTYPE_F64 = 10,
 } vx_ptype;
 
+typedef enum {
+    /**
+     * Items can't be null
+     */
+    VX_VALIDITY_NON_NULLABLE = 0,
+    /**
+     * All items are valid
+     */
+    VX_VALIDITY_ALL_VALID = 1,
+    /**
+     * All items are invalid
+     */
+    VX_VALIDITY_ALL_INVALID = 2,
+    /**
+     * Items validity is determined by a boolean array. True values in boolean
+     * array are valid, false values are invalid (null)
+     */
+    VX_VALIDITY_ARRAY = 3,
+} vx_validity_type;
+
 /**
- * The variant tag for a Vortex data type.
+ * Equalities, inequalities, and boolean operations over possibly null values.
+ * For most operations, if either side is null, the result is null.
+ * VX_OPERATOR_KLEENE_AND, VX_OPERATOR_KLEENE_OR obey Kleene (three-valued)
+ * logic
  */
 typedef enum {
     /**
-     * Null type.
+     * Expressions are equal.
      */
-    DTYPE_NULL = 0,
+    VX_OPERATOR_EQ = 0,
     /**
-     * Boolean type.
+     * Expressions are not equal.
      */
-    DTYPE_BOOL = 1,
+    VX_OPERATOR_NOT_EQ = 1,
     /**
-     * Primitive types (e.g., u8, i16, f32, etc.).
+     * Expression is greater than another
      */
-    DTYPE_PRIMITIVE = 2,
+    VX_OPERATOR_GT = 2,
     /**
-     * Variable-length UTF-8 string type.
+     * Expression is greater or equal to another
      */
-    DTYPE_UTF8 = 3,
+    VX_OPERATOR_GTE = 3,
     /**
-     * Variable-length binary data type.
+     * Expression is less than another
      */
-    DTYPE_BINARY = 4,
+    VX_OPERATOR_LT = 4,
     /**
-     * Nested struct type.
+     * Expression is less or equal to another
      */
-    DTYPE_STRUCT = 5,
+    VX_OPERATOR_LTE = 5,
     /**
-     * Nested list type.
+     * Boolean AND /\.
      */
-    DTYPE_LIST = 6,
+    VX_OPERATOR_KLEENE_AND = 6,
     /**
-     * User-defined extension type.
+     * Boolean OR \/.
      */
-    DTYPE_EXTENSION = 7,
+    VX_OPERATOR_KLEENE_OR = 7,
     /**
-     * Decimal type with fixed precision and scale.
+     * The sum of the arguments.
+     * Errors at runtime if the sum would overflow or underflow.
      */
-    DTYPE_DECIMAL = 8,
+    VX_OPERATOR_ADD = 8,
     /**
-     * Nested fixed-size list type.
+     * The difference between the arguments.
+     * Errors at runtime if the sum would overflow or underflow.
+     * The result is null at any index where either input is null.
      */
-    DTYPE_FIXED_SIZE_LIST = 9,
-} vx_dtype_variant;
+    VX_OPERATOR_SUB = 9,
+    /**
+     * Multiply two numbers
+     */
+    VX_OPERATOR_MUL = 10,
+    /**
+     * Divide the left side by the right side
+     */
+    VX_OPERATOR_DIV = 11,
+} vx_binary_operator;
 
 /**
  * Log levels for the Vortex library.
@@ -233,16 +313,23 @@ typedef struct DType DType;
  */
 typedef struct Nullability Nullability;
 
+typedef struct Primitive Primitive;
+
 /**
- * Base type for all Vortex arrays.
+ * Arrays are reference-counted handles to owned memory buffers that hold
+ * scalars. These buffers can be held in a number of physical encodings to
+ * perform lightweight compression that exploits the particular data
+ * distribution of the array's values.
+ *
+ * Every data type recognized by Vortex also has a canonical physical
+ * encoding format, which arrays can be canonicalized into for ease of
+ * access in compute functions.
  *
- * All built-in Vortex array types can be safely cast to this type to pass into functions that
- * expect a generic array type. e.g.
+ * As an implementation detail, vx_array Arc'ed inside, so cloning an
+ * array is a cheap operation.
  *
- * ```cpp
- * auto primitive_array = vx_array_primitive_new(...);
- * vx_array_len((*vx_array) primitive_array));
- * ```
+ * Unless stated explicitly, all operations with vx_array don't take
+ * ownership of it, and thus it must be freed by the caller.
  */
 typedef struct vx_array vx_array;
 
@@ -295,6 +382,22 @@ typedef struct vx_dtype vx_dtype;
  */
 typedef struct vx_error vx_error;
 
+/**
+ * A node in a Vortex expression tree.
+ *
+ * Expressions represent scalar computations that can be performed on
+ * data. Each expression consists of an encoding (vtable), heap-allocated
+ * metadata, and child expressions.
+ *
+ * Unless stated explicitly, all expressions returned are owned and must
+ * be freed by the caller.
+ * Unless stated explicitly, if an operation on const vx_expression* is
+ * passed NULL, NULL is returned.
+ * Operations on expressions don't take ownership of input values, and so
+ * input values must be freed by the caller.
+ */
+typedef struct vx_expression vx_expression;
+
 /**
  * A handle to a Vortex file encapsulating the footer and logic for instantiating a reader.
  */
@@ -310,6 +413,8 @@ typedef struct vx_session vx_session;
  */
 typedef struct vx_string vx_string;
 
+typedef struct vx_struct_column_builder vx_struct_column_builder;
+
 /**
  * Represents a Vortex struct data type, without top-level nullability.
  */
@@ -320,6 +425,16 @@ typedef struct vx_struct_fields vx_struct_fields;
  */
 typedef struct vx_struct_fields_builder vx_struct_fields_builder;
 
+typedef struct {
+    vx_validity_type 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
+     * array which must be freed by the caller.
+     */
+    const vx_array *array;
+} vx_validity;
+
 /**
  * Options supplied for opening a file.
  */
@@ -399,6 +514,40 @@ const vx_array *vx_array_clone(const vx_array *ptr);
  */
 void vx_array_free(const vx_array *ptr);
 
+/**
+ * Check if array's dtype is nullable.
+ * As a particular example, a Null array is nullable.
+ */
+bool vx_array_is_nullable(const vx_array *array);
+
+/**
+ * Check array's dtype against a variant.
+ * Equivalent to vx_get_dtype_variant(vx_array_dtype(array)).
+ *
+ * Example:
+ *
+ * const vx_array* array = vx_array_new_null(1);
+ * assert(vx_array_has_dtype(array, DTYPE_NULL));
+ * vx_array_free(array);
+ *
+ */
+bool vx_array_has_dtype(const vx_array *array, vx_dtype_variant variant);
+
+/**
+ * Check whether array has a Primitive dtype with a specific ptype.
+ *
+ * const vx_array* array = vx_array_new_null(1);
+ * assert(!vx_array_is_primitive(array, PTYPE_U32));
+ * vx_array_free(array);
+ *
+ */
+bool vx_array_is_primitive(const vx_array *array, vx_ptype ptype);
+
+/**
+ * Return array's validity as a type and a boolean array.
+ */
+void vx_array_get_validity(const vx_array *array, vx_validity *validity, vx_error **error);
+
 /**
  * Get the length of the array.
  */
@@ -412,57 +561,93 @@ size_t vx_array_len(const vx_array *array);
  */
 const vx_dtype *vx_array_dtype(const vx_array *array);
 
-const vx_array *vx_array_get_field(const vx_array *array, uint32_t index, vx_error **error_out);
+const vx_array *vx_array_get_field(const vx_array *array, size_t index, vx_error **error_out);
+
+const vx_array *vx_array_slice(const vx_array *array, size_t start, size_t stop, vx_error **error_out);
+
+/**
+ * Check whether array's element at index is invalid (null) according to the
+ * validity array. Sets error if index is out of bounds or underlying validity
+ * array is corrupted.
+ */
+bool vx_array_element_is_invalid(const vx_array *array, size_t index, vx_error **error);
 
-const vx_array *vx_array_slice(const vx_array *array, uint32_t start, uint32_t stop, vx_error **error_out);
+/**
+ * Check how many items in the array are invalid (null).
+ */
+size_t vx_array_invalid_count(const vx_array *array, vx_error **error_out);
 
-bool vx_array_is_null(const vx_array *array, uint32_t index, vx_error **_error_out);
+/**
+ * Create a new array with DTYPE_NULL dtype.
+ */
+const vx_array *vx_array_new_null(size_t len);
 
-uint32_t vx_array_null_count(const vx_array *array, vx_error **error_out);
+/**
+ * Create a new primitive array from an existing buffer.
+ * It is caller's responsibility to ensure ptr points to a buffer of correct
+ * type. ptr buffer contents are copied.
+ * validity can't be NULL.
+ *
+ * Example:
+ *
+ * const vx_error* error = NULL;
+ * vx_validity validity = {};
+ * validity.type = VX_VALIDITY_NON_NULLABLE;
+ * uint32_t buffer[] = {1, 2, 3};
+ * const vx_array* array = vx_array_new_primitive(PTYPE_U32, buffer, 3,
+ *     &validity, &error);
+ * vx_array_free(array);
+ *
+ */
+const vx_array *vx_array_new_primitive(vx_ptype ptype,
+                                       const void *ptr,
+                                       size_t len,
+                                       const vx_validity *validity,
+                                       vx_error **error);
 
-uint8_t vx_array_get_u8(const vx_array *array, uint32_t index);
+uint8_t vx_array_get_u8(const vx_array *array, size_t index);
 
-uint8_t vx_array_get_storage_u8(const vx_array *array, uint32_t index);
+uint8_t vx_array_get_storage_u8(const vx_array *array, size_t index);
 
-uint16_t vx_array_get_u16(const vx_array *array, uint32_t index);
+uint16_t vx_array_get_u16(const vx_array *array, size_t index);
 
-uint16_t vx_array_get_storage_u16(const vx_array *array, uint32_t index);
+uint16_t vx_array_get_storage_u16(const vx_array *array, size_t index);
 
-uint32_t vx_array_get_u32(const vx_array *array, uint32_t index);
+uint32_t vx_array_get_u32(const vx_array *array, size_t index);
 
-uint32_t vx_array_get_storage_u32(const vx_array *array, uint32_t index);
+uint32_t vx_array_get_storage_u32(const vx_array *array, size_t index);
 
-uint64_t vx_array_get_u64(const vx_array *array, uint32_t index);
+uint64_t vx_array_get_u64(const vx_array *array, size_t index);
 
-uint64_t vx_array_get_storage_u64(const vx_array *array, uint32_t index);
+uint64_t vx_array_get_storage_u64(const vx_array *array, size_t index);
 
-int8_t vx_array_get_i8(const vx_array *array, uint32_t index);
+int8_t vx_array_get_i8(const vx_array *array, size_t index);
 
-int8_t vx_array_get_storage_i8(const vx_array *array, uint32_t index);
+int8_t vx_array_get_storage_i8(const vx_array *array, size_t index);
 
-int16_t vx_array_get_i16(const vx_array *array, uint32_t index);
+int16_t vx_array_get_i16(const vx_array *array, size_t index);
 
-int16_t vx_array_get_storage_i16(const vx_array *array, uint32_t index);
+int16_t vx_array_get_storage_i16(const vx_array *array, size_t index);
 
-int32_t vx_array_get_i32(const vx_array *array, uint32_t index);
+int32_t vx_array_get_i32(const vx_array *array, size_t index);
 
-int32_t vx_array_get_storage_i32(const vx_array *array, uint32_t index);
+int32_t vx_array_get_storage_i32(const vx_array *array, size_t index);
 
-int64_t vx_array_get_i64(const vx_array *array, uint32_t index);
+int64_t vx_array_get_i64(const vx_array *array, size_t index);
 
-int64_t vx_array_get_storage_i64(const vx_array *array, uint32_t index);
+int64_t vx_array_get_storage_i64(const vx_array *array, size_t index);
 
-uint16_t vx_array_get_f16(const vx_array *array, uint32_t index);
+uint16_t vx_array_get_f16(const vx_array *array, size_t index);
 
-uint16_t vx_array_get_storage_f16(const vx_array *array, uint32_t index);
+uint16_t vx_array_get_storage_f16(const vx_array *array, size_t index);
 
-float vx_array_get_f32(const vx_array *array, uint32_t index);
+float vx_array_get_f32(const vx_array *array, size_t index);
 
-float vx_array_get_storage_f32(const vx_array *array, uint32_t index);
+float vx_array_get_storage_f32(const vx_array *array, size_t index);
 
-double vx_array_get_f64(const vx_array *array, uint32_t index);
+double vx_array_get_f64(const vx_array *array, size_t index);
 
-double vx_array_get_storage_f64(const vx_array *array, uint32_t index);
+double vx_array_get_storage_f64(const vx_array *array, size_t index);
 
 /**
  * Return the utf-8 string at `index` in the array. The pointer will be null if the value at `index` is null.
@@ -476,6 +661,13 @@ const vx_string *vx_array_get_utf8(const vx_array *array, uint32_t index);
  */
 const vx_binary *vx_array_get_binary(const vx_array *array, uint32_t index);
 
+/**
+ * Apply the expression to the array, wrapping it with a ScalarFnArray.
+ * This operation takes constant time as it doesn't execute the underlying
+ * array. Executing the underlying array still takes O(n) time.
+ */
+const vx_array *vx_array_apply(const vx_array *array, const vx_expression *expression, vx_error **error);
+
 /**
  * Free an owned [`vx_array_iterator`] object.
  */
@@ -576,7 +768,7 @@ const vx_dtype *vx_dtype_new_fixed_size_list(const vx_dtype *element, uint32_t s
  *
  * Takes ownership of the `struct_dtype` pointer.
  */
-const vx_dtype *vx_dtype_new_struct(const vx_struct_fields *struct_dtype, bool is_nullable);
+const vx_dtype *vx_dtype_new_struct(vx_struct_fields *struct_dtype, bool is_nullable);
 
 /**
  * Create a new decimal data type.
@@ -675,6 +867,115 @@ void vx_error_free(vx_error *ptr);
  */
 const vx_string *vx_error_get_message(const vx_error *error);
 
+/**
+ * Free an owned [`vx_expression`] object.
+ */
+void vx_expression_free(vx_expression *ptr);
+
+/**
+ * Create a root expression. A root expression, applied to an array in
+ * vx_array_apply, takes the array itself as opposed to functions like
+ * vx_expression_column or vx_expression_select which take the array's parts.
+ *
+ * Example:
+ *
+ * const vx_array* array = ...;
+ * vx_expression* root = vx_expression_root();
+ * const vx_error* error = NULL;
+ * vx_array* applied_array = vx_array_apply(array, root, &error);
+ * // array and applied_array are identical
+ * vx_array_free(applied_array);
+ * vx_expression_free(root);
+ * vx_array_free(array);
+ *
+ */
+vx_expression *vx_expression_root(void);
+
+/**
+ * Create an expression that selects (includes) specific fields from a child
+ * expression. Child expression must have a DTYPE_STRUCT dtype. Errors in
+ * vx_array_apply if the child expression doesn't have a specified field.
+ *
+ * Example:
+ *
+ * vx_expression* root = vx_expression_root();
+ * const char* names[] = {"name", "age"};
+ * vx_expression* select = vx_expression_select(names, 2, root);
+ * vx_expression_free(select);
+ * vx_expression_free(root);
+ *
+ */
+vx_expression *vx_expression_select(const char *const *names, size_t len, const vx_expression *child);
+
+/**
+ * Create an AND expression for multiple child expressions.
+ * If there are no input expressions, returns NULL
+ */
+vx_expression *vx_expression_and(const vx_expression *const *expressions, size_t len);
+
+/**
+ * Create an OR disjunction expression for multiple child expressions.
+ * If there are no input expressions, returns NULL;
+ */
+vx_expression *vx_expression_or(const vx_expression *const *expressions, size_t len);
+
+/**
+ * Create a binary expression for two expressions of form lhs OP rhs.
+ * If either input is NULL, returns NULL.
+ *
+ * Example for a binary sum:
+ *
+ * vx_expression* age = vx_expression_column("age");
+ * vx_expression* height = vx_expression_column("height");
+ * vx_expression* sum = vx_expression_binary(VX_OPERATOR_ADD, age, height);
+ * vx_expression_free(sum);
+ * vx_expression_free(height);
+ * vx_expression_free(age);
+ *
+ * Example for a binary equality function:
+ *
+ * vx_expression* vx_expression_eq(
+ *     const vx_expression* lhs,
+ *     const vx_expression* rhs
+ * ) {
+ *     return vx_expression_binary(VX_OPERATOR_EQ, lhs, rhs);
+ * }
+ *
+ */
+vx_expression *
+vx_expression_binary(vx_binary_operator operator_, const vx_expression *lhs, const vx_expression *rhs);
+
+/**
+ * Create a logical NOT of the child expression.
+ *
+ * Returns the logical negation of the input boolean expression.
+ */
+const vx_expression *vx_expression_not(const vx_expression *child);
+
+/**
+ * Create an expression that checks for null values.
+ *
+ * Returns a boolean array indicating which positions contain null values.
+ */
+vx_expression *vx_expression_is_null(const vx_expression *child);
+
+/**
+ * Create an expression that extracts a named field from a struct expression.
+ * Child expression must have a DTYPE_STRUCT dtype.
+ * Errors in vx_array_apply if the root array doesn't have a specified field.
+ *
+ * Accesses the specified field from the result of the child expression.
+ * Equivalent to select(&item, 1, child).
+ */
+vx_expression *vx_expression_get_item(const char *item, const vx_expression *child);
+
+/**
+ * Create an expression that checks if a value is contained in a list.
+ *
+ * Returns a boolean array indicating whether the value appears in each list.
+ */
+vx_expression *vx_expression_list_contains(const vx_expression *list, const vx_expression *value);
+
 /**
  * Clone a borrowed [`vx_file`], returning an owned [`vx_file`].
  *
@@ -745,6 +1046,13 @@ void vx_session_free(vx_session *ptr);
  */
 vx_session *vx_session_new(void);
 
+/**
+ * Clone a Vortex session, returning an owned copy.
+ *
+ * The caller is responsible for freeing the session with [`vx_session_free`].
+ */
+vx_session *vx_session_clone(const vx_session *session);
+
 /**
  * Opens a writable array stream, where sink is used to push values into the stream.
  * To close the stream close the sink with `vx_array_sink_close`.
@@ -755,7 +1063,8 @@ vx_array_sink *vx_array_sink_open_file(const vx_session *session,
                                        vx_error **error_out);
 
 /**
- * Pushed a single array chunk into a file sink.
+ * Push an array into a file sink.
+ * Does not take ownership of array
  */
 void vx_array_sink_push(vx_array_sink *sink, const vx_array *array, vx_error **error_out);
 
@@ -799,17 +1108,60 @@ size_t vx_string_len(const vx_string *ptr);
 const char *vx_string_ptr(const vx_string *ptr);
 
 /**
- * Clone a borrowed [`vx_struct_fields`], returning an owned [`vx_struct_fields`].
+ * Free an owned [`vx_struct_column_builder`] object.
+ */
+void vx_struct_column_builder_free(vx_struct_column_builder *ptr);
+
+/**
+ * Create a new column-wise struct array builder with given validity and a
+ * capacity hint. validity can't be NULL.
+ * If you don't know capacity, pass 0.
+ * if validity is NULL, returns NULL.
+ */
+vx_struct_column_builder *vx_struct_column_builder_new(const vx_validity *validity, size_t capacity);
+
+/**
+ * Add a named field to a struct array builder.
+ * All arguments must be non-NULL.
+ * If field's length doesn't match lengths of previous fields, sets error.
+ * If an error is returned, the builder is still valid, and caller must
+ * deallocate it using vx_struct_column_builder_free.
+ */
+void vx_struct_column_builder_add_field(vx_struct_column_builder *builder,
+                                        const char *name,
+                                        const vx_array *field,
+                                        vx_error **error);
+
+/**
+ * Finalize a struct array builder, returning a struct array.
+ * Consumes the builder. Caller doesn't need to free the builder after calling
+ * this function.
+ *
+ * Example:
+ *
+ * vx_error* error = NULL;
+ *
+ * vx_validity validity = {};
+ * validity.type = VX_VALIDITY_NON_NULLABLE;
+ *
+ * const vx_array* field_array = vx_array_new_null(5);
+ * const vx_struct_column_builder* builder =
+ *     vx_struct_column_builder_new(&validity, 1);
+ *
+ * vx_struct_column_builder_add_field(builder, "age", field_array, &error);
+ *
+ * vx_array* struct_array = vx_struct_column_builder_finalize(builder, &error);
  *
+ * vx_array_free(struct_array);
+ * vx_array_free(field_array);
  *
- * Must be released with [`vx_struct_fields_free`].
  */
-const vx_struct_fields *vx_struct_fields_clone(const vx_struct_fields *ptr);
+const vx_array *vx_struct_column_builder_finalize(vx_struct_column_builder *builder, vx_error **error);
 
 /**
  * Free an owned [`vx_struct_fields`] object.
  */
-void vx_struct_fields_free(const vx_struct_fields *ptr);
+void vx_struct_fields_free(vx_struct_fields *ptr);
 
 /**
  * Return the number of fields in the struct dtype.
@@ -860,7 +1212,7 @@ void vx_struct_fields_builder_add_field(vx_struct_fields_builder *builder,
  *
  * Takes ownership of the `builder`.
  */
-const vx_struct_fields *vx_struct_fields_builder_finalize(vx_struct_fields_builder *builder);
+vx_struct_fields *vx_struct_fields_builder_finalize(vx_struct_fields_builder *builder);
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/vortex-ffi/examples/hello_vortex.rs b/vortex-ffi/examples/hello_vortex.rs
index c6ca24d9b8f..a87d0338292 100644
--- a/vortex-ffi/examples/hello_vortex.rs
+++ b/vortex-ffi/examples/hello_vortex.rs
@@ -18,7 +18,6 @@ use std::process::Command;
 use std::sync::LazyLock;
 
 use vortex::VortexSessionDefault;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::arrays::ChunkedArray;
@@ -156,7 +155,7 @@ async fn write_vortex_file(path: impl AsRef<Path>) -> VortexResult<()> {
 
     SESSION
         .write_options()
-        .write(&mut file, test_data.to_array_stream())
+        .write(&mut file, test_data.into_array().to_array_stream())
         .await?;
     file.shutdown().await?;
 
diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs
index 54d794f52a5..776a91f3216 100644
--- a/vortex-ffi/src/array.rs
+++ b/vortex-ffi/src/array.rs
@@ -1,37 +1,183 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
+#![allow(non_camel_case_types)]
 
 //! FFI interface for working with Vortex Arrays.
+use std::ffi::c_void;
 use std::ptr;
 use std::sync::Arc;
 
-use vortex::array::Array;
+use paste::paste;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::ToCanonical;
+use vortex::array::arrays::NullArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::struct_::StructArrayExt;
+use vortex::array::validity::Validity;
+use vortex::buffer::Buffer;
+use vortex::dtype::DType;
 use vortex::dtype::half::f16;
 use vortex::error::VortexExpect;
+use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
 
-use crate::arc_dyn_wrapper;
+use crate::arc_wrapper;
 use crate::binary::vx_binary;
 use crate::dtype::vx_dtype;
+use crate::dtype::vx_dtype_variant;
 use crate::error::try_or_default;
 use crate::error::vx_error;
+use crate::error::write_error;
+use crate::expression::vx_expression;
+use crate::ptype::vx_ptype;
 use crate::string::vx_string;
 
-arc_dyn_wrapper!(
-    /// Base type for all Vortex arrays.
+arc_wrapper!(
+    /// Arrays are reference-counted handles to owned memory buffers that hold
+    /// scalars. These buffers can be held in a number of physical encodings to
+    /// perform lightweight compression that exploits the particular data
+    /// distribution of the array's values.
     ///
-    /// All built-in Vortex array types can be safely cast to this type to pass into functions that
-    /// expect a generic array type. e.g.
+    /// Every data type recognized by Vortex also has a canonical physical
+    /// encoding format, which arrays can be canonicalized into for ease of
+    /// access in compute functions.
     ///
-    /// ```cpp
-    /// auto primitive_array = vx_array_primitive_new(...);
-    /// vx_array_len((*vx_array) primitive_array));
-    /// ```
-    dyn Array,
+    /// As an implementation detail, vx_array Arc'ed inside, so cloning an
+    /// array is a cheap operation.
+    ///
+    /// Unless stated explicitly, all operations with vx_array don't take
+    /// ownership of it, and thus it must be freed by the caller.
+    ArrayRef,
     vx_array
 );
 
+/// Check if array's dtype is nullable.
+/// As a particular example, a Null array is nullable.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_array_is_nullable(array: *const vx_array) -> bool {
+    if array.is_null() {
+        return false;
+    }
+    vx_array::as_ref(array).dtype().is_nullable()
+}
+
+/// Check array's dtype against a variant.
+/// Equivalent to vx_get_dtype_variant(vx_array_dtype(array)).
+///
+/// Example:
+///
+/// const vx_array* array = vx_array_new_null(1);
+/// assert(vx_array_has_dtype(array, DTYPE_NULL));
+/// vx_array_free(array);
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_array_has_dtype(
+    array: *const vx_array,
+    variant: vx_dtype_variant,
+) -> bool {
+    if array.is_null() {
+        return false;
+    }
+    let other: vx_dtype_variant = vx_array::as_ref(array).dtype().into();
+    other == variant
+}
+
+/// Check whether array has a Primitive dtype with a specific ptype.
+///
+/// const vx_array* array = vx_array_new_null(1);
+/// assert(!vx_array_is_primitive(array, PTYPE_U32));
+/// vx_array_free(array);
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_array_is_primitive(
+    array: *const vx_array,
+    ptype: vx_ptype,
+) -> bool {
+    if array.is_null() {
+        return false;
+    }
+    let ptype = ptype.into();
+    match vx_array::as_ref(array).dtype() {
+        DType::Primitive(other, _) => other == &ptype,
+        _ => false,
+    }
+}
+
+#[repr(C)]
+pub enum vx_validity_type {
+    /// Items can't be null
+    VX_VALIDITY_NON_NULLABLE = 0,
+    /// All items are valid
+    VX_VALIDITY_ALL_VALID = 1,
+    /// All items are invalid
+    VX_VALIDITY_ALL_INVALID = 2,
+    /// Items validity is determined by a boolean array. True values in boolean
+    /// array are valid, false values are invalid (null)
+    VX_VALIDITY_ARRAY = 3,
+}
+
+#[repr(C)]
+pub struct vx_validity {
+    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
+    /// array which must be freed by the caller.
+    pub array: *const vx_array,
+}
+
+impl From<&vx_validity> for Validity {
+    fn from(validity: &vx_validity) -> Self {
+        match validity.r#type {
+            vx_validity_type::VX_VALIDITY_NON_NULLABLE => Validity::NonNullable,
+            vx_validity_type::VX_VALIDITY_ALL_VALID => Validity::AllValid,
+            vx_validity_type::VX_VALIDITY_ALL_INVALID => Validity::AllInvalid,
+            vx_validity_type::VX_VALIDITY_ARRAY => {
+                Validity::Array(vx_array::as_ref(validity.array).clone())
+            }
+        }
+    }
+}
+
+impl From<Validity> for vx_validity {
+    fn from(validity: Validity) -> Self {
+        match validity {
+            Validity::NonNullable => vx_validity {
+                r#type: vx_validity_type::VX_VALIDITY_NON_NULLABLE,
+                array: ptr::null(),
+            },
+            Validity::AllValid => vx_validity {
+                r#type: vx_validity_type::VX_VALIDITY_ALL_VALID,
+                array: ptr::null(),
+            },
+            Validity::AllInvalid => vx_validity {
+                r#type: vx_validity_type::VX_VALIDITY_ALL_INVALID,
+                array: ptr::null(),
+            },
+            Validity::Array(array) => vx_validity {
+                r#type: vx_validity_type::VX_VALIDITY_ARRAY,
+                array: vx_array::new(Arc::new(array)),
+            },
+        }
+    }
+}
+
+/// Return array's validity as a type and a boolean array.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_array_get_validity(
+    array: *const vx_array,
+    validity: *mut vx_validity,
+    error: *mut *mut vx_error,
+) {
+    try_or_default(error, || {
+        vortex_ensure!(!array.is_null());
+        vortex_ensure!(!validity.is_null());
+        let array = vx_array::as_ref(array);
+        *unsafe { &mut *validity } = array.validity()?.into();
+        Ok(())
+    });
+}
+
 /// Get the length of the array.
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_array_len(array: *const vx_array) -> usize {
@@ -50,7 +196,7 @@ pub unsafe extern "C-unwind" fn vx_array_dtype(array: *const vx_array) -> *const
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_array_get_field(
     array: *const vx_array,
-    index: u32,
+    index: usize,
     error_out: *mut *mut vx_error,
 ) -> *const vx_array {
     try_or_default(error_out, || {
@@ -59,59 +205,128 @@ pub unsafe extern "C-unwind" fn vx_array_get_field(
         let field_array = array
             .to_struct()
             .unmasked_fields()
-            .get(index as usize)
+            .get(index)
             .ok_or_else(|| vortex_err!("Field index out of bounds"))?
             .clone();
 
-        Ok(vx_array::new(field_array))
+        Ok(vx_array::new(Arc::new(field_array)))
     })
 }
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_array_slice(
     array: *const vx_array,
-    start: u32,
-    stop: u32,
+    start: usize,
+    stop: usize,
     error_out: *mut *mut vx_error,
 ) -> *const vx_array {
     try_or_default(error_out, || {
         let array = vx_array::as_ref(array);
-        let sliced = array.slice(start as usize..stop as usize)?;
-        Ok(vx_array::new(sliced))
+        let sliced = array.slice(start..stop)?;
+        Ok(vx_array::new(Arc::new(sliced)))
     })
 }
 
+/// Check whether array's element at index is invalid (null) according to the
+/// validity array. Sets error if index is out of bounds or underlying validity
+/// array is corrupted.
 #[unsafe(no_mangle)]
-pub unsafe extern "C-unwind" fn vx_array_is_null(
+pub unsafe extern "C-unwind" fn vx_array_element_is_invalid(
     array: *const vx_array,
-    index: u32,
-    _error_out: *mut *mut vx_error,
+    index: usize,
+    error: *mut *mut vx_error,
 ) -> bool {
-    let array = vx_array::as_ref(array);
-    // TODO(joe): propagate this error up instead of expecting
-    array
-        .is_invalid(index as usize)
-        .vortex_expect("is_invalid failed")
+    try_or_default(error, || {
+        vortex_ensure!(!array.is_null());
+        vx_array::as_ref(array).is_invalid(index)
+    })
 }
 
-// TODO(robert): Make this return usize and remove error
+/// Check how many items in the array are invalid (null).
 #[unsafe(no_mangle)]
-pub unsafe extern "C-unwind" fn vx_array_null_count(
+pub unsafe extern "C-unwind" fn vx_array_invalid_count(
     array: *const vx_array,
     error_out: *mut *mut vx_error,
-) -> u32 {
-    let array = vx_array::as_ref(array);
-    try_or_default(error_out, || Ok(array.invalid_count()?.try_into()?))
+) -> usize {
+    try_or_default(error_out, || {
+        vortex_ensure!(!array.is_null());
+        let array = vx_array::as_ref(array);
+        array.invalid_count()
+    })
+}
+
+/// Create a new array with DTYPE_NULL dtype.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_array_new_null(len: usize) -> *const vx_array {
+    vx_array::new(Arc::new(NullArray::new(len).into_array()))
+}
+
+/// SAFETY:
+/// `ptr` must be valid for `len` reads of `T`, properly aligned,
+/// and must not be null if `len > 0`.
+unsafe fn primitive_from_raw<T: vortex::dtype::NativePType>(
+    ptr: *const T,
+    len: usize,
+    validity: &vx_validity,
+) -> *const vx_array {
+    let slice = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let buffer = Buffer::copy_from(slice);
+    let array = PrimitiveArray::new(buffer, validity.into());
+    vx_array::new(Arc::new(array.into_array()))
+}
+
+/// Create a new primitive array from an existing buffer.
+/// It is caller's responsibility to ensure ptr points to a buffer of correct
+/// type. ptr buffer contents are copied.
+/// validity can't be NULL.
+///
+/// Example:
+///
+/// const vx_error* error = NULL;
+/// vx_validity validity = {};
+/// validity.type = VX_VALIDITY_NON_NULLABLE;
+/// uint32_t buffer[] = {1, 2, 3};
+/// const vx_array* array = vx_array_new_primitive(PTYPE_U32, buffer, 3,
+///     &validity, &error);
+/// vx_array_free(array);
+///
+#[unsafe(no_mangle)]
+pub extern "C-unwind" fn vx_array_new_primitive(
+    ptype: vx_ptype,
+    ptr: *const c_void,
+    len: usize,
+    validity: *const vx_validity,
+    error: *mut *mut vx_error,
+) -> *const vx_array {
+    if validity.is_null() {
+        write_error(error, "validity is NULL");
+        return ptr::null_mut();
+    }
+    let validity = unsafe { &*validity };
+
+    match ptype {
+        vx_ptype::PTYPE_U8 => unsafe { primitive_from_raw(ptr as *const u8, len, validity) },
+        vx_ptype::PTYPE_U16 => unsafe { primitive_from_raw(ptr as *const u16, len, validity) },
+        vx_ptype::PTYPE_U32 => unsafe { primitive_from_raw(ptr as *const u32, len, validity) },
+        vx_ptype::PTYPE_U64 => unsafe { primitive_from_raw(ptr as *const u64, len, validity) },
+        vx_ptype::PTYPE_I8 => unsafe { primitive_from_raw(ptr as *const i8, len, validity) },
+        vx_ptype::PTYPE_I16 => unsafe { primitive_from_raw(ptr as *const i16, len, validity) },
+        vx_ptype::PTYPE_I32 => unsafe { primitive_from_raw(ptr as *const i32, len, validity) },
+        vx_ptype::PTYPE_I64 => unsafe { primitive_from_raw(ptr as *const i64, len, validity) },
+        vx_ptype::PTYPE_F16 => unsafe { primitive_from_raw(ptr as *const f16, len, validity) },
+        vx_ptype::PTYPE_F32 => unsafe { primitive_from_raw(ptr as *const f32, len, validity) },
+        vx_ptype::PTYPE_F64 => unsafe { primitive_from_raw(ptr as *const f64, len, validity) },
+    }
 }
 
 macro_rules! ffiarray_get_ptype {
     ($ptype:ident) => {
-        paste::paste! {
+        paste! {
             #[unsafe(no_mangle)]
-            pub unsafe extern "C-unwind" fn [<vx_array_get_ $ptype>](array: *const vx_array, index: u32) -> $ptype {
+            pub unsafe extern "C-unwind" fn [<vx_array_get_ $ptype>](array: *const vx_array, index: usize) -> $ptype {
                 let array = vx_array::as_ref(array);
                 // TODO(joe): propagate this error up instead of expecting
-                let value = array.scalar_at(index as usize).vortex_expect("scalar_at failed");
+                let value = array.scalar_at(index).vortex_expect("scalar_at failed");
                 // TODO(joe): propagate this error up instead of expecting
                 value.as_primitive()
                     .as_::<$ptype>()
@@ -119,10 +334,10 @@ macro_rules! ffiarray_get_ptype {
             }
 
             #[unsafe(no_mangle)]
-            pub unsafe extern "C-unwind" fn [<vx_array_get_storage_ $ptype>](array: *const vx_array, index: u32) -> $ptype {
+            pub unsafe extern "C-unwind" fn [<vx_array_get_storage_ $ptype>](array: *const vx_array, index: usize) -> $ptype {
                 let array = vx_array::as_ref(array);
                 // TODO(joe): propagate this error up instead of expecting
-                let value = array.scalar_at(index as usize).vortex_expect("scalar_at failed");
+                let value = array.scalar_at(index).vortex_expect("scalar_at failed");
                 // TODO(joe): propagate this error up instead of expecting
                 value.as_extension()
                     .to_storage_scalar()
@@ -186,32 +401,69 @@ pub unsafe extern "C-unwind" fn vx_array_get_binary(
     }
 }
 
+/// Apply the expression to the array, wrapping it with a ScalarFnArray.
+/// This operation takes constant time as it doesn't execute the underlying
+/// array. Executing the underlying array still takes O(n) time.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_array_apply(
+    array: *const vx_array,
+    expression: *const vx_expression,
+    error: *mut *mut vx_error,
+) -> *const vx_array {
+    try_or_default(error, || {
+        vortex_ensure!(!array.is_null());
+        vortex_ensure!(!expression.is_null());
+        let array = vx_array::as_ref(array);
+        let expression = vx_expression::as_ref(expression);
+        Ok(vx_array::new(Arc::new(array.clone().apply(expression)?)))
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use std::ptr;
 
     use vortex::array::IntoArray;
+    use vortex::array::arrays::BoolArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::StructArray;
     use vortex::array::arrays::VarBinViewArray;
+    use vortex::array::arrays::bool::BoolArrayExt;
     use vortex::array::validity::Validity;
-    use vortex::buffer::Buffer;
     use vortex::buffer::buffer;
     #[cfg(not(miri))]
     use vortex::dtype::half::f16;
+    use vortex::expr::eq;
+    use vortex::expr::lit;
+    use vortex::expr::root;
 
     use crate::array::*;
     use crate::binary::vx_binary_free;
     use crate::dtype::vx_dtype_get_variant;
     use crate::dtype::vx_dtype_variant;
     use crate::error::vx_error_free;
+    use crate::error::vx_error_get_message;
+    use crate::expression::vx_expression_free;
     use crate::string::vx_string_free;
 
+    fn assert_no_error(error: *mut vx_error) {
+        if !error.is_null() {
+            let message;
+            unsafe {
+                message = vx_string::as_str(vx_error_get_message(error)).to_owned();
+                vx_error_free(error);
+            }
+            panic!("{message}");
+        }
+    }
+
     #[test]
+    // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_simple() {
         unsafe {
             let primitive = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-            let ffi_array = vx_array::new(primitive.into_array());
+            let ffi_array = vx_array::new(Arc::new(primitive.into_array()));
 
             assert_eq!(vx_array_len(ffi_array), 3);
 
@@ -230,15 +482,30 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_simple_is() {
+        unsafe {
+            let primitive =
+                PrimitiveArray::new(buffer![1i32, 2i32, 3i32, 4i32, 5i32], Validity::NonNullable);
+            let array = vx_array::new(Arc::new(primitive.into_array()));
+            assert!(!vx_array_is_nullable(array));
+            assert!(vx_array_is_primitive(array, vx_ptype::PTYPE_I32));
+            vx_array_free(array);
+        }
+    }
+
+    #[test]
+    // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_slice() {
         unsafe {
             let primitive =
                 PrimitiveArray::new(buffer![1i32, 2i32, 3i32, 4i32, 5i32], Validity::NonNullable);
-            let ffi_array = vx_array::new(primitive.into_array());
+            let ffi_array = vx_array::new(Arc::new(primitive.into_array()));
 
             let mut error = ptr::null_mut();
             let sliced = vx_array_slice(ffi_array, 1, 4, &raw mut error);
-            assert!(error.is_null());
+            assert_no_error(error);
             assert_eq!(vx_array_len(sliced), 3);
             assert_eq!(vx_array_get_i32(sliced, 0), 2);
             assert_eq!(vx_array_get_i32(sliced, 1), 3);
@@ -250,26 +517,26 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)]
     // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_null_operations() {
         unsafe {
             let primitive = PrimitiveArray::new(
                 buffer![1i32, 2i32, 3i32],
                 Validity::from_iter([true, false, true]),
             );
-            let ffi_array = vx_array::new(primitive.into_array());
+            let ffi_array = vx_array::new(Arc::new(primitive.into_array()));
 
             let mut error = ptr::null_mut();
-            assert!(!vx_array_is_null(ffi_array, 0, &raw mut error));
-            assert!(error.is_null());
-            assert!(vx_array_is_null(ffi_array, 1, &raw mut error));
-            assert!(error.is_null());
-            assert!(!vx_array_is_null(ffi_array, 2, &raw mut error));
-            assert!(error.is_null());
-
-            let null_count = vx_array_null_count(ffi_array, &raw mut error);
-            assert!(error.is_null());
+            assert!(!vx_array_element_is_invalid(ffi_array, 0, &raw mut error));
+            assert_no_error(error);
+            assert!(vx_array_element_is_invalid(ffi_array, 1, &raw mut error));
+            assert_no_error(error);
+            assert!(!vx_array_element_is_invalid(ffi_array, 2, &raw mut error));
+            assert_no_error(error);
+
+            let null_count = vx_array_invalid_count(ffi_array, &raw mut error);
+            assert_no_error(error);
             assert_eq!(null_count, 1);
 
             vx_array_free(ffi_array);
@@ -277,8 +544,8 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)]
     // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_get_field() {
         unsafe {
             let names = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]);
@@ -290,15 +557,15 @@ mod tests {
                 Validity::NonNullable,
             )
             .unwrap();
-            let ffi_array = vx_array::new(struct_array.into_array());
+            let ffi_array = vx_array::new(Arc::new(struct_array.into_array()));
 
             let mut error = ptr::null_mut();
             let field0 = vx_array_get_field(ffi_array, 0, &raw mut error);
-            assert!(error.is_null());
+            assert_no_error(error);
             assert_eq!(vx_array_len(field0), 3);
 
             let field1 = vx_array_get_field(ffi_array, 1, &raw mut error);
-            assert!(error.is_null());
+            assert_no_error(error);
             assert_eq!(vx_array_len(field1), 3);
             assert_eq!(vx_array_get_u8(field1, 0), 30);
             assert_eq!(vx_array_get_u8(field1, 1), 25);
@@ -317,35 +584,66 @@ mod tests {
     }
 
     #[test]
+    // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_primitive_getters() {
         unsafe {
             // Test a representative sample of primitive types
             // The macro generates identical code for all types, so exhaustive testing is redundant
 
             // Test signed integer with edge cases
-            let i32_array =
-                PrimitiveArray::new(buffer![i32::MAX, i32::MIN, 0i32], Validity::NonNullable);
-            let ffi_i32 = vx_array::new(i32_array.into_array());
+            let mut error = ptr::null_mut();
+            let validity = vx_validity {
+                r#type: vx_validity_type::VX_VALIDITY_NON_NULLABLE,
+                array: ptr::null(),
+            };
+
+            let i32_array = [i32::MAX, i32::MIN, 0];
+            let ffi_i32 = vx_array_new_primitive(
+                vx_ptype::PTYPE_I32,
+                i32_array.as_ptr() as *const c_void,
+                i32_array.len(),
+                &raw const validity,
+                &raw mut error,
+            );
+            assert_no_error(error);
+            assert!(!ffi_i32.is_null());
+
+            assert!(vx_array_is_primitive(ffi_i32, vx_ptype::PTYPE_I32));
             assert_eq!(vx_array_get_i32(ffi_i32, 0), i32::MAX);
             assert_eq!(vx_array_get_i32(ffi_i32, 1), i32::MIN);
             assert_eq!(vx_array_get_i32(ffi_i32, 2), 0);
             vx_array_free(ffi_i32);
 
             // Test unsigned integer
-            let u64_array =
-                PrimitiveArray::new(buffer![u64::MAX, 0u64, 42u64], Validity::NonNullable);
-            let ffi_u64 = vx_array::new(u64_array.into_array());
+            let u64_array = [u64::MAX, 0u64, 42u64];
+            let ffi_u64 = vx_array_new_primitive(
+                vx_ptype::PTYPE_U64,
+                u64_array.as_ptr() as *const c_void,
+                u64_array.len(),
+                &raw const validity,
+                &raw mut error,
+            );
+            assert_no_error(error);
+            assert!(!ffi_u64.is_null());
+            assert!(vx_array_is_primitive(ffi_u64, vx_ptype::PTYPE_U64));
             assert_eq!(vx_array_get_u64(ffi_u64, 0), u64::MAX);
             assert_eq!(vx_array_get_u64(ffi_u64, 1), 0);
             assert_eq!(vx_array_get_u64(ffi_u64, 2), 42);
             vx_array_free(ffi_u64);
 
             // Test floating point including special values
-            let f64_array = PrimitiveArray::new(
-                buffer![f64::NEG_INFINITY, 0.0f64, f64::NAN],
-                Validity::NonNullable,
+            let f64_array = [f64::NEG_INFINITY, 0.0f64, f64::NAN];
+            let ffi_f64 = vx_array_new_primitive(
+                vx_ptype::PTYPE_F64,
+                f64_array.as_ptr() as *const c_void,
+                f64_array.len(),
+                &raw const validity,
+                &raw mut error,
             );
-            let ffi_f64 = vx_array::new(f64_array.into_array());
+            assert_no_error(error);
+            assert!(!ffi_f64.is_null());
+            assert!(vx_array_is_primitive(ffi_f64, vx_ptype::PTYPE_F64));
             assert_eq!(vx_array_get_f64(ffi_f64, 0), f64::NEG_INFINITY);
             assert_eq!(vx_array_get_f64(ffi_f64, 1), 0.0);
             assert!(vx_array_get_f64(ffi_f64, 2).is_nan());
@@ -354,11 +652,16 @@ mod tests {
             // Test f16 (special half-precision type) - skip in Miri due to inline assembly
             #[cfg(not(miri))]
             {
-                let f16_array = PrimitiveArray::new(
-                    buffer![f16::from_f32(1.0), f16::from_f32(-0.5)],
-                    Validity::NonNullable,
+                let f16_array = [f16::from_f32(1.0), f16::from_f32(-0.5)];
+                let ffi_f16 = vx_array_new_primitive(
+                    vx_ptype::PTYPE_F16,
+                    f16_array.as_ptr() as *const c_void,
+                    f16_array.len(),
+                    &raw const validity,
+                    &raw mut error,
                 );
-                let ffi_f16 = vx_array::new(f16_array.into_array());
+                assert_no_error(error);
+                assert!(!ffi_f16.is_null());
                 assert_eq!(vx_array_get_f16(ffi_f16, 0), f16::from_f32(1.0));
                 assert_eq!(vx_array_get_f16(ffi_f16, 1), f16::from_f32(-0.5));
                 vx_array_free(ffi_f16);
@@ -367,10 +670,13 @@ mod tests {
     }
 
     #[test]
+    // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_get_utf8() {
         unsafe {
             let utf8_array = VarBinViewArray::from_iter_str(["hello", "world", "test"]);
-            let ffi_array = vx_array::new(utf8_array.into_array());
+            let ffi_array = vx_array::new(Arc::new(utf8_array.into_array()));
+            assert!(vx_array_has_dtype(ffi_array, vx_dtype_variant::DTYPE_UTF8));
 
             let vx_str1 = vx_array_get_utf8(ffi_array, 0);
             assert_eq!(vx_string::as_str(vx_str1), "hello");
@@ -389,6 +695,8 @@ mod tests {
     }
 
     #[test]
+    // TODO(joe): enable once this is fixed https://github.com/Amanieu/parking_lot/issues/477
+    #[cfg_attr(miri, ignore)]
     fn test_get_binary() {
         unsafe {
             let binary_array = VarBinViewArray::from_iter_bin(vec![
@@ -396,7 +704,11 @@ mod tests {
                 vec![0xFF, 0xEE],
                 vec![0xAA, 0xBB, 0xCC, 0xDD],
             ]);
-            let ffi_array = vx_array::new(binary_array.into_array());
+            let ffi_array = vx_array::new(Arc::new(binary_array.into_array()));
+            assert!(vx_array_has_dtype(
+                ffi_array,
+                vx_dtype_variant::DTYPE_BINARY
+            ));
 
             let vx_bin1 = vx_array_get_binary(ffi_array, 0);
             assert_eq!(vx_binary::as_slice(vx_bin1), &[0x01, 0x02, 0x03]);
@@ -414,6 +726,55 @@ mod tests {
         }
     }
 
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_apply() {
+        let primitive = PrimitiveArray::new(
+            buffer![1i32, 2i32, 3i32, 3i32],
+            Validity::from_iter([true, false, true, true]),
+        );
+
+        unsafe {
+            let mut error = ptr::null_mut();
+
+            let res = vx_array_apply(ptr::null(), ptr::null(), &raw mut error);
+            assert!(res.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+
+            let array = vx_array::new(Arc::new(primitive.into_array()));
+
+            let res = vx_array_apply(array, ptr::null(), &raw mut error);
+            assert!(res.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+
+            // Test with Vortex Rust-side expressions here, test C API for
+            // expressions in src/expressions.rs
+            let expression = eq(root(), lit(3i32));
+            let expression = vx_expression::new(expression);
+
+            let res = vx_array_apply(ptr::null(), expression, &raw mut error);
+            assert!(res.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+
+            let res = vx_array_apply(array, expression, &raw mut error);
+            assert_no_error(error);
+            assert!(!res.is_null());
+            {
+                let res = vx_array::as_ref(res);
+                let buffer = res.to_bool().to_bit_buffer();
+                let expected = BoolArray::from_iter(vec![false, false, true, true]);
+                assert_eq!(buffer, expected.to_bit_buffer());
+            }
+            vx_array_free(res);
+
+            vx_expression_free(expression);
+            vx_array_free(array);
+        }
+    }
+
     #[test]
     fn test_array_dtype_lifetime_pattern() {
         let array = {
@@ -427,7 +788,8 @@ mod tests {
             .unwrap()
             .into_array()
         };
-        let vx_arr = vx_array::new(array);
+        let vx_arr = vx_array::new(Arc::new(array));
+        assert!(unsafe { vx_array_has_dtype(vx_arr, vx_dtype_variant::DTYPE_STRUCT) });
 
         // Get dtype reference - this is valid as long as array lives
         let dtype_ptr = unsafe { vx_array_dtype(vx_arr) };
diff --git a/vortex-ffi/src/array_iterator.rs b/vortex-ffi/src/array_iterator.rs
index 65ff65e62c5..6fa5fc20b25 100644
--- a/vortex-ffi/src/array_iterator.rs
+++ b/vortex-ffi/src/array_iterator.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::ptr;
+use std::sync::Arc;
 
 use vortex::array::iter::ArrayIterator;
 
@@ -41,7 +42,7 @@ pub unsafe extern "C-unwind" fn vx_array_iterator_next(
         let element = iter.next();
 
         if let Some(element) = element {
-            Ok(vx_array::new(element?))
+            Ok(vx_array::new(Arc::new(element?)))
         } else {
             // Drop the iter pointer.
             Ok(ptr::null_mut())
diff --git a/vortex-ffi/src/dtype.rs b/vortex-ffi/src/dtype.rs
index a05a53459ca..f404187bb9f 100644
--- a/vortex-ffi/src/dtype.rs
+++ b/vortex-ffi/src/dtype.rs
@@ -68,6 +68,7 @@ impl From<&DType> for vx_dtype_variant {
             DType::List(..) => vx_dtype_variant::DTYPE_LIST,
             DType::FixedSizeList(..) => vx_dtype_variant::DTYPE_FIXED_SIZE_LIST,
             DType::Extension(_) => vx_dtype_variant::DTYPE_EXTENSION,
+            DType::Variant(_) => vortex_panic!("Variant DType is not supported in FFI yet"),
         }
     }
 }
@@ -139,11 +140,11 @@ pub unsafe extern "C-unwind" fn vx_dtype_new_fixed_size_list(
 /// Takes ownership of the `struct_dtype` pointer.
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_dtype_new_struct(
-    struct_dtype: *const vx_struct_fields,
+    struct_dtype: *mut vx_struct_fields,
     is_nullable: bool,
 ) -> *const vx_dtype {
-    let struct_dtype = vx_struct_fields::as_ref(struct_dtype).clone();
-    vx_dtype::new(Arc::new(DType::Struct(struct_dtype, is_nullable.into())))
+    let struct_dtype = vx_struct_fields::into_box(struct_dtype);
+    vx_dtype::new(Arc::new(DType::Struct(*struct_dtype, is_nullable.into())))
 }
 
 /// Create a new decimal data type.
@@ -205,10 +206,9 @@ pub unsafe extern "C-unwind" fn vx_dtype_decimal_scale(dtype: *const vx_dtype) -
 pub unsafe extern "C-unwind" fn vx_dtype_struct_dtype(
     dtype: *const vx_dtype,
 ) -> *const vx_struct_fields {
-    // TODO(joe): propagate this error up instead of expecting
-    let struct_dtype = vx_dtype::as_ref(dtype)
-        .as_struct_fields_opt()
-        .vortex_expect("not a struct dtype");
+    let Some(struct_dtype) = vx_dtype::as_ref(dtype).as_struct_fields_opt() else {
+        return ptr::null();
+    };
     vx_struct_fields::new_ref(struct_dtype)
 }
 
@@ -218,10 +218,9 @@ pub unsafe extern "C-unwind" fn vx_dtype_struct_dtype(
 /// Do NOT free the returned dtype pointer - it shares the lifetime of the list dtype.
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_dtype_list_element(dtype: *const vx_dtype) -> *const vx_dtype {
-    // TODO(joe): propagate this error up instead of expecting
-    let element_dtype = vx_dtype::as_ref(dtype)
-        .as_list_element_opt()
-        .vortex_expect("not a list dtype");
+    let Some(element_dtype) = vx_dtype::as_ref(dtype).as_list_element_opt() else {
+        return ptr::null();
+    };
     vx_dtype::new_ref(element_dtype)
 }
 
@@ -319,7 +318,7 @@ pub unsafe extern "C-unwind" fn vx_dtype_time_zone(dtype: *const DType) -> *cons
     };
 
     match opts.tz.as_ref() {
-        Some(zone) => vx_string::new(zone.clone()),
+        Some(zone) => vx_string::new(Arc::clone(zone)),
         None => ptr::null(),
     }
 }
@@ -644,7 +643,7 @@ mod tests {
     #[test]
     fn test_struct_introspection_simple() {
         let array = create_test_struct_array();
-        let vx_arr = vx_array::new(array);
+        let vx_arr = vx_array::new(Arc::new(array));
         let dtype_ptr = unsafe { vx_array_dtype(vx_arr) };
 
         let struct_fields_ptr = unsafe { vx_dtype_struct_dtype(dtype_ptr) };
@@ -660,7 +659,7 @@ mod tests {
     #[test]
     fn test_field_name_access() {
         let array = create_test_struct_array();
-        let vx_arr = vx_array::new(array);
+        let vx_arr = vx_array::new(Arc::new(array));
         let dtype_ptr = unsafe { vx_array_dtype(vx_arr) };
 
         let struct_fields_ptr = unsafe { vx_dtype_struct_dtype(dtype_ptr) };
@@ -685,7 +684,7 @@ mod tests {
     #[test]
     fn test_comprehensive_struct_introspection() {
         let array = create_test_struct_array();
-        let vx_arr = vx_array::new(array);
+        let vx_arr = vx_array::new(Arc::new(array));
         let dtype_ptr = unsafe { vx_array_dtype(vx_arr) };
 
         let struct_fields_ptr = unsafe { vx_dtype_struct_dtype(dtype_ptr) };
diff --git a/vortex-ffi/src/error.rs b/vortex-ffi/src/error.rs
index 53c91bca7eb..79115bad43b 100644
--- a/vortex-ffi/src/error.rs
+++ b/vortex-ffi/src/error.rs
@@ -19,7 +19,15 @@ box_wrapper!(
     vx_error
 );
 
-#[inline]
+/// Write an error message to `error` which has not been populated before.
+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) };
+}
+
 pub fn try_or_default<T: Default>(
     error_out: *mut *mut vx_error,
     function: impl FnOnce() -> VortexResult<T>,
@@ -30,9 +38,9 @@ pub fn try_or_default<T: Default>(
             value
         }
         Err(err) => {
-            let err = vx_error::new(Box::new(VortexError {
+            let err = vx_error::new(VortexError {
                 message: err.to_string().into(),
-            }));
+            });
             unsafe { error_out.write(err) };
             T::default()
         }
diff --git a/vortex-ffi/src/expression.rs b/vortex-ffi/src/expression.rs
new file mode 100644
index 00000000000..1f7dcf67195
--- /dev/null
+++ b/vortex-ffi/src/expression.rs
@@ -0,0 +1,544 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#![allow(non_camel_case_types)]
+
+use std::ffi::CStr;
+use std::ffi::c_char;
+use std::ptr;
+use std::slice;
+use std::sync::Arc;
+
+use vortex::dtype::FieldName;
+use vortex::error::VortexExpect;
+use vortex::expr::Expression;
+use vortex::expr::and_collect;
+use vortex::expr::get_item;
+use vortex::expr::is_null;
+use vortex::expr::list_contains;
+use vortex::expr::not;
+use vortex::expr::or_collect;
+use vortex::expr::root;
+use vortex::expr::select;
+use vortex::scalar_fn::ScalarFnVTableExt;
+use vortex::scalar_fn::fns::binary::Binary;
+use vortex::scalar_fn::fns::operators::Operator;
+
+use crate::to_field_names;
+
+// Expressions are Arc'ed inside
+crate::box_wrapper!(
+    /// A node in a Vortex expression tree.
+    ///
+    /// Expressions represent scalar computations that can be performed on
+    /// data. Each expression consists of an encoding (vtable), heap-allocated
+    /// metadata, and child expressions.
+    ///
+    /// Unless stated explicitly, all expressions returned are owned and must
+    /// be freed by the caller.
+    /// Unless stated explicitly, if an operation on const vx_expression* is
+    /// passed NULL, NULL is returned.
+    /// Operations on expressions don't take ownership of input values, and so
+    /// input values must be freed by the caller.
+    Expression,
+    vx_expression);
+
+/// Create a root expression. A root expression, applied to an array in
+/// vx_array_apply, takes the array itself as opposed to functions like
+/// vx_expression_column or vx_expression_select which take the array's parts.
+///
+/// Example:
+///
+/// const vx_array* array = ...;
+/// vx_expression* root = vx_expression_root();
+/// const vx_error* error = NULL;
+/// vx_array* applied_array = vx_array_apply(array, root, &error);
+/// // array and applied_array are identical
+/// vx_array_free(applied_array);
+/// vx_expression_free(root);
+/// vx_array_free(array);
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_root() -> *mut vx_expression {
+    vx_expression::new(root())
+}
+
+/// Create an expression that selects (includes) specific fields from a child
+/// expression. Child expression must have a DTYPE_STRUCT dtype. Errors in
+/// vx_array_apply if the child expression doesn't have a specified field.
+///
+/// Example:
+///
+/// vx_expression* root = vx_expression_root();
+/// const char* names[] = {"name", "age"};
+/// vx_expression* select = vx_expression_select(names, 2, root);
+/// vx_expression_free(select);
+/// vx_expression_free(root);
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_select(
+    names: *const *const c_char,
+    len: usize,
+    child: *const vx_expression,
+) -> *mut vx_expression {
+    if child.is_null() {
+        return ptr::null_mut();
+    }
+    let names =
+        unsafe { to_field_names(names, len) }.vortex_expect("converting names to field names");
+    let expr = select(names, vx_expression::as_ref(child).clone());
+    vx_expression::new(expr)
+}
+
+/// Create an AND expression for multiple child expressions.
+/// If there are no input expressions, returns NULL
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_and(
+    expressions: *const *const vx_expression,
+    len: usize,
+) -> *mut vx_expression {
+    if expressions.is_null() {
+        return ptr::null_mut();
+    }
+    let slice = unsafe { slice::from_raw_parts(expressions, len) };
+    match and_collect(slice.iter().map(|x| vx_expression::as_ref(*x).clone())) {
+        Some(expr) => vx_expression::new(expr),
+        None => ptr::null_mut(),
+    }
+}
+
+/// Create an OR disjunction expression for multiple child expressions.
+/// If there are no input expressions, returns NULL;
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_or(
+    expressions: *const *const vx_expression,
+    len: usize,
+) -> *mut vx_expression {
+    if expressions.is_null() {
+        return ptr::null_mut();
+    }
+    let slice = unsafe { slice::from_raw_parts(expressions, len) };
+    match or_collect(slice.iter().map(|x| vx_expression::as_ref(*x).clone())) {
+        Some(expr) => vx_expression::new(expr),
+        None => ptr::null_mut(),
+    }
+}
+
+/// Equalities, inequalities, and boolean operations over possibly null values.
+/// For most operations, if either side is null, the result is null.
+/// VX_OPERATOR_KLEENE_AND, VX_OPERATOR_KLEENE_OR obey Kleene (three-valued)
+/// logic
+#[repr(C)]
+pub enum vx_binary_operator {
+    /// Expressions are equal.
+    VX_OPERATOR_EQ = 0,
+    /// Expressions are not equal.
+    VX_OPERATOR_NOT_EQ = 1,
+    /// Expression is greater than another
+    VX_OPERATOR_GT = 2,
+    /// Expression is greater or equal to another
+    VX_OPERATOR_GTE = 3,
+    /// Expression is less than another
+    VX_OPERATOR_LT = 4,
+    /// Expression is less or equal to another
+    VX_OPERATOR_LTE = 5,
+    /// Boolean AND /\.
+    VX_OPERATOR_KLEENE_AND = 6,
+    /// Boolean OR \/.
+    VX_OPERATOR_KLEENE_OR = 7,
+    /// The sum of the arguments.
+    /// Errors at runtime if the sum would overflow or underflow.
+    VX_OPERATOR_ADD = 8,
+    /// The difference between the arguments.
+    /// Errors at runtime if the sum would overflow or underflow.
+    /// The result is null at any index where either input is null.
+    VX_OPERATOR_SUB = 9,
+    /// Multiply two numbers
+    VX_OPERATOR_MUL = 10,
+    /// Divide the left side by the right side
+    VX_OPERATOR_DIV = 11,
+}
+
+impl From<vx_binary_operator> for Operator {
+    fn from(operator: vx_binary_operator) -> Self {
+        match operator {
+            vx_binary_operator::VX_OPERATOR_EQ => Operator::Eq,
+            vx_binary_operator::VX_OPERATOR_NOT_EQ => Operator::NotEq,
+            vx_binary_operator::VX_OPERATOR_GT => Operator::Gt,
+            vx_binary_operator::VX_OPERATOR_GTE => Operator::Gte,
+            vx_binary_operator::VX_OPERATOR_LT => Operator::Lt,
+            vx_binary_operator::VX_OPERATOR_LTE => Operator::Lte,
+            vx_binary_operator::VX_OPERATOR_KLEENE_AND => Operator::And,
+            vx_binary_operator::VX_OPERATOR_KLEENE_OR => Operator::Or,
+            vx_binary_operator::VX_OPERATOR_ADD => Operator::Add,
+            vx_binary_operator::VX_OPERATOR_SUB => Operator::Sub,
+            vx_binary_operator::VX_OPERATOR_MUL => Operator::Mul,
+            vx_binary_operator::VX_OPERATOR_DIV => Operator::Div,
+        }
+    }
+}
+
+/// Create a binary expression for two expressions of form lhs OP rhs.
+/// If either input is NULL, returns NULL.
+///
+/// Example for a binary sum:
+///
+/// vx_expression* age = vx_expression_column("age");
+/// vx_expression* height = vx_expression_column("height");
+/// vx_expression* sum = vx_expression_binary(VX_OPERATOR_ADD, age, height);
+/// vx_expression_free(sum);
+/// vx_expression_free(height);
+/// vx_expression_free(age);
+///
+/// Example for a binary equality function:
+///
+/// vx_expression* vx_expression_eq(
+///     const vx_expression* lhs,
+///     const vx_expression* rhs
+/// ) {
+///     return vx_expression_binary(VX_OPERATOR_EQ, lhs, rhs);
+/// }
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_binary(
+    operator: vx_binary_operator,
+    lhs: *const vx_expression,
+    rhs: *const vx_expression,
+) -> *mut vx_expression {
+    if lhs.is_null() {
+        return ptr::null_mut();
+    }
+    if rhs.is_null() {
+        return ptr::null_mut();
+    }
+    let lhs = vx_expression::as_ref(lhs).clone();
+    let rhs = vx_expression::as_ref(rhs).clone();
+    vx_expression::new(Binary.new_expr(operator.into(), [lhs, rhs]))
+}
+
+/// Create a logical NOT of the child expression.
+///
+/// Returns the logical negation of the input boolean expression.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_not(child: *const vx_expression) -> *const vx_expression {
+    if child.is_null() {
+        return child;
+    }
+    vx_expression::new(not(vx_expression::as_ref(child).clone()))
+}
+
+/// Create an expression that checks for null values.
+///
+/// Returns a boolean array indicating which positions contain null values.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_is_null(child: *const vx_expression) -> *mut vx_expression {
+    if child.is_null() {
+        return ptr::null_mut();
+    }
+    vx_expression::new(is_null(vx_expression::as_ref(child).clone()))
+}
+
+/// Create an expression that extracts a named field from a struct expression.
+/// Child expression must have a DTYPE_STRUCT dtype.
+/// Errors in vx_array_apply if the root array doesn't have a specified field.
+///
+/// Accesses the specified field from the result of the child expression.
+/// Equivalent to select(&item, 1, child).
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_get_item(
+    item: *const c_char,
+    child: *const vx_expression,
+) -> *mut vx_expression {
+    if child.is_null() {
+        return ptr::null_mut();
+    }
+    if item.is_null() {
+        return ptr::null_mut();
+    }
+    #[expect(clippy::expect_used)]
+    let item = unsafe {
+        CStr::from_ptr(item)
+            .to_str()
+            .expect("converting pointer to str")
+    };
+    let item: Arc<str> = Arc::from(item);
+    let item: FieldName = item.into();
+    vx_expression::new(get_item(item, vx_expression::as_ref(child).clone()))
+}
+
+/// Create an expression that checks if a value is contained in a list.
+///
+/// Returns a boolean array indicating whether the value appears in each list.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_expression_list_contains(
+    list: *const vx_expression,
+    value: *const vx_expression,
+) -> *mut vx_expression {
+    if list.is_null() {
+        return ptr::null_mut();
+    }
+    if value.is_null() {
+        return ptr::null_mut();
+    }
+    let list = vx_expression::as_ref(list).clone();
+    let value = vx_expression::as_ref(value).clone();
+    vx_expression::new(list_contains(list, value))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ptr;
+    use std::sync::Arc;
+
+    use vortex::array::IntoArray;
+    use vortex::array::ToCanonical;
+    use vortex::array::arrays::BoolArray;
+    use vortex::array::arrays::ListArray;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::arrays::StructArray;
+    use vortex::array::arrays::VarBinViewArray;
+    use vortex::array::arrays::bool::BoolArrayExt;
+    use vortex::array::validity::Validity;
+    use vortex::buffer::Buffer;
+    use vortex::buffer::buffer;
+    use vortex::expr::lit;
+
+    use crate::array::vx_array;
+    use crate::array::vx_array_apply;
+    use crate::array::vx_array_free;
+    use crate::error::vx_error_free;
+    use crate::expression::vx_binary_operator;
+    use crate::expression::vx_expression;
+    use crate::expression::vx_expression_and;
+    use crate::expression::vx_expression_binary;
+    use crate::expression::vx_expression_free;
+    use crate::expression::vx_expression_get_item;
+    use crate::expression::vx_expression_list_contains;
+    use crate::expression::vx_expression_or;
+    use crate::expression::vx_expression_root;
+    use crate::expression::vx_expression_select;
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_root() {
+        unsafe {
+            let root = vx_expression_root();
+            vx_expression_free(root);
+        }
+    }
+
+    fn struct_array() -> (StructArray, VarBinViewArray, PrimitiveArray) {
+        let names_array = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]);
+        let ages_buffer = buffer![30u8, 25u8, 35u8];
+        let ages_array = PrimitiveArray::new(ages_buffer, Validity::NonNullable);
+        let fields = vec![
+            names_array.clone().into_array(),
+            ages_array.clone().into_array(),
+        ];
+        let names = ["name", "age"].into();
+        let struct_array = StructArray::try_new(names, fields, 3, Validity::NonNullable);
+        (struct_array.unwrap(), names_array, ages_array)
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_get_item() {
+        let (array, names_array, ages_array) = struct_array();
+        unsafe {
+            let root = vx_expression_root();
+            let column = vx_expression_get_item(c"age".as_ptr(), root);
+            assert_ne!(column, ptr::null_mut());
+
+            let array = vx_array::new(Arc::new(array.into_array()));
+            let mut error = ptr::null_mut();
+
+            let applied_array = vx_array_apply(array, column, &raw mut error);
+            assert!(!applied_array.is_null());
+            assert!(error.is_null());
+            {
+                let applied_array = vx_array::as_ref(applied_array);
+                let expected: Buffer<u8> = ages_array.to_buffer();
+                assert_eq!(applied_array.to_primitive().to_buffer(), expected);
+            }
+            vx_array_free(applied_array);
+
+            vx_expression_free(column);
+
+            let column = vx_expression_get_item(c"ololo".as_ptr(), root);
+            assert_ne!(column, ptr::null_mut());
+
+            let applied_array = vx_array_apply(array, column, &raw mut error);
+            assert!(applied_array.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+
+            let names_array_vx = vx_array::new(Arc::new(names_array.into_array()));
+            let applied_array = vx_array_apply(names_array_vx, column, &raw mut error);
+            assert!(applied_array.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+            vx_array_free(names_array_vx);
+
+            vx_expression_free(column);
+
+            vx_array_free(array);
+            vx_expression_free(root);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_select() {
+        let (array, ..) = struct_array();
+        unsafe {
+            let root = vx_expression_root();
+
+            let array = vx_array::new(Arc::new(array.into_array()));
+
+            let columns = [c"name".as_ptr(), c"age".as_ptr()];
+            let column = vx_expression_select(columns.as_ptr(), 2, root);
+            assert_ne!(column, ptr::null_mut());
+
+            let mut error = ptr::null_mut();
+            let applied_array = vx_array_apply(array, column, &raw mut error);
+            assert!(!applied_array.is_null());
+            assert!(error.is_null());
+            {
+                let array = vx_array::as_ref(array);
+                let applied_array = vx_array::as_ref(applied_array);
+                assert_eq!(applied_array.dtype(), array.dtype());
+            }
+            vx_array_free(applied_array);
+            vx_expression_free(column);
+
+            let columns = [c"age".as_ptr(), c"ololo".as_ptr()];
+            let column = vx_expression_select(columns.as_ptr(), 2, root);
+            let applied_array = vx_array_apply(array, column, &raw mut error);
+            assert!(applied_array.is_null());
+            assert!(!error.is_null());
+            vx_error_free(error);
+            vx_expression_free(column);
+
+            vx_array_free(array);
+            vx_expression_free(root);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_and_or() {
+        let col1 = BoolArray::from_iter([true, false, true, true]);
+        let col2 = BoolArray::from_iter([false, true, true, false]);
+        let col3 = BoolArray::from_iter([false, true, true, true]);
+        let fields = vec![col1.into_array(), col2.into_array(), col3.into_array()];
+        let names = ["col1", "col2", "col3"].into();
+        let array = StructArray::try_new(names, fields, 4, Validity::NonNullable);
+
+        unsafe {
+            let array = vx_array::new(Arc::new(array.unwrap().into_array()));
+
+            let root = vx_expression_root();
+            let expression_col1 = vx_expression_get_item(c"col1".as_ptr(), root);
+            let expression_col2 = vx_expression_get_item(c"col2".as_ptr(), root);
+            let expression_col3 = vx_expression_get_item(c"col3".as_ptr(), root);
+            let expression_12 = vx_expression_binary(
+                vx_binary_operator::VX_OPERATOR_EQ,
+                expression_col1,
+                expression_col2,
+            );
+            let expression_23 = vx_expression_binary(
+                vx_binary_operator::VX_OPERATOR_EQ,
+                expression_col2,
+                expression_col3,
+            );
+
+            let expressions = [expression_12, expression_23];
+
+            let mut error = ptr::null_mut();
+            let expressions_ptr = expressions.as_ptr() as *const *const vx_expression;
+            let expression_and123 = vx_expression_and(expressions_ptr, 2);
+            assert!(!expression_and123.is_null());
+            let applied_array = vx_array_apply(array, expression_and123, &raw mut error);
+            assert!(error.is_null());
+            assert!(!applied_array.is_null());
+            {
+                let array = vx_array::as_ref(applied_array).to_bool();
+                let expected = BoolArray::from_iter([false, false, true, false]);
+                assert_eq!(array.to_bit_buffer(), expected.to_bit_buffer());
+            }
+            vx_expression_free(expression_and123);
+            vx_array_free(applied_array);
+
+            let expression_or123 = vx_expression_or(expressions_ptr, 2);
+            assert!(!expression_or123.is_null());
+            let applied_array = vx_array_apply(array, expression_or123, &raw mut error);
+            assert!(error.is_null());
+            assert!(!applied_array.is_null());
+            {
+                let array = vx_array::as_ref(applied_array).to_bool();
+                let expected = BoolArray::from_iter([true, true, true, false]);
+                assert_eq!(array.to_bit_buffer(), expected.to_bit_buffer());
+            }
+            vx_array_free(applied_array);
+
+            vx_expression_free(expression_or123);
+
+            vx_expression_free(expression_23);
+            vx_expression_free(expression_12);
+            vx_expression_free(expression_col3);
+            vx_expression_free(expression_col2);
+            vx_expression_free(expression_col1);
+            vx_expression_free(root);
+
+            vx_array_free(array);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_empty_and_or() {
+        unsafe {
+            let root = vx_expression_root();
+
+            let and_empty = vx_expression_and(ptr::null_mut(), 9);
+            assert!(and_empty.is_null());
+            let or_empty = vx_expression_or(ptr::null_mut(), 9);
+            assert!(or_empty.is_null());
+
+            vx_expression_free(root);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_list_contains() {
+        let elements = buffer![1i32, 2, 3, 4, 5].into_array();
+        let offsets = buffer![0u32, 2, 5, 5].into_array();
+        let array = ListArray::try_new(elements, offsets, Validity::NonNullable).unwrap();
+
+        unsafe {
+            let root = vx_expression_root();
+            let array = vx_array::new(Arc::new(array.into_array()));
+            let expression_value = vx_expression::new(lit(1));
+
+            let expression = vx_expression_list_contains(root, expression_value);
+            assert!(!expression.is_null());
+
+            let mut error = ptr::null_mut();
+            let applied = vx_array_apply(array, expression, &raw mut error);
+            assert!(error.is_null());
+            assert!(!applied.is_null());
+            {
+                let applied = vx_array::as_ref(applied).to_bool();
+                let expected = BoolArray::from_iter([true, false, false]);
+                assert_eq!(applied.to_bit_buffer(), expected.to_bit_buffer());
+            }
+            vx_array_free(applied);
+
+            vx_expression_free(expression_value);
+            vx_expression_free(expression);
+            vx_array_free(array);
+
+            vx_expression_free(root);
+        }
+    }
+}
diff --git a/vortex-ffi/src/file.rs b/vortex-ffi/src/file.rs
index 7d9c68dfc51..61e49b1d624 100644
--- a/vortex-ffi/src/file.rs
+++ b/vortex-ffi/src/file.rs
@@ -36,9 +36,9 @@ use vortex::file::OpenOptionsSessionExt;
 use vortex::file::VortexFile;
 use vortex::file::WriteOptionsSessionExt;
 use vortex::io::runtime::BlockingRuntime;
+use vortex::layout::scan::scan_builder::ScanBuilder;
+use vortex::layout::scan::split_by::SplitBy;
 use vortex::proto::expr::Expr;
-use vortex::scan::ScanBuilder;
-use vortex::scan::SplitBy;
 use vortex::session::VortexSession;
 
 use crate::RUNTIME;
@@ -185,8 +185,10 @@ pub unsafe extern "C-unwind" fn vx_file_open_reader(
             .parse()
             .map_err(|e| vortex_err!("Failed to parse URI '{}': {}", uri_str, e))?;
 
-        let prop_keys = unsafe { to_string_vec(options.property_keys, options.property_len) };
-        let prop_vals = unsafe { to_string_vec(options.property_vals, options.property_len) };
+        let prop_keys =
+            unsafe { to_string_vec(options.property_keys, options.property_len as usize) };
+        let prop_vals =
+            unsafe { to_string_vec(options.property_vals, options.property_len as usize) };
 
         let object_store = make_object_store(&uri, &prop_keys, &prop_vals)?;
 
diff --git a/vortex-ffi/src/lib.rs b/vortex-ffi/src/lib.rs
index 1d97f29a01b..db387172150 100644
--- a/vortex-ffi/src/lib.rs
+++ b/vortex-ffi/src/lib.rs
@@ -11,6 +11,7 @@ mod array_iterator;
 mod binary;
 mod dtype;
 mod error;
+mod expression;
 mod file;
 mod log;
 mod macros;
@@ -18,14 +19,19 @@ mod ptype;
 mod session;
 mod sink;
 mod string;
+mod struct_array;
 mod struct_fields;
 
 use std::ffi::CStr;
 use std::ffi::c_char;
-use std::ffi::c_int;
+use std::sync::Arc;
 use std::sync::LazyLock;
 
 pub use log::vx_log_level;
+use vortex::dtype::FieldName;
+use vortex::error::VortexExpect;
+use vortex::error::VortexResult;
+use vortex::error::vortex_err;
 use vortex::io::runtime::current::CurrentThreadRuntime;
 
 #[cfg(all(feature = "mimalloc", not(miri)))]
@@ -41,8 +47,33 @@ pub(crate) unsafe fn to_string(ptr: *const c_char) -> String {
     c_str.to_string_lossy().into_owned()
 }
 
-pub(crate) unsafe fn to_string_vec(ptr: *const *const c_char, len: c_int) -> Vec<String> {
+pub(crate) unsafe fn to_string_vec(ptr: *const *const c_char, len: usize) -> Vec<String> {
+    #[expect(clippy::expect_used)]
     (0..len)
-        .map(|i| unsafe { to_string(*ptr.offset(i as isize)) })
+        .map(|i: usize| unsafe {
+            to_string(*ptr.offset(i.try_into().expect("pointer offset overflow")))
+        })
+        .collect()
+}
+
+/// 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) }
+        .to_str()
+        .map_err(|e| vortex_err!("{e}"))?;
+    let name: Arc<str> = Arc::from(name);
+    Ok(name.into())
+}
+
+/// SAFETY: names must be a non-NULL pointer valid for reads up to len.
+pub(crate) unsafe fn to_field_names(
+    names: *const *const c_char,
+    len: usize,
+) -> VortexResult<Vec<FieldName>> {
+    (0..len)
+        .map(|i| unsafe {
+            let name = *names.offset(i.try_into().vortex_expect("pointer offset overflow"));
+            to_field_name(name)
+        })
         .collect()
 }
diff --git a/vortex-ffi/src/macros.rs b/vortex-ffi/src/macros.rs
index a0a0f9b4711..9c4e6f2c342 100644
--- a/vortex-ffi/src/macros.rs
+++ b/vortex-ffi/src/macros.rs
@@ -119,7 +119,7 @@ macro_rules! arc_wrapper {
             impl $ffi_ident {
                 /// Wrap an owned object into a raw pointer.
                 pub(crate) fn new(obj: std::sync::Arc<$T>) -> *const $ffi_ident {
-                    std::sync::Arc::into_raw(obj).cast()
+                     std::sync::Arc::into_raw(obj).cast::<$ffi_ident>()
                 }
 
                 /// Wrap a borrowed object into a raw pointer.
@@ -240,13 +240,18 @@ macro_rules! box_wrapper {
         paste::paste! {
             $(#[$meta])*
             #[allow(non_camel_case_types)]
-            pub(crate) struct $ffi_ident($T);
+            pub struct $ffi_ident($T);
 
             #[allow(dead_code)]
             impl $ffi_ident {
                 /// Wrap an owned object into a raw pointer.
-                pub(crate) fn new(obj: Box<$T>) -> *mut $ffi_ident {
-                    Box::into_raw(obj).cast()
+                pub(crate) fn new_box(obj: Box<$T>) -> *mut $ffi_ident {
+                    Box::into_raw(obj).cast::<$ffi_ident>()
+                }
+
+                /// Wrap an owned object into a raw pointer.
+                pub(crate) fn new(obj: $T) -> *mut $ffi_ident {
+                    Box::into_raw(Box::new(obj)).cast::<$ffi_ident>()
                 }
 
                 /// Wrap a borrowed object into a raw pointer.
diff --git a/vortex-ffi/src/session.rs b/vortex-ffi/src/session.rs
index 8950abb90d4..668598852eb 100644
--- a/vortex-ffi/src/session.rs
+++ b/vortex-ffi/src/session.rs
@@ -20,7 +20,14 @@ box_wrapper!(
 /// 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(Box::new(
-        VortexSession::default().with_handle(RUNTIME.handle()),
-    ))
+    vx_session::new(VortexSession::default().with_handle(RUNTIME.handle()))
+}
+
+/// Clone a Vortex session, returning an owned copy.
+///
+/// The caller is responsible for freeing the session with [`vx_session_free`].
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_session_clone(session: *const vx_session) -> *mut vx_session {
+    let session = vx_session::as_ref(session);
+    vx_session::new(session.clone())
 }
diff --git a/vortex-ffi/src/sink.rs b/vortex-ffi/src/sink.rs
index 249a1825b52..7b0bbe69ca0 100644
--- a/vortex-ffi/src/sink.rs
+++ b/vortex-ffi/src/sink.rs
@@ -10,9 +10,9 @@ use futures::channel::mpsc;
 use futures::channel::mpsc::Sender;
 use vortex::array::ArrayRef;
 use vortex::array::stream::ArrayStreamAdapter;
-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::file::WriteOptionsSessionExt;
 use vortex::file::WriteSummary;
@@ -79,20 +79,23 @@ pub unsafe extern "C-unwind" fn vx_array_sink_open_file(
     })
 }
 
-/// Pushed a single array chunk into a file sink.
+/// Push an array into a file sink.
+/// Does not take ownership of array
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_array_sink_push(
     sink: *mut vx_array_sink,
     array: *const vx_array,
     error_out: *mut *mut vx_error,
 ) {
-    let array = vx_array::as_ref(array);
-    // TODO(joe): propagate this error up instead of expecting
-    let sink = unsafe { sink.as_mut().vortex_expect("null array stream") };
     try_or_default(error_out, || {
+        vortex_ensure!(!array.is_null());
+        vortex_ensure!(!sink.is_null());
+
+        let array = vx_array::as_ref(array);
+        let sink = unsafe { &mut *sink };
         RUNTIME
             .block_on(sink.sink.send(Ok(array.clone())))
-            .map_err(|e| vortex_err!("send error {}", e.to_string()))
+            .map_err(|e| vortex_err!("Send error: {e}"))
     })
 }
 
@@ -134,6 +137,7 @@ mod tests {
     use crate::dtype::vx_dtype;
     use crate::dtype::vx_dtype_free;
     use crate::error::vx_error_free;
+    use crate::session::vx_session_free;
     use crate::session::vx_session_new;
 
     #[test]
@@ -156,7 +160,7 @@ mod tests {
 
             // Create and push an array
             let array = PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable);
-            let vx_array_ptr = vx_array::new(array.into_array());
+            let vx_array_ptr = vx_array::new(Arc::new(array.into_array()));
 
             vx_array_sink_push(sink, vx_array_ptr, &raw mut error);
             assert!(error.is_null());
@@ -168,6 +172,7 @@ mod tests {
             // Cleanup
             vx_array_free(vx_array_ptr);
             vx_dtype_free(vx_dtype_ptr);
+            vx_session_free(session);
         }
     }
 
@@ -195,7 +200,7 @@ mod tests {
                     buffer![start as u64, (start + 1) as u64, (start + 2) as u64],
                     Validity::NonNullable,
                 );
-                let vx_array_ptr = vx_array::new(array.into_array());
+                let vx_array_ptr = vx_array::new(Arc::new(array.into_array()));
 
                 vx_array_sink_push(sink, vx_array_ptr, &raw mut error);
                 assert!(error.is_null());
@@ -207,6 +212,7 @@ mod tests {
             assert!(error.is_null());
 
             vx_dtype_free(vx_dtype_ptr);
+            vx_session_free(session);
         }
     }
 
@@ -233,7 +239,7 @@ mod tests {
             if !sink.is_null() {
                 // Push an array
                 let array = PrimitiveArray::new(buffer![1i32], Validity::NonNullable);
-                let vx_array_ptr = vx_array::new(array.into_array());
+                let vx_array_ptr = vx_array::new(Arc::new(array.into_array()));
                 vx_array_sink_push(sink, vx_array_ptr, &raw mut error);
                 vx_array_free(vx_array_ptr);
 
@@ -251,6 +257,7 @@ mod tests {
             }
 
             vx_dtype_free(vx_dtype_ptr);
+            vx_session_free(session);
         }
     }
 
@@ -273,6 +280,7 @@ mod tests {
 
             vx_error_free(error);
             vx_dtype_free(vx_dtype_ptr);
+            vx_session_free(session);
         }
     }
 }
diff --git a/vortex-ffi/src/struct_array.rs b/vortex-ffi/src/struct_array.rs
new file mode 100644
index 00000000000..33409531be0
--- /dev/null
+++ b/vortex-ffi/src/struct_array.rs
@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+use std::ffi::c_char;
+use std::ptr;
+use std::sync::Arc;
+
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::validity::Validity;
+use vortex::dtype::FieldName;
+use vortex::error::vortex_bail;
+use vortex::error::vortex_ensure;
+
+use crate::array::vx_array;
+use crate::array::vx_validity;
+use crate::error::try_or_default;
+use crate::error::vx_error;
+use crate::to_field_name;
+
+pub(crate) struct StructBuilder {
+    names: Vec<FieldName>,
+    fields: Vec<ArrayRef>,
+    validity: Validity,
+}
+
+crate::box_wrapper!(StructBuilder, vx_struct_column_builder);
+
+/// Create a new column-wise struct array builder with given validity and a
+/// capacity hint. validity can't be NULL.
+/// If you don't know capacity, pass 0.
+/// if validity is NULL, returns NULL.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_struct_column_builder_new(
+    validity: *const vx_validity,
+    capacity: usize,
+) -> *mut vx_struct_column_builder {
+    if validity.is_null() {
+        return ptr::null_mut();
+    }
+
+    let names = Vec::with_capacity(capacity);
+    let fields = Vec::with_capacity(capacity);
+    let validity = unsafe { &*validity }.into();
+    let builder = StructBuilder {
+        names,
+        fields,
+        validity,
+    };
+    vx_struct_column_builder::new(builder)
+}
+
+/// Add a named field to a struct array builder.
+/// All arguments must be non-NULL.
+/// If field's length doesn't match lengths of previous fields, sets error.
+/// If an error is returned, the builder is still valid, and caller must
+/// deallocate it using vx_struct_column_builder_free.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn vx_struct_column_builder_add_field(
+    builder: *mut vx_struct_column_builder,
+    name: *const c_char,
+    field: *const vx_array,
+    error: *mut *mut vx_error,
+) {
+    try_or_default(error, || {
+        vortex_ensure!(!builder.is_null());
+        vortex_ensure!(!name.is_null());
+        vortex_ensure!(!field.is_null());
+        let builder = vx_struct_column_builder::as_mut(builder);
+
+        let name = unsafe { to_field_name(name)? };
+        let field = (*vx_array::as_ref(field)).clone();
+
+        if !builder.fields.is_empty() && field.len() != builder.fields[0].len() {
+            vortex_bail!(
+                "Field length mismatch: expected {}, got {}",
+                builder.fields[0].len(),
+                field.len()
+            );
+        }
+        builder.names.push(name);
+        builder.fields.push(field);
+        Ok(())
+    })
+}
+
+/// Finalize a struct array builder, returning a struct array.
+/// Consumes the builder. Caller doesn't need to free the builder after calling
+/// this function.
+///
+/// Example:
+///
+/// vx_error* error = NULL;
+///
+/// vx_validity validity = {};
+/// validity.type = VX_VALIDITY_NON_NULLABLE;
+///
+/// const vx_array* field_array = vx_array_new_null(5);
+/// const vx_struct_column_builder* builder =
+///     vx_struct_column_builder_new(&validity, 1);
+///
+/// vx_struct_column_builder_add_field(builder, "age", field_array, &error);
+///
+/// vx_array* struct_array = vx_struct_column_builder_finalize(builder, &error);
+///
+/// vx_array_free(struct_array);
+/// vx_array_free(field_array);
+///
+#[unsafe(no_mangle)]
+pub extern "C-unwind" fn vx_struct_column_builder_finalize(
+    builder: *mut vx_struct_column_builder,
+    error: *mut *mut vx_error,
+) -> *const vx_array {
+    try_or_default(error, || {
+        vortex_ensure!(!builder.is_null());
+        let builder = *vx_struct_column_builder::into_box(builder);
+        let rows = if builder.fields.is_empty() {
+            0
+        } else {
+            builder.fields[0].len()
+        };
+        let array =
+            StructArray::try_new(builder.names.into(), builder.fields, rows, builder.validity)?;
+        Ok(vx_array::new(Arc::new(array.into_array())))
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ffi::c_void;
+    use std::ptr;
+    use std::sync::Arc;
+
+    use vortex::array::IntoArray;
+    use vortex::array::ToCanonical;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::arrays::StructArray;
+    use vortex::array::arrays::VarBinViewArray;
+    use vortex::array::assert_arrays_eq;
+    use vortex::array::validity::Validity;
+    use vortex::buffer::buffer;
+
+    use crate::array::vx_array;
+    use crate::array::vx_array_free;
+    use crate::array::vx_array_new_null;
+    use crate::array::vx_array_new_primitive;
+    use crate::array::vx_validity;
+    use crate::array::vx_validity_type;
+    use crate::error::vx_error_free;
+    use crate::ptype::vx_ptype;
+    use crate::struct_array::vx_struct_column_builder_add_field;
+    use crate::struct_array::vx_struct_column_builder_finalize;
+    use crate::struct_array::vx_struct_column_builder_free;
+    use crate::struct_array::vx_struct_column_builder_new;
+
+    #[test]
+    fn test_empty() {
+        let validity = vx_validity {
+            r#type: vx_validity_type::VX_VALIDITY_NON_NULLABLE,
+            array: ptr::null(),
+        };
+        unsafe {
+            let builder = vx_struct_column_builder_new(&raw const validity, 0);
+            assert!(!builder.is_null());
+            vx_struct_column_builder_free(builder);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_many() {
+        let names = ["age", "name"];
+        let age_field = PrimitiveArray::new(buffer![30u8, 25u8, 35u8], Validity::NonNullable);
+        let name_field = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]);
+        let struct_array = StructArray::try_new(
+            names.into(),
+            vec![age_field.into_array(), name_field.clone().into_array()],
+            3,
+            Validity::NonNullable,
+        )
+        .unwrap();
+
+        let validity = vx_validity {
+            r#type: vx_validity_type::VX_VALIDITY_NON_NULLABLE,
+            array: ptr::null(),
+        };
+
+        unsafe {
+            let mut error = ptr::null_mut();
+            let builder = vx_struct_column_builder_new(&raw const validity, 2);
+            assert!(!builder.is_null());
+
+            let ffi_age = [30u8, 25u8, 35u8];
+            let ffi_age_field = vx_array_new_primitive(
+                vx_ptype::PTYPE_U8,
+                &raw const ffi_age as *const c_void,
+                3,
+                &raw const validity,
+                &raw mut error,
+            );
+            assert!(!ffi_age_field.is_null());
+            assert!(error.is_null());
+
+            vx_struct_column_builder_add_field(
+                builder,
+                c"age".as_ptr(),
+                ffi_age_field,
+                &raw mut error,
+            );
+            assert!(error.is_null());
+
+            // Check field mismatch
+            let ffi_null_field = vx_array_new_null(5);
+            vx_struct_column_builder_add_field(
+                builder,
+                c"null".as_ptr(),
+                ffi_null_field,
+                &raw mut error,
+            );
+            assert!(!error.is_null());
+            vx_error_free(error);
+            vx_array_free(ffi_null_field);
+
+            // Can't create a string array from C API yet.
+            let ffi_name_field = vx_array::new(Arc::new(name_field.into_array()));
+            vx_struct_column_builder_add_field(
+                builder,
+                c"name".as_ptr(),
+                ffi_name_field,
+                &raw mut error,
+            );
+            assert!(error.is_null());
+
+            let array = vx_struct_column_builder_finalize(builder, &raw mut error);
+            assert!(error.is_null());
+            assert!(!array.is_null());
+
+            {
+                let array = vx_array::as_ref(array).to_struct();
+                assert_arrays_eq!(array, struct_array);
+            }
+
+            vx_array_free(array);
+            vx_array_free(ffi_name_field);
+            vx_array_free(ffi_age_field);
+        }
+    }
+}
diff --git a/vortex-ffi/src/struct_fields.rs b/vortex-ffi/src/struct_fields.rs
index bcfd7ac87ee..fa8f10aca83 100644
--- a/vortex-ffi/src/struct_fields.rs
+++ b/vortex-ffi/src/struct_fields.rs
@@ -9,12 +9,11 @@ use vortex::dtype::DType;
 use vortex::dtype::StructFields;
 use vortex::error::VortexExpect;
 
-use crate::arc_wrapper;
 use crate::box_wrapper;
 use crate::dtype::vx_dtype;
 use crate::string::vx_string;
 
-arc_wrapper!(
+box_wrapper!(
     /// Represents a Vortex struct data type, without top-level nullability.
     StructFields,
     vx_struct_fields
@@ -90,10 +89,10 @@ box_wrapper!(
 /// Create a new struct dtype builder.
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_struct_fields_builder_new() -> *mut vx_struct_fields_builder {
-    vx_struct_fields_builder::new(Box::new(StructDTypeBuilder {
+    vx_struct_fields_builder::new(StructDTypeBuilder {
         names: Vec::new(),
         fields: Vec::new(),
-    }))
+    })
 }
 
 /// Add a field to the struct dtype builder.
@@ -119,8 +118,8 @@ pub unsafe extern "C-unwind" fn vx_struct_fields_builder_add_field(
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_struct_fields_builder_finalize(
     builder: *mut vx_struct_fields_builder,
-) -> *const vx_struct_fields {
-    let builder = vx_struct_fields_builder::into_box(builder);
-    let struct_dtype = StructFields::new(builder.names.into(), builder.fields);
-    vx_struct_fields::new(Arc::new(struct_dtype))
+) -> *mut vx_struct_fields {
+    let StructDTypeBuilder { names, fields } = *vx_struct_fields_builder::into_box(builder);
+    let struct_dtype = StructFields::new(names.into(), fields);
+    vx_struct_fields::new(struct_dtype)
 }
diff --git a/vortex-ffi/test/CMakeLists.txt b/vortex-ffi/test/CMakeLists.txt
new file mode 100644
index 00000000000..029a63efffc
--- /dev/null
+++ b/vortex-ffi/test/CMakeLists.txt
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+include(CTest)
+include(FetchContent)
+
+FetchContent_Declare(
+  Catch
+  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+  GIT_TAG        v3.8.1
+)
+FetchContent_MakeAvailable(Catch)
+include(Catch)
+
+file(GLOB TEST_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+message(NOTICE "Test files ${TEST_FILES}")
+add_executable(vortex_ffi_test ${TEST_FILES})
+target_link_libraries(vortex_ffi_test PRIVATE vortex_ffi_shared Catch2::Catch2WithMain)
+catch_discover_tests(vortex_ffi_test)
diff --git a/vortex-ffi/test/array.cpp b/vortex-ffi/test/array.cpp
new file mode 100644
index 00000000000..4fde064a339
--- /dev/null
+++ b/vortex-ffi/test/array.cpp
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#include <catch2/catch_test_macros.hpp>
+#include <vortex.h>
+#include "common.h"
+
+TEST_CASE("Null array creation", "[array]") {
+    const vx_array *array = vx_array_new_null(1999);
+    REQUIRE(array != nullptr);
+    REQUIRE(vx_array_is_nullable(array));
+    REQUIRE(vx_array_has_dtype(array, DTYPE_NULL));
+    REQUIRE(vx_dtype_get_variant(vx_array_dtype(array)) == DTYPE_NULL);
+    REQUIRE(vx_array_len(array) == 1999);
+    vx_array_free(array);
+}
+
+TEST_CASE("Primitive array creation", "[array]") {
+    std::vector<uint8_t> buffer(20, 1);
+    buffer[3] = 8;
+
+    vx_validity validity = {};
+    validity.type = VX_VALIDITY_ALL_VALID;
+    vx_error *error = nullptr;
+    const vx_array *array = vx_array_new_primitive(PTYPE_U8, buffer.data(), buffer.size(), &validity, &error);
+
+    require_no_error(error);
+    REQUIRE(array != nullptr);
+    REQUIRE(vx_array_has_dtype(array, DTYPE_PRIMITIVE));
+    REQUIRE(vx_dtype_get_variant(vx_array_dtype(array)) == DTYPE_PRIMITIVE);
+    REQUIRE(vx_array_is_primitive(array, PTYPE_U8));
+    REQUIRE(vx_array_len(array) == buffer.size());
+
+    for (size_t i = 0; i < buffer.size(); ++i) {
+        REQUIRE(buffer[i] == vx_array_get_u8(array, i));
+    }
+
+    buffer = {};
+
+    for (size_t i = 0; i < 20; ++i) {
+        REQUIRE(vx_array_get_u8(array, i) == (i == 3 ? 8 : 1));
+    }
+
+    vx_array_free(array);
+}
+
+TEST_CASE("Struct array creation", "[array]") {
+    vx_error *error = nullptr;
+
+    vx_validity validity = {};
+    validity.type = VX_VALIDITY_NON_NULLABLE;
+
+    const vx_array *field_array = vx_array_new_null(5);
+    CHECK(field_array != nullptr);
+    vx_struct_column_builder *builder = vx_struct_column_builder_new(&validity, 2);
+    CHECK(builder != nullptr);
+
+    vx_struct_column_builder_add_field(builder, "age", field_array, &error);
+    vx_array_free(field_array);
+
+    SECTION("Struct array builder free") {
+        vx_struct_column_builder_free(builder);
+    }
+
+    SECTION("Struct array builder finalize") {
+        const vx_array *struct_array = vx_struct_column_builder_finalize(builder, &error);
+        vx_array_free(struct_array);
+    }
+}
diff --git a/vortex-ffi/test/common.h b/vortex-ffi/test/common.h
new file mode 100644
index 00000000000..dbbcf56d318
--- /dev/null
+++ b/vortex-ffi/test/common.h
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#pragma once
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+#include "vortex.h"
+
+inline std::string to_string(vx_error *err) {
+    const vx_string *msg = vx_error_get_message(err);
+    return {vx_string_ptr(msg), vx_string_len(msg)};
+}
+
+inline std::string_view to_string_view(const vx_string *msg) {
+    return {vx_string_ptr(msg), vx_string_len(msg)};
+}
+
+inline std::string_view to_string_view(vx_error *err) {
+    return to_string_view(vx_error_get_message(err));
+}
+
+inline void require_no_error(vx_error *err) {
+    if (err) {
+        FAIL(to_string(err));
+    }
+}
diff --git a/vortex-ffi/test/main.cpp b/vortex-ffi/test/main.cpp
new file mode 100644
index 00000000000..188e8739d9f
--- /dev/null
+++ b/vortex-ffi/test/main.cpp
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#include <catch2/catch_test_macros.hpp>
+#include <unistd.h>
+#include "vortex.h"
+
+using namespace std::string_literals;
+using namespace std::string_view_literals;
+
+TEST_CASE("Session creation", "[session]") {
+    vx_session *session = vx_session_new();
+    REQUIRE(session != nullptr);
+    vx_session *session2 = vx_session_clone(session);
+    REQUIRE(session2 != nullptr);
+    REQUIRE(session != session2);
+    vx_session_free(session);
+    vx_session_free(session2);
+}
+
+TEST_CASE("Creating and iterating binaries", "[binary]") {
+    for (std::string_view str : {"ololo"sv, "Широкая строка"sv, "مرحبا بالعالم"sv}) {
+        const vx_binary *binary = vx_binary_new(str.data(), str.size());
+
+        REQUIRE(binary != nullptr);
+        const size_t len = vx_binary_len(binary);
+        REQUIRE(len == str.size());
+
+        const char *ptr = vx_binary_ptr(binary);
+        REQUIRE(std::string_view {ptr, len} == str);
+
+        const vx_binary *binary2 = vx_binary_clone(binary);
+        vx_binary_free(binary);
+
+        ptr = vx_binary_ptr(binary2);
+        REQUIRE(std::string_view {ptr, len} == str);
+
+        vx_binary_free(binary2);
+    }
+}
+
+TEST_CASE("Creating dtypes", "[dtype]") {
+    const vx_dtype *dtype = vx_dtype_new_null();
+    REQUIRE(dtype != nullptr);
+    CHECK(vx_dtype_get_variant(dtype) == DTYPE_NULL);
+    CHECK(vx_dtype_is_nullable(dtype));
+    vx_dtype_free(dtype);
+
+    dtype = vx_dtype_new_decimal(5, 2, false);
+    REQUIRE(dtype != nullptr);
+    CHECK(vx_dtype_get_variant(dtype) == DTYPE_DECIMAL);
+    CHECK(vx_dtype_decimal_precision(dtype) == 5);
+    CHECK(vx_dtype_decimal_scale(dtype) == 2);
+    CHECK_FALSE(vx_dtype_is_nullable(dtype));
+
+    CHECK(vx_dtype_struct_dtype(dtype) == nullptr);
+    CHECK(vx_dtype_list_element(dtype) == nullptr);
+
+    vx_dtype_free(dtype);
+}
diff --git a/vortex-ffi/test/struct.cpp b/vortex-ffi/test/struct.cpp
new file mode 100644
index 00000000000..6ccdb04c037
--- /dev/null
+++ b/vortex-ffi/test/struct.cpp
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#include <catch2/catch_test_macros.hpp>
+#include <vortex.h>
+
+using namespace std::string_view_literals;
+using namespace std::string_literals;
+
+TEST_CASE("Struct builder", "[struct]") {
+    vx_struct_fields_builder *builder = vx_struct_fields_builder_new();
+
+    constexpr auto col1 = "col1"sv;
+    const vx_string *col1_name = vx_string_new(col1.data(), col1.size());
+    const vx_dtype *col1_dtype = vx_dtype_new_primitive(PTYPE_U8, false);
+    vx_struct_fields_builder_add_field(builder, col1_name, col1_dtype);
+
+    constexpr auto col2 = "col2"sv;
+    const vx_string *col2_name = vx_string_new(col2.data(), col2.size());
+    const vx_dtype *col2_dtype = vx_dtype_new_binary(true);
+    vx_struct_fields_builder_add_field(builder, col2_name, col2_dtype);
+
+    SECTION("Struct builder free") {
+        vx_struct_fields_builder_free(builder);
+    }
+
+    SECTION("Struct builder finalize") {
+        vx_struct_fields *fields = vx_struct_fields_builder_finalize(builder);
+
+        SECTION("struct fields free") {
+            vx_struct_fields_free(fields);
+        }
+
+        SECTION("struct fields finalize") {
+            const vx_dtype *dtype = vx_dtype_new_struct(fields, false);
+            vx_dtype_free(dtype);
+        }
+    }
+}
+
+constexpr size_t STRUCT_LEN = 10;
+TEST_CASE("Creating structs", "[struct]") {
+    vx_struct_fields_builder *builder = vx_struct_fields_builder_new();
+    REQUIRE(builder != nullptr);
+
+    for (size_t i = 0; i < STRUCT_LEN; ++i) {
+        const std::string target_name = "name"s + std::to_string(i);
+        const vx_string *name = vx_string_new(target_name.data(), target_name.size());
+        const vx_dtype *dtype = i % 2 ? vx_dtype_new_binary(false) : vx_dtype_new_primitive(PTYPE_F32, true);
+        vx_struct_fields_builder_add_field(builder, name, dtype);
+    }
+    vx_struct_fields *fields = vx_struct_fields_builder_finalize(builder);
+    REQUIRE(fields != nullptr);
+
+    const size_t len = vx_struct_fields_nfields(fields);
+    CHECK(len == STRUCT_LEN);
+    for (size_t i = 0; i < len; ++i) {
+        // borrowed
+        const vx_string *name = vx_struct_fields_field_name(fields, i);
+        // owned TODO(myrrc): that's weird API
+        const vx_dtype *dtype = vx_struct_fields_field_dtype(fields, i);
+
+        std::string_view name_view {vx_string_ptr(name), vx_string_len(name)};
+        std::string target_name = "name"s + std::to_string(i);
+
+        CHECK(name_view == target_name);
+
+        if (i % 2) {
+            CHECK_FALSE(vx_dtype_is_nullable(dtype));
+            CHECK(vx_dtype_get_variant(dtype) == DTYPE_BINARY);
+        } else {
+            CHECK(vx_dtype_is_nullable(dtype));
+            CHECK(vx_dtype_get_variant(dtype) == DTYPE_PRIMITIVE);
+        }
+
+        vx_dtype_free(dtype);
+    }
+
+    vx_struct_fields_free(fields);
+}
diff --git a/vortex-ffi/tsan_suppressions.txt b/vortex-ffi/tsan_suppressions.txt
new file mode 100644
index 00000000000..6f9ffaae597
--- /dev/null
+++ b/vortex-ffi/tsan_suppressions.txt
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+# https://github.com/vortex-data/vortex/pull/7244
+# This is likely a false positive in TSan for oneshot::channel and kanal
+# where ordering is correct but uses an explicit fence and not relaxed load
+race:oneshot-*/src/channel.rs
diff --git a/vortex-file/Cargo.toml b/vortex-file/Cargo.toml
index d568328bb52..e812ab228c6 100644
--- a/vortex-file/Cargo.toml
+++ b/vortex-file/Cargo.toml
@@ -54,6 +54,7 @@ vortex-scan = { workspace = true }
 vortex-sequence = { workspace = true }
 vortex-session = { workspace = true }
 vortex-sparse = { workspace = true }
+vortex-tensor = { workspace = true, optional = true }
 vortex-utils = { workspace = true, features = ["dashmap"] }
 vortex-zigzag = { workspace = true }
 vortex-zstd = { workspace = true, optional = true }
@@ -79,6 +80,7 @@ tokio = [
 zstd = ["dep:vortex-zstd", "vortex-btrblocks/zstd", "vortex-btrblocks/pco"]
 # This feature enables unstable encodings for which we don't guarantee stability.
 unstable_encodings = [
+    "dep:vortex-tensor",
     "vortex-zstd?/unstable_encodings",
     "vortex-btrblocks/unstable_encodings",
 ]
diff --git a/vortex-file/public-api.lock b/vortex-file/public-api.lock
index 3ade56875ae..36d501a926e 100644
--- a/vortex-file/public-api.lock
+++ b/vortex-file/public-api.lock
@@ -6,7 +6,7 @@ pub struct vortex_file::multi::MultiFileDataSource
 
 impl vortex_file::multi::MultiFileDataSource
 
-pub async fn vortex_file::multi::MultiFileDataSource::build(self) -> vortex_error::VortexResult<impl vortex_scan::api::DataSource>
+pub async fn vortex_file::multi::MultiFileDataSource::build(self) -> vortex_error::VortexResult<impl vortex_scan::DataSource>
 
 pub fn vortex_file::multi::MultiFileDataSource::new(session: vortex_session::VortexSession) -> Self
 
@@ -126,7 +126,7 @@ pub fn vortex_file::BlockingWriter<'_, '_, B>::bytes_written(&self) -> u64
 
 pub fn vortex_file::BlockingWriter<'_, '_, B>::finish(self) -> vortex_error::VortexResult<vortex_file::WriteSummary>
 
-pub fn vortex_file::BlockingWriter<'_, '_, B>::push(&mut self, chunk: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<()>
+pub fn vortex_file::BlockingWriter<'_, '_, B>::push(&mut self, chunk: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<()>
 
 pub struct vortex_file::FileStatistics
 
@@ -134,7 +134,7 @@ impl vortex_file::FileStatistics
 
 pub fn vortex_file::FileStatistics::dtypes(&self) -> &alloc::sync::Arc<[vortex_array::dtype::DType]>
 
-pub fn vortex_file::FileStatistics::from_flatbuffer<'a>(fb: &vortex_flatbuffers::footer::FileStatistics<'a>, file_dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
+pub fn vortex_file::FileStatistics::from_flatbuffer<'a>(fb: &vortex_flatbuffers::footer::FileStatistics<'a>, file_dtype: &vortex_array::dtype::DType, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<Self>
 
 pub fn vortex_file::FileStatistics::get(&self, field_idx: usize) -> (&vortex_array::stats::stats_set::StatsSet, &vortex_array::dtype::DType)
 
@@ -256,13 +256,15 @@ impl core::fmt::Debug for vortex_file::SegmentSpec
 
 pub fn vortex_file::SegmentSpec::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
+impl core::marker::Copy for vortex_file::SegmentSpec
+
 pub struct vortex_file::VortexFile
 
 impl vortex_file::VortexFile
 
 pub fn vortex_file::VortexFile::can_prune(&self, filter: &vortex_array::expr::expression::Expression) -> vortex_error::VortexResult<bool>
 
-pub fn vortex_file::VortexFile::data_source(&self) -> vortex_error::VortexResult<vortex_scan::api::DataSourceRef>
+pub fn vortex_file::VortexFile::data_source(&self) -> vortex_error::VortexResult<vortex_scan::DataSourceRef>
 
 pub fn vortex_file::VortexFile::dtype(&self) -> &vortex_array::dtype::DType
 
@@ -274,7 +276,7 @@ pub fn vortex_file::VortexFile::layout_reader(&self) -> vortex_error::VortexResu
 
 pub fn vortex_file::VortexFile::row_count(&self) -> u64
 
-pub fn vortex_file::VortexFile::scan(&self) -> vortex_error::VortexResult<vortex_scan::scan_builder::ScanBuilder<vortex_array::array::ArrayRef>>
+pub fn vortex_file::VortexFile::scan(&self) -> vortex_error::VortexResult<vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>>
 
 pub fn vortex_file::VortexFile::segment_source(&self) -> alloc::sync::Arc<dyn vortex_layout::segments::source::SegmentSource>
 
@@ -342,24 +344,30 @@ impl vortex_file::WriteStrategyBuilder
 
 pub fn vortex_file::WriteStrategyBuilder::build(self) -> alloc::sync::Arc<dyn vortex_layout::strategy::LayoutStrategy>
 
-pub fn vortex_file::WriteStrategyBuilder::with_allow_encodings(self, allow_encodings: vortex_array::session::ArrayRegistry) -> Self
+pub fn vortex_file::WriteStrategyBuilder::with_allow_encodings(self, allow_encodings: vortex_utils::aliases::hash_set::HashSet<vortex_array::array::ArrayId>) -> Self
 
-pub fn vortex_file::WriteStrategyBuilder::with_compact_encodings(self) -> Self
+pub fn vortex_file::WriteStrategyBuilder::with_btrblocks_builder(self, builder: vortex_btrblocks::builder::BtrBlocksCompressorBuilder) -> Self
 
 pub fn vortex_file::WriteStrategyBuilder::with_compressor<C: vortex_layout::layouts::compressed::CompressorPlugin>(self, compressor: C) -> Self
 
-pub fn vortex_file::WriteStrategyBuilder::with_cuda_compatible_encodings(self) -> Self
-
 pub fn vortex_file::WriteStrategyBuilder::with_field_writer(self, field: impl core::convert::Into<vortex_array::dtype::field::FieldPath>, writer: alloc::sync::Arc<dyn vortex_layout::strategy::LayoutStrategy>) -> Self
 
 pub fn vortex_file::WriteStrategyBuilder::with_flat_strategy(self, flat: alloc::sync::Arc<dyn vortex_layout::strategy::LayoutStrategy>) -> Self
 
 pub fn vortex_file::WriteStrategyBuilder::with_row_block_size(self, row_block_size: usize) -> Self
 
+impl core::clone::Clone for vortex_file::WriteStrategyBuilder
+
+pub fn vortex_file::WriteStrategyBuilder::clone(&self) -> vortex_file::WriteStrategyBuilder
+
 impl core::default::Default for vortex_file::WriteStrategyBuilder
 
 pub fn vortex_file::WriteStrategyBuilder::default() -> Self
 
+impl core::fmt::Debug for vortex_file::WriteStrategyBuilder
+
+pub fn vortex_file::WriteStrategyBuilder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
 pub struct vortex_file::WriteSummary
 
 impl vortex_file::WriteSummary
@@ -380,7 +388,7 @@ pub fn vortex_file::Writer<'_>::bytes_written(&self) -> u64
 
 pub async fn vortex_file::Writer<'_>::finish(self) -> vortex_error::VortexResult<vortex_file::WriteSummary>
 
-pub async fn vortex_file::Writer<'_>::push(&mut self, chunk: vortex_array::array::ArrayRef) -> vortex_error::VortexResult<()>
+pub async fn vortex_file::Writer<'_>::push(&mut self, chunk: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<()>
 
 pub async fn vortex_file::Writer<'_>::push_stream(&mut self, stream: vortex_array::stream::SendableArrayStream) -> vortex_error::VortexResult<()>
 
@@ -396,13 +404,15 @@ pub const vortex_file::VERSION: u16
 
 pub const vortex_file::VORTEX_FILE_EXTENSION: &str
 
-pub static vortex_file::ALLOWED_ENCODINGS: std::sync::lazy_lock::LazyLock<vortex_array::session::ArrayRegistry>
+pub static vortex_file::ALLOWED_ENCODINGS: std::sync::lazy_lock::LazyLock<vortex_utils::aliases::hash_set::HashSet<vortex_array::array::ArrayId>>
 
-pub trait vortex_file::OpenOptionsSessionExt: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt
+pub trait vortex_file::OpenOptionsSessionExt: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt + vortex_array::memory::MemorySessionExt
 
 pub fn vortex_file::OpenOptionsSessionExt::open_options(&self) -> vortex_file::VortexOpenOptions
 
-impl<S: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt> vortex_file::OpenOptionsSessionExt for S
+impl<S: vortex_array::session::ArraySessionExt + vortex_layout::session::LayoutSessionExt + vortex_io::session::RuntimeSessionExt + vortex_array::memory::MemorySessionExt> vortex_file::OpenOptionsSessionExt for S
+
+pub fn S::open_options(&self) -> vortex_file::VortexOpenOptions
 
 pub trait vortex_file::WriteOptionsSessionExt: vortex_session::SessionExt
 
@@ -410,4 +420,6 @@ pub fn vortex_file::WriteOptionsSessionExt::write_options(&self) -> vortex_file:
 
 impl<S: vortex_session::SessionExt> vortex_file::WriteOptionsSessionExt for S
 
-pub fn vortex_file::register_default_encodings(session: &mut vortex_session::VortexSession)
+pub fn S::write_options(&self) -> vortex_file::VortexWriteOptions
+
+pub fn vortex_file::register_default_encodings(session: &vortex_session::VortexSession)
diff --git a/vortex-file/src/counting.rs b/vortex-file/src/counting.rs
index 6eaa8f07d16..78f8a8741a9 100644
--- a/vortex-file/src/counting.rs
+++ b/vortex-file/src/counting.rs
@@ -24,7 +24,7 @@ impl<W: VortexWrite> CountingVortexWrite<W> {
     }
 
     pub fn counter(&self) -> Arc<AtomicU64> {
-        self.bytes_written.clone()
+        Arc::clone(&self.bytes_written)
     }
 }
 
diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs
index d113cc8cf98..7257676b05c 100644
--- a/vortex-file/src/file.rs
+++ b/vortex-file/src/file.rs
@@ -22,11 +22,11 @@ use vortex_array::expr::Expression;
 use vortex_array::expr::pruning::checked_pruning_expr;
 use vortex_error::VortexResult;
 use vortex_layout::LayoutReader;
+use vortex_layout::scan::layout::LayoutReaderDataSource;
+use vortex_layout::scan::scan_builder::ScanBuilder;
+use vortex_layout::scan::split_by::SplitBy;
 use vortex_layout::segments::SegmentSource;
-use vortex_scan::ScanBuilder;
-use vortex_scan::SplitBy;
-use vortex_scan::api::DataSourceRef;
-use vortex_scan::layout::LayoutReaderDataSource;
+use vortex_scan::DataSourceRef;
 use vortex_session::VortexSession;
 use vortex_utils::aliases::hash_map::HashMap;
 
@@ -78,7 +78,7 @@ impl VortexFile {
     /// This may spawn a background I/O driver that will exit when the returned segment source
     /// is dropped.
     pub fn segment_source(&self) -> Arc<dyn SegmentSource> {
-        self.segment_source.clone()
+        Arc::clone(&self.segment_source)
     }
 
     /// Create a new layout reader for the file.
@@ -90,7 +90,7 @@ impl VortexFile {
             .new_reader("".into(), segment_source, &self.session)
     }
 
-    /// Create a [`DataSource`](vortex_scan::api::DataSource) from this file for scanning.
+    /// Create a [`DataSource`](vortex_scan::DataSource) from this file for scanning.
     ///
     /// Wraps the file's layout reader with [`FileStatsLayoutReader`] (when file-level
     /// statistics are available) and [`LayoutReaderDataSource`].
diff --git a/vortex-file/src/footer/deserializer.rs b/vortex-file/src/footer/deserializer.rs
index fb644812ea7..9b594e31fd6 100644
--- a/vortex-file/src/footer/deserializer.rs
+++ b/vortex-file/src/footer/deserializer.rs
@@ -142,7 +142,13 @@ impl FooterDeserializer {
             .statistics
             .as_ref()
             .map(|segment| {
-                self.parse_file_statistics(initial_offset, &self.buffer, segment, &dtype)
+                self.parse_file_statistics(
+                    initial_offset,
+                    &self.buffer,
+                    segment,
+                    &dtype,
+                    &self.session,
+                )
             })
             .transpose()?;
 
@@ -222,13 +228,14 @@ impl FooterDeserializer {
         initial_read: &[u8],
         segment: &PostscriptSegment,
         dtype: &DType,
+        session: &VortexSession,
     ) -> VortexResult<FileStatistics> {
         let offset = usize::try_from(segment.offset - initial_offset)?;
         let sliced_buffer =
             FlatBuffer::copy_from(&initial_read[offset..offset + (segment.length as usize)]);
 
         let fb = root::<vortex_flatbuffers::footer::FileStatistics>(&sliced_buffer)?;
-        FileStatistics::from_flatbuffer(&fb, dtype)
+        FileStatistics::from_flatbuffer(&fb, dtype, session)
     }
 
     /// Parse the rest of the footer from the initial read.
diff --git a/vortex-file/src/footer/file_layout.rs b/vortex-file/src/footer/file_layout.rs
index 684955d7c80..22e5a3e593d 100644
--- a/vortex-file/src/footer/file_layout.rs
+++ b/vortex-file/src/footer/file_layout.rs
@@ -11,12 +11,11 @@ use std::sync::Arc;
 
 use flatbuffers::FlatBufferBuilder;
 use flatbuffers::WIPOffset;
-use vortex_array::ArrayContext;
 use vortex_error::VortexResult;
 use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::footer as fb;
-use vortex_layout::LayoutContext;
+use vortex_session::registry::ReadContext;
 
 use crate::footer::segment::SegmentSpec;
 
@@ -26,9 +25,9 @@ use crate::footer::segment::SegmentSpec;
 /// which describes the structure of the data in the file.
 pub(crate) struct FooterFlatBufferWriter {
     /// The array context containing encodings used in the file.
-    pub(crate) ctx: ArrayContext,
+    pub(crate) ctx: ReadContext,
     /// The layout context containing the layouts used in the file.
-    pub(crate) layout_ctx: LayoutContext,
+    pub(crate) layout_ctx: ReadContext,
     /// Specifications for all segments in the file.
     pub(crate) segment_specs: Arc<[SegmentSpec]>,
 }
@@ -47,7 +46,7 @@ impl WriteFlatBuffer for FooterFlatBufferWriter {
 
         let array_specs = self
             .ctx
-            .to_ids()
+            .ids()
             .iter()
             .map(|e| {
                 let id = fbb.create_string(e.as_ref());
@@ -58,7 +57,7 @@ impl WriteFlatBuffer for FooterFlatBufferWriter {
 
         let layout_specs = self
             .layout_ctx
-            .to_ids()
+            .ids()
             .iter()
             .map(|e| {
                 let id = fbb.create_string(e.as_ref());
diff --git a/vortex-file/src/footer/file_statistics.rs b/vortex-file/src/footer/file_statistics.rs
index 704ae6a44c0..4fac3ad8482 100644
--- a/vortex-file/src/footer/file_statistics.rs
+++ b/vortex-file/src/footer/file_statistics.rs
@@ -20,6 +20,7 @@ use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::array::ArrayStats;
 use vortex_flatbuffers::footer as fb;
+use vortex_session::VortexSession;
 
 /// Contains statistical information about the data in a Vortex file.
 ///
@@ -90,6 +91,7 @@ impl FileStatistics {
     pub fn from_flatbuffer<'a>(
         fb: &fb::FileStatistics<'a>,
         file_dtype: &DType,
+        session: &VortexSession,
     ) -> VortexResult<Self> {
         let field_stats = fb.field_stats().unwrap_or_default();
         let mut array_stats: Vec<ArrayStats> = field_stats.iter().collect();
@@ -101,7 +103,7 @@ impl FileStatistics {
                 .into_iter()
                 .zip(struct_fields.fields())
                 .map(|(array_stat, field_dtype)| {
-                    StatsSet::from_flatbuffer(&array_stat, &field_dtype)
+                    StatsSet::from_flatbuffer(&array_stat, &field_dtype, session)
                 })
                 .try_collect()?;
 
@@ -117,7 +119,7 @@ impl FileStatistics {
             let array_stat = array_stats
                 .pop()
                 .vortex_expect("we just checked that there was 1 field");
-            let stats_set = StatsSet::from_flatbuffer(&array_stat, file_dtype)?;
+            let stats_set = StatsSet::from_flatbuffer(&array_stat, file_dtype, session)?;
 
             Ok(Self {
                 stats: Arc::new([stats_set]),
diff --git a/vortex-file/src/footer/mod.rs b/vortex-file/src/footer/mod.rs
index 4142a60ded9..e0d08568108 100644
--- a/vortex-file/src/footer/mod.rs
+++ b/vortex-file/src/footer/mod.rs
@@ -24,21 +24,20 @@ pub use file_statistics::FileStatistics;
 use flatbuffers::root;
 use itertools::Itertools;
 pub use segment::*;
-use vortex_array::ArrayContext;
+use vortex_array::ArrayId;
 use vortex_array::dtype::DType;
-use vortex_array::vtable::ArrayId;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::footer as fb;
-use vortex_layout::LayoutContext;
 use vortex_layout::LayoutEncodingId;
 use vortex_layout::LayoutRef;
-use vortex_layout::layout_from_flatbuffer;
+use vortex_layout::layout_from_flatbuffer_with_options;
 use vortex_layout::session::LayoutSessionExt;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 /// Captures the layout information of a Vortex file.
 #[derive(Debug, Clone)]
@@ -47,7 +46,7 @@ pub struct Footer {
     segments: Arc<[SegmentSpec]>,
     statistics: Option<FileStatistics>,
     // The specific arrays used within the file, in the order they were registered.
-    array_ctx: ArrayContext,
+    array_read_ctx: ReadContext,
     // The approximate size of the footer in bytes, used for caching and memory management.
     approx_byte_size: Option<usize>,
 }
@@ -57,13 +56,13 @@ impl Footer {
         root_layout: LayoutRef,
         segments: Arc<[SegmentSpec]>,
         statistics: Option<FileStatistics>,
-        array_ctx: ArrayContext,
+        array_read_ctx: ReadContext,
     ) -> Self {
         Self {
             root_layout,
             segments,
             statistics,
-            array_ctx,
+            array_read_ctx,
             approx_byte_size: None,
         }
     }
@@ -86,28 +85,29 @@ impl Footer {
 
         // Create a LayoutContext from the registry.
         let layout_specs = fb_footer.layout_specs();
-        let layout_ids = layout_specs
+        let layout_ids: Arc<[_]> = layout_specs
             .iter()
             .flat_map(|e| e.iter())
             .map(|encoding| LayoutEncodingId::new_arc(Arc::from(encoding.id())))
             .collect();
-        let layout_ctx = LayoutContext::new(layout_ids);
+        let layout_read_ctx = ReadContext::new(layout_ids);
 
         // Create an ArrayContext from the registry.
         let array_specs = fb_footer.array_specs();
-        let array_ids = array_specs
+        let array_ids: Arc<[_]> = array_specs
             .iter()
             .flat_map(|e| e.iter())
             .map(|encoding| ArrayId::new_arc(Arc::from(encoding.id())))
             .collect();
-        let array_ctx = ArrayContext::new(array_ids);
+        let array_read_ctx = ReadContext::new(array_ids);
 
-        let root_layout = layout_from_flatbuffer(
+        let root_layout = layout_from_flatbuffer_with_options(
             layout_bytes,
             &dtype,
-            &layout_ctx,
-            &array_ctx,
+            &layout_read_ctx,
+            &array_read_ctx,
             session.layouts().registry(),
+            session.allows_unknown(),
         )?;
 
         let segments: Arc<[SegmentSpec]> = fb_footer
@@ -126,7 +126,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
-            array_ctx,
+            array_read_ctx,
             approx_byte_size: Some(approx_byte_size),
         })
     }
diff --git a/vortex-file/src/footer/segment.rs b/vortex-file/src/footer/segment.rs
index 7872116404b..8dcb7d1802b 100644
--- a/vortex-file/src/footer/segment.rs
+++ b/vortex-file/src/footer/segment.rs
@@ -11,7 +11,7 @@ use vortex_flatbuffers::footer as fb;
 ///
 /// A segment is a contiguous block of bytes in a file that contains a part of the file's data.
 /// The `SegmentSpec` struct specifies the location and properties of a segment.
-#[derive(Clone, Debug)]
+#[derive(Clone, Copy, Debug)]
 pub struct SegmentSpec {
     /// The byte offset of the segment from the start of the file.
     pub offset: u64,
diff --git a/vortex-file/src/footer/serializer.rs b/vortex-file/src/footer/serializer.rs
index cc1d773115f..af5a7f9e909 100644
--- a/vortex-file/src/footer/serializer.rs
+++ b/vortex-file/src/footer/serializer.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -10,6 +12,7 @@ use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::WriteFlatBufferExt;
 use vortex_layout::LayoutContext;
+use vortex_session::registry::ReadContext;
 
 use crate::EOF_SIZE;
 use crate::Footer;
@@ -94,9 +97,9 @@ impl FooterSerializer {
         let (buffer, footer_segment) = write_flatbuffer(
             &mut self.offset,
             &FooterFlatBufferWriter {
-                ctx: self.footer.array_ctx.clone(),
-                layout_ctx,
-                segment_specs: self.footer.segments.clone(),
+                ctx: self.footer.array_read_ctx.clone(),
+                layout_ctx: ReadContext::new(layout_ctx.to_ids()),
+                segment_specs: Arc::clone(&self.footer.segments),
             },
         )?;
         buffers.push(buffer);
diff --git a/vortex-file/src/lib.rs b/vortex-file/src/lib.rs
index 055c4b53890..000df4a7bcb 100644
--- a/vortex-file/src/lib.rs
+++ b/vortex-file/src/lib.rs
@@ -109,23 +109,14 @@ pub use footer::*;
 pub use forever_constant::*;
 pub use open::*;
 pub use strategy::*;
-use vortex_alp::ALPRDVTable;
-use vortex_alp::ALPVTable;
-use vortex_array::arrays::DictVTable;
+use vortex_array::arrays::Dict;
 use vortex_array::session::ArraySessionExt;
-use vortex_bytebool::ByteBoolVTable;
-use vortex_datetime_parts::DateTimePartsVTable;
-use vortex_decimal_byte_parts::DecimalBytePartsVTable;
-use vortex_fastlanes::BitPackedVTable;
-use vortex_fastlanes::DeltaVTable;
-use vortex_fastlanes::FoRVTable;
-use vortex_fastlanes::RLEVTable;
-use vortex_fsst::FSSTVTable;
-use vortex_pco::PcoVTable;
-use vortex_sequence::SequenceVTable;
+use vortex_bytebool::ByteBool;
+use vortex_fsst::FSST;
+use vortex_pco::Pco;
 use vortex_session::VortexSession;
-use vortex_sparse::SparseVTable;
-use vortex_zigzag::ZigZagVTable;
+use vortex_sparse::Sparse;
+use vortex_zigzag::ZigZag;
 pub use writer::*;
 
 /// The current version of the Vortex file format
@@ -164,34 +155,30 @@ mod forever_constant {
 ///
 /// NOTE: this function will be changed in the future to encapsulate logic for using different
 /// Vortex "Editions" that may support different sets of encodings.
-pub fn register_default_encodings(session: &mut VortexSession) {
+pub fn register_default_encodings(session: &VortexSession) {
     {
         let arrays = session.arrays();
-        arrays.register(ALPVTable::ID, ALPVTable);
-        arrays.register(ALPRDVTable::ID, ALPRDVTable);
-        arrays.register(BitPackedVTable::ID, BitPackedVTable);
-        arrays.register(ByteBoolVTable::ID, ByteBoolVTable);
-        arrays.register(DateTimePartsVTable::ID, DateTimePartsVTable);
-        arrays.register(DecimalBytePartsVTable::ID, DecimalBytePartsVTable);
-        arrays.register(DeltaVTable::ID, DeltaVTable);
-        arrays.register(DictVTable::ID, DictVTable);
-        arrays.register(FSSTVTable::ID, FSSTVTable);
-        arrays.register(FoRVTable::ID, FoRVTable);
-        arrays.register(PcoVTable::ID, PcoVTable);
-        arrays.register(RLEVTable::ID, RLEVTable);
-        arrays.register(SequenceVTable::ID, SequenceVTable);
-        arrays.register(SparseVTable::ID, SparseVTable);
-        arrays.register(ZigZagVTable::ID, ZigZagVTable);
+        arrays.register(ByteBool);
+        arrays.register(Dict);
+        arrays.register(FSST);
+        arrays.register(Pco);
+        arrays.register(Sparse);
+        arrays.register(ZigZag);
         #[cfg(feature = "zstd")]
-        arrays.register(vortex_zstd::ZstdVTable::ID, vortex_zstd::ZstdVTable);
+        arrays.register(vortex_zstd::Zstd);
         #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-        arrays.register(
-            vortex_zstd::ZstdBuffersVTable::ID,
-            vortex_zstd::ZstdBuffersVTable,
-        );
+        arrays.register(vortex_zstd::ZstdBuffers);
     }
 
     // Eventually all encodings crates should expose an initialize function. For now it's only
     // a few of them.
-    vortex_runend::initialize(session)
+    vortex_alp::initialize(session);
+    vortex_datetime_parts::initialize(session);
+    vortex_decimal_byte_parts::initialize(session);
+    vortex_fastlanes::initialize(session);
+    vortex_runend::initialize(session);
+    vortex_sequence::initialize(session);
+
+    #[cfg(feature = "unstable_encodings")]
+    vortex_tensor::initialize(session);
 }
diff --git a/vortex-file/src/multi/mod.rs b/vortex-file/src/multi/mod.rs
index 36a5812588f..2e0c3735499 100644
--- a/vortex-file/src/multi/mod.rs
+++ b/vortex-file/src/multi/mod.rs
@@ -17,9 +17,9 @@ use vortex_error::vortex_err;
 use vortex_io::filesystem::FileListing;
 use vortex_io::filesystem::FileSystemRef;
 use vortex_layout::LayoutReaderRef;
-use vortex_scan::api::DataSource;
-use vortex_scan::multi::LayoutReaderFactory;
-use vortex_scan::multi::MultiLayoutDataSource;
+use vortex_layout::scan::multi::LayoutReaderFactory;
+use vortex_layout::scan::multi::MultiLayoutDataSource;
+use vortex_scan::DataSource;
 use vortex_session::VortexSession;
 
 use crate::OpenOptionsSessionExt;
@@ -127,10 +127,10 @@ impl MultiFileDataSource {
             .iter()
             .map(|f| {
                 Arc::new(VortexFileReaderFactory {
-                    fs: fs.clone(),
+                    fs: Arc::clone(&fs),
                     file: f.clone(),
                     session: self.session.clone(),
-                    open_options_fn: self.open_options_fn.clone(),
+                    open_options_fn: Arc::clone(&self.open_options_fn),
                 }) as Arc<dyn LayoutReaderFactory>
             })
             .collect();
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 8ed8c6645ec..3a5d3cf90e5 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -6,6 +6,7 @@ use std::sync::Arc;
 use futures::executor::block_on;
 use parking_lot::RwLock;
 use vortex_array::dtype::DType;
+use vortex_array::memory::MemorySessionExt;
 use vortex_array::session::ArraySessionExt;
 use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
@@ -32,6 +33,7 @@ use crate::EOF_SIZE;
 use crate::MAX_POSTSCRIPT_SIZE;
 use crate::VortexFile;
 use crate::footer::Footer;
+use crate::segments::BufferSegmentSource;
 use crate::segments::FileSegmentSource;
 use crate::segments::InitialReadSegmentCache;
 use crate::segments::RequestMetrics;
@@ -60,7 +62,9 @@ pub struct VortexOpenOptions {
     labels: Vec<Label>,
 }
 
-pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt {
+pub trait OpenOptionsSessionExt:
+    ArraySessionExt + LayoutSessionExt + RuntimeSessionExt + MemorySessionExt
+{
     /// Create a new [`VortexOpenOptions`] using the provided session to open a file.
     fn open_options(&self) -> VortexOpenOptions {
         VortexOpenOptions {
@@ -76,7 +80,10 @@ pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSes
         }
     }
 }
-impl<S: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt> OpenOptionsSessionExt for S {}
+impl<S: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt + MemorySessionExt>
+    OpenOptionsSessionExt for S
+{
+}
 
 impl VortexOpenOptions {
     /// Configure the initial read size for the Vortex file.
@@ -156,14 +163,42 @@ impl VortexOpenOptions {
     pub async fn open_path(self, path: impl AsRef<std::path::Path>) -> VortexResult<VortexFile> {
         use vortex_io::std_file::FileReadAt;
         let handle = self.session.handle();
-        let source = Arc::new(FileReadAt::open(path, handle)?);
+        let allocator = self.session.allocator();
+        let source = Arc::new(FileReadAt::open_with_allocator(path, handle, allocator)?);
         self.open(source).await
     }
 
     /// Open a Vortex file from an in-memory buffer.
+    ///
+    /// This uses a `BufferSegmentSource` that resolves segments synchronously
+    /// by slicing the buffer directly, bypassing the async I/O pipeline.
     pub fn open_buffer<B: Into<ByteBuffer>>(self, buffer: B) -> VortexResult<VortexFile> {
-        // We know this is in memory, so we can open it synchronously.
-        block_on(self.with_initial_read_size(0).open_read(buffer.into()))
+        let buffer: ByteBuffer = buffer.into();
+
+        if self.segment_cache.is_some() {
+            tracing::warn!("segment cache is ignored for in-memory `open_buffer`");
+        }
+        if self.metrics_registry.is_some() {
+            tracing::warn!("metrics registry is ignored for in-memory `open_buffer`");
+        }
+
+        let mut opts = self.with_initial_read_size(0);
+
+        let footer = match opts.footer.take() {
+            Some(footer) => footer,
+            None => block_on(opts.read_footer(&buffer))?,
+        };
+
+        let segment_source = Arc::new(BufferSegmentSource::new(
+            buffer,
+            Arc::clone(footer.segment_map()),
+        ));
+
+        Ok(VortexFile {
+            footer,
+            segment_source,
+            session: opts.session,
+        })
     }
 
     /// An API for opening a [`VortexFile`] using any [`VortexReadAt`] implementation.
@@ -197,7 +232,7 @@ impl VortexOpenOptions {
 
         // Create a segment source backed by the VortexRead implementation.
         let segment_source = Arc::new(SharedSegmentSource::new(FileSegmentSource::open(
-            footer.segment_map().clone(),
+            Arc::clone(footer.segment_map()),
             reader,
             self.session.handle(),
             metrics,
@@ -301,10 +336,12 @@ impl VortexOpenOptions {
         use vortex_io::object_store::ObjectStoreReadAt;
 
         let handle = self.session.handle();
-        let source = Arc::new(ObjectStoreReadAt::new(
-            object_store.clone(),
+        let allocator = self.session.allocator();
+        let source = Arc::new(ObjectStoreReadAt::new_with_allocator(
+            Arc::clone(object_store),
             path.into(),
             handle,
+            allocator,
         ));
         self.open(source).await
     }
@@ -319,9 +356,15 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::buffer::BufferHandle;
     use vortex_array::dtype::session::DTypeSession;
+    use vortex_array::memory::DefaultHostAllocator;
+    use vortex_array::memory::HostAllocator;
+    use vortex_array::memory::MemorySessionExt;
+    use vortex_array::memory::WritableHostBuffer;
     use vortex_array::scalar_fn::session::ScalarFnSession;
     use vortex_array::session::ArraySession;
+    use vortex_buffer::Alignment;
     use vortex_buffer::Buffer;
+    use vortex_buffer::ByteBuffer;
     use vortex_buffer::ByteBufferMut;
     use vortex_io::session::RuntimeSession;
     use vortex_layout::session::LayoutSession;
@@ -363,18 +406,31 @@ mod tests {
         }
     }
 
+    #[derive(Debug)]
+    struct CountingAllocator {
+        allocations: Arc<AtomicUsize>,
+    }
+
+    impl HostAllocator for CountingAllocator {
+        fn allocate(&self, len: usize, alignment: Alignment) -> VortexResult<WritableHostBuffer> {
+            self.allocations.fetch_add(1, Ordering::Relaxed);
+            DefaultHostAllocator.allocate(len, alignment)
+        }
+    }
+
     #[tokio::test]
     async fn test_initial_read_size() {
-        // Create a large file (> 1MB)
-        let mut buf = ByteBufferMut::empty();
-        let mut session = VortexSession::empty()
+        let session = VortexSession::empty()
             .with::<DTypeSession>()
             .with::<ArraySession>()
             .with::<LayoutSession>()
             .with::<ScalarFnSession>()
             .with::<RuntimeSession>();
 
-        crate::register_default_encodings(&mut session);
+        crate::register_default_encodings(&session);
+
+        // Create a large file (> 1MB)
+        let mut buf = ByteBufferMut::empty();
 
         // 1.5M integers -> ~6MB. We use a pattern to avoid Sequence encoding.
         let array = Buffer::from(
@@ -401,8 +457,8 @@ mod tests {
         let first_read_len = Arc::new(AtomicUsize::new(0));
         let reader = CountingRead {
             inner: buffer,
-            total_read: total_read.clone(),
-            first_read_len: first_read_len.clone(),
+            total_read: Arc::clone(&total_read),
+            first_read_len: Arc::clone(&first_read_len),
         };
 
         // Open the file
@@ -418,4 +474,46 @@ mod tests {
         let read = total_read.load(Ordering::Relaxed);
         assert!(read < 1024 * 1024, "Read {} bytes, expected < 1MB", read);
     }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test]
+    async fn test_open_path_uses_memory_session_allocator() {
+        let session = VortexSession::empty()
+            .with::<DTypeSession>()
+            .with::<ArraySession>()
+            .with::<LayoutSession>()
+            .with::<ScalarFnSession>()
+            .with::<RuntimeSession>();
+
+        crate::register_default_encodings(&session);
+
+        let mut buf = ByteBufferMut::empty();
+        let array = Buffer::from((0i32..16_384).collect::<Vec<i32>>()).into_array();
+        session
+            .write_options()
+            .write(&mut buf, array.to_array_stream())
+            .await
+            .unwrap();
+
+        let file_path = std::env::temp_dir().join(format!(
+            "vortex-open-memory-session-{}.vx",
+            std::process::id()
+        ));
+        std::fs::write(&file_path, ByteBuffer::from(buf).as_slice()).unwrap();
+
+        let allocations = Arc::new(AtomicUsize::new(0));
+        session
+            .memory_mut()
+            .set_allocator(Arc::new(CountingAllocator {
+                allocations: Arc::clone(&allocations),
+            }));
+
+        let _file = session.open_options().open_path(&file_path).await.unwrap();
+        std::fs::remove_file(&file_path).unwrap();
+
+        assert!(
+            allocations.load(Ordering::Relaxed) > 0,
+            "expected at least one host allocation from MemorySession"
+        );
+    }
 }
diff --git a/vortex-file/src/pruning.rs b/vortex-file/src/pruning.rs
index 7da01350fe3..d5ae649ae6d 100644
--- a/vortex-file/src/pruning.rs
+++ b/vortex-file/src/pruning.rs
@@ -4,6 +4,7 @@
 use std::sync::Arc;
 
 use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::dtype::Field;
@@ -30,7 +31,7 @@ pub fn extract_relevant_file_stats_as_struct_row(
 ) -> VortexResult<Option<ArrayRef>> {
     if access.is_empty() {
         return StructArray::try_new(FieldNames::default(), vec![], 1, Validity::NonNullable)
-            .map(|s| Some(s.to_array()));
+            .map(|s| Some(s.into_array()));
     }
 
     let mut columns: Vec<(FieldName, ArrayRef)> = Vec::with_capacity(access.len() * 2);
@@ -64,7 +65,7 @@ pub fn extract_relevant_file_stats_as_struct_row(
                 };
                 columns.push((
                     field_path_stat_field_name(field_path, *stat),
-                    ConstantArray::new(stat_value, 1).to_array(),
+                    ConstantArray::new(stat_value, 1).into_array(),
                 ));
             } else {
                 todo!("unsupported file prune stat {stat}")
@@ -72,6 +73,6 @@ pub fn extract_relevant_file_stats_as_struct_row(
         }
     }
     Ok(Some(
-        StructArray::from_fields(columns.as_slice())?.to_array(),
+        StructArray::from_fields(columns.as_slice())?.into_array(),
     ))
 }
diff --git a/vortex-file/src/read/request.rs b/vortex-file/src/read/request.rs
index cdd71670070..7caaa08d3d8 100644
--- a/vortex-file/src/read/request.rs
+++ b/vortex-file/src/read/request.rs
@@ -140,7 +140,7 @@ impl CoalescedRequest {
                     Err(e) => {
                         let e = Arc::new(e);
                         for req in self.requests.into_iter() {
-                            req.resolve(Err(VortexError::from(e.clone())));
+                            req.resolve(Err(VortexError::from(Arc::clone(&e))));
                         }
                         return;
                     }
@@ -163,7 +163,7 @@ impl CoalescedRequest {
             Err(e) => {
                 let e = Arc::new(e);
                 for req in self.requests.into_iter() {
-                    req.resolve(Err(VortexError::from(e.clone())));
+                    req.resolve(Err(VortexError::from(Arc::clone(&e))));
                 }
             }
         }
diff --git a/vortex-file/src/segments/source.rs b/vortex-file/src/segments/source.rs
index b981e1d5afa..8f83150c4bb 100644
--- a/vortex-file/src/segments/source.rs
+++ b/vortex-file/src/segments/source.rs
@@ -14,6 +14,7 @@ use futures::channel::mpsc;
 use futures::future;
 use vortex_array::buffer::BufferHandle;
 use vortex_buffer::Alignment;
+use vortex_buffer::ByteBuffer;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
@@ -136,7 +137,7 @@ impl SegmentSource for FileSegmentSource {
     fn request(&self, id: SegmentId) -> SegmentFuture {
         // We eagerly register the read request here assuming the behaviour of [`FileRead`], where
         // coalescing becomes effective prior to the future being polled.
-        let spec = match self.segments.get(*id as usize).cloned() {
+        let spec = *match self.segments.get(*id as usize) {
             Some(spec) => spec,
             None => {
                 return future::ready(Err(vortex_err!("Missing segment: {}", id))).boxed();
@@ -166,7 +167,7 @@ impl SegmentSource for FileSegmentSource {
 
         let fut = ReadFuture {
             id,
-            recv,
+            recv: recv.into_future(),
             polled: false,
             finished: false,
             events: self.events.clone(),
@@ -183,7 +184,7 @@ impl SegmentSource for FileSegmentSource {
 /// If dropped, the read request will be canceled where possible.
 struct ReadFuture {
     id: usize,
-    recv: oneshot::Receiver<VortexResult<BufferHandle>>,
+    recv: oneshot::AsyncReceiver<VortexResult<BufferHandle>>,
     polled: bool,
     finished: bool,
     events: mpsc::UnboundedSender<ReadEvent>,
@@ -251,3 +252,46 @@ impl RequestMetrics {
         }
     }
 }
+
+/// A [`SegmentSource`] that resolves segments synchronously from an
+/// in-memory [`ByteBuffer`].
+///
+/// Resolves segments synchronously, bypassing the async I/O pipeline.
+pub(crate) struct BufferSegmentSource {
+    buffer: ByteBuffer,
+    segments: Arc<[SegmentSpec]>,
+}
+
+impl BufferSegmentSource {
+    /// Create a new `BufferSegmentSource` from a buffer and its segment map.
+    pub fn new(buffer: ByteBuffer, segments: Arc<[SegmentSpec]>) -> Self {
+        Self { buffer, segments }
+    }
+}
+
+impl SegmentSource for BufferSegmentSource {
+    fn request(&self, id: SegmentId) -> SegmentFuture {
+        let spec = match self.segments.get(*id as usize) {
+            Some(spec) => spec,
+            None => {
+                return future::ready(Err(vortex_err!("Missing segment: {}", id))).boxed();
+            }
+        };
+
+        let start = spec.offset as usize;
+        let end = start + spec.length as usize;
+        if end > self.buffer.len() {
+            return future::ready(Err(vortex_err!(
+                "Segment {} range {}..{} out of bounds for buffer of length {}",
+                *id,
+                start,
+                end,
+                self.buffer.len()
+            )))
+            .boxed();
+        }
+
+        let slice = self.buffer.slice(start..end).aligned(spec.alignment);
+        future::ready(Ok(BufferHandle::new_host(slice))).boxed()
+    }
+}
diff --git a/vortex-file/src/strategy.rs b/vortex-file/src/strategy.rs
index abd273f936d..544d2b03470 100644
--- a/vortex-file/src/strategy.rs
+++ b/vortex-file/src/strategy.rs
@@ -6,43 +6,38 @@
 use std::sync::Arc;
 use std::sync::LazyLock;
 
-// Compressed encodings from encoding crates
-// Canonical array encodings from vortex-array
-use vortex_alp::ALPRDVTable;
-use vortex_alp::ALPVTable;
-use vortex_array::arrays::BoolVTable;
-use vortex_array::arrays::ChunkedVTable;
-use vortex_array::arrays::ConstantVTable;
-use vortex_array::arrays::DecimalVTable;
-use vortex_array::arrays::DictVTable;
-use vortex_array::arrays::ExtensionVTable;
-use vortex_array::arrays::FixedSizeListVTable;
-use vortex_array::arrays::ListVTable;
-use vortex_array::arrays::ListViewVTable;
-use vortex_array::arrays::MaskedVTable;
-use vortex_array::arrays::NullVTable;
-use vortex_array::arrays::PrimitiveVTable;
-use vortex_array::arrays::StructVTable;
-use vortex_array::arrays::VarBinVTable;
-use vortex_array::arrays::VarBinViewVTable;
+use vortex_alp::ALP;
+use vortex_alp::ALPRD;
+use vortex_array::ArrayId;
+use vortex_array::VTable;
+use vortex_array::arrays::Bool;
+use vortex_array::arrays::Chunked;
+use vortex_array::arrays::Constant;
+use vortex_array::arrays::Decimal;
+use vortex_array::arrays::Dict;
+use vortex_array::arrays::Extension;
+use vortex_array::arrays::FixedSizeList;
+use vortex_array::arrays::List;
+use vortex_array::arrays::ListView;
+use vortex_array::arrays::Masked;
+use vortex_array::arrays::Null;
+use vortex_array::arrays::Patched;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::Struct;
+use vortex_array::arrays::VarBin;
+use vortex_array::arrays::VarBinView;
 use vortex_array::dtype::FieldPath;
-use vortex_array::session::ArrayRegistry;
-#[cfg(feature = "zstd")]
 use vortex_btrblocks::BtrBlocksCompressorBuilder;
-#[cfg(feature = "zstd")]
-use vortex_btrblocks::FloatCode;
-#[cfg(feature = "zstd")]
-use vortex_btrblocks::IntCode;
-#[cfg(feature = "zstd")]
-use vortex_btrblocks::StringCode;
-use vortex_bytebool::ByteBoolVTable;
-use vortex_datetime_parts::DateTimePartsVTable;
-use vortex_decimal_byte_parts::DecimalBytePartsVTable;
-use vortex_fastlanes::BitPackedVTable;
-use vortex_fastlanes::DeltaVTable;
-use vortex_fastlanes::FoRVTable;
-use vortex_fastlanes::RLEVTable;
-use vortex_fsst::FSSTVTable;
+use vortex_btrblocks::SchemeExt;
+use vortex_btrblocks::schemes::integer::IntDictScheme;
+use vortex_bytebool::ByteBool;
+use vortex_datetime_parts::DateTimeParts;
+use vortex_decimal_byte_parts::DecimalByteParts;
+use vortex_fastlanes::BitPacked;
+use vortex_fastlanes::Delta;
+use vortex_fastlanes::FoR;
+use vortex_fastlanes::RLE;
+use vortex_fsst::FSST;
 use vortex_layout::LayoutStrategy;
 use vortex_layout::layouts::buffered::BufferedStrategy;
 use vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy;
@@ -56,16 +51,19 @@ use vortex_layout::layouts::repartition::RepartitionWriterOptions;
 use vortex_layout::layouts::table::TableStrategy;
 use vortex_layout::layouts::zoned::writer::ZonedLayoutOptions;
 use vortex_layout::layouts::zoned::writer::ZonedStrategy;
-use vortex_pco::PcoVTable;
-use vortex_runend::RunEndVTable;
-use vortex_sequence::SequenceVTable;
-use vortex_sparse::SparseVTable;
+use vortex_pco::Pco;
+use vortex_runend::RunEnd;
+use vortex_sequence::Sequence;
+use vortex_sparse::Sparse;
+#[cfg(feature = "unstable_encodings")]
+use vortex_tensor::encodings::turboquant::TurboQuant;
 use vortex_utils::aliases::hash_map::HashMap;
-use vortex_zigzag::ZigZagVTable;
-#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-use vortex_zstd::ZstdBuffersVTable;
+use vortex_utils::aliases::hash_set::HashSet;
+use vortex_zigzag::ZigZag;
 #[cfg(feature = "zstd")]
-use vortex_zstd::ZstdVTable;
+use vortex_zstd::Zstd;
+#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+use vortex_zstd::ZstdBuffers;
 
 const ONE_MEG: u64 = 1 << 20;
 
@@ -73,62 +71,89 @@ const ONE_MEG: u64 = 1 << 20;
 ///
 /// This includes all canonical encodings from vortex-array plus all compressed
 /// encodings from the various encoding crates.
-pub static ALLOWED_ENCODINGS: LazyLock<ArrayRegistry> = LazyLock::new(|| {
-    let registry = ArrayRegistry::default();
+pub static ALLOWED_ENCODINGS: LazyLock<HashSet<ArrayId>> = LazyLock::new(|| {
+    let mut allowed = HashSet::new();
 
     // Canonical encodings from vortex-array
-    registry.register(NullVTable::ID, NullVTable);
-    registry.register(BoolVTable::ID, BoolVTable);
-    registry.register(PrimitiveVTable::ID, PrimitiveVTable);
-    registry.register(DecimalVTable::ID, DecimalVTable);
-    registry.register(VarBinVTable::ID, VarBinVTable);
-    registry.register(VarBinViewVTable::ID, VarBinViewVTable);
-    registry.register(ListVTable::ID, ListVTable);
-    registry.register(ListViewVTable::ID, ListViewVTable);
-    registry.register(FixedSizeListVTable::ID, FixedSizeListVTable);
-    registry.register(StructVTable::ID, StructVTable);
-    registry.register(ExtensionVTable::ID, ExtensionVTable);
-    registry.register(ChunkedVTable::ID, ChunkedVTable);
-    registry.register(ConstantVTable::ID, ConstantVTable);
-    registry.register(MaskedVTable::ID, MaskedVTable);
-    registry.register(DictVTable::ID, DictVTable);
+    allowed.insert(Null.id());
+    allowed.insert(Bool.id());
+    allowed.insert(Primitive.id());
+    allowed.insert(Decimal.id());
+    allowed.insert(VarBin.id());
+    allowed.insert(VarBinView.id());
+    allowed.insert(List.id());
+    allowed.insert(ListView.id());
+    allowed.insert(FixedSizeList.id());
+    allowed.insert(Struct.id());
+    allowed.insert(Extension.id());
+    allowed.insert(Chunked.id());
+    allowed.insert(Constant.id());
+    allowed.insert(Masked.id());
+    allowed.insert(Dict.id());
+
+    if *vortex_fastlanes::USE_EXPERIMENTAL_PATCHES {
+        allowed.insert(Patched.id());
+    }
 
     // Compressed encodings from encoding crates
-    registry.register(ALPVTable::ID, ALPVTable);
-    registry.register(ALPRDVTable::ID, ALPRDVTable);
-    registry.register(BitPackedVTable::ID, BitPackedVTable);
-    registry.register(ByteBoolVTable::ID, ByteBoolVTable);
-    registry.register(DateTimePartsVTable::ID, DateTimePartsVTable);
-    registry.register(DecimalBytePartsVTable::ID, DecimalBytePartsVTable);
-    registry.register(DeltaVTable::ID, DeltaVTable);
-    registry.register(FoRVTable::ID, FoRVTable);
-    registry.register(FSSTVTable::ID, FSSTVTable);
-    registry.register(PcoVTable::ID, PcoVTable);
-    registry.register(RLEVTable::ID, RLEVTable);
-    registry.register(RunEndVTable::ID, RunEndVTable);
-    registry.register(SequenceVTable::ID, SequenceVTable);
-    registry.register(SparseVTable::ID, SparseVTable);
-    registry.register(ZigZagVTable::ID, ZigZagVTable);
+    allowed.insert(ALP.id());
+    allowed.insert(ALPRD.id());
+    allowed.insert(BitPacked.id());
+    allowed.insert(ByteBool.id());
+    allowed.insert(DateTimeParts.id());
+    allowed.insert(DecimalByteParts.id());
+    allowed.insert(Delta.id());
+    allowed.insert(FoR.id());
+    allowed.insert(FSST.id());
+    allowed.insert(Pco.id());
+    allowed.insert(RLE.id());
+    allowed.insert(RunEnd.id());
+    allowed.insert(Sequence.id());
+    allowed.insert(Sparse.id());
+    #[cfg(feature = "unstable_encodings")]
+    allowed.insert(TurboQuant.id());
+    allowed.insert(ZigZag.id());
 
     #[cfg(feature = "zstd")]
-    registry.register(ZstdVTable::ID, ZstdVTable);
+    allowed.insert(Zstd.id());
     #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-    registry.register(ZstdBuffersVTable::ID, ZstdBuffersVTable);
+    allowed.insert(ZstdBuffers.id());
 
-    registry
+    allowed
 });
 
-/// Build a new [writer strategy][LayoutStrategy] to compress and reorganize chunks of a Vortex file.
+/// How the compressor was configured on [`WriteStrategyBuilder`].
+#[derive(Clone)]
+enum CompressorConfig {
+    /// A [`BtrBlocksCompressorBuilder`] that [`WriteStrategyBuilder::build`] will finalize.
+    /// `IntDictScheme` is automatically excluded from the data compressor to prevent recursive
+    /// dictionary encoding.
+    BtrBlocks(BtrBlocksCompressorBuilder),
+    /// An opaque compressor used as-is for both data and stats compression.
+    Opaque(Arc<dyn CompressorPlugin>),
+}
+
+impl std::fmt::Debug for CompressorConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::BtrBlocks(_) => f.write_str("BtrBlocks"),
+            Self::Opaque(_) => f.write_str("Opaque"),
+        }
+    }
+}
+
+/// Build a new [writer strategy](LayoutStrategy) to compress and reorganize chunks of a Vortex
+/// file.
 ///
 /// Vortex provides an out-of-the-box file writer that optimizes the layout of chunks on-disk,
 /// repartitioning and compressing them to strike a balance between size on-disk,
 /// bulk decoding performance, and IOPS required to perform an indexed read.
 #[derive(Clone)]
 pub struct WriteStrategyBuilder {
-    compressor: Option<Arc<dyn CompressorPlugin>>,
+    compressor: CompressorConfig,
     row_block_size: usize,
     field_writers: HashMap<FieldPath, Arc<dyn LayoutStrategy>>,
-    allow_encodings: Option<ArrayRegistry>,
+    allow_encodings: Option<HashSet<ArrayId>>,
     flat_strategy: Option<Arc<dyn LayoutStrategy>>,
 }
 
@@ -150,25 +175,16 @@ impl Default for WriteStrategyBuilder {
     /// and then finally built yielding the [`LayoutStrategy`].
     fn default() -> Self {
         Self {
-            compressor: None,
+            compressor: CompressorConfig::BtrBlocks(BtrBlocksCompressorBuilder::default()),
             row_block_size: 8192,
             field_writers: HashMap::new(),
-            allow_encodings: None,
+            allow_encodings: Some(ALLOWED_ENCODINGS.clone()),
             flat_strategy: None,
         }
     }
 }
 
 impl WriteStrategyBuilder {
-    /// Override the [compressor][CompressorPlugin] used for compressing chunks in the file.
-    ///
-    /// If not provided, this will use a BtrBlocks-style cascading compressor that tries to balance
-    /// total size with decoding performance.
-    pub fn with_compressor<C: CompressorPlugin>(mut self, compressor: C) -> Self {
-        self.compressor = Some(Arc::new(compressor));
-        self
-    }
-
     /// Override the row block size used to determine the zone map sizes.
     pub fn with_row_block_size(mut self, row_block_size: usize) -> Self {
         self.row_block_size = row_block_size;
@@ -187,7 +203,7 @@ impl WriteStrategyBuilder {
     }
 
     /// Override the allowed array encodings for normalization.
-    pub fn with_allow_encodings(mut self, allow_encodings: ArrayRegistry) -> Self {
+    pub fn with_allow_encodings(mut self, allow_encodings: HashSet<ArrayId>) -> Self {
         self.allow_encodings = Some(allow_encodings);
         self
     }
@@ -201,46 +217,20 @@ impl WriteStrategyBuilder {
         self
     }
 
-    /// Configure a write strategy that emits only CUDA-compatible encodings.
+    /// Override the default [`BtrBlocksCompressorBuilder`] used for compression.
     ///
-    /// This configures BtrBlocks to exclude schemes without CUDA kernel support.
-    /// With the `unstable_encodings` feature, strings use buffer-level Zstd compression
-    /// (`ZstdBuffersArray`) which preserves the array buffer layout for zero-conversion
-    /// GPU decompression. Without it, strings use interleaved Zstd compression.
-    #[cfg(feature = "zstd")]
-    pub fn with_cuda_compatible_encodings(mut self) -> Self {
-        let mut builder = BtrBlocksCompressorBuilder::default()
-            .exclude_int([IntCode::Sparse, IntCode::Rle])
-            .exclude_float([FloatCode::AlpRd, FloatCode::Rle, FloatCode::Sparse])
-            .exclude_string([StringCode::Dict, StringCode::Fsst]);
-
-        #[cfg(feature = "unstable_encodings")]
-        {
-            builder = builder.include_string([StringCode::ZstdBuffers]);
-        }
-        #[cfg(not(feature = "unstable_encodings"))]
-        {
-            builder = builder.include_string([StringCode::Zstd]);
-        }
-
-        self.compressor = Some(Arc::new(builder.build()));
+    /// The builder is finalized during [`build`](Self::build), producing two compressors: one for
+    /// data (with `IntDictScheme` excluded) and one for stats.
+    pub fn with_btrblocks_builder(mut self, builder: BtrBlocksCompressorBuilder) -> Self {
+        self.compressor = CompressorConfig::BtrBlocks(builder);
         self
     }
 
-    /// Configure a write strategy that uses compact encodings (Pco for numerics, Zstd for
-    /// strings/binary).
+    /// Set the compressor to an opaque [`CompressorPlugin`].
     ///
-    /// This provides better compression ratios than the default BtrBlocks strategy,
-    /// especially for floating-point heavy datasets.
-    #[cfg(feature = "zstd")]
-    pub fn with_compact_encodings(mut self) -> Self {
-        let btrblocks = BtrBlocksCompressorBuilder::default()
-            .include_string([StringCode::Zstd])
-            .include_int([IntCode::Pco])
-            .include_float([FloatCode::Pco])
-            .build();
-
-        self.compressor = Some(Arc::new(btrblocks));
+    /// The compressor is used as-is for both data and stats compression.
+    pub fn with_compressor<C: CompressorPlugin>(mut self, compressor: C) -> Self {
+        self.compressor = CompressorConfig::Opaque(Arc::new(compressor));
         self
     }
 
@@ -256,15 +246,24 @@ impl WriteStrategyBuilder {
         };
 
         // 7. for each chunk create a flat layout
-        let chunked = ChunkedLayoutStrategy::new(flat.clone());
+        let chunked = ChunkedLayoutStrategy::new(Arc::clone(&flat));
         // 6. buffer chunks so they end up with closer segment ids physically
         let buffered = BufferedStrategy::new(chunked, 2 * ONE_MEG); // 2MB
-        // 5. compress each chunk
-        let compressing = if let Some(ref compressor) = self.compressor {
-            CompressingStrategy::new_opaque(buffered, compressor.clone())
-        } else {
-            CompressingStrategy::new_btrblocks(buffered, true)
+
+        // 5. compress each chunk.
+        // Exclude IntDictScheme from the data compressor because DictStrategy (step 3) already
+        // dictionary-encodes columns. Allowing IntDictScheme here would redundantly
+        // dictionary-encode the integer codes produced by that earlier step.
+        let data_compressor: Arc<dyn CompressorPlugin> = match &self.compressor {
+            CompressorConfig::BtrBlocks(builder) => Arc::new(
+                builder
+                    .clone()
+                    .exclude_schemes([IntDictScheme.id()])
+                    .build(),
+            ),
+            CompressorConfig::Opaque(compressor) => Arc::clone(compressor),
         };
+        let compressing = CompressingStrategy::new(buffered, data_compressor);
 
         // 4. prior to compression, coalesce up to a minimum size
         let coalescing = RepartitionStrategy::new(
@@ -284,11 +283,11 @@ impl WriteStrategyBuilder {
         );
 
         // 2.1. | 3.1. compress stats tables and dict values.
-        let compress_then_flat = if let Some(ref compressor) = self.compressor {
-            CompressingStrategy::new_opaque(flat, compressor.clone())
-        } else {
-            CompressingStrategy::new_btrblocks(flat, false)
+        let stats_compressor: Arc<dyn CompressorPlugin> = match self.compressor {
+            CompressorConfig::BtrBlocks(builder) => Arc::new(builder.build()),
+            CompressorConfig::Opaque(compressor) => compressor,
         };
+        let compress_then_flat = CompressingStrategy::new(flat, stats_compressor);
 
         // 3. apply dict encoding or fallback
         let dict = DictStrategy::new(
diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs
index c8dc836fc31..84840b2f5bf 100644
--- a/vortex-file/src/tests.rs
+++ b/vortex-file/src/tests.rs
@@ -10,7 +10,6 @@ use bytes::Bytes;
 use futures::StreamExt;
 use futures::TryStreamExt;
 use futures::pin_mut;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
@@ -18,13 +17,15 @@ use vortex_array::accessor::ArrayAccessor;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::DecimalArray;
-use vortex_array::arrays::DictVTable;
+use vortex_array::arrays::Dict;
 use vortex_array::arrays::ListArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
 use vortex_array::arrays::TemporalArray;
 use vortex_array::arrays::VarBinArray;
 use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::dict::DictArraySlotsExt;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::assert_arrays_eq;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::DecimalDType;
@@ -62,8 +63,9 @@ use vortex_buffer::ByteBufferMut;
 use vortex_buffer::buffer;
 use vortex_error::VortexResult;
 use vortex_io::session::RuntimeSession;
+use vortex_layout::Layout;
+use vortex_layout::scan::scan_builder::ScanBuilder;
 use vortex_layout::session::LayoutSession;
-use vortex_scan::ScanBuilder;
 use vortex_session::VortexSession;
 
 use crate::OpenOptionsSessionExt;
@@ -71,15 +73,16 @@ use crate::V1_FOOTER_FBS_SIZE;
 use crate::VERSION;
 use crate::VortexFile;
 use crate::WriteOptionsSessionExt;
+use crate::footer::SegmentSpec;
 
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-    let mut session = VortexSession::empty()
+    let session = VortexSession::empty()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ScalarFnSession>()
         .with::<RuntimeSession>();
 
-    crate::register_default_encodings(&mut session);
+    crate::register_default_encodings(&session);
 
     session
 });
@@ -111,7 +114,7 @@ async fn test_read_simple() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -187,11 +190,12 @@ async fn test_round_trip_many_types() {
         ("decimal_35", decimal_35),
     ])
     .unwrap();
+    let dtype = st.dtype().clone();
     let mut buf = ByteBufferMut::empty();
 
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -207,7 +211,7 @@ async fn test_round_trip_many_types() {
         .await
         .unwrap();
 
-    let read = ChunkedArray::try_new(chunks, st.dtype().clone()).unwrap();
+    let read = ChunkedArray::try_new(chunks, dtype).unwrap();
 
     assert_eq!(read.len(), 3);
 }
@@ -248,7 +252,7 @@ async fn test_read_simple_with_spawn() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -279,7 +283,7 @@ async fn test_read_projection() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -302,9 +306,9 @@ async fn test_read_projection() {
         )
     );
 
-    let actual = array.to_struct().unmasked_fields()[0].clone();
+    let actual = array.to_struct().unmasked_field(0).clone();
     let expected = VarBinArray::from(strings_expected.to_vec()).into_array();
-    assert_arrays_eq!(actual.as_ref(), expected.as_ref());
+    assert_arrays_eq!(actual, expected);
 
     let array = file
         .scan()
@@ -324,9 +328,9 @@ async fn test_read_projection() {
         )
     );
 
-    let actual = array.to_struct().unmasked_fields()[0].clone();
+    let actual = array.to_struct().unmasked_field(0).clone();
     let expected = Buffer::copy_from(numbers_expected).into_array();
-    assert_arrays_eq!(actual.as_ref(), expected.as_ref());
+    assert_arrays_eq!(actual, expected);
 }
 
 #[tokio::test]
@@ -348,7 +352,7 @@ async fn unequal_batches() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -408,7 +412,7 @@ async fn write_chunked() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, chunked_st.to_array_stream())
+        .write(&mut buf, chunked_st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -435,11 +439,12 @@ async fn test_empty_varbin_array_roundtrip() {
     let empty = VarBinArray::from(Vec::<&str>::new()).into_array();
 
     let st = StructArray::from_fields(&[("a", empty)]).unwrap();
+    let dtype = st.dtype().clone();
 
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -455,7 +460,7 @@ async fn test_empty_varbin_array_roundtrip() {
         .unwrap();
 
     assert_eq!(result.len(), 0);
-    assert_eq!(result.dtype(), st.dtype());
+    assert_eq!(result.dtype(), &dtype);
 }
 
 #[tokio::test]
@@ -518,7 +523,7 @@ async fn filter_string() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -536,15 +541,15 @@ async fn filter_string() {
         .unwrap();
 
     assert_eq!(result.len(), 1);
-    let names_actual = result[0].to_struct().unmasked_fields()[0].clone();
+    let names_actual = result[0].to_struct().unmasked_field(0).clone();
     let names_expected =
         VarBinArray::from_iter(vec![Some("Joseph")], DType::Utf8(Nullability::Nullable))
             .into_array();
-    assert_arrays_eq!(names_actual.as_ref(), names_expected.as_ref());
+    assert_arrays_eq!(names_actual, names_expected);
 
-    let ages_actual = result[0].to_struct().unmasked_fields()[1].clone();
+    let ages_actual = result[0].to_struct().unmasked_field(1).clone();
     let ages_expected = PrimitiveArray::from_option_iter([Some(25i32)]).into_array();
-    assert_arrays_eq!(ages_actual.as_ref(), ages_expected.as_ref());
+    assert_arrays_eq!(ages_actual, ages_expected);
 }
 
 #[tokio::test]
@@ -567,7 +572,7 @@ async fn filter_or() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -591,17 +596,17 @@ async fn filter_or() {
         .unwrap();
 
     assert_eq!(result.len(), 1);
-    let names_actual = result[0].to_struct().unmasked_fields()[0].clone();
+    let names_actual = result[0].to_struct().unmasked_field(0).clone();
     let names_expected = VarBinArray::from_iter(
         vec![Some("Joseph"), Some("Angela")],
         DType::Utf8(Nullability::Nullable),
     )
     .into_array();
-    assert_arrays_eq!(names_actual.as_ref(), names_expected.as_ref());
+    assert_arrays_eq!(names_actual, names_expected);
 
-    let ages_actual = result[0].to_struct().unmasked_fields()[1].clone();
+    let ages_actual = result[0].to_struct().unmasked_field(1).clone();
     let ages_expected = PrimitiveArray::from_option_iter([Some(25i32), None]).into_array();
-    assert_arrays_eq!(ages_actual.as_ref(), ages_expected.as_ref());
+    assert_arrays_eq!(ages_actual, ages_expected);
 }
 
 #[tokio::test]
@@ -624,7 +629,7 @@ async fn filter_and() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -645,17 +650,17 @@ async fn filter_and() {
         .unwrap();
 
     assert_eq!(result.len(), 1);
-    let names_actual = result[0].to_struct().unmasked_fields()[0].clone();
+    let names_actual = result[0].to_struct().unmasked_field(0).clone();
     let names_expected = VarBinArray::from_iter(
         vec![Some("Joseph"), None],
         DType::Utf8(Nullability::Nullable),
     )
     .into_array();
-    assert_arrays_eq!(names_actual.as_ref(), names_expected.as_ref());
+    assert_arrays_eq!(names_actual, names_expected);
 
-    let ages_actual = result[0].to_struct().unmasked_fields()[1].clone();
+    let ages_actual = result[0].to_struct().unmasked_field(1).clone();
     let ages_expected = PrimitiveArray::from_option_iter([Some(25i32), Some(31i32)]).into_array();
-    assert_arrays_eq!(ages_actual.as_ref(), ages_expected.as_ref());
+    assert_arrays_eq!(ages_actual, ages_expected);
 }
 
 #[tokio::test]
@@ -678,7 +683,7 @@ async fn test_with_indices_simple() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, expected_array.to_array_stream())
+        .write(&mut buf, expected_array.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -711,14 +716,14 @@ async fn test_with_indices_simple() {
         .await
         .unwrap()
         .to_struct();
-    let actual_kept_numbers_array = actual_kept_array.unmasked_fields()[0].to_primitive();
+    let actual_kept_numbers_array = actual_kept_array.unmasked_field(0).to_primitive();
 
     let expected_kept_numbers: Vec<i16> = kept_indices
         .iter()
         .map(|&x| expected_numbers[x as usize])
         .collect();
     let expected_array = Buffer::copy_from(&expected_kept_numbers).into_array();
-    assert_arrays_eq!(actual_kept_numbers_array.as_ref(), expected_array.as_ref());
+    assert_arrays_eq!(actual_kept_numbers_array, expected_array);
 
     // test all indices
     let actual_array = file
@@ -731,9 +736,9 @@ async fn test_with_indices_simple() {
         .await
         .unwrap()
         .to_struct();
-    let actual_numbers_array = actual_array.unmasked_fields()[0].clone();
+    let actual_numbers_array = actual_array.unmasked_field(0).clone();
     let expected_array = Buffer::copy_from(&expected_numbers).into_array();
-    assert_arrays_eq!(actual_numbers_array.as_ref(), expected_array.as_ref());
+    assert_arrays_eq!(actual_numbers_array, expected_array);
 }
 
 #[tokio::test]
@@ -757,7 +762,7 @@ async fn test_with_indices_on_two_columns() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -773,24 +778,23 @@ async fn test_with_indices_on_two_columns() {
         .read_all()
         .await
         .unwrap()
-        .to_struct()
         .to_struct();
 
-    let strings_actual = array.unmasked_fields()[0].clone();
+    let strings_actual = array.unmasked_field(0).clone();
     let strings_expected_vec: Vec<&str> = kept_indices
         .iter()
         .map(|&x| strings_expected[x as usize])
         .collect();
     let strings_expected_array = VarBinArray::from(strings_expected_vec).into_array();
-    assert_arrays_eq!(strings_actual.as_ref(), strings_expected_array.as_ref());
+    assert_arrays_eq!(strings_actual, strings_expected_array);
 
-    let numbers_actual = array.unmasked_fields()[1].clone();
+    let numbers_actual = array.unmasked_field(1).clone();
     let numbers_expected_vec: Vec<u32> = kept_indices
         .iter()
         .map(|&x| numbers_expected[x as usize])
         .collect();
     let numbers_expected_array = Buffer::copy_from(&numbers_expected_vec).into_array();
-    assert_arrays_eq!(numbers_actual.as_ref(), numbers_expected_array.as_ref());
+    assert_arrays_eq!(numbers_actual, numbers_expected_array);
 }
 
 #[tokio::test]
@@ -813,7 +817,7 @@ async fn test_with_indices_and_with_row_filter_simple() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, expected_array.to_array_stream())
+        .write(&mut buf, expected_array.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -848,7 +852,7 @@ async fn test_with_indices_and_with_row_filter_simple() {
         .unwrap()
         .to_struct();
 
-    let actual_kept_numbers_array = actual_kept_array.unmasked_fields()[0].to_primitive();
+    let actual_kept_numbers_array = actual_kept_array.unmasked_field(0).to_primitive();
 
     let expected_kept_numbers: Buffer<i16> = kept_indices
         .iter()
@@ -856,7 +860,7 @@ async fn test_with_indices_and_with_row_filter_simple() {
         .filter(|&x| x > 50)
         .collect();
     let expected_array = expected_kept_numbers.into_array();
-    assert_arrays_eq!(actual_kept_numbers_array.as_ref(), expected_array.as_ref());
+    assert_arrays_eq!(actual_kept_numbers_array, expected_array);
 
     // test all indices
     let actual_array = file
@@ -871,17 +875,14 @@ async fn test_with_indices_and_with_row_filter_simple() {
         .unwrap()
         .to_struct();
 
-    let actual_numbers_array = actual_array.unmasked_fields()[0].clone();
+    let actual_numbers_array = actual_array.unmasked_field(0).clone();
     let expected_filtered: Buffer<i16> = expected_numbers
         .iter()
         .filter(|&&x| x > 50)
         .cloned()
         .collect();
     let expected_numbers_array = expected_filtered.into_array();
-    assert_arrays_eq!(
-        actual_numbers_array.as_ref(),
-        expected_numbers_array.as_ref()
-    );
+    assert_arrays_eq!(actual_numbers_array, expected_numbers_array);
 }
 
 #[tokio::test]
@@ -934,15 +935,15 @@ async fn filter_string_chunked() {
         .to_struct();
 
     assert_eq!(actual_array.len(), 1);
-    let names_actual = actual_array.unmasked_fields()[0].clone();
+    let names_actual = actual_array.unmasked_field(0).clone();
     let names_expected =
         VarBinArray::from_iter(vec![Some("Joseph")], DType::Utf8(Nullability::Nullable))
             .into_array();
-    assert_arrays_eq!(names_actual.as_ref(), names_expected.as_ref());
+    assert_arrays_eq!(names_actual, names_expected);
 
-    let ages_actual = actual_array.unmasked_fields()[1].clone();
+    let ages_actual = actual_array.unmasked_field(1).clone();
     let ages_expected = PrimitiveArray::from_option_iter([Some(25i32)]).into_array();
-    assert_arrays_eq!(ages_actual.as_ref(), ages_expected.as_ref());
+    assert_arrays_eq!(ages_actual, ages_expected);
 }
 
 #[tokio::test]
@@ -1025,7 +1026,7 @@ async fn test_pruning_with_or() {
         .to_struct();
 
     assert_eq!(actual_array.len(), 10);
-    let letters_actual = actual_array.unmasked_fields()[0].clone();
+    let letters_actual = actual_array.unmasked_field(0).clone();
     let letters_expected = VarBinViewArray::from_iter_nullable_str([
         Some("A".to_owned()),
         Some("B".to_owned()),
@@ -1039,9 +1040,9 @@ async fn test_pruning_with_or() {
         Some("P".to_owned()),
     ])
     .into_array();
-    assert_arrays_eq!(letters_actual.as_ref(), letters_expected.as_ref());
+    assert_arrays_eq!(letters_actual, letters_expected);
 
-    let numbers_actual = actual_array.unmasked_fields()[1].clone();
+    let numbers_actual = actual_array.unmasked_field(1).clone();
     let numbers_expected = PrimitiveArray::from_option_iter([
         Some(25_i32),
         Some(31),
@@ -1055,7 +1056,7 @@ async fn test_pruning_with_or() {
         Some(22),
     ])
     .into_array();
-    assert_arrays_eq!(numbers_actual.as_ref(), numbers_expected.as_ref());
+    assert_arrays_eq!(numbers_actual, numbers_expected);
 }
 
 #[tokio::test]
@@ -1077,7 +1078,7 @@ async fn test_repeated_projection() {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, single_column_array.to_array_stream())
+        .write(&mut buf, single_column_array.into_array().to_array_stream())
         .await
         .unwrap();
 
@@ -1120,7 +1121,7 @@ async fn basic_file_roundtrip() -> VortexResult<()> {
     let result = vxf.scan()?.into_array_stream()?.read_all().await?;
 
     let expected = buffer![0i32, 1, 2, 3, 4, 5, 6, 7, 8].into_array();
-    assert_arrays_eq!(result.as_ref(), expected.as_ref());
+    assert_arrays_eq!(result, expected);
 
     Ok(())
 }
@@ -1168,7 +1169,7 @@ async fn file_take() -> VortexResult<()> {
         .await?;
 
     let expected = buffer![0i32, 1, 8].into_array();
-    assert_arrays_eq!(result.as_ref(), expected.as_ref());
+    assert_arrays_eq!(result, expected);
 
     Ok(())
 }
@@ -1198,7 +1199,7 @@ async fn write_nullable_top_level_struct() {
 }
 
 async fn round_trip(
-    array: &dyn Array,
+    array: &ArrayRef,
     f: impl Fn(ScanBuilder<ArrayRef>) -> VortexResult<ScanBuilder<ArrayRef>>,
 ) -> VortexResult<ArrayRef> {
     let mut writer = vec![];
@@ -1229,7 +1230,7 @@ async fn write_nullable_nested_struct() -> VortexResult<()> {
         Nullability::Nullable,
     );
 
-    let struct_ = ConstantArray::new(Scalar::null(nested_dtype.clone()), 3).to_array();
+    let struct_ = ConstantArray::new(Scalar::null(nested_dtype.clone()), 3).into_array();
 
     let array = StructArray::try_new(
         ["struct"].into(),
@@ -1242,7 +1243,7 @@ async fn write_nullable_nested_struct() -> VortexResult<()> {
     let result = round_trip(&array, Ok).await?.to_struct();
 
     assert_eq!(result.len(), 3);
-    assert_eq!(result.unmasked_fields().len(), 1);
+    assert_eq!(result.struct_fields().nfields(), 1);
     assert!(result.all_valid()?);
 
     let nested_struct = result.unmasked_field_by_name("struct")?.to_struct();
@@ -1257,7 +1258,7 @@ async fn write_nullable_nested_struct() -> VortexResult<()> {
 async fn scan_empty_fields() -> VortexResult<()> {
     let array = (0..10000).collect::<PrimitiveArray>();
 
-    let result = round_trip(array.as_ref(), |scan| {
+    let result = round_trip(&array.clone().into_array(), |scan| {
         Ok(scan.with_projection(Pack.new_expr(
             PackOptions {
                 names: Default::default(),
@@ -1291,7 +1292,7 @@ async fn test_into_tokio_array_stream() -> VortexResult<()> {
     let mut buf = ByteBufferMut::empty();
     SESSION
         .write_options()
-        .write(&mut buf, st.to_array_stream())
+        .write(&mut buf, st.into_array().to_array_stream())
         .await?;
 
     let file = SESSION.open_options().open_buffer(buf)?;
@@ -1320,10 +1321,10 @@ async fn test_array_stream_no_double_dict_encode() -> VortexResult<()> {
     let read_array = file.scan()?.into_array_stream()?.read_all().await?;
 
     let dict = read_array
-        .as_opt::<DictVTable>()
+        .as_opt::<Dict>()
         .expect("expected root to be dictionary");
     assert!(
-        !dict.codes().is::<DictVTable>(),
+        !dict.codes().is::<Dict>(),
         "dictionary codes should not be dictionary encoded"
     );
     Ok(())
@@ -1383,7 +1384,7 @@ async fn test_writer_multiple_pushes() -> VortexResult<()> {
         .unmasked_field_by_name("numbers")?
         .clone();
     let expected = buffer![1u32, 2, 3, 4, 5, 6, 7, 8, 9].into_array();
-    assert_arrays_eq!(numbers.as_ref(), expected.as_ref());
+    assert_arrays_eq!(numbers, expected);
 
     Ok(())
 }
@@ -1417,7 +1418,7 @@ async fn test_writer_push_stream() -> VortexResult<()> {
         .unmasked_field_by_name("numbers")?
         .clone();
     let expected = buffer![1u32, 2, 3, 4, 5, 6].into_array();
-    assert_arrays_eq!(numbers.as_ref(), expected.as_ref());
+    assert_arrays_eq!(numbers, expected);
 
     Ok(())
 }
@@ -1481,7 +1482,7 @@ async fn test_writer_empty_chunks() -> VortexResult<()> {
         .unmasked_field_by_name("numbers")?
         .clone();
     let expected = buffer![1u32, 2].into_array();
-    assert_arrays_eq!(numbers.as_ref(), expected.as_ref());
+    assert_arrays_eq!(numbers, expected);
 
     Ok(())
 }
@@ -1519,7 +1520,7 @@ async fn test_writer_mixed_push_and_stream() -> VortexResult<()> {
         .unmasked_field_by_name("numbers")?
         .clone();
     let expected = buffer![1u32, 2, 3, 4, 5, 6].into_array();
-    assert_arrays_eq!(numbers.as_ref(), expected.as_ref());
+    assert_arrays_eq!(numbers, expected);
 
     Ok(())
 }
@@ -1597,7 +1598,7 @@ async fn test_writer_with_statistics() -> VortexResult<()> {
 }
 
 #[tokio::test]
-async fn main_test() -> Result<(), Box<dyn std::error::Error>> {
+async fn timestamp_unit_mismatch() -> Result<(), Box<dyn std::error::Error>> {
     // Write file with MILLISECONDS timestamps
     let ts_array = PrimitiveArray::from_iter(vec![1704067200000i64, 1704153600000, 1704240000000])
         .into_array();
@@ -1621,6 +1622,62 @@ async fn main_test() -> Result<(), Box<dyn std::error::Error>> {
         )),
     );
 
+    let mut stream = SESSION
+        .open_options()
+        .open_buffer(buf)?
+        .scan()?
+        .with_filter(filter_expr)
+        .into_array_stream()?;
+
+    let result = stream.try_next().await;
+
+    assert!(result.is_err());
+
+    Ok(())
+}
+
+/// Regression test: filtering a milliseconds timestamp column with a seconds scalar should
+/// always error, regardless of how the internal children of `DateTimePartsArray` are encoded.
+///
+/// This test forces `ConstantArray` encoding for the seconds/subseconds children by using a
+/// compressor with Dict excluded (which triggers distinct-value computation, letting
+/// `ConstantScheme` win for `[0, 0, 0]`). The scanner should still detect the time unit
+/// mismatch and error, not silently return wrong results.
+#[tokio::test]
+async fn timestamp_unit_mismatch_errors_with_constant_children()
+-> Result<(), Box<dyn std::error::Error>> {
+    // Build a compressor where ConstantScheme wins for [0, 0, 0] by including Dict
+    // (which enables distinct-value computation).
+    let compressor = vortex_btrblocks::BtrBlocksCompressor::default();
+
+    // Write file with MILLISECONDS timestamps using this compressor.
+    let ts_array = PrimitiveArray::from_iter(vec![1704067200000i64, 1704153600000, 1704240000000])
+        .into_array();
+    let temporal = TemporalArray::new_timestamp(ts_array, TimeUnit::Milliseconds, None);
+
+    let strategy = crate::strategy::WriteStrategyBuilder::default()
+        .with_compressor(compressor)
+        .build();
+
+    let mut buf = ByteBufferMut::empty();
+    SESSION
+        .write_options()
+        .with_strategy(strategy)
+        .write(&mut buf, temporal.into_array().to_array_stream())
+        .await?;
+
+    // Read with SECONDS filter scalar — should error due to time unit mismatch.
+    let filter_expr = gt(
+        root(),
+        lit(Scalar::extension::<Timestamp>(
+            TimestampOptions {
+                unit: TimeUnit::Seconds,
+                tz: None,
+            },
+            Scalar::from(1704153600i64),
+        )),
+    );
+
     let stream = SESSION
         .open_options()
         .open_buffer(buf)?
@@ -1630,7 +1687,186 @@ async fn main_test() -> Result<(), Box<dyn std::error::Error>> {
 
     let results = stream.try_collect::<Vec<_>>().await;
 
-    assert!(results.is_err());
+    assert!(
+        results.is_err(),
+        "Expected error from timestamp unit mismatch (ms vs s), but got {} results. \
+         This indicates the scanner silently applied the filter incorrectly when \
+         DateTimePartsArray children use ConstantArray encoding.",
+        results.unwrap().len()
+    );
+
+    Ok(())
+}
+
+/// Collect all segment byte offsets reachable from a layout node.
+fn collect_segment_offsets(layout: &dyn Layout, segment_specs: &[SegmentSpec]) -> Vec<u64> {
+    let mut result = Vec::new();
+    collect_segment_offsets_inner(layout, segment_specs, &mut result);
+    result
+}
+
+fn collect_segment_offsets_inner(
+    layout: &dyn Layout,
+    segment_specs: &[SegmentSpec],
+    result: &mut Vec<u64>,
+) {
+    for seg_id in layout.segment_ids() {
+        result.push(segment_specs[*seg_id as usize].offset);
+    }
+    for child in layout.children().unwrap() {
+        collect_segment_offsets_inner(child.as_ref(), segment_specs, result);
+    }
+}
+
+/// Assert that all offsets in `before` are less than all offsets in `after`.
+fn assert_offsets_ordered(before: &[u64], after: &[u64], context: &str) {
+    if let (Some(&max_before), Some(&min_after)) = (before.iter().max(), after.iter().min()) {
+        assert!(
+            max_before < min_after,
+            "{context}: expected all 'before' offsets < all 'after' offsets, \
+             but max before = {max_before} >= min after = {min_after}"
+        );
+    }
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn test_segment_ordering_dict_codes_before_values() -> VortexResult<()> {
+    // Create low-cardinality strings to trigger dict encoding, plus an integer column.
+    let n = 100_000;
+    let values: Vec<&str> = (0..n).map(|i| ["alpha", "beta", "gamma"][i % 3]).collect();
+    let strings = VarBinArray::from(values).into_array();
+    let numbers = PrimitiveArray::from_iter(0..n as i32).into_array();
+
+    let st = StructArray::from_fields(&[("strings", strings), ("numbers", numbers)]).unwrap();
+
+    let mut buf = ByteBufferMut::empty();
+    let summary = SESSION
+        .write_options()
+        .write(&mut buf, st.into_array().to_array_stream())
+        .await?;
+
+    let footer = summary.footer();
+    let segment_specs = footer.segment_map();
+    let root = footer.layout();
+
+    // Walk the layout tree and find all dict layouts.
+    // Verify codes segments come before values segments in byte order within each run.
+    fn check_dict_ordering(layout: &dyn Layout, segment_specs: &[SegmentSpec]) {
+        if layout.encoding_id().as_ref() == "vortex.dict" {
+            // child 0 = values, child 1 = codes
+            let values_offsets =
+                collect_segment_offsets(layout.child(0).unwrap().as_ref(), segment_specs);
+            let codes_offsets =
+                collect_segment_offsets(layout.child(1).unwrap().as_ref(), segment_specs);
+
+            assert_offsets_ordered(
+                &codes_offsets,
+                &values_offsets,
+                "dict: codes should come before values",
+            );
+        }
+
+        for child in layout.children().unwrap() {
+            check_dict_ordering(child.as_ref(), segment_specs);
+        }
+    }
+
+    check_dict_ordering(root.as_ref(), segment_specs);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn test_segment_ordering_zonemaps_after_data() -> VortexResult<()> {
+    // Create a multi-column struct with enough rows to produce zone maps.
+    let n = 100_000;
+    let values: Vec<&str> = (0..n).map(|i| ["alpha", "beta", "gamma"][i % 3]).collect();
+    let strings = VarBinArray::from(values).into_array();
+    let numbers = PrimitiveArray::from_iter(0..n as i32).into_array();
+    let floats = PrimitiveArray::from_iter((0..n).map(|i| i as f64 * 0.1)).into_array();
+
+    let st = StructArray::from_fields(&[
+        ("strings", strings),
+        ("numbers", numbers),
+        ("floats", floats),
+    ])
+    .unwrap();
+
+    let mut buf = ByteBufferMut::empty();
+    let summary = SESSION
+        .write_options()
+        .write(&mut buf, st.into_array().to_array_stream())
+        .await?;
+
+    let footer = summary.footer();
+    let segment_specs = footer.segment_map();
+    let root = footer.layout();
+
+    // Find all zoned layouts and verify data segments come before zone map segments.
+    fn check_zoned_ordering(layout: &dyn Layout, segment_specs: &[SegmentSpec]) {
+        if layout.encoding_id().as_ref() == "vortex.stats" {
+            // child 0 = data, child 1 = zones
+            let data_offsets =
+                collect_segment_offsets(layout.child(0).unwrap().as_ref(), segment_specs);
+            let zones_offsets =
+                collect_segment_offsets(layout.child(1).unwrap().as_ref(), segment_specs);
+
+            assert_offsets_ordered(
+                &data_offsets,
+                &zones_offsets,
+                "zoned: data should come before zones",
+            );
+        }
+
+        for child in layout.children().unwrap() {
+            check_zoned_ordering(child.as_ref(), segment_specs);
+        }
+    }
+
+    check_zoned_ordering(root.as_ref(), segment_specs);
+
+    // Additionally: all zone map segments across all columns should appear after
+    // all data segments across all columns.
+    let mut all_data_offsets = Vec::new();
+    let mut all_zones_offsets = Vec::new();
+
+    fn collect_all_zoned(
+        layout: &dyn Layout,
+        segment_specs: &[SegmentSpec],
+        all_data: &mut Vec<u64>,
+        all_zones: &mut Vec<u64>,
+    ) {
+        if layout.encoding_id().as_ref() == "vortex.stats" {
+            // child 0 = data, child 1 = zones
+            all_data.extend(collect_segment_offsets(
+                layout.child(0).unwrap().as_ref(),
+                segment_specs,
+            ));
+            all_zones.extend(collect_segment_offsets(
+                layout.child(1).unwrap().as_ref(),
+                segment_specs,
+            ));
+            return;
+        }
+        for child in layout.children().unwrap() {
+            collect_all_zoned(child.as_ref(), segment_specs, all_data, all_zones);
+        }
+    }
+
+    collect_all_zoned(
+        root.as_ref(),
+        segment_specs,
+        &mut all_data_offsets,
+        &mut all_zones_offsets,
+    );
+
+    assert_offsets_ordered(
+        &all_data_offsets,
+        &all_zones_offsets,
+        "global: all data segments should come before all zone map segments",
+    );
 
     Ok(())
 }
diff --git a/vortex-file/src/v2/file_stats_reader.rs b/vortex-file/src/v2/file_stats_reader.rs
index f8de172fea9..fb31b28d61f 100644
--- a/vortex-file/src/v2/file_stats_reader.rs
+++ b/vortex-file/src/v2/file_stats_reader.rs
@@ -101,6 +101,7 @@ impl FileStatsLayoutReader {
         let result = pruning
             .execute::<Canonical>(&mut ctx)?
             .into_bool()
+            .into_array()
             .scalar_at(0)?;
 
         Ok(result.as_bool().value() == Some(true))
@@ -218,6 +219,7 @@ mod tests {
     use vortex_error::VortexResult;
     use vortex_io::runtime::single::block_on;
     use vortex_io::session::RuntimeSession;
+    use vortex_io::session::RuntimeSessionExt;
     use vortex_layout::LayoutReader;
     use vortex_layout::LayoutStrategy;
     use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
@@ -252,6 +254,7 @@ mod tests {
     #[test]
     fn pruning_when_filter_out_of_range() -> VortexResult<()> {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -265,10 +268,10 @@ mod tests {
             let layout = strategy
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     struct_array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await?;
 
@@ -290,6 +293,7 @@ mod tests {
     #[test]
     fn no_pruning_when_filter_in_range() -> VortexResult<()> {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -303,10 +307,10 @@ mod tests {
             let layout = strategy
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     struct_array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await?;
 
diff --git a/vortex-file/src/writer.rs b/vortex-file/src/writer.rs
index 4715393656e..63f30cd102e 100644
--- a/vortex-file/src/writer.rs
+++ b/vortex-file/src/writer.rs
@@ -45,6 +45,7 @@ use vortex_layout::sequence::SequentialStreamAdapter;
 use vortex_layout::sequence::SequentialStreamExt;
 use vortex_session::SessionExt;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::Footer;
 use crate::MAGIC_BYTES;
@@ -188,10 +189,18 @@ impl VortexWriteOptions {
         // We spawn the layout future so it is driven in the background while we write the
         // buffer stream, so we don't need to poll it until all buffers have been drained.
         let ctx2 = ctx.clone();
-        let layout_fut = self.session.handle().spawn_nested(|h| async move {
+        let session = self.session.clone();
+        let layout_fut = self.session.handle().spawn_nested(move |h| async move {
+            let session = session.with_handle(h);
             let layout = self
                 .strategy
-                .write_stream(ctx2, segments.clone(), stream, eof, h)
+                .write_stream(
+                    ctx2,
+                    Arc::<BufferedSegmentSink>::clone(&segments),
+                    stream,
+                    eof,
+                    &session,
+                )
                 .await?;
             Ok::<_, VortexError>((layout, segments.segment_specs()))
         });
@@ -211,7 +220,7 @@ impl VortexWriteOptions {
 
         // Assemble the Footer object now that we have all the segments.
         let mut footer = Footer::new(
-            layout.clone(),
+            Arc::clone(&layout),
             segment_specs,
             if self.file_statistics.is_empty() {
                 None
@@ -221,7 +230,7 @@ impl VortexWriteOptions {
                     &dtype,
                 ))
             },
-            ctx,
+            ReadContext::new(ctx.to_ids()),
         );
 
         // Emit the footer buffers and EOF.
@@ -259,7 +268,7 @@ impl VortexWriteOptions {
 
         let write = CountingVortexWrite::new(write);
         let bytes_written = write.counter();
-        let strategy = self.strategy.clone();
+        let strategy = Arc::clone(&self.strategy);
         let future = self.write(write, arrays).boxed_local().fuse();
 
         Writer {
diff --git a/vortex-file/tests/test_write_table.rs b/vortex-file/tests/test_write_table.rs
index 59687d337fb..d0522c5a78c 100644
--- a/vortex-file/tests/test_write_table.rs
+++ b/vortex-file/tests/test_write_table.rs
@@ -10,13 +10,18 @@ use futures::StreamExt;
 use futures::pin_mut;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::DictArray;
+use vortex_array::arrays::ListViewArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::StructArray;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::FieldNames;
 use vortex_array::field_path;
 use vortex_array::scalar_fn::session::ScalarFnSession;
 use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
+use vortex_btrblocks::BtrBlocksCompressor;
 use vortex_buffer::ByteBuffer;
 use vortex_file::OpenOptionsSessionExt;
 use vortex_file::WriteOptionsSessionExt;
@@ -28,13 +33,13 @@ use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
 
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-    let mut session = VortexSession::empty()
+    let session = VortexSession::empty()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ScalarFnSession>()
         .with::<RuntimeSession>();
 
-    vortex_file::register_default_encodings(&mut session);
+    vortex_file::register_default_encodings(&session);
 
     session
 });
@@ -64,9 +69,9 @@ async fn test_file_roundtrip() {
 
     // Create a writer which by default uses the BtrBlocks compressor for a.compressed, but leaves
     // the b and the a.raw columns uncompressed.
-    let default_strategy = Arc::new(CompressingStrategy::new_btrblocks(
+    let default_strategy = Arc::new(CompressingStrategy::new(
         FlatLayoutStrategy::default(),
-        false,
+        BtrBlocksCompressor::default(),
     ));
 
     let writer = Arc::new(
@@ -111,3 +116,52 @@ async fn test_file_roundtrip() {
         assert!(raw.nbytes() > compressed.nbytes());
     }
 }
+
+/// Regression test: writing a Dict<ListView> where the list has
+/// Validity::Array(BoolArray) and the dict codes are nullable used to fail
+/// with "Array vortex.fill_null does not support serialization".
+#[tokio::test]
+async fn test_dict_listview_validity_roundtrip() {
+    let elements = PrimitiveArray::from_iter(vec![1i32, 2, 3, 4, 5]).into_array();
+    let offsets = PrimitiveArray::from_iter(vec![0u32, 2, 4]).into_array();
+    let sizes = PrimitiveArray::from_iter(vec![2u32, 2, 1]).into_array();
+    let list_validity = Validity::Array(BoolArray::from_iter([true, false, true]).into_array());
+    let listview = ListViewArray::new(elements, offsets, sizes, list_validity).into_array();
+
+    let codes = PrimitiveArray::new(
+        vortex_buffer::buffer![0u32, 0, 1, 0, 2],
+        Validity::from_iter(vec![true, false, true, true, true]),
+    )
+    .into_array();
+
+    let dict = DictArray::new(codes, listview).into_array();
+
+    let data = StructArray::from_fields(&[("col", dict)])
+        .expect("from_fields")
+        .into_array();
+
+    let mut bytes = Vec::new();
+    SESSION
+        .write_options()
+        .write(&mut bytes, data.to_array_stream())
+        .await
+        .expect("write should not fail with fill_null serialization error");
+
+    let bytes = ByteBuffer::from(bytes);
+    let vxf = SESSION.open_options().open_buffer(bytes).expect("open");
+
+    let stream = vxf
+        .scan()
+        .expect("scan")
+        .into_stream()
+        .expect("into_stream");
+    pin_mut!(stream);
+
+    let chunk = stream
+        .next()
+        .await
+        .unwrap()
+        .expect("read back should succeed");
+    vortex_array::assert_arrays_eq!(data, chunk);
+    assert!(stream.next().await.is_none(), "expected a single chunk");
+}
diff --git a/vortex-flatbuffers/flatbuffers/vortex-dtype/dtype.fbs b/vortex-flatbuffers/flatbuffers/vortex-dtype/dtype.fbs
index ae3b813c80e..b50e2362b65 100644
--- a/vortex-flatbuffers/flatbuffers/vortex-dtype/dtype.fbs
+++ b/vortex-flatbuffers/flatbuffers/vortex-dtype/dtype.fbs
@@ -63,6 +63,10 @@ table Extension {
     metadata: [ubyte];
 }
 
+table Variant {
+    nullable: bool;
+}
+
 union Type {
     Null = 1,
     Bool = 2,
@@ -74,6 +78,7 @@ union Type {
     List = 8,
     Extension = 9,
     FixedSizeList = 10, // This is after `Extension` for backwards compatibility.
+    Variant = 11,
 }
 
 table DType {
diff --git a/vortex-flatbuffers/public-api.lock b/vortex-flatbuffers/public-api.lock
index 8f1a4291000..18d0dae07cf 100644
--- a/vortex-flatbuffers/public-api.lock
+++ b/vortex-flatbuffers/public-api.lock
@@ -574,6 +574,8 @@ pub enum vortex_flatbuffers::dtype::Struct_Offset
 
 pub enum vortex_flatbuffers::dtype::Utf8Offset
 
+pub enum vortex_flatbuffers::dtype::VariantOffset
+
 pub struct vortex_flatbuffers::dtype::Binary<'a>
 
 pub vortex_flatbuffers::dtype::Binary::_tab: flatbuffers::table::Table<'a>
@@ -726,6 +728,8 @@ pub fn vortex_flatbuffers::dtype::DType<'a>::type__as_struct_(&self) -> core::op
 
 pub fn vortex_flatbuffers::dtype::DType<'a>::type__as_utf_8(&self) -> core::option::Option<vortex_flatbuffers::dtype::Utf8<'a>>
 
+pub fn vortex_flatbuffers::dtype::DType<'a>::type__as_variant(&self) -> core::option::Option<vortex_flatbuffers::dtype::Variant<'a>>
+
 pub fn vortex_flatbuffers::dtype::DType<'a>::type_type(&self) -> vortex_flatbuffers::dtype::Type
 
 impl core::fmt::Debug for vortex_flatbuffers::dtype::DType<'_>
@@ -1380,6 +1384,8 @@ pub const vortex_flatbuffers::dtype::Type::Struct_: Self
 
 pub const vortex_flatbuffers::dtype::Type::Utf8: Self
 
+pub const vortex_flatbuffers::dtype::Type::Variant: Self
+
 pub fn vortex_flatbuffers::dtype::Type::variant_name(self) -> core::option::Option<&'static str>
 
 impl core::clone::Clone for vortex_flatbuffers::dtype::Type
@@ -1502,6 +1508,64 @@ pub fn vortex_flatbuffers::dtype::Utf8Builder<'a, 'b, A>::finish(self) -> flatbu
 
 pub fn vortex_flatbuffers::dtype::Utf8Builder<'a, 'b, A>::new(_fbb: &'b mut flatbuffers::builder::FlatBufferBuilder<'a, A>) -> vortex_flatbuffers::dtype::Utf8Builder<'a, 'b, A>
 
+pub struct vortex_flatbuffers::dtype::Variant<'a>
+
+pub vortex_flatbuffers::dtype::Variant::_tab: flatbuffers::table::Table<'a>
+
+impl<'a> vortex_flatbuffers::dtype::Variant<'a>
+
+pub const vortex_flatbuffers::dtype::Variant<'a>::VT_NULLABLE: flatbuffers::primitives::VOffsetT
+
+pub fn vortex_flatbuffers::dtype::Variant<'a>::create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::builder::Allocator + 'bldr>(_fbb: &'mut_bldr mut flatbuffers::builder::FlatBufferBuilder<'bldr, A>, args: &'args vortex_flatbuffers::dtype::VariantArgs) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::dtype::Variant<'bldr>>
+
+pub unsafe fn vortex_flatbuffers::dtype::Variant<'a>::init_from_table(table: flatbuffers::table::Table<'a>) -> Self
+
+pub fn vortex_flatbuffers::dtype::Variant<'a>::nullable(&self) -> bool
+
+impl core::fmt::Debug for vortex_flatbuffers::dtype::Variant<'_>
+
+pub fn vortex_flatbuffers::dtype::Variant<'_>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl flatbuffers::verifier::Verifiable for vortex_flatbuffers::dtype::Variant<'_>
+
+pub fn vortex_flatbuffers::dtype::Variant<'_>::run_verifier(v: &mut flatbuffers::verifier::Verifier<'_, '_>, pos: usize) -> core::result::Result<(), flatbuffers::verifier::InvalidFlatbuffer>
+
+impl<'a> core::clone::Clone for vortex_flatbuffers::dtype::Variant<'a>
+
+pub fn vortex_flatbuffers::dtype::Variant<'a>::clone(&self) -> vortex_flatbuffers::dtype::Variant<'a>
+
+impl<'a> core::cmp::PartialEq for vortex_flatbuffers::dtype::Variant<'a>
+
+pub fn vortex_flatbuffers::dtype::Variant<'a>::eq(&self, other: &vortex_flatbuffers::dtype::Variant<'a>) -> bool
+
+impl<'a> core::marker::Copy for vortex_flatbuffers::dtype::Variant<'a>
+
+impl<'a> core::marker::StructuralPartialEq for vortex_flatbuffers::dtype::Variant<'a>
+
+impl<'a> flatbuffers::follow::Follow<'a> for vortex_flatbuffers::dtype::Variant<'a>
+
+pub type vortex_flatbuffers::dtype::Variant<'a>::Inner = vortex_flatbuffers::dtype::Variant<'a>
+
+pub unsafe fn vortex_flatbuffers::dtype::Variant<'a>::follow(buf: &'a [u8], loc: usize) -> Self::Inner
+
+pub struct vortex_flatbuffers::dtype::VariantArgs
+
+pub vortex_flatbuffers::dtype::VariantArgs::nullable: bool
+
+impl<'a> core::default::Default for vortex_flatbuffers::dtype::VariantArgs
+
+pub fn vortex_flatbuffers::dtype::VariantArgs::default() -> Self
+
+pub struct vortex_flatbuffers::dtype::VariantBuilder<'a: 'b, 'b, A: flatbuffers::builder::Allocator + 'a>
+
+impl<'a: 'b, 'b, A: flatbuffers::builder::Allocator + 'a> vortex_flatbuffers::dtype::VariantBuilder<'a, 'b, A>
+
+pub fn vortex_flatbuffers::dtype::VariantBuilder<'a, 'b, A>::add_nullable(&mut self, nullable: bool)
+
+pub fn vortex_flatbuffers::dtype::VariantBuilder<'a, 'b, A>::finish(self) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::dtype::Variant<'a>>
+
+pub fn vortex_flatbuffers::dtype::VariantBuilder<'a, 'b, A>::new(_fbb: &'b mut flatbuffers::builder::FlatBufferBuilder<'a, A>) -> vortex_flatbuffers::dtype::VariantBuilder<'a, 'b, A>
+
 pub const vortex_flatbuffers::dtype::ENUM_MAX_PTYPE: u8
 
 pub const vortex_flatbuffers::dtype::ENUM_MAX_TYPE: u8
@@ -1512,7 +1576,7 @@ pub const vortex_flatbuffers::dtype::ENUM_MIN_TYPE: u8
 
 pub const vortex_flatbuffers::dtype::ENUM_VALUES_PTYPE: [vortex_flatbuffers::dtype::PType; 11]
 
-pub const vortex_flatbuffers::dtype::ENUM_VALUES_TYPE: [vortex_flatbuffers::dtype::Type; 11]
+pub const vortex_flatbuffers::dtype::ENUM_VALUES_TYPE: [vortex_flatbuffers::dtype::Type; 12]
 
 pub fn vortex_flatbuffers::dtype::finish_dtype_buffer<'a, 'b, A: flatbuffers::builder::Allocator + 'a>(fbb: &'b mut flatbuffers::builder::FlatBufferBuilder<'a, A>, root: flatbuffers::primitives::WIPOffset<vortex_flatbuffers::dtype::DType<'a>>)
 
diff --git a/vortex-flatbuffers/src/generated/dtype.rs b/vortex-flatbuffers/src/generated/dtype.rs
index 1ba03d8a3c3..ac1ac8ee9a4 100644
--- a/vortex-flatbuffers/src/generated/dtype.rs
+++ b/vortex-flatbuffers/src/generated/dtype.rs
@@ -133,10 +133,10 @@ impl flatbuffers::SimpleToVerifyInSlice for PType {}
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_TYPE: u8 = 0;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MAX_TYPE: u8 = 10;
+pub const ENUM_MAX_TYPE: u8 = 11;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
-pub const ENUM_VALUES_TYPE: [Type; 11] = [
+pub const ENUM_VALUES_TYPE: [Type; 12] = [
   Type::NONE,
   Type::Null,
   Type::Bool,
@@ -148,6 +148,7 @@ pub const ENUM_VALUES_TYPE: [Type; 11] = [
   Type::List,
   Type::Extension,
   Type::FixedSizeList,
+  Type::Variant,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -166,9 +167,10 @@ impl Type {
   pub const List: Self = Self(8);
   pub const Extension: Self = Self(9);
   pub const FixedSizeList: Self = Self(10);
+  pub const Variant: Self = Self(11);
 
   pub const ENUM_MIN: u8 = 0;
-  pub const ENUM_MAX: u8 = 10;
+  pub const ENUM_MAX: u8 = 11;
   pub const ENUM_VALUES: &'static [Self] = &[
     Self::NONE,
     Self::Null,
@@ -181,6 +183,7 @@ impl Type {
     Self::List,
     Self::Extension,
     Self::FixedSizeList,
+    Self::Variant,
   ];
   /// Returns the variant's name or "" if unknown.
   pub fn variant_name(self) -> Option<&'static str> {
@@ -196,6 +199,7 @@ impl Type {
       Self::List => Some("List"),
       Self::Extension => Some("Extension"),
       Self::FixedSizeList => Some("FixedSizeList"),
+      Self::Variant => Some("Variant"),
       _ => None,
     }
   }
@@ -1375,6 +1379,103 @@ impl core::fmt::Debug for Extension<'_> {
       ds.finish()
   }
 }
+pub enum VariantOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Variant<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for Variant<'a> {
+  type Inner = Variant<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Variant<'a> {
+  pub const VT_NULLABLE: flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    Variant { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args VariantArgs
+  ) -> flatbuffers::WIPOffset<Variant<'bldr>> {
+    let mut builder = VariantBuilder::new(_fbb);
+    builder.add_nullable(args.nullable);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn nullable(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(Variant::VT_NULLABLE, Some(false)).unwrap()}
+  }
+}
+
+impl flatbuffers::Verifiable for Variant<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .visit_field::<bool>("nullable", Self::VT_NULLABLE, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct VariantArgs {
+    pub nullable: bool,
+}
+impl<'a> Default for VariantArgs {
+  #[inline]
+  fn default() -> Self {
+    VariantArgs {
+      nullable: false,
+    }
+  }
+}
+
+pub struct VariantBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> VariantBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_nullable(&mut self, nullable: bool) {
+    self.fbb_.push_slot::<bool>(Variant::VT_NULLABLE, nullable, false);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> VariantBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    VariantBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<Variant<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl core::fmt::Debug for Variant<'_> {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let mut ds = f.debug_struct("Variant");
+      ds.field("nullable", &self.nullable());
+      ds.finish()
+  }
+}
 pub enum DTypeOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
@@ -1574,6 +1675,21 @@ impl<'a> DType<'a> {
     }
   }
 
+  #[inline]
+  #[allow(non_snake_case)]
+  pub fn type__as_variant(&self) -> Option<Variant<'a>> {
+    if self.type_type() == Type::Variant {
+      self.type_().map(|t| {
+       // Safety:
+       // Created from a valid Table for this object
+       // Which contains a valid union in this slot
+       unsafe { Variant::init_from_table(t) }
+     })
+    } else {
+      None
+    }
+  }
+
 }
 
 impl flatbuffers::Verifiable for DType<'_> {
@@ -1595,6 +1711,7 @@ impl flatbuffers::Verifiable for DType<'_> {
           Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>("Type::List", pos),
           Type::Extension => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Extension>>("Type::Extension", pos),
           Type::FixedSizeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>("Type::FixedSizeList", pos),
+          Type::Variant => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Variant>>("Type::Variant", pos),
           _ => Ok(()),
         }
      })?
@@ -1719,6 +1836,13 @@ impl core::fmt::Debug for DType<'_> {
             ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
           }
         },
+        Type::Variant => {
+          if let Some(x) = self.type__as_variant() {
+            ds.field("type_", &x)
+          } else {
+            ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
+          }
+        },
         _ => {
           let x: Option<()> = None;
           ds.field("type_", &x)
diff --git a/vortex-flatbuffers/src/generated/message.rs b/vortex-flatbuffers/src/generated/message.rs
index 618bdedb808..0748adec10a 100644
--- a/vortex-flatbuffers/src/generated/message.rs
+++ b/vortex-flatbuffers/src/generated/message.rs
@@ -3,8 +3,8 @@
 
 // @generated
 
-use crate::dtype::*;
 use crate::array::*;
+use crate::dtype::*;
 use core::mem;
 use core::cmp::Ordering;
 
diff --git a/vortex-io/Cargo.toml b/vortex-io/Cargo.toml
index 132ca7b55eb..da8053af471 100644
--- a/vortex-io/Cargo.toml
+++ b/vortex-io/Cargo.toml
@@ -50,7 +50,9 @@ custom-labels = { workspace = true }
 # Smol is our default impl, so we don't want it to be optional, but it cannot be part of wasm
 smol = { workspace = true }
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
+# target_os = "unknown" matches wasm32-unknown-unknown (browser), excluding WASI targets
+# where wasm-bindgen's JS interop is not available.
+[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
 wasm-bindgen-futures = { workspace = true }
 
 [dev-dependencies]
diff --git a/vortex-io/public-api.lock b/vortex-io/public-api.lock
index fb3daf12742..08d74ffc830 100644
--- a/vortex-io/public-api.lock
+++ b/vortex-io/public-api.lock
@@ -150,12 +150,12 @@ impl vortex_io::object_store::ObjectStoreReadAt
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::new(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle) -> Self
 
+pub fn vortex_io::object_store::ObjectStoreReadAt::new_with_allocator(store: alloc::sync::Arc<dyn object_store::ObjectStore>, path: object_store::path::Path, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> Self
+
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_coalesce_config(self, config: vortex_io::CoalesceConfig) -> Self
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::with_concurrency(self, concurrency: usize) -> Self
 
-pub fn vortex_io::object_store::ObjectStoreReadAt::with_some_coalesce_config(self, config: core::option::Option<vortex_io::CoalesceConfig>) -> Self
-
 impl vortex_io::VortexReadAt for vortex_io::object_store::ObjectStoreReadAt
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>
@@ -454,6 +454,12 @@ pub fn vortex_io::session::RuntimeSessionExt::with_tokio(self) -> Self
 
 impl<S: vortex_session::SessionExt> vortex_io::session::RuntimeSessionExt for S
 
+pub fn S::handle(&self) -> vortex_io::runtime::Handle
+
+pub fn S::with_handle(self, handle: vortex_io::runtime::Handle) -> Self
+
+pub fn S::with_tokio(self) -> Self
+
 pub mod vortex_io::std_file
 
 pub struct vortex_io::std_file::FileReadAt
@@ -462,6 +468,8 @@ impl vortex_io::std_file::FileReadAt
 
 pub fn vortex_io::std_file::FileReadAt::open(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle) -> vortex_error::VortexResult<Self>
 
+pub fn vortex_io::std_file::FileReadAt::open_with_allocator(path: impl core::convert::AsRef<std::path::Path>, handle: vortex_io::runtime::Handle, allocator: vortex_array::memory::HostAllocatorRef) -> vortex_error::VortexResult<Self>
+
 impl vortex_io::VortexReadAt for vortex_io::std_file::FileReadAt
 
 pub fn vortex_io::std_file::FileReadAt::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>
@@ -476,6 +484,8 @@ pub fn vortex_io::std_file::FileReadAt::uri(&self) -> core::option::Option<&allo
 
 pub const vortex_io::std_file::DEFAULT_CONCURRENCY: usize
 
+pub fn vortex_io::std_file::read_exact_at(file: &std::fs::File, buffer: &mut [u8], offset: u64) -> std::io::error::Result<()>
+
 pub struct vortex_io::AsyncWriteAdapter<W: futures_io::if_std::AsyncWrite>(pub W)
 
 impl<W: futures_io::if_std::AsyncWrite + core::marker::Unpin> vortex_io::VortexWrite for vortex_io::AsyncWriteAdapter<W>
@@ -494,7 +504,9 @@ pub vortex_io::CoalesceConfig::max_size: u64
 
 impl vortex_io::CoalesceConfig
 
-pub const fn vortex_io::CoalesceConfig::local() -> Self
+pub const fn vortex_io::CoalesceConfig::file() -> Self
+
+pub const fn vortex_io::CoalesceConfig::in_memory() -> Self
 
 pub const fn vortex_io::CoalesceConfig::new(distance: u64, max_size: u64) -> Self
 
@@ -548,6 +560,8 @@ pub fn vortex_io::OwnedSlice<T>::bytes_init(&self) -> usize
 
 pub fn vortex_io::OwnedSlice<T>::read_ptr(&self) -> *const u8
 
+pub fn vortex_io::OwnedSlice<T>::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 pub struct vortex_io::SizeLimitedStream<Fut>
 
 impl<Fut> vortex_io::SizeLimitedStream<Fut> where Fut: core::future::future::Future
@@ -588,6 +602,8 @@ pub fn &'static [u8]::bytes_init(&self) -> usize
 
 pub fn &'static [u8]::read_ptr(&self) -> *const u8
 
+pub fn &'static [u8]::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl vortex_io::IoBuf for alloc::vec::Vec<u8>
 
 pub fn alloc::vec::Vec<u8>::as_slice(&self) -> &[u8]
@@ -596,6 +612,8 @@ pub fn alloc::vec::Vec<u8>::bytes_init(&self) -> usize
 
 pub fn alloc::vec::Vec<u8>::read_ptr(&self) -> *const u8
 
+pub fn alloc::vec::Vec<u8>::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl vortex_io::IoBuf for bytes::bytes::Bytes
 
 pub fn bytes::bytes::Bytes::as_slice(&self) -> &[u8]
@@ -604,6 +622,8 @@ pub fn bytes::bytes::Bytes::bytes_init(&self) -> usize
 
 pub fn bytes::bytes::Bytes::read_ptr(&self) -> *const u8
 
+pub fn bytes::bytes::Bytes::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl<T: core::marker::Unpin + core::marker::Send + 'static> vortex_io::IoBuf for vortex_buffer::buffer::Buffer<T>
 
 pub fn vortex_buffer::buffer::Buffer<T>::as_slice(&self) -> &[u8]
@@ -612,6 +632,8 @@ pub fn vortex_buffer::buffer::Buffer<T>::bytes_init(&self) -> usize
 
 pub fn vortex_buffer::buffer::Buffer<T>::read_ptr(&self) -> *const u8
 
+pub fn vortex_buffer::buffer::Buffer<T>::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl<T: vortex_io::IoBuf> vortex_io::IoBuf for vortex_io::OwnedSlice<T>
 
 pub fn vortex_io::OwnedSlice<T>::as_slice(&self) -> &[u8]
@@ -620,6 +642,8 @@ pub fn vortex_io::OwnedSlice<T>::bytes_init(&self) -> usize
 
 pub fn vortex_io::OwnedSlice<T>::read_ptr(&self) -> *const u8
 
+pub fn vortex_io::OwnedSlice<T>::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl<const A: usize> vortex_io::IoBuf for vortex_buffer::ConstByteBuffer<A>
 
 pub fn vortex_buffer::ConstByteBuffer<A>::as_slice(&self) -> &[u8]
@@ -628,6 +652,8 @@ pub fn vortex_buffer::ConstByteBuffer<A>::bytes_init(&self) -> usize
 
 pub fn vortex_buffer::ConstByteBuffer<A>::read_ptr(&self) -> *const u8
 
+pub fn vortex_buffer::ConstByteBuffer<A>::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 impl<const N: usize> vortex_io::IoBuf for [u8; N]
 
 pub fn [u8; N]::as_slice(&self) -> &[u8]
@@ -636,6 +662,8 @@ pub fn [u8; N]::bytes_init(&self) -> usize
 
 pub fn [u8; N]::read_ptr(&self) -> *const u8
 
+pub fn [u8; N]::slice_owned(self, range: core::ops::range::Range<usize>) -> vortex_io::OwnedSlice<Self> where Self: core::marker::Sized
+
 pub trait vortex_io::VortexReadAt: core::marker::Send + core::marker::Sync + 'static
 
 pub fn vortex_io::VortexReadAt::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>
@@ -662,12 +690,16 @@ pub fn alloc::sync::Arc<dyn vortex_io::VortexReadAt>::uri(&self) -> core::option
 
 impl vortex_io::VortexReadAt for vortex_buffer::ByteBuffer
 
+pub fn vortex_buffer::ByteBuffer::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>
+
 pub fn vortex_buffer::ByteBuffer::concurrency(&self) -> usize
 
 pub fn vortex_buffer::ByteBuffer::read_at(&self, offset: u64, length: usize, alignment: vortex_buffer::alignment::Alignment) -> futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::buffer::BufferHandle>>
 
 pub fn vortex_buffer::ByteBuffer::size(&self) -> futures_core::future::BoxFuture<'static, vortex_error::VortexResult<u64>>
 
+pub fn vortex_buffer::ByteBuffer::uri(&self) -> core::option::Option<&alloc::sync::Arc<str>>
+
 impl vortex_io::VortexReadAt for vortex_io::object_store::ObjectStoreReadAt
 
 pub fn vortex_io::object_store::ObjectStoreReadAt::coalesce_config(&self) -> core::option::Option<vortex_io::CoalesceConfig>
diff --git a/vortex-io/src/limit.rs b/vortex-io/src/limit.rs
index 52c7c4b285d..f49ea7a3661 100644
--- a/vortex-io/src/limit.rs
+++ b/vortex-io/src/limit.rs
@@ -81,9 +81,7 @@ where
         // Attempt to acquire enough permits to begin working on a request that will occupy
         // `bytes` amount of memory when it completes.
         // Acquiring the permits is what creates backpressure for the producer.
-        let permits = self
-            .bytes_available
-            .clone()
+        let permits = Arc::clone(&self.bytes_available)
             .acquire_many_owned(bytes.try_into().vortex_expect("bytes must fit in u32"))
             .await
             .unwrap_or_else(|_| unreachable!("pushing to closed semaphore"));
@@ -102,9 +100,7 @@ where
     ///
     /// If there is not enough capacity, the original future is returned to the caller.
     pub fn try_push(&self, fut: Fut, bytes: usize) -> Result<(), Fut> {
-        match self
-            .bytes_available
-            .clone()
+        match Arc::clone(&self.bytes_available)
             .try_acquire_many_owned(bytes.try_into().vortex_expect("bytes must fit in u32"))
         {
             Ok(permits) => {
diff --git a/vortex-io/src/object_store/filesystem.rs b/vortex-io/src/object_store/filesystem.rs
index 4a328725a40..6fdbc23caa3 100644
--- a/vortex-io/src/object_store/filesystem.rs
+++ b/vortex-io/src/object_store/filesystem.rs
@@ -76,7 +76,7 @@ impl FileSystem for ObjectStoreFileSystem {
 
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
         Ok(Arc::new(ObjectStoreReadAt::new(
-            self.store.clone(),
+            Arc::clone(&self.store),
             path.into(),
             self.handle.clone(),
         )))
diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs
index f14b6ac5770..fd0f979c187 100644
--- a/vortex-io/src/object_store/read_at.rs
+++ b/vortex-io/src/object_store/read_at.rs
@@ -11,10 +11,12 @@ use object_store::GetOptions;
 use object_store::GetRange;
 use object_store::GetResultPayload;
 use object_store::ObjectStore;
+use object_store::ObjectStoreExt;
 use object_store::path::Path as ObjectPath;
 use vortex_array::buffer::BufferHandle;
+use vortex_array::memory::DefaultHostAllocator;
+use vortex_array::memory::HostAllocatorRef;
 use vortex_buffer::Alignment;
-use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexError;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
@@ -34,6 +36,7 @@ pub struct ObjectStoreReadAt {
     path: ObjectPath,
     uri: Arc<str>,
     handle: Handle,
+    allocator: HostAllocatorRef,
     concurrency: usize,
     coalesce_config: Option<CoalesceConfig>,
 }
@@ -41,12 +44,23 @@ pub struct ObjectStoreReadAt {
 impl ObjectStoreReadAt {
     /// Create a new object store source.
     pub fn new(store: Arc<dyn ObjectStore>, path: ObjectPath, handle: Handle) -> Self {
+        Self::new_with_allocator(store, path, handle, Arc::new(DefaultHostAllocator))
+    }
+
+    /// Create a new object store source with a custom writable buffer allocator.
+    pub fn new_with_allocator(
+        store: Arc<dyn ObjectStore>,
+        path: ObjectPath,
+        handle: Handle,
+        allocator: HostAllocatorRef,
+    ) -> Self {
         let uri = Arc::from(path.to_string());
         Self {
             store,
             path,
             uri,
             handle,
+            allocator,
             concurrency: DEFAULT_CONCURRENCY,
             coalesce_config: Some(CoalesceConfig::object_storage()),
         }
@@ -63,12 +77,6 @@ impl ObjectStoreReadAt {
         self.coalesce_config = Some(config);
         self
     }
-
-    /// Set an optional coalesce config for this source.
-    pub fn with_some_coalesce_config(mut self, config: Option<CoalesceConfig>) -> Self {
-        self.coalesce_config = config;
-        self
-    }
 }
 
 impl VortexReadAt for ObjectStoreReadAt {
@@ -85,7 +93,7 @@ impl VortexReadAt for ObjectStoreReadAt {
     }
 
     fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
-        let store = self.store.clone();
+        let store = Arc::clone(&self.store);
         let path = self.path.clone();
         async move {
             store
@@ -103,13 +111,14 @@ impl VortexReadAt for ObjectStoreReadAt {
         length: usize,
         alignment: Alignment,
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
-        let store = self.store.clone();
+        let store = Arc::clone(&self.store);
         let path = self.path.clone();
         let handle = self.handle.clone();
+        let allocator = Arc::clone(&self.allocator);
         let range = offset..(offset + length as u64);
 
         async move {
-            let mut buffer = ByteBufferMut::with_capacity_aligned(length, alignment);
+            let mut buffer = allocator.allocate(length, alignment)?;
 
             let response = store
                 .get_opts(
@@ -124,11 +133,9 @@ impl VortexReadAt for ObjectStoreReadAt {
             let buffer = match response.payload {
                 #[cfg(not(target_arch = "wasm32"))]
                 GetResultPayload::File(file, _) => {
-                    unsafe { buffer.set_len(length) };
-
                     handle
                         .spawn_blocking(move || {
-                            read_exact_at(&file, &mut buffer, range.start)?;
+                            read_exact_at(&file, buffer.as_mut_slice(), range.start)?;
                             Ok::<_, io::Error>(buffer)
                         })
                         .await
@@ -139,14 +146,25 @@ impl VortexReadAt for ObjectStoreReadAt {
                     unreachable!("File payload not supported on wasm32")
                 }
                 GetResultPayload::Stream(mut byte_stream) => {
+                    let mut written = 0usize;
                     while let Some(bytes) = byte_stream.next().await {
-                        buffer.extend_from_slice(&bytes?);
+                        let bytes = bytes?;
+                        let end = written + bytes.len();
+                        vortex_ensure!(
+                            end <= length,
+                            "Object store stream returned too many bytes: {} > expected {} (range: {:?})",
+                            end,
+                            length,
+                            range
+                        );
+                        buffer.as_mut_slice()[written..end].copy_from_slice(&bytes);
+                        written = end;
                     }
 
                     vortex_ensure!(
-                        buffer.len() == length,
+                        written == length,
                         "Object store stream returned {} bytes but expected {} bytes (range: {:?})",
-                        buffer.len(),
+                        written,
                         length,
                         range
                     );
diff --git a/vortex-io/src/object_store/write.rs b/vortex-io/src/object_store/write.rs
index 20bfb7815c4..3cb73cec331 100644
--- a/vortex-io/src/object_store/write.rs
+++ b/vortex-io/src/object_store/write.rs
@@ -9,6 +9,7 @@ use futures::TryStreamExt;
 use futures::stream::FuturesUnordered;
 use object_store::MultipartUpload;
 use object_store::ObjectStore;
+use object_store::ObjectStoreExt;
 use object_store::PutPayload;
 use object_store::PutResult;
 use object_store::path::Path;
@@ -128,7 +129,7 @@ mod tests {
         let location = Path::from("test.bin");
 
         for test_store in [memory_store, local_store] {
-            let mut writer = ObjectStoreWrite::new(test_store.clone(), &location).await?;
+            let mut writer = ObjectStoreWrite::new(Arc::clone(&test_store), &location).await?;
 
             #[expect(clippy::cast_possible_truncation)]
             let data = (0..3)
diff --git a/vortex-io/src/read_at.rs b/vortex-io/src/read_at.rs
index 2291dc0e1c7..28cc5bf244b 100644
--- a/vortex-io/src/read_at.rs
+++ b/vortex-io/src/read_at.rs
@@ -33,11 +33,16 @@ impl CoalesceConfig {
         Self { distance, max_size }
     }
 
-    /// Configuration appropriate for fast local storage (memory, NVMe).
-    pub const fn local() -> Self {
+    /// Configuration appropriate for in-memory / low-latency sources.
+    pub const fn in_memory() -> Self {
         Self::new(8 * 1024, 8 * 1024) // 8KB
     }
 
+    /// Configuration appropriate for local filesystem access.
+    pub const fn file() -> Self {
+        Self::new(1 << 20, 4 << 20) // 1MB distance, 4MB max
+    }
+
     /// Configuration appropriate for object storage (S3, GCS, etc.).
     pub const fn object_storage() -> Self {
         Self::new(1 << 20, 16 << 20) // 1MB distance, 16MB max
@@ -317,12 +322,19 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_coalesce_config_local() {
-        let config = CoalesceConfig::local();
+    fn test_coalesce_config_in_memory() {
+        let config = CoalesceConfig::in_memory();
         assert_eq!(config.distance, 8 * 1024);
         assert_eq!(config.max_size, 8 * 1024);
     }
 
+    #[test]
+    fn test_coalesce_config_file() {
+        let config = CoalesceConfig::file();
+        assert_eq!(config.distance, 1 << 20); // 1MB
+        assert_eq!(config.max_size, 4 << 20); // 4MB
+    }
+
     #[test]
     fn test_coalesce_config_object_storage() {
         let config = CoalesceConfig::object_storage();
diff --git a/vortex-io/src/runtime/current.rs b/vortex-io/src/runtime/current.rs
index 1d2eda71487..c49d9e010a5 100644
--- a/vortex-io/src/runtime/current.rs
+++ b/vortex-io/src/runtime/current.rs
@@ -45,7 +45,7 @@ impl CurrentThreadRuntime {
     /// By default, the pool has no worker threads; the caller must set the desired number of
     /// worker threads using the `set_workers` method on the returned pool.
     pub fn new_pool(&self) -> CurrentThreadWorkerPool {
-        CurrentThreadWorkerPool::new(self.executor.clone())
+        CurrentThreadWorkerPool::new(Arc::clone(&self.executor))
     }
 
     /// Returns an iterator wrapper around a stream, blocking the current thread for each item.
@@ -81,7 +81,7 @@ impl CurrentThreadRuntime {
             .detach();
 
         ThreadSafeIterator {
-            executor: self.executor.clone(),
+            executor: Arc::clone(&self.executor),
             results: result_rx,
         }
     }
@@ -91,7 +91,7 @@ impl BlockingRuntime for CurrentThreadRuntime {
     type BlockingIterator<'a, R: 'a> = CurrentThreadIterator<'a, R>;
 
     fn handle(&self) -> Handle {
-        let executor: Arc<dyn Executor> = self.executor.clone();
+        let executor: Arc<dyn Executor> = Arc::clone(&self.executor) as Arc<dyn Executor>;
         Handle::new(Arc::downgrade(&executor))
     }
 
@@ -108,7 +108,7 @@ impl BlockingRuntime for CurrentThreadRuntime {
         R: Send + 'a,
     {
         CurrentThreadIterator {
-            executor: self.executor.clone(),
+            executor: Arc::clone(&self.executor),
             stream: stream.boxed(),
         }
     }
@@ -138,7 +138,7 @@ pub struct ThreadSafeIterator<T> {
 impl<T> Clone for ThreadSafeIterator<T> {
     fn clone(&self) -> Self {
         Self {
-            executor: self.executor.clone(),
+            executor: Arc::clone(&self.executor),
             results: self.results.clone(),
         }
     }
@@ -174,7 +174,7 @@ mod tests {
 
         // We spawn a future that sets a value on a separate thread.
         let value = Arc::new(AtomicUsize::new(0));
-        let value2 = value.clone();
+        let value2 = Arc::clone(&value);
         runtime
             .handle()
             .spawn(async move {
@@ -229,9 +229,9 @@ mod tests {
         let threads: Vec<_> = (0..num_threads)
             .map(|_| {
                 let mut iter = iter.clone();
-                let counter = counter.clone();
-                let barrier = barrier.clone();
-                let results = results.clone();
+                let counter = Arc::clone(&counter);
+                let barrier = Arc::clone(&barrier);
+                let results = Arc::clone(&results);
 
                 thread::spawn(move || {
                     barrier.wait();
@@ -290,8 +290,8 @@ mod tests {
         let threads: Vec<_> = (0..num_threads)
             .map(|thread_id| {
                 let iter = iter.clone();
-                let collected = collected.clone();
-                let barrier = barrier.clone();
+                let collected = Arc::clone(&collected);
+                let barrier = Arc::clone(&barrier);
 
                 thread::spawn(move || {
                     barrier.wait();
@@ -346,11 +346,11 @@ mod tests {
     #[test]
     fn test_block_on_stream_drop_receivers_early() {
         let counter = Arc::new(AtomicUsize::new(0));
-        let c = counter.clone();
+        let c = Arc::clone(&counter);
 
         let mut iter = CurrentThreadRuntime::new().block_on_stream({
             stream::unfold(0, move |state| {
-                let c = c.clone();
+                let c = Arc::clone(&c);
                 async move {
                     (state < 100).then(|| {
                         c.fetch_add(1, Ordering::SeqCst);
@@ -382,7 +382,7 @@ mod tests {
 
         let iter1 = iter.clone();
         let iter2 = iter;
-        let barrier1 = barrier.clone();
+        let barrier1 = Arc::clone(&barrier);
         let barrier2 = barrier;
 
         let thread1 = thread::spawn(move || {
@@ -441,8 +441,8 @@ mod tests {
         let threads: Vec<_> = (0..num_threads)
             .map(|_| {
                 let iter = iter.clone();
-                let received = received.clone();
-                let barrier = barrier.clone();
+                let received = Arc::clone(&received);
+                let barrier = Arc::clone(&barrier);
 
                 thread::spawn(move || {
                     barrier.wait();
diff --git a/vortex-io/src/runtime/handle.rs b/vortex-io/src/runtime/handle.rs
index 5d8ccc10093..f04b897b29e 100644
--- a/vortex-io/src/runtime/handle.rs
+++ b/vortex-io/src/runtime/handle.rs
@@ -9,6 +9,7 @@ use std::task::Poll;
 use std::task::ready;
 
 use futures::FutureExt;
+use tracing::Instrument;
 use vortex_error::vortex_panic;
 
 use crate::runtime::AbortHandleRef;
@@ -65,15 +66,17 @@ impl Handle {
         R: Send + 'static,
     {
         let (send, recv) = oneshot::channel();
+        let span = tracing::Span::current();
         let abort_handle = self.runtime().spawn(
             async move {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
                 drop(send.send(f.await));
             }
+            .instrument(span)
             .boxed(),
         );
         Task {
-            recv,
+            recv: recv.into_future(),
             abort_handle: Some(abort_handle),
         }
     }
@@ -85,7 +88,7 @@ impl Handle {
         Fut: Future<Output = R> + Send + 'static,
         R: Send + 'static,
     {
-        self.spawn(f(Handle::new(self.runtime.clone())))
+        self.spawn(f(Handle::new(Weak::clone(&self.runtime))))
     }
 
     /// Spawn a CPU-bound task for execution on the runtime.
@@ -103,7 +106,9 @@ impl Handle {
         R: Send + 'static,
     {
         let (send, recv) = oneshot::channel();
+        let span = tracing::Span::current();
         let abort_handle = self.runtime().spawn_cpu(Box::new(move || {
+            let _guard = span.enter();
             // Optimistically avoid the work if the result won't be used.
             if !send.is_closed() {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
@@ -111,7 +116,7 @@ impl Handle {
             }
         }));
         Task {
-            recv,
+            recv: recv.into_future(),
             abort_handle: Some(abort_handle),
         }
     }
@@ -123,7 +128,9 @@ impl Handle {
         R: Send + 'static,
     {
         let (send, recv) = oneshot::channel();
+        let span = tracing::Span::current();
         let abort_handle = self.runtime().spawn_blocking_io(Box::new(move || {
+            let _guard = span.enter();
             // Optimistically avoid the work if the result won't be used.
             if !send.is_closed() {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
@@ -131,7 +138,7 @@ impl Handle {
             }
         }));
         Task {
-            recv,
+            recv: recv.into_future(),
             abort_handle: Some(abort_handle),
         }
     }
@@ -143,7 +150,7 @@ impl Handle {
 /// continue running in the background, call [`Task::detach`].
 #[must_use = "When a Task is dropped without being awaited, it is cancelled"]
 pub struct Task<T> {
-    recv: oneshot::Receiver<T>,
+    recv: oneshot::AsyncReceiver<T>,
     abort_handle: Option<AbortHandleRef>,
 }
 
diff --git a/vortex-io/src/runtime/mod.rs b/vortex-io/src/runtime/mod.rs
index 9caf425f472..6a294c1311d 100644
--- a/vortex-io/src/runtime/mod.rs
+++ b/vortex-io/src/runtime/mod.rs
@@ -29,7 +29,9 @@ pub mod single;
 mod smol;
 #[cfg(feature = "tokio")]
 pub mod tokio;
-#[cfg(target_arch = "wasm32")]
+// target_os = "unknown" matches wasm32-unknown-unknown (browser), excluding WASI targets
+// where wasm-bindgen's JS interop is not available.
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 pub mod wasm;
 
 #[cfg(test)]
diff --git a/vortex-io/src/runtime/pool.rs b/vortex-io/src/runtime/pool.rs
index 962407551ec..a8d1f67a149 100644
--- a/vortex-io/src/runtime/pool.rs
+++ b/vortex-io/src/runtime/pool.rs
@@ -44,8 +44,8 @@ impl CurrentThreadWorkerPool {
             // Spawn new workers
             for _ in current..n {
                 let shutdown = Arc::new(AtomicBool::new(false));
-                let executor = self.executor.clone();
-                let shutdown_clone = shutdown.clone();
+                let executor = Arc::clone(&self.executor);
+                let shutdown_clone = Arc::clone(&shutdown);
 
                 std::thread::Builder::new()
                     .name("vortex-current-thread-worker".to_string())
diff --git a/vortex-io/src/runtime/single.rs b/vortex-io/src/runtime/single.rs
index 0a3abf553dc..743dc587f48 100644
--- a/vortex-io/src/runtime/single.rs
+++ b/vortex-io/src/runtime/single.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::rc::Rc;
+use std::rc::Weak as RcWeak;
 use std::sync::Arc;
 
 use futures::Stream;
@@ -57,7 +58,7 @@ impl Sender {
         let weak_local = Rc::downgrade(local);
 
         // Drive scheduling tasks.
-        let weak_local2 = weak_local.clone();
+        let weak_local2 = RcWeak::clone(&weak_local);
         local
             .spawn(async move {
                 while let Ok(spawn) = scheduling_recv.as_async().recv().await {
@@ -74,7 +75,7 @@ impl Sender {
             .detach();
 
         // Drive CPU tasks.
-        let weak_local2 = weak_local.clone();
+        let weak_local2 = RcWeak::clone(&weak_local);
         local
             .spawn(async move {
                 while let Ok(spawn) = cpu_recv.as_async().recv().await {
@@ -90,7 +91,7 @@ impl Sender {
             .detach();
 
         // Drive blocking tasks.
-        let weak_local2 = weak_local.clone();
+        let weak_local2 = RcWeak::clone(&weak_local);
         local
             .spawn(async move {
                 while let Ok(spawn) = blocking_recv.as_async().recv().await {
@@ -162,7 +163,7 @@ impl BlockingRuntime for SingleThreadRuntime {
     type BlockingIterator<'a, R: 'a> = SingleThreadIterator<'a, R>;
 
     fn handle(&self) -> Handle {
-        let executor: Arc<dyn Executor> = self.sender.clone();
+        let executor: Arc<dyn Executor> = Arc::clone(&self.sender) as Arc<dyn Executor>;
         Handle::new(Arc::downgrade(&executor))
     }
 
@@ -179,7 +180,7 @@ impl BlockingRuntime for SingleThreadRuntime {
         R: Send + 'a,
     {
         SingleThreadIterator {
-            executor: self.executor.clone(),
+            executor: Rc::clone(&self.executor),
             stream: stream.boxed_local(),
         }
     }
@@ -281,7 +282,7 @@ mod tests {
     #[test]
     fn test_spawn_cpu_task() {
         let counter = Arc::new(AtomicUsize::new(0));
-        let c = counter.clone();
+        let c = Arc::clone(&counter);
 
         block_on(|handle| async move {
             handle
diff --git a/vortex-io/src/runtime/tests.rs b/vortex-io/src/runtime/tests.rs
index 12b685b820e..8b342f4242d 100644
--- a/vortex-io/src/runtime/tests.rs
+++ b/vortex-io/src/runtime/tests.rs
@@ -213,7 +213,7 @@ fn test_handle_spawn_future() {
 async fn test_handle_spawn_cpu() {
     let handle = TokioRuntime::current();
     let counter = Arc::new(AtomicUsize::new(0));
-    let c = counter.clone();
+    let c = Arc::clone(&counter);
 
     let task = handle.spawn_cpu(move || {
         c.fetch_add(1, Ordering::SeqCst);
@@ -278,7 +278,7 @@ async fn test_custom_vortex_read() {
 
     let read_at: Arc<dyn VortexReadAt> = Arc::new(CountingReadAt {
         data: ByteBuffer::from(TEST_DATA.to_vec()),
-        read_count: read_count.clone(),
+        read_count: Arc::clone(&read_count),
     });
 
     // Perform several reads
@@ -315,7 +315,7 @@ async fn test_read_out_of_bounds() {
 async fn test_task_detach() {
     let handle = TokioRuntime::current();
     let counter = Arc::new(AtomicUsize::new(0));
-    let c = counter.clone();
+    let c = Arc::clone(&counter);
     let (tx, rx) = oneshot::channel::<()>();
 
     let task = handle.spawn(async move {
diff --git a/vortex-io/src/runtime/tokio.rs b/vortex-io/src/runtime/tokio.rs
index e4fd7095361..4a014bb5ed0 100644
--- a/vortex-io/src/runtime/tokio.rs
+++ b/vortex-io/src/runtime/tokio.rs
@@ -95,23 +95,15 @@ struct CurrentTokioRuntime;
 
 impl Executor for CurrentTokioRuntime {
     fn spawn(&self, fut: BoxFuture<'static, ()>) -> AbortHandleRef {
-        Box::new(tokio::runtime::Handle::current().spawn(fut).abort_handle())
+        Executor::spawn(&tokio::runtime::Handle::current(), fut)
     }
 
     fn spawn_cpu(&self, cpu: Box<dyn FnOnce() + Send + 'static>) -> AbortHandleRef {
-        Box::new(
-            tokio::runtime::Handle::current()
-                .spawn(async move { cpu() })
-                .abort_handle(),
-        )
+        Executor::spawn_cpu(&tokio::runtime::Handle::current(), cpu)
     }
 
     fn spawn_blocking_io(&self, task: Box<dyn FnOnce() + Send + 'static>) -> AbortHandleRef {
-        Box::new(
-            tokio::runtime::Handle::current()
-                .spawn_blocking(task)
-                .abort_handle(),
-        )
+        Executor::spawn_blocking_io(&tokio::runtime::Handle::current(), task)
     }
 }
 
@@ -126,7 +118,7 @@ impl BlockingRuntime for TokioRuntime {
     type BlockingIterator<'a, R: 'a> = TokioBlockingIterator<'a, R>;
 
     fn handle(&self) -> Handle {
-        let executor: Arc<dyn Executor> = self.0.clone();
+        let executor: Arc<dyn Executor> = Arc::clone(&self.0) as Arc<dyn Executor>;
         Handle::new(Arc::downgrade(&executor))
     }
 
@@ -138,7 +130,7 @@ impl BlockingRuntime for TokioRuntime {
         if tokio::runtime::Handle::try_current().is_ok() {
             vortex_error::vortex_panic!("block_on cannot be called from within a Tokio runtime");
         }
-        let handle = self.0.clone();
+        let handle = Arc::clone(&self.0);
         tokio::task::block_in_place(move || handle.block_on(fut))
     }
 
@@ -153,19 +145,17 @@ impl BlockingRuntime for TokioRuntime {
                 "block_on_stream cannot be called from within a Tokio runtime"
             );
         }
-        let handle = self.0.clone();
+        let handle = Arc::clone(&self.0);
         let stream = Box::pin(stream);
         TokioBlockingIterator { handle, stream }
     }
 }
 
-#[cfg(feature = "tokio")]
 pub struct TokioBlockingIterator<'a, T> {
     handle: Arc<tokio::runtime::Handle>,
     stream: futures::stream::BoxStream<'a, T>,
 }
 
-#[cfg(feature = "tokio")]
 impl<T> Iterator for TokioBlockingIterator<'_, T> {
     type Item = T;
 
@@ -207,7 +197,7 @@ mod tests {
         let runtime = TokioRuntime::from(tokio_rt.handle());
 
         let counter = Arc::new(AtomicUsize::new(0));
-        let c = counter.clone();
+        let c = Arc::clone(&counter);
 
         // Create a channel to ensure the future doesn't complete immediately
         let (send, recv) = tokio::sync::oneshot::channel::<()>();
diff --git a/vortex-io/src/std_file/read_at.rs b/vortex-io/src/std_file/read_at.rs
index 887d7de0283..3d59a595f70 100644
--- a/vortex-io/src/std_file/read_at.rs
+++ b/vortex-io/src/std_file/read_at.rs
@@ -17,8 +17,9 @@ use std::sync::Arc;
 use futures::FutureExt;
 use futures::future::BoxFuture;
 use vortex_array::buffer::BufferHandle;
+use vortex_array::memory::DefaultHostAllocator;
+use vortex_array::memory::HostAllocatorRef;
 use vortex_buffer::Alignment;
-use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexResult;
 
 use crate::CoalesceConfig;
@@ -28,7 +29,7 @@ use crate::runtime::Handle;
 /// Read exactly `buffer.len()` bytes from `file` starting at `offset`.
 /// This is a platform-specific helper that uses the most efficient method available.
 #[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn read_exact_at(file: &File, buffer: &mut [u8], offset: u64) -> io::Result<()> {
+pub fn read_exact_at(file: &File, buffer: &mut [u8], offset: u64) -> io::Result<()> {
     #[cfg(unix)]
     {
         file.read_exact_at(buffer, offset)
@@ -57,10 +58,6 @@ pub(crate) fn read_exact_at(file: &File, buffer: &mut [u8], offset: u64) -> io::
     }
 }
 
-const COALESCING_CONFIG: CoalesceConfig = CoalesceConfig {
-    distance: 1024 * 1024,     // 1MB
-    max_size: 4 * 1024 * 1024, // 4MB
-};
 /// Default number of concurrent requests to allow for local file I/O.
 pub const DEFAULT_CONCURRENCY: usize = 32;
 
@@ -69,15 +66,30 @@ pub struct FileReadAt {
     uri: Arc<str>,
     file: Arc<File>,
     handle: Handle,
+    allocator: HostAllocatorRef,
 }
 
 impl FileReadAt {
     /// Open a file for reading.
     pub fn open(path: impl AsRef<Path>, handle: Handle) -> VortexResult<Self> {
+        Self::open_with_allocator(path, handle, Arc::new(DefaultHostAllocator))
+    }
+
+    /// Open a file for reading using a custom writable buffer allocator.
+    pub fn open_with_allocator(
+        path: impl AsRef<Path>,
+        handle: Handle,
+        allocator: HostAllocatorRef,
+    ) -> VortexResult<Self> {
         let path = path.as_ref();
         let uri = path.to_string_lossy().to_string().into();
         let file = Arc::new(File::open(path)?);
-        Ok(Self { uri, file, handle })
+        Ok(Self {
+            uri,
+            file,
+            handle,
+            allocator,
+        })
     }
 }
 
@@ -87,7 +99,7 @@ impl VortexReadAt for FileReadAt {
     }
 
     fn coalesce_config(&self) -> Option<CoalesceConfig> {
-        Some(COALESCING_CONFIG)
+        Some(CoalesceConfig::file())
     }
 
     fn concurrency(&self) -> usize {
@@ -95,7 +107,7 @@ impl VortexReadAt for FileReadAt {
     }
 
     fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
-        let file = self.file.clone();
+        let file = Arc::clone(&self.file);
         async move {
             let metadata = file.metadata()?;
             Ok(metadata.len())
@@ -109,14 +121,14 @@ impl VortexReadAt for FileReadAt {
         length: usize,
         alignment: Alignment,
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
-        let file = self.file.clone();
+        let file = Arc::clone(&self.file);
         let handle = self.handle.clone();
+        let allocator = Arc::clone(&self.allocator);
         async move {
             handle
                 .spawn_blocking(move || {
-                    let mut buffer = ByteBufferMut::with_capacity_aligned(length, alignment);
-                    unsafe { buffer.set_len(length) };
-                    read_exact_at(&file, &mut buffer, offset)?;
+                    let mut buffer = allocator.allocate(length, alignment)?;
+                    read_exact_at(&file, buffer.as_mut_slice(), offset)?;
                     Ok(BufferHandle::new_host(buffer.freeze()))
                 })
                 .await
diff --git a/vortex-ipc/public-api.lock b/vortex-ipc/public-api.lock
index 553d4fb6b17..5eba6f17f38 100644
--- a/vortex-ipc/public-api.lock
+++ b/vortex-ipc/public-api.lock
@@ -22,7 +22,7 @@ pub fn vortex_ipc::iterator::SyncIPCReader<R>::try_new(read: R, session: &vortex
 
 impl<R: std::io::Read> core::iter::traits::iterator::Iterator for vortex_ipc::iterator::SyncIPCReader<R>
 
-pub type vortex_ipc::iterator::SyncIPCReader<R>::Item = core::result::Result<alloc::sync::Arc<dyn vortex_array::array::Array>, vortex_error::VortexError>
+pub type vortex_ipc::iterator::SyncIPCReader<R>::Item = core::result::Result<vortex_array::array::erased::ArrayRef, vortex_error::VortexError>
 
 pub fn vortex_ipc::iterator::SyncIPCReader<R>::next(&mut self) -> core::option::Option<Self::Item>
 
@@ -32,21 +32,21 @@ pub fn vortex_ipc::iterator::SyncIPCReader<R>::dtype(&self) -> &vortex_array::dt
 
 pub trait vortex_ipc::iterator::ArrayIteratorIPC
 
-pub fn vortex_ipc::iterator::ArrayIteratorIPC::into_ipc(self) -> vortex_error::VortexResult<vortex_ipc::iterator::ArrayIteratorIPCBytes> where Self: core::marker::Sized
+pub fn vortex_ipc::iterator::ArrayIteratorIPC::into_ipc(self, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_ipc::iterator::ArrayIteratorIPCBytes> where Self: core::marker::Sized
 
-pub fn vortex_ipc::iterator::ArrayIteratorIPC::write_ipc<W: std::io::Write>(self, write: W) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
+pub fn vortex_ipc::iterator::ArrayIteratorIPC::write_ipc<W: std::io::Write>(self, write: W, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
 
 impl<I: vortex_array::iter::ArrayIterator + 'static> vortex_ipc::iterator::ArrayIteratorIPC for I
 
-pub fn I::into_ipc(self) -> vortex_error::VortexResult<vortex_ipc::iterator::ArrayIteratorIPCBytes> where Self: core::marker::Sized
+pub fn I::into_ipc(self, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_ipc::iterator::ArrayIteratorIPCBytes> where Self: core::marker::Sized
 
-pub fn I::write_ipc<W: std::io::Write>(self, write: W) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
+pub fn I::write_ipc<W: std::io::Write>(self, write: W, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
 
 pub mod vortex_ipc::messages
 
 pub enum vortex_ipc::messages::DecoderMessage
 
-pub vortex_ipc::messages::DecoderMessage::Array((vortex_array::serde::ArrayParts, vortex_array::context::ArrayContext, usize))
+pub vortex_ipc::messages::DecoderMessage::Array((vortex_array::serde::SerializedArray, vortex_session::registry::ReadContext, usize))
 
 pub vortex_ipc::messages::DecoderMessage::Buffer(vortex_buffer::ByteBuffer)
 
@@ -58,7 +58,7 @@ pub fn vortex_ipc::messages::DecoderMessage::fmt(&self, f: &mut core::fmt::Forma
 
 pub enum vortex_ipc::messages::EncoderMessage<'a>
 
-pub vortex_ipc::messages::EncoderMessage::Array(&'a dyn vortex_array::array::Array)
+pub vortex_ipc::messages::EncoderMessage::Array(&'a vortex_array::array::erased::ArrayRef)
 
 pub vortex_ipc::messages::EncoderMessage::Buffer(&'a vortex_buffer::ByteBuffer)
 
@@ -96,7 +96,7 @@ pub fn vortex_ipc::messages::AsyncMessageWriter<W>::inner(&self) -> &W
 
 pub fn vortex_ipc::messages::AsyncMessageWriter<W>::into_inner(self) -> W
 
-pub fn vortex_ipc::messages::AsyncMessageWriter<W>::new(write: W) -> Self
+pub fn vortex_ipc::messages::AsyncMessageWriter<W>::new(write: W, session: &vortex_session::VortexSession) -> Self
 
 pub async fn vortex_ipc::messages::AsyncMessageWriter<W>::write_message(&mut self, message: vortex_ipc::messages::EncoderMessage<'_>) -> vortex_error::VortexResult<()>
 
@@ -128,9 +128,7 @@ impl vortex_ipc::messages::MessageEncoder
 
 pub fn vortex_ipc::messages::MessageEncoder::encode(&mut self, message: vortex_ipc::messages::EncoderMessage<'_>) -> vortex_error::VortexResult<alloc::vec::Vec<bytes::bytes::Bytes>>
 
-impl core::default::Default for vortex_ipc::messages::MessageEncoder
-
-pub fn vortex_ipc::messages::MessageEncoder::default() -> Self
+pub fn vortex_ipc::messages::MessageEncoder::new(session: vortex_session::VortexSession) -> Self
 
 pub struct vortex_ipc::messages::SyncMessageReader<R>
 
@@ -148,7 +146,7 @@ pub struct vortex_ipc::messages::SyncMessageWriter<W>
 
 impl<W: std::io::Write> vortex_ipc::messages::SyncMessageWriter<W>
 
-pub fn vortex_ipc::messages::SyncMessageWriter<W>::new(write: W) -> Self
+pub fn vortex_ipc::messages::SyncMessageWriter<W>::new(write: W, session: &vortex_session::VortexSession) -> Self
 
 pub fn vortex_ipc::messages::SyncMessageWriter<W>::write_message(&mut self, message: vortex_ipc::messages::EncoderMessage<'_>) -> vortex_error::VortexResult<()>
 
@@ -176,7 +174,7 @@ impl<'__pin, R> core::marker::Unpin for vortex_ipc::stream::AsyncIPCReader<R> wh
 
 impl<R: futures_io::if_std::AsyncRead> futures_core::stream::Stream for vortex_ipc::stream::AsyncIPCReader<R>
 
-pub type vortex_ipc::stream::AsyncIPCReader<R>::Item = core::result::Result<alloc::sync::Arc<dyn vortex_array::array::Array>, vortex_error::VortexError>
+pub type vortex_ipc::stream::AsyncIPCReader<R>::Item = core::result::Result<vortex_array::array::erased::ArrayRef, vortex_error::VortexError>
 
 pub fn vortex_ipc::stream::AsyncIPCReader<R>::poll_next(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<core::option::Option<Self::Item>>
 
@@ -186,12 +184,12 @@ pub fn vortex_ipc::stream::AsyncIPCReader<R>::dtype(&self) -> &vortex_array::dty
 
 pub trait vortex_ipc::stream::ArrayStreamIPC
 
-pub fn vortex_ipc::stream::ArrayStreamIPC::into_ipc(self) -> vortex_ipc::stream::ArrayStreamIPCBytes where Self: core::marker::Sized
+pub fn vortex_ipc::stream::ArrayStreamIPC::into_ipc(self, session: &vortex_session::VortexSession) -> vortex_ipc::stream::ArrayStreamIPCBytes where Self: core::marker::Sized
 
-pub fn vortex_ipc::stream::ArrayStreamIPC::write_ipc<W: futures_io::if_std::AsyncWrite + core::marker::Unpin>(self, write: W) -> impl core::future::future::Future<Output = vortex_error::VortexResult<W>> where Self: core::marker::Sized
+pub fn vortex_ipc::stream::ArrayStreamIPC::write_ipc<W: futures_io::if_std::AsyncWrite + core::marker::Unpin>(self, write: W, session: &vortex_session::VortexSession) -> impl core::future::future::Future<Output = vortex_error::VortexResult<W>> where Self: core::marker::Sized
 
 impl<S: vortex_array::stream::ArrayStream + 'static> vortex_ipc::stream::ArrayStreamIPC for S
 
-pub fn S::into_ipc(self) -> vortex_ipc::stream::ArrayStreamIPCBytes where Self: core::marker::Sized
+pub fn S::into_ipc(self, session: &vortex_session::VortexSession) -> vortex_ipc::stream::ArrayStreamIPCBytes where Self: core::marker::Sized
 
-pub async fn S::write_ipc<W: futures_io::if_std::AsyncWrite + core::marker::Unpin>(self, write: W) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
+pub async fn S::write_ipc<W: futures_io::if_std::AsyncWrite + core::marker::Unpin>(self, write: W, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<W> where Self: core::marker::Sized
diff --git a/vortex-ipc/src/iterator.rs b/vortex-ipc/src/iterator.rs
index a6765d57ed8..318d062127c 100644
--- a/vortex-ipc/src/iterator.rs
+++ b/vortex-ipc/src/iterator.rs
@@ -85,21 +85,21 @@ impl<R: Read> Iterator for SyncIPCReader<R> {
 
 /// A trait for converting an [`ArrayIterator`] into an IPC stream.
 pub trait ArrayIteratorIPC {
-    fn into_ipc(self) -> VortexResult<ArrayIteratorIPCBytes>
+    fn into_ipc(self, session: &VortexSession) -> VortexResult<ArrayIteratorIPCBytes>
     where
         Self: Sized;
 
-    fn write_ipc<W: Write>(self, write: W) -> VortexResult<W>
+    fn write_ipc<W: Write>(self, write: W, session: &VortexSession) -> VortexResult<W>
     where
         Self: Sized;
 }
 
 impl<I: ArrayIterator + 'static> ArrayIteratorIPC for I {
-    fn into_ipc(self) -> VortexResult<ArrayIteratorIPCBytes>
+    fn into_ipc(self, session: &VortexSession) -> VortexResult<ArrayIteratorIPCBytes>
     where
         Self: Sized,
     {
-        let mut encoder = MessageEncoder::default();
+        let mut encoder = MessageEncoder::new(session.clone());
         let buffers = encoder.encode(EncoderMessage::DType(self.dtype()))?;
         Ok(ArrayIteratorIPCBytes {
             inner: Box::new(self),
@@ -108,11 +108,11 @@ impl<I: ArrayIterator + 'static> ArrayIteratorIPC for I {
         })
     }
 
-    fn write_ipc<W: Write>(self, mut write: W) -> VortexResult<W>
+    fn write_ipc<W: Write>(self, mut write: W, session: &VortexSession) -> VortexResult<W>
     where
         Self: Sized,
     {
-        let mut stream = self.into_ipc()?;
+        let mut stream = self.into_ipc(session)?;
         for buffer in &mut stream {
             write.write_all(buffer?.as_ref())?;
         }
@@ -183,7 +183,10 @@ mod test {
     #[test]
     fn test_sync_stream() -> VortexResult<()> {
         let array = buffer![1i32, 2, 3].into_array();
-        let ipc_buffer = array.to_array_iterator().into_ipc()?.collect_to_buffer()?;
+        let ipc_buffer = array
+            .to_array_iterator()
+            .into_ipc(&SESSION)?
+            .collect_to_buffer()?;
 
         let reader = SyncIPCReader::try_new(Cursor::new(ipc_buffer), &SESSION)?;
 
diff --git a/vortex-ipc/src/messages/decoder.rs b/vortex-ipc/src/messages/decoder.rs
index 5b949a4ccbb..d5f2cce336d 100644
--- a/vortex-ipc/src/messages/decoder.rs
+++ b/vortex-ipc/src/messages/decoder.rs
@@ -7,9 +7,8 @@ use std::sync::Arc;
 use bytes::Buf;
 use flatbuffers::root;
 use flatbuffers::root_unchecked;
-use vortex_array::ArrayContext;
-use vortex_array::serde::ArrayParts;
-use vortex_array::vtable::ArrayId;
+use vortex_array::ArrayId;
+use vortex_array::serde::SerializedArray;
 use vortex_buffer::AlignedBuf;
 use vortex_buffer::Alignment;
 use vortex_buffer::ByteBuffer;
@@ -21,11 +20,12 @@ use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::message as fb;
 use vortex_flatbuffers::message::MessageHeader;
 use vortex_flatbuffers::message::MessageVersion;
+use vortex_session::registry::ReadContext;
 
 /// A message decoded from an IPC stream.
 #[derive(Debug)]
 pub enum DecoderMessage {
-    Array((ArrayParts, ArrayContext, usize)),
+    Array((SerializedArray, ReadContext, usize)),
     Buffer(ByteBuffer),
     DType(FlatBuffer),
 }
@@ -115,20 +115,20 @@ impl MessageDecoder {
                         MessageHeader::ArrayMessage => {
                             // We don't care about alignment here since ArrayParts will handle it.
                             let body = bytes.copy_to_aligned(body_length, Alignment::new(1));
-                            let parts = ArrayParts::try_from(body)?;
+                            let parts = SerializedArray::try_from(body)?;
 
                             let header = msg
                                 .header_as_array_message()
                                 .vortex_expect("header is array");
 
-                            let encoding_ids: Vec<_> = header
+                            let encoding_ids: Arc<_> = header
                                 .encodings()
                                 .iter()
                                 .flat_map(|e| e.iter())
                                 .map(|id| ArrayId::new_arc(Arc::from(id.to_string())))
                                 .collect();
 
-                            let ctx = ArrayContext::new(encoding_ids);
+                            let ctx = ReadContext::new(encoding_ids);
                             let row_count = header.row_count() as usize;
 
                             self.state = Default::default();
@@ -167,7 +167,7 @@ impl MessageDecoder {
 #[cfg(test)]
 mod test {
     use bytes::BytesMut;
-    use vortex_array::Array;
+    use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::arrays::ConstantArray;
     use vortex_buffer::buffer;
@@ -178,9 +178,9 @@ mod test {
     use crate::messages::MessageEncoder;
     use crate::test::SESSION;
 
-    fn write_and_read(expected: &dyn Array) {
+    fn write_and_read(expected: &ArrayRef) {
         let mut ipc_bytes = BytesMut::new();
-        let mut encoder = MessageEncoder::default();
+        let mut encoder = MessageEncoder::new(SESSION.clone());
         for buf in encoder.encode(EncoderMessage::Array(expected)).unwrap() {
             ipc_bytes.extend_from_slice(buf.as_ref());
         }
@@ -213,6 +213,6 @@ mod test {
         // Constant arrays have a single buffer
         let array = ConstantArray::new(10i32, 20);
         assert_eq!(array.nbuffers(), 1, "Array should have a single buffer");
-        write_and_read(array.as_ref());
+        write_and_read(&array.into_array());
     }
 }
diff --git a/vortex-ipc/src/messages/encoder.rs b/vortex-ipc/src/messages/encoder.rs
index ce615498c93..c4372b3cdd9 100644
--- a/vortex-ipc/src/messages/encoder.rs
+++ b/vortex-ipc/src/messages/encoder.rs
@@ -4,8 +4,8 @@
 use bytes::Bytes;
 use bytes::BytesMut;
 use flatbuffers::FlatBufferBuilder;
-use vortex_array::Array;
 use vortex_array::ArrayContext;
+use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::serde::SerializeOptions;
 use vortex_buffer::ByteBuffer;
@@ -14,10 +14,11 @@ use vortex_error::vortex_err;
 use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::WriteFlatBufferExt;
 use vortex_flatbuffers::message as fb;
+use vortex_session::VortexSession;
 
 /// An IPC message ready to be passed to the encoder.
 pub enum EncoderMessage<'a> {
-    Array(&'a dyn Array),
+    Array(&'a ArrayRef),
     Buffer(&'a ByteBuffer),
     DType(&'a DType),
 }
@@ -25,17 +26,17 @@ pub enum EncoderMessage<'a> {
 pub struct MessageEncoder {
     /// A reusable buffer of zeros used for padding.
     zeros: Bytes,
+    session: VortexSession,
 }
 
-impl Default for MessageEncoder {
-    fn default() -> Self {
+impl MessageEncoder {
+    pub fn new(session: VortexSession) -> Self {
         Self {
+            session,
             zeros: BytesMut::zeroed(u16::MAX as usize).freeze(),
         }
     }
-}
 
-impl MessageEncoder {
     /// Encode an IPC message for writing to a byte stream.
     ///
     /// The returned buffers should be written contiguously to the stream.
@@ -59,7 +60,8 @@ impl MessageEncoder {
                 // sending deltas later.
                 let ctx = ArrayContext::empty();
 
-                let array_buffers = array.serialize(&ctx, &SerializeOptions::default())?;
+                let array_buffers =
+                    array.serialize(&ctx, &self.session, &SerializeOptions::default())?;
                 let body_len = array_buffers.iter().map(|b| b.len() as u64).sum::<u64>();
 
                 let array_encodings = ctx
diff --git a/vortex-ipc/src/messages/writer_async.rs b/vortex-ipc/src/messages/writer_async.rs
index ca3cf9b6f77..39b0434ee72 100644
--- a/vortex-ipc/src/messages/writer_async.rs
+++ b/vortex-ipc/src/messages/writer_async.rs
@@ -4,6 +4,7 @@
 use futures::AsyncWrite;
 use futures::AsyncWriteExt;
 use vortex_error::VortexResult;
+use vortex_session::VortexSession;
 
 use crate::messages::EncoderMessage;
 use crate::messages::MessageEncoder;
@@ -14,10 +15,10 @@ pub struct AsyncMessageWriter<W> {
 }
 
 impl<W: AsyncWrite + Unpin> AsyncMessageWriter<W> {
-    pub fn new(write: W) -> Self {
+    pub fn new(write: W, session: &VortexSession) -> Self {
         Self {
             write,
-            encoder: MessageEncoder::default(),
+            encoder: MessageEncoder::new(session.clone()),
         }
     }
 
diff --git a/vortex-ipc/src/messages/writer_sync.rs b/vortex-ipc/src/messages/writer_sync.rs
index 0c3ae72565d..30309e08a1d 100644
--- a/vortex-ipc/src/messages/writer_sync.rs
+++ b/vortex-ipc/src/messages/writer_sync.rs
@@ -4,6 +4,7 @@
 use std::io::Write;
 
 use vortex_error::VortexResult;
+use vortex_session::VortexSession;
 
 use crate::messages::EncoderMessage;
 use crate::messages::MessageEncoder;
@@ -14,10 +15,10 @@ pub struct SyncMessageWriter<W> {
 }
 
 impl<W: Write> SyncMessageWriter<W> {
-    pub fn new(write: W) -> Self {
+    pub fn new(write: W, session: &VortexSession) -> Self {
         Self {
             write,
-            encoder: MessageEncoder::default(),
+            encoder: MessageEncoder::new(session.clone()),
         }
     }
 
diff --git a/vortex-ipc/src/stream.rs b/vortex-ipc/src/stream.rs
index 69bea062cc4..8b6d9f69e3e 100644
--- a/vortex-ipc/src/stream.rs
+++ b/vortex-ipc/src/stream.rs
@@ -107,33 +107,41 @@ impl<R: AsyncRead> Stream for AsyncIPCReader<R> {
 
 /// A trait for converting an [`ArrayStream`] into IPC streams.
 pub trait ArrayStreamIPC {
-    fn into_ipc(self) -> ArrayStreamIPCBytes
+    fn into_ipc(self, session: &VortexSession) -> ArrayStreamIPCBytes
     where
         Self: Sized;
 
-    fn write_ipc<W: AsyncWrite + Unpin>(self, write: W) -> impl Future<Output = VortexResult<W>>
+    fn write_ipc<W: AsyncWrite + Unpin>(
+        self,
+        write: W,
+        session: &VortexSession,
+    ) -> impl Future<Output = VortexResult<W>>
     where
         Self: Sized;
 }
 
 impl<S: ArrayStream + 'static> ArrayStreamIPC for S {
-    fn into_ipc(self) -> ArrayStreamIPCBytes
+    fn into_ipc(self, session: &VortexSession) -> ArrayStreamIPCBytes
     where
         Self: Sized,
     {
         ArrayStreamIPCBytes {
             stream: Box::pin(self),
-            encoder: MessageEncoder::default(),
+            encoder: MessageEncoder::new(session.clone()),
             buffers: vec![],
             written_dtype: false,
         }
     }
 
-    async fn write_ipc<W: AsyncWrite + Unpin>(self, mut write: W) -> VortexResult<W>
+    async fn write_ipc<W: AsyncWrite + Unpin>(
+        self,
+        mut write: W,
+        session: &VortexSession,
+    ) -> VortexResult<W>
     where
         Self: Sized,
     {
-        let mut stream = self.into_ipc();
+        let mut stream = self.into_ipc(session);
         while let Some(chunk) = stream.next().await {
             write.write_all(&chunk?).await?;
         }
@@ -230,7 +238,7 @@ mod test {
         let array = buffer![1, 2, 3].into_array();
         let ipc_buffer = array
             .to_array_stream()
-            .into_ipc()
+            .into_ipc(&SESSION)
             .collect_to_buffer()
             .await
             .unwrap();
@@ -266,7 +274,7 @@ mod test {
         let array = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_array();
         let ipc_buffer = array
             .to_array_stream()
-            .into_ipc()
+            .into_ipc(&SESSION)
             .collect_to_buffer()
             .await
             .unwrap();
@@ -289,7 +297,7 @@ mod test {
         let array = buffer![42i64, -1, 0, i64::MAX, i64::MIN].into_array();
         let ipc_buffer = array
             .to_array_stream()
-            .into_ipc()
+            .into_ipc(&SESSION)
             .collect_to_buffer()
             .await
             .unwrap();
diff --git a/vortex-jni/src/array.rs b/vortex-jni/src/array.rs
index c1a3abf91be..c45f232b920 100644
--- a/vortex-jni/src/array.rs
+++ b/vortex-jni/src/array.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use arrow_array::ffi::FFI_ArrowArray;
 use arrow_array::ffi::FFI_ArrowSchema;
 use arrow_schema::DataType;
@@ -24,11 +26,14 @@ use jni::sys::jlong;
 use jni::sys::jobject;
 use jni::sys::jshort;
 use jni::sys::jstring;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
+use vortex::array::ArrayView;
 use vortex::array::ToCanonical;
-use vortex::array::arrays::VarBinArray;
-use vortex::array::arrays::VarBinViewArray;
+use vortex::array::arrays::VarBin;
+use vortex::array::arrays::VarBinView;
+use vortex::array::arrays::extension::ExtensionArrayExt;
+use vortex::array::arrays::struct_::StructArrayExt;
+use vortex::array::arrays::varbin::VarBinArrayExt;
 use vortex::array::arrow::IntoArrowArray;
 use vortex::dtype::DType;
 use vortex::dtype::i256;
@@ -148,7 +153,7 @@ fn data_type_no_views(data_type: DataType) -> DataType {
             let viewless_fields: Vec<FieldRef> = fields
                 .iter()
                 .map(|field_ref| {
-                    let field = (*field_ref.clone()).clone();
+                    let field = (*Arc::clone(field_ref)).clone();
                     let data_type = field.data_type().clone();
                     let field = field.with_data_type(data_type_no_views(data_type));
                     FieldRef::new(field)
@@ -158,7 +163,12 @@ fn data_type_no_views(data_type: DataType) -> DataType {
         }
         DataType::Decimal128(precision, scale) => DataType::Decimal128(precision, scale),
         DataType::Decimal256(precision, scale) => DataType::Decimal256(precision, scale),
-        DataType::FixedSizeList(..) => unreachable!("Vortex never returns FixedSizeList"),
+        DataType::FixedSizeList(inner, size) => {
+            let new_inner = (*inner)
+                .clone()
+                .with_data_type(data_type_no_views(inner.data_type().clone()));
+            DataType::FixedSizeList(FieldRef::new(new_inner), size)
+        }
         DataType::Union(..) => unreachable!("Vortex never returns Union"),
         DataType::Dictionary(..) => unreachable!("Vortex never returns Dictionary"),
         DataType::Map(..) => unreachable!("Vortex never returns Map"),
@@ -222,13 +232,12 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_getField(
     let array_ref = unsafe { NativeArray::from_ptr(array_ptr) };
 
     try_or_throw(&mut env, |_| {
-        let field = array_ref
-            .inner
-            .to_struct()
-            .unmasked_fields()
-            .get(index as usize)
-            .cloned()
-            .ok_or_else(|| vortex_err!("Field index out of bounds"))?;
+        let struct_array = array_ref.inner.to_struct();
+        let idx = index as usize;
+        if idx >= struct_array.struct_fields().nfields() {
+            return Err(vortex_err!("Field index out of bounds").into());
+        }
+        let field = struct_array.unmasked_field(idx).clone();
         Ok(NativeArray::new(field).into_raw())
     })
 }
@@ -244,10 +253,7 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_slice(
     let array_ref = unsafe { NativeArray::from_ptr(array_ptr) };
 
     try_or_throw(&mut env, |_| {
-        let sliced_array = array_ref
-            .inner
-            .as_ref()
-            .slice(start as usize..end as usize)?;
+        let sliced_array = array_ref.inner.slice(start as usize..end as usize)?;
         Ok(NativeArray::new(sliced_array).into_raw())
     })
 }
@@ -294,7 +300,7 @@ macro_rules! get_primitive {
                     array_ref
                         .inner
                         .to_extension()
-                        .storage()
+                        .storage_array()
                         .scalar_at(index as usize)?
                 } else {
                     array_ref.inner.scalar_at(index as usize)?
@@ -333,7 +339,7 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_getBigDecimal(
             array_ref
                 .inner
                 .to_extension()
-                .storage()
+                .storage_array()
                 .scalar_at(index as usize)?
         } else {
             array_ref.inner.scalar_at(index as usize)?
@@ -445,12 +451,11 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_getUTF8_1ptr_1len<
             throw_runtime!("getUTF8_ptr_len expected UTF8 array");
         }
 
-        if let Some(varbin) = array_ref.inner.as_any().downcast_ref::<VarBinArray>() {
+        if let Some(varbin) = array_ref.inner.as_opt::<VarBin>() {
             let (ptr, len) = get_ptr_len_varbin(index, varbin);
             env.set_long_array_region(&out_ptr, 0, &[ptr as jlong])?;
             env.set_int_array_region(&out_len, 0, &[len as jint])?;
-        } else if let Some(varbinview) = array_ref.inner.as_any().downcast_ref::<VarBinViewArray>()
-        {
+        } else if let Some(varbinview) = array_ref.inner.as_opt::<VarBinView>() {
             let (ptr, len) = get_ptr_len_view(index, varbinview);
             env.set_long_array_region(&out_ptr, 0, &[ptr as jlong])?;
             env.set_int_array_region(&out_len, 0, &[len as jint])?;
@@ -481,7 +486,7 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_getBinary<'local>(
 /// Get a raw pointer + len to pass back to Java to avoid copying across the boundary.
 ///
 /// Panics if the index is out of bounds.
-fn get_ptr_len_varbin(index: jint, array: &VarBinArray) -> (*const u8, u32) {
+fn get_ptr_len_varbin(index: jint, array: ArrayView<VarBin>) -> (*const u8, u32) {
     // TODO: propagate this error up instead of expecting
     let bytes = array.bytes_at(usize::try_from(index).vortex_expect("index must fit in usize"));
     (
@@ -492,7 +497,7 @@ fn get_ptr_len_varbin(index: jint, array: &VarBinArray) -> (*const u8, u32) {
 }
 
 /// Get a raw pointer + len to pass back to Java to avoid copying across the boundary.
-fn get_ptr_len_view(index: jint, array: &VarBinViewArray) -> (*const u8, u32) {
+fn get_ptr_len_view(index: jint, array: ArrayView<VarBinView>) -> (*const u8, u32) {
     // TODO: propagate this error up instead of expecting
     let bytes = array.bytes_at(usize::try_from(index).vortex_expect("index must fit in usize"));
     (
diff --git a/vortex-jni/src/dtype.rs b/vortex-jni/src/dtype.rs
index 8830064b8cd..3c8666127ae 100644
--- a/vortex-jni/src/dtype.rs
+++ b/vortex-jni/src/dtype.rs
@@ -52,6 +52,7 @@ pub const DTYPE_STRUCT: jbyte = 15;
 pub const DTYPE_LIST: jbyte = 16;
 pub const DTYPE_EXTENSION: jbyte = 17;
 pub const DTYPE_DECIMAL: jbyte = 18;
+pub const DTYPE_FIXED_SIZE_LIST: jbyte = 19;
 
 static LONG_CLASS: &str = "java/lang/Long";
 
@@ -94,10 +95,9 @@ pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_getVariant(
         DType::Binary(_) => DTYPE_BINARY,
         DType::Struct(..) => DTYPE_STRUCT,
         DType::List(..) => DTYPE_LIST,
-        DType::FixedSizeList(..) => {
-            unimplemented!("TODO(connor)[FixedSizeList]")
-        }
+        DType::FixedSizeList(..) => DTYPE_FIXED_SIZE_LIST,
         DType::Extension(_) => DTYPE_EXTENSION,
+        DType::Variant(_) => unimplemented!("Variant DType is not supported in JNI yet"),
     }
 }
 
@@ -183,8 +183,11 @@ pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_getElementType(
     let dtype = unsafe { &*(dtype_ptr as *const DType) };
 
     try_or_throw(&mut env, |_| {
-        let Some(element_type) = dtype.as_list_element_opt() else {
-            throw_runtime!("DType should be LIST, was {dtype}");
+        let element_type = dtype
+            .as_list_element_opt()
+            .or_else(|| dtype.as_fixed_size_list_element_opt());
+        let Some(element_type) = element_type else {
+            throw_runtime!("DType should be LIST or FIXED_SIZE_LIST, was {dtype}");
         };
 
         Ok(element_type.as_ref() as *const DType as jlong)
@@ -505,6 +508,41 @@ pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_newList(
     Box::into_raw(Box::new(list_type)) as jlong
 }
 
+/// FixedSizeList constructor
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_newFixedSizeList(
+    _env: JNIEnv,
+    _class: JClass,
+    element_ptr: jlong,
+    size: jint,
+    is_nullable: jboolean,
+) -> jlong {
+    let element_dtype = unsafe { *Box::from_raw(element_ptr as *mut DType) };
+    let element_dtype = Arc::new(element_dtype);
+
+    let fsl_type = DType::FixedSizeList(element_dtype, size as u32, to_nullability(is_nullable));
+
+    Box::into_raw(Box::new(fsl_type)) as jlong
+}
+
+/// Get the fixed size of a FixedSizeList DType.
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_getFixedSizeListSize(
+    mut env: JNIEnv,
+    _class: JClass,
+    dtype_ptr: jlong,
+) -> jint {
+    let dtype = unsafe { &*(dtype_ptr as *const DType) };
+
+    try_or_throw(&mut env, |_| {
+        let DType::FixedSizeList(_, size, _) = dtype else {
+            throw_runtime!("DType should be FIXED_SIZE_LIST, was {dtype}");
+        };
+
+        Ok(*size as jint)
+    })
+}
+
 /// Struct constructor
 #[unsafe(no_mangle)]
 pub extern "system" fn Java_dev_vortex_jni_NativeDTypeMethods_newStruct<'local>(
diff --git a/vortex-jni/src/errors.rs b/vortex-jni/src/errors.rs
index f7a7a191443..166fb06fe92 100644
--- a/vortex-jni/src/errors.rs
+++ b/vortex-jni/src/errors.rs
@@ -83,7 +83,6 @@ impl JNIDefault for jobject {
     clippy::expect_used,
     reason = "JNI operations must succeed for proper error handling"
 )]
-#[inline]
 pub fn try_or_throw<'a, F, T>(env: &mut JNIEnv<'a>, function: F) -> T
 where
     F: FnOnce(&mut JNIEnv<'a>) -> Result<T, JNIError>,
diff --git a/vortex-jni/src/file.rs b/vortex-jni/src/file.rs
index 2ab70aa5e85..a492a25a6a0 100644
--- a/vortex-jni/src/file.rs
+++ b/vortex-jni/src/file.rs
@@ -15,6 +15,7 @@ use jni::objects::ReleaseMode;
 use jni::sys::jlong;
 use jni::sys::jobject;
 use object_store::ObjectStore;
+use object_store::ObjectStoreExt;
 use object_store::path::Path;
 use prost::Message;
 use url::Url;
diff --git a/vortex-jni/src/object_store.rs b/vortex-jni/src/object_store.rs
index 53da2322df0..d982fd3ab29 100644
--- a/vortex-jni/src/object_store.rs
+++ b/vortex-jni/src/object_store.rs
@@ -36,11 +36,11 @@ pub(crate) fn make_object_store(
     let (scheme, _) = ObjectStoreScheme::parse(url)
         .map_err(|error| VortexError::from(object_store::Error::from(error)))?;
 
-    let cache_key = url_cache_key(url);
+    let cache_key = url_cache_key(url, properties);
 
     {
         if let Some(cached) = OBJECT_STORES.lock().get(&cache_key) {
-            return Ok((cached.clone(), scheme));
+            return Ok((Arc::clone(cached), scheme));
         }
         // guard dropped at close of scope
     }
@@ -57,7 +57,10 @@ pub(crate) fn make_object_store(
                 .with_url(url.to_string())
                 // Use generic S3 endpoint to avoid DNS resolution issues with region-specific endpoints
                 .with_endpoint("https://s3.amazonaws.com")
-                .with_virtual_hosted_style_request(false); // Use path-style URLs
+                // Use path-style URLs
+                .with_virtual_hosted_style_request(false)
+                // Allow user to override endpoint to HTTP endpoints, e.g. LocalStack, Minio
+                .with_allow_http(true);
 
             // Try to load credentials from environment if not provided in properties
             if !properties.contains_key("access_key_id")
@@ -126,7 +129,7 @@ pub(crate) fn make_object_store(
     };
 
     {
-        OBJECT_STORES.lock().insert(cache_key, store.clone());
+        OBJECT_STORES.lock().insert(cache_key, Arc::clone(&store));
         // Guard dropped at close of scope.
     }
 
@@ -136,10 +139,19 @@ pub(crate) fn make_object_store(
     Ok((store, scheme))
 }
 
-fn url_cache_key(url: &Url) -> String {
+fn url_cache_key(url: &Url, properties: &HashMap<String, String>) -> String {
+    let mut sorted_props: Vec<_> = properties.iter().collect();
+    sorted_props.sort_by_key(|(k, _)| *k);
+
+    let props_str: String = sorted_props
+        .iter()
+        .map(|(k, v)| format!("{k}={v}"))
+        .collect::<Vec<_>>()
+        .join(",");
     format!(
-        "{}://{}",
+        "{}://{};{}",
         url.scheme(),
         &url[url::Position::BeforeHost..url::Position::AfterPort],
+        props_str,
     )
 }
diff --git a/vortex-jni/src/writer.rs b/vortex-jni/src/writer.rs
index 4b341426c1f..45d33d9ef70 100644
--- a/vortex-jni/src/writer.rs
+++ b/vortex-jni/src/writer.rs
@@ -4,6 +4,9 @@
 use std::io::Cursor;
 
 use arrow_array::RecordBatch;
+use arrow_array::StructArray;
+use arrow_array::ffi::FFI_ArrowArray;
+use arrow_array::ffi::FFI_ArrowSchema;
 use arrow_ipc::reader::StreamReader;
 use futures::SinkExt;
 use futures::channel::mpsc;
@@ -18,7 +21,6 @@ use jni::sys::jboolean;
 use jni::sys::jlong;
 use object_store::path::Path;
 use url::Url;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::arrow::FromArrowArray;
 use vortex::array::stream::ArrayStreamAdapter;
@@ -226,6 +228,40 @@ pub extern "system" fn Java_dev_vortex_jni_NativeWriterMethods_writeBatch<'local
     })
 }
 
+/// Writes a batch to the Vortex file directly from Arrow C Data Interface pointers.
+///
+/// This avoids the IPC serialization/deserialization overhead of `writeBatch` by accepting
+/// raw Arrow FFI pointers directly.
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_dev_vortex_jni_NativeWriterMethods_writeBatchFfi<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    writer_ptr: jlong,
+    arrow_array_addr: jlong,
+    arrow_schema_addr: jlong,
+) -> jboolean {
+    if writer_ptr <= 0 {
+        return JNI_FALSE;
+    }
+
+    try_or_throw(&mut env, |_env| {
+        let writer = unsafe { NativeWriter::from_ptr(writer_ptr) };
+
+        // Reconstruct FFI structs from the raw pointers provided by Java.
+        let ffi_array =
+            unsafe { FFI_ArrowArray::from_raw(arrow_array_addr as *mut FFI_ArrowArray) };
+        let ffi_schema = unsafe { &*(arrow_schema_addr as *const FFI_ArrowSchema) };
+
+        let array_data = unsafe { arrow_array::ffi::from_ffi(ffi_array, ffi_schema) }
+            .map_err(|e| JNIError::Vortex(vortex_err!("Failed to import Arrow FFI data: {}", e)))?;
+
+        let batch = RecordBatch::from(StructArray::from(array_data));
+        writer.write_record_batch(batch)?;
+
+        Ok(JNI_TRUE)
+    })
+}
+
 /// Closes the writer
 #[unsafe(no_mangle)]
 pub extern "system" fn Java_dev_vortex_jni_NativeWriterMethods_close<'local>(
diff --git a/vortex-layout/Cargo.toml b/vortex-layout/Cargo.toml
index e7b66a9bd43..8bbccf09b91 100644
--- a/vortex-layout/Cargo.toml
+++ b/vortex-layout/Cargo.toml
@@ -18,8 +18,11 @@ all-features = true
 
 [dependencies]
 arcref = { workspace = true }
+arrow-array = { workspace = true }
+arrow-schema = { workspace = true }
 async-stream = { workspace = true }
 async-trait = { workspace = true }
+bit-vec = { workspace = true }
 flatbuffers = { workspace = true }
 futures = { workspace = true, features = ["alloc", "async-await", "executor"] }
 itertools = { workspace = true }
@@ -32,10 +35,10 @@ paste = { workspace = true }
 pin-project-lite = { workspace = true }
 prost = { workspace = true }
 rustc-hash = { workspace = true }
+sketches-ddsketch = { workspace = true }
 termtree = { workspace = true }
 tokio = { workspace = true, features = ["rt"], optional = true }
 tracing = { workspace = true }
-uuid = { workspace = true }
 vortex-array = { workspace = true }
 vortex-btrblocks = { workspace = true }
 vortex-buffer = { workspace = true }
@@ -44,6 +47,7 @@ vortex-flatbuffers = { workspace = true, features = ["layout"] }
 vortex-io = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-metrics = { workspace = true }
+vortex-scan = { workspace = true }
 vortex-sequence = { workspace = true }
 vortex-session = { workspace = true }
 vortex-utils = { workspace = true, features = ["dashmap"] }
diff --git a/vortex-layout/public-api.lock b/vortex-layout/public-api.lock
index 1102f135753..6cc0db21db5 100644
--- a/vortex-layout/public-api.lock
+++ b/vortex-layout/public-api.lock
@@ -36,7 +36,7 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::buffered::Buffere
 
 pub fn vortex_layout::layouts::buffered::BufferedStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::buffered::BufferedStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::buffered::BufferedStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub mod vortex_layout::layouts::chunked
 
@@ -58,7 +58,45 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::chunked::writer::
 
 pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
+
+pub struct vortex_layout::layouts::chunked::Chunked
+
+impl core::fmt::Debug for vortex_layout::layouts::chunked::Chunked
+
+pub fn vortex_layout::layouts::chunked::Chunked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_layout::VTable for vortex_layout::layouts::chunked::Chunked
+
+pub type vortex_layout::layouts::chunked::Chunked::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
+
+pub type vortex_layout::layouts::chunked::Chunked::Layout = vortex_layout::layouts::chunked::ChunkedLayout
+
+pub type vortex_layout::layouts::chunked::Chunked::Metadata = vortex_array::metadata::EmptyMetadata
+
+pub fn vortex_layout::layouts::chunked::Chunked::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
+
+pub fn vortex_layout::layouts::chunked::Chunked::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+
+pub fn vortex_layout::layouts::chunked::Chunked::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+
+pub fn vortex_layout::layouts::chunked::Chunked::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::layouts::chunked::Chunked::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+
+pub fn vortex_layout::layouts::chunked::Chunked::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+
+pub fn vortex_layout::layouts::chunked::Chunked::metadata(_layout: &Self::Layout) -> Self::Metadata
+
+pub fn vortex_layout::layouts::chunked::Chunked::nchildren(layout: &Self::Layout) -> usize
+
+pub fn vortex_layout::layouts::chunked::Chunked::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+
+pub fn vortex_layout::layouts::chunked::Chunked::row_count(layout: &Self::Layout) -> u64
+
+pub fn vortex_layout::layouts::chunked::Chunked::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+
+pub fn vortex_layout::layouts::chunked::Chunked::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
 pub struct vortex_layout::layouts::chunked::ChunkedLayout
 
@@ -110,44 +148,6 @@ pub type vortex_layout::layouts::chunked::ChunkedLayoutEncoding::Target = dyn vo
 
 pub fn vortex_layout::layouts::chunked::ChunkedLayoutEncoding::deref(&self) -> &Self::Target
 
-pub struct vortex_layout::layouts::chunked::ChunkedVTable
-
-impl core::fmt::Debug for vortex_layout::layouts::chunked::ChunkedVTable
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-impl vortex_layout::VTable for vortex_layout::layouts::chunked::ChunkedVTable
-
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
-
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Layout = vortex_layout::layouts::chunked::ChunkedLayout
-
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Metadata = vortex_array::metadata::EmptyMetadata
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::nchildren(layout: &Self::Layout) -> usize
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::row_count(layout: &Self::Layout) -> u64
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
-
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
-
 pub mod vortex_layout::layouts::collect
 
 pub struct vortex_layout::layouts::collect::CollectStrategy
@@ -160,7 +160,7 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::collect::CollectS
 
 pub fn vortex_layout::layouts::collect::CollectStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::collect::CollectStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::collect::CollectStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub mod vortex_layout::layouts::compressed
 
@@ -168,9 +168,7 @@ pub struct vortex_layout::layouts::compressed::CompressingStrategy
 
 impl vortex_layout::layouts::compressed::CompressingStrategy
 
-pub fn vortex_layout::layouts::compressed::CompressingStrategy::new_btrblocks<S: vortex_layout::LayoutStrategy>(child: S, exclude_int_dict_encoding: bool) -> Self
-
-pub fn vortex_layout::layouts::compressed::CompressingStrategy::new_opaque<S: vortex_layout::LayoutStrategy, C: vortex_layout::layouts::compressed::CompressorPlugin>(child: S, compressor: C) -> Self
+pub fn vortex_layout::layouts::compressed::CompressingStrategy::new<S: vortex_layout::LayoutStrategy, C: vortex_layout::layouts::compressed::CompressorPlugin>(child: S, compressor: C) -> Self
 
 pub fn vortex_layout::layouts::compressed::CompressingStrategy::with_concurrency(self, concurrency: usize) -> Self
 
@@ -182,23 +180,23 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::compressed::Compr
 
 pub fn vortex_layout::layouts::compressed::CompressingStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::compressed::CompressingStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::compressed::CompressingStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub trait vortex_layout::layouts::compressed::CompressorPlugin: core::marker::Send + core::marker::Sync + 'static
 
-pub fn vortex_layout::layouts::compressed::CompressorPlugin::compress_chunk(&self, chunk: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_layout::layouts::compressed::CompressorPlugin::compress_chunk(&self, chunk: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
 impl vortex_layout::layouts::compressed::CompressorPlugin for alloc::sync::Arc<dyn vortex_layout::layouts::compressed::CompressorPlugin>
 
-pub fn alloc::sync::Arc<dyn vortex_layout::layouts::compressed::CompressorPlugin>::compress_chunk(&self, chunk: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn alloc::sync::Arc<dyn vortex_layout::layouts::compressed::CompressorPlugin>::compress_chunk(&self, chunk: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
 impl vortex_layout::layouts::compressed::CompressorPlugin for vortex_btrblocks::canonical_compressor::BtrBlocksCompressor
 
-pub fn vortex_btrblocks::canonical_compressor::BtrBlocksCompressor::compress_chunk(&self, chunk: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_btrblocks::canonical_compressor::BtrBlocksCompressor::compress_chunk(&self, chunk: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
-impl<F> vortex_layout::layouts::compressed::CompressorPlugin for F where F: core::ops::function::Fn(&dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef> + core::marker::Send + core::marker::Sync + 'static
+impl<F> vortex_layout::layouts::compressed::CompressorPlugin for F where F: core::ops::function::Fn(&vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef> + core::marker::Send + core::marker::Sync + 'static
 
-pub fn F::compress_chunk(&self, chunk: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn F::compress_chunk(&self, chunk: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
 pub mod vortex_layout::layouts::dict
 
@@ -274,10 +272,48 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::dict::writer::Dic
 
 pub fn vortex_layout::layouts::dict::writer::DictStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::dict::writer::DictStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::dict::writer::DictStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub fn vortex_layout::layouts::dict::writer::dict_layout_supported(dtype: &vortex_array::dtype::DType) -> bool
 
+pub struct vortex_layout::layouts::dict::Dict
+
+impl core::fmt::Debug for vortex_layout::layouts::dict::Dict
+
+pub fn vortex_layout::layouts::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_layout::VTable for vortex_layout::layouts::dict::Dict
+
+pub type vortex_layout::layouts::dict::Dict::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
+
+pub type vortex_layout::layouts::dict::Dict::Layout = vortex_layout::layouts::dict::DictLayout
+
+pub type vortex_layout::layouts::dict::Dict::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
+
+pub fn vortex_layout::layouts::dict::Dict::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
+
+pub fn vortex_layout::layouts::dict::Dict::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+
+pub fn vortex_layout::layouts::dict::Dict::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+
+pub fn vortex_layout::layouts::dict::Dict::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::layouts::dict::Dict::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+
+pub fn vortex_layout::layouts::dict::Dict::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+
+pub fn vortex_layout::layouts::dict::Dict::metadata(layout: &Self::Layout) -> Self::Metadata
+
+pub fn vortex_layout::layouts::dict::Dict::nchildren(_layout: &Self::Layout) -> usize
+
+pub fn vortex_layout::layouts::dict::Dict::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+
+pub fn vortex_layout::layouts::dict::Dict::row_count(layout: &Self::Layout) -> u64
+
+pub fn vortex_layout::layouts::dict::Dict::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+
+pub fn vortex_layout::layouts::dict::Dict::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+
 pub struct vortex_layout::layouts::dict::DictLayout
 
 impl vortex_layout::layouts::dict::DictLayout
@@ -358,44 +394,6 @@ pub fn vortex_layout::layouts::dict::DictLayoutMetadata::clear(&mut self)
 
 pub fn vortex_layout::layouts::dict::DictLayoutMetadata::encoded_len(&self) -> usize
 
-pub struct vortex_layout::layouts::dict::DictVTable
-
-impl core::fmt::Debug for vortex_layout::layouts::dict::DictVTable
-
-pub fn vortex_layout::layouts::dict::DictVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-impl vortex_layout::VTable for vortex_layout::layouts::dict::DictVTable
-
-pub type vortex_layout::layouts::dict::DictVTable::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
-
-pub type vortex_layout::layouts::dict::DictVTable::Layout = vortex_layout::layouts::dict::DictLayout
-
-pub type vortex_layout::layouts::dict::DictVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
-
-pub fn vortex_layout::layouts::dict::DictVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
-
-pub fn vortex_layout::layouts::dict::DictVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
-
-pub fn vortex_layout::layouts::dict::DictVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
-
-pub fn vortex_layout::layouts::dict::DictVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
-
-pub fn vortex_layout::layouts::dict::DictVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
-
-pub fn vortex_layout::layouts::dict::DictVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
-
-pub fn vortex_layout::layouts::dict::DictVTable::metadata(layout: &Self::Layout) -> Self::Metadata
-
-pub fn vortex_layout::layouts::dict::DictVTable::nchildren(_layout: &Self::Layout) -> usize
-
-pub fn vortex_layout::layouts::dict::DictVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
-
-pub fn vortex_layout::layouts::dict::DictVTable::row_count(layout: &Self::Layout) -> u64
-
-pub fn vortex_layout::layouts::dict::DictVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
-
-pub fn vortex_layout::layouts::dict::DictVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
-
 pub mod vortex_layout::layouts::file_stats
 
 pub struct vortex_layout::layouts::file_stats::FileStatsAccumulator
@@ -416,7 +414,7 @@ pub mod vortex_layout::layouts::flat::writer
 
 pub struct vortex_layout::layouts::flat::writer::FlatLayoutStrategy
 
-pub vortex_layout::layouts::flat::writer::FlatLayoutStrategy::allowed_encodings: core::option::Option<vortex_array::session::ArrayRegistry>
+pub vortex_layout::layouts::flat::writer::FlatLayoutStrategy::allowed_encodings: core::option::Option<vortex_utils::aliases::hash_set::HashSet<vortex_array::array::ArrayId>>
 
 pub vortex_layout::layouts::flat::writer::FlatLayoutStrategy::include_padding: bool
 
@@ -424,7 +422,7 @@ pub vortex_layout::layouts::flat::writer::FlatLayoutStrategy::max_variable_lengt
 
 impl vortex_layout::layouts::flat::writer::FlatLayoutStrategy
 
-pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::with_allow_encodings(self, allow_encodings: vortex_array::session::ArrayRegistry) -> Self
+pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::with_allow_encodings(self, allow_encodings: vortex_utils::aliases::hash_set::HashSet<vortex_array::array::ArrayId>) -> Self
 
 pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::with_include_padding(self, include_padding: bool) -> Self
 
@@ -442,19 +440,57 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::flat::writer::Fla
 
 pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, _eof: vortex_layout::sequence::SequencePointer, _handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, _eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
+
+pub struct vortex_layout::layouts::flat::Flat
+
+impl core::fmt::Debug for vortex_layout::layouts::flat::Flat
+
+pub fn vortex_layout::layouts::flat::Flat::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_layout::VTable for vortex_layout::layouts::flat::Flat
+
+pub type vortex_layout::layouts::flat::Flat::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
+
+pub type vortex_layout::layouts::flat::Flat::Layout = vortex_layout::layouts::flat::FlatLayout
+
+pub type vortex_layout::layouts::flat::Flat::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
+
+pub fn vortex_layout::layouts::flat::Flat::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
+
+pub fn vortex_layout::layouts::flat::Flat::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+
+pub fn vortex_layout::layouts::flat::Flat::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
+
+pub fn vortex_layout::layouts::flat::Flat::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::layouts::flat::Flat::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+
+pub fn vortex_layout::layouts::flat::Flat::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+
+pub fn vortex_layout::layouts::flat::Flat::metadata(layout: &Self::Layout) -> Self::Metadata
+
+pub fn vortex_layout::layouts::flat::Flat::nchildren(_layout: &Self::Layout) -> usize
+
+pub fn vortex_layout::layouts::flat::Flat::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+
+pub fn vortex_layout::layouts::flat::Flat::row_count(layout: &Self::Layout) -> u64
+
+pub fn vortex_layout::layouts::flat::Flat::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+
+pub fn vortex_layout::layouts::flat::Flat::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
 pub struct vortex_layout::layouts::flat::FlatLayout
 
 impl vortex_layout::layouts::flat::FlatLayout
 
-pub fn vortex_layout::layouts::flat::FlatLayout::array_ctx(&self) -> &vortex_array::context::ArrayContext
+pub fn vortex_layout::layouts::flat::FlatLayout::array_ctx(&self) -> &vortex_session::registry::ReadContext
 
 pub fn vortex_layout::layouts::flat::FlatLayout::array_tree(&self) -> core::option::Option<&vortex_buffer::ByteBuffer>
 
-pub fn vortex_layout::layouts::flat::FlatLayout::new(row_count: u64, dtype: vortex_array::dtype::DType, segment_id: vortex_layout::segments::SegmentId, ctx: vortex_array::context::ArrayContext) -> Self
+pub fn vortex_layout::layouts::flat::FlatLayout::new(row_count: u64, dtype: vortex_array::dtype::DType, segment_id: vortex_layout::segments::SegmentId, ctx: vortex_session::registry::ReadContext) -> Self
 
-pub fn vortex_layout::layouts::flat::FlatLayout::new_with_metadata(row_count: u64, dtype: vortex_array::dtype::DType, segment_id: vortex_layout::segments::SegmentId, ctx: vortex_array::context::ArrayContext, metadata: core::option::Option<vortex_buffer::ByteBuffer>) -> Self
+pub fn vortex_layout::layouts::flat::FlatLayout::new_with_metadata(row_count: u64, dtype: vortex_array::dtype::DType, segment_id: vortex_layout::segments::SegmentId, ctx: vortex_session::registry::ReadContext, metadata: core::option::Option<vortex_buffer::ByteBuffer>) -> Self
 
 pub fn vortex_layout::layouts::flat::FlatLayout::segment_id(&self) -> vortex_layout::segments::SegmentId
 
@@ -522,44 +558,6 @@ pub fn vortex_layout::layouts::flat::FlatLayoutMetadata::clear(&mut self)
 
 pub fn vortex_layout::layouts::flat::FlatLayoutMetadata::encoded_len(&self) -> usize
 
-pub struct vortex_layout::layouts::flat::FlatVTable
-
-impl core::fmt::Debug for vortex_layout::layouts::flat::FlatVTable
-
-pub fn vortex_layout::layouts::flat::FlatVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-impl vortex_layout::VTable for vortex_layout::layouts::flat::FlatVTable
-
-pub type vortex_layout::layouts::flat::FlatVTable::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
-
-pub type vortex_layout::layouts::flat::FlatVTable::Layout = vortex_layout::layouts::flat::FlatLayout
-
-pub type vortex_layout::layouts::flat::FlatVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
-
-pub fn vortex_layout::layouts::flat::FlatVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
-
-pub fn vortex_layout::layouts::flat::FlatVTable::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
-
-pub fn vortex_layout::layouts::flat::FlatVTable::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
-
-pub fn vortex_layout::layouts::flat::FlatVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
-
-pub fn vortex_layout::layouts::flat::FlatVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
-
-pub fn vortex_layout::layouts::flat::FlatVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
-
-pub fn vortex_layout::layouts::flat::FlatVTable::metadata(layout: &Self::Layout) -> Self::Metadata
-
-pub fn vortex_layout::layouts::flat::FlatVTable::nchildren(_layout: &Self::Layout) -> usize
-
-pub fn vortex_layout::layouts::flat::FlatVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
-
-pub fn vortex_layout::layouts::flat::FlatVTable::row_count(layout: &Self::Layout) -> u64
-
-pub fn vortex_layout::layouts::flat::FlatVTable::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
-
-pub fn vortex_layout::layouts::flat::FlatVTable::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
-
 pub mod vortex_layout::layouts::repartition
 
 pub struct vortex_layout::layouts::repartition::RepartitionStrategy
@@ -576,7 +574,7 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::repartition::Repa
 
 pub fn vortex_layout::layouts::repartition::RepartitionStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::repartition::RepartitionStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::repartition::RepartitionStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub struct vortex_layout::layouts::repartition::RepartitionWriterOptions
 
@@ -608,7 +606,7 @@ pub fn vortex_layout::layouts::row_idx::RowIdx::arity(&self, _options: &Self::Op
 
 pub fn vortex_layout::layouts::row_idx::RowIdx::child_name(&self, _instance: &Self::Options, _child_idx: usize) -> vortex_array::scalar_fn::vtable::ChildName
 
-pub fn vortex_layout::layouts::row_idx::RowIdx::execute(&self, _options: &Self::Options, _args: vortex_array::scalar_fn::vtable::ExecutionArgs<'_>) -> vortex_error::VortexResult<vortex_array::array::ArrayRef>
+pub fn vortex_layout::layouts::row_idx::RowIdx::execute(&self, _options: &Self::Options, _args: &dyn vortex_array::scalar_fn::vtable::ExecutionArgs, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
 
 pub fn vortex_layout::layouts::row_idx::RowIdx::fmt_sql(&self, _options: &Self::Options, _expr: &vortex_array::expr::expression::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
@@ -630,7 +628,7 @@ pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::filter_evaluation(&s
 
 pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::name(&self) -> &alloc::sync::Arc<str>
 
-pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::projection_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_array::mask_future::MaskFuture) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::ArrayRef>>>
+pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::projection_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_array::mask_future::MaskFuture) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>>>
 
 pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::pruning_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::mask_future::MaskFuture>
 
@@ -642,23 +640,43 @@ pub fn vortex_layout::layouts::row_idx::row_idx() -> vortex_array::expr::express
 
 pub mod vortex_layout::layouts::struct_
 
-pub mod vortex_layout::layouts::struct_::writer
+pub struct vortex_layout::layouts::struct_::Struct
+
+impl core::fmt::Debug for vortex_layout::layouts::struct_::Struct
+
+pub fn vortex_layout::layouts::struct_::Struct::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_layout::VTable for vortex_layout::layouts::struct_::Struct
+
+pub type vortex_layout::layouts::struct_::Struct::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
+
+pub type vortex_layout::layouts::struct_::Struct::Layout = vortex_layout::layouts::struct_::StructLayout
 
-pub struct vortex_layout::layouts::struct_::writer::StructStrategy
+pub type vortex_layout::layouts::struct_::Struct::Metadata = vortex_array::metadata::EmptyMetadata
 
-impl vortex_layout::layouts::struct_::writer::StructStrategy
+pub fn vortex_layout::layouts::struct_::Struct::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::new<S: vortex_layout::LayoutStrategy, V: vortex_layout::LayoutStrategy>(child: S, validity: V) -> Self
+pub fn vortex_layout::layouts::struct_::Struct::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-impl core::clone::Clone for vortex_layout::layouts::struct_::writer::StructStrategy
+pub fn vortex_layout::layouts::struct_::Struct::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::clone(&self) -> vortex_layout::layouts::struct_::writer::StructStrategy
+pub fn vortex_layout::layouts::struct_::Struct::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-impl vortex_layout::LayoutStrategy for vortex_layout::layouts::struct_::writer::StructStrategy
+pub fn vortex_layout::layouts::struct_::Struct::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::buffered_bytes(&self) -> u64
+pub fn vortex_layout::layouts::struct_::Struct::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::struct_::Struct::metadata(_layout: &Self::Layout) -> Self::Metadata
+
+pub fn vortex_layout::layouts::struct_::Struct::nchildren(layout: &Self::Layout) -> usize
+
+pub fn vortex_layout::layouts::struct_::Struct::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+
+pub fn vortex_layout::layouts::struct_::Struct::row_count(layout: &Self::Layout) -> u64
+
+pub fn vortex_layout::layouts::struct_::Struct::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+
+pub fn vortex_layout::layouts::struct_::Struct::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
 pub struct vortex_layout::layouts::struct_::StructLayout
 
@@ -716,44 +734,6 @@ pub type vortex_layout::layouts::struct_::StructLayoutEncoding::Target = dyn vor
 
 pub fn vortex_layout::layouts::struct_::StructLayoutEncoding::deref(&self) -> &Self::Target
 
-pub struct vortex_layout::layouts::struct_::StructVTable
-
-impl core::fmt::Debug for vortex_layout::layouts::struct_::StructVTable
-
-pub fn vortex_layout::layouts::struct_::StructVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-impl vortex_layout::VTable for vortex_layout::layouts::struct_::StructVTable
-
-pub type vortex_layout::layouts::struct_::StructVTable::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
-
-pub type vortex_layout::layouts::struct_::StructVTable::Layout = vortex_layout::layouts::struct_::StructLayout
-
-pub type vortex_layout::layouts::struct_::StructVTable::Metadata = vortex_array::metadata::EmptyMetadata
-
-pub fn vortex_layout::layouts::struct_::StructVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
-
-pub fn vortex_layout::layouts::struct_::StructVTable::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
-
-pub fn vortex_layout::layouts::struct_::StructVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
-
-pub fn vortex_layout::layouts::struct_::StructVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
-
-pub fn vortex_layout::layouts::struct_::StructVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
-
-pub fn vortex_layout::layouts::struct_::StructVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
-
-pub fn vortex_layout::layouts::struct_::StructVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
-
-pub fn vortex_layout::layouts::struct_::StructVTable::nchildren(layout: &Self::Layout) -> usize
-
-pub fn vortex_layout::layouts::struct_::StructVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
-
-pub fn vortex_layout::layouts::struct_::StructVTable::row_count(layout: &Self::Layout) -> u64
-
-pub fn vortex_layout::layouts::struct_::StructVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
-
-pub fn vortex_layout::layouts::struct_::StructVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
-
 pub mod vortex_layout::layouts::table
 
 pub struct vortex_layout::layouts::table::TableStrategy
@@ -772,7 +752,9 @@ pub fn vortex_layout::layouts::table::TableStrategy::with_validity_strategy(self
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::table::TableStrategy
 
-pub fn vortex_layout::layouts::table::TableStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::table::TableStrategy::buffered_bytes(&self) -> u64
+
+pub fn vortex_layout::layouts::table::TableStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub mod vortex_layout::layouts::zoned
 
@@ -802,7 +784,7 @@ impl vortex_layout::LayoutStrategy for vortex_layout::layouts::zoned::writer::Zo
 
 pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub mod vortex_layout::layouts::zoned::zone_map
 
@@ -814,34 +796,72 @@ pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::as_stats_table
 
 pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::new(dtype: &vortex_array::dtype::DType, stats: &[vortex_array::expr::stats::Stat], max_variable_length_statistics_size: usize) -> Self
 
-pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::push_chunk(&mut self, array: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::push_chunk(&mut self, array: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::push_chunk_without_compute(&mut self, array: &dyn vortex_array::array::Array) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::zoned::zone_map::StatsAccumulator::push_chunk_without_compute(&mut self, array: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<()>
 
 pub struct vortex_layout::layouts::zoned::zone_map::ZoneMap
 
 impl vortex_layout::layouts::zoned::zone_map::ZoneMap
 
-pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::array(&self) -> &vortex_array::arrays::struct_::array::StructArray
+pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::array(&self) -> &vortex_array::arrays::struct_::vtable::StructArray
 
 pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::dtype_for_stats_table(column_dtype: &vortex_array::dtype::DType, present_stats: &[vortex_array::expr::stats::Stat]) -> vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::get_stat(&self, stat: vortex_array::expr::stats::Stat) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
+pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::get_stat(&self, stat: vortex_array::expr::stats::Stat) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
 
-pub unsafe fn vortex_layout::layouts::zoned::zone_map::ZoneMap::new_unchecked(array: vortex_array::arrays::struct_::array::StructArray, stats: alloc::sync::Arc<[vortex_array::expr::stats::Stat]>) -> Self
+pub unsafe fn vortex_layout::layouts::zoned::zone_map::ZoneMap::new_unchecked(array: vortex_array::arrays::struct_::vtable::StructArray, stats: alloc::sync::Arc<[vortex_array::expr::stats::Stat]>) -> Self
 
 pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::present_stats(&self) -> &alloc::sync::Arc<[vortex_array::expr::stats::Stat]>
 
 pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::prune(&self, predicate: &vortex_array::expr::expression::Expression, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_mask::Mask>
 
-pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::to_stats_set(&self, stats: &[vortex_array::expr::stats::Stat]) -> vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>
+pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::to_stats_set(&self, stats: &[vortex_array::expr::stats::Stat], ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>
 
-pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::try_new(column_dtype: vortex_array::dtype::DType, array: vortex_array::arrays::struct_::array::StructArray, stats: alloc::sync::Arc<[vortex_array::expr::stats::Stat]>) -> vortex_error::VortexResult<Self>
+pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::try_new(column_dtype: vortex_array::dtype::DType, array: vortex_array::arrays::struct_::vtable::StructArray, stats: alloc::sync::Arc<[vortex_array::expr::stats::Stat]>) -> vortex_error::VortexResult<Self>
 
 impl core::clone::Clone for vortex_layout::layouts::zoned::zone_map::ZoneMap
 
 pub fn vortex_layout::layouts::zoned::zone_map::ZoneMap::clone(&self) -> vortex_layout::layouts::zoned::zone_map::ZoneMap
 
+pub struct vortex_layout::layouts::zoned::Zoned
+
+impl core::fmt::Debug for vortex_layout::layouts::zoned::Zoned
+
+pub fn vortex_layout::layouts::zoned::Zoned::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_layout::VTable for vortex_layout::layouts::zoned::Zoned
+
+pub type vortex_layout::layouts::zoned::Zoned::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
+
+pub type vortex_layout::layouts::zoned::Zoned::Layout = vortex_layout::layouts::zoned::ZonedLayout
+
+pub type vortex_layout::layouts::zoned::Zoned::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
+
+pub fn vortex_layout::layouts::zoned::Zoned::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
+
+pub fn vortex_layout::layouts::zoned::Zoned::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+
+pub fn vortex_layout::layouts::zoned::Zoned::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+
+pub fn vortex_layout::layouts::zoned::Zoned::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::layouts::zoned::Zoned::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+
+pub fn vortex_layout::layouts::zoned::Zoned::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+
+pub fn vortex_layout::layouts::zoned::Zoned::metadata(layout: &Self::Layout) -> Self::Metadata
+
+pub fn vortex_layout::layouts::zoned::Zoned::nchildren(_layout: &Self::Layout) -> usize
+
+pub fn vortex_layout::layouts::zoned::Zoned::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+
+pub fn vortex_layout::layouts::zoned::Zoned::row_count(layout: &Self::Layout) -> u64
+
+pub fn vortex_layout::layouts::zoned::Zoned::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+
+pub fn vortex_layout::layouts::zoned::Zoned::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+
 pub struct vortex_layout::layouts::zoned::ZonedLayout
 
 impl vortex_layout::layouts::zoned::ZonedLayout
@@ -922,49 +942,205 @@ impl vortex_array::metadata::SerializeMetadata for vortex_layout::layouts::zoned
 
 pub fn vortex_layout::layouts::zoned::ZonedMetadata::serialize(self) -> alloc::vec::Vec<u8>
 
-pub struct vortex_layout::layouts::zoned::ZonedVTable
+pub const vortex_layout::layouts::zoned::MAX_IS_TRUNCATED: &str
 
-impl core::fmt::Debug for vortex_layout::layouts::zoned::ZonedVTable
+pub const vortex_layout::layouts::zoned::MIN_IS_TRUNCATED: &str
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub type vortex_layout::layouts::SharedArrayFuture = futures_util::future::future::shared::Shared<futures_core::future::BoxFuture<'static, vortex_error::SharedVortexResult<vortex_array::array::erased::ArrayRef>>>
 
-impl vortex_layout::VTable for vortex_layout::layouts::zoned::ZonedVTable
+pub mod vortex_layout::scan
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
+pub mod vortex_layout::scan::arrow
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Layout = vortex_layout::layouts::zoned::ZonedLayout
+pub struct vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
+impl<I> vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>::new(iter: I, schema: arrow_schema::schema::SchemaRef) -> Self
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+impl<I: core::clone::Clone> core::clone::Clone for vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>::clone(&self) -> vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+impl<I> arrow_array::record_batch::RecordBatchReader for vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>::schema(&self) -> arrow_schema::schema::SchemaRef
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+impl<I> core::iter::traits::iterator::Iterator for vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub type vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>::Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::scan::arrow::RecordBatchIteratorAdapter<I>::next(&mut self) -> core::option::Option<Self::Item>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub mod vortex_layout::scan::layout
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::row_count(layout: &Self::Layout) -> u64
+pub struct vortex_layout::scan::layout::LayoutReaderDataSource
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+impl vortex_layout::scan::layout::LayoutReaderDataSource
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::new(reader: vortex_layout::LayoutReaderRef, session: vortex_session::VortexSession) -> Self
 
-pub const vortex_layout::layouts::zoned::MAX_IS_TRUNCATED: &str
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::with_metrics_registry(self, metrics: alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>) -> Self
 
-pub const vortex_layout::layouts::zoned::MIN_IS_TRUNCATED: &str
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::with_some_metrics_registry(self, metrics: core::option::Option<alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>>) -> Self
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::with_split_max_row_count(self, row_count: u64) -> Self
+
+impl vortex_scan::DataSource for vortex_layout::scan::layout::LayoutReaderDataSource
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::PartitionRef>
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
+
+pub fn vortex_layout::scan::layout::LayoutReaderDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+
+pub mod vortex_layout::scan::multi
+
+pub struct vortex_layout::scan::multi::MultiLayoutDataSource
+
+impl vortex_layout::scan::multi::MultiLayoutDataSource
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::new_deferred(dtype: vortex_array::dtype::DType, factories: alloc::vec::Vec<alloc::sync::Arc<dyn vortex_layout::scan::multi::LayoutReaderFactory>>, session: &vortex_session::VortexSession) -> Self
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::new_with_first(first: vortex_layout::LayoutReaderRef, remaining: alloc::vec::Vec<alloc::sync::Arc<dyn vortex_layout::scan::multi::LayoutReaderFactory>>, session: &vortex_session::VortexSession) -> Self
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::with_concurrency(self, concurrency: usize) -> Self
+
+impl vortex_scan::DataSource for vortex_layout::scan::multi::MultiLayoutDataSource
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::PartitionRef>
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
+
+pub fn vortex_layout::scan::multi::MultiLayoutDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+
+pub trait vortex_layout::scan::multi::LayoutReaderFactory: 'static + core::marker::Send + core::marker::Sync
+
+pub fn vortex_layout::scan::multi::LayoutReaderFactory::open<'life0, 'async_trait>(&'life0 self) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<core::option::Option<vortex_layout::LayoutReaderRef>>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+
+pub mod vortex_layout::scan::repeated_scan
 
-pub type vortex_layout::layouts::SharedArrayFuture = futures_util::future::future::shared::Shared<futures_core::future::BoxFuture<'static, vortex_error::SharedVortexResult<vortex_array::array::ArrayRef>>>
+pub struct vortex_layout::scan::repeated_scan::RepeatedScan<A: 'static + core::marker::Send>
+
+impl vortex_layout::scan::repeated_scan::RepeatedScan<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<vortex_array::array::erased::ArrayRef>::dtype(&self) -> &vortex_array::dtype::DType
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<vortex_array::array::erased::ArrayRef>::execute_array_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(&self, row_range: core::option::Option<core::ops::range::Range<u64>>, runtime: &B) -> vortex_error::VortexResult<impl vortex_array::iter::ArrayIterator + 'static>
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<vortex_array::array::erased::ArrayRef>::execute_array_stream(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<impl vortex_array::stream::ArrayStream + core::marker::Send + 'static>
+
+impl<A: 'static + core::marker::Send> vortex_layout::scan::repeated_scan::RepeatedScan<A>
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<A>::execute(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<alloc::vec::Vec<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<core::option::Option<A>>>>>
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<A>::execute_stream(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = vortex_error::VortexResult<A>> + core::marker::Send + 'static + use<A>>
+
+pub fn vortex_layout::scan::repeated_scan::RepeatedScan<A>::new(session: vortex_session::VortexSession, layout_reader: vortex_layout::LayoutReaderRef, projection: vortex_array::expr::expression::Expression, filter: core::option::Option<vortex_array::expr::expression::Expression>, ordered: bool, row_range: core::option::Option<core::ops::range::Range<u64>>, selection: vortex_scan::selection::Selection, splits: vortex_layout::scan::splits::Splits, concurrency: usize, map_fn: alloc::sync::Arc<(dyn core::ops::function::Fn(vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<A> + core::marker::Send + core::marker::Sync)>, limit: core::option::Option<u64>, dtype: vortex_array::dtype::DType) -> Self
+
+pub mod vortex_layout::scan::scan_builder
+
+pub struct vortex_layout::scan::scan_builder::ScanBuilder<A>
+
+impl vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>::into_array_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(self, runtime: &B) -> vortex_error::VortexResult<impl vortex_array::iter::ArrayIterator + 'static>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>::into_array_stream(self) -> vortex_error::VortexResult<impl vortex_array::stream::ArrayStream + core::marker::Send + 'static>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>::new(session: vortex_session::VortexSession, layout_reader: alloc::sync::Arc<dyn vortex_layout::LayoutReader>) -> Self
+
+impl vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>::into_record_batch_reader<B: vortex_io::runtime::blocking::BlockingRuntime>(self, schema: arrow_schema::schema::SchemaRef, runtime: &B) -> vortex_error::VortexResult<impl arrow_array::record_batch::RecordBatchReader + 'static>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>::into_record_batch_stream(self, schema: arrow_schema::schema::SchemaRef) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>> + core::marker::Send + 'static>
+
+impl<A: 'static + core::marker::Send> vortex_layout::scan::scan_builder::ScanBuilder<A>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::build(self) -> vortex_error::VortexResult<alloc::vec::Vec<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<core::option::Option<A>>>>>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::concurrency(&self) -> usize
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::into_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(self, runtime: &B) -> vortex_error::VortexResult<impl core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<A>> + 'static>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::into_stream(self) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = vortex_error::VortexResult<A>> + core::marker::Send + 'static + use<A>>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::map<B: 'static>(self, map_fn: impl core::ops::function::Fn(A) -> vortex_error::VortexResult<B> + 'static + core::marker::Send + core::marker::Sync) -> vortex_layout::scan::scan_builder::ScanBuilder<B>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::ordered(&self) -> bool
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::prepare(self) -> vortex_error::VortexResult<vortex_layout::scan::repeated_scan::RepeatedScan<A>>
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::session(&self) -> &vortex_session::VortexSession
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_concurrency(self, concurrency: usize) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_filter(self, filter: vortex_array::expr::expression::Expression) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_limit(self, limit: u64) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_metrics_registry(self, metrics: alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_ordered(self, ordered: bool) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_projection(self, projection: vortex_array::expr::expression::Expression) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_row_indices(self, row_indices: vortex_buffer::buffer::Buffer<u64>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_row_offset(self, row_offset: u64) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_row_range(self, row_range: core::ops::range::Range<u64>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_selection(self, selection: vortex_scan::selection::Selection) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_some_filter(self, filter: core::option::Option<vortex_array::expr::expression::Expression>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_some_limit(self, limit: core::option::Option<u64>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_some_metrics_registry(self, metrics: core::option::Option<alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>>) -> Self
+
+pub fn vortex_layout::scan::scan_builder::ScanBuilder<A>::with_split_by(self, split_by: vortex_layout::scan::split_by::SplitBy) -> Self
+
+pub fn vortex_layout::scan::scan_builder::filter_and_projection_masks(projection: &vortex_array::expr::expression::Expression, filter: core::option::Option<&vortex_array::expr::expression::Expression>, dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<(alloc::vec::Vec<vortex_array::dtype::field_mask::FieldMask>, alloc::vec::Vec<vortex_array::dtype::field_mask::FieldMask>)>
+
+pub mod vortex_layout::scan::split_by
+
+pub enum vortex_layout::scan::split_by::SplitBy
+
+pub vortex_layout::scan::split_by::SplitBy::Layout
+
+pub vortex_layout::scan::split_by::SplitBy::RowCount(usize)
+
+impl vortex_layout::scan::split_by::SplitBy
+
+pub fn vortex_layout::scan::split_by::SplitBy::splits(&self, layout_reader: &dyn vortex_layout::LayoutReader, row_range: &core::ops::range::Range<u64>, field_mask: &[vortex_array::dtype::field_mask::FieldMask]) -> vortex_error::VortexResult<alloc::collections::btree::set::BTreeSet<u64>>
+
+impl core::clone::Clone for vortex_layout::scan::split_by::SplitBy
+
+pub fn vortex_layout::scan::split_by::SplitBy::clone(&self) -> vortex_layout::scan::split_by::SplitBy
+
+impl core::default::Default for vortex_layout::scan::split_by::SplitBy
+
+pub fn vortex_layout::scan::split_by::SplitBy::default() -> vortex_layout::scan::split_by::SplitBy
+
+impl core::fmt::Debug for vortex_layout::scan::split_by::SplitBy
+
+pub fn vortex_layout::scan::split_by::SplitBy::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_layout::scan::split_by::SplitBy
 
 pub mod vortex_layout::segments
 
@@ -1182,15 +1358,15 @@ pub fn vortex_layout::sequence::SequentialStreamAdapter<S>::new(dtype: vortex_ar
 
 impl<'__pin, S> core::marker::Unpin for vortex_layout::sequence::SequentialStreamAdapter<S> where pin_project_lite::__private::PinnedFieldsOf<__Origin<'__pin, S>>: core::marker::Unpin
 
-impl<S> futures_core::stream::Stream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::ArrayRef)>>
+impl<S> futures_core::stream::Stream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::erased::ArrayRef)>>
 
-pub type vortex_layout::sequence::SequentialStreamAdapter<S>::Item = core::result::Result<(vortex_layout::sequence::SequenceId, alloc::sync::Arc<dyn vortex_array::array::Array>), vortex_error::VortexError>
+pub type vortex_layout::sequence::SequentialStreamAdapter<S>::Item = core::result::Result<(vortex_layout::sequence::SequenceId, vortex_array::array::erased::ArrayRef), vortex_error::VortexError>
 
 pub fn vortex_layout::sequence::SequentialStreamAdapter<S>::poll_next(self: core::pin::Pin<&mut Self>, cx: &mut core::task::wake::Context<'_>) -> core::task::poll::Poll<core::option::Option<Self::Item>>
 
 pub fn vortex_layout::sequence::SequentialStreamAdapter<S>::size_hint(&self) -> (usize, core::option::Option<usize>)
 
-impl<S> vortex_layout::sequence::SequentialStream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::ArrayRef)>>
+impl<S> vortex_layout::sequence::SequentialStream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::erased::ArrayRef)>>
 
 pub fn vortex_layout::sequence::SequentialStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
 
@@ -1200,7 +1376,9 @@ pub fn vortex_layout::sequence::SequentialArrayStreamExt::sequenced(self, pointe
 
 impl<S: vortex_array::stream::ArrayStream> vortex_layout::sequence::SequentialArrayStreamExt for S
 
-pub trait vortex_layout::sequence::SequentialStream: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::ArrayRef)>>
+pub fn S::sequenced(self, pointer: vortex_layout::sequence::SequencePointer) -> vortex_layout::sequence::SendableSequentialStream where Self: core::marker::Sized + core::marker::Send + 'static
+
+pub trait vortex_layout::sequence::SequentialStream: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::erased::ArrayRef)>>
 
 pub fn vortex_layout::sequence::SequentialStream::dtype(&self) -> &vortex_array::dtype::DType
 
@@ -1208,7 +1386,7 @@ impl vortex_layout::sequence::SequentialStream for vortex_layout::sequence::Send
 
 pub fn vortex_layout::sequence::SendableSequentialStream::dtype(&self) -> &vortex_array::dtype::DType
 
-impl<S> vortex_layout::sequence::SequentialStream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::ArrayRef)>>
+impl<S> vortex_layout::sequence::SequentialStream for vortex_layout::sequence::SequentialStreamAdapter<S> where S: futures_core::stream::Stream<Item = vortex_error::VortexResult<(vortex_layout::sequence::SequenceId, vortex_array::array::erased::ArrayRef)>>
 
 pub fn vortex_layout::sequence::SequentialStreamAdapter<S>::dtype(&self) -> &vortex_array::dtype::DType
 
@@ -1218,6 +1396,8 @@ pub fn vortex_layout::sequence::SequentialStreamExt::sendable(self) -> vortex_la
 
 impl<S: vortex_layout::sequence::SequentialStream> vortex_layout::sequence::SequentialStreamExt for S
 
+pub fn S::sendable(self) -> vortex_layout::sequence::SendableSequentialStream where Self: core::marker::Sized + core::marker::Send + 'static
+
 pub type vortex_layout::sequence::SendableSequentialStream = core::pin::Pin<alloc::boxed::Box<(dyn vortex_layout::sequence::SequentialStream + core::marker::Send)>>
 
 pub mod vortex_layout::session
@@ -1246,6 +1426,8 @@ pub fn vortex_layout::session::LayoutSessionExt::layouts(&self) -> vortex_sessio
 
 impl<S: vortex_session::SessionExt> vortex_layout::session::LayoutSessionExt for S
 
+pub fn S::layouts(&self) -> vortex_session::Ref<'_, vortex_layout::session::LayoutSession>
+
 pub type vortex_layout::session::LayoutRegistry = vortex_session::registry::Registry<vortex_layout::LayoutEncodingRef>
 
 pub mod vortex_layout::vtable
@@ -1258,7 +1440,7 @@ pub type vortex_layout::vtable::VTable::Layout: 'static + core::marker::Send + c
 
 pub type vortex_layout::vtable::VTable::Metadata: vortex_array::metadata::SerializeMetadata + vortex_array::metadata::DeserializeMetadata + core::fmt::Debug
 
-pub fn vortex_layout::vtable::VTable::build(encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::vtable::VTable::build(encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
 pub fn vortex_layout::vtable::VTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
@@ -1282,165 +1464,165 @@ pub fn vortex_layout::vtable::VTable::segment_ids(layout: &Self::Layout) -> allo
 
 pub fn vortex_layout::vtable::VTable::with_children(_layout: &mut Self::Layout, _children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::chunked::ChunkedVTable
+impl vortex_layout::VTable for vortex_layout::layouts::chunked::Chunked
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
+pub type vortex_layout::layouts::chunked::Chunked::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Layout = vortex_layout::layouts::chunked::ChunkedLayout
+pub type vortex_layout::layouts::chunked::Chunked::Layout = vortex_layout::layouts::chunked::ChunkedLayout
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub type vortex_layout::layouts::chunked::Chunked::Metadata = vortex_array::metadata::EmptyMetadata
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::chunked::Chunked::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::chunked::Chunked::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::chunked::Chunked::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::chunked::Chunked::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::chunked::Chunked::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::chunked::Chunked::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::chunked::Chunked::metadata(_layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::nchildren(layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::chunked::Chunked::nchildren(layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::chunked::Chunked::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::chunked::Chunked::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::chunked::Chunked::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::chunked::Chunked::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::dict::DictVTable
+impl vortex_layout::VTable for vortex_layout::layouts::dict::Dict
 
-pub type vortex_layout::layouts::dict::DictVTable::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
+pub type vortex_layout::layouts::dict::Dict::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
 
-pub type vortex_layout::layouts::dict::DictVTable::Layout = vortex_layout::layouts::dict::DictLayout
+pub type vortex_layout::layouts::dict::Dict::Layout = vortex_layout::layouts::dict::DictLayout
 
-pub type vortex_layout::layouts::dict::DictVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
+pub type vortex_layout::layouts::dict::Dict::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
 
-pub fn vortex_layout::layouts::dict::DictVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::dict::Dict::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::dict::DictVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::dict::Dict::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::dict::DictVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::dict::Dict::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::dict::DictVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::dict::Dict::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::dict::DictVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::dict::Dict::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::dict::DictVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::dict::Dict::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::dict::DictVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::dict::Dict::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::dict::DictVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::dict::Dict::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::dict::DictVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::dict::Dict::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::dict::DictVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::dict::Dict::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::dict::DictVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::dict::Dict::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::dict::DictVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::dict::Dict::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::flat::FlatVTable
+impl vortex_layout::VTable for vortex_layout::layouts::flat::Flat
 
-pub type vortex_layout::layouts::flat::FlatVTable::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
+pub type vortex_layout::layouts::flat::Flat::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
 
-pub type vortex_layout::layouts::flat::FlatVTable::Layout = vortex_layout::layouts::flat::FlatLayout
+pub type vortex_layout::layouts::flat::Flat::Layout = vortex_layout::layouts::flat::FlatLayout
 
-pub type vortex_layout::layouts::flat::FlatVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
+pub type vortex_layout::layouts::flat::Flat::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::flat::Flat::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::flat::Flat::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::flat::Flat::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::flat::FlatVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::flat::Flat::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::flat::FlatVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::flat::Flat::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::flat::FlatVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::flat::Flat::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::flat::FlatVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::flat::Flat::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::flat::FlatVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::flat::Flat::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::flat::FlatVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::flat::Flat::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::flat::Flat::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::flat::FlatVTable::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::flat::Flat::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::flat::Flat::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::struct_::StructVTable
+impl vortex_layout::VTable for vortex_layout::layouts::struct_::Struct
 
-pub type vortex_layout::layouts::struct_::StructVTable::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
+pub type vortex_layout::layouts::struct_::Struct::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
 
-pub type vortex_layout::layouts::struct_::StructVTable::Layout = vortex_layout::layouts::struct_::StructLayout
+pub type vortex_layout::layouts::struct_::Struct::Layout = vortex_layout::layouts::struct_::StructLayout
 
-pub type vortex_layout::layouts::struct_::StructVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub type vortex_layout::layouts::struct_::Struct::Metadata = vortex_array::metadata::EmptyMetadata
 
-pub fn vortex_layout::layouts::struct_::StructVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::struct_::Struct::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::struct_::Struct::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::struct_::Struct::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::struct_::StructVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::struct_::Struct::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::struct_::StructVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::struct_::Struct::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::struct_::StructVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::struct_::Struct::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::struct_::StructVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::struct_::Struct::metadata(_layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::struct_::StructVTable::nchildren(layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::struct_::Struct::nchildren(layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::struct_::StructVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::struct_::Struct::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::struct_::Struct::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::struct_::StructVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::struct_::Struct::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::struct_::Struct::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::zoned::ZonedVTable
+impl vortex_layout::VTable for vortex_layout::layouts::zoned::Zoned
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
+pub type vortex_layout::layouts::zoned::Zoned::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Layout = vortex_layout::layouts::zoned::ZonedLayout
+pub type vortex_layout::layouts::zoned::Zoned::Layout = vortex_layout::layouts::zoned::ZonedLayout
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
+pub type vortex_layout::layouts::zoned::Zoned::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::zoned::Zoned::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::zoned::Zoned::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::zoned::Zoned::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::zoned::Zoned::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::zoned::Zoned::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::zoned::Zoned::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::zoned::Zoned::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::zoned::Zoned::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::zoned::Zoned::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::zoned::Zoned::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::zoned::Zoned::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layouts::zoned::Zoned::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
 pub macro vortex_layout::vtable!
 
@@ -1518,7 +1700,7 @@ impl<V: vortex_layout::VTable> vortex_layout::LayoutEncoding for vortex_layout::
 
 pub fn vortex_layout::LayoutEncodingAdapter<V>::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_layout::LayoutEncodingAdapter<V>::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::LayoutEncodingAdapter<V>::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
 pub fn vortex_layout::LayoutEncodingAdapter<V>::id(&self) -> vortex_layout::LayoutEncodingId
 
@@ -1638,7 +1820,7 @@ pub trait vortex_layout::LayoutEncoding: 'static + core::marker::Send + core::ma
 
 pub fn vortex_layout::LayoutEncoding::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_layout::LayoutEncoding::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::LayoutEncoding::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
 pub fn vortex_layout::LayoutEncoding::id(&self) -> vortex_layout::LayoutEncodingId
 
@@ -1646,7 +1828,7 @@ impl<V: vortex_layout::VTable> vortex_layout::LayoutEncoding for vortex_layout::
 
 pub fn vortex_layout::LayoutEncodingAdapter<V>::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_layout::LayoutEncodingAdapter<V>::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::LayoutEncodingAdapter<V>::build(&self, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &[u8], segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
 pub fn vortex_layout::LayoutEncodingAdapter<V>::id(&self) -> vortex_layout::LayoutEncodingId
 
@@ -1674,7 +1856,7 @@ pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::filter_evaluation(&s
 
 pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::name(&self) -> &alloc::sync::Arc<str>
 
-pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::projection_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_array::mask_future::MaskFuture) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::ArrayRef>>>
+pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::projection_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_array::mask_future::MaskFuture) -> vortex_error::VortexResult<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>>>
 
 pub fn vortex_layout::layouts::row_idx::RowIdxLayoutReader::pruning_evaluation(&self, row_range: &core::ops::range::Range<u64>, expr: &vortex_array::expr::expression::Expression, mask: vortex_mask::Mask) -> vortex_error::VortexResult<vortex_array::mask_future::MaskFuture>
 
@@ -1686,71 +1868,67 @@ pub trait vortex_layout::LayoutStrategy: 'static + core::marker::Send + core::ma
 
 pub fn vortex_layout::LayoutStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::LayoutStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::LayoutStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for alloc::sync::Arc<dyn vortex_layout::LayoutStrategy>
 
 pub fn alloc::sync::Arc<dyn vortex_layout::LayoutStrategy>::buffered_bytes(&self) -> u64
 
-pub fn alloc::sync::Arc<dyn vortex_layout::LayoutStrategy>::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn alloc::sync::Arc<dyn vortex_layout::LayoutStrategy>::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::buffered::BufferedStrategy
 
 pub fn vortex_layout::layouts::buffered::BufferedStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::buffered::BufferedStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::buffered::BufferedStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy
 
 pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::chunked::writer::ChunkedLayoutStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::collect::CollectStrategy
 
 pub fn vortex_layout::layouts::collect::CollectStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::collect::CollectStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::collect::CollectStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::compressed::CompressingStrategy
 
 pub fn vortex_layout::layouts::compressed::CompressingStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::compressed::CompressingStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::compressed::CompressingStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::dict::writer::DictStrategy
 
 pub fn vortex_layout::layouts::dict::writer::DictStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::dict::writer::DictStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::dict::writer::DictStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::flat::writer::FlatLayoutStrategy
 
 pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, _eof: vortex_layout::sequence::SequencePointer, _handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::flat::writer::FlatLayoutStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, _eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::repartition::RepartitionStrategy
 
 pub fn vortex_layout::layouts::repartition::RepartitionStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::repartition::RepartitionStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-impl vortex_layout::LayoutStrategy for vortex_layout::layouts::struct_::writer::StructStrategy
-
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::buffered_bytes(&self) -> u64
-
-pub fn vortex_layout::layouts::struct_::writer::StructStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::repartition::RepartitionStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::table::TableStrategy
 
-pub fn vortex_layout::layouts::table::TableStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::table::TableStrategy::buffered_bytes(&self) -> u64
+
+pub fn vortex_layout::layouts::table::TableStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 impl vortex_layout::LayoutStrategy for vortex_layout::layouts::zoned::writer::ZonedStrategy
 
 pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::buffered_bytes(&self) -> u64
 
-pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::write_stream<'life0, 'async_trait>(&'life0 self, ctx: vortex_array::context::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, handle: vortex_io::runtime::handle::Handle) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
+pub fn vortex_layout::layouts::zoned::writer::ZonedStrategy::write_stream<'life0, 'life1, 'async_trait>(&'life0 self, ctx: vortex_array::ArrayContext, segment_sink: vortex_layout::segments::SegmentSinkRef, stream: vortex_layout::sequence::SendableSequentialStream, eof: vortex_layout::sequence::SequencePointer, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_layout::LayoutRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
 pub trait vortex_layout::VTable: 'static + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
@@ -1760,7 +1938,7 @@ pub type vortex_layout::VTable::Layout: 'static + core::marker::Send + core::mar
 
 pub type vortex_layout::VTable::Metadata: vortex_array::metadata::SerializeMetadata + vortex_array::metadata::DeserializeMetadata + core::fmt::Debug
 
-pub fn vortex_layout::VTable::build(encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::VTable::build(encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
 pub fn vortex_layout::VTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
@@ -1784,169 +1962,171 @@ pub fn vortex_layout::VTable::segment_ids(layout: &Self::Layout) -> alloc::vec::
 
 pub fn vortex_layout::VTable::with_children(_layout: &mut Self::Layout, _children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-impl vortex_layout::VTable for vortex_layout::layouts::chunked::ChunkedVTable
+impl vortex_layout::VTable for vortex_layout::layouts::chunked::Chunked
+
+pub type vortex_layout::layouts::chunked::Chunked::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Encoding = vortex_layout::layouts::chunked::ChunkedLayoutEncoding
+pub type vortex_layout::layouts::chunked::Chunked::Layout = vortex_layout::layouts::chunked::ChunkedLayout
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Layout = vortex_layout::layouts::chunked::ChunkedLayout
+pub type vortex_layout::layouts::chunked::Chunked::Metadata = vortex_array::metadata::EmptyMetadata
 
-pub type vortex_layout::layouts::chunked::ChunkedVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub fn vortex_layout::layouts::chunked::Chunked::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::chunked::Chunked::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::chunked::Chunked::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::chunked::Chunked::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::chunked::Chunked::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::chunked::Chunked::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::chunked::Chunked::metadata(_layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::chunked::Chunked::nchildren(layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::nchildren(layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::chunked::Chunked::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::chunked::Chunked::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::chunked::Chunked::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::chunked::Chunked::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::chunked::ChunkedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+impl vortex_layout::VTable for vortex_layout::layouts::dict::Dict
 
-impl vortex_layout::VTable for vortex_layout::layouts::dict::DictVTable
+pub type vortex_layout::layouts::dict::Dict::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
 
-pub type vortex_layout::layouts::dict::DictVTable::Encoding = vortex_layout::layouts::dict::DictLayoutEncoding
+pub type vortex_layout::layouts::dict::Dict::Layout = vortex_layout::layouts::dict::DictLayout
 
-pub type vortex_layout::layouts::dict::DictVTable::Layout = vortex_layout::layouts::dict::DictLayout
+pub type vortex_layout::layouts::dict::Dict::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
 
-pub type vortex_layout::layouts::dict::DictVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::dict::DictLayoutMetadata>
+pub fn vortex_layout::layouts::dict::Dict::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::dict::DictVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::dict::Dict::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::dict::DictVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::dict::Dict::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::dict::DictVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::dict::Dict::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::dict::DictVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::dict::Dict::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::dict::DictVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::dict::Dict::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::dict::DictVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::dict::Dict::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::dict::DictVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::dict::Dict::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::dict::DictVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::dict::Dict::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::dict::DictVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::dict::Dict::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::dict::DictVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::dict::Dict::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::dict::DictVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::dict::Dict::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::dict::DictVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+impl vortex_layout::VTable for vortex_layout::layouts::flat::Flat
 
-impl vortex_layout::VTable for vortex_layout::layouts::flat::FlatVTable
+pub type vortex_layout::layouts::flat::Flat::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
 
-pub type vortex_layout::layouts::flat::FlatVTable::Encoding = vortex_layout::layouts::flat::FlatLayoutEncoding
+pub type vortex_layout::layouts::flat::Flat::Layout = vortex_layout::layouts::flat::FlatLayout
 
-pub type vortex_layout::layouts::flat::FlatVTable::Layout = vortex_layout::layouts::flat::FlatLayout
+pub type vortex_layout::layouts::flat::Flat::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
 
-pub type vortex_layout::layouts::flat::FlatVTable::Metadata = vortex_array::metadata::ProstMetadata<vortex_layout::layouts::flat::FlatLayoutMetadata>
+pub fn vortex_layout::layouts::flat::Flat::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, _children: &dyn vortex_layout::LayoutChildren, ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::flat::Flat::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::child(_layout: &Self::Layout, _idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::flat::Flat::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::flat::FlatVTable::child_type(_layout: &Self::Layout, _idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::flat::Flat::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::flat::FlatVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::flat::Flat::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::flat::FlatVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::flat::Flat::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::flat::FlatVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::flat::Flat::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::flat::FlatVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::flat::Flat::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::flat::FlatVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::flat::Flat::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::flat::Flat::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::flat::FlatVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::flat::Flat::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::segment_ids(layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::flat::Flat::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::flat::FlatVTable::with_children(_layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+impl vortex_layout::VTable for vortex_layout::layouts::struct_::Struct
 
-impl vortex_layout::VTable for vortex_layout::layouts::struct_::StructVTable
+pub type vortex_layout::layouts::struct_::Struct::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
 
-pub type vortex_layout::layouts::struct_::StructVTable::Encoding = vortex_layout::layouts::struct_::StructLayoutEncoding
+pub type vortex_layout::layouts::struct_::Struct::Layout = vortex_layout::layouts::struct_::StructLayout
 
-pub type vortex_layout::layouts::struct_::StructVTable::Layout = vortex_layout::layouts::struct_::StructLayout
+pub type vortex_layout::layouts::struct_::Struct::Metadata = vortex_array::metadata::EmptyMetadata
 
-pub type vortex_layout::layouts::struct_::StructVTable::Metadata = vortex_array::metadata::EmptyMetadata
+pub fn vortex_layout::layouts::struct_::Struct::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, row_count: u64, _metadata: &<Self::Metadata as vortex_array::metadata::DeserializeMetadata>::Output, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::struct_::Struct::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::child(layout: &Self::Layout, index: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::struct_::Struct::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::struct_::StructVTable::child_type(layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::struct_::Struct::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::struct_::StructVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::struct_::Struct::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::struct_::StructVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::struct_::Struct::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::struct_::StructVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::struct_::Struct::metadata(_layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::struct_::StructVTable::metadata(_layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::struct_::Struct::nchildren(layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::struct_::StructVTable::nchildren(layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::struct_::Struct::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::struct_::Struct::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::struct_::StructVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::struct_::Struct::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::struct_::Struct::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::struct_::StructVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+impl vortex_layout::VTable for vortex_layout::layouts::zoned::Zoned
 
-impl vortex_layout::VTable for vortex_layout::layouts::zoned::ZonedVTable
+pub type vortex_layout::layouts::zoned::Zoned::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Encoding = vortex_layout::layouts::zoned::ZonedLayoutEncoding
+pub type vortex_layout::layouts::zoned::Zoned::Layout = vortex_layout::layouts::zoned::ZonedLayout
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Layout = vortex_layout::layouts::zoned::ZonedLayout
+pub type vortex_layout::layouts::zoned::Zoned::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
 
-pub type vortex_layout::layouts::zoned::ZonedVTable::Metadata = vortex_layout::layouts::zoned::ZonedMetadata
+pub fn vortex_layout::layouts::zoned::Zoned::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_session::registry::ReadContext) -> vortex_error::VortexResult<Self::Layout>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::build(_encoding: &Self::Encoding, dtype: &vortex_array::dtype::DType, _row_count: u64, metadata: &vortex_layout::layouts::zoned::ZonedMetadata, _segment_ids: alloc::vec::Vec<vortex_layout::segments::SegmentId>, children: &dyn vortex_layout::LayoutChildren, _ctx: &vortex_array::context::ArrayContext) -> vortex_error::VortexResult<Self::Layout>
+pub fn vortex_layout::layouts::zoned::Zoned::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child(layout: &Self::Layout, idx: usize) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layouts::zoned::Zoned::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::child_type(_layout: &Self::Layout, idx: usize) -> vortex_layout::LayoutChildType
+pub fn vortex_layout::layouts::zoned::Zoned::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::dtype(layout: &Self::Layout) -> &vortex_array::dtype::DType
+pub fn vortex_layout::layouts::zoned::Zoned::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::encoding(_layout: &Self::Layout) -> vortex_layout::LayoutEncodingRef
+pub fn vortex_layout::layouts::zoned::Zoned::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::id(_encoding: &Self::Encoding) -> vortex_layout::LayoutId
+pub fn vortex_layout::layouts::zoned::Zoned::metadata(layout: &Self::Layout) -> Self::Metadata
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::metadata(layout: &Self::Layout) -> Self::Metadata
+pub fn vortex_layout::layouts::zoned::Zoned::nchildren(_layout: &Self::Layout) -> usize
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::nchildren(_layout: &Self::Layout) -> usize
+pub fn vortex_layout::layouts::zoned::Zoned::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::new_reader(layout: &Self::Layout, name: alloc::sync::Arc<str>, segment_source: alloc::sync::Arc<dyn vortex_layout::segments::SegmentSource>, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_layout::LayoutReaderRef>
+pub fn vortex_layout::layouts::zoned::Zoned::row_count(layout: &Self::Layout) -> u64
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::row_count(layout: &Self::Layout) -> u64
+pub fn vortex_layout::layouts::zoned::Zoned::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::segment_ids(_layout: &Self::Layout) -> alloc::vec::Vec<vortex_layout::segments::SegmentId>
+pub fn vortex_layout::layouts::zoned::Zoned::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
 
-pub fn vortex_layout::layouts::zoned::ZonedVTable::with_children(layout: &mut Self::Layout, children: alloc::vec::Vec<vortex_layout::LayoutRef>) -> vortex_error::VortexResult<()>
+pub fn vortex_layout::layout_from_flatbuffer(flatbuffer: vortex_flatbuffers::FlatBuffer, dtype: &vortex_array::dtype::DType, layout_ctx: &vortex_session::registry::ReadContext, ctx: &vortex_session::registry::ReadContext, layouts: &vortex_layout::session::LayoutRegistry) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub fn vortex_layout::layout_from_flatbuffer(flatbuffer: vortex_flatbuffers::FlatBuffer, dtype: &vortex_array::dtype::DType, layout_ctx: &vortex_layout::LayoutContext, ctx: &vortex_array::context::ArrayContext, layouts: &vortex_layout::session::LayoutRegistry) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
+pub fn vortex_layout::layout_from_flatbuffer_with_options(flatbuffer: vortex_flatbuffers::FlatBuffer, dtype: &vortex_array::dtype::DType, layout_ctx: &vortex_session::registry::ReadContext, ctx: &vortex_session::registry::ReadContext, layouts: &vortex_layout::session::LayoutRegistry, allow_unknown: bool) -> vortex_error::VortexResult<vortex_layout::LayoutRef>
 
-pub type vortex_layout::ArrayFuture = futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::ArrayRef>>
+pub type vortex_layout::ArrayFuture = futures_core::future::BoxFuture<'static, vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>>
 
 pub type vortex_layout::LayoutContext = vortex_session::registry::Context<vortex_layout::LayoutEncodingRef>
 
diff --git a/vortex-layout/src/children.rs b/vortex-layout/src/children.rs
index e87f0d05031..916e216543e 100644
--- a/vortex-layout/src/children.rs
+++ b/vortex-layout/src/children.rs
@@ -7,15 +7,14 @@ use std::sync::Arc;
 
 use flatbuffers::Follow;
 use itertools::Itertools;
-use vortex_array::ArrayContext;
 use vortex_array::dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::layout as fbl;
+use vortex_session::registry::ReadContext;
 
-use crate::LayoutContext;
 use crate::LayoutRef;
 use crate::segments::SegmentId;
 use crate::session::LayoutRegistry;
@@ -44,7 +43,7 @@ impl Debug for dyn LayoutChildren {
 
 impl LayoutChildren for Arc<dyn LayoutChildren> {
     fn to_arc(&self) -> Arc<dyn LayoutChildren> {
-        self.clone()
+        Arc::clone(self)
     }
 
     fn child(&self, idx: usize, dtype: &DType) -> VortexResult<LayoutRef> {
@@ -85,7 +84,7 @@ impl LayoutChildren for OwnedLayoutChildren {
         if child.dtype() != dtype {
             vortex_bail!("Child dtype mismatch: {} != {}", child.dtype(), dtype);
         }
-        Ok(child.clone())
+        Ok(Arc::clone(child))
     }
 
     fn child_row_count(&self, idx: usize) -> u64 {
@@ -101,9 +100,10 @@ impl LayoutChildren for OwnedLayoutChildren {
 pub(crate) struct ViewedLayoutChildren {
     flatbuffer: FlatBuffer,
     flatbuffer_loc: usize,
-    array_ctx: ArrayContext,
-    layout_ctx: LayoutContext,
+    array_read_ctx: ReadContext,
+    layout_read_ctx: ReadContext,
     layouts: LayoutRegistry,
+    allow_unknown: bool,
 }
 
 impl ViewedLayoutChildren {
@@ -115,16 +115,18 @@ impl ViewedLayoutChildren {
     pub(super) unsafe fn new_unchecked(
         flatbuffer: FlatBuffer,
         flatbuffer_loc: usize,
-        array_ctx: ArrayContext,
-        layout_ctx: LayoutContext,
+        array_read_ctx: ReadContext,
+        layout_read_ctx: ReadContext,
         layouts: LayoutRegistry,
+        allow_unknown: bool,
     ) -> Self {
         Self {
             flatbuffer,
             flatbuffer_loc,
-            array_ctx,
-            layout_ctx,
+            array_read_ctx,
+            layout_read_ctx,
             layouts,
+            allow_unknown,
         }
     }
 
@@ -135,6 +137,41 @@ impl ViewedLayoutChildren {
         // The lifetime of the returned Layout is tied to self, ensuring the buffer remains valid.
         unsafe { fbl::Layout::follow(self.flatbuffer.as_ref(), self.flatbuffer_loc) }
     }
+
+    fn foreign_layout_from_fb(
+        &self,
+        fb_layout: fbl::Layout<'_>,
+        dtype: &DType,
+    ) -> VortexResult<LayoutRef> {
+        let encoding_id = self
+            .layout_read_ctx
+            .resolve(fb_layout.encoding())
+            .ok_or_else(|| vortex_err!("Encoding not found: {}", fb_layout.encoding()))?;
+
+        let children = fb_layout
+            .children()
+            .unwrap_or_default()
+            .iter()
+            .map(|child| self.foreign_layout_from_fb(child, dtype))
+            .collect::<VortexResult<Vec<_>>>()?;
+
+        Ok(crate::layouts::foreign::new_foreign_layout(
+            encoding_id,
+            dtype.clone(),
+            fb_layout.row_count(),
+            fb_layout
+                .metadata()
+                .map(|m| m.bytes().to_vec())
+                .unwrap_or_default(),
+            fb_layout
+                .segments()
+                .unwrap_or_default()
+                .iter()
+                .map(SegmentId::from)
+                .collect_vec(),
+            children,
+        ))
+    }
 }
 
 impl LayoutChildren for ViewedLayoutChildren {
@@ -151,18 +188,25 @@ impl LayoutChildren for ViewedLayoutChildren {
         let viewed_children = ViewedLayoutChildren {
             flatbuffer: self.flatbuffer.clone(),
             flatbuffer_loc: fb_child._tab.loc(),
-            array_ctx: self.array_ctx.clone(),
-            layout_ctx: self.layout_ctx.clone(),
+            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 encoding_id = self
-            .layout_ctx
+            .layout_read_ctx
             .resolve(fb_child.encoding())
             .ok_or_else(|| vortex_err!("Encoding not found: {}", fb_child.encoding()))?;
-        let encoding = self.layouts.find(&encoding_id).ok_or_else(|| {
-            vortex_err!("Encoding not found in registry: {}", 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,
@@ -178,7 +222,7 @@ impl LayoutChildren for ViewedLayoutChildren {
                 .map(SegmentId::from)
                 .collect_vec(),
             &viewed_children,
-            &self.array_ctx,
+            &self.array_read_ctx,
         )
     }
 
diff --git a/vortex-layout/src/display.rs b/vortex-layout/src/display.rs
index 5f21c031cd5..39605dfb5d1 100644
--- a/vortex-layout/src/display.rs
+++ b/vortex-layout/src/display.rs
@@ -5,13 +5,13 @@ use std::sync::Arc;
 
 use futures::future::try_join_all;
 use termtree::Tree;
-use vortex_array::serde::ArrayParts;
+use vortex_array::serde::SerializedArray;
 use vortex_error::VortexResult;
 use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::LayoutRef;
+use crate::layouts::flat::Flat;
 use crate::layouts::flat::FlatLayout;
-use crate::layouts::flat::FlatVTable;
 use crate::segments::SegmentId;
 use crate::segments::SegmentSource;
 
@@ -32,10 +32,10 @@ pub(super) async fn display_tree_with_segment_sizes(
 
     // Fetch segments in parallel and parse buffer info
     let fetch_futures = segments_to_fetch.iter().map(|&segment_id| {
-        let segment_source = segment_source.clone();
+        let segment_source = Arc::clone(&segment_source);
         async move {
             let buffer = segment_source.request(segment_id).await?;
-            let parts = ArrayParts::try_from(buffer)?;
+            let parts = SerializedArray::try_from(buffer)?;
             VortexResult::Ok((segment_id, parts.buffer_lengths()))
         }
     });
@@ -55,7 +55,7 @@ fn collect_segments_to_fetch(
     segment_ids: &mut Vec<SegmentId>,
 ) -> VortexResult<()> {
     // For FlatLayout, only add if there's no inline array_tree
-    if let Some(flat_layout) = layout.as_opt::<FlatVTable>() {
+    if let Some(flat_layout) = layout.as_opt::<Flat>() {
         if flat_layout.array_tree().is_none() {
             segment_ids.push(flat_layout.segment_id());
         }
@@ -80,7 +80,7 @@ fn format_flat_layout_buffers(
 
     // First, try to get buffer info from inline array_tree
     if let Some(array_tree) = flat_layout.array_tree()
-        && let Ok(parts) = ArrayParts::from_array_tree(array_tree.as_ref().to_vec())
+        && let Ok(parts) = SerializedArray::from_array_tree(array_tree.as_ref().to_vec())
     {
         return format_buffer_sizes(&parts.buffer_lengths(), *segment_id);
     }
@@ -147,7 +147,7 @@ impl DisplayLayoutTree {
         }
 
         // For FlatLayout, show buffer info
-        if let Some(flat_layout) = layout.as_opt::<FlatVTable>() {
+        if let Some(flat_layout) = layout.as_opt::<Flat>() {
             node_parts.push(format_flat_layout_buffers(
                 flat_layout,
                 self.segment_buffer_sizes.as_ref(),
@@ -202,7 +202,7 @@ impl DisplayLayoutTree {
 
 impl std::fmt::Display for DisplayLayoutTree {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.make_tree(self.layout.clone()) {
+        match self.make_tree(Arc::clone(&self.layout)) {
             Ok(tree) => write!(f, "{}", tree),
             Err(e) => write!(f, "Error building layout tree: {}", e),
         }
@@ -225,29 +225,32 @@ mod tests {
     use vortex_array::dtype::Nullability::NonNullable;
     use vortex_array::dtype::PType;
     use vortex_array::dtype::StructFields;
-    use vortex_array::serde::ArrayParts;
+    use vortex_array::serde::SerializedArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBufferMut;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
     use vortex_utils::env::EnvVarGuard;
 
     use crate::IntoLayout;
     use crate::OwnedLayoutChildren;
     use crate::layouts::chunked::ChunkedLayout;
-    use crate::layouts::flat::FlatVTable;
+    use crate::layouts::flat::Flat;
     use crate::layouts::flat::writer::FlatLayoutStrategy;
     use crate::layouts::struct_::StructLayout;
     use crate::segments::TestSegments;
     use crate::sequence::SequenceId;
     use crate::sequence::SequentialArrayStreamExt;
     use crate::strategy::LayoutStrategy;
+    use crate::test::SESSION;
 
     /// Test display_tree with inline array_tree metadata (no segment source needed).
     #[test]
     fn test_display_tree_inline_array_tree() {
         let _guard = EnvVarGuard::set("FLAT_LAYOUT_INLINE_ARRAY_NODE", "1");
         block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
 
@@ -264,10 +267,10 @@ mod tests {
             let layout1 = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx.clone(),
-                    segments.clone(),
-                    array1.to_array_stream().sequenced(ptr1),
+                    Arc::<TestSegments>::clone(&segments),
+                    array1.into_array().to_array_stream().sequenced(ptr1),
                     eof1,
-                    handle.clone(),
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -287,10 +290,14 @@ mod tests {
             let layout2 = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx.clone(),
-                    segments.clone(),
-                    builder.finish().to_array_stream().sequenced(ptr2),
+                    Arc::<TestSegments>::clone(&segments),
+                    builder
+                        .finish()
+                        .into_array()
+                        .to_array_stream()
+                        .sequenced(ptr2),
                     eof2,
-                    handle.clone(),
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -338,6 +345,7 @@ vortex.struct, dtype: {numbers=i64?, strings=utf8}, children: 2, rows: 5
         // Ensure inline array node is disabled for this test
         let _guard = EnvVarGuard::remove("FLAT_LAYOUT_INLINE_ARRAY_NODE");
         block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
 
@@ -347,10 +355,10 @@ vortex.struct, dtype: {numbers=i64?, strings=utf8}, children: 2, rows: 5
             let layout1 = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx.clone(),
-                    segments.clone(),
-                    array1.to_array_stream().sequenced(ptr1),
+                    Arc::<TestSegments>::clone(&segments),
+                    array1.into_array().to_array_stream().sequenced(ptr1),
                     eof1,
-                    handle.clone(),
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -361,10 +369,10 @@ vortex.struct, dtype: {numbers=i64?, strings=utf8}, children: 2, rows: 5
             let layout2 = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx.clone(),
-                    segments.clone(),
-                    array2.to_array_stream().sequenced(ptr2),
+                    Arc::<TestSegments>::clone(&segments),
+                    array2.into_array().to_array_stream().sequenced(ptr2),
                     eof2,
-                    handle.clone(),
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -403,25 +411,26 @@ vortex.chunked, dtype: i32, children: 2, rows: 10
         // Create a simple primitive array
         let array = PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5], Validity::AllValid);
         let layout = block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             FlatLayoutStrategy::default()
                 .write_stream(
                     ctx.clone(),
-                    segments.clone(),
-                    array.to_array_stream().sequenced(ptr),
+                    Arc::<TestSegments>::clone(&segments),
+                    array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap()
         });
 
-        let flat_layout = layout.as_::<FlatVTable>();
+        let flat_layout = layout.as_::<Flat>();
 
         let array_tree = flat_layout
             .array_tree()
             .expect("array_tree should be populated when FLAT_LAYOUT_INLINE_ARRAY_NODE is set");
 
-        let parts = ArrayParts::from_array_tree(array_tree.as_ref().to_vec())
+        let parts = SerializedArray::from_array_tree(array_tree.as_ref().to_vec())
             .expect("should parse array_tree");
         assert_eq!(parts.buffer_lengths(), vec![20]); // 5 i32 values = 20 bytes
 
@@ -445,13 +454,14 @@ vortex.flat, dtype: i32?, segment 0, buffers=[20B], total=20B
         // Create a simple primitive array
         let array = PrimitiveArray::new(buffer![10i64, 20, 30], Validity::NonNullable);
         let layout = block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
-                    array.to_array_stream().sequenced(ptr),
+                    Arc::<TestSegments>::clone(&segments),
+                    array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap()
diff --git a/vortex-layout/src/encoding.rs b/vortex-layout/src/encoding.rs
index d6b0892327e..271a94f9059 100644
--- a/vortex-layout/src/encoding.rs
+++ b/vortex-layout/src/encoding.rs
@@ -7,12 +7,12 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 
 use arcref::ArcRef;
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::dtype::DType;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
+use vortex_session::registry::ReadContext;
 
 use crate::IntoLayout;
 use crate::LayoutChildren;
@@ -35,7 +35,7 @@ pub trait LayoutEncoding: 'static + Send + Sync + Debug + private::Sealed {
         metadata: &[u8],
         segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
     ) -> VortexResult<LayoutRef>;
 }
 
@@ -58,7 +58,7 @@ impl<V: VTable> LayoutEncoding for LayoutEncodingAdapter<V> {
         metadata: &[u8],
         segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
     ) -> VortexResult<LayoutRef> {
         let metadata = <V::Metadata as DeserializeMetadata>::deserialize(metadata)?;
         let layout = V::build(
@@ -128,8 +128,10 @@ impl dyn LayoutEncoding + '_ {
 
 mod private {
     use super::*;
+    use crate::layouts::foreign::ForeignLayoutEncoding;
 
     pub trait Sealed {}
 
     impl<V: VTable> Sealed for LayoutEncodingAdapter<V> {}
+    impl Sealed for ForeignLayoutEncoding {}
 }
diff --git a/vortex-layout/src/flatbuffers.rs b/vortex-layout/src/flatbuffers.rs
index 88010bcd083..02e05b199c8 100644
--- a/vortex-layout/src/flatbuffers.rs
+++ b/vortex-layout/src/flatbuffers.rs
@@ -8,7 +8,6 @@ use flatbuffers::FlatBufferBuilder;
 use flatbuffers::VerifierOptions;
 use flatbuffers::WIPOffset;
 use flatbuffers::root_with_opts;
-use vortex_array::ArrayContext;
 use vortex_array::dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
@@ -16,6 +15,7 @@ use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::layout;
+use vortex_session::registry::ReadContext;
 
 use crate::Layout;
 use crate::LayoutContext;
@@ -45,17 +45,33 @@ static LAYOUT_VERIFIER: LazyLock<VerifierOptions> = LazyLock::new(|| {
 pub fn layout_from_flatbuffer(
     flatbuffer: FlatBuffer,
     dtype: &DType,
-    layout_ctx: &LayoutContext,
-    ctx: &ArrayContext,
+    layout_ctx: &ReadContext,
+    ctx: &ReadContext,
     layouts: &LayoutRegistry,
+) -> VortexResult<LayoutRef> {
+    layout_from_flatbuffer_with_options(flatbuffer, dtype, layout_ctx, ctx, layouts, false)
+}
+
+/// Parse a [`LayoutRef`] from a layout flatbuffer with unknown-encoding behavior control.
+pub fn layout_from_flatbuffer_with_options(
+    flatbuffer: FlatBuffer,
+    dtype: &DType,
+    layout_ctx: &ReadContext,
+    ctx: &ReadContext,
+    layouts: &LayoutRegistry,
+    allow_unknown: bool,
 ) -> VortexResult<LayoutRef> {
     let fb_layout = root_with_opts::<layout::Layout>(&LAYOUT_VERIFIER, &flatbuffer)?;
     let encoding_id = layout_ctx
         .resolve(fb_layout.encoding())
         .ok_or_else(|| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;
-    let encoding = layouts
-        .find(&encoding_id)
-        .ok_or_else(|| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;
+    let encoding = layouts.find(&encoding_id);
+
+    if encoding.is_none() && allow_unknown {
+        return foreign_layout_from_fb(fb_layout, dtype, layout_ctx);
+    }
+    let encoding =
+        encoding.ok_or_else(|| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;
 
     // SAFETY: we validate the flatbuffer above in the `root` call, and extract a loc.
     let viewed_children = unsafe {
@@ -65,6 +81,7 @@ pub fn layout_from_flatbuffer(
             ctx.clone(),
             layout_ctx.clone(),
             layouts.clone(),
+            allow_unknown,
         )
     };
 
@@ -88,6 +105,40 @@ pub fn layout_from_flatbuffer(
     Ok(layout)
 }
 
+fn foreign_layout_from_fb(
+    fb_layout: layout::Layout<'_>,
+    dtype: &DType,
+    layout_ctx: &ReadContext,
+) -> VortexResult<LayoutRef> {
+    let encoding_id = layout_ctx
+        .resolve(fb_layout.encoding())
+        .ok_or_else(|| vortex_err!("Invalid encoding ID: {}", fb_layout.encoding()))?;
+
+    let children = fb_layout
+        .children()
+        .unwrap_or_default()
+        .iter()
+        .map(|child| foreign_layout_from_fb(child, dtype, layout_ctx))
+        .collect::<VortexResult<Vec<_>>>()?;
+
+    Ok(crate::layouts::foreign::new_foreign_layout(
+        encoding_id,
+        dtype.clone(),
+        fb_layout.row_count(),
+        fb_layout
+            .metadata()
+            .map(|m| m.bytes().to_vec())
+            .unwrap_or_default(),
+        fb_layout
+            .segments()
+            .unwrap_or_default()
+            .iter()
+            .map(SegmentId::from)
+            .collect(),
+        children,
+    ))
+}
+
 impl dyn Layout + '_ {
     /// Serialize the layout into a [`FlatBufferBuilder`].
     pub fn flatbuffer_writer<'a>(
@@ -159,3 +210,83 @@ impl WriteFlatBuffer for LayoutFlatBufferWriter<'_> {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use flatbuffers::FlatBufferBuilder;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_flatbuffers::layout as fbl;
+    use vortex_session::registry::ReadContext;
+
+    use super::layout_from_flatbuffer_with_options;
+    use crate::LayoutEncodingId;
+    use crate::session::LayoutSession;
+
+    #[test]
+    fn unknown_layout_encoding_allow_unknown() {
+        let mut fbb = FlatBufferBuilder::new();
+
+        let child_metadata = fbb.create_vector(&[9u8]);
+        let child = fbl::Layout::create(
+            &mut fbb,
+            &fbl::LayoutArgs {
+                encoding: 1,
+                row_count: 3,
+                metadata: Some(child_metadata),
+                children: None,
+                segments: None,
+            },
+        );
+
+        let children = fbb.create_vector(&[child]);
+        let metadata = fbb.create_vector(&[1u8, 2, 3]);
+        let segments = fbb.create_vector(&[7u32]);
+        let root = fbl::Layout::create(
+            &mut fbb,
+            &fbl::LayoutArgs {
+                encoding: 0,
+                row_count: 10,
+                metadata: Some(metadata),
+                children: Some(children),
+                segments: Some(segments),
+            },
+        );
+        fbb.finish_minimal(root);
+        let (buf, start) = fbb.collapse();
+        let layout_buffer = vortex_flatbuffers::FlatBuffer::align_from(
+            vortex_buffer::ByteBuffer::from(buf).slice(start..),
+        );
+
+        let layout_ctx = ReadContext::new([
+            LayoutEncodingId::new_ref("vortex.test.foreign_layout"),
+            LayoutEncodingId::new_ref("vortex.test.foreign_child_layout"),
+        ]);
+        let array_ctx = ReadContext::new([]);
+        let layouts = LayoutSession::default().registry().clone();
+
+        let layout = layout_from_flatbuffer_with_options(
+            layout_buffer,
+            &DType::Variant(Nullability::Nullable),
+            &layout_ctx,
+            &array_ctx,
+            &layouts,
+            true,
+        )
+        .unwrap();
+
+        assert_eq!(layout.encoding_id().as_ref(), "vortex.test.foreign_layout");
+        assert_eq!(layout.row_count(), 10);
+        assert_eq!(layout.metadata(), vec![1, 2, 3]);
+        assert_eq!(layout.segment_ids().len(), 1);
+        assert_eq!(*layout.segment_ids()[0], 7);
+        assert_eq!(layout.nchildren(), 1);
+
+        let child = layout.child(0).unwrap();
+        assert_eq!(
+            child.encoding_id().as_ref(),
+            "vortex.test.foreign_child_layout"
+        );
+        assert_eq!(child.metadata(), vec![9]);
+    }
+}
diff --git a/vortex-layout/src/layout.rs b/vortex-layout/src/layout.rs
index 91df3db8061..0d805623c0f 100644
--- a/vortex-layout/src/layout.rs
+++ b/vortex-layout/src/layout.rs
@@ -96,8 +96,8 @@ impl LayoutChildType {
     pub fn name(&self) -> Arc<str> {
         match self {
             LayoutChildType::Chunk((idx, _offset)) => format!("[{idx}]").into(),
-            LayoutChildType::Auxiliary(name) => name.clone(),
-            LayoutChildType::Transparent(name) => name.clone(),
+            LayoutChildType::Auxiliary(name) => Arc::clone(name),
+            LayoutChildType::Transparent(name) => Arc::clone(name),
             LayoutChildType::Field(name) => name.clone().into(),
         }
     }
@@ -317,16 +317,18 @@ impl<V: VTable> Layout for LayoutAdapter<V> {
 
 mod private {
     use super::*;
+    use crate::layouts::foreign::ForeignLayout;
 
     pub trait Sealed {}
 
     impl<V: VTable> Sealed for LayoutAdapter<V> {}
+    impl Sealed for ForeignLayout {}
 }
 
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::ArrayContext;
+    use vortex_session::registry::ReadContext;
 
     use super::*;
 
@@ -463,7 +465,7 @@ mod tests {
         ];
 
         for field_name in special_fields {
-            let field = LayoutChildType::Field(field_name.clone().into());
+            let field = LayoutChildType::Field(Arc::clone(&field_name).into());
             assert_eq!(field.name(), field_name);
             assert_eq!(field.row_offset(), Some(0));
         }
@@ -482,7 +484,7 @@ mod tests {
         use crate::layouts::struct_::StructLayout;
         use crate::segments::SegmentId;
 
-        let ctx = ArrayContext::empty();
+        let ctx = ReadContext::new([]);
 
         // Create a flat layout for dict values (utf8 strings)
         let dict_values =
@@ -511,7 +513,8 @@ mod tests {
         );
 
         // Create dict layout (column "name")
-        let dict_layout = DictLayout::new(dict_values.clone(), dict_codes.clone()).into_layout();
+        let dict_layout =
+            DictLayout::new(Arc::clone(&dict_values), Arc::clone(&dict_codes)).into_layout();
 
         // Test dict layout display (no direct segments)
         assert_eq!(format!("{}", dict_layout), "vortex.dict(utf8, rows=10)");
@@ -537,7 +540,10 @@ mod tests {
         let chunked_layout = ChunkedLayout::new(
             10,
             DType::Primitive(PType::I64, NonNullable),
-            crate::OwnedLayoutChildren::layout_children(vec![chunk1.clone(), chunk2.clone()]),
+            crate::OwnedLayoutChildren::layout_children(vec![
+                Arc::clone(&chunk1),
+                Arc::clone(&chunk2),
+            ]),
         )
         .into_layout();
 
diff --git a/vortex-layout/src/layouts/buffered.rs b/vortex-layout/src/layouts/buffered.rs
index 26d9e1a394f..aa5d64c67fd 100644
--- a/vortex-layout/src/layouts/buffered.rs
+++ b/vortex-layout/src/layouts/buffered.rs
@@ -9,9 +9,10 @@ use std::sync::atomic::Ordering;
 use async_stream::try_stream;
 use async_trait::async_trait;
 use futures::StreamExt as _;
+use futures::pin_mut;
 use vortex_array::ArrayContext;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_session::VortexSession;
 
 use crate::LayoutRef;
 use crate::LayoutStrategy;
@@ -44,20 +45,18 @@ impl LayoutStrategy for BufferedStrategy {
         &self,
         ctx: ArrayContext,
         segment_sink: SegmentSinkRef,
-        mut stream: SendableSequentialStream,
-        mut eof: SequencePointer,
-        handle: Handle,
+        stream: SendableSequentialStream,
+        eof: SequencePointer,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let dtype = stream.dtype().clone();
         let buffer_size = self.buffer_size;
 
-        // We have no choice but to put our final buffers here!
-        // We cannot hold on to sequence ids across iterations of the stream, otherwise we can
-        // cause deadlocks with other columns that are waiting for us to flush.
-        let mut final_flush = eof.split_off();
-
-        let buffered_bytes_counter = self.buffered_bytes.clone();
+        let buffered_bytes_counter = Arc::clone(&self.buffered_bytes);
         let buffered_stream = try_stream! {
+            let stream = stream.peekable();
+            pin_mut!(stream);
+
             let mut nbytes = 0u64;
             let mut chunks = VecDeque::new();
 
@@ -68,11 +67,21 @@ impl LayoutStrategy for BufferedStrategy {
                 buffered_bytes_counter.fetch_add(chunk_size, Ordering::Relaxed);
                 chunks.push_back(chunk);
 
+                // If this is the last element, flush everything.
+                if stream.as_mut().peek().await.is_none() {
+                    let mut sequence_ptr = sequence_id.descend();
+                    while let Some(chunk) = chunks.pop_front() {
+                        buffered_bytes_counter.fetch_sub(chunk.nbytes(), Ordering::Relaxed);
+                        yield (sequence_ptr.advance(), chunk)
+                    }
+                    break;
+                }
+
                 if nbytes < 2 * buffer_size {
                     continue;
                 };
 
-                // Wait until we're at 2x the buffer size before flushing 1x the buffer size
+                // Wait until we're at 2x the buffer size before flushing 1x the buffer size.
                 // This avoids small tail stragglers being flushed at the end of the file.
                 let mut sequence_ptr = sequence_id.descend();
                 while nbytes > buffer_size {
@@ -85,13 +94,6 @@ impl LayoutStrategy for BufferedStrategy {
                     yield (sequence_ptr.advance(), chunk)
                 }
             }
-
-            // Now the input stream has ended, flush everything
-            while let Some(chunk) = chunks.pop_front() {
-                let chunk_size = chunk.nbytes();
-                buffered_bytes_counter.fetch_sub(chunk_size, Ordering::Relaxed);
-                yield (final_flush.advance(), chunk)
-            }
         };
 
         self.child
@@ -100,7 +102,7 @@ impl LayoutStrategy for BufferedStrategy {
                 segment_sink,
                 SequentialStreamAdapter::new(dtype, buffered_stream).sendable(),
                 eof,
-                handle,
+                session,
             )
             .await
     }
diff --git a/vortex-layout/src/layouts/chunked/mod.rs b/vortex-layout/src/layouts/chunked/mod.rs
index dcca8d84598..af3c8bef4fa 100644
--- a/vortex-layout/src/layouts/chunked/mod.rs
+++ b/vortex-layout/src/layouts/chunked/mod.rs
@@ -6,12 +6,12 @@ pub mod writer;
 
 use std::sync::Arc;
 
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::EmptyMetadata;
 use vortex_array::dtype::DType;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
@@ -28,7 +28,7 @@ use crate::vtable;
 
 vtable!(Chunked);
 
-impl VTable for ChunkedVTable {
+impl VTable for Chunked {
     type Layout = ChunkedLayout;
     type Encoding = ChunkedLayoutEncoding;
     type Metadata = EmptyMetadata;
@@ -90,7 +90,7 @@ impl VTable for ChunkedVTable {
         _metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         _segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        _ctx: &ArrayContext,
+        _ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         Ok(ChunkedLayout::new(
             row_count,
@@ -118,6 +118,10 @@ impl VTable for ChunkedVTable {
 #[derive(Debug)]
 pub struct ChunkedLayoutEncoding;
 
+/// Partitions a column into row-based chunks so that each chunk can be read independently.
+///
+/// Used to break large columns into smaller pieces for parallel I/O and to limit memory
+/// usage when scanning.
 #[derive(Clone, Debug)]
 pub struct ChunkedLayout {
     row_count: u64,
diff --git a/vortex-layout/src/layouts/chunked/reader.rs b/vortex-layout/src/layouts/chunked/reader.rs
index c6191625bef..756e5573704 100644
--- a/vortex-layout/src/layouts/chunked/reader.rs
+++ b/vortex-layout/src/layouts/chunked/reader.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::collections::BTreeSet;
+use std::future;
 use std::ops::Range;
 use std::sync::Arc;
 
@@ -11,6 +12,8 @@ use futures::future::BoxFuture;
 use futures::stream::FuturesOrdered;
 use itertools::Itertools;
 use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
 use vortex_array::MaskFuture;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::dtype::DType;
@@ -57,7 +60,7 @@ impl ChunkedReader {
             .map(|idx| Arc::from(format!("{name}.[{idx}]")))
             .collect();
         let lazy_children = LazyReaderChildren::new(
-            layout.children.clone(),
+            Arc::clone(&layout.children),
             dtypes,
             names,
             segment_source,
@@ -224,7 +227,7 @@ impl LayoutReader for ChunkedReader {
             chunk_evals.push(chunk_eval);
         }
 
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         Ok(MaskFuture::new(mask.len(), async move {
             tracing::debug!(
                 "Chunked pruning evaluation {} (mask = {})",
@@ -267,7 +270,7 @@ impl LayoutReader for ChunkedReader {
             chunk_evals.push(chunk_eval);
         }
 
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         Ok(MaskFuture::new(mask.len(), async move {
             tracing::debug!("Chunked mask evaluation {}", name);
 
@@ -292,7 +295,7 @@ impl LayoutReader for ChunkedReader {
     ) -> VortexResult<BoxFuture<'static, VortexResult<ArrayRef>>> {
         let dtype = expr.return_dtype(self.dtype())?;
         if row_range.is_empty() {
-            return Ok(async move { Ok(ChunkedArray::try_new(vec![], dtype)?.to_array()) }.boxed());
+            return Ok(future::ready(Ok(Canonical::empty(&dtype).into_array())).boxed());
         }
 
         let mut chunk_evals = vec![];
@@ -317,7 +320,7 @@ impl LayoutReader for ChunkedReader {
             }
 
             // Combine the arrays.
-            Ok(ChunkedArray::try_new(chunks, dtype)?.to_array())
+            Ok(ChunkedArray::try_new(chunks, dtype)?.into_array())
         }
         .boxed())
     }
@@ -340,6 +343,7 @@ mod test {
     use vortex_array::expr::root;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
 
     use crate::LayoutRef;
     use crate::LayoutStrategy;
@@ -360,22 +364,26 @@ mod test {
         let segments = Arc::new(TestSegments::default());
         let strategy = ChunkedLayoutStrategy::new(FlatLayoutStrategy::default());
         let (mut sequence_id, eof) = SequenceId::root().split();
-        let layout = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments.clone(),
-                SequentialStreamAdapter::new(
-                    DType::Primitive(PType::I32, NonNullable),
-                    stream::iter([
-                        Ok((sequence_id.advance(), buffer![1, 2, 3].into_array())),
-                        Ok((sequence_id.advance(), buffer![4, 5, 6].into_array())),
-                        Ok((sequence_id.advance(), buffer![7, 8, 9].into_array())),
-                    ]),
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    segments2,
+                    SequentialStreamAdapter::new(
+                        DType::Primitive(PType::I32, NonNullable),
+                        stream::iter([
+                            Ok((sequence_id.advance(), buffer![1, 2, 3].into_array())),
+                            Ok((sequence_id.advance(), buffer![4, 5, 6].into_array())),
+                            Ok((sequence_id.advance(), buffer![7, 8, 9].into_array())),
+                        ]),
+                    )
+                    .sendable(),
+                    eof,
+                    &session,
                 )
-                .sendable(),
-                eof,
-                handle,
-            )
+                .await
         })
         .unwrap();
 
@@ -400,7 +408,7 @@ mod test {
                 .unwrap();
 
             let expected = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9].into_array();
-            assert_arrays_eq!(result.as_ref(), expected.as_ref());
+            assert_arrays_eq!(result, expected);
         })
     }
 }
diff --git a/vortex-layout/src/layouts/chunked/writer.rs b/vortex-layout/src/layouts/chunked/writer.rs
index 67970af124e..29596fadff0 100644
--- a/vortex-layout/src/layouts/chunked/writer.rs
+++ b/vortex-layout/src/layouts/chunked/writer.rs
@@ -11,7 +11,8 @@ use futures::stream;
 use vortex_array::ArrayContext;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_io::session::RuntimeSessionExt;
+use vortex_session::VortexSession;
 
 use crate::IntoLayout;
 use crate::LayoutRef;
@@ -46,11 +47,12 @@ impl LayoutStrategy for ChunkedLayoutStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         mut eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let dtype = stream.dtype().clone();
         let dtype2 = dtype.clone();
-        let chunk_strategy = self.chunk_strategy.clone();
+        let chunk_strategy = Arc::clone(&self.chunk_strategy);
+        let handle = session.handle();
 
         // We spawn each child to allow parallelism when processing chunks.
         let stream = stream! {
@@ -58,12 +60,14 @@ impl LayoutStrategy for ChunkedLayoutStrategy {
             while let Some(chunk) = stream.next().await {
                 let chunk_eof = eof.split_off();
 
-                let chunk_strategy = chunk_strategy.clone();
+                let chunk_strategy = Arc::clone(&chunk_strategy);
                 let ctx = ctx.clone();
-                let segment_sink = segment_sink.clone();
+                let segment_sink = Arc::clone(&segment_sink);
                 let dtype = dtype2.clone();
+                let session = session.clone();
 
                 yield handle.spawn_nested(move |handle| async move {
+                    let session = session.with_handle(handle);
                     chunk_strategy
                         .write_stream(
                             ctx,
@@ -74,7 +78,7 @@ impl LayoutStrategy for ChunkedLayoutStrategy {
                             )
                             .sendable(),
                             chunk_eof,
-                            handle,
+                            &session,
                         )
                         .await
                 })
diff --git a/vortex-layout/src/layouts/collect.rs b/vortex-layout/src/layouts/collect.rs
index d006ea35746..916d63ce485 100644
--- a/vortex-layout/src/layouts/collect.rs
+++ b/vortex-layout/src/layouts/collect.rs
@@ -8,10 +8,11 @@ use async_trait::async_trait;
 use futures::StreamExt;
 use futures::pin_mut;
 use vortex_array::ArrayContext;
+use vortex_array::IntoArray;
 use vortex_array::arrays::ChunkedArray;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_session::VortexSession;
 
 use crate::LayoutRef;
 use crate::LayoutStrategy;
@@ -43,7 +44,7 @@ impl LayoutStrategy for CollectStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         // Read the whole stream, then write one Chunked stream to the inner thing
         let dtype = stream.dtype().clone();
@@ -60,14 +61,14 @@ impl LayoutStrategy for CollectStrategy {
                 chunks.push(chunk);
             }
 
-            let collected = ChunkedArray::try_new(chunks, _dtype)?.to_array();
+            let collected = ChunkedArray::try_new(chunks, _dtype)?.into_array();
             yield (latest_sequence_id.vortex_expect("must have visited at least one chunk"), collected);
         };
 
         let adapted = Box::pin(SequentialStreamAdapter::new(dtype, collected_stream));
 
         self.child
-            .write_stream(ctx, segment_sink, adapted, eof, handle)
+            .write_stream(ctx, segment_sink, adapted, eof, session)
             .await
     }
 
diff --git a/vortex-layout/src/layouts/compressed.rs b/vortex-layout/src/layouts/compressed.rs
index 91661e92c77..24dc2a02874 100644
--- a/vortex-layout/src/layouts/compressed.rs
+++ b/vortex-layout/src/layouts/compressed.rs
@@ -5,15 +5,13 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use futures::StreamExt as _;
-use vortex_array::Array;
 use vortex_array::ArrayContext;
 use vortex_array::ArrayRef;
 use vortex_array::expr::stats::Stat;
 use vortex_btrblocks::BtrBlocksCompressor;
-use vortex_btrblocks::BtrBlocksCompressorBuilder;
-use vortex_btrblocks::IntCode;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_io::session::RuntimeSessionExt;
+use vortex_session::VortexSession;
 
 use crate::LayoutRef;
 use crate::LayoutStrategy;
@@ -26,27 +24,27 @@ use crate::sequence::SequentialStreamExt;
 /// A boxed compressor function from arrays into compressed arrays.
 ///
 /// API consumers are free to implement this trait to provide new plugin compressors.
-pub trait CompressorPlugin: std::fmt::Debug + Send + Sync + 'static {
-    fn compress_chunk(&self, chunk: &dyn Array) -> VortexResult<ArrayRef>;
+pub trait CompressorPlugin: Send + Sync + 'static {
+    fn compress_chunk(&self, chunk: &ArrayRef) -> VortexResult<ArrayRef>;
 }
 
 impl CompressorPlugin for Arc<dyn CompressorPlugin> {
-    fn compress_chunk(&self, chunk: &dyn Array) -> VortexResult<ArrayRef> {
+    fn compress_chunk(&self, chunk: &ArrayRef) -> VortexResult<ArrayRef> {
         self.as_ref().compress_chunk(chunk)
     }
 }
 
 impl<F> CompressorPlugin for F
 where
-    F: Fn(&dyn Array) -> VortexResult<ArrayRef> + Send + Sync + 'static + std::fmt::Debug,
+    F: Fn(&ArrayRef) -> VortexResult<ArrayRef> + Send + Sync + 'static,
 {
-    fn compress_chunk(&self, chunk: &dyn Array) -> VortexResult<ArrayRef> {
+    fn compress_chunk(&self, chunk: &ArrayRef) -> VortexResult<ArrayRef> {
         self(chunk)
     }
 }
 
 impl CompressorPlugin for BtrBlocksCompressor {
-    fn compress_chunk(&self, chunk: &dyn Array) -> VortexResult<ArrayRef> {
+    fn compress_chunk(&self, chunk: &ArrayRef) -> VortexResult<ArrayRef> {
         self.compress(chunk)
     }
 }
@@ -60,32 +58,11 @@ pub struct CompressingStrategy {
 }
 
 impl CompressingStrategy {
-    /// Create a new writer that uses the BtrBlocks-style cascading compressor to compress chunks.
-    ///
-    /// This provides a good balance between decoding speed and small file size.
-    ///
-    /// Set `exclude_int_dict_encoding` to true to prevent dictionary encoding of integer arrays,
-    /// which is useful when compressing dictionary codes to avoid recursive dictionary encoding.
-    pub fn new_btrblocks<S: LayoutStrategy>(child: S, exclude_int_dict_encoding: bool) -> Self {
-        let compressor = if exclude_int_dict_encoding {
-            BtrBlocksCompressorBuilder::default()
-                .exclude_int([IntCode::Dict])
-                .build()
-        } else {
-            BtrBlocksCompressor::default()
-        };
-        Self::new(child, Arc::new(compressor))
-    }
-
-    /// Create a new compressor from a plugin interface.
-    pub fn new_opaque<S: LayoutStrategy, C: CompressorPlugin>(child: S, compressor: C) -> Self {
-        Self::new(child, Arc::new(compressor))
-    }
-
-    fn new<S: LayoutStrategy>(child: S, compressor: Arc<dyn CompressorPlugin>) -> Self {
+    /// Create a new compressing layout strategy with the given child strategy and compressor.
+    pub fn new<S: LayoutStrategy, C: CompressorPlugin>(child: S, compressor: C) -> Self {
         Self {
             child: Arc::new(child),
-            compressor,
+            compressor: Arc::new(compressor),
             concurrency: std::thread::available_parallelism()
                 .map(|v| v.get())
                 .unwrap_or(1),
@@ -106,16 +83,16 @@ impl LayoutStrategy for CompressingStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let dtype = stream.dtype().clone();
-        let compressor = self.compressor.clone();
+        let compressor = Arc::clone(&self.compressor);
 
-        let handle2 = handle.clone();
+        let handle = session.handle();
         let stream = stream
             .map(move |chunk| {
-                let compressor = compressor.clone();
-                handle2.spawn_cpu(move || {
+                let compressor = Arc::clone(&compressor);
+                handle.spawn_cpu(move || {
                     let (sequence_id, chunk) = chunk?;
                     // Compute the stats for the chunk prior to compression
                     chunk
@@ -132,7 +109,7 @@ impl LayoutStrategy for CompressingStrategy {
                 segment_sink,
                 SequentialStreamAdapter::new(dtype, stream).sendable(),
                 eof,
-                handle,
+                session,
             )
             .await
     }
diff --git a/vortex-layout/src/layouts/dict/mod.rs b/vortex-layout/src/layouts/dict/mod.rs
index 37cbf6ce372..866cf6587e9 100644
--- a/vortex-layout/src/layouts/dict/mod.rs
+++ b/vortex-layout/src/layouts/dict/mod.rs
@@ -7,7 +7,6 @@ pub mod writer;
 use std::sync::Arc;
 
 use reader::DictReader;
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::ProstMetadata;
 use vortex_array::dtype::DType;
@@ -20,6 +19,7 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
@@ -34,7 +34,7 @@ use crate::vtable;
 
 vtable!(Dict);
 
-impl VTable for DictVTable {
+impl VTable for Dict {
     type Layout = DictLayout;
     type Encoding = DictLayoutEncoding;
     type Metadata = ProstMetadata<DictLayoutMetadata>;
@@ -73,8 +73,8 @@ impl VTable for DictVTable {
 
     fn child(layout: &Self::Layout, idx: usize) -> VortexResult<LayoutRef> {
         match idx {
-            0 => Ok(layout.values.clone()),
-            1 => Ok(layout.codes.clone()),
+            0 => Ok(Arc::clone(&layout.values)),
+            1 => Ok(Arc::clone(&layout.codes)),
             _ => vortex_bail!("Unreachable child index: {}", idx),
         }
     }
@@ -108,7 +108,7 @@ impl VTable for DictVTable {
         metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         _segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        _ctx: &ArrayContext,
+        _ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         let values = children.child(0, dtype)?;
         let codes_nullable = metadata
@@ -116,7 +116,7 @@ impl VTable for DictVTable {
             .map(Nullability::from)
             // The old behaviour (without `is_nullable_codes` metadata) used the nullability
             // of the values (and whole array).
-            // see [`SerdeVTable<DictVTable>::build`].
+            // see [`SerdeVTable<Dict>::build`].
             .unwrap_or_else(|| dtype.nullability());
         let codes = children.child(1, &DType::Primitive(metadata.codes_ptype(), codes_nullable))?;
         Ok(unsafe {
@@ -145,6 +145,10 @@ impl VTable for DictVTable {
 #[derive(Debug)]
 pub struct DictLayoutEncoding;
 
+/// Stores a shared dictionary of values alongside compact integer codes that index into it.
+///
+/// Useful for columns with many repeated values, where storing each value once and
+/// referencing it by index saves significant space.
 #[derive(Clone, Debug)]
 pub struct DictLayout {
     values: LayoutRef,
diff --git a/vortex-layout/src/layouts/dict/reader.rs b/vortex-layout/src/layouts/dict/reader.rs
index 0d795a294db..486bbab14c2 100644
--- a/vortex-layout/src/layouts/dict/reader.rs
+++ b/vortex-layout/src/layouts/dict/reader.rs
@@ -11,7 +11,6 @@ use futures::FutureExt;
 use futures::TryFutureExt;
 use futures::future::BoxFuture;
 use futures::try_join;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::MaskFuture;
@@ -62,7 +61,7 @@ impl DictReader {
         let values_len = usize::try_from(layout.values.row_count())?;
         let values = layout.values.new_reader(
             format!("{name}.values").into(),
-            segment_source.clone(),
+            Arc::clone(&segment_source),
             &session,
         )?;
         let codes =
@@ -106,6 +105,25 @@ impl DictReader {
             .clone()
     }
 
+    // This is the dict values array without canonicalization, if not already canonical
+    fn values_array_uncanonical(&self) -> SharedArrayFuture {
+        // We capture the name, so it may be wrong if we re-use the same reader within multiple
+        // different parent readers. But that's rare...
+        let values_len = self.values_len;
+        self.values_array.get().cloned().unwrap_or_else(|| {
+            self.values
+                .projection_evaluation(
+                    &(0..values_len as u64),
+                    &root(),
+                    MaskFuture::new_true(values_len),
+                )
+                .vortex_expect("must construct dict values array evaluation")
+                .map_err(Arc::new)
+                .boxed()
+                .shared()
+        })
+    }
+
     fn values_eval(&self, expr: Expression) -> SharedArrayFuture {
         // This is unsound since we cannot be sure that all the values are referenced in the query
         // after applying the filter, so if the expression is fallible this might fail when it
@@ -120,7 +138,7 @@ impl DictReader {
         self.values_evals
             .entry(expr.clone())
             .or_insert_with(|| {
-                self.values_array()
+                self.values_array_uncanonical()
                     .map(move |array| {
                         let array = array?.apply(&expr)?;
                         Ok(SharedArray::new(array).into_array())
@@ -206,7 +224,7 @@ impl LayoutReader for DictReader {
         mask: MaskFuture,
     ) -> VortexResult<BoxFuture<'static, VortexResult<ArrayRef>>> {
         // TODO: fix up expr partitioning with fallible & null sensitive annotations
-        let values_eval = self.values_eval(root());
+        let values_eval = self.values_array();
         let codes_eval = self
             .codes
             .projection_evaluation(row_range, &root(), mask)
@@ -226,7 +244,7 @@ impl LayoutReader for DictReader {
                 DictArray::new_unchecked(codes, values)
                     .set_all_values_referenced(all_values_referenced)
             }
-            .to_array()
+            .into_array()
             .optimize()?;
 
             array.apply(&expr)
@@ -257,9 +275,15 @@ mod tests {
     use vortex_array::expr::not;
     use vortex_array::expr::pack;
     use vortex_array::expr::root;
+    use vortex_array::scalar_fn::session::ScalarFnSession;
+    use vortex_array::session::ArraySession;
     use vortex_array::validity::Validity;
     use vortex_error::VortexExpect;
+    use vortex_io::runtime::Handle;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSession;
+    use vortex_io::session::RuntimeSessionExt;
+    use vortex_session::VortexSession;
 
     use crate::LayoutId;
     use crate::LayoutRef;
@@ -272,11 +296,23 @@ mod tests {
     use crate::sequence::SequentialArrayStreamExt;
     use crate::sequence::SequentialStreamAdapter;
     use crate::sequence::SequentialStreamExt;
-    use crate::test::SESSION;
+    use crate::session::LayoutSession;
+
+    // FIXME(ngates): Deprecate the global `runtime::single::block_on` helper and require tests
+    // to call `block_on` on an explicit runtime instance.
+    fn session_with_handle(handle: Handle) -> VortexSession {
+        VortexSession::empty()
+            .with::<ArraySession>()
+            .with::<LayoutSession>()
+            .with::<ScalarFnSession>()
+            .with::<RuntimeSession>()
+            .with_handle(handle)
+    }
 
     #[test]
     fn reading_nested_packs_works() {
         block_on(|handle| async move {
+            let session = session_with_handle(handle);
             let strategy = DictStrategy::new(
                 FlatLayoutStrategy::default(),
                 FlatLayoutStrategy::default(),
@@ -298,7 +334,7 @@ mod tests {
                 ],
                 DType::Utf8(Nullability::Nullable),
             )
-            .to_array();
+            .into_array();
             let array_to_write = array.clone();
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
@@ -306,14 +342,14 @@ mod tests {
             let layout: LayoutRef = strategy
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     SequentialStreamAdapter::new(
                         DType::Utf8(Nullability::Nullable),
                         array_to_write.to_array_stream().sequenced(ptr),
                     )
                     .sendable(),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -327,7 +363,7 @@ mod tests {
             );
             assert!(layout.encoding_id() == LayoutId::new_ref("vortex.dict"));
             let actual = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &session)
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -375,6 +411,7 @@ mod tests {
         #[case] expected: Vec<bool>,
     ) {
         block_on(|handle| async move {
+            let session = session_with_handle(handle);
             let strategy = DictStrategy::new(
                 FlatLayoutStrategy::default(),
                 FlatLayoutStrategy::default(),
@@ -382,21 +419,22 @@ mod tests {
                 DictLayoutOptions::default(),
             );
 
-            let array = VarBinArray::from_iter(data, DType::Utf8(Nullability::Nullable)).to_array();
+            let array =
+                VarBinArray::from_iter(data, DType::Utf8(Nullability::Nullable)).into_array();
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
             let layout: LayoutRef = strategy
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     SequentialStreamAdapter::new(
                         DType::Utf8(Nullability::Nullable),
                         array.to_array_stream().sequenced(ptr),
                     )
                     .sendable(),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -409,7 +447,7 @@ mod tests {
                 )),
             );
             let mask = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &session)
                 .unwrap()
                 .filter_evaluation(&(0..3), &filter, MaskFuture::new_true(3))
                 .unwrap()
@@ -423,6 +461,7 @@ mod tests {
     #[test]
     fn reading_is_null_works() {
         block_on(|handle| async move {
+            let session = session_with_handle(handle);
             let strategy = DictStrategy::new(
                 FlatLayoutStrategy::default(),
                 FlatLayoutStrategy::default(),
@@ -444,7 +483,7 @@ mod tests {
                 ],
                 DType::Utf8(Nullability::Nullable),
             )
-            .to_array();
+            .into_array();
             let array_to_write = array.clone();
             let ctx = ArrayContext::empty();
 
@@ -453,14 +492,14 @@ mod tests {
             let layout: LayoutRef = strategy
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     SequentialStreamAdapter::new(
                         DType::Utf8(Nullability::Nullable),
                         array_to_write.to_array_stream().sequenced(ptr),
                     )
                     .sendable(),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -468,7 +507,7 @@ mod tests {
             let expression = not(is_null(root())); // easier to test not_is_null b/c that's the validity array
             assert_eq!(layout.encoding_id(), LayoutId::new_ref("vortex.dict"));
             let actual = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &session)
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
diff --git a/vortex-layout/src/layouts/dict/writer.rs b/vortex-layout/src/layouts/dict/writer.rs
index 335e53e10ae..a1ca9a2b9df 100644
--- a/vortex-layout/src/layouts/dict/writer.rs
+++ b/vortex-layout/src/layouts/dict/writer.rs
@@ -18,10 +18,9 @@ use futures::pin_mut;
 use futures::stream::BoxStream;
 use futures::stream::once;
 use futures::try_join;
-use vortex_array::Array;
 use vortex_array::ArrayContext;
 use vortex_array::ArrayRef;
-use vortex_array::arrays::DictVTable;
+use vortex_array::arrays::Dict;
 use vortex_array::builders::dict::DictConstraints;
 use vortex_array::builders::dict::DictEncoder;
 use vortex_array::builders::dict::dict_encoder;
@@ -34,7 +33,8 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 use vortex_io::kanal_ext::KanalExt;
-use vortex_io::runtime::Handle;
+use vortex_io::session::RuntimeSessionExt;
+use vortex_session::VortexSession;
 
 use crate::IntoLayout;
 use crate::LayoutRef;
@@ -131,13 +131,13 @@ impl LayoutStrategy for DictStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         mut eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         // Fallback if dtype is not supported
         if !dict_layout_supported(stream.dtype()) {
             return self
                 .fallback
-                .write_stream(ctx, segment_sink, stream, eof, handle)
+                .write_stream(ctx, segment_sink, stream, eof, session)
                 .await;
         }
 
@@ -152,14 +152,14 @@ impl LayoutStrategy for DictStrategy {
             None => true, // empty stream
             Some(chunk) => {
                 let compressed = BtrBlocksCompressor::default().compress(&chunk)?;
-                !compressed.is::<DictVTable>()
+                !compressed.is::<Dict>()
             }
         };
         if should_fallback {
             // first chunk did not compress to dict, or did not exist. Skip dict layout
             return self
                 .fallback
-                .write_stream(ctx, segment_sink, stream, eof, handle)
+                .write_stream(ctx, segment_sink, stream, eof, session)
                 .await;
         }
 
@@ -172,37 +172,42 @@ impl LayoutStrategy for DictStrategy {
         // Each of these pairs becomes a child dict layout.
         let runs = DictionaryTransformer::new(dict_stream);
 
+        let handle = session.handle();
         let dtype2 = dtype.clone();
         let child_layouts = stream! {
             pin_mut!(runs);
 
             while let Some((codes_stream, values_fut)) = runs.next().await {
-                let codes = self.codes.clone();
+                let codes = Arc::clone(&self.codes);
                 let codes_eof = eof.split_off();
                 let ctx2 = ctx.clone();
-                let segment_sink2 = segment_sink.clone();
+                let segment_sink2 = Arc::clone(&segment_sink);
+                let session2 = session.clone();
                 let codes_fut = handle.spawn_nested(move |h| async move {
+                    let session2 = session2.with_handle(h);
                     codes.write_stream(
                         ctx2,
                         segment_sink2,
                         codes_stream.sendable(),
                         codes_eof,
-                        h,
+                        &session2,
                     ).await
                 });
 
-                let values = self.values.clone();
+                let values = Arc::clone(&self.values);
                 let values_eof = eof.split_off();
                 let ctx2 = ctx.clone();
-                let segment_sink2 = segment_sink.clone();
+                let segment_sink2 = Arc::clone(&segment_sink);
                 let dtype2 = dtype2.clone();
+                let session2 = session.clone();
                 let values_layout = handle.spawn_nested(move |h| async move {
+                    let session2 = session2.with_handle(h);
                     values.write_stream(
                         ctx2,
                         segment_sink2,
                         SequentialStreamAdapter::new(dtype2, once(values_fut)).sendable(),
                         values_eof,
-                        h,
+                        &session2,
                     ).await
                 });
 
@@ -541,14 +546,14 @@ enum EncodingState {
     Done((ArrayRef, ArrayRef, ArrayRef)),
 }
 
-fn start_encoding(constraints: &DictConstraints, chunk: &dyn Array) -> VortexResult<EncodingState> {
+fn start_encoding(constraints: &DictConstraints, chunk: &ArrayRef) -> VortexResult<EncodingState> {
     let encoder = dict_encoder(chunk, constraints);
     encode_chunk(encoder, chunk)
 }
 
 fn encode_chunk(
     mut encoder: Box<dyn DictEncoder>,
-    chunk: &dyn Array,
+    chunk: &ArrayRef,
 ) -> VortexResult<EncodingState> {
     let encoded = encoder.encode(chunk);
     match remainder(chunk, encoded.len())? {
@@ -557,7 +562,7 @@ fn encode_chunk(
     }
 }
 
-fn remainder(array: &dyn Array, encoded_len: usize) -> VortexResult<Option<ArrayRef>> {
+fn remainder(array: &ArrayRef, encoded_len: usize) -> VortexResult<Option<ArrayRef>> {
     if encoded_len < array.len() {
         Ok(Some(array.slice(encoded_len..array.len())?))
     } else {
diff --git a/vortex-layout/src/layouts/file_stats.rs b/vortex-layout/src/layouts/file_stats.rs
index 10032dec4c3..f6b779b431d 100644
--- a/vortex-layout/src/layouts/file_stats.rs
+++ b/vortex-layout/src/layouts/file_stats.rs
@@ -8,7 +8,10 @@ use futures::StreamExt;
 use itertools::Itertools;
 use parking_lot::Mutex;
 use vortex_array::ArrayRef;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::ToCanonical as _;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::expr::stats::Stat;
@@ -97,7 +100,7 @@ impl FileStatsAccumulator {
                 .accumulators
                 .lock()
                 .iter_mut()
-                .zip_eq(chunk.unmasked_fields().iter())
+                .zip_eq(chunk.iter_unmasked_fields())
             {
                 acc.push_chunk(field)?;
             }
@@ -108,6 +111,7 @@ impl FileStatsAccumulator {
     }
 
     pub fn stats_sets(&self) -> Vec<StatsSet> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         self.accumulators
             .lock()
             .iter_mut()
@@ -116,7 +120,7 @@ impl FileStatsAccumulator {
                     .vortex_expect("as_stats_table should not fail")
                     .map(|table| {
                         table
-                            .to_stats_set(&self.stats)
+                            .to_stats_set(&self.stats, &mut ctx)
                             .vortex_expect("shouldn't fail to convert table we just created")
                     })
                     .unwrap_or_default()
diff --git a/vortex-layout/src/layouts/flat/mod.rs b/vortex-layout/src/layouts/flat/mod.rs
index 40060ee4a53..6fa95a5e256 100644
--- a/vortex-layout/src/layouts/flat/mod.rs
+++ b/vortex-layout/src/layouts/flat/mod.rs
@@ -7,7 +7,6 @@ pub mod writer;
 use std::env;
 use std::sync::Arc;
 
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::ProstMetadata;
 use vortex_array::dtype::DType;
@@ -16,6 +15,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
@@ -37,7 +37,7 @@ pub(super) fn flat_layout_inline_array_node() -> bool {
 
 vtable!(Flat);
 
-impl VTable for FlatVTable {
+impl VTable for Flat {
     type Layout = FlatLayout;
     type Encoding = FlatLayoutEncoding;
     type Metadata = ProstMetadata<FlatLayoutMetadata>;
@@ -101,7 +101,7 @@ impl VTable for FlatVTable {
         metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         segment_ids: Vec<SegmentId>,
         _children: &dyn LayoutChildren,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         if segment_ids.len() != 1 {
             vortex_bail!("Flat layout must have exactly one segment ID");
@@ -129,17 +129,19 @@ impl VTable for FlatVTable {
 #[derive(Debug)]
 pub struct FlatLayoutEncoding;
 
+/// The terminal node of a layout tree. Stores a single chunk of array data as one serialized
+/// segment on disk.
 #[derive(Clone, Debug)]
 pub struct FlatLayout {
     row_count: u64,
     dtype: DType,
     segment_id: SegmentId,
-    ctx: ArrayContext,
+    ctx: ReadContext,
     array_tree: Option<ByteBuffer>,
 }
 
 impl FlatLayout {
-    pub fn new(row_count: u64, dtype: DType, segment_id: SegmentId, ctx: ArrayContext) -> Self {
+    pub fn new(row_count: u64, dtype: DType, segment_id: SegmentId, ctx: ReadContext) -> Self {
         Self {
             row_count,
             dtype,
@@ -153,7 +155,7 @@ impl FlatLayout {
         row_count: u64,
         dtype: DType,
         segment_id: SegmentId,
-        ctx: ArrayContext,
+        ctx: ReadContext,
         metadata: Option<ByteBuffer>,
     ) -> Self {
         Self {
@@ -171,7 +173,7 @@ impl FlatLayout {
     }
 
     #[inline]
-    pub fn array_ctx(&self) -> &ArrayContext {
+    pub fn array_ctx(&self) -> &ReadContext {
         &self.ctx
     }
 
diff --git a/vortex-layout/src/layouts/flat/reader.rs b/vortex-layout/src/layouts/flat/reader.rs
index 6380803197b..29627e2b4fd 100644
--- a/vortex-layout/src/layouts/flat/reader.rs
+++ b/vortex-layout/src/layouts/flat/reader.rs
@@ -8,14 +8,13 @@ use std::sync::Arc;
 
 use futures::FutureExt;
 use futures::future::BoxFuture;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::MaskFuture;
 use vortex_array::VortexSessionExecute;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldMask;
 use vortex_array::expr::Expression;
-use vortex_array::serde::ArrayParts;
+use vortex_array::serde::SerializedArray;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -73,10 +72,10 @@ impl FlatReader {
             let segment = segment_fut.await?;
             let parts = if let Some(array_tree) = array_tree {
                 // Use the pre-stored flatbuffer from layout metadata combined with segment buffers.
-                ArrayParts::from_flatbuffer_and_segment(array_tree, segment)?
+                SerializedArray::from_flatbuffer_and_segment(array_tree, segment)?
             } else {
                 // Parse the flatbuffer from the segment itself.
-                ArrayParts::try_from(segment)?
+                SerializedArray::try_from(segment)?
             };
             parts
                 .decode(&dtype, row_count, &ctx, &session)
@@ -129,7 +128,7 @@ impl LayoutReader for FlatReader {
             .vortex_expect("Row range begin must fit within FlatLayout size")
             ..usize::try_from(row_range.end)
                 .vortex_expect("Row range end must fit within FlatLayout size");
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         let array = self.array_future();
         let expr = expr.clone();
         let session = self.session.clone();
@@ -187,7 +186,7 @@ impl LayoutReader for FlatReader {
             .vortex_expect("Row range begin must fit within FlatLayout size")
             ..usize::try_from(row_range.end)
                 .vortex_expect("Row range end must fit within FlatLayout size");
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         let array = self.array_future();
         let expr = expr.clone();
 
@@ -236,6 +235,7 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
 
     use crate::LayoutStrategy;
     use crate::layouts::flat::writer::FlatLayoutStrategy;
@@ -247,17 +247,19 @@ mod test {
     #[test]
     fn flat_identity() -> VortexResult<()> {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
-            let array = PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).to_array();
+            let array =
+                PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).into_array();
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await?;
 
@@ -284,18 +286,20 @@ mod test {
     #[test]
     fn flat_expr() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
 
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
-            let array = PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).to_array();
+            let array =
+                PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).into_array();
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -321,17 +325,19 @@ mod test {
     #[test]
     fn flat_unaligned_row_mask() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
-            let array = PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).to_array();
+            let array =
+                PrimitiveArray::new(buffer![1, 2, 3, 4, 5], Validity::AllValid).into_array();
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -345,7 +351,7 @@ mod test {
                 .unwrap();
 
             let expected = PrimitiveArray::new(buffer![3i32, 4], Validity::AllValid).into_array();
-            assert_arrays_eq!(result.as_ref(), expected.as_ref());
+            assert_arrays_eq!(result, expected);
         })
     }
 }
diff --git a/vortex-layout/src/layouts/flat/writer.rs b/vortex-layout/src/layouts/flat/writer.rs
index 729d140160d..0d804ee6fb8 100644
--- a/vortex-layout/src/layouts/flat/writer.rs
+++ b/vortex-layout/src/layouts/flat/writer.rs
@@ -3,8 +3,8 @@
 
 use async_trait::async_trait;
 use futures::StreamExt;
-use vortex_array::Array;
 use vortex_array::ArrayContext;
+use vortex_array::ArrayId;
 use vortex_array::dtype::DType;
 use vortex_array::expr::stats::Precision;
 use vortex_array::expr::stats::Stat;
@@ -16,14 +16,15 @@ use vortex_array::scalar::ScalarTruncation;
 use vortex_array::scalar::lower_bound;
 use vortex_array::scalar::upper_bound;
 use vortex_array::serde::SerializeOptions;
-use vortex_array::session::ArrayRegistry;
 use vortex_array::stats::StatsSetRef;
 use vortex_buffer::BufferString;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_io::runtime::Handle;
+use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
+use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::IntoLayout;
 use crate::LayoutRef;
@@ -42,7 +43,7 @@ pub struct FlatLayoutStrategy {
     pub max_variable_length_statistics_size: usize,
     /// Optional set of allowed array encodings for normalization.
     /// If None, then all are allowed.
-    pub allowed_encodings: Option<ArrayRegistry>,
+    pub allowed_encodings: Option<HashSet<ArrayId>>,
 }
 
 impl Default for FlatLayoutStrategy {
@@ -69,7 +70,7 @@ impl FlatLayoutStrategy {
     }
 
     /// Set the allowed array encodings for normalization.
-    pub fn with_allow_encodings(mut self, allow_encodings: ArrayRegistry) -> Self {
+    pub fn with_allow_encodings(mut self, allow_encodings: HashSet<ArrayId>) -> Self {
         self.allowed_encodings = Some(allow_encodings);
         self
     }
@@ -99,7 +100,7 @@ impl LayoutStrategy for FlatLayoutStrategy {
         segment_sink: SegmentSinkRef,
         mut stream: SendableSequentialStream,
         _eof: SequencePointer,
-        _handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let ctx = ctx.clone();
         let Some(chunk) = stream.next().await else {
@@ -160,6 +161,7 @@ impl LayoutStrategy for FlatLayoutStrategy {
 
         let buffers = chunk.serialize(
             &ctx,
+            session,
             &SerializeOptions {
                 offset: 0,
                 include_padding: self.include_padding,
@@ -178,7 +180,7 @@ impl LayoutStrategy for FlatLayoutStrategy {
             row_count,
             stream.dtype().clone(),
             segment_id,
-            ctx.clone(),
+            ReadContext::new(ctx.to_ids()),
             array_node,
         )
         .into_layout())
@@ -194,18 +196,17 @@ impl LayoutStrategy for FlatLayoutStrategy {
 mod tests {
     use std::sync::Arc;
 
-    use vortex_array::Array;
     use vortex_array::ArrayContext;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::MaskFuture;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::BoolArray;
+    use vortex_array::arrays::Dict;
     use vortex_array::arrays::DictArray;
-    use vortex_array::arrays::DictVTable;
     use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::arrays::PrimitiveVTable;
     use vortex_array::arrays::StructArray;
+    use vortex_array::arrays::struct_::StructArrayExt;
     use vortex_array::builders::ArrayBuilder;
     use vortex_array::builders::VarBinViewBuilder;
     use vortex_array::dtype::DType;
@@ -216,15 +217,17 @@ mod tests {
     use vortex_array::expr::stats::Precision;
     use vortex_array::expr::stats::Stat;
     use vortex_array::expr::stats::StatsProviderExt;
-    use vortex_array::session::ArrayRegistry;
     use vortex_array::validity::Validity;
+    use vortex_array::vtable::VTable;
     use vortex_buffer::BitBufferMut;
     use vortex_buffer::buffer;
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
     use vortex_mask::AllOr;
     use vortex_mask::Mask;
+    use vortex_utils::aliases::hash_set::HashSet;
 
     use crate::LayoutStrategy;
     use crate::layouts::flat::writer::FlatLayoutStrategy;
@@ -239,6 +242,7 @@ mod tests {
     #[test]
     fn flat_stats() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -246,10 +250,10 @@ mod tests {
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
-                    array.to_array_stream().sequenced(ptr),
+                    Arc::<TestSegments>::clone(&segments),
+                    array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -276,6 +280,7 @@ mod tests {
     #[test]
     fn truncates_variable_size_stats() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -295,10 +300,10 @@ mod tests {
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
-                    array.to_array_stream().sequenced(ptr),
+                    Arc::<TestSegments>::clone(&segments),
+                    array.into_array().to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -335,6 +340,7 @@ mod tests {
     #[test]
     fn struct_array_round_trip() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let mut validity_builder = BitBufferMut::with_capacity(2);
             validity_builder.append(true);
             validity_builder.append(false);
@@ -362,10 +368,10 @@ mod tests {
                 let layout = FlatLayoutStrategy::default()
                     .write_stream(
                         ctx,
-                        segments.clone(),
-                        array.to_array_stream().sequenced(ptr),
+                        Arc::<TestSegments>::clone(&segments),
+                        array.into_array().to_array_stream().sequenced(ptr),
                         eof,
-                        handle,
+                        &session,
                     )
                     .await
                     .unwrap();
@@ -414,6 +420,7 @@ mod tests {
     #[test]
     fn flat_invalid_array_fails() -> VortexResult<()> {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let prim: PrimitiveArray = (0..10).collect();
             let filter = prim.filter(Mask::from_indices(10, vec![2, 3]))?;
 
@@ -423,17 +430,16 @@ mod tests {
             let (layout, _segments) = {
                 let segments = Arc::new(TestSegments::default());
                 let (ptr, eof) = SequenceId::root().split();
-                // Only allow primitive encodings - filter arrays should fail.
-                let allowed = ArrayRegistry::default();
-                allowed.register(PrimitiveVTable::ID, PrimitiveVTable);
+                // Disallow all encodings so filter arrays fail normalization immediately.
+                let allowed = HashSet::default();
                 let layout = FlatLayoutStrategy::default()
                     .with_allow_encodings(allowed)
                     .write_stream(
                         ctx,
-                        segments.clone(),
-                        filter.to_array_stream().sequenced(ptr),
+                        Arc::<TestSegments>::clone(&segments),
+                        filter.into_array().to_array_stream().sequenced(ptr),
                         eof,
-                        handle,
+                        &session,
                     )
                     .await;
 
@@ -454,6 +460,7 @@ mod tests {
     #[test]
     fn flat_valid_array_writes() -> VortexResult<()> {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let codes: PrimitiveArray = (0u32..10).collect();
             let values: PrimitiveArray = (0..10).collect();
             let dict = DictArray::new(codes.into_array(), values.into_array());
@@ -464,18 +471,17 @@ mod tests {
             let (layout, _segments) = {
                 let segments = Arc::new(TestSegments::default());
                 let (ptr, eof) = SequenceId::root().split();
-                // Only allow primitive encodings - filter arrays should fail.
-                let allowed = ArrayRegistry::default();
-                allowed.register(PrimitiveVTable::ID, PrimitiveVTable);
-                allowed.register(DictVTable::ID, DictVTable);
+                // Only allow the dict encoding; canonical primitive children remain permitted.
+                let mut allowed = HashSet::default();
+                allowed.insert(Dict.id());
                 let layout = FlatLayoutStrategy::default()
                     .with_allow_encodings(allowed)
                     .write_stream(
                         ctx,
-                        segments.clone(),
-                        dict.to_array_stream().sequenced(ptr),
+                        Arc::<TestSegments>::clone(&segments),
+                        dict.into_array().to_array_stream().sequenced(ptr),
                         eof,
-                        handle,
+                        &session,
                     )
                     .await;
 
diff --git a/vortex-layout/src/layouts/foreign/mod.rs b/vortex-layout/src/layouts/foreign/mod.rs
new file mode 100644
index 00000000000..358e2a42be1
--- /dev/null
+++ b/vortex-layout/src/layouts/foreign/mod.rs
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::any::Any;
+use std::sync::Arc;
+
+use vortex_array::dtype::DType;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
+
+use crate::Layout;
+use crate::LayoutChildType;
+use crate::LayoutChildren;
+use crate::LayoutEncoding;
+use crate::LayoutEncodingId;
+use crate::LayoutEncodingRef;
+use crate::LayoutReaderRef;
+use crate::LayoutRef;
+use crate::segments::SegmentId;
+use crate::segments::SegmentSource;
+
+/// Placeholder layout encoding used when deserializing an unknown layout encoding ID.
+#[derive(Clone, Debug)]
+pub(crate) struct ForeignLayoutEncoding {
+    id: LayoutEncodingId,
+}
+
+impl ForeignLayoutEncoding {
+    pub(crate) fn new(id: LayoutEncodingId) -> Self {
+        Self { id }
+    }
+}
+
+impl LayoutEncoding for ForeignLayoutEncoding {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn id(&self) -> LayoutEncodingId {
+        self.id.clone()
+    }
+
+    fn build(
+        &self,
+        dtype: &DType,
+        row_count: u64,
+        metadata: &[u8],
+        segment_ids: Vec<SegmentId>,
+        children: &dyn LayoutChildren,
+        _ctx: &ReadContext,
+    ) -> VortexResult<LayoutRef> {
+        let child_layouts = (0..children.nchildren())
+            .map(|idx| children.child(idx, dtype))
+            .collect::<VortexResult<Vec<_>>>()?;
+
+        Ok(new_foreign_layout(
+            self.id.clone(),
+            dtype.clone(),
+            row_count,
+            metadata.to_vec(),
+            segment_ids,
+            child_layouts,
+        ))
+    }
+}
+
+/// Placeholder layout used when deserializing an unknown layout encoding ID.
+#[derive(Clone, Debug)]
+pub(crate) struct ForeignLayout {
+    encoding: LayoutEncodingRef,
+    dtype: DType,
+    row_count: u64,
+    metadata: Vec<u8>,
+    segment_ids: Vec<SegmentId>,
+    children: Vec<LayoutRef>,
+}
+
+impl ForeignLayout {
+    pub(crate) fn new(
+        encoding_id: LayoutEncodingId,
+        dtype: DType,
+        row_count: u64,
+        metadata: Vec<u8>,
+        segment_ids: Vec<SegmentId>,
+        children: Vec<LayoutRef>,
+    ) -> Self {
+        let encoding =
+            LayoutEncodingRef::new_arc(Arc::new(ForeignLayoutEncoding::new(encoding_id)));
+
+        Self {
+            encoding,
+            dtype,
+            row_count,
+            metadata,
+            segment_ids,
+            children,
+        }
+    }
+}
+
+pub(crate) fn new_foreign_layout(
+    encoding_id: LayoutEncodingId,
+    dtype: DType,
+    row_count: u64,
+    metadata: Vec<u8>,
+    segment_ids: Vec<SegmentId>,
+    children: Vec<LayoutRef>,
+) -> LayoutRef {
+    Arc::new(ForeignLayout::new(
+        encoding_id,
+        dtype,
+        row_count,
+        metadata,
+        segment_ids,
+        children,
+    ))
+}
+
+impl Layout for ForeignLayout {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
+        self
+    }
+
+    fn to_layout(&self) -> LayoutRef {
+        Arc::new(self.clone())
+    }
+
+    fn encoding(&self) -> LayoutEncodingRef {
+        self.encoding.clone()
+    }
+
+    fn row_count(&self) -> u64 {
+        self.row_count
+    }
+
+    fn dtype(&self) -> &DType {
+        &self.dtype
+    }
+
+    fn nchildren(&self) -> usize {
+        self.children.len()
+    }
+
+    fn child(&self, idx: usize) -> VortexResult<LayoutRef> {
+        self.children.get(idx).cloned().ok_or_else(|| {
+            vortex_err!("Child index out of bounds: {} of {}", idx, self.nchildren())
+        })
+    }
+
+    fn child_type(&self, idx: usize) -> LayoutChildType {
+        LayoutChildType::Auxiliary(format!("[{idx}]").into())
+    }
+
+    fn metadata(&self) -> Vec<u8> {
+        self.metadata.clone()
+    }
+
+    fn segment_ids(&self) -> Vec<SegmentId> {
+        self.segment_ids.clone()
+    }
+
+    fn new_reader(
+        &self,
+        _name: Arc<str>,
+        _segment_source: Arc<dyn SegmentSource>,
+        _session: &VortexSession,
+    ) -> VortexResult<LayoutReaderRef> {
+        vortex_bail!(
+            "Cannot read unknown layout encoding '{}'",
+            self.encoding.id()
+        )
+    }
+}
diff --git a/vortex-layout/src/layouts/mod.rs b/vortex-layout/src/layouts/mod.rs
index 03b29a97a8f..18df5b8f347 100644
--- a/vortex-layout/src/layouts/mod.rs
+++ b/vortex-layout/src/layouts/mod.rs
@@ -15,6 +15,7 @@ pub mod compressed;
 pub mod dict;
 pub mod file_stats;
 pub mod flat;
+pub(crate) mod foreign;
 pub(crate) mod partitioned;
 pub mod repartition;
 pub mod row_idx;
diff --git a/vortex-layout/src/layouts/repartition.rs b/vortex-layout/src/layouts/repartition.rs
index 492a01d5015..03c7e15d722 100644
--- a/vortex-layout/src/layouts/repartition.rs
+++ b/vortex-layout/src/layouts/repartition.rs
@@ -8,7 +8,6 @@ use async_stream::try_stream;
 use async_trait::async_trait;
 use futures::StreamExt as _;
 use futures::pin_mut;
-use vortex_array::Array;
 use vortex_array::ArrayContext;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
@@ -16,7 +15,7 @@ use vortex_array::arrays::ChunkedArray;
 use vortex_array::dtype::DType;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_session::VortexSession;
 
 use crate::LayoutRef;
 use crate::LayoutStrategy;
@@ -98,7 +97,7 @@ impl LayoutStrategy for RepartitionStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         // TODO(os): spawn stream below like:
         // canon_stream = stream.map(async {to_canonical}).map(spawn).buffered(parallelism)
@@ -148,7 +147,7 @@ impl LayoutStrategy for RepartitionStrategy {
                         if !chunked.is_empty() {
                             yield (
                                 sequence_pointer.advance(),
-                                chunked.to_canonical()?.into_array(),
+                                chunked.into_array().to_canonical()?.into_array(),
                             )
                         }
                     }
@@ -161,7 +160,7 @@ impl LayoutStrategy for RepartitionStrategy {
                     if !to_flush.is_empty() {
                         yield (
                             sequence_pointer.advance(),
-                            to_flush.to_canonical()?.into_array(),
+                            to_flush.into_array().to_canonical()?.into_array(),
                         )
                     }
                 }
@@ -174,7 +173,7 @@ impl LayoutStrategy for RepartitionStrategy {
                 segment_sink,
                 SequentialStreamAdapter::new(dtype, repartitioned_stream).sendable(),
                 eof,
-                handle,
+                session,
             )
             .await
     }
@@ -266,7 +265,6 @@ impl ChunksBuffer {
 mod tests {
     use std::sync::Arc;
 
-    use vortex_array::Array;
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
     use vortex_array::arrays::ConstantArray;
@@ -279,6 +277,7 @@ mod tests {
     use vortex_array::validity::Validity;
     use vortex_error::VortexResult;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
 
     use super::*;
     use crate::LayoutStrategy;
@@ -287,6 +286,7 @@ mod tests {
     use crate::segments::TestSegments;
     use crate::sequence::SequenceId;
     use crate::sequence::SequentialArrayStreamExt;
+    use crate::test::SESSION;
 
     const ONE_MEG: u64 = 1 << 20;
 
@@ -386,8 +386,18 @@ mod tests {
         );
 
         let stream = fsl.into_array().to_array_stream().sequenced(ptr);
-        let layout =
-            block_on(|handle| strategy.write_stream(ctx, segments.clone(), stream, eof, handle))?;
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    Arc::<TestSegments>::clone(&segments),
+                    stream,
+                    eof,
+                    &session,
+                )
+                .await
+        })?;
 
         // The layout should be a ChunkedLayout with multiple children.
         // With 1000 rows and effective block_len = 132:
@@ -441,8 +451,18 @@ mod tests {
         );
 
         let stream = elements.into_array().to_array_stream().sequenced(ptr);
-        let layout =
-            block_on(|handle| strategy.write_stream(ctx, segments.clone(), stream, eof, handle))?;
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    Arc::<TestSegments>::clone(&segments),
+                    stream,
+                    eof,
+                    &session,
+                )
+                .await
+        })?;
 
         assert_eq!(layout.row_count(), num_elements as u64);
         assert_eq!(layout.nchildren(), 2);
@@ -477,6 +497,7 @@ mod tests {
         let _output = buf.pop_front().unwrap();
 
         // Transition SharedState from Source to Cached for ALL slices sharing this Arc.
+        use vortex_array::arrays::shared::SharedArrayExt;
         shared_handle.get_or_compute(|source| source.to_canonical())?;
 
         // Before the fix this panicked with "attempt to subtract with overflow".
diff --git a/vortex-layout/src/layouts/row_idx/expr.rs b/vortex-layout/src/layouts/row_idx/expr.rs
index 3a7295fe516..c235193ac6c 100644
--- a/vortex-layout/src/layouts/row_idx/expr.rs
+++ b/vortex-layout/src/layouts/row_idx/expr.rs
@@ -49,7 +49,12 @@ impl ScalarFnVTable for RowIdx {
         Ok(DType::Primitive(PType::U64, Nullability::NonNullable))
     }
 
-    fn execute(&self, _options: &Self::Options, _args: ExecutionArgs) -> VortexResult<ArrayRef> {
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        _args: &dyn ExecutionArgs,
+        _ctx: &mut vortex_array::ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
         vortex_bail!(
             "RowIdxExpr should not be executed directly, use it in the context of a Vortex scan and it will be substituted for a row index array"
         );
diff --git a/vortex-layout/src/layouts/row_idx/mod.rs b/vortex-layout/src/layouts/row_idx/mod.rs
index 44b8f012ca6..a4cabee8e45 100644
--- a/vortex-layout/src/layouts/row_idx/mod.rs
+++ b/vortex-layout/src/layouts/row_idx/mod.rs
@@ -9,6 +9,7 @@ use std::fmt::Formatter;
 use std::ops::BitAnd;
 use std::ops::Range;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use Nullability::NonNullable;
 pub use expr::*;
@@ -18,7 +19,6 @@ use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::MaskFuture;
 use vortex_array::VortexSessionExecute;
-use vortex_array::compute::filter;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldMask;
 use vortex_array::dtype::FieldName;
@@ -35,6 +35,7 @@ use vortex_array::scalar::PValue;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
+use vortex_sequence::Sequence;
 use vortex_sequence::SequenceArray;
 use vortex_session::VortexSession;
 use vortex_utils::aliases::dash_map::DashMap;
@@ -47,14 +48,14 @@ pub struct RowIdxLayoutReader {
     name: Arc<str>,
     row_offset: u64,
     child: Arc<dyn LayoutReader>,
-    partition_cache: DashMap<ExactExpr, Partitioning>,
+    partition_cache: DashMap<ExactExpr, Arc<OnceLock<Partitioning>>>,
     session: VortexSession,
 }
 
 impl RowIdxLayoutReader {
     pub fn new(row_offset: u64, child: Arc<dyn LayoutReader>, session: VortexSession) -> Self {
         Self {
-            name: child.name().clone(),
+            name: Arc::clone(child.name()),
             row_offset,
             child,
             partition_cache: DashMap::with_hasher(Default::default()),
@@ -66,45 +67,52 @@ impl RowIdxLayoutReader {
         let key = ExactExpr(expr.clone());
 
         // Check cache first with read-only lock.
-        if let Some(partitioning) = self.partition_cache.get(&key) {
+        if let Some(entry) = self.partition_cache.get(&key)
+            && let Some(partitioning) = entry.value().get()
+        {
             return partitioning.clone();
         }
 
-        self.partition_cache
+        let cell = self
+            .partition_cache
             .entry(key)
-            .or_insert_with(|| {
-                // Partition the expression into row idx and child expressions.
-                let mut partitioned = partition(expr.clone(), self.dtype(), |expr| {
-                    if expr.is::<RowIdx>() {
-                        vec![Partition::RowIdx]
-                    } else if is_root(expr) {
-                        vec![Partition::Child]
-                    } else {
-                        vec![]
-                    }
-                })
-                .vortex_expect("We should not fail to partition expression over struct fields");
-
-                // If there's only a single partition, we can directly return the expression.
-                if partitioned.partitions.len() == 1 {
-                    return match &partitioned.partition_annotations[0] {
-                        Partition::RowIdx => {
-                            Partitioning::RowIdx(replace(expr.clone(), &row_idx(), root()))
-                        }
-                        Partition::Child => Partitioning::Child(expr.clone()),
-                    };
+            .or_insert_with(|| Arc::new(OnceLock::new()))
+            .clone();
+
+        cell.get_or_init(|| self.compute_partitioning(expr)).clone()
+    }
+
+    fn compute_partitioning(&self, expr: &Expression) -> Partitioning {
+        // Partition the expression into row idx and child expressions.
+        let mut partitioned = partition(expr.clone(), self.dtype(), |expr| {
+            if expr.is::<RowIdx>() {
+                vec![Partition::RowIdx]
+            } else if is_root(expr) {
+                vec![Partition::Child]
+            } else {
+                vec![]
+            }
+        })
+        .vortex_expect("We should not fail to partition expression over struct fields");
+
+        // If there's only a single partition, we can directly return the expression.
+        if partitioned.partitions.len() == 1 {
+            return match &partitioned.partition_annotations[0] {
+                Partition::RowIdx => {
+                    Partitioning::RowIdx(replace(expr.clone(), &row_idx(), root()))
                 }
+                Partition::Child => Partitioning::Child(expr.clone()),
+            };
+        }
 
-                // Replace the row_idx expression with the root expression in the row_idx partition.
-                partitioned.partitions = partitioned
-                    .partitions
-                    .into_iter()
-                    .map(|p| replace(p, &row_idx(), root()))
-                    .collect();
+        // Replace the row_idx expression with the root expression in the row_idx partition.
+        partitioned.partitions = partitioned
+            .partitions
+            .into_iter()
+            .map(|p| replace(p, &row_idx(), root()))
+            .collect();
 
-                Partitioning::Partitioned(Arc::new(partitioned))
-            })
-            .clone()
+        Partitioning::Partitioned(Arc::new(partitioned))
     }
 }
 
@@ -197,7 +205,7 @@ impl LayoutReader for RowIdxLayoutReader {
             // during the filter evaluation.
             Partitioning::RowIdx(_) => Ok(mask),
             Partitioning::Child(expr) => self.child.filter_evaluation(row_range, expr, mask),
-            Partitioning::Partitioned(p) => p.clone().into_mask_future(
+            Partitioning::Partitioned(p) => Arc::clone(p).into_mask_future(
                 mask,
                 |annotation, expr, mask| match annotation {
                     Partition::RowIdx => Ok(row_idx_mask_future(
@@ -232,13 +240,12 @@ impl LayoutReader for RowIdxLayoutReader {
             }
             Partitioning::Child(expr) => self.child.projection_evaluation(row_range, expr, mask),
             Partitioning::Partitioned(p) => {
-                p.clone()
-                    .into_array_future(mask, |annotation, expr, mask| match annotation {
-                        Partition::RowIdx => {
-                            Ok(row_idx_array_future(self.row_offset, row_range, expr, mask))
-                        }
-                        Partition::Child => self.child.projection_evaluation(row_range, expr, mask),
-                    })
+                Arc::clone(p).into_array_future(mask, |annotation, expr, mask| match annotation {
+                    Partition::RowIdx => {
+                        Ok(row_idx_array_future(self.row_offset, row_range, expr, mask))
+                    }
+                    Partition::Child => self.child.projection_evaluation(row_range, expr, mask),
+                })
             }
         }
     }
@@ -246,7 +253,7 @@ impl LayoutReader for RowIdxLayoutReader {
 
 // Returns a SequenceArray representing the row indices for the given row range,
 fn idx_array(row_offset: u64, row_range: &Range<u64>) -> SequenceArray {
-    SequenceArray::new(
+    Sequence::try_new(
         PValue::U64(row_offset + row_range.start),
         PValue::U64(1),
         PType::U64,
@@ -286,7 +293,7 @@ fn row_idx_array_future(
     let expr = expr.clone();
     async move {
         let array = idx_array(row_offset, &row_range).into_array();
-        let array = filter(&array, &mask.await?)?;
+        let array = array.filter(mask.await?)?.to_canonical()?.into_array();
         array.apply(&expr)
     }
     .boxed()
@@ -308,6 +315,7 @@ mod tests {
     use vortex_array::expr::root;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
 
     use crate::LayoutReader;
     use crate::LayoutStrategy;
@@ -322,6 +330,7 @@ mod tests {
     #[test]
     fn flat_expr_no_row_id() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -329,10 +338,10 @@ mod tests {
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -362,6 +371,7 @@ mod tests {
     #[test]
     fn flat_expr_row_id() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -369,10 +379,10 @@ mod tests {
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
@@ -402,6 +412,7 @@ mod tests {
     #[test]
     fn flat_expr_or() {
         block_on(|handle| async {
+            let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();
             let segments = Arc::new(TestSegments::default());
             let (ptr, eof) = SequenceId::root().split();
@@ -409,10 +420,10 @@ mod tests {
             let layout = FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     array.to_array_stream().sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
                 .unwrap();
diff --git a/vortex-layout/src/layouts/struct_/mod.rs b/vortex-layout/src/layouts/struct_/mod.rs
index 66e6198662c..3924394ff11 100644
--- a/vortex-layout/src/layouts/struct_/mod.rs
+++ b/vortex-layout/src/layouts/struct_/mod.rs
@@ -2,12 +2,10 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 mod reader;
-pub mod writer;
 
 use std::sync::Arc;
 
 use reader::StructReader;
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::EmptyMetadata;
 use vortex_array::dtype::DType;
@@ -22,6 +20,7 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_session::SessionExt;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
@@ -37,7 +36,7 @@ use crate::vtable;
 
 vtable!(Struct);
 
-impl VTable for StructVTable {
+impl VTable for Struct {
     type Layout = StructLayout;
     type Encoding = StructLayoutEncoding;
     type Metadata = EmptyMetadata;
@@ -131,7 +130,7 @@ impl VTable for StructVTable {
         _metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         _segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        _ctx: &ArrayContext,
+        _ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         let struct_dt = dtype
             .as_struct_fields_opt()
@@ -174,6 +173,9 @@ impl VTable for StructVTable {
 #[derive(Debug)]
 pub struct StructLayoutEncoding;
 
+/// Decomposes a struct-typed column into one child per field, enabling columnar projection.
+///
+/// Queries that only need a subset of fields can skip reading the rest entirely.
 #[derive(Clone, Debug)]
 pub struct StructLayout {
     row_count: u64,
diff --git a/vortex-layout/src/layouts/struct_/reader.rs b/vortex-layout/src/layouts/struct_/reader.rs
index bd6f7354ca6..5d0b2cf0a8d 100644
--- a/vortex-layout/src/layouts/struct_/reader.rs
+++ b/vortex-layout/src/layouts/struct_/reader.rs
@@ -4,6 +4,7 @@
 use std::collections::BTreeSet;
 use std::ops::Range;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use futures::try_join;
 use itertools::Itertools;
@@ -12,6 +13,7 @@ use vortex_array::IntoArray;
 use vortex_array::MaskFuture;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::StructArray;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldMask;
@@ -29,7 +31,6 @@ use vortex_array::expr::transform::replace;
 use vortex_array::expr::transform::replace_root_fields;
 use vortex_array::scalar_fn::fns::merge::Merge;
 use vortex_array::scalar_fn::fns::pack::Pack;
-use vortex_array::vtable::ValidityHelper;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_err;
@@ -57,7 +58,7 @@ pub struct StructReader {
     expanded_root_expr: Expression,
 
     field_lookup: Option<HashMap<FieldName, usize>>,
-    partitioned_expr_cache: DashMap<ExactExpr, Partitioned>,
+    partitioned_expr_cache: DashMap<ExactExpr, Arc<OnceLock<Partitioned>>>,
 }
 
 impl StructReader {
@@ -83,7 +84,7 @@ impl StructReader {
         let mut names: Vec<Arc<str>> = struct_dt
             .names()
             .iter()
-            .map(|x| x.inner().clone())
+            .map(|x| Arc::clone(x.inner()))
             .collect();
 
         if layout.dtype.is_nullable() {
@@ -92,10 +93,10 @@ impl StructReader {
         }
 
         let lazy_children = LazyReaderChildren::new(
-            layout.children.clone(),
+            Arc::clone(&layout.children),
             dtypes,
             names,
-            segment_source.clone(),
+            Arc::clone(&segment_source),
             session.clone(),
         );
 
@@ -152,51 +153,65 @@ impl StructReader {
 
     /// Utility for partitioning an expression over the fields of a struct.
     fn partition_expr(&self, expr: Expression) -> Partitioned {
-        self.partitioned_expr_cache
-            .entry(ExactExpr(expr.clone()))
-            .or_insert_with(|| {
-                // First, we expand the root scope into the fields of the struct to ensure
-                // that partitioning works correctly.
-                let expr = replace(expr.clone(), &root(), self.expanded_root_expr.clone());
-                let expr = expr
-                    .optimize_recursive(self.dtype())
-                    .vortex_expect("We should not fail to simplify expression over struct fields");
-
-                // Partition the expression into expressions that can be evaluated over individual fields
-                let mut partitioned = partition(
-                    expr.clone(),
-                    self.dtype(),
-                    make_free_field_annotator(
-                        self.dtype()
-                            .as_struct_fields_opt()
-                            .vortex_expect("We know it's a struct DType"),
-                    ),
-                )
-                .vortex_expect("We should not fail to partition expression over struct fields");
-
-                if partitioned.partitions.len() == 1 {
-                    // If there's only one partition, we step into the field scope of the original
-                    // expression by replacing any `$.a` with `$`.
-                    return Partitioned::Single(
-                        partitioned.partition_names[0].clone(),
-                        replace(expr, &col(partitioned.partition_names[0].clone()), root()),
-                    );
-                }
+        let key = ExactExpr(expr.clone());
+
+        if let Some(entry) = self.partitioned_expr_cache.get(&key)
+            && let Some(partitioning) = entry.value().get()
+        {
+            return partitioning.clone();
+        }
 
-                // We now need to process the partitioned expressions to rewrite the root scope
-                // to be that of the field, rather than the struct. In other words, "stepping in"
-                // to the field scope.
-                partitioned.partitions = partitioned
-                    .partitions
-                    .iter()
-                    .zip_eq(partitioned.partition_names.iter())
-                    .map(|(e, name)| replace(e.clone(), &col(name.clone()), root()))
-                    .collect();
-
-                Partitioned::Multi(Arc::new(partitioned))
-            })
+        let cell = self
+            .partitioned_expr_cache
+            .entry(key)
+            .or_insert_with(|| Arc::new(OnceLock::new()))
+            .clone();
+
+        cell.get_or_init(|| self.compute_partitioned_expr(expr))
             .clone()
     }
+
+    fn compute_partitioned_expr(&self, expr: Expression) -> Partitioned {
+        // First, we expand the root scope into the fields of the struct to ensure
+        // that partitioning works correctly.
+        let expr = replace(expr, &root(), self.expanded_root_expr.clone());
+        let expr = expr
+            .optimize_recursive(self.dtype())
+            .vortex_expect("We should not fail to simplify expression over struct fields");
+
+        // Partition the expression into expressions that can be evaluated over individual fields
+        let mut partitioned = partition(
+            expr.clone(),
+            self.dtype(),
+            make_free_field_annotator(
+                self.dtype()
+                    .as_struct_fields_opt()
+                    .vortex_expect("We know it's a struct DType"),
+            ),
+        )
+        .vortex_expect("We should not fail to partition expression over struct fields");
+
+        if partitioned.partitions.len() == 1 {
+            // If there's only one partition, we step into the field scope of the original
+            // expression by replacing any `$.a` with `$`.
+            return Partitioned::Single(
+                partitioned.partition_names[0].clone(),
+                replace(expr, &col(partitioned.partition_names[0].clone()), root()),
+            );
+        }
+
+        // We now need to process the partitioned expressions to rewrite the root scope
+        // to be that of the field, rather than the struct. In other words, "stepping in"
+        // to the field scope.
+        partitioned.partitions = partitioned
+            .partitions
+            .iter()
+            .zip_eq(partitioned.partition_names.iter())
+            .map(|(e, name)| replace(e.clone(), &col(name.clone()), root()))
+            .collect();
+
+        Partitioned::Multi(Arc::new(partitioned))
+    }
 }
 
 /// When partitioning an expression, in the case it only has a single partition we can avoid
@@ -279,7 +294,7 @@ impl LayoutReader for StructReader {
                 .map_err(|err| {
                     err.with_context(format!("While evaluating filter partition {name}"))
                 }),
-            Partitioned::Multi(partitioned) => partitioned.clone().into_mask_future(
+            Partitioned::Multi(partitioned) => Arc::clone(partitioned).into_mask_future(
                 mask,
                 |name, expr, mask| {
                     self.field_reader(name)?
@@ -325,17 +340,15 @@ impl LayoutReader for StructReader {
             ),
 
             Partitioned::Multi(partitioned) => (
-                partitioned
-                    .clone()
-                    .into_array_future(mask_fut, |name, expr, mask| {
-                        self.field_reader(name)?
-                            .projection_evaluation(row_range, expr, mask)
-                            .map_err(|err| {
-                                err.with_context(format!(
-                                    "While evaluating projection partition {name}"
-                                ))
-                            })
-                    })?,
+                Arc::clone(partitioned).into_array_future(mask_fut, |name, expr, mask| {
+                    self.field_reader(name)?
+                        .projection_evaluation(row_range, expr, mask)
+                        .map_err(|err| {
+                            err.with_context(format!(
+                                "While evaluating projection partition {name}"
+                            ))
+                        })
+                })?,
                 partitioned.root.is::<Pack>() || partitioned.root.is::<Merge>(),
             ),
         };
@@ -348,8 +361,7 @@ impl LayoutReader for StructReader {
                 if is_pack_merge {
                     let struct_array = array.to_struct();
                     let masked_fields: Vec<ArrayRef> = struct_array
-                        .unmasked_fields()
-                        .iter()
+                        .iter_unmasked_fields()
                         .map(|a| a.clone().mask(validity.clone()))
                         .try_collect()?;
 
@@ -357,7 +369,7 @@ impl LayoutReader for StructReader {
                         struct_array.names().clone(),
                         masked_fields,
                         struct_array.len(),
-                        struct_array.validity().clone(),
+                        struct_array.validity()?,
                     )?
                     .into_array())
                 } else {
@@ -378,7 +390,6 @@ mod tests {
 
     use rstest::fixture;
     use rstest::rstest;
-    use vortex_array::Array;
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
     use vortex_array::MaskFuture;
@@ -386,6 +397,7 @@ mod tests {
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
+    use vortex_array::arrays::struct_::StructArrayExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::assert_nth_scalar;
     use vortex_array::dtype::DType;
@@ -407,6 +419,7 @@ mod tests {
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
     use vortex_mask::Mask;
 
     use crate::LayoutRef;
@@ -429,23 +442,27 @@ mod tests {
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
-        let layout = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments.clone(),
-                StructArray::try_new(
-                    Vec::<FieldName>::new().into(),
-                    vec![],
-                    5,
-                    Validity::NonNullable,
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    segments2,
+                    StructArray::try_new(
+                        Vec::<FieldName>::new().into(),
+                        vec![],
+                        5,
+                        Validity::NonNullable,
+                    )
+                    .unwrap()
+                    .into_array()
+                    .to_array_stream()
+                    .sequenced(ptr),
+                    eof,
+                    &session,
                 )
-                .unwrap()
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
+                .await
         })
         .unwrap();
 
@@ -462,25 +479,29 @@ mod tests {
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
-        let layout = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments.clone(),
-                StructArray::from_fields(
-                    [
-                        ("a", buffer![7, 2, 3].into_array()),
-                        ("b", buffer![4, 5, 6].into_array()),
-                        ("c", buffer![4, 5, 6].into_array()),
-                    ]
-                    .as_slice(),
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    segments2,
+                    StructArray::from_fields(
+                        [
+                            ("a", buffer![7, 2, 3].into_array()),
+                            ("b", buffer![4, 5, 6].into_array()),
+                            ("c", buffer![4, 5, 6].into_array()),
+                        ]
+                        .as_slice(),
+                    )
+                    .unwrap()
+                    .into_array()
+                    .to_array_stream()
+                    .sequenced(ptr),
+                    eof,
+                    &session,
                 )
-                .unwrap()
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
+                .await
         })
         .unwrap();
 
@@ -498,25 +519,29 @@ mod tests {
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
-        let layout = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments.clone(),
-                StructArray::try_from_iter_with_validity(
-                    [
-                        ("a", buffer![7, 2, 3].into_array()),
-                        ("b", buffer![4, 5, 6].into_array()),
-                        ("c", buffer![4, 5, 6].into_array()),
-                    ],
-                    Validity::Array(BoolArray::from_iter([false, true, true]).into_array()),
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    segments2,
+                    StructArray::try_from_iter_with_validity(
+                        [
+                            ("a", buffer![7, 2, 3].into_array()),
+                            ("b", buffer![4, 5, 6].into_array()),
+                            ("c", buffer![4, 5, 6].into_array()),
+                        ],
+                        Validity::Array(BoolArray::from_iter([false, true, true]).into_array()),
+                    )
+                    .unwrap()
+                    .into_array()
+                    .to_array_stream()
+                    .sequenced(ptr),
+                    eof,
+                    &session,
                 )
-                .unwrap()
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
+                .await
         })
         .unwrap();
 
@@ -539,37 +564,43 @@ mod tests {
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
-        let layout = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments.clone(),
-                StructArray::try_from_iter_with_validity(
-                    [(
-                        "a",
-                        StructArray::try_from_iter_with_validity(
-                            [(
-                                "b",
-                                StructArray::try_from_iter_with_validity(
-                                    [("c", buffer![4, 5, 6].into_array())],
-                                    Validity::NonNullable,
-                                )
-                                .unwrap()
-                                .into_array(),
-                            )],
-                            Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
-                        )
-                        .unwrap()
-                        .into_array(),
-                    )],
-                    Validity::NonNullable,
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(
+                    ctx,
+                    segments2,
+                    StructArray::try_from_iter_with_validity(
+                        [(
+                            "a",
+                            StructArray::try_from_iter_with_validity(
+                                [(
+                                    "b",
+                                    StructArray::try_from_iter_with_validity(
+                                        [("c", buffer![4, 5, 6].into_array())],
+                                        Validity::NonNullable,
+                                    )
+                                    .unwrap()
+                                    .into_array(),
+                                )],
+                                Validity::Array(
+                                    BoolArray::from_iter([true, false, true]).into_array(),
+                                ),
+                            )
+                            .unwrap()
+                            .into_array(),
+                        )],
+                        Validity::NonNullable,
+                    )
+                    .unwrap()
+                    .into_array()
+                    .to_array_stream()
+                    .sequenced(ptr),
+                    eof,
+                    &session,
                 )
-                .unwrap()
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
+                .await
         })
         .unwrap();
 
diff --git a/vortex-layout/src/layouts/struct_/writer.rs b/vortex-layout/src/layouts/struct_/writer.rs
deleted file mode 100644
index de2bd019278..00000000000
--- a/vortex-layout/src/layouts/struct_/writer.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-#![allow(deprecated, reason = "This module is deprecated")]
-
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use futures::StreamExt;
-use futures::TryStreamExt;
-use futures::future::try_join_all;
-use futures::pin_mut;
-use itertools::Itertools;
-use vortex_array::Array;
-use vortex_array::ArrayContext;
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::ToCanonical;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::Nullability;
-use vortex_error::VortexError;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_io::kanal_ext::KanalExt;
-use vortex_io::runtime::Handle;
-use vortex_utils::aliases::DefaultHashBuilder;
-use vortex_utils::aliases::hash_set::HashSet;
-
-use crate::IntoLayout as _;
-use crate::LayoutRef;
-use crate::LayoutStrategy;
-use crate::layouts::struct_::StructLayout;
-use crate::segments::SegmentSinkRef;
-use crate::sequence::SendableSequentialStream;
-use crate::sequence::SequenceId;
-use crate::sequence::SequencePointer;
-use crate::sequence::SequentialStreamAdapter;
-use crate::sequence::SequentialStreamExt;
-
-/// A write strategy that shreds tabular data into columns and writes each column
-/// as its own distinct stream.
-///
-/// This is now deprecated, users are encouraged to instead use the
-/// [`TableStrategy`][crate::layouts::table::TableStrategy].
-#[derive(Clone)]
-#[deprecated(since = "0.59.0", note = "Use the `TableStrategy` instead.")]
-pub struct StructStrategy {
-    child: Arc<dyn LayoutStrategy>,
-    validity: Arc<dyn LayoutStrategy>,
-}
-
-/// A [`LayoutStrategy`] that splits a StructArray batch into child layout writers
-impl StructStrategy {
-    pub fn new<S: LayoutStrategy, V: LayoutStrategy>(child: S, validity: V) -> Self {
-        Self {
-            child: Arc::new(child),
-            validity: Arc::new(validity),
-        }
-    }
-}
-
-#[async_trait]
-impl LayoutStrategy for StructStrategy {
-    async fn write_stream(
-        &self,
-        ctx: ArrayContext,
-        segment_sink: SegmentSinkRef,
-        stream: SendableSequentialStream,
-        mut eof: SequencePointer,
-        handle: Handle,
-    ) -> VortexResult<LayoutRef> {
-        let dtype = stream.dtype().clone();
-        let Some(struct_dtype) = stream.dtype().as_struct_fields_opt().cloned() else {
-            return self
-                .child
-                .write_stream(ctx, segment_sink, stream, eof, handle)
-                .await;
-        };
-
-        // Check for unique field names at write time.
-        if HashSet::<_, DefaultHashBuilder>::from_iter(struct_dtype.names().iter()).len()
-            != struct_dtype.names().len()
-        {
-            vortex_bail!("StructLayout must have unique field names");
-        }
-
-        let is_nullable = dtype.is_nullable();
-
-        // Optimization: when there are no fields, don't spawn any work and just write a trivial
-        // StructLayout.
-        if struct_dtype.nfields() == 0 && !is_nullable {
-            let row_count = stream
-                .try_fold(
-                    0u64,
-                    |acc, (_, arr)| async move { Ok(acc + arr.len() as u64) },
-                )
-                .await?;
-            return Ok(StructLayout::new(row_count, dtype, vec![]).into_layout());
-        }
-
-        // stream<struct_chunk> -> stream<vec<column_chunk>>
-        let columns_vec_stream = stream.map(move |chunk| {
-            let (sequence_id, chunk) = chunk?;
-            let mut sequence_pointer = sequence_id.descend();
-            let struct_chunk = chunk.to_struct();
-            let mut columns: Vec<(SequenceId, ArrayRef)> = Vec::new();
-            if is_nullable {
-                columns.push((
-                    sequence_pointer.advance(),
-                    chunk.validity_mask()?.into_array(),
-                ));
-            }
-
-            columns.extend(
-                struct_chunk
-                    .unmasked_fields()
-                    .iter()
-                    .map(|field| (sequence_pointer.advance(), field.to_array())),
-            );
-
-            Ok(columns)
-        });
-
-        let mut stream_count = struct_dtype.nfields();
-        if is_nullable {
-            stream_count += 1;
-        }
-
-        let (column_streams_tx, column_streams_rx): (Vec<_>, Vec<_>) =
-            (0..stream_count).map(|_| kanal::bounded_async(1)).unzip();
-
-        // Spawn a task to fan out column chunks to their respective transposed streams
-        handle
-            .spawn(async move {
-                pin_mut!(columns_vec_stream);
-                while let Some(result) = columns_vec_stream.next().await {
-                    match result {
-                        Ok(columns) => {
-                            for (tx, column) in column_streams_tx.iter().zip_eq(columns.into_iter())
-                            {
-                                let _ = tx.send(Ok(column)).await;
-                            }
-                        }
-                        Err(e) => {
-                            let e: Arc<VortexError> = Arc::new(e);
-                            for tx in column_streams_tx.iter() {
-                                let _ = tx.send(Err(VortexError::from(e.clone()))).await;
-                            }
-                            break;
-                        }
-                    }
-                }
-            })
-            .detach();
-
-        // First child column is the validity, subsequence children are the individual struct fields
-        let column_dtypes: Vec<DType> = if is_nullable {
-            std::iter::once(DType::Bool(Nullability::NonNullable))
-                .chain(struct_dtype.fields())
-                .collect()
-        } else {
-            struct_dtype.fields().collect()
-        };
-
-        let layout_futures: Vec<_> = column_dtypes
-            .into_iter()
-            .zip_eq(column_streams_rx)
-            .enumerate()
-            .map(move |(index, (dtype, recv))| {
-                let column_stream =
-                    SequentialStreamAdapter::new(dtype.clone(), recv.into_stream().boxed())
-                        .sendable();
-                let child_eof = eof.split_off();
-                handle.spawn_nested(|h| {
-                    let child = self.child.clone();
-                    let validity = self.validity.clone();
-                    let this = self.clone();
-                    let ctx = ctx.clone();
-                    let dtype = dtype.clone();
-                    let segment_sink = segment_sink.clone();
-                    async move {
-                        // Write validity stream
-                        if index == 0 && is_nullable {
-                            validity
-                                .write_stream(ctx, segment_sink, column_stream, child_eof, h)
-                                .await
-                        } else {
-                            // Build recursive StructLayout for nested struct fields
-                            // TODO(aduffy): add branch for ListLayout once that's implemented
-                            if dtype.is_struct() {
-                                this.write_stream(ctx, segment_sink, column_stream, child_eof, h)
-                                    .await
-                            } else {
-                                child
-                                    .write_stream(ctx, segment_sink, column_stream, child_eof, h)
-                                    .await
-                            }
-                        }
-                    }
-                })
-            })
-            .collect();
-
-        let column_layouts = try_join_all(layout_futures).await?;
-        // TODO(os): transposed stream could count row counts as well,
-        // This must hold though, all columns must have the same row count of the struct layout
-        let row_count = column_layouts.first().map(|l| l.row_count()).unwrap_or(0);
-        Ok(StructLayout::new(row_count, dtype, column_layouts).into_layout())
-    }
-
-    fn buffered_bytes(&self) -> u64 {
-        self.child.buffered_bytes()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use vortex_array::ArrayContext;
-    use vortex_array::Canonical;
-    use vortex_array::IntoArray as _;
-    use vortex_array::arrays::ChunkedArray;
-    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::validity::Validity;
-    use vortex_io::runtime::single::block_on;
-
-    use crate::LayoutStrategy;
-    use crate::layouts::flat::writer::FlatLayoutStrategy;
-    use crate::layouts::struct_::writer::StructStrategy;
-    use crate::segments::TestSegments;
-    use crate::sequence::SequenceId;
-    use crate::sequence::SequentialArrayStreamExt;
-
-    #[test]
-    #[should_panic]
-    fn fails_on_duplicate_field() {
-        let strategy =
-            StructStrategy::new(FlatLayoutStrategy::default(), FlatLayoutStrategy::default());
-        let (ptr, eof) = SequenceId::root().split();
-        let ctx = ArrayContext::empty();
-
-        let segments = Arc::new(TestSegments::default());
-        block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments,
-                Canonical::empty(&DType::Struct(
-                    [
-                        ("a", DType::Primitive(PType::I32, Nullability::NonNullable)),
-                        ("a", DType::Primitive(PType::I32, Nullability::NonNullable)),
-                    ]
-                    .into_iter()
-                    .collect(),
-                    Nullability::NonNullable,
-                ))
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
-        })
-        .unwrap();
-    }
-
-    #[test]
-    fn write_empty_field_struct_array() {
-        let strategy =
-            StructStrategy::new(FlatLayoutStrategy::default(), FlatLayoutStrategy::default());
-        let (ptr, eof) = SequenceId::root().split();
-        let ctx = ArrayContext::empty();
-
-        let segments = Arc::new(TestSegments::default());
-        let res = block_on(|handle| {
-            strategy.write_stream(
-                ctx,
-                segments,
-                ChunkedArray::from_iter([
-                    StructArray::try_new(FieldNames::default(), vec![], 3, Validity::NonNullable)
-                        .unwrap()
-                        .into_array(),
-                    StructArray::try_new(FieldNames::default(), vec![], 5, Validity::NonNullable)
-                        .unwrap()
-                        .into_array(),
-                ])
-                .into_array()
-                .to_array_stream()
-                .sequenced(ptr),
-                eof,
-                handle,
-            )
-        });
-
-        assert_eq!(res.unwrap().row_count(), 8);
-    }
-}
diff --git a/vortex-layout/src/layouts/table.rs b/vortex-layout/src/layouts/table.rs
index c8fb8ac6eda..f8a0cee3581 100644
--- a/vortex-layout/src/layouts/table.rs
+++ b/vortex-layout/src/layouts/table.rs
@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! A more configurable variant of the `StructStrategy` that allows overwriting
-//! specific leaf fields with custom write strategies.
+//! A configurable writer strategy for tabular data.
+//!
+//! Allows the caller to override specific leaf fields with custom layout strategies.
 
 use std::sync::Arc;
 
@@ -16,6 +17,7 @@ use vortex_array::ArrayContext;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Field;
 use vortex_array::dtype::FieldName;
@@ -25,7 +27,8 @@ use vortex_error::VortexError;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_io::kanal_ext::KanalExt;
-use vortex_io::runtime::Handle;
+use vortex_io::session::RuntimeSessionExt;
+use vortex_session::VortexSession;
 use vortex_utils::aliases::DefaultHashBuilder;
 use vortex_utils::aliases::hash_map::HashMap;
 use vortex_utils::aliases::hash_set::HashSet;
@@ -68,7 +71,7 @@ impl TableStrategy {
     /// // Build a write strategy that does not compress validity or any leaf fields.
     /// let flat = Arc::new(FlatLayoutStrategy::default());
     ///
-    /// let strategy = TableStrategy::new(flat.clone(), flat.clone());
+    /// let strategy = TableStrategy::new(Arc::<FlatLayoutStrategy>::clone(&flat), Arc::<FlatLayoutStrategy>::clone(&flat));
     /// ```
     pub fn new(validity: Arc<dyn LayoutStrategy>, fallback: Arc<dyn LayoutStrategy>) -> Self {
         Self {
@@ -85,12 +88,14 @@ impl TableStrategy {
     /// ```ignore
     /// # use std::sync::Arc;
     /// # use vortex_array::dtype::{field_path, Field, FieldPath};
+    /// # use vortex_btrblocks::BtrBlocksCompressor;
     /// # use vortex_layout::layouts::compressed::CompressingStrategy;
     /// # use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
     /// # use vortex_layout::layouts::table::TableStrategy;
     ///
     /// // A strategy for compressing data using the balanced BtrBlocks compressor.
-    /// let compress = CompressingStrategy::new_btrblocks(FlatLayoutStrategy::default(), true);
+    /// let compress =
+    ///     CompressingStrategy::new(FlatLayoutStrategy::default(), BtrBlocksCompressor::default());
     ///
     /// // Our combined strategy uses no compression for validity buffers, BtrBlocks compression
     /// // for most columns, and stores a nested binary column uncompressed (flat) because it
@@ -152,14 +157,14 @@ impl TableStrategy {
             if field_path.starts_with_field(field)
                 && let Some(subpath) = field_path.clone().step_into()
             {
-                new_writers.insert(subpath, strategy.clone());
+                new_writers.insert(subpath, Arc::clone(strategy));
             }
         }
 
         Self {
             leaf_writers: new_writers,
-            validity: self.validity.clone(),
-            fallback: self.fallback.clone(),
+            validity: Arc::clone(&self.validity),
+            fallback: Arc::clone(&self.fallback),
         }
     }
 
@@ -191,7 +196,7 @@ impl LayoutStrategy for TableStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         mut eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         let dtype = stream.dtype().clone();
 
@@ -199,7 +204,7 @@ impl LayoutStrategy for TableStrategy {
         if !dtype.is_struct() {
             return self
                 .fallback
-                .write_stream(ctx, segment_sink, stream, eof, handle)
+                .write_stream(ctx, segment_sink, stream, eof, session)
                 .await;
         }
 
@@ -240,9 +245,8 @@ impl LayoutStrategy for TableStrategy {
 
             columns.extend(
                 struct_chunk
-                    .unmasked_fields()
-                    .iter()
-                    .map(|field| (sequence_pointer.advance(), field.to_array())),
+                    .iter_unmasked_fields()
+                    .map(|field| (sequence_pointer.advance(), field.clone())),
             );
 
             Ok(columns)
@@ -257,6 +261,7 @@ impl LayoutStrategy for TableStrategy {
             (0..stream_count).map(|_| kanal::bounded_async(1)).unzip();
 
         // Spawn a task to fan out column chunks to their respective transposed streams
+        let handle = session.handle();
         handle
             .spawn(async move {
                 pin_mut!(columns_vec_stream);
@@ -271,7 +276,7 @@ impl LayoutStrategy for TableStrategy {
                         Err(e) => {
                             let e: Arc<VortexError> = Arc::new(e);
                             for tx in column_streams_tx.iter() {
-                                let _ = tx.send(Err(VortexError::from(e.clone()))).await;
+                                let _ = tx.send(Err(VortexError::from(Arc::clone(&e)))).await;
                             }
                             break;
                         }
@@ -308,8 +313,11 @@ impl LayoutStrategy for TableStrategy {
                         .sendable();
                 let child_eof = eof.split_off();
                 let field = Field::Name(name.clone());
-                handle.spawn_nested(|h| {
-                    let validity = self.validity.clone();
+                let session = session.clone();
+                let ctx = ctx.clone();
+                let segment_sink = Arc::clone(&segment_sink);
+                handle.spawn_nested(move |h| {
+                    let validity = Arc::clone(&self.validity);
                     // descend further and try with new fields
                     let writer = self
                         .leaf_writers
@@ -321,11 +329,10 @@ impl LayoutStrategy for TableStrategy {
                                 Arc::new(self.descend(&field))
                             } else {
                                 // Use fallback for leaf columns
-                                self.fallback.clone()
+                                Arc::clone(&self.fallback)
                             }
                         });
-                    let ctx = ctx.clone();
-                    let segment_sink = segment_sink.clone();
+                    let session = session.with_handle(h);
 
                     async move {
                         // If we have a matching writer, we use it.
@@ -333,12 +340,12 @@ impl LayoutStrategy for TableStrategy {
                         // Write validity stream
                         if index == 0 && is_nullable {
                             validity
-                                .write_stream(ctx, segment_sink, column_stream, child_eof, h)
+                                .write_stream(ctx, segment_sink, column_stream, child_eof, &session)
                                 .await
                         } else {
                             // Use the underlying writer, otherwise use the fallback writer.
                             writer
-                                .write_stream(ctx, segment_sink, column_stream, child_eof, h)
+                                .write_stream(ctx, segment_sink, column_stream, child_eof, &session)
                                 .await
                         }
                     }
@@ -372,8 +379,11 @@ mod tests {
         let flat = Arc::new(FlatLayoutStrategy::default());
 
         // Success
-        let path = TableStrategy::new(flat.clone(), flat.clone())
-            .with_field_writer(field_path!(a.b.c), flat.clone());
+        let path = TableStrategy::new(
+            Arc::<FlatLayoutStrategy>::clone(&flat),
+            Arc::<FlatLayoutStrategy>::clone(&flat),
+        )
+        .with_field_writer(field_path!(a.b.c), Arc::<FlatLayoutStrategy>::clone(&flat));
 
         // Should panic right here.
         let _path = path.with_field_writer(field_path!(a.b), flat);
@@ -385,7 +395,10 @@ mod tests {
     )]
     fn test_root_override() {
         let flat = Arc::new(FlatLayoutStrategy::default());
-        let _strategy = TableStrategy::new(flat.clone(), flat.clone())
-            .with_field_writer(FieldPath::root(), flat);
+        let _strategy = TableStrategy::new(
+            Arc::<FlatLayoutStrategy>::clone(&flat),
+            Arc::<FlatLayoutStrategy>::clone(&flat),
+        )
+        .with_field_writer(FieldPath::root(), flat);
     }
 }
diff --git a/vortex-layout/src/layouts/zoned/builder.rs b/vortex-layout/src/layouts/zoned/builder.rs
index de2d4b575e3..c8fd3686281 100644
--- a/vortex-layout/src/layouts/zoned/builder.rs
+++ b/vortex-layout/src/layouts/zoned/builder.rs
@@ -3,7 +3,6 @@
 
 use std::marker::PhantomData;
 
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
diff --git a/vortex-layout/src/layouts/zoned/mod.rs b/vortex-layout/src/layouts/zoned/mod.rs
index 6fdf298146c..5167025ff3a 100644
--- a/vortex-layout/src/layouts/zoned/mod.rs
+++ b/vortex-layout/src/layouts/zoned/mod.rs
@@ -10,7 +10,6 @@ use std::sync::Arc;
 
 pub use builder::MAX_IS_TRUNCATED;
 pub use builder::MIN_IS_TRUNCATED;
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::SerializeMetadata;
 use vortex_array::dtype::DType;
@@ -23,6 +22,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
@@ -40,7 +40,7 @@ use crate::vtable;
 
 vtable!(Zoned);
 
-impl VTable for ZonedVTable {
+impl VTable for Zoned {
     type Layout = ZonedLayout;
     type Encoding = ZonedLayoutEncoding;
     type Metadata = ZonedMetadata;
@@ -64,7 +64,7 @@ impl VTable for ZonedVTable {
     fn metadata(layout: &Self::Layout) -> Self::Metadata {
         ZonedMetadata {
             zone_len: u32::try_from(layout.zone_len).vortex_expect("Invalid zone length"),
-            present_stats: layout.present_stats.clone(),
+            present_stats: Arc::clone(&layout.present_stats),
         }
     }
 
@@ -116,13 +116,13 @@ impl VTable for ZonedVTable {
         metadata: &ZonedMetadata,
         _segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        _ctx: &ArrayContext,
+        _ctx: &ReadContext,
     ) -> VortexResult<Self::Layout> {
         Ok(ZonedLayout {
             dtype: dtype.clone(),
             children: children.to_arc(),
             zone_len: metadata.zone_len as usize,
-            present_stats: metadata.present_stats.clone(),
+            present_stats: Arc::clone(&metadata.present_stats),
         })
     }
 
@@ -141,6 +141,9 @@ impl VTable for ZonedVTable {
 #[derive(Debug)]
 pub struct ZonedLayoutEncoding;
 
+/// Annotates a data layout with per-zone aggregate statistics (e.g. min, max, null count).
+///
+/// During reads, zone maps allow entire zones to be skipped when a filter predicate cannot match.
 #[derive(Clone, Debug)]
 pub struct ZonedLayout {
     dtype: DType,
diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs
index 50b7780cae0..23118e8ce5c 100644
--- a/vortex-layout/src/layouts/zoned/reader.rs
+++ b/vortex-layout/src/layouts/zoned/reader.rs
@@ -73,12 +73,12 @@ impl ZonedReader {
             layout.dtype.clone(),
             ZoneMap::dtype_for_stats_table(layout.dtype(), layout.present_stats()),
         ];
-        let names = vec![name.clone(), format!("{}.zones", name).into()];
+        let names = vec![Arc::clone(&name), format!("{}.zones", name).into()];
         let lazy_children = LazyReaderChildren::new(
-            layout.children.clone(),
+            Arc::clone(&layout.children),
             dtypes,
             names,
-            segment_source.clone(),
+            Arc::clone(&segment_source),
             session.clone(),
         );
 
@@ -93,7 +93,6 @@ impl ZonedReader {
         })
     }
 
-    #[inline]
     fn data_child(&self) -> VortexResult<&LayoutReaderRef> {
         self.lazy_children.get(0)
     }
@@ -123,7 +122,7 @@ impl ZonedReader {
         self.zone_map
             .get_or_init(move || {
                 let nzones = self.layout.nzones();
-                let present_stats = self.layout.present_stats.clone();
+                let present_stats = Arc::clone(&self.layout.present_stats);
 
                 let zones_eval = self
                     .lazy_children
@@ -272,7 +271,7 @@ impl LayoutReader for ZonedReader {
             })
             .try_collect()?;
 
-        let name = self.name.clone();
+        let name = Arc::clone(&self.name);
         let expr = expr.clone();
 
         Ok(MaskFuture::new(mask.len(), async move {
@@ -408,6 +407,7 @@ mod test {
     use vortex_array::expr::root;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
+    use vortex_io::session::RuntimeSessionExt;
     use vortex_mask::Mask;
 
     use crate::LayoutRef;
@@ -444,8 +444,12 @@ mod test {
         .into_array()
         .to_array_stream()
         .sequenced(ptr);
-        let layout = block_on(|handle| {
-            strategy.write_stream(ctx, segments.clone(), array_stream, eof, handle)
+        let segments2 = Arc::<TestSegments>::clone(&segments);
+        let layout = block_on(|handle| async move {
+            let session = SESSION.clone().with_handle(handle);
+            strategy
+                .write_stream(ctx, segments2, array_stream, eof, &session)
+                .await
         })
         .unwrap();
         (segments, layout)
@@ -469,7 +473,7 @@ mod test {
                 .unwrap();
 
             let expected = buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9].into_array();
-            assert_arrays_eq!(result.as_ref(), expected.as_ref());
+            assert_arrays_eq!(result, expected);
         })
     }
 
diff --git a/vortex-layout/src/layouts/zoned/writer.rs b/vortex-layout/src/layouts/zoned/writer.rs
index 1800532b1ee..3e1d61098b0 100644
--- a/vortex-layout/src/layouts/zoned/writer.rs
+++ b/vortex-layout/src/layouts/zoned/writer.rs
@@ -7,10 +7,12 @@ use async_trait::async_trait;
 use futures::StreamExt as _;
 use parking_lot::Mutex;
 use vortex_array::ArrayContext;
+use vortex_array::IntoArray;
 use vortex_array::expr::stats::Stat;
 use vortex_array::stats::PRUNING_STATS;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_io::session::RuntimeSessionExt;
+use vortex_session::VortexSession;
 
 use crate::IntoLayout;
 use crate::LayoutRef;
@@ -76,9 +78,10 @@ impl LayoutStrategy for ZonedStrategy {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         mut eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
-        let stats = self.options.stats.clone();
+        let stats = Arc::clone(&self.options.stats);
+        let handle = session.handle();
         let handle2 = handle.clone();
 
         let stats_accumulator = Arc::new(Mutex::new(StatsAccumulator::new(
@@ -92,7 +95,7 @@ impl LayoutStrategy for ZonedStrategy {
             stream.dtype().clone(),
             stream
                 .map(move |chunk| {
-                    let stats = stats.clone();
+                    let stats = Arc::clone(&stats);
                     handle2.spawn_cpu(move || {
                         let (sequence_id, chunk) = chunk?;
                         chunk.statistics().compute_all(&stats)?;
@@ -105,7 +108,7 @@ impl LayoutStrategy for ZonedStrategy {
 
         // Now we accumulate the stats we computed above, this time we cannot spawn because we
         // need to feed the accumulator an ordered stream.
-        let stats_accumulator2 = stats_accumulator.clone();
+        let stats_accumulator2 = Arc::clone(&stats_accumulator);
         let stream = SequentialStreamAdapter::new(
             stream.dtype().clone(),
             stream.map(move |item| {
@@ -127,10 +130,10 @@ impl LayoutStrategy for ZonedStrategy {
             .child
             .write_stream(
                 ctx.clone(),
-                segment_sink.clone(),
+                Arc::clone(&segment_sink),
                 stream,
                 data_eof,
-                handle.clone(),
+                session,
             )
             .await?;
 
@@ -144,18 +147,20 @@ impl LayoutStrategy for ZonedStrategy {
         // the table depends on which stats were successfully computed.
         let stats_stream = stats_table
             .array()
+            .clone()
+            .into_array()
             .to_array_stream()
             .sequenced(eof.split_off());
         let zones_layout = self
             .stats
-            .write_stream(ctx, segment_sink.clone(), stats_stream, eof, handle)
+            .write_stream(ctx, Arc::clone(&segment_sink), stats_stream, eof, session)
             .await?;
 
         Ok(ZonedLayout::new(
             data_layout,
             zones_layout,
             block_size,
-            stats_table.present_stats().clone(),
+            Arc::clone(stats_table.present_stats()),
         )
         .into_layout())
     }
diff --git a/vortex-layout/src/layouts/zoned/zone_map.rs b/vortex-layout/src/layouts/zoned/zone_map.rs
index 2b1dabcfdf9..39ab7179236 100644
--- a/vortex-layout/src/layouts/zoned/zone_map.rs
+++ b/vortex-layout/src/layouts/zoned/zone_map.rs
@@ -4,11 +4,13 @@
 use std::sync::Arc;
 
 use itertools::Itertools;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
+use vortex_array::aggregate_fn::fns::sum::sum;
 use vortex_array::arrays::StructArray;
-use vortex_array::compute::sum;
+use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
@@ -78,6 +80,15 @@ impl ZoneMap {
                     .iter()
                     .filter_map(|stat| {
                         stat.dtype(column_dtype)
+                            .or_else(|| {
+                                // Backward compat: older files may have stored stats (e.g. Sum)
+                                // for extension types by resolving through the storage dtype.
+                                if let DType::Extension(ext) = column_dtype {
+                                    stat.dtype(ext.storage_dtype())
+                                } else {
+                                    None
+                                }
+                            })
                             .map(|dtype| (stat, dtype.as_nullable()))
                     })
                     .flat_map(|(s, dt)| match s {
@@ -107,7 +118,7 @@ impl ZoneMap {
     }
 
     /// Returns an aggregated stats set for the table.
-    pub fn to_stats_set(&self, stats: &[Stat]) -> VortexResult<StatsSet> {
+    pub fn to_stats_set(&self, stats: &[Stat], ctx: &mut ExecutionCtx) -> VortexResult<StatsSet> {
         let mut stats_set = StatsSet::default();
         for &stat in stats {
             let Some(array) = self.get_stat(stat)? else {
@@ -126,7 +137,7 @@ impl ZoneMap {
                 }
                 // These stats sum up
                 Stat::NullCount | Stat::NaNCount | Stat::UncompressedSizeInBytes => {
-                    if let Some(sum_value) = sum(&array)?
+                    if let Some(sum_value) = sum(&array, ctx)?
                         .cast(&DType::Primitive(PType::U64, Nullability::Nullable))?
                         .into_value()
                     {
@@ -156,7 +167,8 @@ impl ZoneMap {
     pub fn prune(&self, predicate: &Expression, session: &VortexSession) -> VortexResult<Mask> {
         let mut ctx = session.create_execution_ctx();
         self.array
-            .to_array()
+            .clone()
+            .into_array()
             .apply(predicate)?
             .execute::<Mask>(&mut ctx)
     }
@@ -194,7 +206,7 @@ impl StatsAccumulator {
         }
     }
 
-    pub fn push_chunk_without_compute(&mut self, array: &dyn Array) -> VortexResult<()> {
+    pub fn push_chunk_without_compute(&mut self, array: &ArrayRef) -> VortexResult<()> {
         for builder in self.builders.iter_mut() {
             if let Some(Precision::Exact(v)) = array.statistics().get(builder.stat()) {
                 builder.append_scalar(v.cast(&v.dtype().as_nullable())?)?;
@@ -206,7 +218,7 @@ impl StatsAccumulator {
         Ok(())
     }
 
-    pub fn push_chunk(&mut self, array: &dyn Array) -> VortexResult<()> {
+    pub fn push_chunk(&mut self, array: &ArrayRef) -> VortexResult<()> {
         for builder in self.builders.iter_mut() {
             if let Some(v) = array.statistics().compute_stat(builder.stat())? {
                 builder.append_scalar(v.cast(&v.dtype().as_nullable())?)?;
@@ -267,6 +279,8 @@ mod tests {
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
+    use vortex_array::arrays::bool::BoolArrayExt;
+    use vortex_array::arrays::struct_::StructArrayExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builders::ArrayBuilder;
     use vortex_array::builders::VarBinViewBuilder;
@@ -323,13 +337,17 @@ mod tests {
             ]
         );
         assert_eq!(
-            stats_table.array.unmasked_fields()[1]
+            stats_table
+                .array
+                .unmasked_field(1)
                 .to_bool()
                 .to_bit_buffer(),
             BitBuffer::from(vec![false, true])
         );
         assert_eq!(
-            stats_table.array.unmasked_fields()[3]
+            stats_table
+                .array
+                .unmasked_field(3)
                 .to_bool()
                 .to_bit_buffer(),
             BitBuffer::from(vec![true, false])
@@ -357,13 +375,17 @@ mod tests {
             ]
         );
         assert_eq!(
-            stats_table.array.unmasked_fields()[1]
+            stats_table
+                .array
+                .unmasked_field(1)
                 .to_bool()
                 .to_bit_buffer(),
             BitBuffer::from(vec![false])
         );
         assert_eq!(
-            stats_table.array.unmasked_fields()[3]
+            stats_table
+                .array
+                .unmasked_field(3)
                 .to_bool()
                 .to_bit_buffer(),
             BitBuffer::from(vec![false])
diff --git a/vortex-layout/src/lib.rs b/vortex-layout/src/lib.rs
index f7f3787da79..be1bad67236 100644
--- a/vortex-layout/src/lib.rs
+++ b/vortex-layout/src/lib.rs
@@ -18,6 +18,7 @@ mod encoding;
 mod flatbuffers;
 mod layout;
 mod reader;
+pub mod scan;
 pub mod segments;
 pub mod sequence;
 pub mod session;
diff --git a/vortex-layout/src/reader.rs b/vortex-layout/src/reader.rs
index 9ccd695c572..e103c163efe 100644
--- a/vortex-layout/src/reader.rs
+++ b/vortex-layout/src/reader.rs
@@ -145,7 +145,7 @@ impl LazyReaderChildren {
             let child = self.children.child(idx, dtype)?;
             child.new_reader(
                 Arc::clone(&self.names[idx]),
-                self.segment_source.clone(),
+                Arc::clone(&self.segment_source),
                 &self.session,
             )
         })
diff --git a/vortex-scan/src/arrow.rs b/vortex-layout/src/scan/arrow.rs
similarity index 96%
rename from vortex-scan/src/arrow.rs
rename to vortex-layout/src/scan/arrow.rs
index 8937129a93b..875db04e4df 100644
--- a/vortex-scan/src/arrow.rs
+++ b/vortex-layout/src/scan/arrow.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use arrow_array::RecordBatch;
 use arrow_array::RecordBatchReader;
 use arrow_array::cast::AsArray;
@@ -16,7 +18,7 @@ use vortex_array::arrow::ArrowArrayExecutor;
 use vortex_error::VortexResult;
 use vortex_io::runtime::BlockingRuntime;
 
-use crate::ScanBuilder;
+use crate::scan::scan_builder::ScanBuilder;
 
 impl ScanBuilder<ArrayRef> {
     /// Creates a new `RecordBatchReader` from the scan builder.
@@ -104,7 +106,7 @@ where
 {
     #[inline]
     fn schema(&self) -> SchemaRef {
-        self.schema.clone()
+        Arc::clone(&self.schema)
     }
 }
 
@@ -128,7 +130,7 @@ mod tests {
     use vortex_error::VortexResult;
 
     use super::*;
-    use crate::test::SCAN_SESSION;
+    use crate::scan::test::SCAN_SESSION;
 
     fn create_test_struct_array() -> VortexResult<ArrayRef> {
         // Create Arrow arrays
@@ -195,14 +197,14 @@ mod tests {
     fn test_record_batch_iterator_adapter() -> VortexResult<()> {
         let schema = create_arrow_schema();
         let batch1 = RecordBatch::try_new(
-            schema.clone(),
+            Arc::clone(&schema),
             vec![
                 Arc::new(Int32Array::from(vec![Some(1), Some(2)])) as ArrowArrayRef,
                 Arc::new(StringArray::from(vec![Some("Alice"), Some("Bob")])) as ArrowArrayRef,
             ],
         )?;
         let batch2 = RecordBatch::try_new(
-            schema.clone(),
+            Arc::clone(&schema),
             vec![
                 Arc::new(Int32Array::from(vec![None, Some(4)])) as ArrowArrayRef,
                 Arc::new(StringArray::from(vec![Some("Charlie"), None])) as ArrowArrayRef,
@@ -212,7 +214,7 @@ mod tests {
         let iter = vec![Ok(batch1), Ok(batch2)].into_iter();
         let mut adapter = RecordBatchIteratorAdapter {
             iter,
-            schema: schema.clone(),
+            schema: Arc::clone(&schema),
         };
 
         // Test RecordBatchReader trait
@@ -238,7 +240,7 @@ mod tests {
         let iter = vec![Err(error)].into_iter();
         let mut adapter = RecordBatchIteratorAdapter {
             iter,
-            schema: schema.clone(),
+            schema: Arc::clone(&schema),
         };
 
         // Test that error is propagated
@@ -251,7 +253,7 @@ mod tests {
     fn test_mixed_success_and_error() {
         let schema = create_arrow_schema();
         let batch = RecordBatch::try_new(
-            schema.clone(),
+            Arc::clone(&schema),
             vec![
                 Arc::new(Int32Array::from(vec![Some(1)])) as ArrowArrayRef,
                 Arc::new(StringArray::from(vec![Some("Test")])) as ArrowArrayRef,
diff --git a/vortex-scan/src/filter.rs b/vortex-layout/src/scan/filter.rs
similarity index 100%
rename from vortex-scan/src/filter.rs
rename to vortex-layout/src/scan/filter.rs
diff --git a/vortex-scan/src/layout.rs b/vortex-layout/src/scan/layout.rs
similarity index 96%
rename from vortex-scan/src/layout.rs
rename to vortex-layout/src/scan/layout.rs
index e2f11b30201..4ffdadab2e6 100644
--- a/vortex-scan/src/layout.rs
+++ b/vortex-layout/src/scan/layout.rs
@@ -27,20 +27,20 @@ use vortex_array::stream::ArrayStreamExt;
 use vortex_array::stream::SendableArrayStream;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
-use vortex_layout::LayoutReaderRef;
 use vortex_mask::Mask;
 use vortex_metrics::MetricsRegistry;
+use vortex_scan::DataSource;
+use vortex_scan::DataSourceScan;
+use vortex_scan::DataSourceScanRef;
+use vortex_scan::Partition;
+use vortex_scan::PartitionRef;
+use vortex_scan::PartitionStream;
+use vortex_scan::ScanRequest;
+use vortex_scan::selection::Selection;
 use vortex_session::VortexSession;
 
-use crate::ScanBuilder;
-use crate::Selection;
-use crate::api::DataSource;
-use crate::api::DataSourceScan;
-use crate::api::DataSourceScanRef;
-use crate::api::Partition;
-use crate::api::PartitionRef;
-use crate::api::PartitionStream;
-use crate::api::ScanRequest;
+use crate::LayoutReaderRef;
+use crate::scan::scan_builder::ScanBuilder;
 
 /// An implementation of a [`DataSource`] that reads data from a [`LayoutReaderRef`].
 pub struct LayoutReaderDataSource {
@@ -158,7 +158,7 @@ impl DataSource for LayoutReaderDataSource {
         }
 
         Ok(Box::new(LayoutReaderScan {
-            reader: self.reader.clone(),
+            reader: Arc::clone(&self.reader),
             session: self.session.clone(),
             dtype,
             projection: scan_request.projection,
@@ -246,7 +246,7 @@ impl Stream for LayoutReaderScan {
         }
 
         let split = Box::new(LayoutReaderSplit {
-            reader: this.reader.clone(),
+            reader: Arc::clone(&this.reader),
             session: this.session.clone(),
             projection: this.projection.clone(),
             filter: this.filter.clone(),
diff --git a/vortex-layout/src/scan/mod.rs b/vortex-layout/src/scan/mod.rs
new file mode 100644
index 00000000000..98fd1918a42
--- /dev/null
+++ b/vortex-layout/src/scan/mod.rs
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+pub mod arrow;
+mod filter;
+pub mod layout;
+pub mod multi;
+pub mod repeated_scan;
+pub mod scan_builder;
+pub mod split_by;
+mod splits;
+mod tasks;
+#[cfg(test)]
+mod test;
+
+/// A heuristic for an ideal split size.
+///
+/// We don't actually know if this is right, but it is probably a good estimate.
+const IDEAL_SPLIT_SIZE: u64 = 100_000;
diff --git a/vortex-scan/src/multi.rs b/vortex-layout/src/scan/multi.rs
similarity index 97%
rename from vortex-scan/src/multi.rs
rename to vortex-layout/src/scan/multi.rs
index df405011b6b..307aca187cc 100644
--- a/vortex-scan/src/multi.rs
+++ b/vortex-layout/src/scan/multi.rs
@@ -43,18 +43,18 @@ use vortex_array::stream::SendableArrayStream;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_io::session::RuntimeSessionExt;
-use vortex_layout::LayoutReaderRef;
 use vortex_mask::Mask;
+use vortex_scan::DataSource;
+use vortex_scan::DataSourceScan;
+use vortex_scan::DataSourceScanRef;
+use vortex_scan::Partition;
+use vortex_scan::PartitionRef;
+use vortex_scan::PartitionStream;
+use vortex_scan::ScanRequest;
 use vortex_session::VortexSession;
 
-use crate::ScanBuilder;
-use crate::api::DataSource;
-use crate::api::DataSourceScan;
-use crate::api::DataSourceScanRef;
-use crate::api::Partition;
-use crate::api::PartitionRef;
-use crate::api::PartitionStream;
-use crate::api::ScanRequest;
+use crate::LayoutReaderRef;
+use crate::scan::scan_builder::ScanBuilder;
 
 /// Default concurrency for opening deferred readers.
 const DEFAULT_CONCURRENCY: usize = 8;
@@ -204,8 +204,8 @@ impl DataSource for MultiLayoutDataSource {
 
         for child in &self.children {
             match child {
-                MultiLayoutChild::Opened(reader) => ready.push_back(reader.clone()),
-                MultiLayoutChild::Deferred(factory) => deferred.push_back(factory.clone()),
+                MultiLayoutChild::Opened(reader) => ready.push_back(Arc::clone(reader)),
+                MultiLayoutChild::Deferred(factory) => deferred.push_back(Arc::clone(factory)),
             }
         }
 
diff --git a/vortex-scan/src/repeated_scan.rs b/vortex-layout/src/scan/repeated_scan.rs
similarity index 94%
rename from vortex-scan/src/repeated_scan.rs
rename to vortex-layout/src/scan/repeated_scan.rs
index f87849e605a..1d5caaa66cf 100644
--- a/vortex-scan/src/repeated_scan.rs
+++ b/vortex-layout/src/scan/repeated_scan.rs
@@ -20,14 +20,14 @@ use vortex_array::stream::ArrayStreamAdapter;
 use vortex_error::VortexResult;
 use vortex_io::runtime::BlockingRuntime;
 use vortex_io::session::RuntimeSessionExt;
-use vortex_layout::LayoutReaderRef;
+use vortex_scan::selection::Selection;
 use vortex_session::VortexSession;
 
-use crate::filter::FilterExpr;
-use crate::selection::Selection;
-use crate::splits::Splits;
-use crate::tasks::TaskContext;
-use crate::tasks::split_exec;
+use crate::LayoutReaderRef;
+use crate::scan::filter::FilterExpr;
+use crate::scan::splits::Splits;
+use crate::scan::tasks::TaskContext;
+use crate::scan::tasks::split_exec;
 
 /// A projected subset (by indices, range, and filter) of rows from a Vortex data source.
 ///
@@ -87,7 +87,7 @@ impl<A: 'static + Send> RepeatedScan<A> {
         clippy::too_many_arguments,
         reason = "all arguments are needed for scan construction"
     )]
-    pub(super) fn new(
+    pub fn new(
         session: VortexSession,
         layout_reader: LayoutReaderRef,
         projection: Expression,
@@ -124,9 +124,9 @@ impl<A: 'static + Send> RepeatedScan<A> {
         let ctx = Arc::new(TaskContext {
             selection: self.selection.clone(),
             filter: self.filter.clone().map(|f| Arc::new(FilterExpr::new(f))),
-            reader: self.layout_reader.clone(),
+            reader: Arc::clone(&self.layout_reader),
             projection: self.projection.clone(),
-            mapper: self.map_fn.clone(),
+            mapper: Arc::clone(&self.map_fn),
         });
 
         let row_range = intersect_ranges(self.row_range.as_ref(), row_range);
@@ -176,7 +176,7 @@ impl<A: 'static + Send> RepeatedScan<A> {
                 break;
             }
 
-            tasks.push(split_exec(ctx.clone(), range, limit.as_mut())?);
+            tasks.push(split_exec(Arc::clone(&ctx), range, limit.as_mut())?);
         }
 
         Ok(tasks)
diff --git a/vortex-scan/src/scan_builder.rs b/vortex-layout/src/scan/scan_builder.rs
similarity index 96%
rename from vortex-scan/src/scan_builder.rs
rename to vortex-layout/src/scan/scan_builder.rs
index 39510453004..d53a38163fa 100644
--- a/vortex-scan/src/scan_builder.rs
+++ b/vortex-layout/src/scan/scan_builder.rs
@@ -35,17 +35,17 @@ use vortex_io::runtime::BlockingRuntime;
 use vortex_io::runtime::Handle;
 use vortex_io::runtime::Task;
 use vortex_io::session::RuntimeSessionExt;
-use vortex_layout::LayoutReader;
-use vortex_layout::LayoutReaderRef;
-use vortex_layout::layouts::row_idx::RowIdxLayoutReader;
 use vortex_metrics::MetricsRegistry;
+use vortex_scan::selection::Selection;
 use vortex_session::VortexSession;
 
-use crate::RepeatedScan;
-use crate::selection::Selection;
-use crate::split_by::SplitBy;
-use crate::splits::Splits;
-use crate::splits::attempt_split_ranges;
+use crate::LayoutReader;
+use crate::LayoutReaderRef;
+use crate::layouts::row_idx::RowIdxLayoutReader;
+use crate::scan::repeated_scan::RepeatedScan;
+use crate::scan::split_by::SplitBy;
+use crate::scan::splits::Splits;
+use crate::scan::splits::attempt_split_ranges;
 
 /// A struct for building a scan operation.
 pub struct ScanBuilder<A> {
@@ -413,7 +413,7 @@ 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(crate) fn filter_and_projection_masks(
+pub fn filter_and_projection_masks(
     projection: &Expression,
     filter: Option<&Expression>,
     dtype: &DType,
@@ -477,11 +477,11 @@ mod test {
     use vortex_error::vortex_err;
     use vortex_io::runtime::BlockingRuntime;
     use vortex_io::runtime::single::SingleThreadRuntime;
-    use vortex_layout::ArrayFuture;
-    use vortex_layout::LayoutReader;
     use vortex_mask::Mask;
 
     use super::ScanBuilder;
+    use crate::ArrayFuture;
+    use crate::LayoutReader;
 
     #[derive(Debug)]
     struct CountingLayoutReader {
@@ -559,9 +559,9 @@ mod test {
     #[test]
     fn into_stream_is_lazy() {
         let calls = Arc::new(AtomicUsize::new(0));
-        let reader = Arc::new(CountingLayoutReader::new(calls.clone()));
+        let reader = Arc::new(CountingLayoutReader::new(Arc::clone(&calls)));
 
-        let session = crate::test::SCAN_SESSION.clone();
+        let session = crate::scan::test::SCAN_SESSION.clone();
 
         let _stream = ScanBuilder::new(session, reader).into_stream().unwrap();
 
@@ -654,10 +654,10 @@ mod test {
     #[test]
     fn into_stream_executes_after_prepare() -> VortexResult<()> {
         let calls = Arc::new(AtomicUsize::new(0));
-        let reader = Arc::new(SplittingLayoutReader::new(calls.clone()));
+        let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls)));
 
         let runtime = SingleThreadRuntime::default();
-        let session = crate::test::session_with_handle(runtime.handle());
+        let session = crate::scan::test::session_with_handle(runtime.handle());
 
         let stream = ScanBuilder::new(session, reader).into_stream().unwrap();
         let mut iter = runtime.block_on_stream(stream);
@@ -755,10 +755,13 @@ mod test {
         let guard = gate.lock();
 
         let calls = Arc::new(AtomicUsize::new(0));
-        let reader = Arc::new(BlockingSplitsLayoutReader::new(gate.clone(), calls.clone()));
+        let reader = Arc::new(BlockingSplitsLayoutReader::new(
+            Arc::clone(&gate),
+            Arc::clone(&calls),
+        ));
 
         let runtime = SingleThreadRuntime::default();
-        let session = crate::test::session_with_handle(runtime.handle());
+        let session = crate::scan::test::session_with_handle(runtime.handle());
 
         let mut stream = ScanBuilder::new(session, reader).into_stream().unwrap();
 
diff --git a/vortex-scan/src/split_by.rs b/vortex-layout/src/scan/split_by.rs
similarity index 86%
rename from vortex-scan/src/split_by.rs
rename to vortex-layout/src/scan/split_by.rs
index 81e1c935852..6ddc68c2568 100644
--- a/vortex-scan/src/split_by.rs
+++ b/vortex-layout/src/scan/split_by.rs
@@ -7,7 +7,8 @@ use std::ops::Range;
 
 use vortex_array::dtype::FieldMask;
 use vortex_error::VortexResult;
-use vortex_layout::LayoutReader;
+
+use crate::LayoutReader;
 
 /// Defines how the Vortex file is split into batches for reading.
 ///
@@ -59,31 +60,33 @@ mod test {
     use vortex_array::dtype::FieldPath;
     use vortex_buffer::buffer;
     use vortex_io::runtime::single::block_on;
-    use vortex_layout::LayoutReaderRef;
-    use vortex_layout::LayoutStrategy;
-    use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-    use vortex_layout::segments::TestSegments;
-    use vortex_layout::sequence::SequenceId;
-    use vortex_layout::sequence::SequentialArrayStreamExt;
+    use vortex_io::session::RuntimeSessionExt;
 
     use super::*;
-    use crate::test::SCAN_SESSION;
+    use crate::LayoutReaderRef;
+    use crate::LayoutStrategy;
+    use crate::layouts::flat::writer::FlatLayoutStrategy;
+    use crate::scan::test::SCAN_SESSION;
+    use crate::segments::TestSegments;
+    use crate::sequence::SequenceId;
+    use crate::sequence::SequentialArrayStreamExt;
 
     fn reader() -> LayoutReaderRef {
         let ctx = ArrayContext::empty();
         let segments = Arc::new(TestSegments::default());
         let (ptr, eof) = SequenceId::root().split();
         let layout = block_on(|handle| async {
+            let session = SCAN_SESSION.clone().with_handle(handle);
             FlatLayoutStrategy::default()
                 .write_stream(
                     ctx,
-                    segments.clone(),
+                    Arc::<TestSegments>::clone(&segments),
                     buffer![1_i32; 10]
                         .into_array()
                         .to_array_stream()
                         .sequenced(ptr),
                     eof,
-                    handle,
+                    &session,
                 )
                 .await
         })
diff --git a/vortex-scan/src/splits.rs b/vortex-layout/src/scan/splits.rs
similarity index 95%
rename from vortex-scan/src/splits.rs
rename to vortex-layout/src/scan/splits.rs
index 2f57c5acee0..16255efb66b 100644
--- a/vortex-scan/src/splits.rs
+++ b/vortex-layout/src/scan/splits.rs
@@ -4,8 +4,9 @@
 use std::collections::BTreeSet;
 use std::ops::Range;
 
-use crate::IDEAL_SPLIT_SIZE;
-use crate::selection::Selection;
+use vortex_scan::selection::Selection;
+
+use crate::scan::IDEAL_SPLIT_SIZE;
 
 /// The maximum number of rows in a single range. This is somewhat arbitrarily chosen.
 const MAX_RANGE_SIZE: u64 = IDEAL_SPLIT_SIZE / 25;
@@ -14,7 +15,7 @@ const MAX_RANGE_SIZE: u64 = IDEAL_SPLIT_SIZE / 25;
 const MIN_GAP_BETWEEN_RANGES: u64 = IDEAL_SPLIT_SIZE / 2;
 
 /// The way in which we compute splits for a file.
-pub(super) enum Splits {
+pub enum Splits {
     /// Natural splits computed by the layout reader (e.g., computing splits across different-sized
     /// column chunks).
     Natural(BTreeSet<u64>),
@@ -27,7 +28,7 @@ pub(super) enum Splits {
 }
 
 /// Attempts to compute split ranges from the given selection.
-pub(super) fn attempt_split_ranges(
+pub fn attempt_split_ranges(
     selection: &Selection,
     row_range: Option<&Range<u64>>,
 ) -> Option<Vec<Range<u64>>> {
diff --git a/vortex-scan/src/tasks.rs b/vortex-layout/src/scan/tasks.rs
similarity index 91%
rename from vortex-scan/src/tasks.rs
rename to vortex-layout/src/scan/tasks.rs
index 9ba1e309948..dc0b489b1f2 100644
--- a/vortex-scan/src/tasks.rs
+++ b/vortex-layout/src/scan/tasks.rs
@@ -15,11 +15,11 @@ use vortex_array::ArrayRef;
 use vortex_array::MaskFuture;
 use vortex_array::expr::Expression;
 use vortex_error::VortexResult;
-use vortex_layout::LayoutReader;
 use vortex_mask::Mask;
+use vortex_scan::selection::Selection;
 
-use crate::filter::FilterExpr;
-use crate::selection::Selection;
+use crate::LayoutReader;
+use crate::scan::filter::FilterExpr;
 
 pub type TaskFuture<A> = BoxFuture<'static, VortexResult<A>>;
 
@@ -35,7 +35,7 @@ pub type TaskFuture<A> = BoxFuture<'static, VortexResult<A>>;
 ///
 /// This mask is then provided to the reader to perform a filtered projection over the split data,
 /// finally mapping the Vortex columnar record batches into some result type `A`.
-pub(super) fn split_exec<A: 'static + Send>(
+pub fn split_exec<A: 'static + Send>(
     ctx: Arc<TaskContext<A>>,
     split: Range<u64>,
     limit: Option<&mut u64>,
@@ -71,8 +71,8 @@ pub(super) fn split_exec<A: 'static + Send>(
             // NOTE: it's very important that the pruning and filter evaluations are built OUTSIDE
             // the future. Registering these row ranges eagerly is a hint to the IO system that
             // we want to start prefetching the IO for this split.
-            let reader = ctx.reader.clone();
-            let filter = filter.clone();
+            let reader = Arc::clone(&ctx.reader);
+            let filter = Arc::clone(filter);
             let row_range = row_range.clone();
 
             MaskFuture::new(row_mask.len(), async move {
@@ -141,7 +141,7 @@ pub(super) fn split_exec<A: 'static + Send>(
         ctx.reader
             .projection_evaluation(&row_range, &ctx.projection, filter_mask.clone())?;
 
-    let mapper = ctx.mapper.clone();
+    let mapper = Arc::clone(&ctx.mapper);
     let array_fut = async move {
         let mask = filter_mask.await?;
         if mask.all_false() {
@@ -156,15 +156,15 @@ pub(super) fn split_exec<A: 'static + Send>(
 }
 
 /// Information needed to execute a single split task.
-pub(super) struct TaskContext<A> {
+pub struct TaskContext<A> {
     /// A row selection to apply.
-    pub(super) selection: Selection,
+    pub selection: Selection,
     /// The shared filter expression.
-    pub(super) filter: Option<Arc<FilterExpr>>,
+    pub filter: Option<Arc<FilterExpr>>,
     /// The layout reader.
-    pub(super) reader: Arc<dyn LayoutReader>,
+    pub reader: Arc<dyn LayoutReader>,
     /// The projection expression to apply to gather the scanned rows.
-    pub(super) projection: Expression,
+    pub projection: Expression,
     /// Function that maps into an A.
-    pub(super) mapper: Arc<dyn Fn(ArrayRef) -> VortexResult<A> + Send + Sync>,
+    pub mapper: Arc<dyn Fn(ArrayRef) -> VortexResult<A> + Send + Sync>,
 }
diff --git a/vortex-scan/src/test.rs b/vortex-layout/src/scan/test.rs
similarity index 94%
rename from vortex-scan/src/test.rs
rename to vortex-layout/src/scan/test.rs
index f6bbf041b90..15ef00dac34 100644
--- a/vortex-scan/src/test.rs
+++ b/vortex-layout/src/scan/test.rs
@@ -8,9 +8,10 @@ use vortex_array::session::ArraySession;
 use vortex_io::runtime::Handle;
 use vortex_io::session::RuntimeSession;
 use vortex_io::session::RuntimeSessionExt;
-use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
 
+use crate::session::LayoutSession;
+
 pub fn new_session() -> VortexSession {
     VortexSession::empty()
         .with::<ArraySession>()
diff --git a/vortex-layout/src/segments/cache.rs b/vortex-layout/src/segments/cache.rs
index 174c6b1e637..37675c19d2a 100644
--- a/vortex-layout/src/segments/cache.rs
+++ b/vortex-layout/src/segments/cache.rs
@@ -137,7 +137,7 @@ impl SegmentCacheSourceAdapter {
 
 impl SegmentSource for SegmentCacheSourceAdapter {
     fn request(&self, id: SegmentId) -> SegmentFuture {
-        let cache = self.cache.clone();
+        let cache = Arc::clone(&self.cache);
         let delegate = self.source.request(id);
 
         async move {
diff --git a/vortex-layout/src/sequence.rs b/vortex-layout/src/sequence.rs
index 1b6854031c7..5e9b8b0495d 100644
--- a/vortex-layout/src/sequence.rs
+++ b/vortex-layout/src/sequence.rs
@@ -16,7 +16,6 @@ use futures::Stream;
 use futures::StreamExt;
 use parking_lot::Mutex;
 use pin_project_lite::pin_project;
-use vortex_array::Array;
 use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::stream::ArrayStream;
@@ -102,7 +101,7 @@ impl SequenceId {
     pub fn descend(self) -> SequencePointer {
         let mut id = self.id.clone();
         id.push(0);
-        SequencePointer(SequenceId::new(id, self.universe.clone()))
+        SequencePointer(SequenceId::new(id, Arc::clone(&self.universe)))
     }
 
     /// Waits until all SequenceIds with IDs lexicographically smaller than this one are dropped.
@@ -188,7 +187,7 @@ impl SequencePointer {
         let last = next_id.last_mut();
         let last = last.vortex_expect("must have at least one element");
         *last += 1;
-        let next_sibling = SequenceId::new(next_id, self.0.universe.clone());
+        let next_sibling = SequenceId::new(next_id, Arc::clone(&self.0.universe));
         std::mem::replace(&mut self.0, next_sibling)
     }
 
diff --git a/vortex-layout/src/strategy.rs b/vortex-layout/src/strategy.rs
index 079c70decdf..480bae462fe 100644
--- a/vortex-layout/src/strategy.rs
+++ b/vortex-layout/src/strategy.rs
@@ -4,7 +4,7 @@
 use async_trait::async_trait;
 use vortex_array::ArrayContext;
 use vortex_error::VortexResult;
-use vortex_io::runtime::Handle;
+use vortex_session::VortexSession;
 
 use crate::LayoutRef;
 use crate::segments::SegmentSinkRef;
@@ -52,7 +52,7 @@ pub trait LayoutStrategy: 'static + Send + Sync {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef>;
 
     /// Returns the number of bytes currently buffered by this strategy and any child strategies.
@@ -73,10 +73,10 @@ impl LayoutStrategy for std::sync::Arc<dyn LayoutStrategy> {
         segment_sink: SegmentSinkRef,
         stream: SendableSequentialStream,
         eof: SequencePointer,
-        handle: Handle,
+        session: &VortexSession,
     ) -> VortexResult<LayoutRef> {
         (**self)
-            .write_stream(ctx, segment_sink, stream, eof, handle)
+            .write_stream(ctx, segment_sink, stream, eof, session)
             .await
     }
 
diff --git a/vortex-layout/src/vtable.rs b/vortex-layout/src/vtable.rs
index 804d97dfc0d..9bb83fcf643 100644
--- a/vortex-layout/src/vtable.rs
+++ b/vortex-layout/src/vtable.rs
@@ -5,13 +5,13 @@ use std::fmt::Debug;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use vortex_array::ArrayContext;
 use vortex_array::DeserializeMetadata;
 use vortex_array::SerializeMetadata;
 use vortex_array::dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
+use vortex_session::registry::ReadContext;
 
 use crate::IntoLayout;
 use crate::Layout;
@@ -73,7 +73,7 @@ pub trait VTable: 'static + Sized + Send + Sync + Debug {
         metadata: &<Self::Metadata as DeserializeMetadata>::Output,
         segment_ids: Vec<SegmentId>,
         children: &dyn LayoutChildren,
-        ctx: &ArrayContext,
+        ctx: &ReadContext,
     ) -> VortexResult<Self::Layout>;
 
     /// Replaces the children of the layout with the given layout references.
@@ -90,14 +90,14 @@ macro_rules! vtable {
     ($V:ident) => {
         $crate::aliases::paste::paste! {
             #[derive(Debug)]
-            pub struct [<$V VTable>];
+            pub struct $V;
 
             impl AsRef<dyn $crate::Layout> for [<$V Layout>] {
                 fn as_ref(&self) -> &dyn $crate::Layout {
                     // SAFETY: LayoutAdapter is #[repr(transparent)] over the Layout type,
                     // which guarantees identical memory layout. This cast is safe because
                     // we're only changing the type metadata, not the actual data.
-                    unsafe { &*(self as *const [<$V Layout>] as *const $crate::LayoutAdapter<[<$V VTable>]>) }
+                    unsafe { &*(self as *const [<$V Layout>] as *const $crate::LayoutAdapter<$V>) }
                 }
             }
 
@@ -108,7 +108,7 @@ macro_rules! vtable {
                     // SAFETY: LayoutAdapter is #[repr(transparent)] over the Layout type,
                     // which guarantees identical memory layout. This cast is safe because
                     // we're only changing the type metadata, not the actual data.
-                    unsafe { &*(self as *const [<$V Layout>] as *const $crate::LayoutAdapter<[<$V VTable>]>) }
+                    unsafe { &*(self as *const [<$V Layout>] as *const $crate::LayoutAdapter<$V>) }
                 }
             }
 
@@ -117,7 +117,7 @@ macro_rules! vtable {
                     // SAFETY: LayoutAdapter is #[repr(transparent)] over the Layout type,
                     // guaranteeing identical memory layout and alignment. The transmute is safe
                     // because both types have the same size and representation.
-                    std::sync::Arc::new(unsafe { std::mem::transmute::<[<$V Layout>], $crate::LayoutAdapter::<[<$V VTable>]>>(self) })
+                    std::sync::Arc::new(unsafe { std::mem::transmute::<[<$V Layout>], $crate::LayoutAdapter::<$V>>(self) })
                 }
             }
 
@@ -133,7 +133,7 @@ macro_rules! vtable {
                     // SAFETY: LayoutEncodingAdapter is #[repr(transparent)] over the LayoutEncoding type,
                     // which guarantees identical memory layout. This cast is safe because
                     // we're only changing the type metadata, not the actual data.
-                    unsafe { &*(self as *const [<$V LayoutEncoding>] as *const $crate::LayoutEncodingAdapter<[<$V VTable>]>) }
+                    unsafe { &*(self as *const [<$V LayoutEncoding>] as *const $crate::LayoutEncodingAdapter<$V>) }
                 }
             }
 
@@ -144,7 +144,7 @@ macro_rules! vtable {
                     // SAFETY: LayoutEncodingAdapter is #[repr(transparent)] over the LayoutEncoding type,
                     // which guarantees identical memory layout. This cast is safe because
                     // we're only changing the type metadata, not the actual data.
-                    unsafe { &*(self as *const [<$V LayoutEncoding>] as *const $crate::LayoutEncodingAdapter<[<$V VTable>]>) }
+                    unsafe { &*(self as *const [<$V LayoutEncoding>] as *const $crate::LayoutEncodingAdapter<$V>) }
                 }
             }
         }
diff --git a/vortex-mask/Cargo.toml b/vortex-mask/Cargo.toml
index e447f205118..037ffdb0d9d 100644
--- a/vortex-mask/Cargo.toml
+++ b/vortex-mask/Cargo.toml
@@ -28,7 +28,12 @@ vortex-buffer = { workspace = true, features = ["arrow"] }
 vortex-error = { workspace = true }
 
 [dev-dependencies]
+divan = { workspace = true }
 rstest = { workspace = true }
 
+[[bench]]
+name = "intersect_by_rank"
+harness = false
+
 [lints]
 workspace = true
diff --git a/vortex-mask/benches/intersect_by_rank.rs b/vortex-mask/benches/intersect_by_rank.rs
new file mode 100644
index 00000000000..fd02d5ece7b
--- /dev/null
+++ b/vortex-mask/benches/intersect_by_rank.rs
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Benchmarks for `intersect_by_rank`.
+
+#![allow(clippy::unwrap_used, clippy::cast_possible_truncation)]
+
+use divan::Bencher;
+use vortex_buffer::BitBuffer;
+use vortex_mask::Mask;
+
+fn main() {
+    divan::main();
+}
+
+// Standard test cases
+const BENCH_ARGS: &[(usize, &str)] = &[
+    (10_000, "random"),
+    (10_000, "runs"),
+    (100_000, "random"),
+    (100_000, "runs"),
+];
+
+// Sparse test cases (varying base selectivity)
+const SPARSE_ARGS: &[(usize, f64, &str)] = &[
+    (100_000, 0.01, "sparse_1pct"),
+    (100_000, 0.05, "sparse_5pct"),
+    (100_000, 0.10, "sparse_10pct"),
+    (100_000, 0.50, "dense_50pct"),
+];
+
+// Four-case density matrix: (self_density, mask_density)
+const DENSITY_MATRIX_ARGS: &[(f64, f64, &str)] = &[
+    (0.05, 0.05, "self_sparse_mask_sparse"),
+    (0.05, 0.50, "self_sparse_mask_dense"),
+    (0.50, 0.05, "self_dense_mask_sparse"),
+    (0.50, 0.50, "self_dense_mask_dense"),
+];
+
+fn create_random_mask(len: usize, selectivity: f64) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter((0..len).map(|i| {
+        let threshold = (selectivity * 1000.0) as usize;
+        (i * 7 + 13) % 1000 < threshold
+    })))
+}
+
+fn create_runs_mask(len: usize, run_len: usize, gap_len: usize) -> Mask {
+    Mask::from_buffer(BitBuffer::from_iter((0..len).map(|i| {
+        let cycle = run_len + gap_len;
+        (i % cycle) < run_len
+    })))
+}
+
+fn create_fixture(size: usize, pattern: &str) -> (Mask, Mask) {
+    match pattern {
+        "random" => {
+            let base = create_random_mask(size, 0.5);
+            let rank_len = base.true_count();
+            let rank = create_random_mask(rank_len, 0.5);
+            (base, rank)
+        }
+        "runs" => {
+            let base = create_runs_mask(size, 64, 64);
+            let rank_len = base.true_count();
+            let rank = create_runs_mask(rank_len, 64, 64);
+            (base, rank)
+        }
+        _ => unreachable!(),
+    }
+}
+
+fn create_sparse_fixture(size: usize, selectivity: f64) -> (Mask, Mask) {
+    let base = create_random_mask(size, selectivity);
+    let rank_len = base.true_count();
+    let rank = create_random_mask(rank_len, 0.5);
+    (base, rank)
+}
+
+fn create_density_matrix_fixture(
+    size: usize,
+    self_density: f64,
+    mask_density: f64,
+) -> (Mask, Mask) {
+    let base = create_random_mask(size, self_density);
+    let rank_len = base.true_count();
+    let rank = create_random_mask(rank_len, mask_density);
+    (base, rank)
+}
+
+/// Standard patterns (random / runs)
+#[divan::bench(args = BENCH_ARGS)]
+fn intersect_by_rank(bencher: Bencher, (size, pattern): (usize, &str)) {
+    let (base, rank) = create_fixture(size, pattern);
+    bencher
+        .with_inputs(|| (&base, &rank))
+        .bench_refs(|(base, rank)| base.intersect_by_rank(rank));
+}
+
+/// Sparse base masks (varying selectivity)
+#[divan::bench(args = SPARSE_ARGS)]
+fn sparse(bencher: Bencher, (size, selectivity, _name): (usize, f64, &str)) {
+    let (base, rank) = create_sparse_fixture(size, selectivity);
+    bencher
+        .with_inputs(|| (&base, &rank))
+        .bench_refs(|(base, rank)| base.intersect_by_rank(rank));
+}
+
+/// Density matrix (self_density x mask_density)
+#[divan::bench(args = DENSITY_MATRIX_ARGS)]
+fn density_matrix(bencher: Bencher, (self_density, mask_density, _name): (f64, f64, &str)) {
+    let (base, rank) = create_density_matrix_fixture(100_000, self_density, mask_density);
+    bencher
+        .with_inputs(|| (&base, &rank))
+        .bench_refs(|(base, rank)| base.intersect_by_rank(rank));
+}
diff --git a/vortex-mask/public-api.lock b/vortex-mask/public-api.lock
index b0cce7abbf9..a986381bcff 100644
--- a/vortex-mask/public-api.lock
+++ b/vortex-mask/public-api.lock
@@ -68,6 +68,8 @@ pub fn vortex_mask::Mask::into_bit_buffer(self) -> vortex_buffer::bit::buf::BitB
 
 pub fn vortex_mask::Mask::is_empty(&self) -> bool
 
+pub fn vortex_mask::Mask::last(&self) -> core::option::Option<usize>
+
 pub fn vortex_mask::Mask::len(&self) -> usize
 
 pub fn vortex_mask::Mask::limit(self, limit: usize) -> Self
@@ -98,6 +100,10 @@ pub fn vortex_mask::Mask::values(&self) -> core::option::Option<&vortex_mask::Ma
 
 impl vortex_mask::Mask
 
+pub fn vortex_mask::Mask::bitand_not(self, rhs: &vortex_mask::Mask) -> vortex_mask::Mask
+
+impl vortex_mask::Mask
+
 pub fn vortex_mask::Mask::intersect_by_rank(&self, mask: &vortex_mask::Mask) -> vortex_mask::Mask
 
 impl vortex_mask::Mask
diff --git a/vortex-mask/src/bitops.rs b/vortex-mask/src/bitops.rs
index a03778eafab..3ad681db161 100644
--- a/vortex-mask/src/bitops.rs
+++ b/vortex-mask/src/bitops.rs
@@ -46,6 +46,21 @@ impl BitOr for &Mask {
     }
 }
 
+impl Mask {
+    /// Computes `self & !rhs` (AND NOT), equivalent to set difference.
+    pub fn bitand_not(self, rhs: &Mask) -> Mask {
+        if self.len() != rhs.len() {
+            vortex_panic!("Masks must have the same length");
+        }
+        match (self.bit_buffer(), rhs.bit_buffer()) {
+            (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)),
+        }
+    }
+}
+
 impl Not for Mask {
     type Output = Mask;
 
@@ -353,6 +368,34 @@ mod tests {
         assert!(!result.value(3)); // (!(!false) | false) & !true = (false | false) & false = false
     }
 
+    #[test]
+    fn test_bitand_not() {
+        let a = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false]));
+        let b = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false]));
+        let result = a.clone().bitand_not(&b);
+        assert!(!result.value(0)); // true & !true  = false
+        assert!(result.value(1)); // true & !false = true
+        assert!(!result.value(2)); // false & !true  = false
+        assert!(!result.value(3)); // false & !false = false
+
+        // bitand_not(All) = None
+        assert!(a.clone().bitand_not(&Mask::new_true(4)).all_false());
+
+        // bitand_not(None) = self
+        let none = Mask::new_false(4);
+        assert_eq!(a.clone().bitand_not(&none).true_count(), a.true_count());
+
+        // None.bitand_not(_) = None
+        assert!(none.bitand_not(&a).all_false());
+
+        // All.bitand_not(x) = !x
+        let not_b = !&b;
+        let all_bitand_not_b = Mask::new_true(4).bitand_not(&b);
+        for i in 0..4 {
+            assert_eq!(all_bitand_not_b.value(i), not_b.value(i));
+        }
+    }
+
     #[test]
     fn test_bitor() {
         // Test basic OR operations
diff --git a/vortex-mask/src/lib.rs b/vortex-mask/src/lib.rs
index 1f87eb70f46..9c551837de1 100644
--- a/vortex-mask/src/lib.rs
+++ b/vortex-mask/src/lib.rs
@@ -102,10 +102,11 @@ where
 impl<T> Eq for AllOr<T> where T: Eq {}
 
 /// Represents a set of sorted unique positive integers.
+/// If a value is included in a Mask, it's valid.
 ///
 /// A [`Mask`] can be constructed from various representations, and converted to various
 /// others. Internally, these are cached.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
 pub enum Mask {
     /// All values are included.
@@ -116,6 +117,16 @@ pub enum Mask {
     Values(Arc<MaskValues>),
 }
 
+impl Debug for Mask {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::AllTrue(len) => write!(f, "All true({len})"),
+            Self::AllFalse(len) => write!(f, "All false({len})"),
+            Self::Values(mask) => write!(f, "{mask:?}"),
+        }
+    }
+}
+
 impl Default for Mask {
     fn default() -> Self {
         Self::new_true(0)
@@ -123,7 +134,6 @@ impl Default for Mask {
 }
 
 /// Represents the values of a [`Mask`] that contains some true and some false elements.
-#[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MaskValues {
     buffer: BitBuffer,
@@ -141,6 +151,23 @@ pub struct MaskValues {
     density: f64,
 }
 
+impl Debug for MaskValues {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "true_count={}, ", self.true_count)?;
+        write!(f, "density={}, ", self.density)?;
+        if let Some(v) = self.indices.get() {
+            write!(f, "indices={v:?}, ")?;
+        }
+        if let Some(v) = self.slices.get() {
+            write!(f, "slices={v:?}, ")?;
+        }
+        if f.alternate() {
+            f.write_str("\n")?;
+        }
+        write!(f, "{}", self.buffer)
+    }
+}
+
 impl Mask {
     /// Create a new Mask with the given length.
     pub fn new(length: usize, value: bool) -> Self {
@@ -423,6 +450,23 @@ impl Mask {
         }
     }
 
+    /// Returns the last true index in the mask.
+    pub fn last(&self) -> Option<usize> {
+        match &self {
+            Self::AllTrue(len) => (*len > 0).then_some(*len - 1),
+            Self::AllFalse(_) => None,
+            Self::Values(values) => {
+                if let Some(indices) = values.indices.get() {
+                    return indices.last().copied();
+                }
+                if let Some(slices) = values.slices.get() {
+                    return slices.last().map(|(_, end)| end - 1);
+                }
+                values.buffer.set_slices().last().map(|(_, end)| end - 1)
+            }
+        }
+    }
+
     /// Returns the position in the mask of the nth true value.
     pub fn rank(&self, n: usize) -> usize {
         if n >= self.true_count() {
diff --git a/vortex-mask/src/mask_mut.rs b/vortex-mask/src/mask_mut.rs
index ba5d794b3c0..91232ec9327 100644
--- a/vortex-mask/src/mask_mut.rs
+++ b/vortex-mask/src/mask_mut.rs
@@ -498,10 +498,10 @@ impl Mask {
             Mask::AllFalse(len) => MaskMut::new_false(len),
             Mask::Values(values) => {
                 let bit_buffer_mut = match Arc::try_unwrap(values) {
-                    Ok(mask_values) => {
-                        let bit_buffer = mask_values.into_buffer();
-                        bit_buffer.into_mut()
-                    }
+                    Ok(mask_values) => mask_values
+                        .into_buffer()
+                        .try_into_mut()
+                        .unwrap_or_else(|bb| BitBufferMut::copy_from(&bb)),
                     Err(arc_mask_values) => {
                         let bit_buffer = arc_mask_values.bit_buffer();
                         BitBufferMut::copy_from(bit_buffer)
diff --git a/vortex-proto/proto/dtype.proto b/vortex-proto/proto/dtype.proto
index 12af29d1c1e..3a735636cf4 100644
--- a/vortex-proto/proto/dtype.proto
+++ b/vortex-proto/proto/dtype.proto
@@ -70,6 +70,10 @@ message Extension {
   optional bytes metadata = 3;
 }
 
+message Variant {
+  bool nullable = 1;
+}
+
 message DType {
   oneof dtype_type {
     Null null = 1;
@@ -82,6 +86,7 @@ message DType {
     List list = 8;
     Extension extension = 9;
     FixedSizeList fixed_size_list = 10; // This is after `Extension` for backwards compatibility.
+    Variant variant = 11;
   }
 }
 
diff --git a/vortex-proto/proto/expr.proto b/vortex-proto/proto/expr.proto
index 7d713a3afb3..73ba7209a15 100644
--- a/vortex-proto/proto/expr.proto
+++ b/vortex-proto/proto/expr.proto
@@ -20,6 +20,12 @@ message Expr {
   optional bytes metadata = 3;
 }
 
+// Captures a serialized aggregate function with its ID and options metadata.
+message AggregateFn {
+  string id = 1;
+  optional bytes metadata = 2;
+}
+
 // Options for `vortex.literal`
 message LiteralOpts {
   vortex.scalar.Scalar value = 1;
@@ -82,7 +88,10 @@ message SelectOpts {
 }
 
 // Options for `vortex.case_when`
+// Encodes num_when_then_pairs and has_else into a single u32 (num_children).
+// num_children = num_when_then_pairs * 2 + (has_else ? 1 : 0)
+// has_else = num_children % 2 == 1
+// num_when_then_pairs = num_children / 2
 message CaseWhenOpts {
-  uint32 num_when_then_pairs = 1;
-  bool has_else = 2;
+  uint32 num_children = 1;
 }
diff --git a/vortex-proto/proto/scalar.proto b/vortex-proto/proto/scalar.proto
index fcc31b25e3e..251863dc3a3 100644
--- a/vortex-proto/proto/scalar.proto
+++ b/vortex-proto/proto/scalar.proto
@@ -28,6 +28,9 @@ message ScalarValue {
     bytes bytes_value = 8;
     ListValue list_value = 9;
     uint64 f16_value = 10;
+    // Variant scalars carry a row-specific nested scalar.
+    // See RFC 0015: https://github.com/vortex-data/rfcs/blob/develop/accepted/0015-variant-type.md
+    Scalar variant_value = 11;
   }
 }
 
diff --git a/vortex-proto/public-api.lock b/vortex-proto/public-api.lock
index 303fa403401..045b53d17eb 100644
--- a/vortex-proto/public-api.lock
+++ b/vortex-proto/public-api.lock
@@ -26,6 +26,8 @@ pub vortex_proto::dtype::d_type::DtypeType::Struct(vortex_proto::dtype::Struct)
 
 pub vortex_proto::dtype::d_type::DtypeType::Utf8(vortex_proto::dtype::Utf8)
 
+pub vortex_proto::dtype::d_type::DtypeType::Variant(vortex_proto::dtype::Variant)
+
 impl vortex_proto::dtype::d_type::DtypeType
 
 pub fn vortex_proto::dtype::d_type::DtypeType::encode(&self, buf: &mut impl bytes::buf::buf_mut::BufMut)
@@ -608,6 +610,42 @@ pub fn vortex_proto::dtype::Utf8::clear(&mut self)
 
 pub fn vortex_proto::dtype::Utf8::encoded_len(&self) -> usize
 
+pub struct vortex_proto::dtype::Variant
+
+pub vortex_proto::dtype::Variant::nullable: bool
+
+impl core::clone::Clone for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::clone(&self) -> vortex_proto::dtype::Variant
+
+impl core::cmp::Eq for vortex_proto::dtype::Variant
+
+impl core::cmp::PartialEq for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::eq(&self, other: &vortex_proto::dtype::Variant) -> bool
+
+impl core::default::Default for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::default() -> Self
+
+impl core::fmt::Debug for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_proto::dtype::Variant
+
+impl core::marker::StructuralPartialEq for vortex_proto::dtype::Variant
+
+impl prost::message::Message for vortex_proto::dtype::Variant
+
+pub fn vortex_proto::dtype::Variant::clear(&mut self)
+
+pub fn vortex_proto::dtype::Variant::encoded_len(&self) -> usize
+
 pub mod vortex_proto::expr
 
 pub mod vortex_proto::expr::binary_opts
@@ -730,6 +768,46 @@ pub fn vortex_proto::expr::select_opts::Opts::hash<__H: core::hash::Hasher>(&sel
 
 impl core::marker::StructuralPartialEq for vortex_proto::expr::select_opts::Opts
 
+pub struct vortex_proto::expr::AggregateFn
+
+pub vortex_proto::expr::AggregateFn::id: alloc::string::String
+
+pub vortex_proto::expr::AggregateFn::metadata: core::option::Option<alloc::vec::Vec<u8>>
+
+impl vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::metadata(&self) -> &[u8]
+
+impl core::clone::Clone for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::clone(&self) -> vortex_proto::expr::AggregateFn
+
+impl core::cmp::Eq for vortex_proto::expr::AggregateFn
+
+impl core::cmp::PartialEq for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::eq(&self, other: &vortex_proto::expr::AggregateFn) -> bool
+
+impl core::default::Default for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::default() -> Self
+
+impl core::fmt::Debug for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_proto::expr::AggregateFn
+
+impl prost::message::Message for vortex_proto::expr::AggregateFn
+
+pub fn vortex_proto::expr::AggregateFn::clear(&mut self)
+
+pub fn vortex_proto::expr::AggregateFn::encoded_len(&self) -> usize
+
 pub struct vortex_proto::expr::BetweenOpts
 
 pub vortex_proto::expr::BetweenOpts::lower_strict: bool
@@ -810,6 +888,42 @@ pub fn vortex_proto::expr::BinaryOpts::clear(&mut self)
 
 pub fn vortex_proto::expr::BinaryOpts::encoded_len(&self) -> usize
 
+pub struct vortex_proto::expr::CaseWhenOpts
+
+pub vortex_proto::expr::CaseWhenOpts::num_children: u32
+
+impl core::clone::Clone for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::clone(&self) -> vortex_proto::expr::CaseWhenOpts
+
+impl core::cmp::Eq for vortex_proto::expr::CaseWhenOpts
+
+impl core::cmp::PartialEq for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::eq(&self, other: &vortex_proto::expr::CaseWhenOpts) -> bool
+
+impl core::default::Default for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::default() -> Self
+
+impl core::fmt::Debug for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_proto::expr::CaseWhenOpts
+
+impl core::marker::StructuralPartialEq for vortex_proto::expr::CaseWhenOpts
+
+impl prost::message::Message for vortex_proto::expr::CaseWhenOpts
+
+pub fn vortex_proto::expr::CaseWhenOpts::clear(&mut self)
+
+pub fn vortex_proto::expr::CaseWhenOpts::encoded_len(&self) -> usize
+
 pub struct vortex_proto::expr::CastOpts
 
 pub vortex_proto::expr::CastOpts::target: core::option::Option<vortex_proto::dtype::DType>
@@ -1104,6 +1218,8 @@ pub vortex_proto::scalar::scalar_value::Kind::StringValue(alloc::string::String)
 
 pub vortex_proto::scalar::scalar_value::Kind::Uint64Value(u64)
 
+pub vortex_proto::scalar::scalar_value::Kind::VariantValue(alloc::boxed::Box<vortex_proto::scalar::Scalar>)
+
 impl vortex_proto::scalar::scalar_value::Kind
 
 pub fn vortex_proto::scalar::scalar_value::Kind::encode(&self, buf: &mut impl bytes::buf::buf_mut::BufMut)
@@ -1158,7 +1274,7 @@ pub struct vortex_proto::scalar::Scalar
 
 pub vortex_proto::scalar::Scalar::dtype: core::option::Option<vortex_proto::dtype::DType>
 
-pub vortex_proto::scalar::Scalar::value: core::option::Option<vortex_proto::scalar::ScalarValue>
+pub vortex_proto::scalar::Scalar::value: core::option::Option<alloc::boxed::Box<vortex_proto::scalar::ScalarValue>>
 
 impl core::clone::Clone for vortex_proto::scalar::Scalar
 
diff --git a/vortex-proto/src/generated/vortex.dtype.rs b/vortex-proto/src/generated/vortex.dtype.rs
index 49a3defb90f..8dfcd84b454 100644
--- a/vortex-proto/src/generated/vortex.dtype.rs
+++ b/vortex-proto/src/generated/vortex.dtype.rs
@@ -66,9 +66,14 @@ pub struct Extension {
     #[prost(bytes = "vec", optional, tag = "3")]
     pub metadata: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
 }
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Variant {
+    #[prost(bool, tag = "1")]
+    pub nullable: bool,
+}
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DType {
-    #[prost(oneof = "d_type::DtypeType", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
+    #[prost(oneof = "d_type::DtypeType", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11")]
     pub dtype_type: ::core::option::Option<d_type::DtypeType>,
 }
 /// Nested message and enum types in `DType`.
@@ -96,6 +101,8 @@ pub mod d_type {
         /// This is after `Extension` for backwards compatibility.
         #[prost(message, tag = "10")]
         FixedSizeList(::prost::alloc::boxed::Box<super::FixedSizeList>),
+        #[prost(message, tag = "11")]
+        Variant(super::Variant),
     }
 }
 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
diff --git a/vortex-proto/src/generated/vortex.expr.rs b/vortex-proto/src/generated/vortex.expr.rs
index 180e693f269..9c7ddb1d90c 100644
--- a/vortex-proto/src/generated/vortex.expr.rs
+++ b/vortex-proto/src/generated/vortex.expr.rs
@@ -11,6 +11,14 @@ pub struct Expr {
     #[prost(bytes = "vec", optional, tag = "3")]
     pub metadata: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
 }
+/// Captures a serialized aggregate function with its ID and options metadata.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct AggregateFn {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(bytes = "vec", optional, tag = "2")]
+    pub metadata: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
+}
 /// Options for `vortex.literal`
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct LiteralOpts {
@@ -146,10 +154,12 @@ pub mod select_opts {
     }
 }
 /// Options for `vortex.case_when`
+/// Encodes num_when_then_pairs and has_else into a single u32 (num_children).
+/// num_children = num_when_then_pairs * 2 + (has_else ? 1 : 0)
+/// has_else = num_children % 2 == 1
+/// num_when_then_pairs = num_children / 2
 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct CaseWhenOpts {
     #[prost(uint32, tag = "1")]
-    pub num_when_then_pairs: u32,
-    #[prost(bool, tag = "2")]
-    pub has_else: bool,
+    pub num_children: u32,
 }
diff --git a/vortex-proto/src/generated/vortex.scalar.rs b/vortex-proto/src/generated/vortex.scalar.rs
index 9f4e3047e54..df43794acf7 100644
--- a/vortex-proto/src/generated/vortex.scalar.rs
+++ b/vortex-proto/src/generated/vortex.scalar.rs
@@ -3,12 +3,12 @@
 pub struct Scalar {
     #[prost(message, optional, tag = "1")]
     pub dtype: ::core::option::Option<super::dtype::DType>,
-    #[prost(message, optional, tag = "2")]
-    pub value: ::core::option::Option<ScalarValue>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub value: ::core::option::Option<::prost::alloc::boxed::Box<ScalarValue>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarValue {
-    #[prost(oneof = "scalar_value::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
+    #[prost(oneof = "scalar_value::Kind", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11")]
     pub kind: ::core::option::Option<scalar_value::Kind>,
 }
 /// Nested message and enum types in `ScalarValue`.
@@ -35,6 +35,10 @@ pub mod scalar_value {
         ListValue(super::ListValue),
         #[prost(uint64, tag = "10")]
         F16Value(u64),
+        /// Variant scalars carry a row-specific nested scalar.
+        /// See RFC 0015: <https://github.com/vortex-data/rfcs/blob/develop/accepted/0015-variant-type.md>
+        #[prost(message, tag = "11")]
+        VariantValue(::prost::alloc::boxed::Box<super::Scalar>),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
diff --git a/vortex-python/Cargo.toml b/vortex-python/Cargo.toml
index 391dc9b4b47..7a606495c7d 100644
--- a/vortex-python/Cargo.toml
+++ b/vortex-python/Cargo.toml
@@ -28,6 +28,10 @@ default = ["extension-module", "tui"]
 # duplicate PyInit__lib symbols.
 extension-module = []
 tui = ["dep:vortex-tui"]
+# Set the default allocator to mimalloc, this is enabled by default
+# for the maturin wheels, but it is not a default feature to not conflict
+# with users that set a different global allocator.
+mimalloc = ["dep:mimalloc"]
 
 [dependencies]
 arrow-array = { workspace = true }
@@ -36,6 +40,7 @@ arrow-schema = { workspace = true }
 bytes = { workspace = true }
 itertools = { workspace = true }
 log = { workspace = true }
+mimalloc = { workspace = true, optional = true }
 object_store = { workspace = true, features = [
     "fs",
     "aws",
@@ -47,7 +52,7 @@ parking_lot = { workspace = true }
 pyo3 = { workspace = true, features = ["abi3", "abi3-py311"] }
 pyo3-bytes = { workspace = true }
 pyo3-log = { workspace = true }
-pyo3-object_store = { version = "0.7" }
+pyo3-object_store = { workspace = true }
 tokio = { workspace = true, features = ["fs", "rt-multi-thread"] }
 url = { workspace = true }
 vortex = { workspace = true, features = ["object_store", "tokio"] }
diff --git a/vortex-python/build.rs b/vortex-python/build.rs
index 1a552ef69f3..51b482e42db 100644
--- a/vortex-python/build.rs
+++ b/vortex-python/build.rs
@@ -2,9 +2,8 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 fn main() {
-    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
-
-    if target_os == "macos" {
+    #[cfg(target_os = "macos")]
+    {
         // For pyo3 to successfully link on macOS.
         // See https://stackoverflow.com/a/77382609
         println!("cargo:rustc-link-arg=-undefined");
diff --git a/vortex-python/pyproject.toml b/vortex-python/pyproject.toml
index e9699dee4fd..e90bae5a41b 100644
--- a/vortex-python/pyproject.toml
+++ b/vortex-python/pyproject.toml
@@ -6,7 +6,7 @@ dynamic = ["version", "description", "authors"]
 readme = "README.md"
 dependencies = [
     "pyarrow>=17.0.0",
-    "substrait>=0.23.0",
+    "substrait>=0.23.0,<0.29.0",
     "typing-extensions>=4.5.0",
 ]
 requires-python = ">= 3.11"
@@ -59,7 +59,7 @@ managed = true
 [tool.maturin]
 python-source = "python"
 module-name = "vortex._lib"
-features = ["pyo3/extension-module"]
+features = ["pyo3/extension-module", "mimalloc"]
 compatibility = "manylinux2014"
 include = [
     { path = "rust-toolchain.toml", format = "sdist" },
@@ -67,16 +67,22 @@ include = [
     { path = "python/vortex/py.typed", format = "sdist" },
 ]
 
-[tool.basedpyright]
-exclude = ["python/vortex/_lib/store/**.pyi"]
-
 [dependency-groups]
 dev = [
-    "basedpyright>=1.31",
+    "duckdb>=1.1.2",
+    "maturin>=1.7.2",
     "numpy>=2.2.2",
     "pandas-stubs>=2.2.3.241126",
+    "pandas[output-formatting]>=2.2.3",
     "pcodec>=0.3.3",
+    "polars>=1.9.0",
     "pyarrow-stubs>=17.16",
     "pytest-benchmark>=5.1.0",
     "pytest-xdist>=3.5.0",
+    "ray>=2.48",
+    # forced transitive bumps
+    "protobuf>=6.33.5",
 ]
+
+[tool.basedpyright]
+exclude = ["python/vortex/_lib/store/**.pyi"]
diff --git a/vortex-python/python/vortex/__init__.py b/vortex-python/python/vortex/__init__.py
index 40c3e7c4a91..5396f50b7a0 100644
--- a/vortex-python/python/vortex/__init__.py
+++ b/vortex-python/python/vortex/__init__.py
@@ -74,7 +74,7 @@
     Utf8Scalar,
     scalar,
 )
-from ._lib.serde import ArrayContext, ArrayParts  # pyright: ignore[reportMissingModuleSource]
+from ._lib.serde import ArrayContext, SerializedArray  # pyright: ignore[reportMissingModuleSource]
 from .arrays import (
     Array,
     PyArray,
@@ -177,7 +177,7 @@
     "ExtensionScalar",
     # Serde
     "ArrayContext",
-    "ArrayParts",
+    "SerializedArray",
     # Pickle
     "_unpickle_array",
     # File
diff --git a/vortex-python/python/vortex/_lib/serde.pyi b/vortex-python/python/vortex/_lib/serde.pyi
index 626946a7e6c..b4d052b3e47 100644
--- a/vortex-python/python/vortex/_lib/serde.pyi
+++ b/vortex-python/python/vortex/_lib/serde.pyi
@@ -10,9 +10,9 @@ from .arrays import Array
 from .dtype import DType
 
 @final
-class ArrayParts:
+class SerializedArray:
     @staticmethod
-    def parse(data: bytes) -> ArrayParts: ...
+    def parse(data: bytes) -> SerializedArray: ...
     @property
     def metadata(self) -> bytes | None: ...
     @property
@@ -22,7 +22,7 @@ class ArrayParts:
     @property
     def nchildren(self) -> int: ...
     @property
-    def children(self) -> list[ArrayParts]: ...
+    def children(self) -> list[SerializedArray]: ...
     def decode(self, ctx: ArrayContext, dtype: DType, len: int) -> pa.Array[pa.Scalar[pa.DataType]]: ...
 
 @final
diff --git a/vortex-python/python/vortex/_lib/store/__init__.pyi b/vortex-python/python/vortex/_lib/store/__init__.pyi
index 56b92353aeb..b394b118b80 100644
--- a/vortex-python/python/vortex/_lib/store/__init__.pyi
+++ b/vortex-python/python/vortex/_lib/store/__init__.pyi
@@ -130,13 +130,13 @@ class LocalStore:
     ```
     """
 
-    def __init__(
+    def __new__(
         self,
         prefix: str | Path | None = None,
         *,
         automatic_cleanup: bool = False,
         mkdir: bool = False,
-    ) -> None:
+    ) -> Self:
         """Create a new LocalStore.
 
         Args:
diff --git a/vortex-python/python/vortex/_lib/store/_aws.pyi b/vortex-python/python/vortex/_lib/store/_aws.pyi
index 8bed273bdca..91833151158 100644
--- a/vortex-python/python/vortex/_lib/store/_aws.pyi
+++ b/vortex-python/python/vortex/_lib/store/_aws.pyi
@@ -457,8 +457,8 @@ class S3Store:
     set in the environment.
     """
 
-    def __init__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
-        self,
+    def __new__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
+        cls,
         bucket: str | None = None,
         *,
         prefix: str | None = None,
@@ -467,7 +467,7 @@ class S3Store:
         retry_config: RetryConfig | None = None,
         credential_provider: S3CredentialProvider | None = None,
         **kwargs: Unpack[S3Config],  # type: ignore # noqa: PGH003 (bucket key overlaps with positional arg)
-    ) -> None:
+    ) -> Self:
         """Create a new S3Store.
 
         Args:
diff --git a/vortex-python/python/vortex/_lib/store/_azure.pyi b/vortex-python/python/vortex/_lib/store/_azure.pyi
index 3c1d99af221..e59aa40c902 100644
--- a/vortex-python/python/vortex/_lib/store/_azure.pyi
+++ b/vortex-python/python/vortex/_lib/store/_azure.pyi
@@ -315,8 +315,8 @@ class AzureStore:
     [`AzureConfig`][vortex.store.AzureConfig] for valid environment variables.
     """
 
-    def __init__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "container_name"
-        self,
+    def __new__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "container_name"
+        cls,
         container_name: str | None = None,
         *,
         prefix: str | None = None,
@@ -325,7 +325,7 @@ class AzureStore:
         retry_config: RetryConfig | None = None,
         credential_provider: AzureCredentialProvider | None = None,
         **kwargs: Unpack[AzureConfig],  # type: ignore # noqa: PGH003 (container_name key overlaps with positional arg)
-    ) -> None:
+    ) -> Self:
         """Construct a new AzureStore.
 
         Args:
diff --git a/vortex-python/python/vortex/_lib/store/_gcs.pyi b/vortex-python/python/vortex/_lib/store/_gcs.pyi
index f7f27008518..a988374593c 100644
--- a/vortex-python/python/vortex/_lib/store/_gcs.pyi
+++ b/vortex-python/python/vortex/_lib/store/_gcs.pyi
@@ -134,8 +134,8 @@ class GCSStore:
     [here](https://cloud.google.com/docs/authentication/application-default-credentials).
     """
 
-    def __init__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
-        self,
+    def __new__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
+        cls,
         bucket: str | None = None,
         *,
         prefix: str | None = None,
@@ -144,7 +144,7 @@ class GCSStore:
         retry_config: RetryConfig | None = None,
         credential_provider: GCSCredentialProvider | None = None,
         **kwargs: Unpack[GCSConfig],  # type: ignore # noqa: PGH003 (bucket key overlaps with positional arg)
-    ) -> None:
+    ) -> Self:
         """Construct a new GCSStore.
 
         Args:
diff --git a/vortex-python/python/vortex/_lib/store/_http.pyi b/vortex-python/python/vortex/_lib/store/_http.pyi
index 549470fd4c5..56d9e464c29 100644
--- a/vortex-python/python/vortex/_lib/store/_http.pyi
+++ b/vortex-python/python/vortex/_lib/store/_http.pyi
@@ -9,13 +9,13 @@ from ._retry import RetryConfig
 class HTTPStore:
     """Configure a connection to a generic HTTP server."""
 
-    def __init__(
+    def __new__(
         self,
         url: str,
         *,
         client_options: ClientConfig | None = None,
         retry_config: RetryConfig | None = None,
-    ) -> None:
+    ) -> Self:
         """Construct a new HTTPStore from a URL.
 
         Any path on the URL will be assigned as the `prefix` for the store. So if you
diff --git a/vortex-python/python/vortex/arrays.py b/vortex-python/python/vortex/arrays.py
index 4180510d501..5181400cb32 100644
--- a/vortex-python/python/vortex/arrays.py
+++ b/vortex-python/python/vortex/arrays.py
@@ -13,7 +13,7 @@
 from vortex._lib.dtype import DType  # pyright: ignore[reportMissingModuleSource]
 from vortex._lib.serde import (  # pyright: ignore[reportMissingModuleSource]
     ArrayContext,
-    ArrayParts,
+    SerializedArray,
     decode_ipc_array_buffers,
 )
 
@@ -463,12 +463,12 @@ def dtype(self) -> DType:
 
     @classmethod
     @abc.abstractmethod
-    def decode(cls, parts: ArrayParts, ctx: ArrayContext, dtype: DType, len: int) -> Array:
+    def decode(cls, parts: SerializedArray, ctx: ArrayContext, dtype: DType, len: int) -> Array:
         """Decode an array from its component parts.
 
-        :class:`ArrayParts` contains the metadata, buffers and child :class:`ArrayParts` that represent the
-        current array. Implementations of this function should validate this information, and then construct
-        a new array.
+        :class:`SerializedArray` contains the metadata, buffers and child :class:`SerializedArray`
+        that represent the current array. Implementations of this function should validate this
+        information, and then construct a new array.
         """
 
 
diff --git a/vortex-python/python/vortex/ray/datasource.py b/vortex-python/python/vortex/ray/datasource.py
index 1f15e2b232a..b3516490026 100644
--- a/vortex-python/python/vortex/ray/datasource.py
+++ b/vortex-python/python/vortex/ray/datasource.py
@@ -8,6 +8,7 @@
 
 from ray.data import Datasource, ReadTask
 from ray.data.block import BlockMetadata
+from ray.data.context import DataContext
 from ray.data.datasource import BaseFileMetadataProvider, DefaultFileMetadataProvider
 from ray.data.datasource.path_util import (
     _resolve_paths_and_filesystem,  # pyright: ignore[reportPrivateUsage, reportUnknownVariableType]
@@ -23,7 +24,6 @@
     import pandas
     import pyarrow.compute as pc
 
-
 T = TypeVar("T")
 
 
@@ -81,7 +81,9 @@ def estimate_inmemory_data_size(self) -> int | None:
         return None
 
     @override
-    def get_read_tasks(self, parallelism: int, per_task_row_limit: int | None = None) -> list[ReadTask]:
+    def get_read_tasks(
+        self, parallelism: int, per_task_row_limit: int | None = None, data_context: DataContext | None = None
+    ) -> list[ReadTask]:
         """Execute the read and return read tasks.
 
         Args:
diff --git a/vortex-python/python/vortex/serde.py b/vortex-python/python/vortex/serde.py
index cb1f7f6c9a0..c30ceef4058 100644
--- a/vortex-python/python/vortex/serde.py
+++ b/vortex-python/python/vortex/serde.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-from vortex._lib.serde import ArrayContext, ArrayParts  # pyright: ignore[reportMissingModuleSource]
+from vortex._lib.serde import ArrayContext, SerializedArray  # pyright: ignore[reportMissingModuleSource]
 
-__all__ = ["ArrayParts", "ArrayContext"]
+__all__ = ["SerializedArray", "ArrayContext"]
diff --git a/vortex-python/python/vortex/store.py b/vortex-python/python/vortex/store.py
deleted file mode 100644
index 3819ef86042..00000000000
--- a/vortex-python/python/vortex/store.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-from typing import TYPE_CHECKING
-
-from ._lib.store import (  # pyright: ignore[reportMissingModuleSource]
-    AzureStore,
-    GCSStore,
-    HTTPStore,
-    LocalStore,
-    MemoryStore,
-    S3Store,
-    from_url,
-)
-
-if TYPE_CHECKING:
-    from ._lib.store import (  # pyright: ignore[reportMissingModuleSource]
-        AzureAccessKey,
-        AzureBearerToken,
-        AzureConfig,
-        AzureCredential,
-        AzureCredentialProvider,
-        AzureSASToken,
-        BackoffConfig,
-        ClientConfig,
-        GCSConfig,
-        GCSCredential,
-        GCSCredentialProvider,
-        ObjectStore,
-        RetryConfig,
-        S3Config,
-        S3Credential,
-        S3CredentialProvider,
-    )
-
-__all__ = [
-    # Azure
-    "AzureAccessKey",
-    "AzureBearerToken",
-    "AzureConfig",
-    "AzureCredential",
-    "AzureCredentialProvider",
-    "AzureSASToken",
-    "AzureStore",
-    # Client
-    "BackoffConfig",
-    "ClientConfig",
-    "RetryConfig",
-    # GCS
-    "GCSConfig",
-    "GCSCredential",
-    "GCSCredentialProvider",
-    "GCSStore",
-    # HTTP
-    "HTTPStore",
-    # Local
-    "LocalStore",
-    "MemoryStore",
-    # S3
-    "S3Config",
-    "S3Credential",
-    "S3CredentialProvider",
-    "S3Store",
-    # Utility
-    "from_url",
-    "ObjectStore",
-]
diff --git a/vortex-python/python/vortex/store/LICENSE b/vortex-python/python/vortex/store/LICENSE
new file mode 100644
index 00000000000..7bca320a280
--- /dev/null
+++ b/vortex-python/python/vortex/store/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Development Seed
+
+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/vortex-python/python/vortex/store/__init__.py b/vortex-python/python/vortex/store/__init__.py
new file mode 100644
index 00000000000..043f0bf9ab6
--- /dev/null
+++ b/vortex-python/python/vortex/store/__init__.py
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+from collections.abc import Callable
+from typing import TypeAlias, Unpack, overload
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+from ._aws import S3Config, S3Credential, S3CredentialProvider, S3Store
+from ._azure import (
+    AzureAccessKey,
+    AzureBearerToken,
+    AzureConfig,
+    AzureCredential,
+    AzureCredentialProvider,
+    AzureSASToken,
+    AzureStore,
+)
+from ._client import ClientConfig
+from ._gcs import GCSConfig, GCSCredential, GCSCredentialProvider, GCSStore
+from ._http import HTTPStore
+from ._local import LocalStore
+from ._memory import MemoryStore
+from ._retry import BackoffConfig, RetryConfig
+
+ObjectStore: TypeAlias = AzureStore | GCSStore | HTTPStore | S3Store | LocalStore | MemoryStore
+"""All supported ObjectStore implementations."""
+
+
+@overload
+def from_url(
+    url: str,
+    *,
+    config: S3Config | None = None,
+    client_options: ClientConfig | None = None,
+    retry_config: RetryConfig | None = None,
+    credential_provider: S3CredentialProvider | None = None,
+    **kwargs: Unpack[S3Config],
+) -> ObjectStore: ...
+@overload
+def from_url(
+    url: str,
+    *,
+    config: GCSConfig | None = None,
+    client_options: ClientConfig | None = None,
+    retry_config: RetryConfig | None = None,
+    credential_provider: GCSCredentialProvider | None = None,
+    **kwargs: Unpack[GCSConfig],
+) -> ObjectStore: ...
+@overload
+def from_url(
+    url: str,
+    *,
+    config: AzureConfig | None = None,
+    client_options: ClientConfig | None = None,
+    retry_config: RetryConfig | None = None,
+    credential_provider: AzureCredentialProvider | None = None,
+    **kwargs: Unpack[AzureConfig],
+) -> ObjectStore: ...
+@overload
+def from_url(
+    url: str,
+    *,
+    config: None = None,
+    client_options: None = None,
+    retry_config: None = None,
+    automatic_cleanup: bool = False,
+    mkdir: bool = False,
+) -> ObjectStore: ...
+def from_url(  # type: ignore[misc] # docstring in pyi file
+    url: str,
+    *,
+    config: S3Config | GCSConfig | AzureConfig | None = None,
+    client_options: ClientConfig | None = None,
+    retry_config: RetryConfig | None = None,
+    credential_provider: Callable[..., object] | None = None,
+    **kwargs: object,
+) -> ObjectStore:
+    """Easy construction of store by URL, identifying the relevant store.
+
+    This will defer to a store-specific ``from_url`` constructor based on the provided
+    ``url``. E.g. passing ``"s3://bucket/path"`` will defer to
+    :meth:`S3Store.from_url <vortex.store.S3Store.from_url>`.
+
+    Supported formats:
+
+    - ``file:///path/to/my/file`` -> :class:`~vortex.store.LocalStore`
+    - ``memory:///`` -> :class:`~vortex.store.MemoryStore`
+    - ``s3://bucket/path`` -> :class:`~vortex.store.S3Store` (also supports ``s3a``)
+    - ``gs://bucket/path`` -> :class:`~vortex.store.GCSStore`
+    - ``az://account/container/path`` -> :class:`~vortex.store.AzureStore` (also
+      supports ``adl``, ``azure``, ``abfs``, ``abfss``)
+    - ``http://mydomain/path`` -> :class:`~vortex.store.HTTPStore`
+    - ``https://mydomain/path`` -> :class:`~vortex.store.HTTPStore`
+
+    There are also special cases for AWS and Azure for ``https://{host?}/path`` paths:
+
+    - ``dfs.core.windows.net``, ``blob.core.windows.net``, ``dfs.fabric.microsoft.com``,
+      ``blob.fabric.microsoft.com`` -> :class:`~vortex.store.AzureStore`
+    - ``amazonaws.com`` -> :class:`~vortex.store.S3Store`
+    - ``r2.cloudflarestorage.com`` -> :class:`~vortex.store.S3Store`
+
+    .. note::
+
+        For best static typing, use the constructors on individual store classes
+        directly.
+
+    Args:
+        url: well-known storage URL.
+
+    Keyword Args:
+        config: per-store Configuration. Values in this config will override values
+            inferred from the url. Defaults to None.
+        client_options: HTTP Client options. Defaults to None.
+        retry_config: Retry configuration. Defaults to None.
+        credential_provider: A callback to provide custom credentials to the underlying store classes.
+        kwargs: per-store configuration passed down to store-specific builders.
+
+    """
+    return _store.from_url(  # pyright: ignore[reportCallIssue, reportUnknownVariableType]
+        url,
+        config=config,  # pyright: ignore[reportArgumentType]
+        client_options=client_options,
+        retry_config=retry_config,
+        credential_provider=credential_provider,  # pyright: ignore[reportArgumentType]
+        **kwargs,  # pyright: ignore[reportArgumentType]
+    )
+
+
+__all__ = [
+    # Azure
+    "AzureAccessKey",
+    "AzureBearerToken",
+    "AzureConfig",
+    "AzureCredential",
+    "AzureCredentialProvider",
+    "AzureSASToken",
+    "AzureStore",
+    # Client
+    "BackoffConfig",
+    "ClientConfig",
+    "RetryConfig",
+    # GCS
+    "GCSConfig",
+    "GCSCredential",
+    "GCSCredentialProvider",
+    "GCSStore",
+    # HTTP
+    "HTTPStore",
+    # Local
+    "LocalStore",
+    "MemoryStore",
+    # S3
+    "S3Config",
+    "S3Credential",
+    "S3CredentialProvider",
+    "S3Store",
+    # Utility
+    "from_url",
+    "ObjectStore",
+]
diff --git a/vortex-python/python/vortex/store/_aws.py b/vortex-python/python/vortex/store/_aws.py
new file mode 100644
index 00000000000..3f3079e9902
--- /dev/null
+++ b/vortex-python/python/vortex/store/_aws.py
@@ -0,0 +1,562 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+from collections.abc import Coroutine
+from datetime import datetime
+from typing import Any, Literal, NotRequired, Protocol, Self, TypeAlias, TypedDict, Unpack
+
+from typing_extensions import override
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+from ._client import ClientConfig
+from ._retry import RetryConfig
+
+S3Regions: TypeAlias = Literal[
+    "af-south-1",
+    "ap-east-1",
+    "ap-northeast-1",
+    "ap-northeast-2",
+    "ap-northeast-3",
+    "ap-south-1",
+    "ap-south-2",
+    "ap-southeast-1",
+    "ap-southeast-2",
+    "ap-southeast-3",
+    "ap-southeast-4",
+    "ap-southeast-5",
+    "ap-southeast-7",
+    "ca-central-1",
+    "ca-west-1",
+    "eu-central-1",
+    "eu-central-2",
+    "eu-north-1",
+    "eu-south-1",
+    "eu-south-2",
+    "eu-west-1",
+    "eu-west-2",
+    "eu-west-3",
+    "il-central-1",
+    "me-central-1",
+    "me-south-1",
+    "mx-central-1",
+    "sa-east-1",
+    "us-east-1",
+    "us-east-2",
+    "us-gov-east-1",
+    "us-gov-west-1",
+    "us-west-1",
+    "us-west-2",
+]
+"""AWS regions."""
+
+S3ChecksumAlgorithm: TypeAlias = Literal["SHA256"]
+"""S3 Checksum algorithms
+
+From https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums
+"""
+
+S3EncryptionAlgorithm: TypeAlias = Literal[
+    "AES256",
+    "aws:kms",
+    "aws:kms:dsse",
+    "sse-c",
+]
+
+
+class S3Config(TypedDict, total=False):
+    """Configuration parameters for S3Store."""
+
+    access_key_id: str
+    """AWS Access Key.
+
+    **Environment variable**: ``AWS_ACCESS_KEY_ID``.
+    """
+    bucket: str
+    """Bucket name (required).
+
+    **Environment variables**:
+
+    - ``AWS_BUCKET``
+    - ``AWS_BUCKET_NAME``
+    """
+    checksum_algorithm: S3ChecksumAlgorithm | str
+    """
+    Sets the `checksum algorithm <https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html>`_
+    which has to be used for object integrity check during upload.
+
+    **Environment variable**: ``AWS_CHECKSUM_ALGORITHM``.
+    """
+    conditional_put: str
+    """Configure how to provide conditional put support
+
+    Supported values:
+
+    - ``"etag"`` (default): Supported for S3-compatible stores that support conditional
+        put using the standard `HTTP precondition <https://datatracker.ietf.org/doc/html/rfc9110#name-preconditions>`_
+        headers ``If-Match`` and ``If-None-Match``.
+
+    - ``"dynamo:<TABLE_NAME>"`` or ``"dynamo:<TABLE_NAME>:<TIMEOUT_MILLIS>"``: The name of a DynamoDB table to
+      use for coordination.
+
+        This will use the same region, credentials and endpoint as configured for S3.
+
+    **Environment variable**: ``AWS_CONDITIONAL_PUT``.
+    """
+    container_credentials_relative_uri: str
+    """Set the container credentials relative URI
+
+    <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+
+    **Environment variable**: ``AWS_CONTAINER_CREDENTIALS_RELATIVE_URI``.
+    """
+    copy_if_not_exists: Literal["multipart"] | str
+    """Configure how to provide "copy if not exists".
+
+    Supported values:
+
+    - ``"multipart"``:
+
+        Native Amazon S3 supports copy if not exists through a multipart upload
+        where the upload copies an existing object and is completed only if the
+        new object does not already exist.
+
+        .. warning::
+
+            When using this mode, ``copy_if_not_exists`` does not copy tags
+            or attributes from the source object.
+
+        .. warning::
+
+            When using this mode, ``copy_if_not_exists`` makes only a best
+            effort attempt to clean up the multipart upload if the copy operation
+            fails. Consider using a lifecycle rule to automatically clean up
+            abandoned multipart uploads.
+
+    - ``"header:<HEADER_NAME>:<HEADER_VALUE>"``:
+
+        Some S3-compatible stores, such as Cloudflare R2, support copy if not exists
+        semantics through custom headers.
+
+        If set, ``copy_if_not_exists`` will perform a normal copy operation with the
+        provided header pair, and expect the store to fail with `412 Precondition
+        Failed` if the destination file already exists.
+
+        For example ``header: cf-copy-destination-if-none-match: *``, would set
+        the header ``cf-copy-destination-if-none-match`` to ``*``.
+
+    - ``"header-with-status:<HEADER_NAME>:<HEADER_VALUE>:<STATUS>"``:
+
+        The same as the header variant above but allows custom status code checking, for
+        object stores that return values other than 412.
+
+    - ``"dynamo:<TABLE_NAME>"`` or ``"dynamo:<TABLE_NAME>:<TIMEOUT_MILLIS>"``:
+
+        The name of a DynamoDB table to use for coordination.
+
+        The default timeout is used if not specified. This will use the same region,
+        credentials and endpoint as configured for S3.
+
+    **Environment variable**: ``AWS_COPY_IF_NOT_EXISTS``.
+    """
+    default_region: S3Regions | str
+    """Default region.
+
+    **Environment variable**: ``AWS_DEFAULT_REGION``.
+    """
+    disable_tagging: bool
+    """Disable tagging objects. This can be desirable if not supported by the backing store.
+
+    **Environment variable**: ``AWS_DISABLE_TAGGING``.
+    """
+    endpoint: str
+    """The endpoint for communicating with AWS S3.
+
+    Defaults to the `region endpoint <https://docs.aws.amazon.com/general/latest/gr/s3.html>`_.
+
+    For example, this might be set to ``"http://localhost:4566"`` for testing against a
+    localstack instance.
+
+    The ``endpoint`` field should be consistent with ``with_virtual_hosted_style_request``,
+    i.e. if ``virtual_hosted_style_request`` is set to ``True`` then ``endpoint`` should have
+    the bucket name included.
+
+    By default, only HTTPS schemes are enabled. To connect to an HTTP endpoint, enable
+    ``allow_http`` in the client options.
+
+    **Environment variables**:
+
+    - ``AWS_ENDPOINT_URL``
+    - ``AWS_ENDPOINT``
+    """
+    imdsv1_fallback: bool
+    """Fall back to ImdsV1.
+
+    By default instance credentials will only be fetched over
+    `IMDSv2 <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html>`_,
+    as AWS recommends against having IMDSv1 enabled on EC2 instances as it is vulnerable to
+    `SSRF attack <https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/>`_.
+
+    However, certain deployment environments, such as those running old versions of
+    kube2iam, may not support IMDSv2. This option will enable automatic fallback to
+    using IMDSv1 if the token endpoint returns a 403 error indicating that IMDSv2 is not
+    supported.
+
+    This option has no effect if not using instance credentials.
+
+    **Environment variable**: ``AWS_IMDSV1_FALLBACK``.
+    """
+    metadata_endpoint: str
+    """Set the instance metadata endpoint, used primarily within AWS EC2.
+
+    This defaults to the IPv4 endpoint: ``http://169.254.169.254``. One can alternatively
+    use the IPv6 endpoint ``http://fd00:ec2::254``.
+
+    **Environment variable**: ``AWS_METADATA_ENDPOINT``.
+    """
+    region: S3Regions | str
+    """The region, defaults to ``us-east-1``
+
+    **Environment variable**: ``AWS_REGION``.
+    """
+    request_payer: bool
+    """If ``True``, enable operations on requester-pays buckets.
+
+    https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html
+
+    **Environment variable**: ``AWS_REQUEST_PAYER``.
+    """
+    s3_express: bool
+    """Enable Support for S3 Express One Zone.
+
+    **Environment variable**: ``AWS_S3_EXPRESS``.
+    """
+    secret_access_key: str
+    """Secret Access Key.
+
+    **Environment variable**: ``AWS_SECRET_ACCESS_KEY``.
+    """
+    server_side_encryption: S3EncryptionAlgorithm | str
+    """Type of encryption to use.
+
+    If set, must be one of:
+
+    - ``"AES256"`` (SSE-S3)
+    - ``"aws:kms"`` (SSE-KMS)
+    - ``"aws:kms:dsse"`` (DSSE-KMS)
+    - ``"sse-c"``
+
+    **Environment variable**: ``AWS_SERVER_SIDE_ENCRYPTION``.
+    """
+    session_token: str
+    """Token to use for requests (passed to underlying provider).
+
+    **Environment variables**:
+
+    - ``AWS_SESSION_TOKEN``
+    - ``AWS_TOKEN``
+    """
+    skip_signature: bool
+    """If ``True``, S3Store will not fetch credentials and will not sign requests.
+
+    This can be useful when interacting with public S3 buckets that deny authorized requests.
+
+    **Environment variable**: ``AWS_SKIP_SIGNATURE``.
+    """
+    sse_bucket_key_enabled: bool
+    """Set whether to enable bucket key for server side encryption.
+
+    This overrides the bucket default setting for bucket keys.
+
+    - When ``False``, each object is encrypted with a unique data key.
+    - When ``True``, a single data key is used for the entire bucket,
+      reducing overhead of encryption.
+
+    **Environment variable**: ``AWS_SSE_BUCKET_KEY_ENABLED``.
+    """
+    sse_customer_key_base64: str
+    """
+    The base64 encoded, 256-bit customer encryption key to use for server-side
+    encryption. If set, the server side encryption config value must be ``"sse-c"``.
+
+    **Environment variable**: ``AWS_SSE_CUSTOMER_KEY_BASE64``.
+    """
+    sse_kms_key_id: str
+    """
+    The KMS key ID to use for server-side encryption.
+
+    If set, the server side encryption config value must be ``"aws:kms"`` or ``"aws:kms:dsse"``.
+
+    **Environment variable**: ``AWS_SSE_KMS_KEY_ID``.
+    """
+    unsigned_payload: bool
+    """Avoid computing payload checksum when calculating signature.
+
+    See `unsigned payload option <https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-header-based-auth.html>`_.
+
+    - ``False`` (default): Signed payload option is used, where the checksum for the request body is computed
+      and included when constructing a canonical request.
+    - ``True``: Unsigned payload option is used. ``UNSIGNED-PAYLOAD`` literal is included when constructing a
+       canonical request,
+
+    **Environment variable**: ``AWS_UNSIGNED_PAYLOAD``.
+    """
+    virtual_hosted_style_request: bool
+    """If virtual hosted style request has to be used.
+
+    If ``virtual_hosted_style_request`` is:
+
+    - ``False`` (default):  Path style request is used
+    - ``True``:  Virtual hosted style request is used
+
+    If the ``endpoint`` is provided then it should be consistent with
+    ``virtual_hosted_style_request``. i.e. if ``virtual_hosted_style_request`` is set to
+    ``True`` then ``endpoint`` should have bucket name included.
+
+    **Environment variable**: ``AWS_VIRTUAL_HOSTED_STYLE_REQUEST``.
+    """
+
+
+class S3Credential(TypedDict):
+    """An S3 credential."""
+
+    access_key_id: str
+    """AWS access key ID."""
+
+    secret_access_key: str
+    """AWS secret access key"""
+
+    token: NotRequired[str | None]
+    """AWS token."""
+
+    expires_at: datetime | None
+    """Expiry datetime of credential. The datetime should have time zone set.
+
+    If None, the credential will never expire.
+    """
+
+
+class S3CredentialProvider(Protocol):
+    """A type hint for a synchronous or asynchronous callback to provide custom S3 credentials.
+
+    This should be passed into the ``credential_provider`` parameter of ``S3Store``.
+
+    **Examples:**
+
+    Return static credentials that don't expire:
+
+    .. code-block:: python
+
+        def get_credentials() -> S3Credential:
+            return {
+                "access_key_id": "...",
+                "secret_access_key": "...",
+                "token": None,
+                "expires_at": None,
+            }
+
+    Return static credentials that are valid for 5 minutes:
+
+    .. code-block:: python
+
+        from datetime import datetime, timedelta, UTC
+
+        async def get_credentials() -> S3Credential:
+            return {
+                "access_key_id": "...",
+                "secret_access_key": "...",
+                "token": None,
+                "expires_at": datetime.now(UTC) + timedelta(minutes=5),
+            }
+
+    A class-based credential provider with state:
+
+    .. code-block:: python
+
+        from __future__ import annotations
+
+        from typing import TYPE_CHECKING
+
+        import boto3
+        import botocore.credentials
+
+        if TYPE_CHECKING:
+            from vortex.store import S3Credential
+
+
+        class Boto3CredentialProvider:
+            credentials: botocore.credentials.Credentials
+
+            def __init__(self, session: boto3.session.Session) -> None:
+                credentials = session.get_credentials()
+                if credentials is None:
+                    raise ValueError("Received None from session.get_credentials")
+
+                self.credentials = credentials
+
+            def __call__(self) -> S3Credential:
+                frozen_credentials = self.credentials.get_frozen_credentials()
+                return {
+                    "access_key_id": frozen_credentials.access_key,
+                    "secret_access_key": frozen_credentials.secret_key,
+                    "token": frozen_credentials.token,
+                    "expires_at": None,
+                }
+
+    """
+
+    def __call__(self) -> S3Credential | Coroutine[Any, Any, S3Credential]:  # pyright: ignore[reportExplicitAny]
+        """Return an ``S3Credential``."""
+        ...
+
+
+class S3Store(_store.S3Store):
+    """Interface to an Amazon S3 bucket.
+
+    All constructors will check for environment variables. Refer to
+    :class:`~vortex.store.S3Config` for valid environment variables.
+
+    **Examples**:
+
+    **Using requester-pays buckets**:
+
+    Pass ``request_payer=True`` as a keyword argument or have ``AWS_REQUESTER_PAYS=True``
+    set in the environment.
+
+    **Anonymous requests**:
+
+    Pass ``skip_signature=True`` as a keyword argument or have ``AWS_SKIP_SIGNATURE=True``
+    set in the environment.
+    """
+
+    @override
+    def __new__(
+        cls,
+        bucket: str | None = None,
+        *,
+        prefix: str | None = None,
+        config: S3Config | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: S3CredentialProvider | None = None,
+        **kwargs: Unpack[S3Config],  # pyright: ignore[reportGeneralTypeIssues]
+    ) -> Self:
+        """Create a new S3Store.
+
+        Args:
+            bucket: The AWS bucket to use.
+
+        Keyword Args:
+            prefix: A prefix within the bucket to use for all operations.
+            config: AWS configuration. Values in this config will override values inferred from the
+                environment. Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom S3 credentials.
+            kwargs: AWS configuration values. Supports the same values as ``config``, but as named keyword
+                args.
+
+        Returns:
+            S3Store
+
+        """
+        return super().__new__(  # pyright: ignore[reportUnknownVariableType]
+            cls,
+            bucket,
+            prefix=prefix,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,  # pyright: ignore[reportCallIssue]  bucket appears in both S3Config and explicitly above
+        )
+
+    @override
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        *,
+        config: S3Config | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: S3CredentialProvider | None = None,
+        **kwargs: Unpack[S3Config],
+    ) -> Self:
+        """Parse available connection info from a well-known storage URL.
+
+        Any path on the URL will be assigned as the ``prefix`` for the store. So if you
+        pass ``s3://bucket/path/to/directory``, the store will be created with a prefix of
+        ``path/to/directory``, and all further operations will use paths relative to that
+        prefix.
+
+        The supported url schemes are:
+
+        - ``s3://<bucket>/<path>``
+        - ``s3a://<bucket>/<path>``
+        - ``https://s3.<region>.amazonaws.com/<bucket>``
+        - ``https://<bucket>.s3.<region>.amazonaws.com``
+        - ``https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket``
+
+        Args:
+            url: well-known storage URL.
+
+        Keyword Args:
+            config: AWS Configuration. Values in this config will override values inferred from the url.
+                Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom S3 credentials.
+            kwargs: AWS configuration values. Supports the same values as ``config``, but as named keyword
+                args.
+
+
+        Returns:
+            S3Store
+
+        """
+        return super(cls).from_url(
+            url,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,
+        )
+
+    @override
+    def __eq__(self, value: object) -> bool:
+        return super().__eq__(value)
+
+    @override
+    def __getnewargs_ex__(self):  # pyright: ignore[reportUnknownParameterType]
+        return super().__getnewargs_ex__()  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    @property
+    @override
+    def prefix(self) -> str | None:
+        """Get the prefix applied to all operations in this store, if any."""
+        return super().prefix
+
+    @property
+    @override
+    def config(self) -> S3Config:
+        """Get the underlying S3 config parameters."""
+        return super().config
+
+    @property
+    @override
+    def client_options(self) -> ClientConfig | None:
+        """Get the store's client configuration."""
+        return super().client_options
+
+    @property
+    @override
+    def credential_provider(self) -> S3CredentialProvider | None:
+        """Get the store's credential provider."""
+        return super().credential_provider
+
+    @property
+    @override
+    def retry_config(self) -> RetryConfig | None:
+        """Get the store's retry configuration."""
+        return super().retry_config
diff --git a/vortex-python/python/vortex/store/_azure.py b/vortex-python/python/vortex/store/_azure.py
new file mode 100644
index 00000000000..1b3ec1b4e52
--- /dev/null
+++ b/vortex-python/python/vortex/store/_azure.py
@@ -0,0 +1,407 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from collections.abc import Coroutine
+from datetime import datetime
+from typing import Any, Protocol, Self, TypeAlias, TypedDict, Unpack
+
+from typing_extensions import override
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+from ._client import ClientConfig
+from ._retry import RetryConfig
+
+
+class AzureConfig(TypedDict, total=False):
+    """Configuration parameters for AzureStore."""
+
+    account_name: str
+    """The name of the azure storage account. (Required.)
+
+    **Environment variable**: ``AZURE_STORAGE_ACCOUNT_NAME``.
+    """
+    account_key: str
+    """Master key for accessing storage account.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_ACCOUNT_KEY``
+    - ``AZURE_STORAGE_ACCESS_KEY``
+    - ``AZURE_STORAGE_MASTER_KEY``
+    """
+    client_id: str
+    """The client id for use in client secret or k8s federated credential flow.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_CLIENT_ID``
+    - ``AZURE_CLIENT_ID``
+    """
+    client_secret: str
+    """The client secret for use in client secret flow.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_CLIENT_SECRET``
+    - ``AZURE_CLIENT_SECRET``
+    """
+    tenant_id: str
+    """The tenant id for use in client secret or k8s federated credential flow.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_TENANT_ID``
+    - ``AZURE_STORAGE_AUTHORITY_ID``
+    - ``AZURE_TENANT_ID``
+    - ``AZURE_AUTHORITY_ID``
+    """
+    authority_host: str
+    """Sets an alternative authority host for OAuth based authorization.
+
+    Defaults to ``https://login.microsoftonline.com``.
+
+    Common hosts for azure clouds are:
+
+    - Azure China: ``"https://login.chinacloudapi.cn"``
+    - Azure Germany: ``"https://login.microsoftonline.de"``
+    - Azure Government: ``"https://login.microsoftonline.us"``
+    - Azure Public: ``"https://login.microsoftonline.com"``
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_AUTHORITY_HOST``
+    - ``AZURE_AUTHORITY_HOST``
+    """
+    sas_key: str
+    """
+    Shared access signature.
+
+    The signature is expected to be percent-encoded, much like they are provided in
+    the azure storage explorer or azure portal.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_SAS_KEY``
+    - ``AZURE_STORAGE_SAS_TOKEN``
+    """
+    token: str
+    """A static bearer token to be used for authorizing requests.
+
+    **Environment variable**: ``AZURE_STORAGE_TOKEN``.
+    """
+    use_emulator: bool
+    """Set if the Azure emulator should be used (defaults to ``False``).
+
+    **Environment variable**: ``AZURE_STORAGE_USE_EMULATOR``.
+    """
+    use_fabric_endpoint: bool
+    """Set if Microsoft Fabric url scheme should be used (defaults to ``False``).
+
+    When disabled the url scheme used is ``https://{account}.blob.core.windows.net``.
+    When enabled the url scheme used is ``https://{account}.dfs.fabric.microsoft.com``.
+
+    .. note::
+
+        ``endpoint`` will take precedence over this option.
+    """
+    endpoint: str
+    """Override the endpoint used to communicate with blob storage.
+
+    Defaults to ``https://{account}.blob.core.windows.net``.
+
+    By default, only HTTPS schemes are enabled. To connect to an HTTP endpoint, enable
+    ``allow_http`` in the client options.
+
+    **Environment variables**:
+
+    - ``AZURE_STORAGE_ENDPOINT``
+    - ``AZURE_ENDPOINT``
+    """
+    msi_endpoint: str
+    """Endpoint to request a imds managed identity token.
+
+    **Environment variables**:
+
+    - ``AZURE_MSI_ENDPOINT``
+    - ``AZURE_IDENTITY_ENDPOINT``
+    """
+    object_id: str
+    """Object id for use with managed identity authentication.
+
+    **Environment variable**: ``AZURE_OBJECT_ID``.
+    """
+    msi_resource_id: str
+    """Msi resource id for use with managed identity authentication.
+
+    **Environment variable**: ``AZURE_MSI_RESOURCE_ID``.
+    """
+    federated_token_file: str
+    """Sets a file path for acquiring azure federated identity token in k8s.
+
+    Requires ``client_id`` and ``tenant_id`` to be set.
+
+    **Environment variable**: ``AZURE_FEDERATED_TOKEN_FILE``.
+    """
+    use_azure_cli: bool
+    """Set if the Azure Cli should be used for acquiring access token.
+
+    <https://learn.microsoft.com/en-us/cli/azure/account?view=azure-cli-latest#az-account-get-access-token>.
+
+    **Environment variable**: ``AZURE_USE_AZURE_CLI``.
+    """
+    skip_signature: bool
+    """If enabled, ``AzureStore`` will not fetch credentials and will not sign requests.
+
+    This can be useful when interacting with public containers.
+
+    **Environment variable**: ``AZURE_SKIP_SIGNATURE``.
+    """
+    container_name: str
+    """Container name.
+
+    **Environment variable**: ``AZURE_CONTAINER_NAME``.
+    """
+    disable_tagging: bool
+    """If set to ``True`` will ignore any tags provided to uploads.
+
+    **Environment variable**: ``AZURE_DISABLE_TAGGING``.
+    """
+    fabric_token_service_url: str
+    """Service URL for Fabric OAuth2 authentication.
+
+    **Environment variable**: ``AZURE_FABRIC_TOKEN_SERVICE_URL``.
+    """
+    fabric_workload_host: str
+    """Workload host for Fabric OAuth2 authentication.
+
+    **Environment variable**: ``AZURE_FABRIC_WORKLOAD_HOST``.
+    """
+    fabric_session_token: str
+    """Session token for Fabric OAuth2 authentication.
+
+    **Environment variable**: ``AZURE_FABRIC_SESSION_TOKEN``.
+    """
+    fabric_cluster_identifier: str
+    """Cluster identifier for Fabric OAuth2 authentication.
+
+    **Environment variable**: ``AZURE_FABRIC_CLUSTER_IDENTIFIER``.
+    """
+
+
+class AzureAccessKey(TypedDict):
+    """A shared Azure Storage Account Key.
+
+    See `Authorize with Shared Key <https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key>`_.
+
+    """
+
+    access_key: str
+    """Access key value."""
+
+    expires_at: datetime | None
+    """Expiry datetime of credential. The datetime should have time zone set.
+
+    If None, the credential will never expire.
+    """
+
+
+class AzureSASToken(TypedDict):
+    """A shared access signature.
+
+    See `Shared Access Signatures <https://learn.microsoft.com/en-us/rest/api/storageservices/delegate-access-with-shared-access-signature>`_.
+
+    """
+
+    sas_token: str | list[tuple[str, str]]
+    """SAS token."""
+
+    expires_at: datetime | None
+    """Expiry datetime of credential. The datetime should have time zone set.
+
+    If None, the credential will never expire.
+    """
+
+
+class AzureBearerToken(TypedDict):
+    """An authorization token.
+
+    See `Authorize with Azure AD <https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-azure-active-directory>`_.
+
+    """
+
+    token: str
+    """Bearer token."""
+
+    expires_at: datetime | None
+    """Expiry datetime of credential. The datetime should have time zone set.
+
+    If None, the credential will never expire.
+    """
+
+
+AzureCredential: TypeAlias = AzureAccessKey | AzureSASToken | AzureBearerToken
+"""A type alias for supported azure credentials to be returned from ``AzureCredentialProvider``.
+
+"""
+
+
+class AzureCredentialProvider(Protocol):
+    """A type hint for a synchronous or asynchronous callback to provide custom Azure credentials.
+
+    This should be passed into the ``credential_provider`` parameter of ``AzureStore``.
+
+    """
+
+    def __call__(self) -> AzureCredential | Coroutine[Any, Any, AzureCredential]:  # pyright: ignore[reportExplicitAny]
+        """Return an ``AzureCredential``."""
+        ...
+
+
+class AzureStore(_store.AzureStore):
+    """Interface to a Microsoft Azure Blob Storage container.
+
+    All constructors will check for environment variables. Refer to
+    :class:`~vortex.store.AzureConfig` for valid environment variables.
+    """
+
+    def __new__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "container_name"
+        cls,
+        container_name: str | None = None,
+        *,
+        prefix: str | None = None,
+        config: AzureConfig | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: AzureCredentialProvider | None = None,
+        **kwargs: Unpack[AzureConfig],  # pyright: ignore[reportGeneralTypeIssues]
+    ) -> Self:
+        """Construct a new AzureStore.
+
+        Args:
+            container_name: the name of the container.
+
+        Keyword Args:
+            prefix: A prefix within the bucket to use for all operations.
+            config: Azure Configuration. Values in this config will override values inferred from
+                the url. Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom Azure credentials.
+            kwargs: Azure configuration values. Supports the same values as ``config``, but as named
+                keyword args.
+
+        Returns:
+            AzureStore
+
+        """
+        return super().__new__(  # pyright: ignore[reportUnknownVariableType]
+            cls,
+            container_name,
+            prefix=prefix,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,  # pyright: ignore[reportCallIssue]
+        )
+
+    @override
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        *,
+        prefix: str | None = None,
+        config: AzureConfig | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: AzureCredentialProvider | None = None,
+        **kwargs: Unpack[AzureConfig],
+    ) -> Self:
+        """Construct a new AzureStore with values populated from a well-known storage URL.
+
+        Any path on the URL will be assigned as the ``prefix`` for the store. So if you
+        pass ``https://<account>.blob.core.windows.net/<container>/path/to/directory``,
+        the store will be created with a prefix of ``path/to/directory``, and all further
+        operations will use paths relative to that prefix.
+
+        The supported url schemes are:
+
+        - ``abfs[s]://<container>/<path>`` (according to `fsspec <https://github.com/fsspec/adlfs>`_)
+        - ``abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>``
+        - ``abfs[s]://<file_system>@<account_name>.dfs.fabric.microsoft.com/<path>``
+        - ``az://<container>/<path>`` (according to `fsspec <https://github.com/fsspec/adlfs>`_)
+        - ``adl://<container>/<path>`` (according to `fsspec <https://github.com/fsspec/adlfs>`_)
+        - ``azure://<container>/<path>`` (custom)
+        - ``https://<account>.dfs.core.windows.net``
+        - ``https://<account>.blob.core.windows.net``
+        - ``https://<account>.blob.core.windows.net/<container>``
+        - ``https://<account>.dfs.fabric.microsoft.com``
+        - ``https://<account>.dfs.fabric.microsoft.com/<container>``
+        - ``https://<account>.blob.fabric.microsoft.com``
+        - ``https://<account>.blob.fabric.microsoft.com/<container>``
+
+        Args:
+            url: well-known storage URL.
+
+        Keyword Args:
+            prefix: A prefix within the bucket to use for all operations.
+            config: Azure Configuration. Values in this config will override values inferred from the
+                url. Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom Azure credentials.
+            kwargs: Azure configuration values. Supports the same values as ``config``, but as named keyword
+                args.
+
+        Returns:
+            AzureStore
+
+        """
+        return super().from_url(
+            url,
+            prefix=prefix,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,
+        )
+
+    @override
+    def __eq__(self, value: object) -> bool:
+        return super().__eq__(value)
+
+    @override
+    def __getnewargs_ex__(self):  # pyright: ignore[reportUnknownParameterType]
+        return super().__getnewargs_ex__()  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    @property
+    @override
+    def prefix(self) -> str | None:
+        """Get the prefix applied to all operations in this store, if any."""
+        return super().prefix
+
+    @property
+    @override
+    def config(self) -> AzureConfig:
+        """Get the underlying Azure config parameters."""
+        return super().config
+
+    @property
+    @override
+    def client_options(self) -> ClientConfig | None:
+        """Get the store's client configuration."""
+        return super().client_options
+
+    @property
+    @override
+    def credential_provider(self) -> AzureCredentialProvider | None:
+        """Get the store's credential provider."""
+        return super().credential_provider
+
+    @property
+    @override
+    def retry_config(self) -> RetryConfig | None:
+        """Get the store's retry configuration."""
+        return super().retry_config
diff --git a/vortex-python/python/vortex/store/_client.py b/vortex-python/python/vortex/store/_client.py
new file mode 100644
index 00000000000..9efe2055c40
--- /dev/null
+++ b/vortex-python/python/vortex/store/_client.py
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from datetime import timedelta
+from typing import TypedDict
+
+
+class ClientConfig(TypedDict, total=False):
+    """HTTP client configuration.
+
+    For timeout values (``connect_timeout``, ``http2_keep_alive_timeout``,
+    ``pool_idle_timeout``, and ``timeout``), values can either be Python ``timedelta``
+    objects, or they can be "human-readable duration strings".
+
+    The human-readable duration string is a concatenation of time spans. Where each time
+    span is an integer number and a suffix. Supported suffixes:
+
+    - ``nsec``, ``ns`` -- nanoseconds
+    - ``usec``, ``us`` -- microseconds
+    - ``msec``, ``ms`` -- milliseconds
+    - ``seconds``, ``second``, ``sec``, ``s``
+    - ``minutes``, ``minute``, ``min``, ``m``
+    - ``hours``, ``hour``, ``hr``, ``h``
+    - ``days``, ``day``, ``d``
+    - ``weeks``, ``week``, ``w``
+    - ``months``, ``month``, ``M`` -- defined as 30.44 days
+    - ``years``, ``year``, ``y`` -- defined as 365.25 days
+
+    For example:
+
+    - ``"2h 37min"``
+    - ``"32ms"``
+
+    """
+
+    allow_http: bool
+    """Allow non-TLS, i.e. non-HTTPS connections."""
+    allow_invalid_certificates: bool
+    """Skip certificate validation on https connections.
+
+    .. warning::
+
+        You should think very carefully before using this method. If
+        invalid certificates are trusted, *any* certificate for *any* site
+        will be trusted for use. This includes expired certificates. This
+        introduces significant vulnerabilities, and should only be used
+        as a last resort or for testing.
+    """
+    connect_timeout: str | timedelta
+    """Timeout for only the connect phase of a Client"""
+    default_content_type: str
+    """Default ``CONTENT_TYPE`` for uploads"""
+    default_headers: dict[str, str] | dict[str, bytes]
+    """Default headers to be sent with each request"""
+    http1_only: bool
+    """Only use http1 connections."""
+    http2_keep_alive_interval: str
+    """Interval for HTTP2 Ping frames should be sent to keep a connection alive."""
+    http2_keep_alive_timeout: str | timedelta
+    """Timeout for receiving an acknowledgement of the keep-alive ping."""
+    http2_keep_alive_while_idle: str
+    """Enable HTTP2 keep alive pings for idle connections"""
+    http2_only: bool
+    """Only use http2 connections"""
+    pool_idle_timeout: str | timedelta
+    """The pool max idle timeout.
+
+    This is the length of time an idle connection will be kept alive.
+    """
+    pool_max_idle_per_host: str
+    """Maximum number of idle connections per host."""
+    proxy_url: str
+    """HTTP proxy to use for requests."""
+    timeout: str | timedelta
+    """Request timeout.
+
+    The timeout is applied from when the request starts connecting until the
+    response body has finished.
+    """
+    user_agent: str
+    """User-Agent header to be used by this client."""
diff --git a/vortex-python/python/vortex/store/_gcs.py b/vortex-python/python/vortex/store/_gcs.py
new file mode 100644
index 00000000000..e1512434093
--- /dev/null
+++ b/vortex-python/python/vortex/store/_gcs.py
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from collections.abc import Coroutine
+from datetime import datetime
+from typing import Any, Protocol, Self, TypedDict, Unpack
+
+from typing_extensions import override
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+from ._client import ClientConfig
+from ._retry import RetryConfig
+
+
+class GCSConfig(TypedDict, total=False):
+    """Configuration parameters for GCSStore."""
+
+    service_account: str
+    """Path to the service account file.
+
+    This or ``service_account_key`` must be set.
+
+    Example value ``"/tmp/gcs.json"``. Example contents of ``gcs.json``:
+
+    .. code-block:: json
+
+        {
+           "gcs_base_url": "https://localhost:4443",
+           "disable_oauth": true,
+           "client_email": "",
+           "private_key": ""
+        }
+
+    **Environment variables**:
+
+    - ``GOOGLE_SERVICE_ACCOUNT``
+    - ``GOOGLE_SERVICE_ACCOUNT_PATH``
+    """
+
+    service_account_key: str
+    """The serialized service account key.
+
+    The service account must be in the JSON format. This or ``with_service_account_path``
+    must be set.
+
+    **Environment variable**: ``GOOGLE_SERVICE_ACCOUNT_KEY``.
+    """
+
+    bucket: str
+    """Bucket name. (required)
+
+    **Environment variables**:
+
+    - ``GOOGLE_BUCKET``
+    - ``GOOGLE_BUCKET_NAME``
+    """
+
+    application_credentials: str
+    """Application credentials path.
+
+    See <https://cloud.google.com/docs/authentication/provide-credentials-adc>.
+
+    **Environment variable**: ``GOOGLE_APPLICATION_CREDENTIALS``.
+    """
+
+    skip_signature: bool
+    """If ``True``, GCSStore will not fetch credentials and will not sign requests.
+
+    This can be useful when interacting with public GCS buckets that deny authorized requests.
+
+    **Environment variable**: ``GOOGLE_SKIP_SIGNATURE``.
+    """
+
+
+class GCSCredential(TypedDict):
+    """A Google Cloud Storage Credential."""
+
+    token: str
+    """An HTTP bearer token."""
+
+    expires_at: datetime | None
+    """Expiry datetime of credential. The datetime should have time zone set.
+
+    If None, the credential will never expire.
+    """
+
+
+class GCSCredentialProvider(Protocol):
+    """A type hint for a synchronous or asynchronous callback to provide custom Google Cloud Storage credentials.
+
+    This should be passed into the ``credential_provider`` parameter of ``GCSStore``.
+
+    """
+
+    def __call__(self) -> GCSCredential | Coroutine[Any, Any, GCSCredential]:  # pyright: ignore[reportExplicitAny]
+        """Return a ``GCSCredential``."""
+        ...
+
+
+class GCSStore(_store.GCSStore):
+    """Interface to Google Cloud Storage.
+
+    All constructors will check for environment variables. Refer to
+    :class:`~vortex.store.GCSConfig` for valid environment variables.
+
+    If no credentials are explicitly provided, they will be sourced from the environment
+    as documented
+    `here <https://cloud.google.com/docs/authentication/application-default-credentials>`_.
+    """
+
+    def __new__(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
+        cls,
+        bucket: str | None = None,
+        *,
+        prefix: str | None = None,
+        config: GCSConfig | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: GCSCredentialProvider | None = None,
+        **kwargs: Unpack[GCSConfig],  # pyright: ignore[reportGeneralTypeIssues]
+    ) -> Self:
+        """Construct a new GCSStore.
+
+        Args:
+            bucket: The GCS bucket to use.
+
+        Keyword Args:
+            prefix: A prefix within the bucket to use for all operations.
+            config: GCS Configuration. Values in this config will override values inferred from the
+                environment. Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom Google credentials.
+            kwargs: GCS configuration values. Supports the same values as ``config``,
+                but as named keyword args.
+
+        Returns:
+            GCSStore
+
+        """
+        return super().__new__(  # pyright: ignore[reportUnknownVariableType]
+            cls,
+            bucket,
+            prefix=prefix,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,  # pyright: ignore[reportCallIssue]
+        )
+
+    @override
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        *,
+        prefix: str | None = None,
+        config: GCSConfig | None = None,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        credential_provider: GCSCredentialProvider | None = None,
+        **kwargs: Unpack[GCSConfig],
+    ) -> Self:
+        """Construct a new GCSStore with values populated from a well-known storage URL.
+
+        Any path on the URL will be assigned as the ``prefix`` for the store. So if you
+        pass ``gs://<bucket>/path/to/directory``, the store will be created with a prefix
+        of ``path/to/directory``, and all further operations will use paths relative to
+        that prefix.
+
+        The supported url schemes are:
+
+        - ``gs://<bucket>/<path>``
+
+        Args:
+            url: well-known storage URL.
+
+        Keyword Args:
+            prefix: A prefix within the bucket to use for all operations.
+            config: GCS Configuration. Values in this config will override values inferred from the
+                url. Defaults to None.
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+            credential_provider: A callback to provide custom Google credentials.
+            kwargs: GCS configuration values. Supports the same values as ``config``, but as named keyword
+                args.
+
+        Returns:
+            GCSStore
+
+        """
+        return super().from_url(  # type: ignore[misc] # Overlap between argument names and ** TypedDict items: "bucket"
+            url,
+            prefix=prefix,
+            config=config,
+            client_options=client_options,
+            retry_config=retry_config,
+            credential_provider=credential_provider,
+            **kwargs,
+        )
+
+    @override
+    def __eq__(self, value: object) -> bool:
+        return super().__eq__(value)
+
+    @override
+    def __getnewargs_ex__(self):  # pyright: ignore[reportUnknownParameterType]
+        return super().__getnewargs_ex__()  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    @property
+    @override
+    def prefix(self) -> str | None:
+        """Get the prefix applied to all operations in this store, if any."""
+        return super().prefix
+
+    @property
+    @override
+    def config(self) -> GCSConfig:
+        """Get the underlying GCS config parameters."""
+        return super().config
+
+    @property
+    @override
+    def client_options(self) -> ClientConfig | None:
+        """Get the store's client configuration."""
+        return super().client_options
+
+    @property
+    @override
+    def credential_provider(self) -> GCSCredentialProvider | None:
+        """Get the store's credential provider."""
+        return super().credential_provider
+
+    @property
+    @override
+    def retry_config(self) -> RetryConfig | None:
+        """Get the store's retry configuration."""
+        return super().retry_config
diff --git a/vortex-python/python/vortex/store/_http.py b/vortex-python/python/vortex/store/_http.py
new file mode 100644
index 00000000000..57d46bb5ebb
--- /dev/null
+++ b/vortex-python/python/vortex/store/_http.py
@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from typing import Self
+
+from typing_extensions import override
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+from ._client import ClientConfig
+from ._retry import RetryConfig
+
+
+class HTTPStore(_store.HTTPStore):
+    """Configure a connection to a generic HTTP server."""
+
+    def __new__(
+        cls,
+        url: str,
+        *,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+    ):
+        """Construct a new HTTPStore from a URL.
+
+        Any path on the URL will be assigned as the ``prefix`` for the store. So if you
+        pass ``https://example.com/path/to/directory``, the store will be created with a
+        prefix of ``path/to/directory``, and all further operations will use paths
+        relative to that prefix.
+
+        Args:
+            url: The base URL to use for the store.
+
+        Keyword Args:
+            client_options: HTTP Client options. Defaults to None.
+            retry_config: Retry configuration. Defaults to None.
+
+        Returns:
+            HTTPStore
+
+        """
+        return super().__new__(cls, url, client_options=client_options, retry_config=retry_config)
+
+    @override
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        *,
+        client_options: ClientConfig | None = None,
+        retry_config: RetryConfig | None = None,
+    ) -> Self:
+        """Construct a new HTTPStore from a URL.
+
+        This is an alias of the :class:`~vortex.store.HTTPStore` constructor.
+        """
+        return super(cls).from_url(url, client_options=client_options, retry_config=retry_config)
+
+    @override
+    def __eq__(self, value: object) -> bool:
+        return super().__eq__(value)
+
+    @override
+    def __getnewargs_ex__(self):  # pyright: ignore[reportUnknownParameterType]
+        return super().__getnewargs_ex__()  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    @property
+    @override
+    def url(self) -> str:
+        """Get the base url of this store."""
+        return super().url
+
+    @property
+    @override
+    def client_options(self) -> ClientConfig | None:
+        """Get the store's client configuration."""
+        return super().client_options
+
+    @property
+    @override
+    def retry_config(self) -> RetryConfig | None:
+        """Get the store's retry configuration."""
+        return super().retry_config
diff --git a/vortex-python/python/vortex/store/_local.py b/vortex-python/python/vortex/store/_local.py
new file mode 100644
index 00000000000..891c8e968b4
--- /dev/null
+++ b/vortex-python/python/vortex/store/_local.py
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from pathlib import Path
+from typing import Self
+
+from typing_extensions import override
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+
+
+class LocalStore(_store.LocalStore):
+    """An ObjectStore interface to local filesystem storage.
+
+    Create a local store with an optional directory prefix::
+
+        from pathlib import Path
+
+        store = LocalStore()
+        store = LocalStore(prefix="/path/to/directory")
+        store = LocalStore(prefix=Path("."))
+    """
+
+    def __new__(
+        cls,
+        prefix: str | Path | None = None,
+        *,
+        automatic_cleanup: bool = False,
+        mkdir: bool = False,
+    ) -> Self:
+        """Create a new LocalStore.
+
+        Args:
+            prefix: Use the specified prefix applied to all paths. Defaults to ``None``.
+
+        Keyword Args:
+            automatic_cleanup: if ``True``, enables automatic cleanup of empty directories
+                when deleting files. Defaults to False.
+            mkdir: if ``True`` and ``prefix`` is not ``None``, the directory at ``prefix`` will
+                attempt to be created. Note that this root directory will not be cleaned
+                up, even if ``automatic_cleanup`` is ``True``.
+
+        """
+        return super().__new__(cls, prefix, automatic_cleanup=automatic_cleanup, mkdir=mkdir)
+
+    @classmethod
+    @override
+    def from_url(
+        cls,
+        url: str,
+        *,
+        automatic_cleanup: bool = False,
+        mkdir: bool = False,
+    ) -> Self:
+        """Construct a new LocalStore from a ``file://`` URL.
+
+        **Examples:**
+
+        Construct a new store pointing to the root of your filesystem::
+
+            url = "file:///"
+            store = LocalStore.from_url(url)
+
+        Construct a new store with a directory prefix::
+
+            url = "file:///Users/kyle/"
+            store = LocalStore.from_url(url)
+
+        """
+        return super(cls).from_url(url, automatic_cleanup=automatic_cleanup, mkdir=mkdir)
+
+    @override
+    def __eq__(self, value: object, /) -> bool:
+        return super().__eq__(value)
+
+    @override
+    def __getnewargs_ex__(self) -> tuple[tuple[()], dict[str, object]]:
+        return super().__getnewargs_ex__()
+
+    @property
+    @override
+    def prefix(self) -> Path | None:
+        """Get the prefix applied to all operations in this store, if any."""
+        return super().prefix
diff --git a/vortex-python/python/vortex/store/_memory.py b/vortex-python/python/vortex/store/_memory.py
new file mode 100644
index 00000000000..763424732eb
--- /dev/null
+++ b/vortex-python/python/vortex/store/_memory.py
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from .._lib import store as _store  # pyright: ignore[reportMissingModuleSource]
+
+
+class MemoryStore(_store.MemoryStore):
+    """A fully in-memory implementation of ObjectStore.
+
+    Create a new in-memory store::
+
+        store = MemoryStore()
+    """
+
+    def __new__(cls):
+        return super().__new__(cls)
diff --git a/vortex-python/python/vortex/store/_retry.py b/vortex-python/python/vortex/store/_retry.py
new file mode 100644
index 00000000000..41eb18d56f7
--- /dev/null
+++ b/vortex-python/python/vortex/store/_retry.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2024 Development Seed
+
+from datetime import timedelta
+from typing import TypedDict
+
+
+class BackoffConfig(TypedDict, total=False):
+    """Exponential backoff with jitter.
+
+    See `Exponential Backoff and Jitter <https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/>`_.
+
+    """
+
+    init_backoff: timedelta
+    """The initial backoff duration.
+
+    Defaults to 100 milliseconds.
+    """
+
+    max_backoff: timedelta
+    """The maximum backoff duration.
+
+    Defaults to 15 seconds.
+    """
+
+    base: int | float
+    """The base of the exponential to use.
+
+    Defaults to ``2``.
+    """
+
+
+class RetryConfig(TypedDict, total=False):
+    """The configuration for how to respond to request errors.
+
+    The following categories of error will be retried:
+
+    * 5xx server errors
+    * Connection errors
+    * Dropped connections
+    * Timeouts for `safe <https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.1>`_ / read-only requests
+
+    Requests will be retried up to some limit, using exponential
+    backoff with jitter. See :class:`~vortex.store.BackoffConfig` for
+    more information.
+    """
+
+    backoff: BackoffConfig
+    """The backoff configuration.
+
+    Defaults to the values listed above if not provided.
+    """
+
+    max_retries: int
+    """
+    The maximum number of times to retry a request
+
+    Set to 0 to disable retries.
+
+    Defaults to 10.
+    """
+
+    retry_timeout: timedelta
+    """
+    The maximum length of time from the initial request
+    after which no further retries will be attempted
+
+    This not only bounds the length of time before a server
+    error will be surfaced to the application, but also bounds
+    the length of time a request's credentials must remain valid.
+
+    As requests are retried without renewing credentials or
+    regenerating request payloads, this number should be kept
+    below 5 minutes to avoid errors due to expired credentials
+    and/or request payloads.
+
+    Defaults to 3 minutes.
+    """
diff --git a/vortex-python/python/vortex/substrait.py b/vortex-python/python/vortex/substrait.py
index 2a099c99d4b..28a144f62ef 100644
--- a/vortex-python/python/vortex/substrait.py
+++ b/vortex-python/python/vortex/substrait.py
@@ -14,26 +14,39 @@
         SimpleExtensionDeclaration,
         SimpleExtensionURI,  # pyright: ignore[reportDeprecated]
     )
-    from substrait.type_pb2 import NamedStruct
+    from substrait.type_pb2 import NamedStruct, Type
 else:
     try:
         # substrait >= 0.27
         from substrait.algebra_pb2 import Expression, FunctionArgument
         from substrait.extended_expression_pb2 import ExpressionReference, ExtendedExpression
         from substrait.extensions.extensions_pb2 import SimpleExtensionDeclaration, SimpleExtensionURI
-        from substrait.type_pb2 import NamedStruct
+        from substrait.type_pb2 import NamedStruct, Type
     except ImportError:
         # substrait < 0.27
         from substrait.gen.proto.algebra_pb2 import Expression, FunctionArgument
         from substrait.gen.proto.extended_expression_pb2 import ExpressionReference, ExtendedExpression
         from substrait.gen.proto.extensions.extensions_pb2 import SimpleExtensionDeclaration, SimpleExtensionURI
-        from substrait.gen.proto.type_pb2 import NamedStruct
+        from substrait.gen.proto.type_pb2 import NamedStruct, Type
 
 from ._lib import dtype as _dtype  # pyright: ignore[reportMissingModuleSource]
 from ._lib import expr as _expr  # pyright: ignore[reportMissingModuleSource]
 
+ExtensionTypes = dict[int, str]
+TypeVariations = dict[int, str]
+IntWidth = Literal[8, 16, 32, 64]
+
 
 def literal(substrait_object: Expression.Literal) -> _expr.Expr:
+    return _literal(substrait_object, extension_types={}, type_variations={})
+
+
+def _literal(
+    substrait_object: Expression.Literal,
+    *,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
+) -> _expr.Expr:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/algebra.proto#L890
     match substrait_object.WhichOneof("literal_type"):
         case "boolean":
@@ -78,6 +91,16 @@ def literal(substrait_object: Expression.Literal) -> _expr.Expr:
         case "precision_time":
             unit = _precision_to_unit("precision_time", substrait_object.precision_time.precision)
             return _expr.literal(_dtype.time(unit=unit, nullable=False), substrait_object.precision_time.value)
+        case "null":
+            return _expr.literal(
+                _type_to_dtype(
+                    substrait_object.null,
+                    force_nullable=True,
+                    extension_types=extension_types,
+                    type_variations=type_variations,
+                ),
+                None,
+            )
         case "interval_year_to_month":
             raise NotImplementedError
         case "interval_day_to_second":
@@ -100,9 +123,6 @@ def literal(substrait_object: Expression.Literal) -> _expr.Expr:
             raise NotImplementedError
         case "uuid":
             raise NotImplementedError
-        case "null":
-            # substrait_object.null is a Type which needs to be converted
-            raise NotImplementedError
         case "list":
             raise NotImplementedError
         case "empty_list":
@@ -117,6 +137,231 @@ def literal(substrait_object: Expression.Literal) -> _expr.Expr:
             raise ValueError(f"unknown literal_type {literal_type}")
 
 
+def _type_to_dtype(
+    substrait_type: Type,
+    *,
+    force_nullable: bool = False,
+    extension_types: ExtensionTypes | None = None,
+    type_variations: TypeVariations | None = None,
+) -> _dtype.DType:
+    extension_types = extension_types or {}
+    type_variations = type_variations or {}
+
+    match substrait_type.WhichOneof("kind"):
+        case "bool":
+            return _dtype.bool_(nullable=_nullability(substrait_type.bool.nullability, force_nullable=force_nullable))
+        case "i8":
+            return _integer_dtype(
+                8,
+                substrait_type.i8.type_variation_reference,
+                substrait_type.i8.nullability,
+                force_nullable=force_nullable,
+                type_variations=type_variations,
+            )
+        case "i16":
+            return _integer_dtype(
+                16,
+                substrait_type.i16.type_variation_reference,
+                substrait_type.i16.nullability,
+                force_nullable=force_nullable,
+                type_variations=type_variations,
+            )
+        case "i32":
+            return _integer_dtype(
+                32,
+                substrait_type.i32.type_variation_reference,
+                substrait_type.i32.nullability,
+                force_nullable=force_nullable,
+                type_variations=type_variations,
+            )
+        case "i64":
+            return _integer_dtype(
+                64,
+                substrait_type.i64.type_variation_reference,
+                substrait_type.i64.nullability,
+                force_nullable=force_nullable,
+                type_variations=type_variations,
+            )
+        case "fp32":
+            return _dtype.float_(
+                32,
+                nullable=_nullability(substrait_type.fp32.nullability, force_nullable=force_nullable),
+            )
+        case "fp64":
+            return _dtype.float_(
+                64,
+                nullable=_nullability(substrait_type.fp64.nullability, force_nullable=force_nullable),
+            )
+        case "string":
+            return _dtype.utf8(nullable=_nullability(substrait_type.string.nullability, force_nullable=force_nullable))
+        case "binary":
+            return _dtype.binary(
+                nullable=_nullability(substrait_type.binary.nullability, force_nullable=force_nullable)
+            )
+        case "decimal":
+            return _dtype.decimal(
+                precision=substrait_type.decimal.precision,
+                scale=substrait_type.decimal.scale,
+                nullable=_nullability(substrait_type.decimal.nullability, force_nullable=force_nullable),
+            )
+        case "date":
+            return _dtype.date(
+                unit="days",
+                nullable=_nullability(substrait_type.date.nullability, force_nullable=force_nullable),
+            )
+        case "time":
+            return _dtype.time(
+                unit="us",
+                nullable=_nullability(substrait_type.time.nullability, force_nullable=force_nullable),
+            )
+        case "precision_time":
+            return _dtype.time(
+                unit=_precision_to_unit("precision_time", substrait_type.precision_time.precision),
+                nullable=_nullability(
+                    substrait_type.precision_time.nullability,
+                    force_nullable=force_nullable,
+                ),
+            )
+        case "timestamp":
+            return _dtype.timestamp(
+                unit="us",
+                nullable=_nullability(substrait_type.timestamp.nullability, force_nullable=force_nullable),
+            )
+        case "precision_timestamp":
+            return _dtype.timestamp(
+                unit=_precision_to_unit("precision_timestamp", substrait_type.precision_timestamp.precision),
+                nullable=_nullability(
+                    substrait_type.precision_timestamp.nullability,
+                    force_nullable=force_nullable,
+                ),
+            )
+        case "timestamp_tz":
+            return _dtype.timestamp(
+                unit="us",
+                tz="UTC",
+                nullable=_nullability(
+                    substrait_type.timestamp_tz.nullability,
+                    force_nullable=force_nullable,
+                ),
+            )
+        case "precision_timestamp_tz":
+            return _dtype.timestamp(
+                unit=_precision_to_unit(
+                    "precision_timestamp_tz",
+                    substrait_type.precision_timestamp_tz.precision,
+                ),
+                tz="UTC",
+                nullable=_nullability(
+                    substrait_type.precision_timestamp_tz.nullability,
+                    force_nullable=force_nullable,
+                ),
+            )
+        case "list":
+            return _dtype.list_(
+                _type_to_dtype(
+                    substrait_type.list.type,
+                    extension_types=extension_types,
+                    type_variations=type_variations,
+                ),
+                nullable=_nullability(substrait_type.list.nullability, force_nullable=force_nullable),
+            )
+        case "user_defined":
+            return _user_defined_dtype(
+                substrait_type.user_defined.type_reference,
+                substrait_type.user_defined.type_variation_reference,
+                substrait_type.user_defined.nullability,
+                force_nullable=force_nullable,
+                extension_types=extension_types,
+                type_variations=type_variations,
+            )
+        case "struct":
+            raise NotImplementedError("Substrait null struct literals are not supported because field names are absent")
+        case "map":
+            raise NotImplementedError("Substrait map types are not supported")
+        case kind:
+            raise NotImplementedError(f"Substrait type {kind} is not supported")
+
+
+def _integer_dtype(
+    width: IntWidth,
+    type_variation_reference: int,
+    nullability: int,
+    *,
+    force_nullable: bool,
+    type_variations: TypeVariations,
+) -> _dtype.DType:
+    nullable = _nullability(nullability, force_nullable=force_nullable)
+    if _is_unsigned_integer_name(type_variations.get(type_variation_reference), width):
+        return _dtype.uint(width, nullable=nullable)
+    return _dtype.int_(width, nullable=nullable)
+
+
+def _user_defined_dtype(
+    type_reference: int,
+    type_variation_reference: int,
+    nullability: int,
+    *,
+    force_nullable: bool,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
+) -> _dtype.DType:
+    nullable = _nullability(nullability, force_nullable=force_nullable)
+
+    # PyArrow's `to_substrait()` currently encodes unsigned integers as Arrow-defined
+    # user-defined types named `u8`/`u16`/`u32`/`u64`, even though core Substrait does not
+    # define unsigned simple types:
+    # https://github.com/apache/arrow/blob/main/format/substrait/extension_types.yaml
+    extension_name = extension_types.get(type_reference)
+    match extension_name:
+        case "u8":
+            return _dtype.uint(8, nullable=nullable)
+        case "u16":
+            return _dtype.uint(16, nullable=nullable)
+        case "u32":
+            return _dtype.uint(32, nullable=nullable)
+        case "u64":
+            return _dtype.uint(64, nullable=nullable)
+        case _:
+            pass
+
+    variation_name = type_variations.get(type_variation_reference)
+    match variation_name:
+        case "u8":
+            return _dtype.uint(8, nullable=nullable)
+        case "u16":
+            return _dtype.uint(16, nullable=nullable)
+        case "u32":
+            return _dtype.uint(32, nullable=nullable)
+        case "u64":
+            return _dtype.uint(64, nullable=nullable)
+        case _:
+            pass
+
+    raise NotImplementedError(f"Substrait user-defined type {extension_name or type_reference} is not supported")
+
+
+def _is_unsigned_integer_name(name: str | None, width: IntWidth | None = None) -> bool:
+    if name is None:
+        return False
+
+    normalized = name.strip().lower().replace("-", "_").replace(" ", "_")
+    if width is not None and normalized in {f"u{width}", f"uint{width}", f"unsigned_{width}"}:
+        return True
+    return normalized.startswith("unsigned")
+
+
+def _nullability(nullability: int, *, force_nullable: bool = False) -> bool:
+    if force_nullable:
+        return True
+    match nullability:
+        case 1:
+            return True
+        case 2:
+            return False
+        case other:
+            raise ValueError(f"Unknown Substrait nullability {other}")
+
+
 def _precision_to_unit(type_: str, p: int) -> Literal["s", "ms", "us", "ns"]:
     match p:
         case 0:
@@ -170,16 +415,35 @@ def struct_field(substrait_object: Expression.ReferenceSegment.StructField) -> l
 
 
 def scalar_function(
-    substrait_object: Expression.ScalarFunction, functions: list[Callable[..., _expr.Expr]], schema: NamedStruct
+    substrait_object: Expression.ScalarFunction,
+    functions: list[Callable[..., _expr.Expr]],
+    schema: NamedStruct,
+    *,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
 ) -> _expr.Expr:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/extensions/extensions.proto#L57
     function = functions[substrait_object.function_reference]
-    arguments = [function_argument(argument, functions, schema) for argument in substrait_object.arguments]
+    arguments = [
+        function_argument(
+            argument,
+            functions,
+            schema,
+            extension_types=extension_types,
+            type_variations=type_variations,
+        )
+        for argument in substrait_object.arguments
+    ]
     return function(*arguments)
 
 
 def function_argument(
-    substrait_object: FunctionArgument, functions: list[Callable[..., _expr.Expr]], schema: NamedStruct
+    substrait_object: FunctionArgument,
+    functions: list[Callable[..., _expr.Expr]],
+    schema: NamedStruct,
+    *,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
 ) -> _expr.Expr:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/algebra.proto#L832
     match substrait_object.WhichOneof("arg_type"):
@@ -188,7 +452,13 @@ def function_argument(
         case "type":
             raise NotImplementedError
         case "value":
-            return expression(substrait_object.value, functions, schema)
+            return expression(
+                substrait_object.value,
+                functions,
+                schema,
+                extension_types=extension_types,
+                type_variations=type_variations,
+            )
         case arg_type:
             raise ValueError(f"unknown arg_type {arg_type}")
 
@@ -255,16 +525,31 @@ def _is_not_null(e: _expr.Expr) -> _expr.Expr:
 
 
 def expression(
-    substrait_object: Expression, functions: list[Callable[..., _expr.Expr]], schema: NamedStruct
+    substrait_object: Expression,
+    functions: list[Callable[..., _expr.Expr]],
+    schema: NamedStruct,
+    *,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
 ) -> _expr.Expr:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/algebra.proto#L857
     match substrait_object.WhichOneof("rex_type"):
         case "literal":
-            return literal(substrait_object.literal)
+            return _literal(
+                substrait_object.literal,
+                extension_types=extension_types,
+                type_variations=type_variations,
+            )
         case "selection":
             return field_reference(substrait_object.selection, schema)
         case "scalar_function":
-            return scalar_function(substrait_object.scalar_function, functions, schema)
+            return scalar_function(
+                substrait_object.scalar_function,
+                functions,
+                schema,
+                extension_types=extension_types,
+                type_variations=type_variations,
+            )
         case "window_function":
             raise NotImplementedError
         case "if_then":
@@ -280,12 +565,23 @@ def expression(
 
 
 def expression_reference(
-    substrait_object: ExpressionReference, functions: list[Callable[..., _expr.Expr]], schema: NamedStruct
+    substrait_object: ExpressionReference,
+    functions: list[Callable[..., _expr.Expr]],
+    schema: NamedStruct,
+    *,
+    extension_types: ExtensionTypes,
+    type_variations: TypeVariations,
 ) -> _expr.Expr:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/extended__expression.proto#L16
     match substrait_object.WhichOneof("expr_type"):
         case "expression":
-            return expression(substrait_object.expression, functions, schema)
+            return expression(
+                substrait_object.expression,
+                functions,
+                schema,
+                extension_types=extension_types,
+                type_variations=type_variations,
+            )
         case _:
             raise ValueError("unknown expr_type: {}")
 
@@ -293,6 +589,8 @@ def expression_reference(
 def extended_expression(substrait_object: ExtendedExpression) -> list[_expr.Expr]:
     # https://github.com/substrait-io/substrait/blob/main/proto/substrait/extended__expression.proto#L27
     functions: list[Callable[..., _expr.Expr]] = []
+    extension_types: ExtensionTypes = {}
+    type_variations: TypeVariations = {}
 
     substrait_schema = substrait_object.base_schema
     extension_uris = substrait_object.extension_uris
@@ -302,9 +600,29 @@ def extended_expression(substrait_object: ExtendedExpression) -> list[_expr.Expr
     for extension in extensions:
         # https://github.com/substrait-io/substrait/blob/main/proto/substrait/extensions/extensions.proto#L25
         match extension.WhichOneof("mapping_type"):
+            case "extension_type":
+                extension_types[extension.extension_type.type_anchor] = extension.extension_type.name
+                # Arrow can declare extension-backed types like `null` in the schema even when the
+                # expression only references functions. Those declarations do not participate in
+                # function_reference indexing.
+                continue
+            case "extension_type_variation":
+                type_variations[extension.extension_type_variation.type_variation_anchor] = (
+                    extension.extension_type_variation.name
+                )
+                continue
             case "extension_function":
                 functions.append(extension_function(extension.extension_function, extension_uris))
             case mapping_type:
                 raise ValueError(f"unsupported extension mapping_type {mapping_type}")
 
-    return [expression_reference(expression, functions, substrait_schema) for expression in expressions]
+    return [
+        expression_reference(
+            expression,
+            functions,
+            substrait_schema,
+            extension_types=extension_types,
+            type_variations=type_variations,
+        )
+        for expression in expressions
+    ]
diff --git a/vortex-python/run_benchmarks.sh b/vortex-python/run_benchmarks.sh
new file mode 100755
index 00000000000..0d2929f7f2d
--- /dev/null
+++ b/vortex-python/run_benchmarks.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+# Run Python benchmarks with a release-profile build of the native extension.
+#
+# Usage:
+#   ./run_benchmarks.sh                     # run all benchmarks
+#   ./run_benchmarks.sh -k "test_scan"      # run benchmarks matching a pattern
+#   ./run_benchmarks.sh --benchmark-only    # skip non-benchmark tests (if any)
+#
+# All arguments are forwarded to pytest.
+
+set -ex -o pipefail
+
+ROOT=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )/.." &> /dev/null && pwd )
+PYTHON_DIR="$ROOT/vortex-python"
+
+# Ensure all packages are synced (includes pytest-benchmark dev dependency).
+uv sync --all-packages
+
+source "$ROOT/.venv/bin/activate"
+
+# Build the native extension in release mode so benchmarks reflect production performance.
+maturin develop --release --manifest-path "$PYTHON_DIR/Cargo.toml"
+
+# Run benchmarks. Extra args are forwarded to pytest.
+pytest "$PYTHON_DIR/benchmark" "$@"
diff --git a/vortex-python/src/arrays/builtins/chunked.rs b/vortex-python/src/arrays/builtins/chunked.rs
index 2323ced4d44..5ca1aafd67f 100644
--- a/vortex-python/src/arrays/builtins/chunked.rs
+++ b/vortex-python/src/arrays/builtins/chunked.rs
@@ -4,10 +4,10 @@
 use pyo3::PyRef;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::arrays::ChunkedVTable;
+use vortex::array::arrays::Chunked;
+use vortex::array::arrays::chunked::ChunkedArrayExt;
 
 use crate::arrays::PyArrayRef;
-use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
 use crate::arrays::native::PyNativeArray;
 
@@ -16,16 +16,17 @@ use crate::arrays::native::PyNativeArray;
 pub(crate) struct PyChunkedArray;
 
 impl EncodingSubclass for PyChunkedArray {
-    type VTable = ChunkedVTable;
+    type VTable = Chunked;
 }
 
 #[pymethods]
 impl PyChunkedArray {
     pub fn chunks(self_: PyRef<'_, Self>) -> Vec<PyArrayRef> {
         self_
-            .as_array_ref()
-            .chunks()
-            .iter()
+            .as_super()
+            .inner()
+            .as_::<Chunked>()
+            .iter_chunks()
             .map(|chunk| PyArrayRef::from(chunk.clone()))
             .collect()
     }
diff --git a/vortex-python/src/arrays/builtins/constant.rs b/vortex-python/src/arrays/builtins/constant.rs
index 51105a39147..510bc7376be 100644
--- a/vortex-python/src/arrays/builtins/constant.rs
+++ b/vortex-python/src/arrays/builtins/constant.rs
@@ -6,7 +6,7 @@ use pyo3::PyRef;
 use pyo3::PyResult;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::arrays::ConstantVTable;
+use vortex::array::arrays::Constant;
 
 use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
@@ -18,7 +18,7 @@ use crate::scalar::PyScalar;
 pub(crate) struct PyConstantArray;
 
 impl EncodingSubclass for PyConstantArray {
-    type VTable = ConstantVTable;
+    type VTable = Constant;
 }
 
 #[pymethods]
diff --git a/vortex-python/src/arrays/builtins/decimal.rs b/vortex-python/src/arrays/builtins/decimal.rs
index db33d44d02c..292af091c04 100644
--- a/vortex-python/src/arrays/builtins/decimal.rs
+++ b/vortex-python/src/arrays/builtins/decimal.rs
@@ -4,7 +4,7 @@
 use pyo3::PyRef;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::arrays::DecimalVTable;
+use vortex::array::arrays::Decimal;
 
 use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
@@ -15,7 +15,7 @@ use crate::arrays::native::PyNativeArray;
 pub(crate) struct PyDecimalArray;
 
 impl EncodingSubclass for PyDecimalArray {
-    type VTable = DecimalVTable;
+    type VTable = Decimal;
 }
 
 #[pymethods]
diff --git a/vortex-python/src/arrays/builtins/mod.rs b/vortex-python/src/arrays/builtins/mod.rs
index 5cbe09103d0..38f2e3886ac 100644
--- a/vortex-python/src/arrays/builtins/mod.rs
+++ b/vortex-python/src/arrays/builtins/mod.rs
@@ -13,14 +13,14 @@ pub(crate) use decimal::*;
 pub(crate) use primitive::*;
 use pyo3::prelude::*;
 pub(crate) use struct_::*;
-use vortex::array::arrays::BoolVTable;
-use vortex::array::arrays::ExtensionVTable;
-use vortex::array::arrays::FixedSizeListVTable;
-use vortex::array::arrays::ListVTable;
-use vortex::array::arrays::NullVTable;
-use vortex::array::arrays::VarBinVTable;
-use vortex::array::arrays::VarBinViewVTable;
-use vortex::encodings::bytebool::ByteBoolVTable;
+use vortex::array::arrays::Bool;
+use vortex::array::arrays::Extension;
+use vortex::array::arrays::FixedSizeList;
+use vortex::array::arrays::List;
+use vortex::array::arrays::Null;
+use vortex::array::arrays::VarBin;
+use vortex::array::arrays::VarBinView;
+use vortex::encodings::bytebool::ByteBool;
 
 use crate::arrays::native::EncodingSubclass;
 use crate::arrays::native::PyNativeArray;
@@ -30,7 +30,7 @@ use crate::arrays::native::PyNativeArray;
 pub(crate) struct PyNullArray;
 
 impl EncodingSubclass for PyNullArray {
-    type VTable = NullVTable;
+    type VTable = Null;
 }
 
 /// Concrete class for arrays with `vortex.bool` encoding.
@@ -38,7 +38,7 @@ impl EncodingSubclass for PyNullArray {
 pub(crate) struct PyBoolArray;
 
 impl EncodingSubclass for PyBoolArray {
-    type VTable = BoolVTable;
+    type VTable = Bool;
 }
 
 /// Concrete class for arrays with `vortex.bytebool` encoding.
@@ -46,7 +46,7 @@ impl EncodingSubclass for PyBoolArray {
 pub(crate) struct PyByteBoolArray;
 
 impl EncodingSubclass for PyByteBoolArray {
-    type VTable = ByteBoolVTable;
+    type VTable = ByteBool;
 }
 
 /// Concrete class for arrays with `vortex.varbin` encoding.
@@ -54,7 +54,7 @@ impl EncodingSubclass for PyByteBoolArray {
 pub(crate) struct PyVarBinArray;
 
 impl EncodingSubclass for PyVarBinArray {
-    type VTable = VarBinVTable;
+    type VTable = VarBin;
 }
 
 /// Concrete class for arrays with `vortex.varbinview` encoding.
@@ -62,7 +62,7 @@ impl EncodingSubclass for PyVarBinArray {
 pub(crate) struct PyVarBinViewArray;
 
 impl EncodingSubclass for PyVarBinViewArray {
-    type VTable = VarBinViewVTable;
+    type VTable = VarBinView;
 }
 
 /// Concrete class for arrays with `vortex.list` encoding.
@@ -70,7 +70,7 @@ impl EncodingSubclass for PyVarBinViewArray {
 pub(crate) struct PyListArray;
 
 impl EncodingSubclass for PyListArray {
-    type VTable = ListVTable;
+    type VTable = List;
 }
 
 /// Concrete class for arrays with `vortex.fixed_size_list` encoding.
@@ -78,7 +78,7 @@ impl EncodingSubclass for PyListArray {
 pub(crate) struct PyFixedSizeListArray;
 
 impl EncodingSubclass for PyFixedSizeListArray {
-    type VTable = FixedSizeListVTable;
+    type VTable = FixedSizeList;
 }
 
 /// Concrete class for arrays with `vortex.ext` encoding.
@@ -86,5 +86,5 @@ impl EncodingSubclass for PyFixedSizeListArray {
 pub(crate) struct PyExtensionArray;
 
 impl EncodingSubclass for PyExtensionArray {
-    type VTable = ExtensionVTable;
+    type VTable = Extension;
 }
diff --git a/vortex-python/src/arrays/builtins/primitive.rs b/vortex-python/src/arrays/builtins/primitive.rs
index 4dce9fddbc7..9fe90774c5d 100644
--- a/vortex-python/src/arrays/builtins/primitive.rs
+++ b/vortex-python/src/arrays/builtins/primitive.rs
@@ -4,7 +4,7 @@
 use pyo3::PyRef;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::arrays::PrimitiveVTable;
+use vortex::array::arrays::Primitive;
 
 use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
@@ -16,7 +16,7 @@ use crate::dtype::PyPType;
 pub(crate) struct PyPrimitiveArray;
 
 impl EncodingSubclass for PyPrimitiveArray {
-    type VTable = PrimitiveVTable;
+    type VTable = Primitive;
 }
 
 #[pymethods]
diff --git a/vortex-python/src/arrays/builtins/struct_.rs b/vortex-python/src/arrays/builtins/struct_.rs
index c32726e39be..b4453d91501 100644
--- a/vortex-python/src/arrays/builtins/struct_.rs
+++ b/vortex-python/src/arrays/builtins/struct_.rs
@@ -6,10 +6,11 @@ use pyo3::PyRef;
 use pyo3::PyResult;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::arrays::StructVTable;
+use vortex::array::arrays::Struct;
+use vortex::array::arrays::struct_::StructArrayExt;
+use vortex::error::VortexExpect;
 
 use crate::arrays::PyArrayRef;
-use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
 use crate::arrays::native::PyNativeArray;
 use crate::error::PyVortexResult;
@@ -19,21 +20,30 @@ use crate::error::PyVortexResult;
 pub(crate) struct PyStructArray;
 
 impl EncodingSubclass for PyStructArray {
-    type VTable = StructVTable;
+    type VTable = Struct;
 }
 
 #[pymethods]
 impl PyStructArray {
     /// Returns the given field of the struct array.
     pub fn field(self_: PyRef<'_, Self>, name: &str) -> PyVortexResult<PyArrayRef> {
-        let field = self_.as_array_ref().unmasked_field_by_name(name)?.clone();
+        let field = self_
+            .as_super()
+            .inner()
+            .as_opt::<Struct>()
+            .vortex_expect("Failed to downcast array")
+            .unmasked_field_by_name(name)?
+            .clone();
         Ok(PyArrayRef::from(field))
     }
 
     /// Get an ordered list of field names for the struct fields.
     pub fn names(self_: PyRef<'_, Self>) -> PyResult<Vec<String>> {
         Ok(self_
-            .as_array_ref()
+            .as_super()
+            .inner()
+            .as_opt::<Struct>()
+            .vortex_expect("Failed to downcast array")
             .struct_fields()
             .names()
             .iter()
diff --git a/vortex-python/src/arrays/compressed.rs b/vortex-python/src/arrays/compressed.rs
index 95b4035b8d3..96abfa4f1a1 100644
--- a/vortex-python/src/arrays/compressed.rs
+++ b/vortex-python/src/arrays/compressed.rs
@@ -4,15 +4,15 @@
 use pyo3::prelude::*;
 use vortex::array::IntoArray;
 use vortex::array::ToCanonical;
-use vortex::array::arrays::DictVTable;
-use vortex::encodings::alp::ALPRDVTable;
-use vortex::encodings::alp::ALPVTable;
-use vortex::encodings::datetime_parts::DateTimePartsVTable;
-use vortex::encodings::fsst::FSSTVTable;
-use vortex::encodings::runend::RunEndVTable;
-use vortex::encodings::sequence::SequenceVTable;
-use vortex::encodings::sparse::SparseVTable;
-use vortex::encodings::zigzag::ZigZagVTable;
+use vortex::array::arrays::Dict;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::ALPRD;
+use vortex::encodings::datetime_parts::DateTimeParts;
+use vortex::encodings::fsst::FSST;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::sequence::Sequence;
+use vortex::encodings::sparse::Sparse;
+use vortex::encodings::zigzag::ZigZag;
 use vortex::encodings::zigzag::zigzag_encode;
 
 use crate::PyVortex;
@@ -26,7 +26,7 @@ use crate::error::PyVortexResult;
 pub(crate) struct PyAlpArray;
 
 impl EncodingSubclass for PyAlpArray {
-    type VTable = ALPVTable;
+    type VTable = ALP;
 }
 
 /// Concrete class for arrays with `vortex.alprd` encoding.
@@ -34,7 +34,7 @@ impl EncodingSubclass for PyAlpArray {
 pub(crate) struct PyAlpRdArray;
 
 impl EncodingSubclass for PyAlpRdArray {
-    type VTable = ALPRDVTable;
+    type VTable = ALPRD;
 }
 
 /// Concrete class for arrays with `vortex.datetimeparts` encoding.
@@ -42,7 +42,7 @@ impl EncodingSubclass for PyAlpRdArray {
 pub(crate) struct PyDateTimePartsArray;
 
 impl EncodingSubclass for PyDateTimePartsArray {
-    type VTable = DateTimePartsVTable;
+    type VTable = DateTimeParts;
 }
 
 /// Concrete class for arrays with `vortex.dict` encoding.
@@ -50,7 +50,7 @@ impl EncodingSubclass for PyDateTimePartsArray {
 pub(crate) struct PyDictArray;
 
 impl EncodingSubclass for PyDictArray {
-    type VTable = DictVTable;
+    type VTable = Dict;
 }
 
 /// Concrete class for arrays with `vortex.fsst` encoding.
@@ -58,7 +58,7 @@ impl EncodingSubclass for PyDictArray {
 pub(crate) struct PyFsstArray;
 
 impl EncodingSubclass for PyFsstArray {
-    type VTable = FSSTVTable;
+    type VTable = FSST;
 }
 
 /// Concrete class for arrays with `vortex.runend` encoding.
@@ -66,7 +66,7 @@ impl EncodingSubclass for PyFsstArray {
 pub(crate) struct PyRunEndArray;
 
 impl EncodingSubclass for PyRunEndArray {
-    type VTable = RunEndVTable;
+    type VTable = RunEnd;
 }
 
 /// Concrete class for arrays with `vortex.sparse` encoding.
@@ -74,7 +74,7 @@ impl EncodingSubclass for PyRunEndArray {
 pub(crate) struct PySparseArray;
 
 impl EncodingSubclass for PySparseArray {
-    type VTable = SparseVTable;
+    type VTable = Sparse;
 }
 
 /// Concrete class for arrays with `vortex.zigzag` encoding.
@@ -82,7 +82,7 @@ impl EncodingSubclass for PySparseArray {
 pub(crate) struct PyZigZagArray;
 
 impl EncodingSubclass for PyZigZagArray {
-    type VTable = ZigZagVTable;
+    type VTable = ZigZag;
 }
 
 #[pymethods]
@@ -100,5 +100,5 @@ impl PyZigZagArray {
 pub(crate) struct PySequenceArray;
 
 impl EncodingSubclass for PySequenceArray {
-    type VTable = SequenceVTable;
+    type VTable = Sequence;
 }
diff --git a/vortex-python/src/arrays/fastlanes.rs b/vortex-python/src/arrays/fastlanes.rs
index 120622c2594..31b49e8d804 100644
--- a/vortex-python/src/arrays/fastlanes.rs
+++ b/vortex-python/src/arrays/fastlanes.rs
@@ -2,9 +2,9 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use pyo3::prelude::*;
-use vortex::encodings::fastlanes::BitPackedVTable;
-use vortex::encodings::fastlanes::DeltaVTable;
-use vortex::encodings::fastlanes::FoRVTable;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::Delta;
+use vortex::encodings::fastlanes::FoR;
 
 use crate::arrays::native::AsArrayRef;
 use crate::arrays::native::EncodingSubclass;
@@ -15,7 +15,7 @@ use crate::arrays::native::PyNativeArray;
 pub(crate) struct PyFastLanesBitPackedArray;
 
 impl EncodingSubclass for PyFastLanesBitPackedArray {
-    type VTable = BitPackedVTable;
+    type VTable = BitPacked;
 }
 
 #[pymethods]
@@ -32,7 +32,7 @@ impl PyFastLanesBitPackedArray {
 pub(crate) struct PyFastLanesDeltaArray;
 
 impl EncodingSubclass for PyFastLanesDeltaArray {
-    type VTable = DeltaVTable;
+    type VTable = Delta;
 }
 
 /// Concrete class for arrays with `fastlanes.for` encoding.
@@ -40,5 +40,5 @@ impl EncodingSubclass for PyFastLanesDeltaArray {
 pub(crate) struct PyFastLanesFoRArray;
 
 impl EncodingSubclass for PyFastLanesFoRArray {
-    type VTable = FoRVTable;
+    type VTable = FoR;
 }
diff --git a/vortex-python/src/arrays/from_arrow.rs b/vortex-python/src/arrays/from_arrow.rs
index 857cf946071..beb142a1625 100644
--- a/vortex-python/src/arrays/from_arrow.rs
+++ b/vortex-python/src/arrays/from_arrow.rs
@@ -8,6 +8,7 @@ use arrow_data::ArrayData as ArrowArrayData;
 use arrow_schema::DataType;
 use arrow_schema::Field;
 use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::*;
 use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
@@ -20,23 +21,26 @@ use vortex::error::VortexResult;
 
 use crate::arrays::PyArrayRef;
 use crate::arrow::FromPyArrow;
+use crate::classes::array_class;
+use crate::classes::chunked_array_class;
+use crate::classes::table_class;
 use crate::error::PyVortexError;
 use crate::error::PyVortexResult;
 
 /// Convert an Arrow object to a Vortex array.
 pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> PyVortexResult<PyArrayRef> {
-    let pa = obj.py().import("pyarrow")?;
-    let pa_array = pa.getattr("Array")?;
-    let chunked_array = pa.getattr("ChunkedArray")?;
-    let table = pa.getattr("Table")?;
+    let py = obj.py();
+    let pa_array = array_class(py)?;
+    let chunked_array = chunked_array_class(py)?;
+    let table = table_class(py)?;
 
-    if obj.is_instance(&pa_array)? {
+    if obj.is_instance(pa_array)? {
         let arrow_array = ArrowArrayData::from_pyarrow(&obj.as_borrowed()).map(make_array)?;
         let is_nullable = arrow_array.is_nullable();
         let enc_array = ArrayRef::from_arrow(arrow_array.as_ref(), is_nullable)?;
         Ok(PyArrayRef::from(enc_array))
-    } else if obj.is_instance(&chunked_array)? {
-        let chunks: Vec<Bound<PyAny>> = obj.getattr("chunks")?.extract()?;
+    } else if obj.is_instance(chunked_array)? {
+        let chunks: Vec<Bound<PyAny>> = obj.getattr(intern!(py, "chunks"))?.extract()?;
         let encoded_chunks = chunks
             .iter()
             .map(|a| {
@@ -45,13 +49,13 @@ pub(super) fn from_arrow(obj: &Borrowed<'_, '_, PyAny>) -> PyVortexResult<PyArra
             })
             .collect::<PyVortexResult<Vec<_>>>()?;
         let dtype: DType = obj
-            .getattr("type")
+            .getattr(intern!(py, "type"))
             .and_then(|v| DataType::from_pyarrow(&v.as_borrowed()))
             .map(|dt| DType::from_arrow(&Field::new("_", dt, false)))?;
         Ok(PyArrayRef::from(
             ChunkedArray::try_new(encoded_chunks, dtype)?.into_array(),
         ))
-    } else if obj.is_instance(&table)? {
+    } else if obj.is_instance(table)? {
         let array_stream = ArrowArrayStreamReader::from_pyarrow(&obj.as_borrowed())?;
         let dtype = DType::from_arrow(array_stream.schema());
         let chunks = array_stream
diff --git a/vortex-python/src/arrays/mod.rs b/vortex-python/src/arrays/mod.rs
index f5ab6942a3e..baabe693614 100644
--- a/vortex-python/src/arrays/mod.rs
+++ b/vortex-python/src/arrays/mod.rs
@@ -15,16 +15,19 @@ use pyo3::IntoPyObjectExt;
 use pyo3::exceptions::PyIndexError;
 use pyo3::exceptions::PyTypeError;
 use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use pyo3::types::PyList;
 use pyo3::types::PyRange;
 use pyo3::types::PyRangeMethods;
 use pyo3_bytes::PyBytes;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::ToCanonical;
-use vortex::array::arrays::ChunkedVTable;
+use vortex::array::arrays::Chunked;
+use vortex::array::arrays::bool::BoolArrayExt;
+use vortex::array::arrays::chunked::ChunkedArrayExt;
 use vortex::array::arrow::IntoArrowArray;
 use vortex::array::builtins::ArrayBuiltins;
 use vortex::array::match_each_integer_ptype;
@@ -39,6 +42,7 @@ use crate::PyVortex;
 use crate::arrays::native::PyNativeArray;
 use crate::arrays::py::PyPythonArray;
 use crate::arrays::py::PythonArray;
+use crate::arrays::py::PythonVTable;
 use crate::arrow::ToPyArrow;
 use crate::dtype::PyDType;
 use crate::error::PyVortexError;
@@ -106,7 +110,7 @@ impl<'py> FromPyObject<'_, 'py> for PyArrayRef {
         }
 
         // Otherwise, if it's a subclass of `PyArray`, then we can extract the inner array.
-        PythonArray::extract(ob).map(|instance| Self(instance.to_array()))
+        PythonArray::extract(ob).map(|instance| Self(instance.into_array()))
     }
 }
 
@@ -117,12 +121,12 @@ impl<'py> IntoPyObject<'py> for PyArrayRef {
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         // If the ArrayRef is a PyArrayInstance, extract the Python object.
-        if let Some(pyarray) = self.0.as_any().downcast_ref::<PythonArray>() {
-            return pyarray.clone().into_pyobject(py);
+        if let Some(pyarray) = self.0.as_opt::<PythonVTable>() {
+            return pyarray.data().clone().into_pyobject(py);
         }
 
         // Otherwise, wrap the ArrayRef in a PyNativeArray.
-        Ok(PyNativeArray::init(py, self.0.clone())?.into_any())
+        Ok(PyNativeArray::init(py, self.0)?.into_any())
     }
 }
 
@@ -323,14 +327,13 @@ impl PyArray {
         let array = PyArrayRef::extract(self_.as_any().as_borrowed())?.into_inner();
         let py = self_.py();
 
-        if let Some(chunked_array) = array.as_opt::<ChunkedVTable>() {
+        if let Some(chunked_array) = array.as_opt::<Chunked>() {
             // We figure out a single Arrow Data Type to convert all chunks into, otherwise
             // the preferred type of each chunk may be different.
             let arrow_dtype = chunked_array.dtype().to_arrow_dtype()?;
 
             let chunks = chunked_array
-                .chunks()
-                .iter()
+                .iter_chunks()
                 .map(|chunk| -> PyVortexResult<_> { Ok(chunk.clone().into_arrow(&arrow_dtype)?) })
                 .collect::<Result<Vec<ArrowArrayRef>, _>>()?;
 
@@ -351,7 +354,6 @@ impl PyArray {
             )?)
         } else {
             Ok(array
-                .clone()
                 .into_arrow_preferred()?
                 .into_data()
                 .to_pyarrow(py)?
@@ -523,8 +525,8 @@ impl PyArray {
     /// ```
     fn filter(slf: Bound<Self>, mask: PyArrayRef) -> PyVortexResult<PyArrayRef> {
         let slf = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
-        let mask = (&*mask as &dyn Array).to_bool().to_mask_fill_null_false();
-        let inner = vortex::compute::filter(&*slf, &mask)?;
+        let mask = (&*mask as &ArrayRef).to_bool().to_mask_fill_null_false();
+        let inner = slf.filter(mask)?.to_canonical()?.into_array();
         Ok(PyArrayRef::from(inner))
     }
 
@@ -696,10 +698,10 @@ impl PyArray {
     /// >>> arr = vx.array([1, 2, None, 3])
     /// >>> print(arr.display_tree()) # doctest: +ELLIPSIS
     /// root: vortex.primitive(i64?, len=4) nbytes=33 B (100.00%)
-    ///   metadata: EmptyMetadata
+    ///   metadata: ptype: i64
     ///   buffer: values host 32 B (align=8) (96.97%)
     ///   validity: vortex.bool(bool, len=4) nbytes=1 B (3.03%)...
-    ///     metadata: BoolMetadata { offset: 0 }
+    ///     metadata: offset: 0
     ///     buffer: bits host 1 B (align=1) (100.00%)
     /// <BLANKLINE>
     /// ```
@@ -715,7 +717,11 @@ impl PyArray {
         // FIXME(ngates): do not copy to vec, use buffer protocol
         let array = PyArrayRef::extract(slf.as_any().as_borrowed())?;
         Ok(array
-            .serialize(ctx, &Default::default())?
+            .serialize(
+                ctx,
+                &vortex::session::VortexSession::empty(),
+                &Default::default(),
+            )?
             .into_iter()
             .map(|buffer| buffer.to_vec())
             .collect())
@@ -731,8 +737,8 @@ impl PyArray {
         let py = slf.py();
         let array = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
-        let mut encoder = MessageEncoder::default();
-        let buffers = encoder.encode(EncoderMessage::Array(&*array))?;
+        let mut encoder = MessageEncoder::new(vortex::session::VortexSession::empty());
+        let buffers = encoder.encode(EncoderMessage::Array(&array))?;
 
         // Return buffers as a list instead of concatenating
         let array_buffers: Vec<Vec<u8>> = buffers.iter().map(|b| b.to_vec()).collect();
@@ -741,7 +747,7 @@ impl PyArray {
         let dtype_buffers: Vec<Vec<u8>> = dtype_buffers.iter().map(|b| b.to_vec()).collect();
 
         let vortex_module = PyModule::import(py, "vortex")?;
-        let unpickle_fn = vortex_module.getattr("_unpickle_array")?;
+        let unpickle_fn = vortex_module.getattr(intern!(py, "_unpickle_array"))?;
 
         let args = (array_buffers, dtype_buffers).into_pyobject(py)?;
         Ok((unpickle_fn, args.into_any()))
@@ -763,12 +769,12 @@ impl PyArray {
 
         let array = PyArrayRef::extract(slf.as_any().as_borrowed())?.into_inner();
 
-        let mut encoder = MessageEncoder::default();
-        let array_buffers = encoder.encode(EncoderMessage::Array(&*array))?;
+        let mut encoder = MessageEncoder::new(vortex::session::VortexSession::empty());
+        let array_buffers = encoder.encode(EncoderMessage::Array(&array))?;
         let dtype_buffers = encoder.encode(EncoderMessage::DType(array.dtype()))?;
 
         let pickle_module = PyModule::import(py, "pickle")?;
-        let pickle_buffer_class = pickle_module.getattr("PickleBuffer")?;
+        let pickle_buffer_class = pickle_module.getattr(intern!(py, "PickleBuffer"))?;
 
         let mut pickle_buffers = Vec::new();
         for buf in array_buffers.into_iter() {
@@ -787,7 +793,7 @@ impl PyArray {
         }
 
         let vortex_module = PyModule::import(py, "vortex")?;
-        let unpickle_fn = vortex_module.getattr("_unpickle_array")?;
+        let unpickle_fn = vortex_module.getattr(intern!(py, "_unpickle_array"))?;
 
         let args = (pickle_buffers, dtype_pickle_buffers).into_pyobject(py)?;
         Ok((unpickle_fn, args.into_any()))
diff --git a/vortex-python/src/arrays/native.rs b/vortex-python/src/arrays/native.rs
index 34e038f36b5..2ff7945fc55 100644
--- a/vortex-python/src/arrays/native.rs
+++ b/vortex-python/src/arrays/native.rs
@@ -5,35 +5,33 @@ use std::ops::Deref;
 
 use pyo3::PyClass;
 use pyo3::prelude::*;
-use vortex::array::Array;
-use vortex::array::ArrayAdapter;
 use vortex::array::ArrayRef;
-use vortex::array::arrays::BoolVTable;
-use vortex::array::arrays::ChunkedVTable;
-use vortex::array::arrays::ConstantVTable;
-use vortex::array::arrays::DecimalVTable;
-use vortex::array::arrays::DictVTable;
-use vortex::array::arrays::ExtensionVTable;
-use vortex::array::arrays::FixedSizeListVTable;
-use vortex::array::arrays::ListVTable;
-use vortex::array::arrays::NullVTable;
-use vortex::array::arrays::PrimitiveVTable;
-use vortex::array::arrays::StructVTable;
-use vortex::array::arrays::VarBinVTable;
-use vortex::array::arrays::VarBinViewVTable;
-use vortex::array::vtable::VTable;
-use vortex::encodings::alp::ALPRDVTable;
-use vortex::encodings::alp::ALPVTable;
-use vortex::encodings::bytebool::ByteBoolVTable;
-use vortex::encodings::datetime_parts::DateTimePartsVTable;
-use vortex::encodings::fastlanes::BitPackedVTable;
-use vortex::encodings::fastlanes::DeltaVTable;
-use vortex::encodings::fastlanes::FoRVTable;
-use vortex::encodings::fsst::FSSTVTable;
-use vortex::encodings::runend::RunEndVTable;
-use vortex::encodings::sequence::SequenceVTable;
-use vortex::encodings::sparse::SparseVTable;
-use vortex::encodings::zigzag::ZigZagVTable;
+use vortex::array::VTable;
+use vortex::array::arrays::Bool;
+use vortex::array::arrays::Chunked;
+use vortex::array::arrays::Constant;
+use vortex::array::arrays::Decimal;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::Extension;
+use vortex::array::arrays::FixedSizeList;
+use vortex::array::arrays::List;
+use vortex::array::arrays::Null;
+use vortex::array::arrays::Primitive;
+use vortex::array::arrays::Struct;
+use vortex::array::arrays::VarBin;
+use vortex::array::arrays::VarBinView;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::ALPRD;
+use vortex::encodings::bytebool::ByteBool;
+use vortex::encodings::datetime_parts::DateTimeParts;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::Delta;
+use vortex::encodings::fastlanes::FoR;
+use vortex::encodings::fsst::FSST;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::sequence::Sequence;
+use vortex::encodings::sparse::Sparse;
+use vortex::encodings::zigzag::ZigZag;
 use vortex::error::VortexExpect;
 
 use crate::arrays::PyArray;
@@ -79,103 +77,103 @@ impl PyNativeArray {
     /// Initialize a [`PyArray`] from a Vortex [`ArrayRef`], ensuring we return the correct typed
     /// subclass array.
     pub fn init(py: Python, array: ArrayRef) -> PyResult<Bound<PyNativeArray>> {
-        if array.is::<NullVTable>() {
+        if array.is::<Null>() {
             return Self::with_subclass(py, array, PyNullArray);
         }
 
-        if array.is::<BoolVTable>() {
+        if array.is::<Bool>() {
             return Self::with_subclass(py, array, PyBoolArray);
         }
 
-        if array.is::<PrimitiveVTable>() {
+        if array.is::<Primitive>() {
             return Self::with_subclass(py, array, PyPrimitiveArray);
         }
 
-        if array.is::<VarBinVTable>() {
+        if array.is::<VarBin>() {
             return Self::with_subclass(py, array, PyVarBinArray);
         }
 
-        if array.is::<VarBinViewVTable>() {
+        if array.is::<VarBinView>() {
             return Self::with_subclass(py, array, PyVarBinViewArray);
         }
 
-        if array.is::<StructVTable>() {
+        if array.is::<Struct>() {
             return Self::with_subclass(py, array, PyStructArray);
         }
 
-        if array.is::<ListVTable>() {
+        if array.is::<List>() {
             return Self::with_subclass(py, array, PyListArray);
         }
 
-        if array.is::<FixedSizeListVTable>() {
+        if array.is::<FixedSizeList>() {
             return Self::with_subclass(py, array, PyFixedSizeListArray);
         }
 
-        if array.is::<ExtensionVTable>() {
+        if array.is::<Extension>() {
             return Self::with_subclass(py, array, PyExtensionArray);
         }
 
-        if array.is::<ChunkedVTable>() {
+        if array.is::<Chunked>() {
             return Self::with_subclass(py, array, PyChunkedArray);
         }
 
-        if array.is::<ConstantVTable>() {
+        if array.is::<Constant>() {
             return Self::with_subclass(py, array, PyConstantArray);
         }
 
-        if array.is::<ByteBoolVTable>() {
+        if array.is::<ByteBool>() {
             return Self::with_subclass(py, array, PyByteBoolArray);
         }
 
-        if array.is::<SparseVTable>() {
+        if array.is::<Sparse>() {
             return Self::with_subclass(py, array, PySparseArray);
         }
 
-        if array.is::<ALPVTable>() {
+        if array.is::<ALP>() {
             return Self::with_subclass(py, array, PyAlpArray);
         }
 
-        if array.is::<ALPRDVTable>() {
+        if array.is::<ALPRD>() {
             return Self::with_subclass(py, array, PyAlpRdArray);
         }
 
-        if array.is::<DateTimePartsVTable>() {
+        if array.is::<DateTimeParts>() {
             return Self::with_subclass(py, array, PyDateTimePartsArray);
         }
 
-        if array.is::<DictVTable>() {
+        if array.is::<Dict>() {
             return Self::with_subclass(py, array, PyDictArray);
         }
 
-        if array.is::<FSSTVTable>() {
+        if array.is::<FSST>() {
             return Self::with_subclass(py, array, PyFsstArray);
         }
 
-        if array.is::<RunEndVTable>() {
+        if array.is::<RunEnd>() {
             return Self::with_subclass(py, array, PyRunEndArray);
         }
 
-        if array.is::<ZigZagVTable>() {
+        if array.is::<ZigZag>() {
             return Self::with_subclass(py, array, PyZigZagArray);
         }
 
-        if array.is::<BitPackedVTable>() {
+        if array.is::<BitPacked>() {
             return Self::with_subclass(py, array, PyFastLanesBitPackedArray);
         }
 
-        if array.is::<DeltaVTable>() {
+        if array.is::<Delta>() {
             return Self::with_subclass(py, array, PyFastLanesDeltaArray);
         }
 
-        if array.is::<FoRVTable>() {
+        if array.is::<FoR>() {
             return Self::with_subclass(py, array, PyFastLanesFoRArray);
         }
 
-        if array.is::<DecimalVTable>() {
+        if array.is::<Decimal>() {
             return Self::with_subclass(py, array, PyDecimalArray);
         }
 
-        if array.is::<SequenceVTable>() {
+        if array.is::<Sequence>() {
             return Self::with_subclass(py, array, PySequenceArray);
         }
 
@@ -249,13 +247,12 @@ pub trait AsArrayRef<T> {
     fn as_array_ref(&self) -> &T;
 }
 
-impl<V: EncodingSubclass> AsArrayRef<<V::VTable as VTable>::Array> for PyRef<'_, V> {
-    fn as_array_ref(&self) -> &<V::VTable as VTable>::Array {
+impl<V: EncodingSubclass> AsArrayRef<<V::VTable as VTable>::ArrayData> for PyRef<'_, V> {
+    fn as_array_ref(&self) -> &<V::VTable as VTable>::ArrayData {
         self.as_super()
             .inner()
-            .as_any()
-            .downcast_ref::<ArrayAdapter<V::VTable>>()
+            .as_opt::<V::VTable>()
             .vortex_expect("Failed to downcast array")
-            .as_inner()
+            .data()
     }
 }
diff --git a/vortex-python/src/arrays/py/array.rs b/vortex-python/src/arrays/py/array.rs
index 48d623efa4d..b73fc9c6fb0 100644
--- a/vortex-python/src/arrays/py/array.rs
+++ b/vortex-python/src/arrays/py/array.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Display;
+use std::fmt::Formatter;
 use std::sync::Arc;
 
 use pyo3::Bound;
@@ -8,11 +10,16 @@ use pyo3::FromPyObject;
 use pyo3::Py;
 use pyo3::PyAny;
 use pyo3::prelude::*;
+use vortex::array::Array;
+use vortex::array::ArrayParts;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::stats::ArrayStats;
-use vortex::array::vtable::ArrayId;
+use vortex::array::stats::StatsSet;
 use vortex::dtype::DType;
 
 use crate::arrays::py::PyPythonArray;
+use crate::arrays::py::PythonVTable;
 use crate::error::PyVortexError;
 
 /// Wrapper struct encapsulating a Vortex array implemented using a Python object.
@@ -21,13 +28,19 @@ use crate::error::PyVortexError;
 /// will ensure the object implements the necessary methods.
 #[derive(Debug, Clone)]
 pub struct PythonArray {
-    pub(super) id: ArrayId,
+    pub(super) vtable: PythonVTable,
     pub(super) object: Arc<Py<PyAny>>,
     pub(super) len: usize,
     pub(super) dtype: DType,
     pub(super) stats: ArrayStats,
 }
 
+impl Display for PythonArray {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "len: {}, dtype: {}", self.len, self.dtype)
+    }
+}
+
 impl<'py> FromPyObject<'_, 'py> for PythonArray {
     type Error = PyErr;
 
@@ -35,7 +48,9 @@ impl<'py> FromPyObject<'_, 'py> for PythonArray {
         let ob_cast = ob.cast::<PyPythonArray>()?;
         let python_array = ob_cast.get();
         Ok(Self {
-            id: python_array.id.clone(),
+            vtable: PythonVTable {
+                id: python_array.id.clone(),
+            },
             object: Arc::new(ob.to_owned().unbind()),
             len: python_array.len,
             dtype: python_array.dtype.clone(),
@@ -53,3 +68,18 @@ impl<'py> IntoPyObject<'py> for PythonArray {
         Ok(self.object.bind(py).to_owned())
     }
 }
+
+impl IntoArray for PythonArray {
+    fn into_array(self) -> ArrayRef {
+        let vtable = self.vtable.clone();
+        let dtype = self.dtype.clone();
+        let len = self.len;
+        let stats = StatsSet::from(self.stats.clone());
+        match Array::try_from_parts(ArrayParts::new(vtable, dtype, len, self)) {
+            Ok(array) => array.with_stats_set(stats).into_array(),
+            Err(err) => unreachable!(
+                "PythonArray metadata extracted from PyPythonArray must be valid: {err}"
+            ),
+        }
+    }
+}
diff --git a/vortex-python/src/arrays/py/mod.rs b/vortex-python/src/arrays/py/mod.rs
index f15ffbaed9b..761d8a3d7df 100644
--- a/vortex-python/src/arrays/py/mod.rs
+++ b/vortex-python/src/arrays/py/mod.rs
@@ -9,9 +9,10 @@ pub(crate) use array::*;
 use pyo3::Bound;
 use pyo3::PyAny;
 use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::PyAnyMethods;
 pub(crate) use python::*;
-use vortex::array::vtable::ArrayId;
+use vortex::array::ArrayId;
 pub(crate) use vtable::*;
 
 use crate::error::PyVortexResult;
@@ -19,7 +20,7 @@ use crate::error::PyVortexResult;
 /// Extract the array id from a Python class `id` attribute.
 pub fn id_from_obj(cls: &Bound<PyAny>) -> PyVortexResult<ArrayId> {
     Ok(ArrayId::new_arc(
-        cls.getattr("id")
+        cls.getattr(intern!(cls.py(), "id"))
             .map_err(|_| {
                 PyValueError::new_err(format!(
                     "PyEncoding subclass {cls:?} must have an 'id' attribute"
diff --git a/vortex-python/src/arrays/py/python.rs b/vortex-python/src/arrays/py/python.rs
index 922e09305e1..ed348b2fe78 100644
--- a/vortex-python/src/arrays/py/python.rs
+++ b/vortex-python/src/arrays/py/python.rs
@@ -3,8 +3,8 @@
 
 use pyo3::prelude::*;
 use pyo3::types::PyType;
+use vortex::array::ArrayId;
 use vortex::array::stats::ArrayStats;
-use vortex::array::vtable::ArrayId;
 use vortex::dtype::DType;
 
 use crate::arrays::PyArray;
diff --git a/vortex-python/src/arrays/py/vtable.rs b/vortex-python/src/arrays/py/vtable.rs
index d565e7aa695..aa646e971fe 100644
--- a/vortex-python/src/arrays/py/vtable.rs
+++ b/vortex-python/src/arrays/py/vtable.rs
@@ -4,164 +4,137 @@
 use std::hash::Hash;
 use std::sync::Arc;
 
-use pyo3::Python;
-use pyo3::intern;
-use pyo3::prelude::*;
-use pyo3::types::PyBytes;
-use vortex::array::ArrayBufferVisitor;
-use vortex::array::ArrayChildVisitor;
+use vortex::array::Array;
+use vortex::array::ArrayEq;
+use vortex::array::ArrayHash;
+use vortex::array::ArrayId;
+use vortex::array::ArrayParts;
 use vortex::array::ArrayRef;
+use vortex::array::ArrayView;
 use vortex::array::ExecutionCtx;
+use vortex::array::ExecutionResult;
+use vortex::array::OperationsVTable;
 use vortex::array::Precision;
-use vortex::array::RawMetadata;
-use vortex::array::SerializeMetadata;
+use vortex::array::VTable;
+use vortex::array::ValidityVTable;
 use vortex::array::buffer::BufferHandle;
-use vortex::array::serde::ArrayChildren;
-use vortex::array::stats::StatsSetRef;
 use vortex::array::validity::Validity;
-use vortex::array::vtable;
-use vortex::array::vtable::ArrayId;
-use vortex::array::vtable::BaseArrayVTable;
-use vortex::array::vtable::OperationsVTable;
-use vortex::array::vtable::VTable;
-use vortex::array::vtable::ValidityVTable;
-use vortex::array::vtable::VisitorVTable;
 use vortex::dtype::DType;
 use vortex::error::VortexResult;
+use vortex::error::vortex_bail;
 use vortex::error::vortex_ensure;
-use vortex::error::vortex_err;
+use vortex::error::vortex_panic;
 use vortex::scalar::Scalar;
 use vortex::session::VortexSession;
 
 use crate::arrays::py::PythonArray;
 
-vtable!(Python);
-
 /// Wrapper struct encapsulating a Python encoding.
-#[derive(Debug)]
-pub struct PythonVTable;
+#[derive(Debug, Clone)]
+pub struct PythonVTable {
+    pub id: ArrayId,
+}
 
-impl VTable for PythonVTable {
-    type Array = PythonArray;
+impl ArrayHash for PythonArray {
+    fn array_hash<H: std::hash::Hasher>(&self, state: &mut H, _precision: Precision) {
+        Arc::as_ptr(&self.object).hash(state);
+    }
+}
 
-    type Metadata = RawMetadata;
+impl ArrayEq for PythonArray {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        Arc::ptr_eq(&self.object, &other.object)
+    }
+}
+
+impl VTable for PythonVTable {
+    type ArrayData = PythonArray;
 
-    type ArrayVTable = Self;
     type OperationsVTable = Self;
     type ValidityVTable = Self;
-    type VisitorVTable = Self;
 
-    fn id(array: &Self::Array) -> ArrayId {
-        array.id.clone()
+    fn id(&self) -> ArrayId {
+        self.id.clone()
     }
 
-    fn metadata(array: &PythonArray) -> VortexResult<Self::Metadata> {
-        Python::attach(|py| {
-            let obj = array.object.bind(py);
-            if !obj
-                .hasattr(intern!(py, "metadata"))
-                .map_err(|e| vortex_err!("{}", e))?
-            {
-                // The class does not have a metadata attribute so does not support serialization.
-                return Ok(RawMetadata(vec![]));
-            }
-
-            let bytes = obj
-                .call_method("__vx_metadata__", (), None)
-                .map_err(|e| vortex_err!("{}", e))?
-                .cast::<PyBytes>()
-                .map_err(|_| vortex_err!("Expected array metadata to be Python bytes"))?
-                .as_bytes()
-                .to_vec();
-
-            Ok(RawMetadata(bytes))
-        })
+    fn validate(
+        &self,
+        data: &PythonArray,
+        dtype: &DType,
+        len: usize,
+        _slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(data.vtable.id == self.id, "PythonArray vtable id mismatch");
+        vortex_ensure!(&data.dtype == dtype, "PythonArray dtype mismatch");
+        vortex_ensure!(data.len == len, "PythonArray len mismatch");
+        Ok(())
     }
 
-    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(metadata.serialize()))
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn deserialize(
-        bytes: &[u8],
-        _dtype: &DType,
-        _len: usize,
-        _buffers: &[BufferHandle],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Metadata> {
-        Ok(RawMetadata(bytes.to_vec()))
+    fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("PythonArray buffer index {idx} out of bounds")
     }
 
-    fn build(
-        _dtype: &DType,
-        _len: usize,
-        _metadata: &Self::Metadata,
-        _buffers: &[BufferHandle],
-        _children: &dyn ArrayChildren,
-    ) -> VortexResult<PythonArray> {
-        todo!()
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
     }
 
-    fn with_children(_array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()> {
-        vortex_ensure!(
-            children.is_empty(),
-            "PythonArray has no children, got {}",
-            children.len()
-        );
-        Ok(())
+    fn nchildren(_array: ArrayView<'_, Self>) -> usize {
+        0
     }
 
-    fn execute(_array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-        todo!()
+    fn child(_array: ArrayView<'_, Self>, idx: usize) -> ArrayRef {
+        vortex_panic!("PythonArray child index {idx} out of bounds")
     }
-}
 
-impl BaseArrayVTable<PythonVTable> for PythonVTable {
-    fn len(array: &PythonArray) -> usize {
-        array.len
+    fn child_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
+        vortex_panic!("PythonArray child_name index {idx} out of bounds")
     }
 
-    fn dtype(array: &PythonArray) -> &DType {
-        &array.dtype
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(None)
     }
 
-    fn stats(array: &PythonArray) -> StatsSetRef<'_> {
-        array.stats.to_ref(array.as_ref())
+    fn deserialize(
+        &self,
+        _dtype: &DType,
+        _len: usize,
+        bytes: &[u8],
+        _buffers: &[BufferHandle],
+        _children: &dyn vortex::array::serde::ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        _ = bytes;
+        vortex_bail!("PythonArray deserialization is not supported");
     }
 
-    fn array_hash<H: std::hash::Hasher>(array: &PythonArray, state: &mut H, _precision: Precision) {
-        Arc::as_ptr(&array.object).hash(state);
-        array.id.hash(state);
-        array.len.hash(state);
-        array.dtype.hash(state);
+    fn slot_name(_array: ArrayView<'_, Self>, _idx: usize) -> String {
+        vortex_panic!("PythonArray has no slots")
     }
 
-    fn array_eq(array: &PythonArray, other: &PythonArray, _precision: Precision) -> bool {
-        Arc::ptr_eq(&array.object, &other.object)
-            && array.id == other.id
-            && array.len == other.len
-            && array.dtype == other.dtype
+    fn execute(_array: Array<Self>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        todo!()
     }
 }
 
 impl OperationsVTable<PythonVTable> for PythonVTable {
-    fn scalar_at(_array: &PythonArray, _index: usize) -> VortexResult<Scalar> {
+    fn scalar_at(
+        _array: ArrayView<'_, PythonVTable>,
+        _index: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
         todo!()
     }
 }
 
 impl ValidityVTable<PythonVTable> for PythonVTable {
-    fn validity(_array: &PythonArray) -> VortexResult<Validity> {
-        todo!()
-    }
-}
-
-impl VisitorVTable<PythonVTable> for PythonVTable {
-    fn visit_buffers(_array: &PythonArray, _visitor: &mut dyn ArrayBufferVisitor) {
-        todo!()
-    }
-
-    fn visit_children(_array: &PythonArray, _visitor: &mut dyn ArrayChildVisitor) {
+    fn validity(_array: ArrayView<'_, PythonVTable>) -> VortexResult<Validity> {
         todo!()
     }
 }
diff --git a/vortex-python/src/arrays/range_to_sequence.rs b/vortex-python/src/arrays/range_to_sequence.rs
index 4ff44616ba1..cfd07168b8b 100644
--- a/vortex-python/src/arrays/range_to_sequence.rs
+++ b/vortex-python/src/arrays/range_to_sequence.rs
@@ -2,13 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity;
 use vortex::buffer::Buffer;
 use vortex::dtype::DType;
 use vortex::dtype::NativePType;
 use vortex::dtype::Nullability;
-use vortex::encodings::sequence::SequenceArray;
+use vortex::encodings::sequence::Sequence;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
@@ -29,7 +30,7 @@ pub fn sequence_array_from_range<T: NativePType + TryFrom<isize> + Into<PValue>>
             Nullability::NonNullable => Validity::NonNullable,
             Nullability::Nullable => Validity::AllValid,
         };
-        return Ok(PrimitiveArray::new::<T>(Buffer::empty(), validity).to_array());
+        return Ok(PrimitiveArray::new::<T>(Buffer::empty(), validity).into_array());
     };
     let Ok(start) = T::try_from(start) else {
         vortex_bail!(
@@ -42,7 +43,7 @@ pub fn sequence_array_from_range<T: NativePType + TryFrom<isize> + Into<PValue>>
         vortex_bail!("Step, {}, does not fit in requested dtype: {}", step, dtype);
     };
 
-    Ok(SequenceArray::typed_new::<T>(start, step, dtype.nullability(), len)?.to_array())
+    Ok(Sequence::try_new_typed::<T>(start, step, dtype.nullability(), len)?.into_array())
 }
 
 fn range_len(start: isize, stop: isize, step: isize) -> Option<usize> {
diff --git a/vortex-python/src/arrow.rs b/vortex-python/src/arrow.rs
index 861602f08c9..1ca4be5981f 100644
--- a/vortex-python/src/arrow.rs
+++ b/vortex-python/src/arrow.rs
@@ -31,10 +31,17 @@ use pyo3::exceptions::PyValueError;
 use pyo3::ffi::Py_uintptr_t;
 use pyo3::ffi::c_str;
 use pyo3::import_exception;
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyCapsule;
 use pyo3::types::PyTuple;
 
+use crate::classes::array_class;
+use crate::classes::data_type_class;
+use crate::classes::field_class;
+use crate::classes::record_batch_reader_class;
+use crate::classes::schema_class;
+
 const SCHEMA_NAME: &CStr = c_str!("arrow_schema");
 const ARRAY_NAME: &CStr = c_str!("arrow_array");
 const ARRAY_STREAM_NAME: &CStr = c_str!("arrow_array_stream");
@@ -69,13 +76,14 @@ pub trait IntoPyArrow {
 
 impl<'py> FromPyArrow<'_, 'py> for DataType {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_schema__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_schema__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_schema__ attribute to be set.",
             ));
         }
 
-        let capsule = value.getattr("__arrow_c_schema__")?.call0()?;
+        let capsule = value.getattr(intern!(py, "__arrow_c_schema__"))?.call0()?;
         let capsule = capsule.cast::<PyCapsule>()?;
 
         let schema_ptr = unsafe {
@@ -92,22 +100,24 @@ impl<'py> FromPyArrow<'_, 'py> for DataType {
 impl ToPyArrow for DataType {
     fn to_pyarrow(&self, py: Python) -> PyResult<Py<PyAny>> {
         let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("DataType")?;
-        let dtype = class.call_method1("_import_from_c", (&raw const c_schema as Py_uintptr_t,))?;
+        let dtype = data_type_class(py)?.call_method1(
+            intern!(py, "_import_from_c"),
+            (&raw const c_schema as Py_uintptr_t,),
+        )?;
         Ok(dtype.into())
     }
 }
 
 impl<'py> FromPyArrow<'_, 'py> for Field {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_schema__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_schema__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_schema__ attribute to be set.",
             ));
         }
 
-        let capsule = value.getattr("__arrow_c_schema__")?.call0()?;
+        let capsule = value.getattr(intern!(py, "__arrow_c_schema__"))?.call0()?;
         let capsule = capsule.cast::<PyCapsule>()?;
 
         let schema_ptr = unsafe {
@@ -124,22 +134,24 @@ impl<'py> FromPyArrow<'_, 'py> for Field {
 impl ToPyArrow for Field {
     fn to_pyarrow(&self, py: Python) -> PyResult<Py<PyAny>> {
         let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("Field")?;
-        let dtype = class.call_method1("_import_from_c", (&raw const c_schema as Py_uintptr_t,))?;
+        let dtype = field_class(py)?.call_method1(
+            intern!(py, "_import_from_c"),
+            (&raw const c_schema as Py_uintptr_t,),
+        )?;
         Ok(dtype.into())
     }
 }
 
 impl<'py> FromPyArrow<'_, 'py> for Schema {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_schema__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_schema__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_schema__ attribute to be set.",
             ));
         }
 
-        let capsule = value.getattr("__arrow_c_schema__")?.call0()?;
+        let capsule = value.getattr(intern!(py, "__arrow_c_schema__"))?.call0()?;
         let capsule = capsule.cast::<PyCapsule>()?;
 
         let schema_ptr = unsafe {
@@ -157,23 +169,24 @@ impl<'py> FromPyArrow<'_, 'py> for Schema {
 impl ToPyArrow for Schema {
     fn to_pyarrow(&self, py: Python) -> PyResult<Py<PyAny>> {
         let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("Schema")?;
-        let schema =
-            class.call_method1("_import_from_c", (&raw const c_schema as Py_uintptr_t,))?;
+        let schema = schema_class(py)?.call_method1(
+            intern!(py, "_import_from_c"),
+            (&raw const c_schema as Py_uintptr_t,),
+        )?;
         Ok(schema.into())
     }
 }
 
 impl<'py> FromPyArrow<'_, 'py> for ArrayData {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_array__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_array__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_array__ attribute to be set.",
             ));
         }
 
-        let tuple = value.getattr("__arrow_c_array__")?.call0()?;
+        let tuple = value.getattr(intern!(py, "__arrow_c_array__"))?.call0()?;
 
         if !tuple.is_instance_of::<PyTuple>() {
             return Err(PyTypeError::new_err(
@@ -207,10 +220,8 @@ impl ToPyArrow for ArrayData {
         let array = FFI_ArrowArray::new(self);
         let schema = FFI_ArrowSchema::try_from(self.data_type()).map_err(to_py_err)?;
 
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("Array")?;
-        let array = class.call_method1(
-            "_import_from_c",
+        let array = array_class(py)?.call_method1(
+            intern!(py, "_import_from_c"),
             (
                 addr_of!(array) as Py_uintptr_t,
                 addr_of!(schema) as Py_uintptr_t,
@@ -222,13 +233,14 @@ impl ToPyArrow for ArrayData {
 
 impl<'py> FromPyArrow<'_, 'py> for RecordBatch {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_array__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_array__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_array__ attribute to be set.",
             ));
         }
 
-        let tuple = value.getattr("__arrow_c_array__")?.call0()?;
+        let tuple = value.getattr(intern!(py, "__arrow_c_array__"))?.call0()?;
 
         if !tuple.is_instance_of::<PyTuple>() {
             return Err(PyTypeError::new_err(
@@ -286,20 +298,21 @@ impl ToPyArrow for RecordBatch {
         let reader = RecordBatchIterator::new(vec![Ok(self.clone())], self.schema());
         let reader: Box<dyn RecordBatchReader + Send> = Box::new(reader);
         let py_reader = reader.into_pyarrow(py)?;
-        py_reader.call_method0(py, "read_next_batch")
+        py_reader.call_method0(py, intern!(py, "read_next_batch"))
     }
 }
 
 /// Supports conversion from `pyarrow.RecordBatchReader` to [ArrowArrayStreamReader].
 impl<'py> FromPyArrow<'_, 'py> for ArrowArrayStreamReader {
     fn from_pyarrow(value: &Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
-        if !value.hasattr("__arrow_c_stream__")? {
+        let py = value.py();
+        if !value.hasattr(intern!(py, "__arrow_c_stream__"))? {
             return Err(PyValueError::new_err(
                 "Expected __arrow_c_stream__ attribute to be set.",
             ));
         }
 
-        let capsule = value.getattr("__arrow_c_stream__")?.call0()?;
+        let capsule = value.getattr(intern!(py, "__arrow_c_stream__"))?.call0()?;
         let capsule = capsule.cast::<PyCapsule>()?;
 
         let array_ptr = capsule
@@ -323,10 +336,9 @@ impl IntoPyArrow for Box<dyn RecordBatchReader + Send> {
     fn into_pyarrow(self, py: Python) -> PyResult<Py<PyAny>> {
         let mut stream = FFI_ArrowArrayStream::new(self);
 
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("RecordBatchReader")?;
         let args = PyTuple::new(py, [&raw mut stream as Py_uintptr_t])?;
-        let reader = class.call_method1("_import_from_c", args)?;
+        let reader =
+            record_batch_reader_class(py)?.call_method1(intern!(py, "_import_from_c"), args)?;
 
         Ok(Py::from(reader))
     }
diff --git a/vortex-python/src/classes.rs b/vortex-python/src/classes.rs
new file mode 100644
index 00000000000..a9e881ed160
--- /dev/null
+++ b/vortex-python/src/classes.rs
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Caching often accesses classes that are accessed across the C ABI
+
+use pyo3::Bound;
+use pyo3::Py;
+use pyo3::PyResult;
+use pyo3::Python;
+use pyo3::sync::PyOnceLock;
+use pyo3::types::PyType;
+
+/// Returns the pyarrow.DataType class
+pub fn data_type_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "DataType")
+}
+
+/// Returns the pyarrow.Field class
+pub fn field_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "Field")
+}
+
+/// Returns the pyarrow.Schema class
+pub fn schema_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "Schema")
+}
+
+/// Returns the pyarrow.Array class
+pub fn array_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "Array")
+}
+
+/// Returns the pyarrow.ChunkedArray class
+pub fn chunked_array_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "ChunkedArray")
+}
+
+/// Returns the pyarrow.RecordBatchReader class
+pub fn record_batch_reader_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "RecordBatchReader")
+}
+
+/// Returns the pyarrow.Table class
+pub fn table_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "pyarrow", "Table")
+}
+
+/// Returns the pyarrow.Decimal class
+pub fn decimal_class(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "decimal", "Decimal")
+}
diff --git a/vortex-python/src/dataset.rs b/vortex-python/src/dataset.rs
index 46c5cce3302..dccb103037d 100644
--- a/vortex-python/src/dataset.rs
+++ b/vortex-python/src/dataset.rs
@@ -21,7 +21,7 @@ use vortex::expr::root;
 use vortex::expr::select;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::VortexFile;
-use vortex::scan::SplitBy;
+use vortex::layout::scan::split_by::SplitBy;
 
 use crate::RUNTIME;
 use crate::SESSION;
@@ -131,7 +131,7 @@ impl PyVortexDataset {
 #[pymethods]
 impl PyVortexDataset {
     fn schema(self_: PyRef<Self>) -> PyResult<Py<PyAny>> {
-        self_.schema.clone().to_pyarrow(self_.py())
+        Arc::clone(&self_.schema).to_pyarrow(self_.py())
     }
 
     #[pyo3(signature = (*, columns = None, row_filter = None, indices = None, row_range = None))]
diff --git a/vortex-python/src/dtype/mod.rs b/vortex-python/src/dtype/mod.rs
index 876e41cbbb5..1f739e7ab94 100644
--- a/vortex-python/src/dtype/mod.rs
+++ b/vortex-python/src/dtype/mod.rs
@@ -26,6 +26,7 @@ use pyo3::PyClass;
 use pyo3::PyClassInitializer;
 use pyo3::PyResult;
 use pyo3::Python;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::PyModule;
 use pyo3::prelude::PyModuleMethods;
 use pyo3::pyclass;
@@ -91,7 +92,15 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
 }
 
 /// Base class for all Vortex data types.
-#[pyclass(name = "DType", module = "vortex", frozen, eq, hash, subclass)]
+#[pyclass(
+    name = "DType",
+    module = "vortex",
+    frozen,
+    eq,
+    hash,
+    subclass,
+    from_py_object
+)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct PyDType(DType);
 
@@ -124,6 +133,9 @@ impl PyDType {
             DType::List(..) => Self::with_subclass(py, dtype, PyListDType),
             DType::FixedSizeList(..) => Self::with_subclass(py, dtype, PyFixedSizeListDType),
             DType::Extension(..) => Self::with_subclass(py, dtype, PyExtensionDType),
+            DType::Variant(_) => Err(PyValueError::new_err(
+                "Variant DType is not supported in Python yet",
+            )),
         }
     }
 
diff --git a/vortex-python/src/dtype/ptype.rs b/vortex-python/src/dtype/ptype.rs
index b331b316844..880181c166e 100644
--- a/vortex-python/src/dtype/ptype.rs
+++ b/vortex-python/src/dtype/ptype.rs
@@ -8,7 +8,15 @@ use pyo3::prelude::*;
 use vortex::dtype::PType;
 
 /// Enum for primitive types.
-#[pyclass(name = "PType", module = "vortex", frozen, eq, eq_int, str)]
+#[pyclass(
+    name = "PType",
+    module = "vortex",
+    frozen,
+    eq,
+    eq_int,
+    str,
+    from_py_object
+)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum PyPType {
     /// An 8-bit unsigned integer
diff --git a/vortex-python/src/expr/mod.rs b/vortex-python/src/expr/mod.rs
index dfd306c6820..2daaefe4f4d 100644
--- a/vortex-python/src/expr/mod.rs
+++ b/vortex-python/src/expr/mod.rs
@@ -45,7 +45,7 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
 /// .. seealso::
 ///    :func:`.column`
 ///
-#[pyclass(name = "Expr", module = "vortex", frozen)]
+#[pyclass(name = "Expr", module = "vortex", frozen, from_py_object)]
 #[derive(Clone)]
 pub struct PyExpr {
     inner: Expression,
diff --git a/vortex-python/src/file.rs b/vortex-python/src/file.rs
index 421b8e9a4f6..06cee7590c1 100644
--- a/vortex-python/src/file.rs
+++ b/vortex-python/src/file.rs
@@ -21,9 +21,9 @@ use vortex::expr::root;
 use vortex::expr::select;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::VortexFile;
+use vortex::layout::scan::scan_builder::ScanBuilder;
+use vortex::layout::scan::split_by::SplitBy;
 use vortex::layout::segments::MokaSegmentCache;
-use vortex::scan::ScanBuilder;
-use vortex::scan::SplitBy;
 
 use crate::RUNTIME;
 use crate::SESSION;
diff --git a/vortex-python/src/io.rs b/vortex-python/src/io.rs
index f9d5e9708c5..edf1061188d 100644
--- a/vortex-python/src/io.rs
+++ b/vortex-python/src/io.rs
@@ -15,6 +15,7 @@ use vortex::array::arrow::FromArrowArray;
 use vortex::array::iter::ArrayIterator;
 use vortex::array::iter::ArrayIteratorAdapter;
 use vortex::array::iter::ArrayIteratorExt;
+use vortex::compressor::BtrBlocksCompressorBuilder;
 use vortex::dtype::DType;
 use vortex::dtype::arrow::FromArrowType;
 use vortex::error::VortexError;
@@ -30,6 +31,8 @@ use crate::TOKIO_RUNTIME;
 use crate::arrays::PyArray;
 use crate::arrays::PyArrayRef;
 use crate::arrow::FromPyArrow;
+use crate::classes::record_batch_reader_class;
+use crate::classes::table_class;
 use crate::dataset::PyVortexDataset;
 use crate::error::PyVortexResult;
 use crate::expr::PyExpr;
@@ -277,7 +280,7 @@ impl PyVortexWriteOptions {
     /// >>> vx.io.VortexWriteOptions.default().write(sprl, "chonky.vortex")
     /// >>> import os
     /// >>> os.path.getsize('chonky.vortex')
-    /// 216020
+    /// 216004
     /// ```
     ///
     /// Wow, Vortex manages to use about two bytes per integer! So advanced. So tiny.
@@ -289,7 +292,7 @@ impl PyVortexWriteOptions {
     /// ```python
     /// >>> vx.io.VortexWriteOptions.compact().write(sprl, "tiny.vortex")
     /// >>> os.path.getsize('tiny.vortex')
-    /// 55088
+    /// 55120
     /// ```
     ///
     /// Random numbers are not (usually) composed of random bytes!
@@ -350,7 +353,8 @@ impl PyVortexWriteOptions {
         py.detach(|| {
             let mut strategy = WriteStrategyBuilder::default();
             if self.use_compact_encodings {
-                strategy = strategy.with_compact_encodings();
+                strategy = strategy
+                    .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact());
             }
             let strategy = strategy.build();
             TOKIO_RUNTIME.block_on(async move {
@@ -425,11 +429,11 @@ fn try_arrow_stream_to_iterator(
     ob: &Borrowed<'_, '_, PyAny>,
 ) -> PyResult<Box<dyn ArrayIterator + Send>> {
     let py = ob.py();
-    let pa = py.import("pyarrow")?;
-    let pa_table = pa.getattr("Table")?;
-    let pa_record_batch_reader = pa.getattr("RecordBatchReader")?;
 
-    if ob.is_instance(&pa_table)? || ob.is_instance(&pa_record_batch_reader)? {
+    let pa_table = table_class(py)?;
+    let pa_record_batch_reader = record_batch_reader_class(py)?;
+
+    if ob.is_instance(pa_table)? || ob.is_instance(pa_record_batch_reader)? {
         // Convert to Arrow stream using FFI
         let arrow_stream = ArrowArrayStreamReader::from_pyarrow(ob)?;
         let dtype = DType::from_arrow(arrow_stream.schema());
diff --git a/vortex-python/src/iter/python.rs b/vortex-python/src/iter/python.rs
index 1b5aafc98ab..bb45404865e 100644
--- a/vortex-python/src/iter/python.rs
+++ b/vortex-python/src/iter/python.rs
@@ -4,7 +4,6 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use pyo3::types::PyIterator;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::iter::ArrayIterator;
 use vortex::dtype::DType;
diff --git a/vortex-python/src/lib.rs b/vortex-python/src/lib.rs
index 1d6bd678a26..a4a1f7a8057 100644
--- a/vortex-python/src/lib.rs
+++ b/vortex-python/src/lib.rs
@@ -1,14 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#[cfg(feature = "mimalloc")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::ops::Deref;
 use std::sync::LazyLock;
 
+use log::LevelFilter;
 use pyo3::exceptions::PyRuntimeError;
+use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3_log::Caching;
+use pyo3_log::Logger;
 
 pub(crate) mod arrays;
 pub mod arrow;
+pub(crate) mod classes;
 #[cfg(feature = "tui")]
 mod cli;
 mod compress;
@@ -27,9 +36,6 @@ mod scan;
 mod serde;
 mod store;
 
-use log::LevelFilter;
-use pyo3_log::Caching;
-use pyo3_log::Logger;
 use tokio::runtime::Runtime;
 use vortex::VortexSessionDefault;
 use vortex::error::VortexError;
@@ -107,10 +113,10 @@ pub fn install_module(name: &str, module: &Bound<PyModule>) -> PyResult<()> {
     module
         .py()
         .import("sys")?
-        .getattr("modules")?
+        .getattr(intern!(module.py(), "modules"))?
         .set_item(name, module)?;
     // needs to be set *after* `add_submodule()`
-    module.setattr("__name__", name)?;
+    module.setattr(intern!(module.py(), "__name__"), name)?;
     Ok(())
 }
 
diff --git a/vortex-python/src/object_store/registry.rs b/vortex-python/src/object_store/registry.rs
index e20b6ef46ab..13a16e3c36c 100644
--- a/vortex-python/src/object_store/registry.rs
+++ b/vortex-python/src/object_store/registry.rs
@@ -172,7 +172,7 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::use_debug)]
+    #[expect(clippy::use_debug)]
     fn test_resolve_url() {
         with_var("AWS_REGION", "us-east-3", || {
             let registry = Registry::default();
diff --git a/vortex-python/src/python_repr.rs b/vortex-python/src/python_repr.rs
index 29c98ba9cba..cf34d60a62a 100644
--- a/vortex-python/src/python_repr.rs
+++ b/vortex-python/src/python_repr.rs
@@ -23,6 +23,7 @@ impl PythonRepr for DType {
     }
 }
 
+// TODO(connor): We should probably just use the `Display` impl on `DType`.
 impl Display for DTypePythonRepr<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let DTypePythonRepr(dtype) = self;
@@ -102,6 +103,7 @@ impl Display for DTypePythonRepr<'_> {
                 }
                 write!(f, ")")
             }
+            DType::Variant(_) => write!(f, "variant()"),
         }
     }
 }
diff --git a/vortex-python/src/registry.rs b/vortex-python/src/registry.rs
index fe5d5933524..f04ef1a8022 100644
--- a/vortex-python/src/registry.rs
+++ b/vortex-python/src/registry.rs
@@ -3,7 +3,6 @@
 
 use pyo3::Bound;
 use pyo3::PyResult;
-use pyo3::Python;
 use pyo3::prelude::*;
 use vortex::array::session::ArraySessionExt;
 
@@ -32,6 +31,6 @@ pub(crate) fn register(cls: &Bound<PyAny>) -> PyVortexResult<()> {
     let id = id_from_obj(cls)?;
     // TODO(ngates): we would need to register the Python class object in a PyVortexSession
     //  to call back into it during deserialize operations.
-    SESSION.arrays().register(id, PythonVTable);
+    SESSION.arrays().register(PythonVTable { id });
     Ok(())
 }
diff --git a/vortex-python/src/scalar/factory.rs b/vortex-python/src/scalar/factory.rs
index 81286574a17..ea07d3494a9 100644
--- a/vortex-python/src/scalar/factory.rs
+++ b/vortex-python/src/scalar/factory.rs
@@ -151,12 +151,14 @@ fn scalar_helper_inner(value: &Bound<'_, PyAny>, dtype: Option<&DType>) -> PyRes
                 )));
             }
 
+            let children: Vec<Scalar> = dict
+                .values()
+                .into_iter()
+                .map(|item| scalar_helper_inner(&item, None))
+                .try_collect()?;
             return Ok(Scalar::struct_(
                 DType::Struct(dtype.clone(), *nullability),
-                dict.values()
-                    .into_iter()
-                    .map(|item| scalar_helper_inner(&item, None))
-                    .try_collect()?,
+                children,
             ));
         } else {
             let values: Vec<Scalar> = dict
@@ -181,7 +183,11 @@ fn scalar_helper_inner(value: &Bound<'_, PyAny>, dtype: Option<&DType>) -> PyRes
                 .iter()
                 .map(|e| scalar_helper_inner(&e, Some(element_dtype)))
                 .try_collect()?;
-            Scalar::list(element_dtype.clone(), elements, Nullability::NonNullable);
+            Scalar::list(
+                Arc::clone(element_dtype),
+                elements,
+                Nullability::NonNullable,
+            );
         } else {
             // If no dtype was provided, we need to infer the element dtype from the list contents.
             // We do this in a greedy way taking the first element dtype we find.
diff --git a/vortex-python/src/scalar/into_py.rs b/vortex-python/src/scalar/into_py.rs
index 70a890821ff..6e2f7124f24 100644
--- a/vortex-python/src/scalar/into_py.rs
+++ b/vortex-python/src/scalar/into_py.rs
@@ -9,6 +9,7 @@ use pyo3::PyAny;
 use pyo3::PyErr;
 use pyo3::PyResult;
 use pyo3::Python;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::PyAnyMethods;
 use pyo3::prelude::PyDictMethods;
 use pyo3::types::PyBytes;
@@ -30,6 +31,7 @@ use vortex::scalar::Scalar;
 use vortex::scalar::StructScalar;
 
 use crate::PyVortex;
+use crate::classes::decimal_class;
 
 impl<'py> IntoPyObject<'py> for PyVortex<&'_ Scalar> {
     type Target = PyAny;
@@ -85,6 +87,9 @@ impl<'py> IntoPyObject<'py> for PyVortex<&'_ Scalar> {
             DType::Extension(_) => {
                 PyVortex(&self.0.as_extension().to_storage_scalar()).into_pyobject(py)
             }
+            DType::Variant(_) => Err(PyValueError::new_err(
+                "Variant scalars are not supported in Python yet",
+            )),
         }
     }
 }
@@ -200,8 +205,7 @@ fn decimal_value_to_py(
     scale: i8,
     decimal_value: DecimalValue,
 ) -> PyResult<Bound<PyAny>> {
-    let m = py.import("decimal")?;
-    let decimal_class = m.getattr("Decimal")?;
+    let decimal_class = decimal_class(py)?;
 
     match_each_decimal_value!(decimal_value, |value| {
         let (whole, decimal) = value.decimal_parts(scale);
diff --git a/vortex-python/src/scalar/mod.rs b/vortex-python/src/scalar/mod.rs
index d6c18d64ea5..7500ae0f592 100644
--- a/vortex-python/src/scalar/mod.rs
+++ b/vortex-python/src/scalar/mod.rs
@@ -20,6 +20,7 @@ mod struct_;
 mod utf8;
 
 use pyo3::PyClass;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use vortex::dtype::DType;
 use vortex::error::VortexError;
@@ -62,7 +63,15 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
 }
 
 /// Base class for Vortex scalar types.
-#[pyclass(name = "Scalar", module = "vortex", subclass, frozen, eq, hash)]
+#[pyclass(
+    name = "Scalar",
+    module = "vortex",
+    subclass,
+    frozen,
+    eq,
+    hash,
+    from_py_object
+)]
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct PyScalar(Scalar);
 
@@ -109,6 +118,9 @@ impl PyScalar {
                 Self::with_subclass(py, scalar, PyListScalar)
             }
             DType::Extension(..) => Self::with_subclass(py, scalar, PyExtensionScalar),
+            DType::Variant(_) => Err(PyValueError::new_err(
+                "Variant scalars are not supported in Python yet",
+            )),
         }
     }
 
diff --git a/vortex-python/src/scan.rs b/vortex-python/src/scan.rs
index a3bb84f74c1..11773588add 100644
--- a/vortex-python/src/scan.rs
+++ b/vortex-python/src/scan.rs
@@ -3,9 +3,8 @@
 
 use pyo3::exceptions::PyIndexError;
 use pyo3::prelude::*;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
-use vortex::scan::RepeatedScan;
+use vortex::layout::scan::repeated_scan::RepeatedScan;
 
 use crate::RUNTIME;
 use crate::error::PyVortexResult;
diff --git a/vortex-python/src/serde/context.rs b/vortex-python/src/serde/context.rs
index a31c22b83c4..6a4f6d5d3a2 100644
--- a/vortex-python/src/serde/context.rs
+++ b/vortex-python/src/serde/context.rs
@@ -2,11 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::ops::Deref;
+use std::sync::Arc;
 
 use itertools::Itertools;
 use pyo3::pyclass;
 use pyo3::pymethods;
 use vortex::array::ArrayContext;
+use vortex::session::registry::Id;
+use vortex::session::registry::ReadContext;
 
 /// An ArrayContext captures an ordered set of encodings.
 ///
@@ -44,3 +47,44 @@ impl PyArrayContext {
         self.to_ids().len()
     }
 }
+
+/// A ReadContext captures an ordered set of encodings.
+///
+/// In a serialized array, encodings are identified by a positional index into such an
+/// :class:`~vortex.ReadContext`.
+#[pyclass(name = "ReadContext", module = "vortex", frozen)]
+pub(crate) struct PyReadContext(ReadContext);
+
+impl From<ReadContext> for PyReadContext {
+    fn from(context: ReadContext) -> Self {
+        Self(context)
+    }
+}
+
+impl Deref for PyReadContext {
+    type Target = ReadContext;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[pymethods]
+impl PyReadContext {
+    #[new]
+    fn new(ids: Vec<String>) -> Self {
+        Self(ReadContext::new(
+            ids.into_iter()
+                .map(|i| Id::new_arc(Arc::from(i)))
+                .collect::<Arc<_>>(),
+        ))
+    }
+
+    fn __str__(&self) -> String {
+        self.0.ids().iter().join(", ")
+    }
+
+    fn __len__(&self) -> usize {
+        self.ids().len()
+    }
+}
diff --git a/vortex-python/src/serde/mod.rs b/vortex-python/src/serde/mod.rs
index 0c6587966c8..c4e4cc95948 100644
--- a/vortex-python/src/serde/mod.rs
+++ b/vortex-python/src/serde/mod.rs
@@ -20,7 +20,8 @@ use crate::arrays::PyArrayRef;
 use crate::error::PyVortexResult;
 use crate::install_module;
 use crate::serde::context::PyArrayContext;
-use crate::serde::parts::PyArrayParts;
+use crate::serde::context::PyReadContext;
+use crate::serde::parts::PySerializedArray;
 
 /// Register serde functions and classes.
 pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
@@ -28,8 +29,9 @@ pub(crate) fn init(py: Python, parent: &Bound<PyModule>) -> PyResult<()> {
     parent.add_submodule(&m)?;
     install_module("vortex._lib.serde", &m)?;
 
-    m.add_class::<PyArrayParts>()?;
+    m.add_class::<PySerializedArray>()?;
     m.add_class::<PyArrayContext>()?;
+    m.add_class::<PyReadContext>()?;
     m.add_function(wrap_pyfunction!(decode_ipc_array, &m)?)?;
     m.add_function(wrap_pyfunction!(decode_ipc_array_buffers, &m)?)?;
 
diff --git a/vortex-python/src/serde/parts.rs b/vortex-python/src/serde/parts.rs
index 68c3c51344f..e05a6b6d1ac 100644
--- a/vortex-python/src/serde/parts.rs
+++ b/vortex-python/src/serde/parts.rs
@@ -7,46 +7,47 @@ use pyo3::Bound;
 use pyo3::PyAny;
 use pyo3::PyRef;
 use pyo3::Python;
+use pyo3::intern;
 use pyo3::prelude::PyAnyMethods;
 use pyo3::pyclass;
 use pyo3::pymethods;
-use vortex::array::serde::ArrayParts;
+use vortex::array::serde::SerializedArray;
 use vortex::buffer::ByteBuffer;
 
 use crate::SESSION;
 use crate::arrays::PyArrayRef;
 use crate::dtype::PyDType;
 use crate::error::PyVortexResult;
-use crate::serde::context::PyArrayContext;
+use crate::serde::context::PyReadContext;
 
-/// ArrayParts is a parsed representation of a serialized array.
+/// SerializedArray is a parsed representation of a serialized array.
 ///
 /// It can be decoded into a full array using the `decode` method.
-#[pyclass(name = "ArrayParts", module = "vortex", frozen)]
-pub(crate) struct PyArrayParts(ArrayParts);
+#[pyclass(name = "SerializedArray", module = "vortex", frozen)]
+pub(crate) struct PySerializedArray(SerializedArray);
 
-impl Deref for PyArrayParts {
-    type Target = ArrayParts;
+impl Deref for PySerializedArray {
+    type Target = SerializedArray;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl From<ArrayParts> for PyArrayParts {
-    fn from(parts: ArrayParts) -> Self {
+impl From<SerializedArray> for PySerializedArray {
+    fn from(parts: SerializedArray) -> Self {
         Self(parts)
     }
 }
 
 #[pymethods]
-impl PyArrayParts {
+impl PySerializedArray {
     /// Parse a serialized array into its parts.
     #[staticmethod]
-    fn parse(data: &[u8]) -> PyVortexResult<PyArrayParts> {
+    fn parse(data: &[u8]) -> PyVortexResult<PySerializedArray> {
         // TODO(ngates): create a buffer from a slice of bytes?
         let buffer = ByteBuffer::copy_from(data);
-        Ok(PyArrayParts(ArrayParts::try_from(buffer)?))
+        Ok(PySerializedArray(SerializedArray::try_from(buffer)?))
     }
 
     /// Decode the array parts into a full array.
@@ -56,7 +57,7 @@ impl PyArrayParts {
     /// The decoded array.
     fn decode(
         &self,
-        ctx: &PyArrayContext,
+        ctx: &PyReadContext,
         dtype: PyDType,
         len: usize,
     ) -> PyVortexResult<PyArrayRef> {
@@ -100,7 +101,8 @@ impl PyArrayParts {
             let addr = buffer.as_ptr() as usize;
             let size = buffer.len();
             let base = &slf;
-            let pa_buffer = pyarrow.call_method("foreign_buffer", (addr, size, base), None)?;
+            let pa_buffer =
+                pyarrow.call_method(intern!(py, "foreign_buffer"), (addr, size, base), None)?;
             buffers.push(pa_buffer);
         }
 
@@ -113,12 +115,12 @@ impl PyArrayParts {
         self.0.nchildren()
     }
 
-    /// Return the child :class:`~vortex.ArrayParts` of the array.
+    /// Return the child :class:`~vortex.SerializedArray` of the array.
     #[getter]
-    fn children(&self) -> Vec<PyArrayParts> {
+    fn children(&self) -> Vec<PySerializedArray> {
         (0..self.0.nchildren())
             .map(|idx| self.0.child(idx))
-            .map(PyArrayParts)
+            .map(PySerializedArray)
             .collect()
     }
 }
diff --git a/vortex-python/test/test_dataset.py b/vortex-python/test/test_dataset.py
index b3bcd8c4fcd..5699095c557 100644
--- a/vortex-python/test/test_dataset.py
+++ b/vortex-python/test/test_dataset.py
@@ -3,6 +3,7 @@
 
 import math
 import os
+from pathlib import Path
 
 import duckdb
 import polars
@@ -109,7 +110,6 @@ def test_to_record_batch_reader_with_polars(ds: pd.Dataset):
 
 
 def test_filter(ds: vx.dataset.VortexDataset):
-
     tbl = ds.to_table(filter=(pc.field("string") >= "950000") & (pc.field("float") < 975.0))
     assert len(tbl) == 6176
 
@@ -129,6 +129,25 @@ def test_filter(ds: vx.dataset.VortexDataset):
     assert len(tbl) == 20
 
 
+def test_filter_with_nested_null_dtype(tmp_path: Path):
+    path = tmp_path / "test.vortex"
+
+    batch = pa.RecordBatch.from_pylist(
+        [
+            {"a": 0, "b": {"x": None}},
+            {"a": 1, "b": {"x": None}},
+        ]
+    )
+
+    arr = vx.array(batch.to_struct_array())
+    vx.io.write(vx.ArrayIterator.from_iter(arr.dtype, iter([arr])), str(path))
+
+    dataset = vx.open(str(path)).to_dataset()
+    actual = dataset.to_table(filter=pc.field("a") == 0)
+
+    assert actual.to_pylist() == [{"a": 0, "b": {"x": None}}]
+
+
 def test_duckdb(ds: vx.dataset.VortexDataset):
     assert ds  # pyright cannot determine that ds is used by duckdb.execute
 
diff --git a/vortex-python/test/test_expression.py b/vortex-python/test/test_expression.py
index cf4177558c6..3d15d1daaa8 100644
--- a/vortex-python/test/test_expression.py
+++ b/vortex-python/test/test_expression.py
@@ -3,11 +3,37 @@
 
 # Tests the _schema_for_substrait workaround in vortex/arrow/expression.py
 
+from typing import TYPE_CHECKING, Literal, TypeAlias
+
 import pyarrow as pa
 import pyarrow.compute as pc
 import pytest
 from vortex.arrow.expression import _schema_for_substrait, arrow_to_vortex  # pyright: ignore[reportPrivateUsage]
 
+import vortex as vx
+import vortex.expr as ve
+from vortex import substrait as vx_substrait
+
+if TYPE_CHECKING:
+    from substrait.algebra_pb2 import Expression
+    from substrait.type_pb2 import Type
+else:
+    try:
+        from substrait.algebra_pb2 import Expression
+        from substrait.type_pb2 import Type
+    except ImportError:
+        from substrait.gen.proto.algebra_pb2 import Expression
+        from substrait.gen.proto.type_pb2 import Type
+
+UIntWidth: TypeAlias = Literal[8, 16, 32, 64]
+UnsignedNullCase: TypeAlias = tuple[pa.DataType, UIntWidth]
+UNSIGNED_NULL_CASES: list[UnsignedNullCase] = [
+    (pa.uint8(), 8),
+    (pa.uint16(), 16),
+    (pa.uint32(), 32),
+    (pa.uint64(), 64),
+]
+
 
 class TestSchemaForSubstrait:
     """Verifies mapping: string_view=>string, binary_view=>binary, else unchanged"""
@@ -100,3 +126,29 @@ def test_view_types_parametrized(self, view_type, value):  # pyright: ignore[rep
         expr = pc.field("col") == value  # pyright: ignore[reportUnknownVariableType]
         vortex_expr = arrow_to_vortex(expr, schema)  # pyright: ignore[reportUnknownArgumentType]
         assert vortex_expr is not None
+
+    def test_null_literal_expression(self):
+        schema = pa.schema([("id", pa.int64())])
+        expr = pc.field("id") == pa.scalar(None, type=pa.int64())
+        vortex_expr = arrow_to_vortex(expr, schema)
+        assert vortex_expr is not None
+
+    @pytest.mark.parametrize(("arrow_type", "width"), UNSIGNED_NULL_CASES)
+    def test_unsigned_null_literal_expression(self, arrow_type: pa.DataType, width: UIntWidth):
+        schema = pa.schema([("u", arrow_type)])
+        expr = pc.field("u") == pa.scalar(None, type=arrow_type)
+
+        actual = arrow_to_vortex(expr, schema)
+        expected = ve.column("u") == ve.literal(vx.uint(width, nullable=True), None)
+
+        assert str(actual) == str(expected)
+
+
+def test_substrait_typed_null_literal():
+    literal: Expression.Literal = Expression.Literal()
+    literal.null.i64.nullability = Type.NULLABILITY_NULLABLE
+
+    actual = vx_substrait.literal(literal)
+    expected = ve.literal(vx.int_(64, nullable=True), None)
+
+    assert str(actual) == str(expected)
diff --git a/vortex-python/test/test_pyarray.py b/vortex-python/test/test_pyarray.py
index 5713ff669f0..f29ca41408f 100644
--- a/vortex-python/test/test_pyarray.py
+++ b/vortex-python/test/test_pyarray.py
@@ -91,7 +91,7 @@ def encode(cls, array: pa.Array[pa.Scalar[pa.DataType]], config: ChunkConfig | N
 
     @override
     @classmethod
-    def decode(cls, parts: vx.ArrayParts, ctx: vx.ArrayContext, dtype: vx.DType, len: int) -> vx.Array:
+    def decode(cls, parts: vx.SerializedArray, ctx: vx.ArrayContext, dtype: vx.DType, len: int) -> vx.Array:
         """Decode the serialized array parts into an array."""
         assert pco
         raise NotImplementedError
diff --git a/vortex-scan/Cargo.toml b/vortex-scan/Cargo.toml
index 71822117df5..e43b8292e23 100644
--- a/vortex-scan/Cargo.toml
+++ b/vortex-scan/Cargo.toml
@@ -17,28 +17,16 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-arrow-array = { workspace = true }
-arrow-schema = { workspace = true }
 vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-error = { workspace = true }
-vortex-io = { workspace = true }
-vortex-layout = { workspace = true }
 vortex-mask = { workspace = true }
-vortex-metrics = { workspace = true }
 vortex-session = { workspace = true }
 
 async-trait = { workspace = true }
-bit-vec = { workspace = true }
 futures = { workspace = true }
-itertools = { workspace = true }
-parking_lot = { workspace = true }
 roaring = { workspace = true }
-sketches-ddsketch = { workspace = true }
 tracing = { workspace = true }
 
-[dev-dependencies]
-vortex-layout = { workspace = true, features = ["_test-harness"] }
-
 [lints]
 workspace = true
diff --git a/vortex-scan/public-api.lock b/vortex-scan/public-api.lock
index 4232ae1994c..2748e5cc037 100644
--- a/vortex-scan/public-api.lock
+++ b/vortex-scan/public-api.lock
@@ -1,319 +1,131 @@
 pub mod vortex_scan
 
-pub mod vortex_scan::api
-
-pub struct vortex_scan::api::ScanRequest
-
-pub vortex_scan::api::ScanRequest::filter: core::option::Option<vortex_array::expr::expression::Expression>
-
-pub vortex_scan::api::ScanRequest::limit: core::option::Option<u64>
-
-pub vortex_scan::api::ScanRequest::ordered: bool
-
-pub vortex_scan::api::ScanRequest::projection: vortex_array::expr::expression::Expression
-
-pub vortex_scan::api::ScanRequest::row_range: core::option::Option<core::ops::range::Range<u64>>
-
-pub vortex_scan::api::ScanRequest::selection: vortex_scan::Selection
-
-impl core::clone::Clone for vortex_scan::api::ScanRequest
-
-pub fn vortex_scan::api::ScanRequest::clone(&self) -> vortex_scan::api::ScanRequest
-
-impl core::default::Default for vortex_scan::api::ScanRequest
-
-pub fn vortex_scan::api::ScanRequest::default() -> Self
-
-impl core::fmt::Debug for vortex_scan::api::ScanRequest
-
-pub fn vortex_scan::api::ScanRequest::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-
-pub trait vortex_scan::api::DataSource: 'static + core::marker::Send + core::marker::Sync
-
-pub fn vortex_scan::api::DataSource::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::api::DataSource::deserialize_partition(&self, data: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::PartitionRef>
-
-pub fn vortex_scan::api::DataSource::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::api::DataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub fn vortex_scan::api::DataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::api::DataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::api::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-pub fn vortex_scan::api::DataSource::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
-impl vortex_scan::api::DataSource for vortex_scan::layout::LayoutReaderDataSource
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::PartitionRef>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::api::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-impl vortex_scan::api::DataSource for vortex_scan::multi::MultiLayoutDataSource
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::PartitionRef>
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::api::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-pub trait vortex_scan::api::DataSourceOpener: 'static
-
-pub fn vortex_scan::api::DataSourceOpener::open<'life0, 'life1, 'async_trait>(&'life0 self, uri: alloc::string::String, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub trait vortex_scan::api::DataSourceRemote: 'static
-
-pub fn vortex_scan::api::DataSourceRemote::deserialize_data_source(&self, data: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::DataSourceRef>
-
-pub trait vortex_scan::api::DataSourceScan: 'static + core::marker::Send
-
-pub fn vortex_scan::api::DataSourceScan::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::api::DataSourceScan::partition_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<usize>>
-
-pub fn vortex_scan::api::DataSourceScan::partitions(self: alloc::boxed::Box<Self>) -> vortex_scan::api::PartitionStream
-
-pub trait vortex_scan::api::Partition: 'static + core::marker::Send
-
-pub fn vortex_scan::api::Partition::as_any(&self) -> &dyn core::any::Any
-
-pub fn vortex_scan::api::Partition::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::api::Partition::execute(self: alloc::boxed::Box<Self>) -> vortex_error::VortexResult<vortex_array::stream::SendableArrayStream>
-
-pub fn vortex_scan::api::Partition::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::api::Partition::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
-pub type vortex_scan::api::DataSourceRef = alloc::sync::Arc<dyn vortex_scan::api::DataSource>
-
-pub type vortex_scan::api::DataSourceScanRef = alloc::boxed::Box<dyn vortex_scan::api::DataSourceScan>
-
-pub type vortex_scan::api::PartitionRef = alloc::boxed::Box<dyn vortex_scan::api::Partition>
-
-pub type vortex_scan::api::PartitionStream = futures_core::stream::BoxStream<'static, vortex_error::VortexResult<vortex_scan::api::PartitionRef>>
-
-pub mod vortex_scan::arrow
-
-pub struct vortex_scan::arrow::RecordBatchIteratorAdapter<I>
-
-impl<I> vortex_scan::arrow::RecordBatchIteratorAdapter<I>
-
-pub fn vortex_scan::arrow::RecordBatchIteratorAdapter<I>::new(iter: I, schema: arrow_schema::schema::SchemaRef) -> Self
-
-impl<I: core::clone::Clone> core::clone::Clone for vortex_scan::arrow::RecordBatchIteratorAdapter<I>
-
-pub fn vortex_scan::arrow::RecordBatchIteratorAdapter<I>::clone(&self) -> vortex_scan::arrow::RecordBatchIteratorAdapter<I>
-
-impl<I> arrow_array::record_batch::RecordBatchReader for vortex_scan::arrow::RecordBatchIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>>
-
-pub fn vortex_scan::arrow::RecordBatchIteratorAdapter<I>::schema(&self) -> arrow_schema::schema::SchemaRef
-
-impl<I> core::iter::traits::iterator::Iterator for vortex_scan::arrow::RecordBatchIteratorAdapter<I> where I: core::iter::traits::iterator::Iterator<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>>
-
-pub type vortex_scan::arrow::RecordBatchIteratorAdapter<I>::Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>
-
-pub fn vortex_scan::arrow::RecordBatchIteratorAdapter<I>::next(&mut self) -> core::option::Option<Self::Item>
-
-pub mod vortex_scan::layout
-
-pub struct vortex_scan::layout::LayoutReaderDataSource
-
-impl vortex_scan::layout::LayoutReaderDataSource
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::new(reader: vortex_layout::reader::LayoutReaderRef, session: vortex_session::VortexSession) -> Self
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::with_metrics_registry(self, metrics: alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>) -> Self
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::with_some_metrics_registry(self, metrics: core::option::Option<alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>>) -> Self
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::with_split_max_row_count(self, row_count: u64) -> Self
-
-impl vortex_scan::api::DataSource for vortex_scan::layout::LayoutReaderDataSource
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::PartitionRef>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::layout::LayoutReaderDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::api::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-pub mod vortex_scan::multi
-
-pub struct vortex_scan::multi::MultiLayoutDataSource
-
-impl vortex_scan::multi::MultiLayoutDataSource
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::new_deferred(dtype: vortex_array::dtype::DType, factories: alloc::vec::Vec<alloc::sync::Arc<dyn vortex_scan::multi::LayoutReaderFactory>>, session: &vortex_session::VortexSession) -> Self
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::new_with_first(first: vortex_layout::reader::LayoutReaderRef, remaining: alloc::vec::Vec<alloc::sync::Arc<dyn vortex_scan::multi::LayoutReaderFactory>>, session: &vortex_session::VortexSession) -> Self
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::with_concurrency(self, concurrency: usize) -> Self
-
-impl vortex_scan::api::DataSource for vortex_scan::multi::MultiLayoutDataSource
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::deserialize_partition(&self, _data: &[u8], _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::api::PartitionRef>
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::dtype(&self) -> &vortex_array::dtype::DType
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, _field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
-
-pub fn vortex_scan::multi::MultiLayoutDataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::api::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::api::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
-pub trait vortex_scan::multi::LayoutReaderFactory: 'static + core::marker::Send + core::marker::Sync
-
-pub fn vortex_scan::multi::LayoutReaderFactory::open<'life0, 'async_trait>(&'life0 self) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<core::option::Option<vortex_layout::reader::LayoutReaderRef>>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
-
 pub mod vortex_scan::row_mask
 
-pub enum vortex_scan::Selection
-
-pub vortex_scan::Selection::All
-
-pub vortex_scan::Selection::ExcludeByIndex(vortex_buffer::buffer::Buffer<u64>)
+pub struct vortex_scan::row_mask::RowMask
 
-pub vortex_scan::Selection::ExcludeRoaring(roaring::treemap::RoaringTreemap)
+impl vortex_scan::row_mask::RowMask
 
-pub vortex_scan::Selection::IncludeByIndex(vortex_buffer::buffer::Buffer<u64>)
+pub fn vortex_scan::row_mask::RowMask::mask(&self) -> &vortex_mask::Mask
 
-pub vortex_scan::Selection::IncludeRoaring(roaring::treemap::RoaringTreemap)
+pub fn vortex_scan::row_mask::RowMask::new(row_offset: u64, mask: vortex_mask::Mask) -> Self
 
-impl vortex_scan::Selection
+pub fn vortex_scan::row_mask::RowMask::row_range(&self) -> core::ops::range::Range<u64>
 
-pub fn vortex_scan::Selection::row_count(&self, total_rows: u64) -> u64
+impl core::clone::Clone for vortex_scan::row_mask::RowMask
 
-impl core::clone::Clone for vortex_scan::Selection
+pub fn vortex_scan::row_mask::RowMask::clone(&self) -> vortex_scan::row_mask::RowMask
 
-pub fn vortex_scan::Selection::clone(&self) -> vortex_scan::Selection
+impl core::fmt::Debug for vortex_scan::row_mask::RowMask
 
-impl core::default::Default for vortex_scan::Selection
+pub fn vortex_scan::row_mask::RowMask::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_scan::Selection::default() -> vortex_scan::Selection
+pub mod vortex_scan::selection
 
-impl core::fmt::Debug for vortex_scan::Selection
+pub enum vortex_scan::selection::Selection
 
-pub fn vortex_scan::Selection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub vortex_scan::selection::Selection::All
 
-pub enum vortex_scan::SplitBy
+pub vortex_scan::selection::Selection::ExcludeByIndex(vortex_buffer::buffer::Buffer<u64>)
 
-pub vortex_scan::SplitBy::Layout
+pub vortex_scan::selection::Selection::ExcludeRoaring(roaring::treemap::RoaringTreemap)
 
-pub vortex_scan::SplitBy::RowCount(usize)
+pub vortex_scan::selection::Selection::IncludeByIndex(vortex_buffer::buffer::Buffer<u64>)
 
-impl vortex_scan::SplitBy
+pub vortex_scan::selection::Selection::IncludeRoaring(roaring::treemap::RoaringTreemap)
 
-pub fn vortex_scan::SplitBy::splits(&self, layout_reader: &dyn vortex_layout::reader::LayoutReader, row_range: &core::ops::range::Range<u64>, field_mask: &[vortex_array::dtype::field_mask::FieldMask]) -> vortex_error::VortexResult<alloc::collections::btree::set::BTreeSet<u64>>
+impl vortex_scan::selection::Selection
 
-impl core::clone::Clone for vortex_scan::SplitBy
+pub fn vortex_scan::selection::Selection::row_count(&self, total_rows: u64) -> u64
 
-pub fn vortex_scan::SplitBy::clone(&self) -> vortex_scan::SplitBy
+pub fn vortex_scan::selection::Selection::row_mask(&self, range: &core::ops::range::Range<u64>) -> vortex_scan::row_mask::RowMask
 
-impl core::default::Default for vortex_scan::SplitBy
+impl core::clone::Clone for vortex_scan::selection::Selection
 
-pub fn vortex_scan::SplitBy::default() -> vortex_scan::SplitBy
+pub fn vortex_scan::selection::Selection::clone(&self) -> vortex_scan::selection::Selection
 
-impl core::fmt::Debug for vortex_scan::SplitBy
+impl core::default::Default for vortex_scan::selection::Selection
 
-pub fn vortex_scan::SplitBy::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn vortex_scan::selection::Selection::default() -> vortex_scan::selection::Selection
 
-impl core::marker::Copy for vortex_scan::SplitBy
+impl core::fmt::Debug for vortex_scan::selection::Selection
 
-pub struct vortex_scan::RepeatedScan<A: 'static + core::marker::Send>
+pub fn vortex_scan::selection::Selection::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-impl vortex_scan::RepeatedScan<vortex_array::array::ArrayRef>
+pub struct vortex_scan::ScanRequest
 
-pub fn vortex_scan::RepeatedScan<vortex_array::array::ArrayRef>::dtype(&self) -> &vortex_array::dtype::DType
+pub vortex_scan::ScanRequest::filter: core::option::Option<vortex_array::expr::expression::Expression>
 
-pub fn vortex_scan::RepeatedScan<vortex_array::array::ArrayRef>::execute_array_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(&self, row_range: core::option::Option<core::ops::range::Range<u64>>, runtime: &B) -> vortex_error::VortexResult<impl vortex_array::iter::ArrayIterator + 'static>
+pub vortex_scan::ScanRequest::limit: core::option::Option<u64>
 
-pub fn vortex_scan::RepeatedScan<vortex_array::array::ArrayRef>::execute_array_stream(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<impl vortex_array::stream::ArrayStream + core::marker::Send + 'static>
+pub vortex_scan::ScanRequest::ordered: bool
 
-impl<A: 'static + core::marker::Send> vortex_scan::RepeatedScan<A>
+pub vortex_scan::ScanRequest::projection: vortex_array::expr::expression::Expression
 
-pub fn vortex_scan::RepeatedScan<A>::execute(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<alloc::vec::Vec<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<core::option::Option<A>>>>>
+pub vortex_scan::ScanRequest::row_range: core::option::Option<core::ops::range::Range<u64>>
 
-pub fn vortex_scan::RepeatedScan<A>::execute_stream(&self, row_range: core::option::Option<core::ops::range::Range<u64>>) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = vortex_error::VortexResult<A>> + core::marker::Send + 'static + use<A>>
+pub vortex_scan::ScanRequest::selection: vortex_scan::selection::Selection
 
-pub struct vortex_scan::ScanBuilder<A>
+impl core::clone::Clone for vortex_scan::ScanRequest
 
-impl vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>
+pub fn vortex_scan::ScanRequest::clone(&self) -> vortex_scan::ScanRequest
 
-pub fn vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>::into_array_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(self, runtime: &B) -> vortex_error::VortexResult<impl vortex_array::iter::ArrayIterator + 'static>
+impl core::default::Default for vortex_scan::ScanRequest
 
-pub fn vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>::into_array_stream(self) -> vortex_error::VortexResult<impl vortex_array::stream::ArrayStream + core::marker::Send + 'static>
+pub fn vortex_scan::ScanRequest::default() -> Self
 
-pub fn vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>::new(session: vortex_session::VortexSession, layout_reader: alloc::sync::Arc<dyn vortex_layout::reader::LayoutReader>) -> Self
+impl core::fmt::Debug for vortex_scan::ScanRequest
 
-impl vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>
+pub fn vortex_scan::ScanRequest::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
-pub fn vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>::into_record_batch_reader<B: vortex_io::runtime::blocking::BlockingRuntime>(self, schema: arrow_schema::schema::SchemaRef, runtime: &B) -> vortex_error::VortexResult<impl arrow_array::record_batch::RecordBatchReader + 'static>
+pub trait vortex_scan::DataSource: 'static + core::marker::Send + core::marker::Sync
 
-pub fn vortex_scan::ScanBuilder<vortex_array::array::ArrayRef>::into_record_batch_stream(self, schema: arrow_schema::schema::SchemaRef) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = core::result::Result<arrow_array::record_batch::RecordBatch, arrow_schema::error::ArrowError>> + core::marker::Send + 'static>
+pub fn vortex_scan::DataSource::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
 
-impl<A: 'static + core::marker::Send> vortex_scan::ScanBuilder<A>
+pub fn vortex_scan::DataSource::deserialize_partition(&self, data: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::PartitionRef>
 
-pub fn vortex_scan::ScanBuilder<A>::build(self) -> vortex_error::VortexResult<alloc::vec::Vec<futures_core::future::BoxFuture<'static, vortex_error::VortexResult<core::option::Option<A>>>>>
+pub fn vortex_scan::DataSource::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_scan::ScanBuilder<A>::concurrency(&self) -> usize
+pub fn vortex_scan::DataSource::field_statistics<'life0, 'life1, 'async_trait>(&'life0 self, field_path: &'life1 vortex_array::dtype::field::FieldPath) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_array::stats::stats_set::StatsSet>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
-pub fn vortex_scan::ScanBuilder<A>::dtype(&self) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+pub fn vortex_scan::DataSource::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
 
-pub fn vortex_scan::ScanBuilder<A>::into_iter<B: vortex_io::runtime::blocking::BlockingRuntime>(self, runtime: &B) -> vortex_error::VortexResult<impl core::iter::traits::iterator::Iterator<Item = vortex_error::VortexResult<A>> + 'static>
+pub fn vortex_scan::DataSource::scan<'life0, 'async_trait>(&'life0 self, scan_request: vortex_scan::ScanRequest) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::DataSourceScanRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait
 
-pub fn vortex_scan::ScanBuilder<A>::into_stream(self) -> vortex_error::VortexResult<impl futures_core::stream::Stream<Item = vortex_error::VortexResult<A>> + core::marker::Send + 'static + use<A>>
+pub fn vortex_scan::DataSource::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_scan::ScanBuilder<A>::map<B: 'static>(self, map_fn: impl core::ops::function::Fn(A) -> vortex_error::VortexResult<B> + 'static + core::marker::Send + core::marker::Sync) -> vortex_scan::ScanBuilder<B>
+pub trait vortex_scan::DataSourceOpener: 'static
 
-pub fn vortex_scan::ScanBuilder<A>::ordered(&self) -> bool
+pub fn vortex_scan::DataSourceOpener::open<'life0, 'life1, 'async_trait>(&'life0 self, uri: alloc::string::String, session: &'life1 vortex_session::VortexSession) -> core::pin::Pin<alloc::boxed::Box<(dyn core::future::future::Future<Output = vortex_error::VortexResult<vortex_scan::DataSourceRef>> + core::marker::Send + 'async_trait)>> where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait
 
-pub fn vortex_scan::ScanBuilder<A>::prepare(self) -> vortex_error::VortexResult<vortex_scan::RepeatedScan<A>>
+pub trait vortex_scan::DataSourceRemote: 'static
 
-pub fn vortex_scan::ScanBuilder<A>::session(&self) -> &vortex_session::VortexSession
+pub fn vortex_scan::DataSourceRemote::deserialize_data_source(&self, data: &[u8], session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_scan::DataSourceRef>
 
-pub fn vortex_scan::ScanBuilder<A>::with_concurrency(self, concurrency: usize) -> Self
+pub trait vortex_scan::DataSourceScan: 'static + core::marker::Send
 
-pub fn vortex_scan::ScanBuilder<A>::with_filter(self, filter: vortex_array::expr::expression::Expression) -> Self
+pub fn vortex_scan::DataSourceScan::dtype(&self) -> &vortex_array::dtype::DType
 
-pub fn vortex_scan::ScanBuilder<A>::with_limit(self, limit: u64) -> Self
+pub fn vortex_scan::DataSourceScan::partition_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<usize>>
 
-pub fn vortex_scan::ScanBuilder<A>::with_metrics_registry(self, metrics: alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>) -> Self
+pub fn vortex_scan::DataSourceScan::partitions(self: alloc::boxed::Box<Self>) -> vortex_scan::PartitionStream
 
-pub fn vortex_scan::ScanBuilder<A>::with_ordered(self, ordered: bool) -> Self
+pub trait vortex_scan::Partition: 'static + core::marker::Send
 
-pub fn vortex_scan::ScanBuilder<A>::with_projection(self, projection: vortex_array::expr::expression::Expression) -> Self
+pub fn vortex_scan::Partition::as_any(&self) -> &dyn core::any::Any
 
-pub fn vortex_scan::ScanBuilder<A>::with_row_indices(self, row_indices: vortex_buffer::buffer::Buffer<u64>) -> Self
+pub fn vortex_scan::Partition::byte_size(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
 
-pub fn vortex_scan::ScanBuilder<A>::with_row_offset(self, row_offset: u64) -> Self
+pub fn vortex_scan::Partition::execute(self: alloc::boxed::Box<Self>) -> vortex_error::VortexResult<vortex_array::stream::SendableArrayStream>
 
-pub fn vortex_scan::ScanBuilder<A>::with_row_range(self, row_range: core::ops::range::Range<u64>) -> Self
+pub fn vortex_scan::Partition::row_count(&self) -> core::option::Option<vortex_array::expr::stats::precision::Precision<u64>>
 
-pub fn vortex_scan::ScanBuilder<A>::with_selection(self, selection: vortex_scan::Selection) -> Self
+pub fn vortex_scan::Partition::serialize(&self) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
 
-pub fn vortex_scan::ScanBuilder<A>::with_some_filter(self, filter: core::option::Option<vortex_array::expr::expression::Expression>) -> Self
+pub type vortex_scan::DataSourceRef = alloc::sync::Arc<dyn vortex_scan::DataSource>
 
-pub fn vortex_scan::ScanBuilder<A>::with_some_limit(self, limit: core::option::Option<u64>) -> Self
+pub type vortex_scan::DataSourceScanRef = alloc::boxed::Box<dyn vortex_scan::DataSourceScan>
 
-pub fn vortex_scan::ScanBuilder<A>::with_some_metrics_registry(self, metrics: core::option::Option<alloc::sync::Arc<dyn vortex_metrics::MetricsRegistry>>) -> Self
+pub type vortex_scan::PartitionRef = alloc::boxed::Box<dyn vortex_scan::Partition>
 
-pub fn vortex_scan::ScanBuilder<A>::with_split_by(self, split_by: vortex_scan::SplitBy) -> Self
+pub type vortex_scan::PartitionStream = futures_core::stream::BoxStream<'static, vortex_error::VortexResult<vortex_scan::PartitionRef>>
diff --git a/vortex-scan/src/api.rs b/vortex-scan/src/api.rs
deleted file mode 100644
index f090dd2cd79..00000000000
--- a/vortex-scan/src/api.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-#![deny(missing_docs)]
-
-//! The Vortex Scan API implements an abstract table scan interface that can be used to
-//! read data from various data sources.
-//!
-//! It supports arbitrary projection expressions, filter expressions, and limit pushdown as well
-//! as mechanisms for parallel and distributed execution via partitions.
-//!
-//! The API is currently under development and may change in future releases, however we hope to
-//! stabilize into stable C ABI for use within foreign language bindings.
-//!
-//! ## Open Issues
-//!
-//! * We probably want to make the DataSource serializable as well, so that we can share
-//!   source-level state with workers, separately from partition serialization.
-//! * We should add a way for the client to negotiate capabilities with the data source, for
-//!   example which encodings it knows about.
-
-use std::any::Any;
-use std::ops::Range;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use futures::stream::BoxStream;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::FieldPath;
-use vortex_array::expr::Expression;
-use vortex_array::expr::root;
-use vortex_array::expr::stats::Precision;
-use vortex_array::stats::StatsSet;
-use vortex_array::stream::SendableArrayStream;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_session::VortexSession;
-
-use crate::Selection;
-
-/// A sendable stream of partitions.
-pub type PartitionStream = BoxStream<'static, VortexResult<PartitionRef>>;
-
-/// Opens a Vortex [`DataSource`] from a URI.
-///
-/// Configuration can be passed via the URI query parameters, similar to JDBC / ADBC.
-/// Providers can be registered with the [`VortexSession`] to support additional URI schemes.
-#[async_trait]
-pub trait DataSourceOpener: 'static {
-    /// Attempt to open a new data source from a URI.
-    async fn open(&self, uri: String, session: &VortexSession) -> VortexResult<DataSourceRef>;
-}
-
-/// Supports deserialization of a Vortex [`DataSource`] on a remote worker.
-#[async_trait]
-pub trait DataSourceRemote: 'static {
-    /// Attempt to deserialize the source.
-    fn deserialize_data_source(
-        &self,
-        data: &[u8],
-        session: &VortexSession,
-    ) -> VortexResult<DataSourceRef>;
-}
-
-/// A reference-counted data source.
-pub type DataSourceRef = Arc<dyn DataSource>;
-
-/// A data source represents a streamable dataset that can be scanned with projection and filter
-/// expressions. Each scan produces partitions that can be executed in parallel to read data. Each
-/// partition can be serialized for remote execution.
-///
-/// The DataSource may be used multiple times to create multiple scans, whereas each scan and each
-/// partition of a scan can only be consumed once.
-#[async_trait]
-pub trait DataSource: 'static + Send + Sync {
-    /// Returns the dtype of the source.
-    fn dtype(&self) -> &DType;
-
-    /// Returns an estimate of the row count of the un-filtered source.
-    fn row_count(&self) -> Option<Precision<u64>> {
-        None
-    }
-
-    /// Returns an estimate of the byte size of the un-filtered source.
-    fn byte_size(&self) -> Option<Precision<u64>> {
-        None
-    }
-
-    /// Serialize the [`DataSource`] to pass to a remote worker.
-    fn serialize(&self) -> VortexResult<Option<Vec<u8>>> {
-        Ok(None)
-    }
-
-    /// Deserialize a partition that was previously serialized from a compatible data source.
-    fn deserialize_partition(
-        &self,
-        data: &[u8],
-        session: &VortexSession,
-    ) -> VortexResult<PartitionRef> {
-        let _ = (data, session);
-        vortex_bail!("DataSource does not support deserialization")
-    }
-
-    /// Returns a scan over the source.
-    async fn scan(&self, scan_request: ScanRequest) -> VortexResult<DataSourceScanRef>;
-
-    /// Returns the statistics for a given field.
-    async fn field_statistics(&self, field_path: &FieldPath) -> VortexResult<StatsSet>;
-}
-
-/// A request to scan a data source.
-#[derive(Debug, Clone)]
-pub struct ScanRequest {
-    /// Projection expression. Defaults to `root()` which returns all columns.
-    pub projection: Expression,
-    /// Filter expression, `None` implies no filter.
-    pub filter: Option<Expression>,
-    /// The row range to read.
-    pub row_range: Option<Range<u64>>,
-    /// A row selection to apply to the scan. The selection identifies rows within the specified
-    /// row range.
-    pub selection: Selection,
-    /// Whether the scan should preserve row order. If false, the scan may produce rows in any
-    /// order, for example to enable parallel execution across partitions.
-    pub ordered: bool,
-    /// Optional limit on the number of rows returned by scan. Limits are applied after all
-    /// filtering and row selection.
-    pub limit: Option<u64>,
-}
-
-impl Default for ScanRequest {
-    fn default() -> Self {
-        Self {
-            projection: root(),
-            filter: None,
-            row_range: None,
-            selection: Selection::default(),
-            ordered: false,
-            limit: None,
-        }
-    }
-}
-
-/// A boxed data source scan.
-pub type DataSourceScanRef = Box<dyn DataSourceScan>;
-
-/// A data source scan produces partitions that can be executed to read data from the source.
-pub trait DataSourceScan: 'static + Send {
-    /// The returned dtype of the scan.
-    fn dtype(&self) -> &DType;
-
-    /// Returns an estimate of the total number of partitions the scan will produce.
-    fn partition_count(&self) -> Option<Precision<usize>>;
-
-    /// Returns a stream of partitions to be processed.
-    fn partitions(self: Box<Self>) -> PartitionStream;
-}
-
-/// A reference-counted partition.
-pub type PartitionRef = Box<dyn Partition>;
-
-/// A partition represents a unit of work that can be executed to produce a stream of arrays.
-pub trait Partition: 'static + Send {
-    /// Downcast the partition to a concrete type.
-    fn as_any(&self) -> &dyn Any;
-
-    /// Returns an estimate of the row count for this partition.
-    fn row_count(&self) -> Option<Precision<u64>>;
-
-    /// Returns an estimate of the byte size for this partition.
-    fn byte_size(&self) -> Option<Precision<u64>>;
-
-    /// Serialize this partition for a remote worker.
-    fn serialize(&self) -> VortexResult<Option<Vec<u8>>> {
-        Ok(None)
-    }
-
-    /// Executes the partition, returning an array stream.
-    ///
-    /// This method must be fast. The returned stream should be lazy — all non-trivial work
-    /// (I/O, decoding, filtering) must be deferred to when the stream is polled. Expensive
-    /// operations should be spawned onto the runtime to enable parallel execution across
-    /// threads.
-    fn execute(self: Box<Self>) -> VortexResult<SendableArrayStream>;
-}
diff --git a/vortex-scan/src/lib.rs b/vortex-scan/src/lib.rs
index 308ce032abf..edcb5e29979 100644
--- a/vortex-scan/src/lib.rs
+++ b/vortex-scan/src/lib.rs
@@ -1,35 +1,190 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-// TODO(ngates): this crate is being re-purposed to expose the Scan API, rather than any specific
-//  implementation of it. Much of the current code is about implementing the Scan API over a
-//  Vortex Layout tree. This should move to the vortex-layout crate.
+#![deny(missing_docs)]
 
-/// A heuristic for an ideal split size.
-///
-/// We don't actually know if this is right, but it is probably a good estimate.
-const IDEAL_SPLIT_SIZE: u64 = 100_000;
+//! The Vortex Scan API implements an abstract table scan interface that can be used to
+//! read data from various data sources.
+//!
+//! It supports arbitrary projection expressions, filter expressions, and limit pushdown as well
+//! as mechanisms for parallel and distributed execution via partitions.
+//!
+//! The API is currently under development and may change in future releases, however we hope to
+//! stabilize into stable C ABI for use within foreign language bindings.
+//!
+//! If you are looking to scan Vortex files or layouts, the Vortex implementation of the Scan API
+//! can be found in the `vortex-layout` crate.
+//!
+//! ## Open Issues
+//!
+//! * We probably want to make the DataSource serializable as well, so that we can share
+//!   source-level state with workers, separately from partition serialization.
+//! * We should add a way for the client to negotiate capabilities with the data source, for
+//!   example which encodings it knows about.
 
-pub mod api;
-pub mod arrow;
-mod filter;
 pub mod row_mask;
-mod splits;
-mod tasks;
+pub mod selection;
+
+use std::any::Any;
+use std::ops::Range;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use futures::stream::BoxStream;
+use selection::Selection;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::FieldPath;
+use vortex_array::expr::Expression;
+use vortex_array::expr::root;
+use vortex_array::expr::stats::Precision;
+use vortex_array::stats::StatsSet;
+use vortex_array::stream::SendableArrayStream;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+/// A sendable stream of partitions.
+pub type PartitionStream = BoxStream<'static, VortexResult<PartitionRef>>;
+
+/// Opens a Vortex [`DataSource`] from a URI.
+///
+/// Configuration can be passed via the URI query parameters, similar to JDBC / ADBC.
+/// Providers can be registered with the [`VortexSession`] to support additional URI schemes.
+#[async_trait]
+pub trait DataSourceOpener: 'static {
+    /// Attempt to open a new data source from a URI.
+    async fn open(&self, uri: String, session: &VortexSession) -> VortexResult<DataSourceRef>;
+}
+
+/// Supports deserialization of a Vortex [`DataSource`] on a remote worker.
+#[async_trait]
+pub trait DataSourceRemote: 'static {
+    /// Attempt to deserialize the source.
+    fn deserialize_data_source(
+        &self,
+        data: &[u8],
+        session: &VortexSession,
+    ) -> VortexResult<DataSourceRef>;
+}
+
+/// A reference-counted data source.
+pub type DataSourceRef = Arc<dyn DataSource>;
+
+/// A data source represents a streamable dataset that can be scanned with projection and filter
+/// expressions. Each scan produces partitions that can be executed in parallel to read data. Each
+/// partition can be serialized for remote execution.
+///
+/// The DataSource may be used multiple times to create multiple scans, whereas each scan and each
+/// partition of a scan can only be consumed once.
+#[async_trait]
+pub trait DataSource: 'static + Send + Sync {
+    /// Returns the dtype of the source.
+    fn dtype(&self) -> &DType;
+
+    /// Returns an estimate of the row count of the un-filtered source.
+    fn row_count(&self) -> Option<Precision<u64>> {
+        None
+    }
+
+    /// Returns an estimate of the byte size of the un-filtered source.
+    fn byte_size(&self) -> Option<Precision<u64>> {
+        None
+    }
+
+    /// Serialize the [`DataSource`] to pass to a remote worker.
+    fn serialize(&self) -> VortexResult<Option<Vec<u8>>> {
+        Ok(None)
+    }
+
+    /// Deserialize a partition that was previously serialized from a compatible data source.
+    fn deserialize_partition(
+        &self,
+        data: &[u8],
+        session: &VortexSession,
+    ) -> VortexResult<PartitionRef> {
+        let _ = (data, session);
+        vortex_bail!("DataSource does not support deserialization")
+    }
+
+    /// Returns a scan over the source.
+    async fn scan(&self, scan_request: ScanRequest) -> VortexResult<DataSourceScanRef>;
+
+    /// Returns the statistics for a given field.
+    async fn field_statistics(&self, field_path: &FieldPath) -> VortexResult<StatsSet>;
+}
+
+/// A request to scan a data source.
+#[derive(Debug, Clone)]
+pub struct ScanRequest {
+    /// Projection expression. Defaults to `root()` which returns all columns.
+    pub projection: Expression,
+    /// Filter expression, `None` implies no filter.
+    pub filter: Option<Expression>,
+    /// The row range to read.
+    pub row_range: Option<Range<u64>>,
+    /// A row selection to apply to the scan. The selection identifies rows within the specified
+    /// row range.
+    pub selection: Selection,
+    /// Whether the scan should preserve row order. If false, the scan may produce rows in any
+    /// order, for example to enable parallel execution across partitions.
+    pub ordered: bool,
+    /// Optional limit on the number of rows returned by scan. Limits are applied after all
+    /// filtering and row selection.
+    pub limit: Option<u64>,
+}
+
+impl Default for ScanRequest {
+    fn default() -> Self {
+        Self {
+            projection: root(),
+            filter: None,
+            row_range: None,
+            selection: Selection::default(),
+            ordered: false,
+            limit: None,
+        }
+    }
+}
+
+/// A boxed data source scan.
+pub type DataSourceScanRef = Box<dyn DataSourceScan>;
+
+/// A data source scan produces partitions that can be executed to read data from the source.
+pub trait DataSourceScan: 'static + Send {
+    /// The returned dtype of the scan.
+    fn dtype(&self) -> &DType;
+
+    /// Returns an estimate of the total number of partitions the scan will produce.
+    fn partition_count(&self) -> Option<Precision<usize>>;
+
+    /// Returns a stream of partitions to be processed.
+    fn partitions(self: Box<Self>) -> PartitionStream;
+}
+
+/// A reference-counted partition.
+pub type PartitionRef = Box<dyn Partition>;
 
-mod selection;
-pub use selection::Selection;
+/// A partition represents a unit of work that can be executed to produce a stream of arrays.
+pub trait Partition: 'static + Send {
+    /// Downcast the partition to a concrete type.
+    fn as_any(&self) -> &dyn Any;
 
-mod split_by;
-pub use split_by::SplitBy;
+    /// Returns an estimate of the row count for this partition.
+    fn row_count(&self) -> Option<Precision<u64>>;
 
-mod scan_builder;
-pub use scan_builder::ScanBuilder;
+    /// Returns an estimate of the byte size for this partition.
+    fn byte_size(&self) -> Option<Precision<u64>>;
 
-pub mod layout;
-pub mod multi;
-mod repeated_scan;
-#[cfg(test)]
-mod test;
+    /// Serialize this partition for a remote worker.
+    fn serialize(&self) -> VortexResult<Option<Vec<u8>>> {
+        Ok(None)
+    }
 
-pub use repeated_scan::RepeatedScan;
+    /// Executes the partition, returning an array stream.
+    ///
+    /// This method must be fast. The returned stream should be lazy — all non-trivial work
+    /// (I/O, decoding, filtering) must be deferred to when the stream is polled. Expensive
+    /// operations should be spawned onto the runtime to enable parallel execution across
+    /// threads.
+    fn execute(self: Box<Self>) -> VortexResult<SendableArrayStream>;
+}
diff --git a/vortex-scan/src/row_mask.rs b/vortex-scan/src/row_mask.rs
index fe6017c6129..8de1c906ea0 100644
--- a/vortex-scan/src/row_mask.rs
+++ b/vortex-scan/src/row_mask.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! A mask over a range of rows.
+
 use std::ops::Range;
 
 use vortex_mask::Mask;
@@ -10,12 +12,13 @@ use vortex_mask::Mask;
 /// The range itself can be [`u64`], but the length of the range must fit into a [`usize`], this
 /// allows us to use a `usize` filter mask within a much larger file.
 #[derive(Debug, Clone)]
-pub(crate) struct RowMask {
+pub struct RowMask {
     row_offset: u64,
     mask: Mask,
 }
 
 impl RowMask {
+    /// Create a new row range.
     #[inline]
     pub fn new(row_offset: u64, mask: Mask) -> Self {
         Self { row_offset, mask }
diff --git a/vortex-scan/src/selection.rs b/vortex-scan/src/selection.rs
index 356616acfd9..1374851bec0 100644
--- a/vortex-scan/src/selection.rs
+++ b/vortex-scan/src/selection.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+//! Defines a selection mask over a scan.
+
 use std::ops::Not;
 use std::ops::Range;
 
@@ -40,7 +42,7 @@ impl Selection {
     }
 
     /// Extract the [`RowMask`] for the given range from this selection.
-    pub(crate) fn row_mask(&self, range: &Range<u64>) -> RowMask {
+    pub fn row_mask(&self, range: &Range<u64>) -> RowMask {
         // Saturating subtraction to prevent underflow, though range should be valid
         let range_diff = range.end.saturating_sub(range.start);
         let range_len = usize::try_from(range_diff).unwrap_or_else(|_| {
diff --git a/vortex-session/public-api.lock b/vortex-session/public-api.lock
index 4e00c75a886..c59b40fd037 100644
--- a/vortex-session/public-api.lock
+++ b/vortex-session/public-api.lock
@@ -12,8 +12,6 @@ pub fn vortex_session::registry::Context<T>::intern(&self, id: &vortex_session::
 
 pub fn vortex_session::registry::Context<T>::new(ids: alloc::vec::Vec<vortex_session::registry::Id>) -> Self
 
-pub fn vortex_session::registry::Context<T>::resolve(&self, idx: u16) -> core::option::Option<vortex_session::registry::Id>
-
 pub fn vortex_session::registry::Context<T>::to_ids(&self) -> alloc::vec::Vec<vortex_session::registry::Id>
 
 pub fn vortex_session::registry::Context<T>::with_registry(self, registry: vortex_session::registry::Registry<T>) -> Self
@@ -30,6 +28,24 @@ impl<T> core::default::Default for vortex_session::registry::Context<T>
 
 pub fn vortex_session::registry::Context<T>::default() -> Self
 
+pub struct vortex_session::registry::ReadContext
+
+impl vortex_session::registry::ReadContext
+
+pub fn vortex_session::registry::ReadContext::ids(&self) -> &[vortex_session::registry::Id]
+
+pub fn vortex_session::registry::ReadContext::new(ids: impl core::convert::Into<alloc::sync::Arc<[vortex_session::registry::Id]>>) -> Self
+
+pub fn vortex_session::registry::ReadContext::resolve(&self, idx: u16) -> core::option::Option<vortex_session::registry::Id>
+
+impl core::clone::Clone for vortex_session::registry::ReadContext
+
+pub fn vortex_session::registry::ReadContext::clone(&self) -> vortex_session::registry::ReadContext
+
+impl core::fmt::Debug for vortex_session::registry::ReadContext
+
+pub fn vortex_session::registry::ReadContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
 pub struct vortex_session::registry::Registry<T>(_)
 
 impl<T: core::clone::Clone> vortex_session::registry::Registry<T>
@@ -94,10 +110,18 @@ pub struct vortex_session::VortexSession(_)
 
 impl vortex_session::VortexSession
 
+pub fn vortex_session::VortexSession::allow_unknown(self) -> Self
+
+pub fn vortex_session::VortexSession::allows_unknown(&self) -> bool
+
 pub fn vortex_session::VortexSession::empty() -> Self
 
+pub fn vortex_session::VortexSession::set<V: vortex_session::SessionVar>(self, val: V) -> Self
+
 pub fn vortex_session::VortexSession::with<V: vortex_session::SessionVar + core::default::Default>(self) -> Self
 
+pub fn vortex_session::VortexSession::with_some<V: vortex_session::SessionVar>(self, var: V) -> Self
+
 impl core::clone::Clone for vortex_session::VortexSession
 
 pub fn vortex_session::VortexSession::clone(&self) -> vortex_session::VortexSession
diff --git a/vortex-session/src/lib.rs b/vortex-session/src/lib.rs
index 1ab0d63fac7..2cd6e7585d0 100644
--- a/vortex-session/src/lib.rs
+++ b/vortex-session/src/lib.rs
@@ -39,6 +39,15 @@ impl VortexSession {
     ///
     /// If a variable of that type already exists.
     pub fn with<V: SessionVar + Default>(self) -> Self {
+        self.with_some(V::default())
+    }
+
+    /// Inserts a new session variable of type `V`.
+    ///
+    /// # Panics
+    ///
+    /// If a variable of that type already exists.
+    pub fn with_some<V: SessionVar>(self, var: V) -> Self {
         match self.0.entry(TypeId::of::<V>()) {
             Entry::Occupied(_) => {
                 vortex_panic!(
@@ -47,7 +56,7 @@ impl VortexSession {
                 );
             }
             Entry::Vacant(e) => {
-                e.insert(Box::new(V::default()));
+                e.insert(Box::new(var));
             }
         }
         self
@@ -59,19 +68,26 @@ impl VortexSession {
     ///
     /// If a variable of that type already exists.
     pub fn set<V: SessionVar>(self, val: V) -> Self {
-        match self.0.entry(TypeId::of::<V>()) {
-            Entry::Occupied(_) => {
-                vortex_panic!(
-                    "Session variable of type {} already exists",
-                    type_name::<V>()
-                );
-            }
-            Entry::Vacant(e) => {
-                e.insert(Box::new(val));
-            }
-        }
+        self.with_some(val)
+    }
+
+    /// Allow deserializing unknown plugin IDs as non-executable foreign placeholders.
+    pub fn allow_unknown(self) -> Self {
+        let mut policy = <Self as SessionExt>::get_mut::<UnknownPluginPolicy>(&self);
+        policy.allow_unknown = true;
+        drop(policy);
         self
     }
+
+    /// Returns whether unknown plugins should deserialize as foreign placeholders.
+    pub fn allows_unknown(&self) -> bool {
+        <Self as SessionExt>::get::<UnknownPluginPolicy>(self).allow_unknown
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+struct UnknownPluginPolicy {
+    allow_unknown: bool,
 }
 
 /// Trait for accessing and modifying the state of a Vortex session.
@@ -244,3 +260,17 @@ impl<'a, T> RefMut<'a, T> {
         RefMut(self.0.map(f))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::VortexSession;
+
+    #[test]
+    fn allow_unknown_flag_is_opt_in() {
+        let session = VortexSession::empty();
+        assert!(!session.allows_unknown());
+
+        let session = session.allow_unknown();
+        assert!(session.allows_unknown());
+    }
+}
diff --git a/vortex-session/src/registry.rs b/vortex-session/src/registry.rs
index a7ae8b5b0ad..35a65b086a3 100644
--- a/vortex-session/src/registry.rs
+++ b/vortex-session/src/registry.rs
@@ -9,7 +9,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 
 use arcref::ArcRef;
-use parking_lot::Mutex;
+use parking_lot::RwLock;
 use vortex_error::VortexExpect;
 use vortex_utils::aliases::dash_map::DashMap;
 
@@ -66,12 +66,35 @@ impl<T: Clone> Registry<T> {
     }
 }
 
+/// A [`ReadContext`] holds a set of interned IDs for use during deserialization, mapping
+/// u16 indices to IDs.
+#[derive(Clone, Debug)]
+pub struct ReadContext {
+    ids: Arc<[Id]>,
+}
+
+impl ReadContext {
+    /// Create a context with the given initial IDs.
+    pub fn new(ids: impl Into<Arc<[Id]>>) -> Self {
+        Self { ids: ids.into() }
+    }
+
+    /// Resolve an interned ID by its index.
+    pub fn resolve(&self, idx: u16) -> Option<Id> {
+        self.ids.get(idx as usize).cloned()
+    }
+
+    pub fn ids(&self) -> &[Id] {
+        &self.ids
+    }
+}
+
 /// A [`Context`] holds a set of interned IDs for use during serialization/deserialization, mapping
 /// IDs to u16 indices.
 ///
 /// ## Upcoming Changes
 ///
-/// 1. This object holds an Arc of Mutex internally because we need concurrent access from the
+/// 1. This object holds an Arc of RwLock internally because we need concurrent access from the
 ///    layout writer code path. We should update SegmentSink to take an Array rather than
 ///    ByteBuffer such that serializing arrays is done sequentially.
 /// 2. The name is terrible. `Interner<T>` is better, but I want to minimize breakage for now.
@@ -79,8 +102,8 @@ impl<T: Clone> Registry<T> {
 pub struct Context<T> {
     // TODO(ngates): it's a long story, but if we make SegmentSink and SegmentSource take an
     //  enum of Segment { Array, DType, Buffer } then we don't actually need a mutable context
-    //  in the LayoutWriter, therefore we don't need a Mutex here and everyone is happier.
-    ids: Arc<Mutex<Vec<Id>>>,
+    //  in the LayoutWriter, therefore we don't need a RwLock here and everyone is happier.
+    ids: Arc<RwLock<Vec<Id>>>,
     // Optional registry used to filter the permissible interned items.
     registry: Option<Registry<T>>,
 }
@@ -88,7 +111,7 @@ pub struct Context<T> {
 impl<T> Default for Context<T> {
     fn default() -> Self {
         Self {
-            ids: Arc::new(Mutex::new(Vec::new())),
+            ids: Arc::new(RwLock::new(Vec::new())),
             registry: None,
         }
     }
@@ -98,7 +121,7 @@ impl<T: Clone> Context<T> {
     /// Create a context with the given initial IDs.
     pub fn new(ids: Vec<Id>) -> Self {
         Self {
-            ids: Arc::new(Mutex::new(ids)),
+            ids: Arc::new(RwLock::new(ids)),
             registry: None,
         }
     }
@@ -123,7 +146,7 @@ impl<T: Clone> Context<T> {
             return None;
         }
 
-        let mut ids = self.ids.lock();
+        let mut ids = self.ids.write();
         if let Some(idx) = ids.iter().position(|e| e == id) {
             return Some(u16::try_from(idx).vortex_expect("Cannot have more than u16::MAX items"));
         }
@@ -137,13 +160,8 @@ impl<T: Clone> Context<T> {
         Some(u16::try_from(idx).vortex_expect("checked already"))
     }
 
-    /// Resolve an interned ID by its index.
-    pub fn resolve(&self, idx: u16) -> Option<Id> {
-        self.ids.lock().get(idx as usize).cloned()
-    }
-
     /// Get the list of interned IDs.
     pub fn to_ids(&self) -> Vec<Id> {
-        self.ids.lock().clone()
+        self.ids.read().clone()
     }
 }
diff --git a/vortex-sqllogictest/Cargo.toml b/vortex-sqllogictest/Cargo.toml
index 04492cb55cf..757abb49689 100644
--- a/vortex-sqllogictest/Cargo.toml
+++ b/vortex-sqllogictest/Cargo.toml
@@ -16,12 +16,14 @@ version = { workspace = true }
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+bigdecimal = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 datafusion = { workspace = true }
 datafusion-sqllogictest = { workspace = true }
 futures.workspace = true
 indicatif.workspace = true
-sqllogictest = "0.28"
+rstest = { workspace = true }
+sqllogictest = "0.29.1"
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 vortex = { workspace = true, features = ["tokio"] }
diff --git a/vortex-sqllogictest/README.md b/vortex-sqllogictest/README.md
index 9c0b74c8c91..783ce822f00 100644
--- a/vortex-sqllogictest/README.md
+++ b/vortex-sqllogictest/README.md
@@ -6,9 +6,10 @@ Different test files might run in parallel, but within the same file, the file w
 
 ## Running tests
 
-In order to run the tests, the current command is:
+In order to run the tests, you first need to generate TPC-H data (scale factor 0.1), the commands are:
 
 ```shell
+./vortex-sqllogictest/slt/tpch/generate_data.sh
 cargo test -p vortex-sqllogictest --test sqllogictests
 ```
 
diff --git a/vortex-sqllogictest/bin/sqllogictests-runner.rs b/vortex-sqllogictest/bin/sqllogictests-runner.rs
index 6efb9df3f88..d20b851677f 100644
--- a/vortex-sqllogictest/bin/sqllogictests-runner.rs
+++ b/vortex-sqllogictest/bin/sqllogictests-runner.rs
@@ -46,31 +46,42 @@ async fn main() -> anyhow::Result<()> {
 
     let crate_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
     let path = crate_path.join("slt/");
-
-    let all_errors = futures::stream::iter(list_files(path)?)
-        .map(|path| {
-            let mpb = mpb.clone();
-
-            async move {
-                let mut errors = vec![];
-                let factory = Arc::new(VortexFormatFactory::new());
-                let session_state_builder = SessionStateBuilder::new()
-                    .with_default_features()
-                    .with_table_factory(
-                        factory.get_ext().to_uppercase(),
-                        Arc::new(DefaultTableFactory::new()),
-                    )
-                    .with_file_formats(vec![factory]);
-
-                let session = SessionContext::new_with_state(session_state_builder.build())
-                    .enable_url_table();
-
-                let filename = path
-                    .file_name()
-                    .vortex_expect("must be file")
-                    .to_string_lossy();
-                let records = parse_file(path.canonicalize()?)?;
-
+    let has_tpch_data = crate_path.join("slt/tpch/data/lineitem.vortex").exists();
+
+    let all_errors = futures::stream::iter(
+        list_files(path)?
+            .into_iter()
+            .filter(|path| {
+                has_tpch_data || !path.components().any(|comp| comp.as_os_str() == "tpch")
+            })
+            .collect::<Vec<_>>(),
+    )
+    .map(|path| {
+        let mpb = mpb.clone();
+
+        async move {
+            let path = path.canonicalize()?;
+
+            let mut errors = vec![];
+            let factory = Arc::new(VortexFormatFactory::new());
+            let session_state_builder = SessionStateBuilder::new()
+                .with_default_features()
+                .with_table_factory(
+                    factory.get_ext().to_uppercase(),
+                    Arc::new(DefaultTableFactory::new()),
+                )
+                .with_file_formats(vec![factory]);
+
+            let session =
+                SessionContext::new_with_state(session_state_builder.build()).enable_url_table();
+
+            let filename = path
+                .file_name()
+                .vortex_expect("must be file")
+                .to_string_lossy();
+            let records = parse_file(path.as_path())?;
+
+            if !path.components().any(|comp| comp.as_os_str() == "duckdb") {
                 let df_pb = mpb.add(ProgressBar::new(records.len() as u64));
                 df_pb.set_message(format!("DF {filename}"));
                 df_pb.set_style(ProgressStyle::default_spinner());
@@ -99,7 +110,12 @@ async fn main() -> anyhow::Result<()> {
                 }
 
                 df_pb.finish_and_clear();
+            }
 
+            if !path
+                .components()
+                .any(|comp| comp.as_os_str() == "datafusion")
+            {
                 let duckdb_pb = mpb.add(ProgressBar::new(records.len() as u64));
                 duckdb_pb.set_message(format!("DuckDB {filename}"));
 
@@ -123,17 +139,27 @@ async fn main() -> anyhow::Result<()> {
                 }
 
                 duckdb_pb.finish_and_clear();
-
-                anyhow::Ok(errors)
             }
-        })
-        .buffer_unordered(args.test_threads)
-        .try_collect::<Vec<_>>()
-        .await?;
 
-    for err in all_errors.into_iter().flatten() {
+            anyhow::Ok(errors)
+        }
+    })
+    .buffer_unordered(args.test_threads)
+    .try_collect::<Vec<_>>()
+    .await?;
+
+    let errors = all_errors.into_iter().flatten().collect::<Vec<_>>();
+    for err in &errors {
         eprintln!("Failure: {err}");
     }
 
+    if !has_tpch_data {
+        eprintln!("Skipping TPC-H sqllogictests because slt/tpch/data is not present.");
+    }
+
+    if !errors.is_empty() {
+        anyhow::bail!("{} sqllogictest failure(s)", errors.len());
+    }
+
     Ok(())
 }
diff --git a/vortex-sqllogictest/slt/datafusion/.keep b/vortex-sqllogictest/slt/datafusion/.keep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/vortex-sqllogictest/slt/projection-pushdown.slt b/vortex-sqllogictest/slt/projection-pushdown.slt
new file mode 100644
index 00000000000..28d8cc5aa91
--- /dev/null
+++ b/vortex-sqllogictest/slt/projection-pushdown.slt
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+# Check projection pushdowns with different sets of pre- and
+# post-filter column set
+
+include ./setup.slt
+
+query I
+COPY (SELECT 0 AS i) TO '$__TEST_DIR__/projection-pushdown.vortex';
+----
+1
+
+query II
+SELECT i, 0 AS t FROM '$__TEST_DIR__/projection-pushdown.vortex';
+----
+0 0
+
+query I
+SELECT i FROM (SELECT i, 8 AS t FROM '$__TEST_DIR__/projection-pushdown.vortex');
+----
+0
+
+query I
+SELECT t FROM (SELECT i, 8 AS t FROM '$__TEST_DIR__/projection-pushdown.vortex');
+----
+8
+
+query I
+SELECT 0 FROM '$__TEST_DIR__/projection-pushdown.vortex';
+----
+0
+
+query I
+COPY (SELECT 'ololo' AS id) TO '$__TEST_DIR__/projection-pushdown-id.vortex';
+----
+1
+
+onlyif duckdb
+query I
+SELECT first(const) FROM (
+    SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+    UNION ALL SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+)
+GROUP BY id;
+----
+0
+
+query TI
+SELECT * FROM (
+    SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+    UNION ALL SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+)
+----
+ololo 0
+ololo 0
+
+onlyif duckdb
+query TI
+SELECT * FROM (
+    SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+    UNION ALL SELECT 'd', 0 AS const
+)
+----
+ololo 0
+d 0
+
+onlyif datafusion
+query TI
+SELECT * FROM (
+    SELECT id, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+    UNION ALL SELECT '', 0 AS const
+)
+ORDER BY id;
+----
+(empty) 0
+ololo 0
+
+onlyif duckdb
+query I
+SELECT first(t) AS sales
+FROM (
+    SELECT id, 0 AS t FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+    UNION ALL SELECT id, 0 AS t FROM '$__TEST_DIR__/projection-pushdown-id.vortex'
+)
+GROUP BY id;
+----
+0
+
+query I
+COPY (SELECT 'ololo' AS id, '' AS id2) TO '$__TEST_DIR__/projection-pushdown-id2.vortex';
+----
+1
+
+query I
+SELECT 0 FROM '$__TEST_DIR__/projection-pushdown-id2.vortex';
+----
+0
+
+onlyif duckdb
+query TTI
+SELECT * FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+    UNION ALL SELECT '' AS id, '' AS id2, 0 AS const
+)
+----
+ololo (empty) 0
+(empty) (empty) 0
+
+onlyif datafusion
+query TTI
+SELECT * FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+    UNION ALL SELECT '' AS id, '' AS id2, 0 AS const
+)
+ORDER BY id;
+----
+(empty) (empty) 0
+ololo (empty) 0
+
+query I
+SELECT count(*) FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+    UNION ALL SELECT '' AS id, '' AS id2, 0 AS const
+)
+----
+2
+
+query TI
+SELECT id, count(*) FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+    UNION ALL SELECT 'a', '', 0 AS const
+)
+GROUP BY id
+ORDER BY id;
+----
+a 1
+ololo 1
+
+query T
+SELECT id FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+    UNION ALL SELECT 'a', '', 0 AS const
+)
+ORDER BY id
+----
+a
+ololo
+
+query T
+SELECT id FROM (
+    SELECT id, id2, 0 AS const FROM '$__TEST_DIR__/projection-pushdown-id2.vortex'
+        WHERE id2 != ''
+    UNION ALL SELECT 'a', '', 0 AS const
+)
+----
+a
diff --git a/vortex-sqllogictest/slt/tpch/.gitignore b/vortex-sqllogictest/slt/tpch/.gitignore
new file mode 100644
index 00000000000..249cda967c1
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/.gitignore
@@ -0,0 +1 @@
+/data
\ No newline at end of file
diff --git a/vortex-sqllogictest/slt/tpch/datafusion/create.slt.no b/vortex-sqllogictest/slt/tpch/datafusion/create.slt.no
new file mode 100644
index 00000000000..b7e5d634ded
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/datafusion/create.slt.no
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS supplier (
+        s_suppkey  BIGINT,
+        s_name VARCHAR,
+        s_address VARCHAR,
+        s_nationkey BIGINT,
+        s_phone VARCHAR,
+        s_acctbal DECIMAL(15, 2),
+        s_comment VARCHAR,
+        s_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/supplier.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS part (
+        p_partkey BIGINT,
+        p_name VARCHAR,
+        p_mfgr VARCHAR,
+        p_brand VARCHAR,
+        p_type VARCHAR,
+        p_size INTEGER,
+        p_container VARCHAR,
+        p_retailprice DECIMAL(15, 2),
+        p_comment VARCHAR,
+        p_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/part.vortex';
+
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS partsupp (
+        ps_partkey BIGINT,
+        ps_suppkey BIGINT,
+        ps_availqty INTEGER,
+        ps_supplycost DECIMAL(15, 2),
+        ps_comment VARCHAR,
+        ps_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/partsupp.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS customer (
+        c_custkey BIGINT,
+        c_name VARCHAR,
+        c_address VARCHAR,
+        c_nationkey BIGINT,
+        c_phone VARCHAR,
+        c_acctbal DECIMAL(15, 2),
+        c_mktsegment VARCHAR,
+        c_comment VARCHAR,
+        c_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/customer.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS orders (
+        o_orderkey BIGINT,
+        o_custkey BIGINT,
+        o_orderstatus VARCHAR,
+        o_totalprice DECIMAL(15, 2),
+        o_orderdate DATE,
+        o_orderpriority VARCHAR,
+        o_clerk VARCHAR,
+        o_shippriority INTEGER,
+        o_comment VARCHAR,
+        o_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/orders.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS lineitem (
+        l_orderkey BIGINT,
+        l_partkey BIGINT,
+        l_suppkey BIGINT,
+        l_linenumber INTEGER,
+        l_quantity DECIMAL(15, 2),
+        l_extendedprice DECIMAL(15, 2),
+        l_discount DECIMAL(15, 2),
+        l_tax DECIMAL(15, 2),
+        l_returnflag VARCHAR,
+        l_linestatus VARCHAR,
+        l_shipdate DATE,
+        l_commitdate DATE,
+        l_receiptdate DATE,
+        l_shipinstruct VARCHAR,
+        l_shipmode VARCHAR,
+        l_comment VARCHAR,
+        l_rev VARCHAR,
+) STORED AS VORTEX 
+LOCATION 'slt/tpch/data/lineitem.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS nation (
+        n_nationkey BIGINT,
+        n_name VARCHAR,
+        n_regionkey BIGINT,
+        n_comment VARCHAR,
+        n_rev VARCHAR,
+) STORED AS VORTEX
+LOCATION 'slt/tpch/data/nation.vortex';
+
+statement ok
+CREATE EXTERNAL TABLE IF NOT EXISTS region (
+        r_regionkey BIGINT,
+        r_name VARCHAR,
+        r_comment VARCHAR,
+        r_rev VARCHAR,
+) STORED AS VORTEX
+LOCATION 'slt/tpch/data/region.vortex';
diff --git a/vortex-sqllogictest/slt/tpch/datafusion/tcph.slt b/vortex-sqllogictest/slt/tpch/datafusion/tcph.slt
new file mode 100644
index 00000000000..7fee809dc9f
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/datafusion/tcph.slt
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+include ../../setup.slt
+
+
+include ./create.slt.no
+
+include ../results/*.slt.no
+# include ../drop.slt.no
\ No newline at end of file
diff --git a/vortex-sqllogictest/slt/tpch/drop.slt.no b/vortex-sqllogictest/slt/tpch/drop.slt.no
new file mode 100644
index 00000000000..e81976ba780
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/drop.slt.no
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+statement ok
+DROP TABLE supplier;
+
+statement ok
+DROP TABLE region;
+
+statement ok
+DROP TABLE  nation;
+
+statement ok
+DROP TABLE lineitem;
+
+statement ok
+DROP TABLE orders;
+
+statement ok
+DROP TABLE customer;
+
+statement ok
+DROP TABLE partsupp;
+
+statement ok
+DROP TABLE part;
\ No newline at end of file
diff --git a/vortex-sqllogictest/slt/tpch/duckdb/create.slt.no b/vortex-sqllogictest/slt/tpch/duckdb/create.slt.no
new file mode 100644
index 00000000000..5e7628882ac
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/duckdb/create.slt.no
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+statement ok
+CREATE TABLE supplier AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/supplier.vortex');
+
+statement ok
+CREATE TABLE part AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/part.vortex');
+
+statement ok
+CREATE TABLE partsupp AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/partsupp.vortex');
+
+statement ok
+CREATE TABLE customer AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/customer.vortex');
+
+statement ok
+CREATE TABLE orders AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/orders.vortex');
+
+statement ok
+CREATE TABLE lineitem AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/lineitem.vortex');
+
+statement ok
+CREATE TABLE nation AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/nation.vortex');
+
+statement ok
+CREATE TABLE region AS SELECT * FROM read_vortex('${PWD}/vortex-sqllogictest/slt/tpch/data/region.vortex');
diff --git a/vortex-sqllogictest/slt/tpch/duckdb/tpch.slt b/vortex-sqllogictest/slt/tpch/duckdb/tpch.slt
new file mode 100644
index 00000000000..bef45d1bad0
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/duckdb/tpch.slt
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+include ../../setup.slt
+
+
+# include ./create.slt.no
+# include ../results/*.slt.no
+# include ../drop.slt.no
\ No newline at end of file
diff --git a/vortex-sqllogictest/slt/tpch/generate_data.sh b/vortex-sqllogictest/slt/tpch/generate_data.sh
new file mode 100755
index 00000000000..42b40d22a05
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/generate_data.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+set -ex -o pipefail
+
+if ! command -v uvx &> /dev/null; then
+  echo "Error: uvx not found. Install uv first: https://docs.astral.sh/uv/" >&2
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DATA_DIR="${SCRIPT_DIR}/data"
+
+mkdir -p "${DATA_DIR}"
+
+# 1. Generate TPC-H data at scale factor 0.1
+echo "Generating TPC-H data (SF=0.1)..."
+uvx tpchgen-cli -s 0.1 --format=parquet --output-dir "${DATA_DIR}/" 
+
+# 2. Convert each parquet file to Vortex format
+for f in "${DATA_DIR}"/*.parquet; do
+  echo "Converting $(basename "$f") to Vortex..."
+  cargo run --release --package vortex-tui --bin vx -- convert "$f"
+done
+
+# 3. Remove parquet files
+echo "Cleaning up parquet files..."
+rm -f "${DATA_DIR}"/*.parquet
+
+echo "Done."
diff --git a/vortex-sqllogictest/slt/tpch/results/q1.slt.no b/vortex-sqllogictest/slt/tpch/results/q1.slt.no
new file mode 100644
index 00000000000..b14a95d9069
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q1.slt.no
@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TTRRRRRRRI rowsort
+select
+    l_returnflag,
+    l_linestatus,
+    sum(l_quantity) as sum_qty,
+    sum(l_extendedprice) as sum_base_price,
+    sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
+    sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
+    avg(l_quantity) as avg_qty,
+    avg(l_extendedprice) as avg_price,
+    avg(l_discount) as avg_disc,
+    count(*) as count_order
+from
+    lineitem
+where
+        l_shipdate <= date '1998-09-02'
+group by
+    l_returnflag,
+    l_linestatus
+order by
+    l_returnflag,
+	l_linestatus;
+----
+A F 3774200 5320753880.69 5054096266.6828 5256751331.449234 25.537587 36002.123829 0.050144 147790
+N F 95257 133737795.84 127132372.6512 132286291.229445 25.300664 35521.326916 0.049394 3765
+N O 7459297 10512270008.9 9986238338.3847 10385578376.585467 25.545537 36000.924688 0.050095 292000
+R F 3785523 5337950526.47 5071818532.942 5274405503.049367 25.525943 35994.029214 0.049989 148301
+
diff --git a/vortex-sqllogictest/slt/tpch/results/q10.slt.no b/vortex-sqllogictest/slt/tpch/results/q10.slt.no
new file mode 100644
index 00000000000..31973c2b440
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q10.slt.no
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query ITRRTTTT
+select
+    c_custkey,
+    c_name,
+    sum(l_extendedprice * (1 - l_discount)) as revenue,
+    c_acctbal,
+    n_name,
+    c_address,
+    c_phone,
+    c_comment
+from
+    customer,
+    orders,
+    lineitem,
+    nation
+where
+        c_custkey = o_custkey
+  and l_orderkey = o_orderkey
+  and o_orderdate >= date '1993-10-01'
+  and o_orderdate < date '1994-01-01'
+  and l_returnflag = 'R'
+  and c_nationkey = n_nationkey
+group by
+    c_custkey,
+    c_name,
+    c_acctbal,
+    c_phone,
+    n_name,
+    c_address,
+    c_comment
+order by
+    revenue desc
+limit 20;
+----
+8242 Customer#000008242 622786.7297 6322.09 ETHIOPIA P2n4nJhy,UqSo2s43YfSvYJDZ6lk 15-792-676-1184 slyly regular packages haggle carefully ironic ideas. courts are furiously. furiously unusual theodolites cajole. i
+7714 Customer#000007714 557400.3053 9799.98 IRAN SnnIGB,SkmnWpX3 20-922-418-6024 arhorses according to the blithely express re
+11032 Customer#000011032 512500.9641 8496.93 UNITED KINGDOM WIKHC7K3Cn7156iNOyfVG3cZ7YqkgsR,Ly 33-102-772-3533 posits-- furiously ironic accounts are again
+2455 Customer#000002455 481592.4053 2070.99 GERMANY RVn1ZSRtLqPlJLIZxvpmsbgC02 17-946-225-9977 al asymptotes. finally ironic accounts cajole furiously. permanently unusual theodolites aro
+12106 Customer#000012106 479414.2133 5342.11 UNITED STATES wth3twOmu6vy 34-905-346-4472 ly after the blithely regular foxes. accounts haggle carefully alongside of the blithely even ideas.
+8530 Customer#000008530 457855.9467 9734.95 MOROCCO GMQyte94oDM7eD7exnkj 4hH9yq3 25-736-932-5850 slyly asymptotes. quickly final deposits in
+13984 Customer#000013984 446316.5104 3482.28 IRAN qZXwuapCHvxbX 20-981-264-2952 y unusual courts could wake furiously
+1966 Customer#000001966 444059.0382 1937.72 ALGERIA jPv1 UHra5JLALR5Isci5u0636RoAu7t vH 10-973-269-8886 the blithely even accounts. final deposits cajole around the blithely final packages. 
+11026 Customer#000011026 417913.4142 7738.76 ALGERIA XorIktoJOAEJkpNNMx 10-184-163-4632 ly even dolphins eat along the blithely even instructions. express attainments cajole slyly. busy dolphins in
+8501 Customer#000008501 412797.51 6906.7 ARGENTINA 776af4rOa mZ66hczs 11-317-552-5840 y final deposits after the fluffily even accounts are slyly final, regular
+1565 Customer#000001565 412506.0062 1820.03 BRAZIL EWQO5Ck,nMuHVQimqL8dLrixRP6QKveXcz9QgorW 12-402-178-2007 ously regular accounts wake slyly ironic idea
+14398 Customer#000014398 408575.36 -602.24 UNITED STATES GWRCgIPHajtU21vICVvbJJerFu2cUk 34-814-111-5424 s. blithely even accounts cajole blithely. even foxes doubt-- 
+1465 Customer#000001465 405055.3457 9365.93 INDIA tDRaTC7UgFbBX7VF6cVXYQA0 18-807-487-1074 s lose blithely ironic, regular packages. regular, final foxes haggle c
+12595 Customer#000012595 401402.2391 -6.92 INDIA LmeaX5cR,w9NqKugl yRm98 18-186-132-3352 o the busy accounts. blithely special gifts maintain a
+961 Customer#000000961 401198.1737 6963.68 JAPAN 5,81YDLFuRR47KKzv8GXdmi3zyP37PlPn 22-989-463-6089 e final requests: busily final accounts believe a
+14299 Customer#000014299 400968.3751 6595.97 RUSSIA 7lFczTya0iM1bhEWT 32-156-618-1224  carefully regular requests. quickly ironic accounts against the ru
+623 Customer#000000623 399883.4257 7887.6 INDONESIA HXiFb9oWlgqZXrJPUCEJ6zZIPxAM4m6 19-113-202-7085  requests. dolphins above the busily regular dependencies cajole after
+9151 Customer#000009151 396562.0295 5691.95 IRAQ 7gIdRdaxB91EVdyx8DyPjShpMD 21-834-147-4906 ajole fluffily. furiously regular accounts are special, silent account
+14819 Customer#000014819 396271.1036 7308.39 FRANCE w8StIbymUXmLCcUag6sx6LUIp8E3pA,Ux 16-769-398-7926 ss, final asymptotes use furiously slyly ironic dependencies. special, express dugouts according to the dep
+13478 Customer#000013478 395513.1358 -778.11 KENYA 9VIsvIeZrJpC6OOdYheMC2vdtq8Ai0Rt 24-983-202-8240 r theodolites. slyly unusual pinto beans sleep fluffily against the asymptotes. quickly r
diff --git a/vortex-sqllogictest/slt/tpch/results/q11.slt.no b/vortex-sqllogictest/slt/tpch/results/q11.slt.no
new file mode 100644
index 00000000000..43322b85b3f
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q11.slt.no
@@ -0,0 +1,2573 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query IR
+select
+    ps_partkey,
+    sum(ps_supplycost * ps_availqty) as value
+from
+    partsupp,
+    supplier,
+    nation
+where
+    ps_suppkey = s_suppkey
+  and s_nationkey = n_nationkey
+  and n_name = 'GERMANY'
+group by
+    ps_partkey having
+    sum(ps_supplycost * ps_availqty) > (
+    select
+    sum(ps_supplycost * ps_availqty) * 0.0001
+    from
+    partsupp,
+    supplier,
+    nation
+    where
+    ps_suppkey = s_suppkey
+                  and s_nationkey = n_nationkey
+                  and n_name = 'GERMANY'
+    )
+order by
+    value desc;
+----
+12098 16227681.21
+5134 15709338.52
+13334 15023662.41
+17052 14351644.2
+3452 14070870.14
+12552 13332469.18
+1084 13170428.29
+5797 13038622.72
+12633 12892561.61
+403 12856217.34
+1833 12024581.72
+2084 11502875.36
+17349 11354213.05
+18427 11282385.24
+2860 11262529.95
+17852 10934711.93
+9871 10889253.68
+12231 10841131.39
+6366 10759786.81
+12146 10257362.66
+5043 10226395.88
+12969 10125777.93
+1504 10004397.08
+14327 9981697.08
+134 9965150.66
+6860 9805871.26
+10624 9776138.4
+15819 9775705.31
+3293 9674928.12
+19865 9653766.83
+8870 9648981.87
+15778 9636332.82
+12360 9635023.92
+14389 9475588.34
+3257 9451029.24
+9476 9435207.28
+19629 9391236.4
+7179 9386222.25
+15723 9383900.8
+4054 9313810.02
+2380 9307751.22
+19084 9302916.8
+4703 9280804.8
+18791 9267017.97
+19994 9235972.92
+9149 9121803.9
+15118 9120819.5
+6116 9079369.2
+7052 9077468.92
+14147 9069193.78
+7305 9035228.53
+9130 9024379.25
+16698 8991337.95
+1553 8977226.1
+16777 8961355.62
+1402 8953779.12
+18963 8934063.4
+8358 8930611.48
+17547 8860117
+5128 8844222.75
+17063 8840649.6
+15490 8833581.4
+14761 8817240.56
+19601 8791341.02
+16160 8740262.76
+13597 8702669.82
+13653 8693170.16
+16383 8691505.92
+325 8667741.28
+8879 8667584.38
+10564 8667098.22
+17429 8661827.9
+17403 8643350.3
+18294 8616583.43
+4181 8592684.66
+13008 8567480.64
+13211 8537000.01
+1884 8532644.34
+11101 8530945.32
+11562 8528028.57
+15878 8523591.84
+834 8522135.27
+2423 8517902.85
+15383 8513433.11
+18119 8507611.8
+7389 8506099.2
+5016 8489784.15
+17473 8444766.24
+6669 8428618.46
+384 8418472.27
+12052 8411519.28
+17562 8409022.83
+8128 8379149.47
+13813 8374830.84
+12800 8318626.78
+10887 8315019.36
+1644 8285453.08
+16638 8274568
+1394 8255140.6
+7219 8254985.3
+13358 8253829.8
+5562 8252365.16
+14861 8242296.15
+15416 8196621.53
+1963 8192206.61
+2841 8148678.45
+6635 8122918.28
+3609 8099812.05
+6372 8093695.06
+5231 8091704.18
+8755 8085017.03
+4071 8083755.18
+4977 8058501.72
+11873 8057540.3
+12127 8051142.94
+2401 8049525.94
+15964 8037547.75
+10129 8030855.04
+7605 8028622.42
+9327 8022291.3
+11814 7983589.59
+4646 7981660.6
+6032 7981511.28
+1076 7977074.75
+4043 7971929.9
+8932 7967222.19
+13705 7953344.52
+16855 7923819
+3234 7920022
+17752 7901362.77
+2097 7892993.17
+18599 7890774.4
+19596 7874564.59
+11392 7861172.48
+18121 7857581.6
+17452 7838465.36
+6076 7821316.8
+15134 7804760.25
+8641 7802917.15
+2134 7800185.43
+16352 7797112
+19312 7775952.24
+2895 7759327.23
+12860 7758135.21
+153 7755681.28
+15089 7735438.26
+14797 7725353.16
+15946 7722773.88
+10919 7722425.36
+9867 7721597.78
+11881 7713136.42
+16552 7708518.15
+6925 7703999.68
+12147 7703826.98
+8923 7702690.28
+16116 7697970.84
+10661 7673830.2
+17094 7665368.16
+18648 7650862.02
+12172 7641326.4
+15123 7633032.5
+4993 7600570.8
+17162 7592062.56
+13506 7580809.83
+3436 7575616.33
+6271 7559793.93
+13314 7555156.63
+17242 7550949.5
+2753 7549574.06
+7391 7543159.68
+7418 7541449.65
+116 7520874.24
+12436 7520234.54
+1181 7494798.28
+12963 7491248.1
+213 7479470.28
+7114 7477681.2
+18521 7476478.3
+8973 7458603.67
+4202 7454095.74
+12009 7442105.4
+10609 7429346.4
+5622 7424142.66
+5143 7422760.28
+898 7414133.8
+12257 7408190.63
+6740 7400350.35
+1146 7394394.48
+5485 7378181.94
+8437 7376353.59
+6531 7362366.78
+16463 7362106.8
+10412 7359552.42
+12857 7340801.58
+12354 7332343.2
+7616 7320032.37
+3426 7312340.41
+8622 7307266.33
+6818 7304782.1
+3705 7299380.1
+12733 7298398.17
+1574 7293446.04
+10554 7289933.72
+9363 7284647.7
+4611 7282115
+7857 7266948.92
+9616 7265005.3
+15860 7254466.66
+15554 7247592.51
+3422 7247586.45
+9134 7236404.67
+17408 7220083.6
+15853 7219984.9
+9266 7218517.11
+1881 7208346.45
+10148 7205335.83
+8860 7202401.44
+8373 7189039.5
+10859 7188990.69
+12670 7188177.22
+2553 7180006.02
+19346 7176797.25
+1681 7160169.84
+15225 7158861.32
+1052 7158586
+77 7155531.1
+7231 7155250.38
+12622 7137408.42
+9814 7105363.14
+8695 7103187
+13174 7099182.53
+6179 7095134.05
+6451 7082495.36
+19860 7073206.83
+9307 7059973.68
+7819 7055963.04
+10556 7053491.07
+9366 7048690.74
+12124 7040021.31
+11476 7037906.76
+19245 7034045.24
+7562 7030275.79
+12290 7020372.06
+18118 7003396.8
+1253 7001569.62
+8662 6999834.27
+1779 6997385.73
+15386 6996871.79
+147 6989079.88
+9562 6983076.9
+3958 6969833.22
+7211 6966606.67
+12842 6923277.66
+4368 6918783.95
+11131 6918656.78
+4628 6894893.82
+5879 6881367.14
+16586 6865931.8
+32 6852925.59
+12119 6842773.7
+1371 6831137.52
+6136 6827917.01
+13857 6824240.6
+1074 6821747.88
+1863 6821522.19
+14597 6817385.66
+9271 6783068.88
+6389 6781075.68
+11703 6776538.36
+13701 6768880.56
+14880 6763788.24
+18428 6763670.54
+1006 6762065.94
+4927 6756765.21
+11659 6755246.68
+6815 6738928.35
+14367 6733857.2
+10703 6730936.46
+3150 6727920.4
+9963 6725919.35
+10438 6710153.62
+4745 6682153.67
+15297 6681711.28
+10848 6678666.25
+11749 6677895.73
+16739 6675549.12
+14915 6672248.66
+19841 6669191.2
+628 6666892.9
+1650 6657178.32
+7069 6648672.24
+7108 6646445.96
+8887 6641655.9
+18735 6636457.56
+3711 6632665.38
+2325 6630475.92
+6484 6622965.2
+2643 6617304.98
+7895 6615061.26
+12840 6604848.54
+4314 6600905.71
+19077 6591091.97
+17476 6576029
+7039 6559838.9
+8106 6558223.02
+2391 6557120.08
+7717 6547706.88
+12476 6546988.15
+9155 6540793.6
+360 6530297.41
+6383 6529336.02
+4830 6518998.92
+12600 6511549.46
+13740 6508057.92
+4678 6507847.98
+17815 6502284.76
+7329 6490811.95
+13884 6490063.1
+5147 6487069
+16548 6482024.5
+14144 6476413.4
+10181 6474984.88
+11031 6463308.02
+19958 6461506.38
+6043 6458177.64
+10060 6455476.89
+9144 6454042.05
+7043 6448019.98
+17346 6444307.52
+13963 6442014.48
+7111 6441947.07
+14140 6439955.54
+2327 6438977.28
+14812 6437152.54
+16755 6430895.36
+14840 6430549.14
+14134 6422079.26
+12655 6405496.79
+1518 6390148.22
+9888 6385033.02
+7387 6384005.18
+5393 6381083.04
+11057 6375974.22
+16818 6368828.8
+4576 6364925.71
+19644 6350000.33
+139 6336065.55
+11735 6334305.9
+10108 6332055.99
+15628 6329801.34
+4349 6314949.68
+7048 6313868.55
+17119 6298935.38
+18597 6291416.31
+2488 6286372.05
+2296 6275519.25
+4343 6272834.2
+9958 6267714.61
+2147 6267475.32
+9368 6254578.92
+13134 6252432.76
+10119 6251456.25
+2093 6249342.36
+2392 6237476.56
+17231 6233509.18
+3773 6226654.68
+9839 6214044.1
+19349 6213969.3
+7869 6212751
+8158 6210279.24
+13179 6205773.65
+2349 6205589.26
+9052 6200729.7
+1744 6189967.36
+597 6183103.47
+16721 6176606.6
+7498 6176277.25
+15157 6176222.5
+17524 6171107.36
+7922 6170906.07
+6615 6170738.42
+2706 6165991.65
+16432 6162740.68
+16473 6162427.96
+12825 6161595.6
+18813 6154678.55
+1030 6146500.28
+2571 6145772.43
+7707 6144754.71
+10327 6137612
+4710 6132346.56
+3649 6130602.63
+4893 6128461.24
+12844 6128191.24
+8794 6122690.28
+1157 6117749.22
+10895 6112017.68
+16166 6108250.98
+11920 6107122.56
+5621 6102123.56
+6141 6093826.56
+14076 6086671.08
+15884 6080485.59
+4814 6080337.96
+5814 6079842.96
+1134 6078685.2
+19048 6071813.28
+303 6070601.35
+15211 6065678.06
+1020 6054168
+11292 6052522.83
+7134 6049865.25
+14119 6049619.55
+2389 6042429.12
+5926 6034269.52
+8553 6030922.95
+18814 6023255.17
+12702 6023190.99
+2644 6020931.33
+19628 6010704
+18112 6008707.52
+13860 6008170.29
+1456 6005092.14
+1633 6002068.85
+2301 6000302.29
+10740 5999809.05
+2630 5997008.43
+8818 5992296.9
+10043 5990594.02
+653 5987942.83
+6829 5985990.66
+15179 5977727.52
+9663 5973523.92
+5863 5973328.92
+3628 5966340.09
+7618 5960155.86
+2588 5952648.56
+4865 5949383.4
+4233 5944699.6
+13390 5944104.69
+16321 5942714.7
+9653 5941308.5
+18884 5925548.24
+4394 5920927.14
+19774 5916723.12
+1257 5914052.36
+2963 5911917.77
+17157 5899573.02
+383 5884693.36
+11709 5884134.48
+18135 5871431.61
+13169 5869736.88
+2932 5868995.8
+2888 5863229.3
+6820 5853106.8
+18622 5850951.6
+9066 5846052.72
+19840 5832251.4
+6325 5827298.43
+14092 5823711.72
+11532 5823277.12
+18043 5815248.7
+3932 5809134.6
+10364 5808371.4
+1179 5808303.24
+11441 5799378.33
+15767 5798263.26
+14063 5797204
+11383 5793893.12
+10065 5781764.45
+17785 5766838.76
+18349 5761765.77
+14824 5760339.78
+14699 5759490.18
+11628 5755137.2
+4403 5752376.64
+13090 5751949.25
+15332 5744606.28
+17573 5744384.15
+12895 5741007.02
+13577 5739209.94
+16594 5732523.64
+8497 5727509.84
+2872 5724068.72
+16181 5721788.16
+6639 5712041.22
+13095 5708798.25
+4535 5693341.2
+10956 5692585.5
+19755 5686913.37
+12995 5682200.41
+13157 5681454.94
+1887 5681341.24
+18472 5680356
+19814 5679360
+18583 5669360.52
+3894 5664385.49
+1740 5659552.04
+62 5659470.16
+16532 5653779.46
+995 5648973.45
+7486 5646851.87
+19007 5642710.93
+13060 5642024.64
+12371 5635710.45
+2280 5634077.4
+3115 5631352.32
+11107 5631252.46
+5873 5629125.75
+14743 5628732.8
+2224 5624746.62
+2653 5623859.99
+17622 5623057.44
+14700 5615344
+14740 5613929.39
+6403 5611924.51
+6896 5609169.88
+10384 5607337.52
+16433 5605707.03
+5898 5604937.76
+4789 5600488.36
+8132 5593107.5
+3838 5592313.2
+13631 5586424.8
+11233 5585247.01
+849 5583516.45
+14653 5581550.45
+14788 5580433
+18181 5578562.88
+19815 5577102.62
+5584 5576692.2
+5385 5576420.19
+13780 5569028.61
+9342 5566783.71
+19056 5566524.12
+8189 5565694.74
+13808 5560721.96
+10635 5560058.55
+8304 5550784.41
+14257 5549164.06
+8999 5542100.1
+19134 5539312.56
+8360 5538031.1
+6397 5536651.92
+2597 5525317.76
+8631 5515909.38
+16729 5512663.65
+11861 5511785.93
+16853 5511689.91
+6341 5502790.08
+1312 5496649.4
+5566 5495885.87
+12519 5490649.97
+19032 5488105.02
+8231 5479312.5
+3026 5466732.32
+6388 5466168.8
+15349 5464571.52
+18985 5463897.13
+19848 5454266.4
+17378 5453284.74
+4000 5448690.39
+3710 5445822.53
+13181 5439774.06
+6420 5438325.32
+3644 5437772.14
+1117 5437024.97
+13027 5436968.46
+12884 5432632.34
+12781 5429161.08
+10084 5428231.62
+5640 5423318.58
+16208 5422901.4
+753 5416899.74
+4120 5413822.46
+12348 5412061.71
+1586 5411198.55
+2503 5411125.8
+1381 5397790.1
+19673 5397746.77
+19389 5394426.4
+15532 5386361.38
+3562 5380335.08
+19114 5375133
+3204 5372215.46
+6653 5365178
+3553 5363690.29
+12687 5361682.12
+3279 5357505.65
+9840 5350112.18
+8258 5347064.67
+11387 5345284
+15210 5341117.92
+15092 5340896.8
+6052 5339762.18
+14043 5339587.68
+6284 5336153
+6297 5332357.74
+16254 5326607.83
+18436 5326198.5
+14436 5325517.14
+10368 5319983.08
+6349 5317943.4
+19984 5317620
+19080 5310678.6
+1403 5306771.32
+5995 5305056.12
+13214 5299420.45
+19293 5297054.4
+7130 5289761.48
+9809 5286784.8
+9273 5277924.77
+16786 5260035
+11032 5256354.35
+17719 5246322.2
+3400 5244203.68
+8278 5243718.48
+7873 5241168.8
+9357 5239695.77
+2239 5235767.83
+18695 5223960.35
+19271 5216498.29
+4563 5214673.7
+1896 5210699.79
+15755 5210481.24
+17628 5209882.37
+5747 5206892.24
+18057 5204907.4
+5075 5204412.81
+5325 5190162.75
+17675 5183135.36
+18818 5181295.3
+11064 5180667.57
+12578 5177222.33
+3725 5169183.75
+11112 5161546
+4749 5161499.44
+7632 5159180.5
+13119 5151665.51
+5653 5140324.64
+16134 5137482.51
+5671 5136815.55
+18348 5132981.07
+562 5132487.25
+2562 5126763.83
+10304 5125180
+7622 5120719.98
+12755 5118213.92
+1814 5100705.58
+11269 5096671.33
+2964 5095253.72
+1616 5091834
+9294 5090753.53
+16793 5085330.54
+4999 5081651.75
+17209 5079029.28
+7151 5078937.6
+15522 5072469.6
+3056 5072329.55
+7612 5068322.87
+18453 5063892.92
+18324 5058901.22
+12266 5058186.75
+19394 5056235.73
+1713 5054968.05
+15681 5051569.63
+8274 5043328
+18160 5043074.83
+18253 5041572
+11840 5040590.04
+1532 5033171
+584 5031602.64
+12382 5028901
+14814 5022200.07
+19058 5019001.92
+4487 5016640.86
+8482 5015444.25
+18476 5011136.36
+12335 5003581.4
+4455 4997933.31
+14355 4992822.92
+15253 4992642.2
+14069 4983244.2
+17843 4977294.37
+9389 4975885.83
+14435 4971442.19
+13254 4959481.45
+9773 4955887.8
+7615 4952421.54
+6476 4947250.05
+9253 4945159.7
+14932 4934395.48
+13253 4932867.45
+19322 4931525.78
+16945 4931440.61
+731 4930191.93
+6540 4925114.51
+5148 4923048
+1934 4921196.9
+15402 4920840.72
+17914 4919607.04
+5416 4916041.92
+16734 4914205.27
+14967 4900262.08
+8706 4894595.58
+136 4891960.92
+19494 4886028.3
+8737 4880640.44
+7653 4879423.64
+4149 4875782.4
+7890 4872424.4
+11142 4871415.42
+10386 4863623.5
+8603 4861814.61
+2680 4861223.74
+4891 4858103.88
+19236 4855097.69
+14251 4854739.86
+18895 4853365.1
+17134 4852041.04
+4932 4843701.45
+10033 4841647.72
+1383 4839144.31
+18721 4837983.36
+8618 4833125.42
+17386 4831545.84
+3790 4830282.36
+1043 4825921.31
+12434 4822597.78
+18385 4819643.4
+6046 4817460.06
+5821 4814423.45
+10836 4814303.24
+6848 4813954.08
+6880 4804600.35
+11249 4800116.82
+11970 4799739.66
+14253 4796521.29
+7782 4793227.13
+75 4790042.88
+7076 4789347.34
+9566 4782531.8
+2137 4767931.74
+2336 4763870.79
+15362 4759043.38
+3284 4755048.76
+12964 4753627.48
+1781 4752835.2
+5454 4748342.98
+12597 4742077.84
+19120 4733459.96
+14884 4731499.44
+825 4730720.28
+14683 4730482.32
+5361 4726113
+12179 4725018.1
+1461 4710954.69
+9890 4709658.4
+13369 4705085.39
+11612 4701627.99
+3096 4699414.4
+10383 4697866.47
+11293 4697336.06
+3383 4695825.2
+6231 4694381.72
+7396 4691319.06
+17827 4688797.44
+15856 4683368.21
+8253 4678560.86
+12327 4677984.74
+4395 4676829.82
+4232 4676646.4
+14260 4670522.8
+15288 4669273.99
+17526 4668545.64
+9884 4662693.84
+2118 4660352.78
+4524 4653956.6
+19090 4650872.94
+3928 4649359.44
+14325 4647762.17
+15476 4643469.04
+4179 4639931.76
+14408 4639631.28
+19424 4634817.44
+3334 4633102.5
+9477 4628073.51
+11803 4625396.8
+14805 4618452.18
+463 4616307.28
+16628 4607490.96
+3116 4604463.1
+19962 4602949.47
+12859 4602870.55
+12063 4600708.45
+5648 4592273.25
+8556 4590726.86
+15281 4589425.41
+9414 4587426.9
+13951 4586281.25
+19328 4582624.82
+15963 4579705.5
+10773 4573276.2
+14179 4568816
+1895 4563988.16
+6408 4561496.39
+5958 4554000
+3653 4548134.4
+11218 4546237.92
+19327 4543987.77
+9572 4535941.16
+14556 4531464.75
+2475 4529761.5
+9631 4529261.56
+1901 4528592.55
+86 4528475.38
+9586 4527146.22
+17361 4519098.87
+8112 4514949.45
+13468 4499728.2
+18239 4497633.64
+10215 4494553.6
+6211 4492264.96
+836 4490945.1
+895 4489141.5
+19542 4488393.75
+4322 4487884.23
+2116 4486944.65
+553 4486075.48
+2515 4485188.26
+16286 4481470.47
+12271 4478224.95
+16570 4465818
+7995 4457574.66
+18396 4457229.6
+16331 4455735.48
+18157 4452196.63
+5271 4452040.01
+11622 4451244.84
+4052 4446397.34
+2864 4446008.38
+490 4442892.3
+19837 4434172.39
+4114 4433657.85
+11436 4433070.15
+6085 4431306.57
+9735 4430445.6
+17834 4416286.33
+8157 4416116.65
+18840 4414925.32
+13553 4412261.7
+12562 4411183.04
+14025 4403442.16
+17964 4400360.09
+636 4399863.84
+8390 4389024.33
+231 4387397.3
+9699 4385891.02
+10622 4384005.32
+14364 4383236.9
+10580 4381533.23
+10124 4369800.96
+10451 4368867.5
+4673 4367113.44
+11351 4362616.5
+4770 4362397.32
+12932 4362042.6
+10603 4357216.5
+19733 4348931.75
+4222 4348871.91
+17319 4347687.69
+3375 4346529.48
+14995 4338295.65
+7675 4337499.6
+15043 4333921.2
+4835 4332648
+4408 4332588.9
+5559 4330577.09
+7376 4328936.54
+18061 4328793.98
+2749 4328671.53
+6628 4328501.88
+5888 4323049.72
+18872 4322595.62
+5476 4319642.58
+1755 4318935.63
+10623 4315822.56
+18775 4314677.64
+3570 4312697.87
+11147 4310740.57
+6071 4307612.4
+10807 4306006
+9550 4299478.56
+657 4296794.19
+19669 4294640.9
+8532 4290651.6
+13469 4281715.62
+8809 4280778.8
+11301 4276847.95
+6147 4266879.92
+2612 4265962.35
+15699 4256118.72
+12300 4254409.11
+3494 4250810.6
+11040 4250030.2
+6190 4244046.8
+17616 4239937.5
+7271 4234407
+14048 4226977.44
+4456 4224684.98
+10012 4223841.21
+11175 4223704.14
+18675 4215406.86
+10792 4214898.57
+10806 4209678.32
+18749 4204787
+17410 4198025.28
+8032 4195430
+11094 4192304.94
+17582 4187341.44
+12246 4183230.95
+6640 4182968.8
+7346 4174707.6
+12747 4169865.81
+3869 4164957.44
+13106 4161902.08
+10547 4159541.36
+15289 4156205.76
+1679 4156156.64
+1126 4155593.08
+19106 4147439.52
+9705 4144024.2
+15324 4142518.56
+16544 4140375.72
+8812 4139322.81
+10772 4134101.64
+2800 4127150.08
+15549 4124704.64
+3607 4118697.57
+1980 4117633.72
+214 4113117.36
+19217 4104217.6
+2460 4098577.46
+19156 4093864.46
+18359 4092727.29
+12865 4092526.84
+14616 4092434.54
+908 4088856.2
+11791 4083804.97
+4157 4078345.6
+3857 4070872.87
+15114 4056112.5
+395 4052997.76
+17456 4051457.28
+10562 4050894.19
+10884 4050330.76
+12177 4049842.68
+15595 4040577.56
+15916 4036044.5
+7084 4035102.72
+4424 4034761.56
+10874 4031015.85
+4740 4030403.76
+16585 4030010.26
+18824 4028984.1
+14875 4028452.08
+13855 4024828.34
+10932 4024002.4
+9084 4021362.45
+14352 4018089.74
+18086 4015180.68
+9514 4013666.67
+15787 4013154.56
+714 4010249.44
+8811 4009588.9
+14386 4007210.88
+616 4004057.26
+7460 4003412.48
+866 4003182.54
+782 4001299.94
+8562 3999441.62
+1366 3994060.86
+2879 3993056.55
+16679 3992434.99
+17306 3990723.3
+13140 3982817.39
+17942 3980857.04
+6572 3977676.28
+3578 3977523.94
+15802 3969946.9
+336 3967938.38
+9807 3964469.6
+12104 3964273.4
+4271 3962359.28
+6702 3961657.44
+19763 3955582.75
+369 3953702.88
+4089 3953455.68
+2593 3946153.8
+590 3943841.16
+8325 3942118.75
+158 3941881.65
+12054 3938362.69
+18330 3938303.88
+5354 3936239.58
+8150 3925793.46
+8344 3921293.6
+6069 3921130.55
+4032 3920008.59
+17939 3917750.27
+7014 3914471.2
+2840 3913131.58
+1868 3912987.54
+10975 3911920.48
+5374 3910802.74
+11128 3908156.46
+18449 3907589.4
+11740 3907459.84
+2356 3907189
+5721 3901585.97
+4231 3900779.05
+4352 3899933.44
+432 3899836.44
+15321 3899516.58
+10296 3897015.14
+5647 3895088.16
+7386 3891916.51
+507 3891487.68
+3995 3887387.07
+4278 3882294.02
+18407 3880267.86
+6127 3879166.71
+145 3875277.24
+19269 3874685.76
+18257 3874454.89
+9068 3869767.74
+576 3860007.79
+4860 3852862.02
+18793 3849838.16
+15988 3847257.05
+6891 3846386.75
+3231 3846344.3
+15237 3845421
+9035 3844166.85
+7597 3838643.35
+16349 3837121.65
+2497 3827850.2
+3616 3827390.95
+11566 3826122.47
+18403 3822033.02
+2972 3821903.55
+812 3821523.72
+2043 3820561.36
+505 3818922.03
+8257 3815071.92
+6084 3814194.95
+11253 3813917.24
+366 3812257.88
+13632 3811601.32
+14298 3801412.42
+7092 3798729.48
+2058 3796109.04
+14820 3791195.86
+7157 3788690.82
+17211 3786030.17
+16644 3786019.25
+15693 3783662.19
+2627 3782394.6
+11231 3782077.6
+12696 3781761.66
+8705 3778077
+16052 3771577.04
+99 3760269.31
+2082 3757517.5
+872 3750005.34
+7126 3749138.92
+10302 3744475.25
+17122 3741012.98
+10080 3740107.1
+16021 3739611.2
+3074 3739224.96
+3142 3738811.02
+13213 3735116.25
+13442 3733132.14
+11542 3731000.12
+13732 3730444.9
+2608 3729372.4
+5 3725511.5
+19157 3723844.72
+18231 3721707.99
+8179 3714155.04
+12740 3708646.91
+11597 3706528.59
+13968 3702376.08
+6436 3687346.44
+9181 3687134.08
+564 3680200.8
+13464 3678406.2
+14084 3673790.38
+2755 3670593.69
+14284 3668640.8
+12178 3653392.48
+15730 3650258.3
+5560 3649569.59
+8594 3647140.56
+7032 3646439.54
+16846 3644843.1
+1530 3642838.08
+3978 3639712.05
+2897 3639442.32
+16625 3636527.54
+12029 3636339.72
+16830 3633448.57
+9597 3632662.11
+5533 3630338.67
+5181 3625965.93
+8131 3625738.62
+8560 3620761.26
+11860 3618746.25
+12008 3614604.4
+10737 3611990.64
+18208 3611596.1
+5119 3611038.2
+11958 3601654.65
+15124 3598278.2
+14058 3597490.02
+12270 3593912.1
+17793 3593318.95
+9385 3587327.84
+12814 3587083.84
+5304 3586230.61
+3631 3582841.65
+610 3581917.3
+19317 3580412.43
+128 3567004.56
+11616 3566154.8
+10176 3565392.15
+7349 3564110.64
+1712 3560408.43
+18860 3559340.6
+17617 3557516
+6443 3556296.96
+15408 3554814.56
+16350 3554388.63
+17436 3554105.13
+5740 3551324.68
+12181 3550218.54
+16895 3550119.3
+19995 3548839.7
+4968 3548306.87
+2257 3546692.29
+1825 3543198.78
+18989 3539038.08
+18727 3536081.4
+16165 3533789.84
+3249 3533709.87
+11731 3532875
+13032 3532415.79
+9377 3531582.08
+5883 3531479
+1211 3528833.4
+12065 3526948.1
+10866 3526146.66
+2073 3520131.3
+2378 3512186.2
+16860 3509693.07
+389 3507814.64
+15604 3505653.27
+11257 3502831.8
+1327 3502022.6
+16602 3501074.88
+1493 3498808.95
+8224 3498179.52
+622 3497158.36
+3072 3495958.72
+1478 3494880.48
+3125 3494169.9
+2052 3488438.08
+8476 3487191.28
+10735 3477740.76
+14860 3476235.84
+6586 3475745.1
+5130 3472024.5
+7181 3471306.3
+618 3467906.52
+15698 3464859.47
+17585 3462450.46
+2548 3456856.96
+2632 3456230.74
+2882 3453986.86
+12216 3452907.15
+4925 3452904.63
+9012 3442581.36
+6667 3430076.4
+17958 3424962.56
+6093 3424241.92
+10648 3417414
+1462 3413248.61
+2569 3412388.82
+18616 3409880.91
+7368 3408036.45
+3110 3407374.6
+10824 3406819.29
+11510 3404701.96
+4840 3397236.4
+4449 3396993.6
+1358 3396616.32
+3885 3395817.6
+13381 3391953.52
+1655 3383051.51
+282 3381785.42
+4928 3374270.48
+3199 3372488.8
+16086 3370710.65
+8612 3362922.5
+19597 3360764
+8867 3354400.11
+4098 3353574.28
+12617 3351499.05
+14365 3347296
+10443 3345493.1
+76 3342081.82
+11585 3341941.22
+4383 3338960.27
+13910 3335964.16
+8076 3332449.89
+16005 3332190.4
+2622 3329364.45
+12822 3321183.52
+17076 3320398.06
+5392 3320357.15
+18628 3319615.84
+13695 3318525.99
+10326 3318274.16
+9109 3317833.9
+1489 3317620.8
+3378 3315948
+7738 3312979.2
+1844 3312277.36
+19963 3307500
+2436 3306419.05
+886 3302180.7
+15475 3301693.5
+6327 3300680.78
+6050 3299460.2
+9876 3298410.05
+19586 3291131.25
+14349 3289862.52
+10993 3287980.57
+18784 3286752.12
+1800 3285466.24
+990 3284595.5
+3823 3281992.94
+15737 3279305.96
+19518 3276759.63
+9032 3272440.32
+7786 3271217.28
+8648 3271162.44
+5532 3270187.97
+15914 3268520.98
+16065 3265068.84
+11212 3264657.03
+13229 3262022.28
+15827 3260862.72
+1582 3260340
+3827 3260093.76
+3546 3259244.07
+15849 3258918
+14856 3258379.4
+2028 3255013.96
+6618 3254581.95
+17461 3252926.88
+13551 3241602.2
+19561 3239795.32
+2276 3236172.3
+14203 3234649.39
+7757 3231351.84
+122 3226213.88
+12954 3225943
+647 3224783.76
+12383 3223989.44
+3831 3223126.6
+16836 3222260.73
+4565 3221597.44
+19426 3218106.54
+17855 3217813.02
+5624 3207777.36
+8368 3203376.45
+9480 3200904
+11181 3199500.53
+8981 3197864
+16426 3195995.97
+1648 3195558.9
+14404 3192729.6
+17867 3188571
+18117 3183229.04
+14289 3182261.6
+53 3182256
+15546 3180180.04
+16245 3178277.46
+1597 3176247.48
+1653 3173456.64
+2845 3171619.61
+15906 3171187.54
+18304 3168571.5
+14068 3167367.6
+6837 3165012.48
+9446 3164446.52
+18889 3156140.96
+16587 3154210.2
+7705 3152977.38
+1120 3151591.17
+17665 3148848
+5311 3146721.86
+14157 3144707.32
+7996 3131351.04
+8663 3130526.32
+18271 3127800.96
+6446 3125685.96
+6972 3125007.06
+2572 3123186.83
+13536 3122527.54
+6196 3122172.48
+9338 3121262.4
+11992 3118647.55
+2580 3118284.37
+9098 3117494.1
+5118 3112661.96
+10184 3109293.4
+9932 3105818.24
+18545 3102273.32
+10963 3099314.5
+8405 3097121.12
+9037 3095195
+179 3091107.28
+1930 3090915.8
+17723 3090624.66
+4308 3089472.75
+8702 3080129.92
+18621 3079984.8
+4501 3079781.1
+3590 3079049.42
+18264 3078858.44
+15648 3078564.06
+5998 3073264
+16904 3072610.8
+3794 3071333.09
+3147 3068485.32
+17221 3068337.22
+4709 3067523.31
+18017 3066743.41
+15613 3063987.86
+16271 3057051.34
+13621 3054774.59
+12919 3054518.5
+12493 3050836.3
+15838 3050645.95
+3273 3048955.15
+8324 3046011.25
+13628 3045324.5
+5522 3044408.5
+2202 3043132.05
+19052 3042566.55
+5767 3041871.7
+17895 3036452.22
+12586 3036386.3
+12425 3035041.52
+13517 3034351.47
+2363 3033336.6
+15060 3032598.51
+6764 3032591.1
+340 3030522
+4723 3028910.25
+3566 3027858.61
+17796 3026838.96
+15384 3023792.64
+16336 3010813.56
+679 3010713.3
+7554 3010667.8
+14553 3009756.96
+8379 3009745.17
+15436 3007499.77
+12471 3003991.86
+18059 3003037.53
+8536 3000746
+19033 2999373.28
+18179 2996151.2
+10711 2996143.17
+17271 2994264.79
+13932 2989023.58
+3101 2987788.16
+14550 2977853.65
+3080 2977232.58
+14533 2976490.49
+14439 2975313.24
+9237 2973124.78
+1205 2971470.28
+12361 2963419.47
+429 2962631.88
+3970 2960418.45
+8403 2957698.45
+1098 2957514
+7932 2955046.14
+16266 2952298.38
+19386 2948854.48
+13147 2947037.91
+2720 2947011.08
+3840 2944219.35
+13482 2942474.88
+9436 2940396.21
+19779 2937105.96
+18032 2933224.38
+7743 2932733.77
+14620 2930766.89
+4606 2927832.59
+18076 2924134.83
+19276 2918176.2
+7483 2915918.95
+8575 2915132.64
+11052 2913140.88
+17251 2908345.8
+8788 2907935.93
+10960 2906511.14
+18782 2903643.78
+19988 2897461.53
+726 2896009.27
+19942 2894251.36
+10864 2892252.48
+17840 2891563.22
+18717 2888939.96
+12391 2886051.3
+18219 2885921.06
+15100 2883342.33
+2491 2880385.74
+12389 2879696.96
+3880 2877770.24
+18579 2874542.48
+13647 2873838.34
+15758 2873804.92
+12917 2873659.6
+18866 2873616.26
+13894 2872986.12
+15200 2872571.93
+9628 2872404.56
+8568 2871598.08
+8389 2870237.88
+5788 2867210.18
+19450 2863310.66
+9440 2863162.92
+16795 2860135.41
+19643 2858987.8
+1974 2856825.84
+14622 2852089.12
+6885 2851437.62
+12532 2848992.64
+1087 2847858.8
+5777 2846407.41
+5629 2846076.12
+6316 2840544.65
+12767 2840514.12
+12134 2840036.91
+14476 2839853.01
+803 2838388.16
+18964 2836942.44
+6020 2833459.2
+10401 2832688.74
+1323 2829964.5
+1151 2829662.44
+1458 2824034.43
+2271 2820756.53
+18740 2814140.8
+7348 2811730.95
+4281 2807190.52
+8043 2804706.24
+3843 2804217.96
+7813 2802350.88
+347 2802245.52
+745 2801725.1
+10388 2799170.58
+18100 2793358.5
+19043 2789013.8
+10644 2787797.01
+16170 2787402.8
+398 2782729.05
+9370 2780078.13
+14504 2780036.04
+1210 2778485.76
+13385 2777445.62
+3799 2775223.6
+11325 2769766.02
+3489 2769554.52
+17181 2769028.5
+6964 2766653.78
+7381 2764898.8
+6253 2764394.64
+5975 2760819.72
+11996 2760687.86
+7570 2758977.12
+4387 2757672
+9014 2755367.42
+9403 2748021.66
+11653 2739731.07
+17697 2739312.29
+958 2738032
+18816 2737140
+14104 2735008.64
+15966 2732250.2
+17912 2724160.95
+7089 2720170.04
+16032 2718976.18
+16891 2717293.32
+19579 2716909.86
+17470 2715048.84
+12408 2712556.52
+4763 2711800.9
+1138 2709709.81
+7363 2708414.4
+7877 2705439.45
+17532 2703698.68
+10512 2701235.92
+11957 2700133.22
+2455 2699593.88
+15119 2696860.8
+9868 2696801.52
+14172 2695307.48
+16120 2689337.82
+13958 2679025.28
+15169 2676686.04
+2648 2672232
+6164 2671317.32
+12701 2669216.4
+16382 2669034.54
+15588 2667212.1
+14830 2666758.15
+9119 2665812.24
+1622 2665206.5
+878 2664045.79
+13269 2662784.12
+619 2655417.63
+18386 2653795.02
+2501 2652260.4
+2310 2651631.09
+19420 2649395.61
+4895 2645152.27
+7553 2643682.07
+17814 2642781.44
+16097 2642500
+10995 2640811.16
+14895 2637733.72
+18546 2637026.71
+9875 2631358.8
+9591 2626899.54
+6001 2625893.76
+7739 2624573.28
+10431 2624379.54
+4544 2615313.75
+16387 2603195.76
+18375 2601407.83
+8395 2598728.44
+18853 2593356.36
+4900 2592813.15
+1302 2592197.76
+17032 2589806.4
+14292 2589749.56
+43 2587359.58
+5221 2587024.04
+397 2579751.46
+17890 2579674.24
+12157 2575510.48
+7340 2574645.83
+19368 2572618.95
+8848 2570819.15
+13789 2570243.26
+14596 2568234.24
+8408 2567434.41
+19726 2565750.42
+13964 2565579.12
+7740 2563027.5
+14768 2560392.6
+11734 2559062.22
+10294 2558257.97
+15032 2557926.22
+9127 2556379.8
+2181 2553175
+16653 2552229.68
+3866 2549994.79
+16814 2548710.76
+1866 2545838.4
+3512 2532626.8
+4145 2529786.15
+12120 2528298.72
+644 2528123.05
+15379 2525181.01
+6392 2524063.08
+2652 2521456.8
+3363 2519202.23
+19167 2517993.18
+16042 2516599.92
+2892 2511854.4
+5711 2509401.72
+14591 2506344.69
+6564 2506277.34
+1231 2505421.24
+5049 2502603
+14576 2501606.69
+10211 2500852.2
+293 2493168.48
+7371 2491134.65
+18154 2491047.2
+9494 2489825.52
+14836 2480432.4
+19471 2480403.75
+802 2478998.33
+12541 2477242.6
+15065 2473563.94
+15995 2472803.2
+9408 2471953.56
+9776 2470447.9
+17325 2468989.05
+3391 2468317.72
+16123 2467022.22
+18758 2463798.06
+407 2460304.47
+6840 2456170.78
+9995 2455155.36
+3877 2453696.65
+5817 2452493.13
+14122 2452226.22
+16699 2450273.98
+8921 2450116.48
+15103 2449861.2
+7637 2449628.72
+3076 2443927.38
+6648 2443248.95
+17116 2442263.72
+1645 2440838.4
+3181 2440017.6
+5966 2431558.08
+15882 2428947.3
+7529 2428381.28
+12836 2427897.33
+18052 2427637.76
+13616 2426638.5
+16615 2424775.08
+18147 2424412.68
+4586 2424123.9
+14403 2423141.96
+11606 2422794.31
+13526 2422212.8
+3677 2421404.46
+5553 2418506.21
+12109 2416514.17
+13118 2415931.8
+1563 2408855.4
+16591 2408045.39
+6411 2404918.53
+10272 2402834.48
+10597 2400247.68
+13700 2398035.86
+9548 2397147.9
+14963 2395781.09
+13325 2390637.58
+13864 2388067.88
+7450 2383447.71
+9275 2382868.4
+5829 2378037.92
+13437 2377806.54
+13594 2375046.3
+11442 2374591.08
+15619 2374052.38
+9063 2374035.84
+5990 2368686.5
+7811 2363829.26
+9525 2362974.53
+5597 2361031.84
+8963 2360774
+1709 2359839.29
+15814 2358656.64
+17613 2357519.04
+5022 2354550.45
+17740 2354242.83
+3388 2351042.26
+13773 2348739.12
+14467 2348665.04
+11544 2345324.45
+349 2344664.13
+10356 2340862.72
+18272 2338754.6
+4627 2337430.84
+327 2335298.46
+19846 2332224.73
+10814 2330319.6
+13102 2326122.75
+18867 2323972
+2824 2323315.08
+19117 2319911.1
+1906 2319757.6
+245 2319450.9
+17318 2317860.39
+3862 2316453.72
+8100 2313874.12
+2958 2312239.47
+10263 2308514.06
+13814 2304940.4
+9394 2303161.74
+18080 2299416.78
+1271 2289526.98
+3327 2278474.48
+8740 2278405.92
+8119 2276428.17
+3368 2274373.62
+7963 2272300.8
+2151 2270932.72
+16995 2270264.68
+9918 2269733.07
+503 2268535.25
+16692 2256484.5
+793 2254198.72
+16455 2252361.86
+6644 2249521.82
+17280 2249437.5
+6813 2248982
+4674 2246915.32
+16325 2244369.8
+182 2243290
+4626 2242474.35
+10860 2241291.6
+14034 2241220.8
+2476 2240855.2
+4253 2239985.64
+3211 2239871.02
+1290 2233313
+8479 2232189.04
+11895 2231607
+3487 2230171.62
+14870 2229915.37
+16328 2229483.96
+18585 2228215.5
+7638 2228208.08
+5436 2225672.28
+14594 2223005.07
+4532 2215711.02
+7586 2210562.51
+11870 2205182.82
+18487 2203653.6
+9179 2202720.52
+16500 2201185.31
+3679 2200592.7
+12803 2198295
+18056 2196741.9
+11396 2195645.64
+5087 2194120.72
+8067 2192048.64
+15357 2191646.58
+4491 2189713.5
+208 2189046.8
+10958 2188766.82
+9126 2188410.5
+15084 2184327.02
+18850 2183309.52
+3398 2180250
+16137 2177318.76
+211 2174808.96
+18422 2174381
+15840 2173510.4
+19553 2173079.77
+8221 2169992.16
+17000 2169611.16
+6755 2168505.15
+10817 2167710.68
+8327 2167650.6
+543 2167368
+4553 2163371.52
+15019 2162288
+334 2162178.48
+8516 2161479.04
+11349 2158941.88
+3902 2157027.86
+14731 2155302.24
+326 2153380.08
+11403 2151242.3
+11657 2150446.08
+9496 2149219.01
+8110 2149120.13
+5153 2148527.25
+884 2148324.98
+8637 2146185.1
+2364 2145790.72
+12386 2145001.47
+10133 2144903.96
+9895 2143324.8
+13755 2142539.4
+4327 2138501.4
+3369 2137408.76
+5815 2136985
+19357 2132657.28
+2675 2124158.72
+17869 2123991.72
+11702 2122132.99
+17257 2117850.64
+9952 2116686.32
+3881 2111457.15
+10951 2111185.58
+2128 2109702.3
+6699 2106578.4
+3155 2103636.64
+16649 2101956.2
+15257 2100297.75
+9978 2099566.56
+16810 2098301.44
+10653 2093388.7
+10476 2092766.48
+10883 2087495.28
+9704 2086967.61
+1119 2085182.84
+19139 2079788.34
+2144 2078391.14
+9135 2076377.8
+18548 2075584.32
+10545 2075230.35
+6220 2074341.72
+8616 2072887.65
+5230 2072161.74
+13916 2070504.72
+4299 2069922.96
+894 2069688.16
+17847 2063367.04
+18879 2061902.25
+13036 2061600.17
+10606 2060492.4
+9454 2060016.48
+118 2059808.86
+9601 2059715.76
+13769 2057668.08
+1987 2057289.27
+13863 2055368
+13562 2054754.24
+1840 2054183.92
+17995 2053221.9
+17389 2051128.2
+15168 2045987.49
+2139 2045365.4
+4024 2044243.1
+8964 2041648.85
+181 2040167.04
+7628 2039548.92
+3 2038846.09
+15553 2036958.91
+11355 2035405.6
+13006 2034991.2
+3091 2031393.51
+1281 2030628.48
+1408 2028621.66
+18211 2024538.67
+2287 2020754.32
+6228 2019198.82
+4362 2018495.25
+10873 2013280.32
+7383 2009581.92
+1386 2006544.26
+9820 2005815.76
+18134 2003409.73
+15727 2000654.5
+157 2000148.16
+19571 1999891.11
+17728 1997944.4
+5278 1996644.21
+17737 1994653.76
+10220 1989890.98
+1397 1984509.22
+6195 1983928.26
+4270 1983726.95
+16965 1983286.25
+1683 1980638.64
+13086 1978609.4
+7124 1974039.38
+5211 1973843.76
+6794 1973149.47
+257 1973035.44
+6995 1968281.55
+8447 1967292.7
+15873 1967257.89
+12862 1964014.13
+8295 1961467.08
+931 1958825.22
+6876 1957359.48
+1932 1954592.4
+1061 1952688.06
+18108 1951143.67
+5138 1950861
+12598 1950211.61
+10829 1943924.62
+11950 1941211
+12076 1939323.96
+2176 1938691.37
+6616 1937401.88
+5893 1934358.58
+976 1933066.8
+13173 1932557.52
+14947 1929229.98
+16857 1928814.8
+13403 1928702.88
+4819 1926969.68
+13127 1926929.83
+6871 1926787.68
+15465 1925145.09
+1131 1920005.5
+11845 1913576.4
+8364 1909122.2
+16588 1904272.37
+6759 1903906.29
+11586 1901895.65
+8145 1901787.66
+17333 1897297.2
+13290 1890633.75
+6499 1887621
+4881 1887535.92
+7147 1886710.2
+3883 1886567.78
+18911 1885597.12
+11336 1883573.6
+8653 1883275.76
+19476 1881492.48
+14799 1880543.4
+14491 1879219.92
+11815 1877434.34
+3173 1874302.1
+7161 1873023.45
+14631 1873015.3
+4247 1869912.96
+3568 1865824.4
+1500 1865451.03
+11833 1863665.23
+495 1860771.3
+6776 1855589.17
+11374 1855221.12
+5637 1853782.17
+3597 1852826.8
+981 1852083.6
+16076 1850349.69
+17597 1845420.95
+19609 1843185.48
+10997 1843072.02
+3403 1842975
+897 1842845.1
+16697 1840630.68
+17644 1840597.8
+6485 1838812.02
+5492 1836202.88
+12038 1835075.06
+9325 1832634.84
+10637 1832347.44
+11318 1830158.39
+4357 1828730
+18553 1826335.2
+12623 1825950.85
+961 1825869.6
+1677 1821816.9
+8211 1820432.52
+19719 1819333.55
+19663 1819074.35
+16296 1818353.77
+16527 1817834.42
+4964 1815400.02
+1769 1812929.2
+13126 1808799.96
+7854 1807608.06
+18380 1803641.22
+6584 1802346.98
+7665 1801765.35
+16553 1796146.78
+17761 1795095.72
+11179 1794890.3
+15171 1794148.72
+3018 1793183.88
+15741 1788612
+5331 1783901.35
+9860 1775071.26
+7984 1774302.75
+15354 1774270.77
+17884 1774212.44
+16257 1771869.71
+10696 1768645.2
+2104 1767902.64
+14465 1764946.4
+10089 1764692.32
+6719 1762699.54
+3648 1760594.42
+7241 1759913.59
+11122 1757430.04
+17019 1752560.65
+13877 1744271.1
+15325 1743826.26
+17860 1739870.44
+2236 1739795.8
+4436 1738760.32
+7701 1738670.4
+8147 1736855.16
+6676 1736341.44
+19505 1735413.43
+9885 1731366.26
+2112 1725934.08
+5330 1722196.98
+3561 1720377.96
+10104 1714419.16
+16362 1712457.38
+15573 1712365.44
+15006 1711381.35
+14629 1709942.05
+9612 1709528.38
+19910 1709211.15
+13145 1708907.46
+11494 1707973.68
+15895 1706999.45
+8239 1705479.1
+2403 1705331.1
+19436 1702706
+3476 1702335.8
+6828 1702292.08
+771 1701589.5
+8448 1700312.44
+3755 1699047.03
+13895 1698679.03
+9785 1698056.37
+6180 1695571.53
+532 1694356.15
+6741 1692552.42
+19964 1692367.64
+3747 1691244.6
+3253 1690719.42
+16119 1688339.25
+7113 1681911
+12368 1681219.8
+16378 1679705.6
+1393 1675545.35
+11119 1675453.44
+4469 1674023.49
+6955 1672618.9
+11579 1672345.32
+19898 1671781.7
+15351 1659204.3
+6133 1658215.46
+9110 1658054.68
+2979 1656016.74
+18764 1653708.48
+8995 1653627.58
+13096 1651408.67
+15062 1650548.02
+7924 1650202.4
+10076 1647970.24
+15859 1646036.28
+17932 1642640.66
+19694 1642089.5
+13827 1642001.31
+17963 1639689
+10698 1635848.26
+18003 1633530.78
+8416 1633366.77
+476 1631154.06
+2806 1630782.8
+12129 1628615.47
+11215 1626624.7
+14061 1624933.44
+5956 1623586.1
+9043 1622670.4
+13287 1621980.36
+11410 1621420.9
+13990 1621268.2
+12952 1619215.18
+15181 1619088.68
+9784 1618120.53
+10733 1616168.88
+16054 1614531.23
+5864 1614397.83
+1875 1611927
+17381 1611664.8
+14562 1607467.92
+575 1605941.73
+2005 1605591.72
+4332 1605448.83
+4653 1602596.3
+15403 1601830.44
+17430 1599681.42
+4798 1593630.5
+12991 1593321.52
+15653 1593138.66
+10066 1593049.06
+8892 1592100.9
+6708 1590159.12
+9825 1589403.92
+8271 1588475.41
+17084 1584280.88
+4003 1583631
+869 1582643.16
+16400 1582313.2
+19088 1581708.56
+6581 1581346.8
+9481 1581048.6
+6092 1580846.49
+3624 1578777.3
+6503 1578507.78
+14557 1578280.96
+2428 1577543.92
+15513 1573560.21
+4641 1573363.54
+10152 1570213.6
+5932 1566902.52
+7482 1561323.5
+13745 1558358.34
+2251 1558274.7
+9845 1558068.12
+7603 1557388.2
+1809 1553837.2
+18128 1547643.36
+8086 1543199.04
+14948 1541721.57
+16725 1540948.5
+2999 1540317.66
+8861 1540008.47
+1964 1538815.25
+19374 1537884.78
+15428 1535994.36
+7449 1534782.48
+16884 1534509.16
+10271 1534397.34
+11782 1529963.22
+8184 1529750.7
+4560 1527433.24
+4616 1525374.46
+3814 1524077.04
+17265 1523932.08
+16520 1522906.28
+10475 1518705.06
+5094 1517317.83
+8626 1515142.07
+19895 1512286.68
+19933 1506235.36
+6854 1505626
+13995 1505562.18
+7102 1504945.67
+9079 1501237.2
+18329 1500146.9
+3742 1496990.77
+12395 1496904.43
+12214 1496489.4
+12298 1495554.3
+4978 1495389.5
+2927 1494280.1
+2119 1494151.14
+15143 1492039.75
+14548 1487406.6
+840 1486128.98
+5902 1486097.28
+10614 1482144.72
+5895 1481356.8
+15958 1480951.6
+11408 1479948.96
+8407 1474236
+6243 1471007.85
+10389 1469004.46
+13871 1468938.64
+19811 1464597.09
+10495 1464290.49
+4389 1463010.83
+1311 1461703.36
+17874 1459408.88
+6597 1458761.87
+19211 1456741.63
+12879 1456178.24
+8840 1455731.46
+14755 1454890.6
+16957 1454465.96
+9257 1454388.76
+5193 1454011.32
+6884 1452474.6
+19948 1452024
+15076 1448395
+16016 1447557.45
+11693 1445839.68
+6975 1440516.96
+4290 1439768.46
+18900 1438722.1
+14383 1438477.92
+15098 1435941.78
+9322 1435282.8
+458 1433040.45
+10042 1432906.35
+5052 1431900.9
+6600 1431116.55
+3630 1428665.04
+9636 1428193.84
+16511 1427308.74
+4045 1427248.35
+19562 1426348.82
+8814 1425690.09
+2616 1425178.04
+4587 1425109.4
+148 1424237.37
+2712 1423780.26
+10863 1423386.16
+16096 1421942.09
+18936 1421938.65
+18327 1419872.92
+11620 1419050.1
+3740 1418609.85
+3457 1418603.5
+1185 1417637.47
+8178 1417357.26
+17791 1413293.13
+13608 1411323.12
+17849 1409613.5
+6814 1406228.4
+14022 1406138.04
+14231 1403771.52
+19546 1402854.6
+19619 1402389.16
+5609 1402302.54
+5342 1401567.59
+3084 1401096.1
+5708 1400334.9
+17998 1399862.45
+19850 1397630.33
+14004 1395443.1
+13071 1394653.24
+2797 1393747.58
+2866 1392947.25
+19809 1389067.68
+13600 1380865.8
+13614 1380654.36
+5884 1380319.74
+9404 1378623.66
+10656 1376954.32
+12324 1376502.4
+7325 1375030.43
+13295 1373987.34
+11864 1373555.68
+6987 1373481.51
+8386 1371854.41
+10916 1370374.32
+12867 1369058.11
+14668 1369040.34
+13383 1367342.3
+18572 1366953.96
+1152 1366861.38
+6015 1366452.18
+3344 1366185.15
+7889 1365521.92
+13345 1364088.88
+6276 1363421.62
+8069 1361824.2
+17509 1360892.49
+15137 1358678.07
+17163 1357391.52
+4704 1356692.4
+8609 1356578.19
+12644 1356088.14
+17141 1356022.38
+11805 1354826.78
+6386 1354187.22
+3004 1352173.44
+8634 1350211.8
+4399 1349881.2
+10362 1349411.34
+1572 1348835.2
+7359 1348224.1
+11884 1346696.82
+11671 1346424.15
+5350 1346359.28
+3119 1345996.48
+5307 1345356
+16117 1345045.12
+8715 1342665.72
+5398 1341179.28
+7627 1338820.56
+8457 1337714.68
+4958 1334732.71
+84 1334146.71
+6932 1333235.36
+757 1332921.07
+4076 1332441
+1751 1329112.32
+15701 1327052.16
+4119 1326549.9
+1562 1325604.28
+8741 1325517.6
+1135 1325422.71
+1002 1323418.65
+5832 1323085.71
+5368 1322793.96
+5382 1322628.84
+5616 1319082.26
+2832 1318691.95
+3895 1317858.44
+8629 1317756.51
+5709 1317058.68
+18383 1316451.05
+15797 1314806.64
+1900 1313660.4
+13882 1310455.86
+6785 1309877.8
+14855 1309280.76
+7761 1308602.24
+14268 1306810.4
+6257 1306056.96
+19002 1305509.52
+5095 1303729.02
+10320 1301657.58
+7826 1299561.68
+13359 1298717.14
+7436 1298127.36
+5644 1295055.77
+11327 1290526.41
+5277 1289329.65
+15932 1286235.84
+14322 1284809.36
+144 1284270.12
+3043 1281162.79
+16788 1280955.34
+17136 1280443.12
+12560 1279117.95
+13833 1278834.75
+5414 1277893.26
+12582 1277592.32
+4644 1277535
+14032 1277077.88
+18325 1271719.68
+7072 1271228.48
+16868 1267469.42
+8137 1267425.81
+5976 1266206.85
+14125 1265569.05
+13299 1265287.55
+18376 1264249.3
+6157 1261759.92
+5002 1261669.64
+13368 1260918.6
+15589 1260059.76
+2149 1258981.44
+9639 1256283.38
+11689 1256027.92
+9083 1245924.24
+16231 1242625.65
+5084 1242385.28
+11634 1240760.18
+15617 1239731.25
+9865 1237181.62
+14212 1236365.52
+10325 1235223.36
+19582 1235105.76
+740 1234746.81
+19231 1233623.1
+16840 1233063.85
+5703 1231744.33
+5761 1229435.2
+15630 1226611.62
+10408 1224698.4
+9177 1221942.51
+13389 1221666.75
+6104 1221577.92
+9673 1218826.64
+2707 1217124.48
+18672 1214208.8
+5112 1209590.2
+6264 1208318.5
+18496 1207881.75
+10971 1207183.52
+19059 1206729.9
+431 1205938.44
+3821 1201192.75
+826 1200454.62
+3317 1200440.9
+19689 1198899.52
+19641 1198797.99
+6379 1197195.5
+814 1194417.4
+18643 1194000.78
+11865 1193965.76
+12393 1193896.8
+9218 1193660.58
+8674 1191881.32
+8582 1191804.02
+13084 1191508
+18844 1190239.96
+16061 1189935
+6134 1185550.8
+8628 1183245.6
+8884 1181547.48
+7697 1181032.5
+9044 1180922.6
+13257 1180158.57
+8066 1178808.12
+5876 1177376.8
+14694 1177059.31
+16062 1175391
+9104 1175178.9
+11600 1175091.06
+10337 1172684.92
+19188 1172349.78
+8833 1171372.93
+6895 1170602.07
+14100 1168878.4
+13538 1168554.28
+3408 1166645.16
+1860 1165673.68
+13436 1164278.7
+19325 1162733.7
+7403 1161982
+4882 1161404.81
+13105 1161320.58
+17880 1161256.02
+19284 1160927.6
+13476 1159035.15
+18913 1158208.3
+18523 1158135
+12508 1157538.45
+9090 1156362.64
+17653 1154338.08
+3926 1152652.52
+10183 1148324.57
+7556 1146268.14
+16436 1142656.47
+4741 1141614
+15651 1141497.93
+3183 1140081.36
+9532 1139902.5
+16403 1139306.37
+2368 1137421.16
+3889 1136395.5
+2885 1135838.14
+7851 1135110.76
+16234 1135017.24
+12746 1134531.04
+2647 1132941.12
+5373 1132158.01
+10340 1132004.24
+8873 1131949.28
+1132 1131338.88
+15594 1131328.62
+4376 1130282.2
+240 1126682.48
+2231 1124447.15
+929 1121383.92
+11599 1119307.27
+3765 1119093.5
+17635 1118420.16
+7119 1118285.08
+15121 1117715.34
+11858 1116963.54
+16963 1116929.45
+16356 1113648.98
+6924 1112198.4
+16223 1111257
+18091 1110043.02
+12628 1108954.8
+16043 1108831.05
+9402 1108290.48
+708 1107084
+4078 1105993.96
+17593 1104713.4
+12776 1104362.59
+7583 1102813.53
+14619 1102675.8
+8842 1100110.26
+4196 1099726.55
+2019 1098178.64
+6863 1097246.36
+6489 1096503.07
+2459 1094813.04
+11964 1094485.02
+3236 1093969.8
+17647 1093809.15
+17648 1093114.62
+119 1092687.48
+9626 1092080
+9124 1091569.68
+13175 1089851.76
+2532 1088706.35
+16083 1088295.39
+8874 1086011.34
+12872 1082970.3
+19821 1082520.84
+4800 1080389.7
+18696 1079685.36
+19545 1079184.33
+13120 1077742.28
+10588 1076203.83
+17696 1075092.72
+14651 1073222.23
+903 1071146.76
+5858 1070259.48
+8302 1069504.8
+18728 1069225.51
+18026 1068569
+19383 1066907.58
+18690 1065930.9
+5924 1065143.12
+4880 1065011.75
+12439 1064381.19
+16529 1062371.7
+19653 1057683.56
+3136 1056810.44
+18932 1056193.65
+2124 1054160.52
+16851 1052646.84
+10123 1051624
+5618 1048447.93
+19851 1045187.85
+16278 1044808.38
+11479 1044276.22
+13263 1042046.2
+6041 1041123.38
+7193 1040455.32
+19408 1039430.01
+11260 1036828.52
+5179 1035633.44
+1331 1034398
+7706 1034249.4
+8436 1033549.35
+1801 1031886
+4170 1031642.9
+11827 1031139.39
+17114 1027985.88
+18278 1026583.11
+1995 1025165.68
+7667 1022980.15
+6559 1021635.45
+17488 1021612.13
+16059 1019781.19
+7633 1018782.57
+10032 1016809.5
+2899 1016438.76
+14628 1016033.2
+10126 1015846.78
+3884 1014413.5
+16913 1013604.4
+18644 1010288.1
+19870 1007919.36
+18564 1007416.2
+10179 1004920
+883 1004650.68
+3627 1004461.04
diff --git a/vortex-sqllogictest/slt/tpch/results/q12.slt.no b/vortex-sqllogictest/slt/tpch/results/q12.slt.no
new file mode 100644
index 00000000000..1851a8ecd29
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q12.slt.no
@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TII
+select
+    l_shipmode,
+    sum(case
+            when o_orderpriority = '1-URGENT'
+                or o_orderpriority = '2-HIGH'
+                then 1
+            else 0
+        end) as high_line_count,
+    sum(case
+            when o_orderpriority <> '1-URGENT'
+                and o_orderpriority <> '2-HIGH'
+                then 1
+            else 0
+        end) as low_line_count
+from
+    lineitem
+        join
+    orders
+    on
+            l_orderkey = o_orderkey
+where
+        l_shipmode in ('MAIL', 'SHIP')
+  and l_commitdate < l_receiptdate
+  and l_shipdate < l_commitdate
+  and l_receiptdate >= date '1994-01-01'
+  and l_receiptdate < date '1995-01-01'
+group by
+    l_shipmode
+order by
+    l_shipmode;
+----
+MAIL 647 945
+SHIP 620 943
diff --git a/vortex-sqllogictest/slt/tpch/results/q13.slt.no b/vortex-sqllogictest/slt/tpch/results/q13.slt.no
new file mode 100644
index 00000000000..85fc9ca3ccc
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q13.slt.no
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query II
+select
+    c_count,
+    count(*) as custdist
+from
+    (
+        select
+            c_custkey,
+            count(o_orderkey)
+        from
+            customer left outer join orders on
+                        c_custkey = o_custkey
+                    and o_comment not like '%special%requests%'
+        group by
+            c_custkey
+    ) as c_orders (c_custkey, c_count)
+group by
+    c_count
+order by
+    custdist desc,
+    c_count desc;
+----
+0 5000
+10 665
+9 657
+11 621
+12 567
+8 564
+13 492
+18 482
+7 480
+20 456
+14 456
+16 449
+19 447
+15 432
+17 423
+21 412
+22 371
+6 337
+23 323
+24 256
+25 204
+5 204
+26 155
+27 141
+28 97
+4 94
+29 64
+3 48
+30 27
+31 26
+32 14
+33 11
+2 11
+34 6
+35 5
+1 2
+36 1
diff --git a/vortex-sqllogictest/slt/tpch/results/q14.slt.no b/vortex-sqllogictest/slt/tpch/results/q14.slt.no
new file mode 100644
index 00000000000..a79678fb317
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q14.slt.no
@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query R
+select
+            100.00 * sum(case
+                             when p_type like 'PROMO%'
+                                 then l_extendedprice * (1 - l_discount)
+                             else 0
+            end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue
+from
+    lineitem,
+    part
+where
+        l_partkey = p_partkey
+  and l_shipdate >= date '1995-09-01'
+  and l_shipdate < date '1995-10-01';
+----
+16.283855689006
diff --git a/vortex-sqllogictest/slt/tpch/results/q15.slt.no b/vortex-sqllogictest/slt/tpch/results/q15.slt.no
new file mode 100644
index 00000000000..691e88b3a07
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q15.slt.no
@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query ITTTR
+WITH revenue AS (select l_suppkey                               as supplier_no,
+                        sum(l_extendedprice * (1 - l_discount)) as total_revenue
+                 from lineitem
+                 where l_shipdate >= date '1996-01-01'
+                   and l_shipdate < date '1996-01-01' + interval '3' month
+                 group by l_suppkey)
+select s_suppkey,
+       s_name,
+       s_address,
+       s_phone,
+       total_revenue
+from supplier,
+     revenue
+where s_suppkey = supplier_no
+  and total_revenue = (select max(total_revenue)
+                       from revenue)
+order by s_suppkey;
+----
+677 Supplier#000000677 8mhrffG7D2WJBSQbOGstQ 23-290-639-3315 1614410.2928
diff --git a/vortex-sqllogictest/slt/tpch/results/q16.slt.no b/vortex-sqllogictest/slt/tpch/results/q16.slt.no
new file mode 100644
index 00000000000..df3f8d67c4e
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q16.slt.no
@@ -0,0 +1,2797 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TTII
+select
+    p_brand,
+    p_type,
+    p_size,
+    count(distinct ps_suppkey) as supplier_cnt
+from
+    partsupp,
+    part
+where
+        p_partkey = ps_partkey
+  and p_brand <> 'Brand#45'
+  and p_type not like 'MEDIUM POLISHED%'
+  and p_size in (49, 14, 23, 45, 19, 3, 36, 9)
+  and ps_suppkey not in (
+    select
+        s_suppkey
+    from
+        supplier
+    where
+            s_comment like '%Customer%Complaints%'
+)
+group by
+    p_brand,
+    p_type,
+    p_size
+order by
+    supplier_cnt desc,
+    p_brand,
+    p_type,
+    p_size;
+----
+Brand#14 SMALL ANODIZED NICKEL 45 12
+Brand#22 SMALL BURNISHED BRASS 19 12
+Brand#25 PROMO POLISHED COPPER 14 12
+Brand#35 LARGE ANODIZED STEEL 45 12
+Brand#35 PROMO BRUSHED COPPER 9 12
+Brand#51 ECONOMY ANODIZED STEEL 9 12
+Brand#53 LARGE BRUSHED NICKEL 45 12
+Brand#11 ECONOMY POLISHED COPPER 14 8
+Brand#11 LARGE PLATED STEEL 23 8
+Brand#11 PROMO POLISHED STEEL 23 8
+Brand#11 STANDARD ANODIZED COPPER 9 8
+Brand#12 ECONOMY BURNISHED BRASS 9 8
+Brand#12 LARGE ANODIZED BRASS 14 8
+Brand#12 SMALL ANODIZED TIN 23 8
+Brand#12 SMALL BRUSHED NICKEL 23 8
+Brand#12 STANDARD ANODIZED BRASS 3 8
+Brand#12 STANDARD BURNISHED TIN 23 8
+Brand#13 ECONOMY POLISHED BRASS 9 8
+Brand#13 LARGE BURNISHED COPPER 45 8
+Brand#13 MEDIUM ANODIZED STEEL 23 8
+Brand#13 MEDIUM PLATED NICKEL 3 8
+Brand#13 PROMO BURNISHED BRASS 9 8
+Brand#13 PROMO POLISHED BRASS 3 8
+Brand#13 PROMO POLISHED TIN 36 8
+Brand#13 SMALL BURNISHED STEEL 23 8
+Brand#13 STANDARD BRUSHED STEEL 9 8
+Brand#14 ECONOMY BRUSHED TIN 3 8
+Brand#14 ECONOMY BURNISHED TIN 23 8
+Brand#14 PROMO BRUSHED STEEL 9 8
+Brand#14 PROMO PLATED TIN 45 8
+Brand#15 ECONOMY PLATED TIN 9 8
+Brand#15 STANDARD BRUSHED COPPER 14 8
+Brand#15 STANDARD PLATED TIN 3 8
+Brand#21 ECONOMY POLISHED TIN 3 8
+Brand#21 PROMO POLISHED COPPER 9 8
+Brand#21 PROMO POLISHED TIN 49 8
+Brand#21 SMALL POLISHED STEEL 3 8
+Brand#21 STANDARD PLATED BRASS 49 8
+Brand#21 STANDARD PLATED NICKEL 49 8
+Brand#22 ECONOMY ANODIZED TIN 49 8
+Brand#22 ECONOMY BRUSHED BRASS 14 8
+Brand#22 LARGE BURNISHED TIN 36 8
+Brand#22 MEDIUM ANODIZED STEEL 36 8
+Brand#22 MEDIUM PLATED STEEL 9 8
+Brand#22 PROMO POLISHED NICKEL 9 8
+Brand#22 SMALL ANODIZED STEEL 19 8
+Brand#22 STANDARD ANODIZED COPPER 23 8
+Brand#23 ECONOMY BRUSHED NICKEL 23 8
+Brand#23 LARGE ANODIZED BRASS 9 8
+Brand#23 LARGE ANODIZED STEEL 23 8
+Brand#23 SMALL BRUSHED COPPER 23 8
+Brand#23 STANDARD BRUSHED TIN 3 8
+Brand#23 STANDARD BURNISHED NICKEL 49 8
+Brand#23 STANDARD PLATED NICKEL 36 8
+Brand#24 ECONOMY ANODIZED BRASS 19 8
+Brand#24 ECONOMY POLISHED BRASS 36 8
+Brand#24 LARGE BURNISHED STEEL 14 8
+Brand#24 MEDIUM PLATED NICKEL 36 8
+Brand#25 ECONOMY BRUSHED STEEL 49 8
+Brand#25 MEDIUM BURNISHED TIN 3 8
+Brand#25 PROMO ANODIZED TIN 36 8
+Brand#25 PROMO PLATED NICKEL 3 8
+Brand#25 SMALL BURNISHED BRASS 3 8
+Brand#31 LARGE ANODIZED BRASS 3 8
+Brand#31 SMALL ANODIZED COPPER 3 8
+Brand#31 SMALL ANODIZED NICKEL 9 8
+Brand#31 SMALL ANODIZED STEEL 14 8
+Brand#32 MEDIUM ANODIZED STEEL 49 8
+Brand#32 MEDIUM BURNISHED COPPER 19 8
+Brand#32 SMALL BURNISHED STEEL 23 8
+Brand#32 STANDARD BURNISHED STEEL 45 8
+Brand#34 ECONOMY ANODIZED NICKEL 49 8
+Brand#34 LARGE BURNISHED TIN 49 8
+Brand#34 MEDIUM BURNISHED NICKEL 3 8
+Brand#34 PROMO ANODIZED TIN 3 8
+Brand#34 SMALL BRUSHED TIN 3 8
+Brand#34 STANDARD BURNISHED TIN 23 8
+Brand#35 MEDIUM BRUSHED STEEL 45 8
+Brand#35 PROMO BURNISHED STEEL 14 8
+Brand#35 SMALL BURNISHED STEEL 23 8
+Brand#35 SMALL POLISHED COPPER 14 8
+Brand#35 STANDARD PLATED COPPER 9 8
+Brand#41 ECONOMY BRUSHED BRASS 23 8
+Brand#41 LARGE BURNISHED STEEL 23 8
+Brand#41 PROMO BURNISHED TIN 14 8
+Brand#41 PROMO PLATED STEEL 36 8
+Brand#41 PROMO POLISHED TIN 19 8
+Brand#41 SMALL BURNISHED COPPER 23 8
+Brand#42 LARGE POLISHED TIN 14 8
+Brand#42 MEDIUM ANODIZED TIN 49 8
+Brand#42 MEDIUM BRUSHED TIN 14 8
+Brand#42 MEDIUM BURNISHED NICKEL 23 8
+Brand#42 MEDIUM PLATED COPPER 45 8
+Brand#42 MEDIUM PLATED TIN 45 8
+Brand#42 SMALL PLATED COPPER 36 8
+Brand#43 ECONOMY BRUSHED STEEL 45 8
+Brand#43 LARGE BRUSHED COPPER 19 8
+Brand#43 PROMO BRUSHED BRASS 36 8
+Brand#43 SMALL BURNISHED TIN 45 8
+Brand#43 SMALL PLATED COPPER 45 8
+Brand#44 PROMO POLISHED TIN 23 8
+Brand#44 SMALL POLISHED NICKEL 14 8
+Brand#44 SMALL POLISHED TIN 45 8
+Brand#44 STANDARD BURNISHED COPPER 3 8
+Brand#51 LARGE ANODIZED BRASS 19 8
+Brand#51 LARGE POLISHED COPPER 23 8
+Brand#51 MEDIUM ANODIZED TIN 9 8
+Brand#51 MEDIUM ANODIZED TIN 14 8
+Brand#51 MEDIUM BURNISHED NICKEL 23 8
+Brand#51 SMALL ANODIZED COPPER 45 8
+Brand#51 SMALL ANODIZED COPPER 49 8
+Brand#51 SMALL BRUSHED COPPER 45 8
+Brand#51 SMALL BRUSHED TIN 36 8
+Brand#51 STANDARD POLISHED TIN 3 8
+Brand#52 ECONOMY ANODIZED STEEL 3 8
+Brand#52 ECONOMY PLATED TIN 19 8
+Brand#52 LARGE PLATED TIN 3 8
+Brand#52 MEDIUM ANODIZED TIN 19 8
+Brand#52 MEDIUM BURNISHED COPPER 3 8
+Brand#52 PROMO POLISHED BRASS 23 8
+Brand#52 SMALL PLATED COPPER 36 8
+Brand#52 SMALL POLISHED NICKEL 9 8
+Brand#52 STANDARD POLISHED NICKEL 45 8
+Brand#53 ECONOMY POLISHED STEEL 45 8
+Brand#53 LARGE POLISHED NICKEL 3 8
+Brand#53 SMALL BRUSHED COPPER 14 8
+Brand#53 STANDARD PLATED STEEL 45 8
+Brand#54 ECONOMY POLISHED BRASS 49 8
+Brand#54 ECONOMY POLISHED TIN 23 8
+Brand#54 LARGE ANODIZED NICKEL 49 8
+Brand#54 MEDIUM BRUSHED STEEL 9 8
+Brand#54 SMALL BURNISHED NICKEL 14 8
+Brand#54 SMALL PLATED TIN 14 8
+Brand#54 STANDARD BURNISHED STEEL 14 8
+Brand#54 STANDARD PLATED BRASS 23 8
+Brand#55 MEDIUM BURNISHED TIN 36 8
+Brand#55 PROMO ANODIZED BRASS 14 8
+Brand#55 STANDARD BURNISHED COPPER 45 8
+Brand#15 STANDARD PLATED TIN 36 7
+Brand#23 SMALL POLISHED BRASS 49 7
+Brand#42 STANDARD PLATED COPPER 19 7
+Brand#51 LARGE POLISHED NICKEL 14 7
+Brand#11 ECONOMY ANODIZED BRASS 19 4
+Brand#11 ECONOMY ANODIZED BRASS 45 4
+Brand#11 ECONOMY ANODIZED NICKEL 36 4
+Brand#11 ECONOMY BRUSHED COPPER 3 4
+Brand#11 ECONOMY BRUSHED COPPER 9 4
+Brand#11 ECONOMY BRUSHED STEEL 9 4
+Brand#11 ECONOMY BRUSHED STEEL 36 4
+Brand#11 ECONOMY BURNISHED BRASS 36 4
+Brand#11 ECONOMY BURNISHED COPPER 9 4
+Brand#11 ECONOMY BURNISHED COPPER 49 4
+Brand#11 ECONOMY BURNISHED NICKEL 14 4
+Brand#11 ECONOMY BURNISHED NICKEL 49 4
+Brand#11 ECONOMY PLATED COPPER 19 4
+Brand#11 ECONOMY PLATED NICKEL 45 4
+Brand#11 ECONOMY PLATED TIN 9 4
+Brand#11 ECONOMY POLISHED BRASS 3 4
+Brand#11 ECONOMY POLISHED COPPER 3 4
+Brand#11 ECONOMY POLISHED COPPER 45 4
+Brand#11 ECONOMY POLISHED NICKEL 36 4
+Brand#11 ECONOMY POLISHED STEEL 23 4
+Brand#11 ECONOMY POLISHED TIN 14 4
+Brand#11 LARGE ANODIZED COPPER 23 4
+Brand#11 LARGE ANODIZED NICKEL 9 4
+Brand#11 LARGE ANODIZED STEEL 9 4
+Brand#11 LARGE ANODIZED TIN 45 4
+Brand#11 LARGE BRUSHED STEEL 19 4
+Brand#11 LARGE BRUSHED TIN 3 4
+Brand#11 LARGE BRUSHED TIN 14 4
+Brand#11 LARGE BURNISHED COPPER 9 4
+Brand#11 LARGE BURNISHED COPPER 19 4
+Brand#11 LARGE BURNISHED STEEL 23 4
+Brand#11 LARGE BURNISHED TIN 9 4
+Brand#11 LARGE PLATED COPPER 23 4
+Brand#11 LARGE PLATED TIN 9 4
+Brand#11 LARGE PLATED TIN 14 4
+Brand#11 LARGE PLATED TIN 23 4
+Brand#11 LARGE POLISHED NICKEL 49 4
+Brand#11 MEDIUM ANODIZED BRASS 45 4
+Brand#11 MEDIUM ANODIZED TIN 14 4
+Brand#11 MEDIUM BRUSHED BRASS 14 4
+Brand#11 MEDIUM BRUSHED BRASS 45 4
+Brand#11 MEDIUM BRUSHED NICKEL 14 4
+Brand#11 MEDIUM BRUSHED NICKEL 36 4
+Brand#11 MEDIUM BRUSHED STEEL 19 4
+Brand#11 MEDIUM BURNISHED COPPER 9 4
+Brand#11 MEDIUM BURNISHED TIN 36 4
+Brand#11 MEDIUM PLATED BRASS 3 4
+Brand#11 MEDIUM PLATED TIN 19 4
+Brand#11 PROMO ANODIZED BRASS 3 4
+Brand#11 PROMO ANODIZED BRASS 19 4
+Brand#11 PROMO ANODIZED BRASS 45 4
+Brand#11 PROMO ANODIZED BRASS 49 4
+Brand#11 PROMO ANODIZED STEEL 23 4
+Brand#11 PROMO ANODIZED TIN 45 4
+Brand#11 PROMO BRUSHED BRASS 23 4
+Brand#11 PROMO BRUSHED STEEL 3 4
+Brand#11 PROMO BURNISHED BRASS 23 4
+Brand#11 PROMO BURNISHED BRASS 36 4
+Brand#11 PROMO BURNISHED BRASS 49 4
+Brand#11 PROMO BURNISHED TIN 9 4
+Brand#11 PROMO PLATED BRASS 9 4
+Brand#11 PROMO PLATED BRASS 45 4
+Brand#11 PROMO PLATED NICKEL 19 4
+Brand#11 PROMO POLISHED BRASS 3 4
+Brand#11 PROMO POLISHED BRASS 9 4
+Brand#11 PROMO POLISHED BRASS 19 4
+Brand#11 PROMO POLISHED COPPER 14 4
+Brand#11 PROMO POLISHED COPPER 45 4
+Brand#11 PROMO POLISHED TIN 49 4
+Brand#11 SMALL ANODIZED COPPER 36 4
+Brand#11 SMALL ANODIZED NICKEL 3 4
+Brand#11 SMALL ANODIZED NICKEL 14 4
+Brand#11 SMALL ANODIZED TIN 14 4
+Brand#11 SMALL ANODIZED TIN 19 4
+Brand#11 SMALL ANODIZED TIN 45 4
+Brand#11 SMALL BRUSHED TIN 14 4
+Brand#11 SMALL BRUSHED TIN 23 4
+Brand#11 SMALL BRUSHED TIN 45 4
+Brand#11 SMALL BURNISHED BRASS 49 4
+Brand#11 SMALL BURNISHED COPPER 23 4
+Brand#11 SMALL PLATED COPPER 45 4
+Brand#11 SMALL PLATED NICKEL 3 4
+Brand#11 SMALL PLATED STEEL 36 4
+Brand#11 SMALL PLATED TIN 19 4
+Brand#11 SMALL POLISHED BRASS 14 4
+Brand#11 SMALL POLISHED BRASS 23 4
+Brand#11 SMALL POLISHED COPPER 14 4
+Brand#11 SMALL POLISHED COPPER 36 4
+Brand#11 SMALL POLISHED STEEL 9 4
+Brand#11 STANDARD BRUSHED COPPER 23 4
+Brand#11 STANDARD BRUSHED NICKEL 14 4
+Brand#11 STANDARD BRUSHED TIN 14 4
+Brand#11 STANDARD BURNISHED BRASS 3 4
+Brand#11 STANDARD BURNISHED STEEL 23 4
+Brand#11 STANDARD PLATED BRASS 19 4
+Brand#11 STANDARD PLATED TIN 19 4
+Brand#11 STANDARD POLISHED NICKEL 45 4
+Brand#11 STANDARD POLISHED TIN 14 4
+Brand#11 STANDARD POLISHED TIN 45 4
+Brand#12 ECONOMY ANODIZED BRASS 23 4
+Brand#12 ECONOMY ANODIZED COPPER 14 4
+Brand#12 ECONOMY ANODIZED NICKEL 19 4
+Brand#12 ECONOMY ANODIZED NICKEL 45 4
+Brand#12 ECONOMY ANODIZED STEEL 9 4
+Brand#12 ECONOMY BRUSHED COPPER 36 4
+Brand#12 ECONOMY BRUSHED NICKEL 49 4
+Brand#12 ECONOMY BRUSHED STEEL 49 4
+Brand#12 ECONOMY BURNISHED COPPER 45 4
+Brand#12 ECONOMY PLATED COPPER 23 4
+Brand#12 ECONOMY PLATED STEEL 23 4
+Brand#12 ECONOMY PLATED TIN 36 4
+Brand#12 ECONOMY POLISHED BRASS 14 4
+Brand#12 ECONOMY POLISHED COPPER 45 4
+Brand#12 ECONOMY POLISHED NICKEL 9 4
+Brand#12 LARGE ANODIZED NICKEL 9 4
+Brand#12 LARGE ANODIZED NICKEL 49 4
+Brand#12 LARGE ANODIZED STEEL 49 4
+Brand#12 LARGE ANODIZED TIN 36 4
+Brand#12 LARGE ANODIZED TIN 45 4
+Brand#12 LARGE BURNISHED BRASS 14 4
+Brand#12 LARGE BURNISHED BRASS 19 4
+Brand#12 LARGE BURNISHED COPPER 9 4
+Brand#12 LARGE BURNISHED NICKEL 45 4
+Brand#12 LARGE BURNISHED TIN 36 4
+Brand#12 LARGE PLATED BRASS 3 4
+Brand#12 LARGE PLATED STEEL 36 4
+Brand#12 LARGE PLATED STEEL 45 4
+Brand#12 LARGE PLATED TIN 23 4
+Brand#12 LARGE POLISHED COPPER 14 4
+Brand#12 LARGE POLISHED COPPER 19 4
+Brand#12 LARGE POLISHED COPPER 49 4
+Brand#12 LARGE POLISHED STEEL 3 4
+Brand#12 MEDIUM ANODIZED COPPER 9 4
+Brand#12 MEDIUM ANODIZED COPPER 45 4
+Brand#12 MEDIUM ANODIZED NICKEL 45 4
+Brand#12 MEDIUM BRUSHED BRASS 19 4
+Brand#12 MEDIUM BRUSHED COPPER 9 4
+Brand#12 MEDIUM BRUSHED COPPER 36 4
+Brand#12 MEDIUM BRUSHED COPPER 49 4
+Brand#12 MEDIUM BRUSHED NICKEL 3 4
+Brand#12 MEDIUM BRUSHED NICKEL 14 4
+Brand#12 MEDIUM BRUSHED NICKEL 23 4
+Brand#12 MEDIUM BURNISHED BRASS 3 4
+Brand#12 MEDIUM BURNISHED COPPER 36 4
+Brand#12 MEDIUM BURNISHED NICKEL 19 4
+Brand#12 MEDIUM BURNISHED TIN 14 4
+Brand#12 MEDIUM PLATED BRASS 23 4
+Brand#12 MEDIUM PLATED TIN 19 4
+Brand#12 MEDIUM PLATED TIN 23 4
+Brand#12 MEDIUM PLATED TIN 49 4
+Brand#12 PROMO ANODIZED BRASS 9 4
+Brand#12 PROMO ANODIZED BRASS 45 4
+Brand#12 PROMO ANODIZED NICKEL 14 4
+Brand#12 PROMO ANODIZED STEEL 49 4
+Brand#12 PROMO ANODIZED TIN 3 4
+Brand#12 PROMO ANODIZED TIN 19 4
+Brand#12 PROMO BRUSHED COPPER 14 4
+Brand#12 PROMO BRUSHED COPPER 19 4
+Brand#12 PROMO BRUSHED NICKEL 23 4
+Brand#12 PROMO BRUSHED STEEL 23 4
+Brand#12 PROMO BRUSHED STEEL 36 4
+Brand#12 PROMO BURNISHED BRASS 49 4
+Brand#12 PROMO BURNISHED TIN 9 4
+Brand#12 PROMO BURNISHED TIN 14 4
+Brand#12 PROMO PLATED BRASS 36 4
+Brand#12 PROMO POLISHED COPPER 23 4
+Brand#12 PROMO POLISHED NICKEL 3 4
+Brand#12 PROMO POLISHED NICKEL 9 4
+Brand#12 PROMO POLISHED STEEL 14 4
+Brand#12 PROMO POLISHED TIN 23 4
+Brand#12 PROMO POLISHED TIN 36 4
+Brand#12 SMALL ANODIZED BRASS 36 4
+Brand#12 SMALL ANODIZED COPPER 23 4
+Brand#12 SMALL ANODIZED STEEL 36 4
+Brand#12 SMALL ANODIZED TIN 14 4
+Brand#12 SMALL BRUSHED COPPER 19 4
+Brand#12 SMALL BRUSHED COPPER 36 4
+Brand#12 SMALL BRUSHED TIN 36 4
+Brand#12 SMALL BURNISHED BRASS 14 4
+Brand#12 SMALL BURNISHED COPPER 9 4
+Brand#12 SMALL BURNISHED COPPER 36 4
+Brand#12 SMALL PLATED BRASS 9 4
+Brand#12 SMALL POLISHED BRASS 49 4
+Brand#12 SMALL POLISHED NICKEL 19 4
+Brand#12 SMALL POLISHED TIN 3 4
+Brand#12 STANDARD ANODIZED BRASS 19 4
+Brand#12 STANDARD ANODIZED NICKEL 19 4
+Brand#12 STANDARD ANODIZED STEEL 19 4
+Brand#12 STANDARD BRUSHED COPPER 36 4
+Brand#12 STANDARD BRUSHED NICKEL 23 4
+Brand#12 STANDARD BRUSHED STEEL 49 4
+Brand#12 STANDARD BURNISHED BRASS 23 4
+Brand#12 STANDARD BURNISHED COPPER 14 4
+Brand#12 STANDARD BURNISHED NICKEL 45 4
+Brand#12 STANDARD BURNISHED NICKEL 49 4
+Brand#12 STANDARD BURNISHED TIN 3 4
+Brand#12 STANDARD BURNISHED TIN 14 4
+Brand#12 STANDARD PLATED BRASS 19 4
+Brand#12 STANDARD PLATED NICKEL 45 4
+Brand#12 STANDARD PLATED STEEL 36 4
+Brand#12 STANDARD PLATED STEEL 45 4
+Brand#12 STANDARD PLATED TIN 9 4
+Brand#12 STANDARD POLISHED BRASS 49 4
+Brand#12 STANDARD POLISHED COPPER 3 4
+Brand#12 STANDARD POLISHED NICKEL 23 4
+Brand#12 STANDARD POLISHED TIN 14 4
+Brand#13 ECONOMY ANODIZED NICKEL 14 4
+Brand#13 ECONOMY ANODIZED NICKEL 19 4
+Brand#13 ECONOMY ANODIZED STEEL 45 4
+Brand#13 ECONOMY ANODIZED STEEL 49 4
+Brand#13 ECONOMY BRUSHED BRASS 3 4
+Brand#13 ECONOMY BURNISHED STEEL 14 4
+Brand#13 ECONOMY BURNISHED TIN 19 4
+Brand#13 ECONOMY BURNISHED TIN 45 4
+Brand#13 ECONOMY PLATED COPPER 19 4
+Brand#13 ECONOMY PLATED NICKEL 3 4
+Brand#13 ECONOMY PLATED STEEL 23 4
+Brand#13 ECONOMY PLATED TIN 3 4
+Brand#13 ECONOMY POLISHED BRASS 3 4
+Brand#13 ECONOMY POLISHED COPPER 9 4
+Brand#13 ECONOMY POLISHED COPPER 49 4
+Brand#13 ECONOMY POLISHED STEEL 23 4
+Brand#13 ECONOMY POLISHED STEEL 49 4
+Brand#13 LARGE ANODIZED BRASS 23 4
+Brand#13 LARGE ANODIZED COPPER 19 4
+Brand#13 LARGE ANODIZED NICKEL 9 4
+Brand#13 LARGE ANODIZED STEEL 45 4
+Brand#13 LARGE ANODIZED TIN 19 4
+Brand#13 LARGE BRUSHED BRASS 3 4
+Brand#13 LARGE BRUSHED BRASS 9 4
+Brand#13 LARGE BRUSHED BRASS 19 4
+Brand#13 LARGE BRUSHED COPPER 9 4
+Brand#13 LARGE BRUSHED COPPER 36 4
+Brand#13 LARGE BRUSHED NICKEL 3 4
+Brand#13 LARGE BRUSHED NICKEL 9 4
+Brand#13 LARGE BRUSHED NICKEL 14 4
+Brand#13 LARGE BRUSHED NICKEL 23 4
+Brand#13 LARGE BRUSHED STEEL 19 4
+Brand#13 LARGE BRUSHED TIN 49 4
+Brand#13 LARGE BURNISHED BRASS 49 4
+Brand#13 LARGE BURNISHED TIN 49 4
+Brand#13 LARGE PLATED COPPER 23 4
+Brand#13 LARGE PLATED STEEL 14 4
+Brand#13 LARGE PLATED STEEL 19 4
+Brand#13 LARGE PLATED STEEL 36 4
+Brand#13 LARGE PLATED TIN 14 4
+Brand#13 LARGE PLATED TIN 45 4
+Brand#13 LARGE POLISHED BRASS 3 4
+Brand#13 LARGE POLISHED BRASS 23 4
+Brand#13 LARGE POLISHED BRASS 49 4
+Brand#13 MEDIUM ANODIZED BRASS 3 4
+Brand#13 MEDIUM ANODIZED BRASS 36 4
+Brand#13 MEDIUM ANODIZED COPPER 14 4
+Brand#13 MEDIUM ANODIZED NICKEL 3 4
+Brand#13 MEDIUM ANODIZED STEEL 14 4
+Brand#13 MEDIUM ANODIZED STEEL 19 4
+Brand#13 MEDIUM ANODIZED STEEL 36 4
+Brand#13 MEDIUM BRUSHED BRASS 49 4
+Brand#13 MEDIUM BRUSHED COPPER 23 4
+Brand#13 MEDIUM BRUSHED NICKEL 45 4
+Brand#13 MEDIUM BURNISHED BRASS 9 4
+Brand#13 MEDIUM BURNISHED STEEL 19 4
+Brand#13 MEDIUM BURNISHED STEEL 49 4
+Brand#13 MEDIUM PLATED BRASS 3 4
+Brand#13 MEDIUM PLATED BRASS 23 4
+Brand#13 MEDIUM PLATED BRASS 36 4
+Brand#13 MEDIUM PLATED COPPER 19 4
+Brand#13 MEDIUM PLATED COPPER 23 4
+Brand#13 MEDIUM PLATED STEEL 3 4
+Brand#13 PROMO ANODIZED BRASS 14 4
+Brand#13 PROMO ANODIZED COPPER 9 4
+Brand#13 PROMO ANODIZED COPPER 45 4
+Brand#13 PROMO ANODIZED STEEL 23 4
+Brand#13 PROMO BRUSHED COPPER 49 4
+Brand#13 PROMO BURNISHED COPPER 19 4
+Brand#13 PROMO BURNISHED NICKEL 9 4
+Brand#13 PROMO BURNISHED STEEL 23 4
+Brand#13 PROMO BURNISHED STEEL 45 4
+Brand#13 PROMO BURNISHED TIN 19 4
+Brand#13 PROMO PLATED BRASS 14 4
+Brand#13 PROMO PLATED BRASS 19 4
+Brand#13 PROMO PLATED COPPER 3 4
+Brand#13 PROMO PLATED COPPER 19 4
+Brand#13 PROMO PLATED TIN 19 4
+Brand#13 PROMO POLISHED BRASS 49 4
+Brand#13 PROMO POLISHED STEEL 45 4
+Brand#13 PROMO POLISHED TIN 14 4
+Brand#13 SMALL ANODIZED STEEL 23 4
+Brand#13 SMALL ANODIZED TIN 3 4
+Brand#13 SMALL ANODIZED TIN 45 4
+Brand#13 SMALL BRUSHED COPPER 3 4
+Brand#13 SMALL BRUSHED NICKEL 19 4
+Brand#13 SMALL BRUSHED TIN 9 4
+Brand#13 SMALL BRUSHED TIN 45 4
+Brand#13 SMALL BURNISHED BRASS 19 4
+Brand#13 SMALL BURNISHED BRASS 45 4
+Brand#13 SMALL PLATED BRASS 9 4
+Brand#13 SMALL PLATED TIN 45 4
+Brand#13 SMALL POLISHED NICKEL 19 4
+Brand#13 SMALL POLISHED STEEL 49 4
+Brand#13 STANDARD ANODIZED COPPER 45 4
+Brand#13 STANDARD ANODIZED NICKEL 9 4
+Brand#13 STANDARD ANODIZED NICKEL 19 4
+Brand#13 STANDARD ANODIZED STEEL 14 4
+Brand#13 STANDARD ANODIZED TIN 9 4
+Brand#13 STANDARD ANODIZED TIN 36 4
+Brand#13 STANDARD BRUSHED BRASS 19 4
+Brand#13 STANDARD BRUSHED TIN 9 4
+Brand#13 STANDARD BURNISHED BRASS 9 4
+Brand#13 STANDARD BURNISHED BRASS 14 4
+Brand#13 STANDARD BURNISHED COPPER 45 4
+Brand#13 STANDARD PLATED BRASS 49 4
+Brand#13 STANDARD PLATED COPPER 19 4
+Brand#13 STANDARD PLATED NICKEL 23 4
+Brand#13 STANDARD PLATED TIN 9 4
+Brand#13 STANDARD POLISHED BRASS 49 4
+Brand#13 STANDARD POLISHED COPPER 9 4
+Brand#13 STANDARD POLISHED COPPER 49 4
+Brand#13 STANDARD POLISHED NICKEL 14 4
+Brand#13 STANDARD POLISHED NICKEL 19 4
+Brand#13 STANDARD POLISHED STEEL 23 4
+Brand#14 ECONOMY ANODIZED BRASS 19 4
+Brand#14 ECONOMY ANODIZED COPPER 9 4
+Brand#14 ECONOMY ANODIZED STEEL 19 4
+Brand#14 ECONOMY ANODIZED STEEL 45 4
+Brand#14 ECONOMY BRUSHED BRASS 19 4
+Brand#14 ECONOMY BRUSHED COPPER 45 4
+Brand#14 ECONOMY BRUSHED NICKEL 14 4
+Brand#14 ECONOMY BRUSHED TIN 14 4
+Brand#14 ECONOMY BURNISHED COPPER 9 4
+Brand#14 ECONOMY BURNISHED COPPER 19 4
+Brand#14 ECONOMY BURNISHED STEEL 36 4
+Brand#14 ECONOMY BURNISHED TIN 3 4
+Brand#14 ECONOMY PLATED BRASS 36 4
+Brand#14 ECONOMY PLATED COPPER 49 4
+Brand#14 ECONOMY PLATED STEEL 45 4
+Brand#14 ECONOMY PLATED TIN 9 4
+Brand#14 ECONOMY POLISHED COPPER 3 4
+Brand#14 ECONOMY POLISHED TIN 19 4
+Brand#14 LARGE ANODIZED COPPER 9 4
+Brand#14 LARGE ANODIZED COPPER 23 4
+Brand#14 LARGE ANODIZED NICKEL 3 4
+Brand#14 LARGE ANODIZED NICKEL 9 4
+Brand#14 LARGE ANODIZED NICKEL 19 4
+Brand#14 LARGE ANODIZED TIN 9 4
+Brand#14 LARGE BRUSHED COPPER 14 4
+Brand#14 LARGE BRUSHED NICKEL 45 4
+Brand#14 LARGE PLATED BRASS 3 4
+Brand#14 LARGE PLATED NICKEL 3 4
+Brand#14 LARGE PLATED NICKEL 14 4
+Brand#14 LARGE PLATED NICKEL 49 4
+Brand#14 LARGE PLATED TIN 49 4
+Brand#14 LARGE POLISHED BRASS 9 4
+Brand#14 LARGE POLISHED BRASS 14 4
+Brand#14 LARGE POLISHED BRASS 36 4
+Brand#14 LARGE POLISHED NICKEL 3 4
+Brand#14 LARGE POLISHED NICKEL 14 4
+Brand#14 LARGE POLISHED STEEL 9 4
+Brand#14 LARGE POLISHED STEEL 23 4
+Brand#14 LARGE POLISHED STEEL 36 4
+Brand#14 MEDIUM ANODIZED NICKEL 3 4
+Brand#14 MEDIUM ANODIZED NICKEL 49 4
+Brand#14 MEDIUM ANODIZED STEEL 23 4
+Brand#14 MEDIUM ANODIZED STEEL 36 4
+Brand#14 MEDIUM BRUSHED BRASS 9 4
+Brand#14 MEDIUM BRUSHED COPPER 23 4
+Brand#14 MEDIUM BRUSHED STEEL 14 4
+Brand#14 MEDIUM BURNISHED COPPER 14 4
+Brand#14 MEDIUM BURNISHED STEEL 3 4
+Brand#14 MEDIUM BURNISHED STEEL 49 4
+Brand#14 MEDIUM PLATED BRASS 36 4
+Brand#14 MEDIUM PLATED STEEL 49 4
+Brand#14 MEDIUM PLATED TIN 14 4
+Brand#14 PROMO ANODIZED BRASS 49 4
+Brand#14 PROMO ANODIZED STEEL 36 4
+Brand#14 PROMO BRUSHED STEEL 19 4
+Brand#14 PROMO BURNISHED BRASS 23 4
+Brand#14 PROMO BURNISHED STEEL 36 4
+Brand#14 PROMO PLATED BRASS 9 4
+Brand#14 PROMO PLATED BRASS 45 4
+Brand#14 PROMO PLATED COPPER 45 4
+Brand#14 PROMO PLATED STEEL 3 4
+Brand#14 PROMO POLISHED BRASS 9 4
+Brand#14 PROMO POLISHED COPPER 49 4
+Brand#14 PROMO POLISHED STEEL 19 4
+Brand#14 SMALL ANODIZED STEEL 23 4
+Brand#14 SMALL ANODIZED TIN 23 4
+Brand#14 SMALL BRUSHED BRASS 19 4
+Brand#14 SMALL BRUSHED BRASS 36 4
+Brand#14 SMALL BRUSHED COPPER 9 4
+Brand#14 SMALL BRUSHED TIN 36 4
+Brand#14 SMALL BURNISHED BRASS 45 4
+Brand#14 SMALL BURNISHED COPPER 9 4
+Brand#14 SMALL BURNISHED COPPER 14 4
+Brand#14 SMALL BURNISHED COPPER 45 4
+Brand#14 SMALL BURNISHED NICKEL 36 4
+Brand#14 SMALL BURNISHED STEEL 36 4
+Brand#14 SMALL BURNISHED TIN 23 4
+Brand#14 SMALL PLATED NICKEL 3 4
+Brand#14 SMALL PLATED NICKEL 9 4
+Brand#14 SMALL PLATED STEEL 14 4
+Brand#14 SMALL POLISHED BRASS 36 4
+Brand#14 SMALL POLISHED COPPER 36 4
+Brand#14 SMALL POLISHED NICKEL 9 4
+Brand#14 SMALL POLISHED STEEL 14 4
+Brand#14 SMALL POLISHED TIN 14 4
+Brand#14 STANDARD ANODIZED BRASS 19 4
+Brand#14 STANDARD ANODIZED NICKEL 14 4
+Brand#14 STANDARD ANODIZED STEEL 9 4
+Brand#14 STANDARD BRUSHED COPPER 45 4
+Brand#14 STANDARD BRUSHED NICKEL 45 4
+Brand#14 STANDARD BRUSHED TIN 45 4
+Brand#14 STANDARD BURNISHED BRASS 9 4
+Brand#14 STANDARD BURNISHED BRASS 23 4
+Brand#14 STANDARD BURNISHED BRASS 49 4
+Brand#14 STANDARD BURNISHED NICKEL 9 4
+Brand#14 STANDARD PLATED BRASS 36 4
+Brand#14 STANDARD PLATED COPPER 45 4
+Brand#14 STANDARD POLISHED NICKEL 3 4
+Brand#14 STANDARD POLISHED NICKEL 9 4
+Brand#14 STANDARD POLISHED TIN 19 4
+Brand#15 ECONOMY ANODIZED COPPER 14 4
+Brand#15 ECONOMY ANODIZED STEEL 19 4
+Brand#15 ECONOMY ANODIZED STEEL 36 4
+Brand#15 ECONOMY BRUSHED BRASS 36 4
+Brand#15 ECONOMY BRUSHED COPPER 14 4
+Brand#15 ECONOMY BRUSHED NICKEL 14 4
+Brand#15 ECONOMY BRUSHED STEEL 3 4
+Brand#15 ECONOMY BRUSHED TIN 3 4
+Brand#15 ECONOMY BURNISHED BRASS 14 4
+Brand#15 ECONOMY BURNISHED COPPER 3 4
+Brand#15 ECONOMY BURNISHED COPPER 23 4
+Brand#15 ECONOMY PLATED NICKEL 49 4
+Brand#15 ECONOMY PLATED STEEL 3 4
+Brand#15 ECONOMY PLATED STEEL 19 4
+Brand#15 ECONOMY PLATED STEEL 45 4
+Brand#15 LARGE ANODIZED BRASS 19 4
+Brand#15 LARGE ANODIZED BRASS 36 4
+Brand#15 LARGE ANODIZED BRASS 45 4
+Brand#15 LARGE ANODIZED COPPER 3 4
+Brand#15 LARGE ANODIZED NICKEL 9 4
+Brand#15 LARGE ANODIZED TIN 19 4
+Brand#15 LARGE BRUSHED BRASS 9 4
+Brand#15 LARGE BRUSHED BRASS 19 4
+Brand#15 LARGE BRUSHED COPPER 14 4
+Brand#15 LARGE BRUSHED STEEL 9 4
+Brand#15 LARGE BRUSHED STEEL 14 4
+Brand#15 LARGE BRUSHED STEEL 19 4
+Brand#15 LARGE BRUSHED STEEL 36 4
+Brand#15 LARGE BURNISHED BRASS 14 4
+Brand#15 LARGE BURNISHED BRASS 19 4
+Brand#15 LARGE BURNISHED COPPER 9 4
+Brand#15 LARGE BURNISHED COPPER 45 4
+Brand#15 LARGE BURNISHED TIN 49 4
+Brand#15 LARGE PLATED BRASS 19 4
+Brand#15 LARGE PLATED COPPER 3 4
+Brand#15 LARGE PLATED COPPER 23 4
+Brand#15 LARGE PLATED NICKEL 36 4
+Brand#15 MEDIUM ANODIZED BRASS 23 4
+Brand#15 MEDIUM ANODIZED COPPER 9 4
+Brand#15 MEDIUM ANODIZED NICKEL 3 4
+Brand#15 MEDIUM ANODIZED TIN 19 4
+Brand#15 MEDIUM BRUSHED BRASS 9 4
+Brand#15 MEDIUM BRUSHED TIN 23 4
+Brand#15 MEDIUM BURNISHED COPPER 36 4
+Brand#15 MEDIUM BURNISHED TIN 45 4
+Brand#15 MEDIUM PLATED COPPER 9 4
+Brand#15 MEDIUM PLATED NICKEL 9 4
+Brand#15 MEDIUM PLATED NICKEL 19 4
+Brand#15 MEDIUM PLATED STEEL 36 4
+Brand#15 MEDIUM PLATED STEEL 49 4
+Brand#15 MEDIUM PLATED TIN 9 4
+Brand#15 MEDIUM PLATED TIN 14 4
+Brand#15 MEDIUM PLATED TIN 23 4
+Brand#15 PROMO ANODIZED COPPER 23 4
+Brand#15 PROMO ANODIZED STEEL 14 4
+Brand#15 PROMO ANODIZED TIN 45 4
+Brand#15 PROMO BRUSHED COPPER 14 4
+Brand#15 PROMO BRUSHED COPPER 19 4
+Brand#15 PROMO BRUSHED NICKEL 19 4
+Brand#15 PROMO BRUSHED NICKEL 23 4
+Brand#15 PROMO BRUSHED STEEL 14 4
+Brand#15 PROMO BRUSHED TIN 36 4
+Brand#15 PROMO BURNISHED NICKEL 9 4
+Brand#15 PROMO BURNISHED STEEL 45 4
+Brand#15 PROMO PLATED COPPER 3 4
+Brand#15 PROMO PLATED COPPER 36 4
+Brand#15 PROMO PLATED STEEL 3 4
+Brand#15 PROMO PLATED TIN 49 4
+Brand#15 PROMO POLISHED COPPER 3 4
+Brand#15 PROMO POLISHED NICKEL 36 4
+Brand#15 PROMO POLISHED STEEL 36 4
+Brand#15 PROMO POLISHED TIN 49 4
+Brand#15 SMALL ANODIZED BRASS 14 4
+Brand#15 SMALL ANODIZED BRASS 19 4
+Brand#15 SMALL ANODIZED COPPER 9 4
+Brand#15 SMALL ANODIZED TIN 45 4
+Brand#15 SMALL BRUSHED BRASS 3 4
+Brand#15 SMALL BRUSHED COPPER 19 4
+Brand#15 SMALL BRUSHED STEEL 23 4
+Brand#15 SMALL BRUSHED TIN 45 4
+Brand#15 SMALL BURNISHED BRASS 19 4
+Brand#15 SMALL BURNISHED COPPER 14 4
+Brand#15 SMALL BURNISHED NICKEL 19 4
+Brand#15 SMALL BURNISHED NICKEL 49 4
+Brand#15 SMALL BURNISHED STEEL 9 4
+Brand#15 SMALL BURNISHED TIN 19 4
+Brand#15 SMALL BURNISHED TIN 23 4
+Brand#15 SMALL BURNISHED TIN 36 4
+Brand#15 SMALL PLATED BRASS 3 4
+Brand#15 SMALL PLATED COPPER 23 4
+Brand#15 SMALL PLATED COPPER 49 4
+Brand#15 SMALL PLATED NICKEL 36 4
+Brand#15 SMALL PLATED NICKEL 45 4
+Brand#15 SMALL PLATED STEEL 3 4
+Brand#15 SMALL PLATED TIN 9 4
+Brand#15 SMALL POLISHED COPPER 9 4
+Brand#15 SMALL POLISHED NICKEL 3 4
+Brand#15 SMALL POLISHED STEEL 19 4
+Brand#15 SMALL POLISHED STEEL 36 4
+Brand#15 SMALL POLISHED TIN 19 4
+Brand#15 SMALL POLISHED TIN 49 4
+Brand#15 STANDARD ANODIZED NICKEL 19 4
+Brand#15 STANDARD ANODIZED NICKEL 49 4
+Brand#15 STANDARD ANODIZED TIN 36 4
+Brand#15 STANDARD BRUSHED NICKEL 3 4
+Brand#15 STANDARD BURNISHED BRASS 23 4
+Brand#15 STANDARD BURNISHED STEEL 3 4
+Brand#15 STANDARD BURNISHED STEEL 45 4
+Brand#15 STANDARD PLATED BRASS 36 4
+Brand#15 STANDARD PLATED COPPER 14 4
+Brand#15 STANDARD PLATED COPPER 23 4
+Brand#15 STANDARD PLATED NICKEL 19 4
+Brand#15 STANDARD PLATED TIN 45 4
+Brand#15 STANDARD POLISHED BRASS 14 4
+Brand#15 STANDARD POLISHED COPPER 23 4
+Brand#15 STANDARD POLISHED NICKEL 45 4
+Brand#21 ECONOMY ANODIZED BRASS 3 4
+Brand#21 ECONOMY ANODIZED NICKEL 14 4
+Brand#21 ECONOMY ANODIZED STEEL 19 4
+Brand#21 ECONOMY ANODIZED STEEL 23 4
+Brand#21 ECONOMY ANODIZED STEEL 49 4
+Brand#21 ECONOMY ANODIZED TIN 19 4
+Brand#21 ECONOMY BRUSHED BRASS 9 4
+Brand#21 ECONOMY BRUSHED BRASS 14 4
+Brand#21 ECONOMY BRUSHED BRASS 36 4
+Brand#21 ECONOMY BRUSHED COPPER 49 4
+Brand#21 ECONOMY BRUSHED STEEL 45 4
+Brand#21 ECONOMY BRUSHED TIN 49 4
+Brand#21 ECONOMY BURNISHED BRASS 3 4
+Brand#21 ECONOMY BURNISHED COPPER 45 4
+Brand#21 ECONOMY BURNISHED STEEL 19 4
+Brand#21 ECONOMY BURNISHED STEEL 36 4
+Brand#21 ECONOMY PLATED BRASS 36 4
+Brand#21 ECONOMY PLATED COPPER 3 4
+Brand#21 ECONOMY PLATED COPPER 14 4
+Brand#21 ECONOMY PLATED NICKEL 49 4
+Brand#21 ECONOMY POLISHED NICKEL 3 4
+Brand#21 ECONOMY POLISHED NICKEL 9 4
+Brand#21 LARGE ANODIZED COPPER 3 4
+Brand#21 LARGE ANODIZED COPPER 9 4
+Brand#21 LARGE ANODIZED STEEL 36 4
+Brand#21 LARGE ANODIZED TIN 45 4
+Brand#21 LARGE BRUSHED COPPER 45 4
+Brand#21 LARGE BRUSHED STEEL 23 4
+Brand#21 LARGE BURNISHED BRASS 49 4
+Brand#21 LARGE BURNISHED COPPER 19 4
+Brand#21 LARGE BURNISHED STEEL 49 4
+Brand#21 LARGE BURNISHED TIN 49 4
+Brand#21 LARGE PLATED BRASS 19 4
+Brand#21 LARGE PLATED NICKEL 23 4
+Brand#21 LARGE PLATED NICKEL 49 4
+Brand#21 LARGE PLATED TIN 19 4
+Brand#21 LARGE POLISHED BRASS 49 4
+Brand#21 LARGE POLISHED COPPER 14 4
+Brand#21 LARGE POLISHED NICKEL 3 4
+Brand#21 LARGE POLISHED NICKEL 14 4
+Brand#21 LARGE POLISHED STEEL 14 4
+Brand#21 LARGE POLISHED TIN 49 4
+Brand#21 MEDIUM ANODIZED COPPER 14 4
+Brand#21 MEDIUM ANODIZED NICKEL 49 4
+Brand#21 MEDIUM BRUSHED COPPER 3 4
+Brand#21 MEDIUM BRUSHED COPPER 49 4
+Brand#21 MEDIUM BRUSHED STEEL 23 4
+Brand#21 MEDIUM BRUSHED TIN 3 4
+Brand#21 MEDIUM BRUSHED TIN 14 4
+Brand#21 MEDIUM BURNISHED NICKEL 14 4
+Brand#21 MEDIUM BURNISHED STEEL 23 4
+Brand#21 MEDIUM BURNISHED TIN 3 4
+Brand#21 MEDIUM PLATED BRASS 3 4
+Brand#21 MEDIUM PLATED BRASS 19 4
+Brand#21 MEDIUM PLATED STEEL 36 4
+Brand#21 PROMO ANODIZED BRASS 9 4
+Brand#21 PROMO ANODIZED COPPER 14 4
+Brand#21 PROMO ANODIZED NICKEL 23 4
+Brand#21 PROMO ANODIZED STEEL 3 4
+Brand#21 PROMO ANODIZED STEEL 14 4
+Brand#21 PROMO ANODIZED STEEL 36 4
+Brand#21 PROMO BRUSHED NICKEL 45 4
+Brand#21 PROMO BRUSHED STEEL 14 4
+Brand#21 PROMO BRUSHED STEEL 23 4
+Brand#21 PROMO BRUSHED STEEL 45 4
+Brand#21 PROMO BURNISHED BRASS 19 4
+Brand#21 PROMO BURNISHED COPPER 19 4
+Brand#21 PROMO BURNISHED NICKEL 9 4
+Brand#21 PROMO BURNISHED TIN 19 4
+Brand#21 PROMO PLATED NICKEL 9 4
+Brand#21 PROMO PLATED NICKEL 36 4
+Brand#21 PROMO PLATED STEEL 49 4
+Brand#21 PROMO PLATED TIN 3 4
+Brand#21 PROMO POLISHED NICKEL 23 4
+Brand#21 PROMO POLISHED TIN 14 4
+Brand#21 PROMO POLISHED TIN 19 4
+Brand#21 PROMO POLISHED TIN 23 4
+Brand#21 SMALL BRUSHED BRASS 23 4
+Brand#21 SMALL BRUSHED COPPER 49 4
+Brand#21 SMALL BURNISHED BRASS 23 4
+Brand#21 SMALL BURNISHED BRASS 36 4
+Brand#21 SMALL BURNISHED STEEL 19 4
+Brand#21 SMALL BURNISHED TIN 19 4
+Brand#21 SMALL PLATED BRASS 45 4
+Brand#21 SMALL PLATED COPPER 45 4
+Brand#21 SMALL PLATED STEEL 45 4
+Brand#21 SMALL PLATED TIN 14 4
+Brand#21 SMALL PLATED TIN 45 4
+Brand#21 SMALL POLISHED COPPER 9 4
+Brand#21 SMALL POLISHED NICKEL 23 4
+Brand#21 SMALL POLISHED TIN 3 4
+Brand#21 STANDARD ANODIZED BRASS 9 4
+Brand#21 STANDARD ANODIZED NICKEL 19 4
+Brand#21 STANDARD ANODIZED TIN 45 4
+Brand#21 STANDARD BURNISHED COPPER 36 4
+Brand#21 STANDARD BURNISHED NICKEL 23 4
+Brand#21 STANDARD BURNISHED TIN 9 4
+Brand#21 STANDARD PLATED BRASS 14 4
+Brand#21 STANDARD PLATED COPPER 19 4
+Brand#21 STANDARD PLATED NICKEL 3 4
+Brand#21 STANDARD PLATED STEEL 9 4
+Brand#21 STANDARD PLATED TIN 9 4
+Brand#21 STANDARD POLISHED BRASS 9 4
+Brand#21 STANDARD POLISHED COPPER 49 4
+Brand#21 STANDARD POLISHED STEEL 36 4
+Brand#21 STANDARD POLISHED TIN 36 4
+Brand#22 ECONOMY ANODIZED STEEL 9 4
+Brand#22 ECONOMY ANODIZED STEEL 14 4
+Brand#22 ECONOMY ANODIZED STEEL 23 4
+Brand#22 ECONOMY ANODIZED TIN 9 4
+Brand#22 ECONOMY ANODIZED TIN 36 4
+Brand#22 ECONOMY BRUSHED NICKEL 36 4
+Brand#22 ECONOMY BRUSHED NICKEL 45 4
+Brand#22 ECONOMY BURNISHED BRASS 9 4
+Brand#22 ECONOMY BURNISHED BRASS 23 4
+Brand#22 ECONOMY BURNISHED BRASS 45 4
+Brand#22 ECONOMY BURNISHED NICKEL 19 4
+Brand#22 ECONOMY BURNISHED NICKEL 49 4
+Brand#22 ECONOMY BURNISHED STEEL 9 4
+Brand#22 ECONOMY BURNISHED STEEL 14 4
+Brand#22 ECONOMY BURNISHED STEEL 23 4
+Brand#22 ECONOMY PLATED BRASS 36 4
+Brand#22 ECONOMY PLATED COPPER 23 4
+Brand#22 ECONOMY PLATED TIN 3 4
+Brand#22 ECONOMY POLISHED TIN 49 4
+Brand#22 LARGE ANODIZED BRASS 19 4
+Brand#22 LARGE ANODIZED COPPER 36 4
+Brand#22 LARGE ANODIZED STEEL 3 4
+Brand#22 LARGE BRUSHED BRASS 23 4
+Brand#22 LARGE BRUSHED BRASS 49 4
+Brand#22 LARGE BRUSHED STEEL 49 4
+Brand#22 LARGE BURNISHED COPPER 19 4
+Brand#22 LARGE BURNISHED STEEL 23 4
+Brand#22 LARGE BURNISHED STEEL 45 4
+Brand#22 LARGE BURNISHED TIN 45 4
+Brand#22 LARGE PLATED COPPER 14 4
+Brand#22 LARGE PLATED STEEL 49 4
+Brand#22 LARGE POLISHED BRASS 19 4
+Brand#22 LARGE POLISHED COPPER 19 4
+Brand#22 LARGE POLISHED COPPER 23 4
+Brand#22 LARGE POLISHED NICKEL 19 4
+Brand#22 LARGE POLISHED TIN 49 4
+Brand#22 MEDIUM ANODIZED BRASS 45 4
+Brand#22 MEDIUM ANODIZED COPPER 19 4
+Brand#22 MEDIUM ANODIZED COPPER 49 4
+Brand#22 MEDIUM ANODIZED NICKEL 9 4
+Brand#22 MEDIUM ANODIZED NICKEL 14 4
+Brand#22 MEDIUM ANODIZED NICKEL 36 4
+Brand#22 MEDIUM ANODIZED TIN 3 4
+Brand#22 MEDIUM ANODIZED TIN 9 4
+Brand#22 MEDIUM BRUSHED BRASS 3 4
+Brand#22 MEDIUM BRUSHED BRASS 14 4
+Brand#22 MEDIUM BRUSHED COPPER 3 4
+Brand#22 MEDIUM BRUSHED COPPER 45 4
+Brand#22 MEDIUM BRUSHED NICKEL 14 4
+Brand#22 MEDIUM BRUSHED TIN 45 4
+Brand#22 MEDIUM BURNISHED COPPER 36 4
+Brand#22 MEDIUM BURNISHED TIN 19 4
+Brand#22 MEDIUM BURNISHED TIN 23 4
+Brand#22 MEDIUM BURNISHED TIN 49 4
+Brand#22 MEDIUM PLATED BRASS 49 4
+Brand#22 MEDIUM PLATED COPPER 9 4
+Brand#22 MEDIUM PLATED STEEL 3 4
+Brand#22 PROMO ANODIZED BRASS 9 4
+Brand#22 PROMO ANODIZED STEEL 36 4
+Brand#22 PROMO ANODIZED TIN 45 4
+Brand#22 PROMO BRUSHED BRASS 3 4
+Brand#22 PROMO BRUSHED BRASS 9 4
+Brand#22 PROMO BRUSHED BRASS 36 4
+Brand#22 PROMO BRUSHED STEEL 36 4
+Brand#22 PROMO BURNISHED BRASS 23 4
+Brand#22 PROMO BURNISHED COPPER 9 4
+Brand#22 PROMO PLATED BRASS 14 4
+Brand#22 PROMO PLATED BRASS 45 4
+Brand#22 PROMO PLATED NICKEL 3 4
+Brand#22 PROMO PLATED STEEL 19 4
+Brand#22 PROMO POLISHED BRASS 3 4
+Brand#22 PROMO POLISHED STEEL 14 4
+Brand#22 PROMO POLISHED STEEL 23 4
+Brand#22 SMALL ANODIZED TIN 36 4
+Brand#22 SMALL ANODIZED TIN 49 4
+Brand#22 SMALL BRUSHED NICKEL 3 4
+Brand#22 SMALL BRUSHED NICKEL 36 4
+Brand#22 SMALL BRUSHED NICKEL 45 4
+Brand#22 SMALL BRUSHED TIN 45 4
+Brand#22 SMALL BURNISHED STEEL 23 4
+Brand#22 SMALL BURNISHED TIN 14 4
+Brand#22 SMALL PLATED STEEL 3 4
+Brand#22 SMALL PLATED TIN 9 4
+Brand#22 SMALL PLATED TIN 36 4
+Brand#22 SMALL POLISHED BRASS 23 4
+Brand#22 SMALL POLISHED NICKEL 19 4
+Brand#22 STANDARD ANODIZED BRASS 14 4
+Brand#22 STANDARD ANODIZED BRASS 23 4
+Brand#22 STANDARD BRUSHED COPPER 49 4
+Brand#22 STANDARD BRUSHED NICKEL 3 4
+Brand#22 STANDARD BRUSHED NICKEL 23 4
+Brand#22 STANDARD BRUSHED STEEL 9 4
+Brand#22 STANDARD BRUSHED TIN 19 4
+Brand#22 STANDARD BURNISHED COPPER 45 4
+Brand#22 STANDARD BURNISHED NICKEL 3 4
+Brand#22 STANDARD BURNISHED NICKEL 14 4
+Brand#22 STANDARD BURNISHED NICKEL 45 4
+Brand#22 STANDARD BURNISHED STEEL 3 4
+Brand#22 STANDARD BURNISHED STEEL 36 4
+Brand#22 STANDARD BURNISHED STEEL 45 4
+Brand#22 STANDARD BURNISHED STEEL 49 4
+Brand#22 STANDARD PLATED BRASS 45 4
+Brand#22 STANDARD PLATED NICKEL 3 4
+Brand#22 STANDARD PLATED NICKEL 45 4
+Brand#22 STANDARD PLATED STEEL 14 4
+Brand#22 STANDARD PLATED TIN 19 4
+Brand#22 STANDARD PLATED TIN 49 4
+Brand#22 STANDARD POLISHED COPPER 9 4
+Brand#22 STANDARD POLISHED STEEL 49 4
+Brand#22 STANDARD POLISHED TIN 45 4
+Brand#23 ECONOMY ANODIZED NICKEL 49 4
+Brand#23 ECONOMY ANODIZED STEEL 14 4
+Brand#23 ECONOMY ANODIZED STEEL 49 4
+Brand#23 ECONOMY ANODIZED TIN 49 4
+Brand#23 ECONOMY BRUSHED BRASS 3 4
+Brand#23 ECONOMY BRUSHED COPPER 9 4
+Brand#23 ECONOMY BRUSHED TIN 9 4
+Brand#23 ECONOMY BURNISHED STEEL 49 4
+Brand#23 ECONOMY PLATED COPPER 14 4
+Brand#23 ECONOMY PLATED NICKEL 23 4
+Brand#23 ECONOMY PLATED STEEL 14 4
+Brand#23 ECONOMY POLISHED NICKEL 9 4
+Brand#23 LARGE ANODIZED BRASS 14 4
+Brand#23 LARGE ANODIZED COPPER 9 4
+Brand#23 LARGE ANODIZED COPPER 14 4
+Brand#23 LARGE ANODIZED COPPER 45 4
+Brand#23 LARGE ANODIZED STEEL 19 4
+Brand#23 LARGE ANODIZED STEEL 36 4
+Brand#23 LARGE ANODIZED STEEL 49 4
+Brand#23 LARGE ANODIZED TIN 9 4
+Brand#23 LARGE PLATED BRASS 9 4
+Brand#23 LARGE PLATED BRASS 49 4
+Brand#23 LARGE PLATED COPPER 3 4
+Brand#23 LARGE POLISHED BRASS 45 4
+Brand#23 LARGE POLISHED STEEL 9 4
+Brand#23 MEDIUM ANODIZED BRASS 19 4
+Brand#23 MEDIUM ANODIZED NICKEL 3 4
+Brand#23 MEDIUM ANODIZED NICKEL 14 4
+Brand#23 MEDIUM ANODIZED STEEL 45 4
+Brand#23 MEDIUM ANODIZED TIN 36 4
+Brand#23 MEDIUM ANODIZED TIN 45 4
+Brand#23 MEDIUM BRUSHED COPPER 3 4
+Brand#23 MEDIUM BRUSHED COPPER 23 4
+Brand#23 MEDIUM BRUSHED NICKEL 3 4
+Brand#23 MEDIUM BRUSHED TIN 14 4
+Brand#23 MEDIUM BURNISHED BRASS 9 4
+Brand#23 MEDIUM BURNISHED BRASS 45 4
+Brand#23 MEDIUM BURNISHED COPPER 19 4
+Brand#23 MEDIUM PLATED COPPER 19 4
+Brand#23 MEDIUM PLATED COPPER 36 4
+Brand#23 MEDIUM PLATED COPPER 45 4
+Brand#23 MEDIUM PLATED NICKEL 9 4
+Brand#23 MEDIUM PLATED NICKEL 14 4
+Brand#23 PROMO ANODIZED COPPER 9 4
+Brand#23 PROMO ANODIZED COPPER 19 4
+Brand#23 PROMO ANODIZED STEEL 36 4
+Brand#23 PROMO ANODIZED TIN 14 4
+Brand#23 PROMO BRUSHED BRASS 3 4
+Brand#23 PROMO BRUSHED BRASS 19 4
+Brand#23 PROMO BRUSHED BRASS 36 4
+Brand#23 PROMO BRUSHED COPPER 3 4
+Brand#23 PROMO BRUSHED TIN 49 4
+Brand#23 PROMO BURNISHED BRASS 14 4
+Brand#23 PROMO BURNISHED BRASS 45 4
+Brand#23 PROMO BURNISHED COPPER 14 4
+Brand#23 PROMO PLATED BRASS 23 4
+Brand#23 PROMO POLISHED BRASS 14 4
+Brand#23 PROMO POLISHED BRASS 23 4
+Brand#23 PROMO POLISHED COPPER 36 4
+Brand#23 PROMO POLISHED STEEL 36 4
+Brand#23 SMALL ANODIZED BRASS 23 4
+Brand#23 SMALL ANODIZED STEEL 23 4
+Brand#23 SMALL BRUSHED BRASS 49 4
+Brand#23 SMALL BRUSHED COPPER 45 4
+Brand#23 SMALL BRUSHED STEEL 3 4
+Brand#23 SMALL BRUSHED STEEL 19 4
+Brand#23 SMALL BURNISHED BRASS 36 4
+Brand#23 SMALL BURNISHED COPPER 45 4
+Brand#23 SMALL BURNISHED COPPER 49 4
+Brand#23 SMALL BURNISHED STEEL 45 4
+Brand#23 SMALL PLATED BRASS 36 4
+Brand#23 SMALL PLATED BRASS 49 4
+Brand#23 SMALL PLATED COPPER 14 4
+Brand#23 SMALL PLATED TIN 14 4
+Brand#23 SMALL POLISHED BRASS 9 4
+Brand#23 SMALL POLISHED BRASS 14 4
+Brand#23 SMALL POLISHED NICKEL 3 4
+Brand#23 SMALL POLISHED STEEL 14 4
+Brand#23 SMALL POLISHED TIN 9 4
+Brand#23 STANDARD ANODIZED BRASS 19 4
+Brand#23 STANDARD ANODIZED BRASS 45 4
+Brand#23 STANDARD ANODIZED COPPER 19 4
+Brand#23 STANDARD ANODIZED TIN 3 4
+Brand#23 STANDARD BRUSHED COPPER 36 4
+Brand#23 STANDARD BRUSHED NICKEL 19 4
+Brand#23 STANDARD BRUSHED STEEL 49 4
+Brand#23 STANDARD BURNISHED COPPER 19 4
+Brand#23 STANDARD PLATED BRASS 3 4
+Brand#23 STANDARD PLATED BRASS 9 4
+Brand#23 STANDARD PLATED STEEL 36 4
+Brand#23 STANDARD PLATED TIN 19 4
+Brand#23 STANDARD POLISHED BRASS 9 4
+Brand#23 STANDARD POLISHED BRASS 49 4
+Brand#23 STANDARD POLISHED STEEL 19 4
+Brand#23 STANDARD POLISHED STEEL 49 4
+Brand#23 STANDARD POLISHED TIN 23 4
+Brand#24 ECONOMY ANODIZED BRASS 3 4
+Brand#24 ECONOMY ANODIZED BRASS 9 4
+Brand#24 ECONOMY ANODIZED BRASS 23 4
+Brand#24 ECONOMY ANODIZED COPPER 9 4
+Brand#24 ECONOMY ANODIZED COPPER 49 4
+Brand#24 ECONOMY BRUSHED BRASS 36 4
+Brand#24 ECONOMY BRUSHED COPPER 23 4
+Brand#24 ECONOMY BURNISHED COPPER 3 4
+Brand#24 ECONOMY BURNISHED NICKEL 19 4
+Brand#24 ECONOMY BURNISHED STEEL 45 4
+Brand#24 ECONOMY PLATED BRASS 23 4
+Brand#24 ECONOMY PLATED COPPER 36 4
+Brand#24 ECONOMY PLATED STEEL 45 4
+Brand#24 ECONOMY POLISHED BRASS 23 4
+Brand#24 ECONOMY POLISHED COPPER 45 4
+Brand#24 ECONOMY POLISHED NICKEL 36 4
+Brand#24 ECONOMY POLISHED STEEL 14 4
+Brand#24 ECONOMY POLISHED STEEL 36 4
+Brand#24 LARGE ANODIZED NICKEL 23 4
+Brand#24 LARGE ANODIZED NICKEL 45 4
+Brand#24 LARGE ANODIZED TIN 45 4
+Brand#24 LARGE BRUSHED BRASS 14 4
+Brand#24 LARGE BRUSHED BRASS 23 4
+Brand#24 LARGE BRUSHED STEEL 9 4
+Brand#24 LARGE BRUSHED STEEL 23 4
+Brand#24 LARGE BRUSHED STEEL 45 4
+Brand#24 LARGE BRUSHED TIN 49 4
+Brand#24 LARGE BURNISHED BRASS 3 4
+Brand#24 LARGE BURNISHED NICKEL 19 4
+Brand#24 LARGE PLATED BRASS 9 4
+Brand#24 LARGE PLATED NICKEL 36 4
+Brand#24 LARGE PLATED NICKEL 49 4
+Brand#24 LARGE PLATED TIN 9 4
+Brand#24 LARGE PLATED TIN 19 4
+Brand#24 LARGE PLATED TIN 36 4
+Brand#24 LARGE PLATED TIN 49 4
+Brand#24 LARGE POLISHED BRASS 9 4
+Brand#24 LARGE POLISHED COPPER 9 4
+Brand#24 LARGE POLISHED COPPER 49 4
+Brand#24 LARGE POLISHED NICKEL 19 4
+Brand#24 LARGE POLISHED STEEL 23 4
+Brand#24 LARGE POLISHED TIN 14 4
+Brand#24 MEDIUM ANODIZED COPPER 45 4
+Brand#24 MEDIUM BRUSHED COPPER 9 4
+Brand#24 MEDIUM BRUSHED COPPER 14 4
+Brand#24 MEDIUM BRUSHED NICKEL 9 4
+Brand#24 MEDIUM BRUSHED NICKEL 23 4
+Brand#24 MEDIUM BRUSHED STEEL 14 4
+Brand#24 MEDIUM BRUSHED STEEL 45 4
+Brand#24 MEDIUM BRUSHED STEEL 49 4
+Brand#24 MEDIUM BURNISHED BRASS 36 4
+Brand#24 MEDIUM BURNISHED NICKEL 36 4
+Brand#24 MEDIUM BURNISHED STEEL 36 4
+Brand#24 MEDIUM PLATED COPPER 14 4
+Brand#24 MEDIUM PLATED STEEL 3 4
+Brand#24 MEDIUM PLATED STEEL 19 4
+Brand#24 PROMO ANODIZED NICKEL 9 4
+Brand#24 PROMO ANODIZED NICKEL 19 4
+Brand#24 PROMO ANODIZED NICKEL 45 4
+Brand#24 PROMO ANODIZED STEEL 3 4
+Brand#24 PROMO ANODIZED TIN 45 4
+Brand#24 PROMO BRUSHED BRASS 19 4
+Brand#24 PROMO BRUSHED NICKEL 19 4
+Brand#24 PROMO BRUSHED NICKEL 45 4
+Brand#24 PROMO BRUSHED STEEL 49 4
+Brand#24 PROMO BURNISHED BRASS 3 4
+Brand#24 PROMO BURNISHED BRASS 45 4
+Brand#24 PROMO BURNISHED STEEL 49 4
+Brand#24 PROMO PLATED BRASS 3 4
+Brand#24 PROMO PLATED COPPER 23 4
+Brand#24 PROMO PLATED COPPER 49 4
+Brand#24 PROMO POLISHED BRASS 3 4
+Brand#24 PROMO POLISHED BRASS 14 4
+Brand#24 PROMO POLISHED NICKEL 3 4
+Brand#24 PROMO POLISHED STEEL 14 4
+Brand#24 PROMO POLISHED STEEL 19 4
+Brand#24 PROMO POLISHED STEEL 23 4
+Brand#24 SMALL ANODIZED BRASS 19 4
+Brand#24 SMALL ANODIZED COPPER 3 4
+Brand#24 SMALL ANODIZED NICKEL 14 4
+Brand#24 SMALL ANODIZED STEEL 36 4
+Brand#24 SMALL ANODIZED TIN 3 4
+Brand#24 SMALL ANODIZED TIN 36 4
+Brand#24 SMALL BRUSHED COPPER 49 4
+Brand#24 SMALL BRUSHED NICKEL 49 4
+Brand#24 SMALL BURNISHED BRASS 14 4
+Brand#24 SMALL BURNISHED BRASS 19 4
+Brand#24 SMALL BURNISHED TIN 9 4
+Brand#24 SMALL PLATED BRASS 3 4
+Brand#24 SMALL PLATED COPPER 14 4
+Brand#24 SMALL PLATED COPPER 36 4
+Brand#24 SMALL PLATED NICKEL 14 4
+Brand#24 SMALL PLATED NICKEL 49 4
+Brand#24 SMALL POLISHED BRASS 3 4
+Brand#24 SMALL POLISHED NICKEL 9 4
+Brand#24 SMALL POLISHED NICKEL 19 4
+Brand#24 SMALL POLISHED NICKEL 36 4
+Brand#24 SMALL POLISHED STEEL 9 4
+Brand#24 SMALL POLISHED STEEL 36 4
+Brand#24 STANDARD ANODIZED TIN 9 4
+Brand#24 STANDARD ANODIZED TIN 49 4
+Brand#24 STANDARD BRUSHED BRASS 14 4
+Brand#24 STANDARD BRUSHED COPPER 23 4
+Brand#24 STANDARD BRUSHED NICKEL 19 4
+Brand#24 STANDARD BRUSHED STEEL 14 4
+Brand#24 STANDARD BRUSHED TIN 36 4
+Brand#24 STANDARD BURNISHED COPPER 19 4
+Brand#24 STANDARD BURNISHED COPPER 36 4
+Brand#24 STANDARD BURNISHED NICKEL 45 4
+Brand#24 STANDARD PLATED BRASS 36 4
+Brand#24 STANDARD PLATED COPPER 45 4
+Brand#24 STANDARD PLATED NICKEL 36 4
+Brand#24 STANDARD PLATED TIN 36 4
+Brand#24 STANDARD POLISHED COPPER 45 4
+Brand#24 STANDARD POLISHED NICKEL 14 4
+Brand#25 ECONOMY ANODIZED BRASS 14 4
+Brand#25 ECONOMY ANODIZED BRASS 49 4
+Brand#25 ECONOMY ANODIZED TIN 9 4
+Brand#25 ECONOMY ANODIZED TIN 19 4
+Brand#25 ECONOMY ANODIZED TIN 49 4
+Brand#25 ECONOMY BRUSHED COPPER 36 4
+Brand#25 ECONOMY BURNISHED COPPER 45 4
+Brand#25 ECONOMY BURNISHED TIN 19 4
+Brand#25 ECONOMY PLATED NICKEL 23 4
+Brand#25 ECONOMY PLATED TIN 14 4
+Brand#25 ECONOMY POLISHED BRASS 23 4
+Brand#25 ECONOMY POLISHED COPPER 9 4
+Brand#25 ECONOMY POLISHED NICKEL 3 4
+Brand#25 ECONOMY POLISHED TIN 9 4
+Brand#25 ECONOMY POLISHED TIN 45 4
+Brand#25 LARGE ANODIZED BRASS 3 4
+Brand#25 LARGE ANODIZED BRASS 14 4
+Brand#25 LARGE ANODIZED COPPER 36 4
+Brand#25 LARGE ANODIZED NICKEL 23 4
+Brand#25 LARGE ANODIZED STEEL 23 4
+Brand#25 LARGE BRUSHED NICKEL 19 4
+Brand#25 LARGE BRUSHED NICKEL 49 4
+Brand#25 LARGE BRUSHED TIN 3 4
+Brand#25 LARGE BRUSHED TIN 9 4
+Brand#25 LARGE BURNISHED BRASS 19 4
+Brand#25 LARGE BURNISHED BRASS 23 4
+Brand#25 LARGE BURNISHED BRASS 49 4
+Brand#25 LARGE BURNISHED NICKEL 14 4
+Brand#25 LARGE BURNISHED TIN 49 4
+Brand#25 LARGE PLATED BRASS 14 4
+Brand#25 LARGE PLATED NICKEL 23 4
+Brand#25 LARGE PLATED NICKEL 45 4
+Brand#25 LARGE PLATED TIN 19 4
+Brand#25 LARGE PLATED TIN 23 4
+Brand#25 LARGE POLISHED BRASS 9 4
+Brand#25 LARGE POLISHED COPPER 14 4
+Brand#25 LARGE POLISHED COPPER 36 4
+Brand#25 MEDIUM ANODIZED TIN 36 4
+Brand#25 MEDIUM BRUSHED COPPER 9 4
+Brand#25 MEDIUM BRUSHED COPPER 36 4
+Brand#25 MEDIUM BRUSHED COPPER 49 4
+Brand#25 MEDIUM BURNISHED COPPER 49 4
+Brand#25 MEDIUM BURNISHED NICKEL 9 4
+Brand#25 MEDIUM BURNISHED NICKEL 49 4
+Brand#25 MEDIUM BURNISHED STEEL 3 4
+Brand#25 MEDIUM BURNISHED STEEL 36 4
+Brand#25 MEDIUM BURNISHED STEEL 45 4
+Brand#25 MEDIUM BURNISHED STEEL 49 4
+Brand#25 MEDIUM BURNISHED TIN 9 4
+Brand#25 MEDIUM BURNISHED TIN 36 4
+Brand#25 MEDIUM PLATED BRASS 45 4
+Brand#25 MEDIUM PLATED COPPER 14 4
+Brand#25 MEDIUM PLATED NICKEL 45 4
+Brand#25 MEDIUM PLATED STEEL 9 4
+Brand#25 MEDIUM PLATED STEEL 36 4
+Brand#25 PROMO ANODIZED COPPER 14 4
+Brand#25 PROMO ANODIZED COPPER 19 4
+Brand#25 PROMO ANODIZED STEEL 36 4
+Brand#25 PROMO ANODIZED TIN 3 4
+Brand#25 PROMO ANODIZED TIN 14 4
+Brand#25 PROMO BRUSHED NICKEL 3 4
+Brand#25 PROMO BRUSHED STEEL 19 4
+Brand#25 PROMO BRUSHED TIN 14 4
+Brand#25 PROMO BRUSHED TIN 36 4
+Brand#25 PROMO BURNISHED COPPER 19 4
+Brand#25 PROMO BURNISHED COPPER 45 4
+Brand#25 PROMO BURNISHED COPPER 49 4
+Brand#25 PROMO BURNISHED NICKEL 36 4
+Brand#25 PROMO BURNISHED TIN 3 4
+Brand#25 PROMO PLATED BRASS 45 4
+Brand#25 PROMO PLATED COPPER 19 4
+Brand#25 PROMO PLATED NICKEL 45 4
+Brand#25 PROMO PLATED NICKEL 49 4
+Brand#25 PROMO PLATED STEEL 23 4
+Brand#25 PROMO POLISHED BRASS 23 4
+Brand#25 SMALL ANODIZED BRASS 45 4
+Brand#25 SMALL ANODIZED NICKEL 19 4
+Brand#25 SMALL ANODIZED STEEL 23 4
+Brand#25 SMALL ANODIZED TIN 14 4
+Brand#25 SMALL ANODIZED TIN 19 4
+Brand#25 SMALL BRUSHED COPPER 45 4
+Brand#25 SMALL BRUSHED NICKEL 9 4
+Brand#25 SMALL BURNISHED COPPER 3 4
+Brand#25 SMALL BURNISHED STEEL 3 4
+Brand#25 SMALL BURNISHED STEEL 14 4
+Brand#25 SMALL BURNISHED TIN 3 4
+Brand#25 SMALL PLATED BRASS 19 4
+Brand#25 SMALL PLATED COPPER 23 4
+Brand#25 SMALL PLATED STEEL 45 4
+Brand#25 SMALL PLATED TIN 36 4
+Brand#25 SMALL POLISHED BRASS 23 4
+Brand#25 SMALL POLISHED COPPER 9 4
+Brand#25 SMALL POLISHED STEEL 14 4
+Brand#25 STANDARD ANODIZED STEEL 3 4
+Brand#25 STANDARD ANODIZED STEEL 19 4
+Brand#25 STANDARD ANODIZED TIN 9 4
+Brand#25 STANDARD BRUSHED BRASS 14 4
+Brand#25 STANDARD BRUSHED NICKEL 19 4
+Brand#25 STANDARD BRUSHED TIN 9 4
+Brand#25 STANDARD BURNISHED NICKEL 9 4
+Brand#25 STANDARD PLATED BRASS 3 4
+Brand#25 STANDARD PLATED COPPER 14 4
+Brand#25 STANDARD PLATED NICKEL 36 4
+Brand#25 STANDARD POLISHED BRASS 45 4
+Brand#25 STANDARD POLISHED COPPER 23 4
+Brand#25 STANDARD POLISHED NICKEL 3 4
+Brand#25 STANDARD POLISHED NICKEL 49 4
+Brand#25 STANDARD POLISHED TIN 36 4
+Brand#25 STANDARD POLISHED TIN 45 4
+Brand#31 ECONOMY ANODIZED BRASS 3 4
+Brand#31 ECONOMY ANODIZED COPPER 45 4
+Brand#31 ECONOMY ANODIZED STEEL 3 4
+Brand#31 ECONOMY ANODIZED TIN 45 4
+Brand#31 ECONOMY BRUSHED BRASS 14 4
+Brand#31 ECONOMY BRUSHED COPPER 19 4
+Brand#31 ECONOMY BRUSHED NICKEL 9 4
+Brand#31 ECONOMY BRUSHED NICKEL 14 4
+Brand#31 ECONOMY BRUSHED NICKEL 49 4
+Brand#31 ECONOMY BURNISHED COPPER 36 4
+Brand#31 ECONOMY BURNISHED STEEL 3 4
+Brand#31 ECONOMY BURNISHED TIN 49 4
+Brand#31 ECONOMY PLATED COPPER 49 4
+Brand#31 ECONOMY PLATED NICKEL 9 4
+Brand#31 ECONOMY PLATED STEEL 23 4
+Brand#31 ECONOMY PLATED TIN 36 4
+Brand#31 ECONOMY PLATED TIN 49 4
+Brand#31 ECONOMY POLISHED COPPER 3 4
+Brand#31 ECONOMY POLISHED COPPER 36 4
+Brand#31 ECONOMY POLISHED COPPER 49 4
+Brand#31 ECONOMY POLISHED NICKEL 3 4
+Brand#31 LARGE ANODIZED BRASS 19 4
+Brand#31 LARGE ANODIZED STEEL 45 4
+Brand#31 LARGE BRUSHED BRASS 36 4
+Brand#31 LARGE BRUSHED BRASS 49 4
+Brand#31 LARGE BRUSHED TIN 3 4
+Brand#31 LARGE BURNISHED BRASS 9 4
+Brand#31 LARGE PLATED COPPER 19 4
+Brand#31 LARGE PLATED NICKEL 14 4
+Brand#31 LARGE PLATED TIN 9 4
+Brand#31 LARGE PLATED TIN 14 4
+Brand#31 LARGE POLISHED BRASS 14 4
+Brand#31 LARGE POLISHED STEEL 14 4
+Brand#31 LARGE POLISHED STEEL 45 4
+Brand#31 LARGE POLISHED TIN 19 4
+Brand#31 MEDIUM ANODIZED BRASS 23 4
+Brand#31 MEDIUM ANODIZED BRASS 36 4
+Brand#31 MEDIUM ANODIZED COPPER 14 4
+Brand#31 MEDIUM ANODIZED COPPER 19 4
+Brand#31 MEDIUM ANODIZED COPPER 36 4
+Brand#31 MEDIUM ANODIZED STEEL 14 4
+Brand#31 MEDIUM ANODIZED STEEL 49 4
+Brand#31 MEDIUM ANODIZED TIN 19 4
+Brand#31 MEDIUM ANODIZED TIN 49 4
+Brand#31 MEDIUM BRUSHED BRASS 36 4
+Brand#31 MEDIUM BRUSHED STEEL 14 4
+Brand#31 MEDIUM BURNISHED BRASS 14 4
+Brand#31 MEDIUM BURNISHED COPPER 3 4
+Brand#31 MEDIUM BURNISHED NICKEL 9 4
+Brand#31 MEDIUM BURNISHED STEEL 9 4
+Brand#31 MEDIUM BURNISHED TIN 14 4
+Brand#31 MEDIUM BURNISHED TIN 23 4
+Brand#31 MEDIUM PLATED BRASS 3 4
+Brand#31 MEDIUM PLATED TIN 9 4
+Brand#31 MEDIUM PLATED TIN 36 4
+Brand#31 MEDIUM PLATED TIN 45 4
+Brand#31 PROMO ANODIZED BRASS 3 4
+Brand#31 PROMO ANODIZED NICKEL 9 4
+Brand#31 PROMO BRUSHED BRASS 3 4
+Brand#31 PROMO BRUSHED BRASS 23 4
+Brand#31 PROMO BRUSHED COPPER 23 4
+Brand#31 PROMO BRUSHED NICKEL 45 4
+Brand#31 PROMO BURNISHED COPPER 36 4
+Brand#31 PROMO BURNISHED STEEL 3 4
+Brand#31 PROMO BURNISHED TIN 3 4
+Brand#31 PROMO PLATED BRASS 19 4
+Brand#31 PROMO PLATED NICKEL 36 4
+Brand#31 PROMO POLISHED BRASS 49 4
+Brand#31 PROMO POLISHED COPPER 14 4
+Brand#31 PROMO POLISHED NICKEL 3 4
+Brand#31 PROMO POLISHED NICKEL 9 4
+Brand#31 PROMO POLISHED TIN 3 4
+Brand#31 PROMO POLISHED TIN 23 4
+Brand#31 SMALL ANODIZED COPPER 45 4
+Brand#31 SMALL ANODIZED STEEL 23 4
+Brand#31 SMALL ANODIZED TIN 3 4
+Brand#31 SMALL BRUSHED COPPER 36 4
+Brand#31 SMALL BRUSHED COPPER 49 4
+Brand#31 SMALL BRUSHED NICKEL 19 4
+Brand#31 SMALL BRUSHED NICKEL 23 4
+Brand#31 SMALL BURNISHED BRASS 45 4
+Brand#31 SMALL BURNISHED NICKEL 9 4
+Brand#31 SMALL BURNISHED NICKEL 36 4
+Brand#31 SMALL PLATED COPPER 36 4
+Brand#31 SMALL PLATED NICKEL 9 4
+Brand#31 SMALL PLATED NICKEL 36 4
+Brand#31 SMALL POLISHED BRASS 3 4
+Brand#31 SMALL POLISHED COPPER 45 4
+Brand#31 SMALL POLISHED NICKEL 45 4
+Brand#31 SMALL POLISHED TIN 23 4
+Brand#31 SMALL POLISHED TIN 49 4
+Brand#31 STANDARD BRUSHED STEEL 23 4
+Brand#31 STANDARD BRUSHED STEEL 49 4
+Brand#31 STANDARD BURNISHED BRASS 14 4
+Brand#31 STANDARD BURNISHED NICKEL 45 4
+Brand#31 STANDARD PLATED NICKEL 3 4
+Brand#31 STANDARD POLISHED BRASS 3 4
+Brand#31 STANDARD POLISHED BRASS 45 4
+Brand#31 STANDARD POLISHED STEEL 36 4
+Brand#32 ECONOMY ANODIZED BRASS 19 4
+Brand#32 ECONOMY ANODIZED COPPER 36 4
+Brand#32 ECONOMY ANODIZED STEEL 23 4
+Brand#32 ECONOMY ANODIZED STEEL 36 4
+Brand#32 ECONOMY ANODIZED STEEL 45 4
+Brand#32 ECONOMY ANODIZED TIN 19 4
+Brand#32 ECONOMY BRUSHED COPPER 45 4
+Brand#32 ECONOMY BRUSHED TIN 45 4
+Brand#32 ECONOMY BURNISHED BRASS 23 4
+Brand#32 ECONOMY BURNISHED COPPER 36 4
+Brand#32 ECONOMY BURNISHED COPPER 45 4
+Brand#32 ECONOMY BURNISHED STEEL 19 4
+Brand#32 ECONOMY PLATED BRASS 9 4
+Brand#32 ECONOMY PLATED COPPER 9 4
+Brand#32 ECONOMY PLATED NICKEL 23 4
+Brand#32 ECONOMY PLATED TIN 45 4
+Brand#32 ECONOMY POLISHED STEEL 3 4
+Brand#32 LARGE ANODIZED BRASS 23 4
+Brand#32 LARGE ANODIZED BRASS 36 4
+Brand#32 LARGE ANODIZED NICKEL 45 4
+Brand#32 LARGE ANODIZED STEEL 3 4
+Brand#32 LARGE ANODIZED STEEL 14 4
+Brand#32 LARGE BRUSHED STEEL 45 4
+Brand#32 LARGE BRUSHED TIN 45 4
+Brand#32 LARGE BURNISHED NICKEL 36 4
+Brand#32 LARGE BURNISHED TIN 19 4
+Brand#32 LARGE BURNISHED TIN 45 4
+Brand#32 LARGE PLATED BRASS 3 4
+Brand#32 LARGE PLATED NICKEL 49 4
+Brand#32 LARGE PLATED STEEL 19 4
+Brand#32 LARGE PLATED STEEL 36 4
+Brand#32 LARGE POLISHED BRASS 45 4
+Brand#32 LARGE POLISHED COPPER 9 4
+Brand#32 LARGE POLISHED COPPER 49 4
+Brand#32 LARGE POLISHED NICKEL 3 4
+Brand#32 MEDIUM ANODIZED BRASS 3 4
+Brand#32 MEDIUM ANODIZED BRASS 9 4
+Brand#32 MEDIUM ANODIZED TIN 23 4
+Brand#32 MEDIUM BRUSHED BRASS 23 4
+Brand#32 MEDIUM BRUSHED BRASS 49 4
+Brand#32 MEDIUM BRUSHED COPPER 9 4
+Brand#32 MEDIUM BRUSHED COPPER 19 4
+Brand#32 MEDIUM BRUSHED TIN 49 4
+Brand#32 MEDIUM BURNISHED BRASS 9 4
+Brand#32 MEDIUM BURNISHED BRASS 36 4
+Brand#32 MEDIUM BURNISHED BRASS 49 4
+Brand#32 MEDIUM BURNISHED COPPER 9 4
+Brand#32 MEDIUM BURNISHED COPPER 45 4
+Brand#32 MEDIUM BURNISHED NICKEL 49 4
+Brand#32 MEDIUM BURNISHED TIN 9 4
+Brand#32 MEDIUM BURNISHED TIN 45 4
+Brand#32 MEDIUM PLATED BRASS 3 4
+Brand#32 MEDIUM PLATED BRASS 49 4
+Brand#32 MEDIUM PLATED COPPER 3 4
+Brand#32 MEDIUM PLATED STEEL 9 4
+Brand#32 MEDIUM PLATED TIN 9 4
+Brand#32 PROMO ANODIZED BRASS 3 4
+Brand#32 PROMO ANODIZED COPPER 19 4
+Brand#32 PROMO ANODIZED NICKEL 23 4
+Brand#32 PROMO BRUSHED COPPER 23 4
+Brand#32 PROMO BRUSHED NICKEL 14 4
+Brand#32 PROMO BRUSHED NICKEL 36 4
+Brand#32 PROMO BRUSHED STEEL 14 4
+Brand#32 PROMO BRUSHED STEEL 23 4
+Brand#32 PROMO BRUSHED STEEL 49 4
+Brand#32 PROMO BURNISHED BRASS 45 4
+Brand#32 PROMO BURNISHED NICKEL 45 4
+Brand#32 PROMO BURNISHED TIN 14 4
+Brand#32 PROMO BURNISHED TIN 45 4
+Brand#32 PROMO PLATED TIN 19 4
+Brand#32 PROMO POLISHED NICKEL 36 4
+Brand#32 PROMO POLISHED TIN 3 4
+Brand#32 SMALL ANODIZED BRASS 3 4
+Brand#32 SMALL ANODIZED NICKEL 3 4
+Brand#32 SMALL ANODIZED NICKEL 14 4
+Brand#32 SMALL ANODIZED TIN 9 4
+Brand#32 SMALL BRUSHED BRASS 9 4
+Brand#32 SMALL BRUSHED BRASS 19 4
+Brand#32 SMALL BRUSHED COPPER 3 4
+Brand#32 SMALL BRUSHED COPPER 23 4
+Brand#32 SMALL BRUSHED NICKEL 9 4
+Brand#32 SMALL BRUSHED NICKEL 45 4
+Brand#32 SMALL BRUSHED STEEL 23 4
+Brand#32 SMALL BRUSHED TIN 9 4
+Brand#32 SMALL BURNISHED NICKEL 36 4
+Brand#32 SMALL BURNISHED STEEL 3 4
+Brand#32 SMALL BURNISHED TIN 23 4
+Brand#32 SMALL PLATED BRASS 49 4
+Brand#32 SMALL PLATED COPPER 36 4
+Brand#32 SMALL PLATED COPPER 45 4
+Brand#32 SMALL PLATED NICKEL 45 4
+Brand#32 SMALL PLATED STEEL 45 4
+Brand#32 SMALL PLATED TIN 23 4
+Brand#32 SMALL PLATED TIN 36 4
+Brand#32 SMALL PLATED TIN 45 4
+Brand#32 SMALL POLISHED NICKEL 36 4
+Brand#32 SMALL POLISHED STEEL 14 4
+Brand#32 SMALL POLISHED STEEL 23 4
+Brand#32 SMALL POLISHED STEEL 36 4
+Brand#32 SMALL POLISHED TIN 36 4
+Brand#32 SMALL POLISHED TIN 45 4
+Brand#32 STANDARD ANODIZED NICKEL 19 4
+Brand#32 STANDARD ANODIZED TIN 9 4
+Brand#32 STANDARD ANODIZED TIN 14 4
+Brand#32 STANDARD ANODIZED TIN 19 4
+Brand#32 STANDARD BRUSHED NICKEL 23 4
+Brand#32 STANDARD BURNISHED BRASS 36 4
+Brand#32 STANDARD BURNISHED BRASS 45 4
+Brand#32 STANDARD BURNISHED COPPER 3 4
+Brand#32 STANDARD BURNISHED COPPER 36 4
+Brand#32 STANDARD BURNISHED NICKEL 49 4
+Brand#32 STANDARD BURNISHED STEEL 49 4
+Brand#32 STANDARD BURNISHED TIN 23 4
+Brand#32 STANDARD PLATED BRASS 9 4
+Brand#32 STANDARD PLATED BRASS 45 4
+Brand#32 STANDARD PLATED STEEL 36 4
+Brand#32 STANDARD POLISHED BRASS 14 4
+Brand#32 STANDARD POLISHED COPPER 36 4
+Brand#32 STANDARD POLISHED STEEL 14 4
+Brand#33 ECONOMY ANODIZED BRASS 23 4
+Brand#33 ECONOMY ANODIZED COPPER 9 4
+Brand#33 ECONOMY ANODIZED NICKEL 3 4
+Brand#33 ECONOMY ANODIZED NICKEL 9 4
+Brand#33 ECONOMY ANODIZED NICKEL 23 4
+Brand#33 ECONOMY ANODIZED NICKEL 36 4
+Brand#33 ECONOMY BRUSHED BRASS 14 4
+Brand#33 ECONOMY BRUSHED COPPER 23 4
+Brand#33 ECONOMY BURNISHED BRASS 49 4
+Brand#33 ECONOMY BURNISHED COPPER 3 4
+Brand#33 ECONOMY BURNISHED COPPER 14 4
+Brand#33 ECONOMY BURNISHED STEEL 3 4
+Brand#33 ECONOMY BURNISHED TIN 36 4
+Brand#33 ECONOMY BURNISHED TIN 45 4
+Brand#33 ECONOMY PLATED COPPER 19 4
+Brand#33 ECONOMY PLATED COPPER 45 4
+Brand#33 ECONOMY PLATED NICKEL 14 4
+Brand#33 ECONOMY PLATED NICKEL 36 4
+Brand#33 ECONOMY PLATED STEEL 3 4
+Brand#33 ECONOMY PLATED STEEL 23 4
+Brand#33 ECONOMY PLATED STEEL 36 4
+Brand#33 ECONOMY POLISHED BRASS 14 4
+Brand#33 ECONOMY POLISHED NICKEL 19 4
+Brand#33 ECONOMY POLISHED TIN 9 4
+Brand#33 LARGE ANODIZED BRASS 36 4
+Brand#33 LARGE ANODIZED COPPER 19 4
+Brand#33 LARGE ANODIZED COPPER 45 4
+Brand#33 LARGE ANODIZED NICKEL 36 4
+Brand#33 LARGE ANODIZED NICKEL 45 4
+Brand#33 LARGE ANODIZED STEEL 3 4
+Brand#33 LARGE ANODIZED STEEL 45 4
+Brand#33 LARGE ANODIZED TIN 45 4
+Brand#33 LARGE BRUSHED BRASS 3 4
+Brand#33 LARGE BRUSHED BRASS 49 4
+Brand#33 LARGE BRUSHED STEEL 19 4
+Brand#33 LARGE BRUSHED TIN 36 4
+Brand#33 LARGE BURNISHED COPPER 45 4
+Brand#33 LARGE BURNISHED NICKEL 23 4
+Brand#33 LARGE BURNISHED STEEL 19 4
+Brand#33 LARGE PLATED BRASS 3 4
+Brand#33 LARGE PLATED COPPER 19 4
+Brand#33 LARGE PLATED STEEL 3 4
+Brand#33 LARGE PLATED STEEL 19 4
+Brand#33 LARGE PLATED TIN 45 4
+Brand#33 LARGE POLISHED BRASS 45 4
+Brand#33 LARGE POLISHED STEEL 14 4
+Brand#33 LARGE POLISHED STEEL 23 4
+Brand#33 LARGE POLISHED TIN 23 4
+Brand#33 MEDIUM ANODIZED BRASS 3 4
+Brand#33 MEDIUM ANODIZED COPPER 9 4
+Brand#33 MEDIUM ANODIZED COPPER 36 4
+Brand#33 MEDIUM ANODIZED COPPER 49 4
+Brand#33 MEDIUM ANODIZED NICKEL 3 4
+Brand#33 MEDIUM ANODIZED NICKEL 19 4
+Brand#33 MEDIUM BRUSHED BRASS 3 4
+Brand#33 MEDIUM BRUSHED STEEL 19 4
+Brand#33 MEDIUM BRUSHED TIN 14 4
+Brand#33 MEDIUM BURNISHED COPPER 14 4
+Brand#33 MEDIUM BURNISHED COPPER 49 4
+Brand#33 MEDIUM BURNISHED TIN 36 4
+Brand#33 MEDIUM PLATED BRASS 3 4
+Brand#33 MEDIUM PLATED STEEL 3 4
+Brand#33 MEDIUM PLATED STEEL 49 4
+Brand#33 PROMO ANODIZED BRASS 3 4
+Brand#33 PROMO BRUSHED BRASS 49 4
+Brand#33 PROMO BURNISHED COPPER 23 4
+Brand#33 PROMO BURNISHED NICKEL 14 4
+Brand#33 PROMO BURNISHED NICKEL 36 4
+Brand#33 PROMO BURNISHED TIN 19 4
+Brand#33 PROMO BURNISHED TIN 23 4
+Brand#33 PROMO PLATED COPPER 14 4
+Brand#33 PROMO PLATED STEEL 45 4
+Brand#33 PROMO PLATED STEEL 49 4
+Brand#33 PROMO PLATED TIN 49 4
+Brand#33 PROMO POLISHED COPPER 3 4
+Brand#33 PROMO POLISHED STEEL 3 4
+Brand#33 PROMO POLISHED STEEL 9 4
+Brand#33 PROMO POLISHED STEEL 23 4
+Brand#33 SMALL ANODIZED BRASS 19 4
+Brand#33 SMALL ANODIZED COPPER 23 4
+Brand#33 SMALL ANODIZED COPPER 49 4
+Brand#33 SMALL ANODIZED STEEL 9 4
+Brand#33 SMALL BRUSHED BRASS 3 4
+Brand#33 SMALL BRUSHED COPPER 3 4
+Brand#33 SMALL BRUSHED NICKEL 45 4
+Brand#33 SMALL BRUSHED STEEL 3 4
+Brand#33 SMALL BRUSHED TIN 9 4
+Brand#33 SMALL BURNISHED BRASS 19 4
+Brand#33 SMALL BURNISHED NICKEL 3 4
+Brand#33 SMALL PLATED BRASS 3 4
+Brand#33 SMALL PLATED STEEL 14 4
+Brand#33 SMALL PLATED STEEL 45 4
+Brand#33 SMALL PLATED TIN 23 4
+Brand#33 SMALL PLATED TIN 36 4
+Brand#33 SMALL POLISHED NICKEL 23 4
+Brand#33 SMALL POLISHED TIN 19 4
+Brand#33 SMALL POLISHED TIN 23 4
+Brand#33 SMALL POLISHED TIN 45 4
+Brand#33 STANDARD ANODIZED COPPER 49 4
+Brand#33 STANDARD ANODIZED STEEL 14 4
+Brand#33 STANDARD ANODIZED STEEL 45 4
+Brand#33 STANDARD ANODIZED STEEL 49 4
+Brand#33 STANDARD ANODIZED TIN 45 4
+Brand#33 STANDARD BRUSHED BRASS 9 4
+Brand#33 STANDARD BRUSHED NICKEL 45 4
+Brand#33 STANDARD BRUSHED STEEL 9 4
+Brand#33 STANDARD BRUSHED TIN 36 4
+Brand#33 STANDARD BURNISHED BRASS 9 4
+Brand#33 STANDARD BURNISHED BRASS 23 4
+Brand#33 STANDARD BURNISHED NICKEL 49 4
+Brand#33 STANDARD PLATED BRASS 49 4
+Brand#33 STANDARD PLATED COPPER 3 4
+Brand#33 STANDARD PLATED COPPER 14 4
+Brand#33 STANDARD PLATED NICKEL 36 4
+Brand#33 STANDARD PLATED STEEL 3 4
+Brand#33 STANDARD PLATED STEEL 36 4
+Brand#33 STANDARD PLATED TIN 14 4
+Brand#33 STANDARD POLISHED BRASS 9 4
+Brand#33 STANDARD POLISHED BRASS 19 4
+Brand#33 STANDARD POLISHED STEEL 3 4
+Brand#33 STANDARD POLISHED STEEL 9 4
+Brand#33 STANDARD POLISHED STEEL 14 4
+Brand#34 ECONOMY ANODIZED BRASS 9 4
+Brand#34 ECONOMY ANODIZED COPPER 3 4
+Brand#34 ECONOMY ANODIZED COPPER 14 4
+Brand#34 ECONOMY ANODIZED COPPER 19 4
+Brand#34 ECONOMY ANODIZED STEEL 9 4
+Brand#34 ECONOMY ANODIZED TIN 49 4
+Brand#34 ECONOMY BRUSHED BRASS 14 4
+Brand#34 ECONOMY BRUSHED NICKEL 49 4
+Brand#34 ECONOMY BURNISHED COPPER 9 4
+Brand#34 ECONOMY BURNISHED STEEL 19 4
+Brand#34 ECONOMY BURNISHED TIN 3 4
+Brand#34 ECONOMY BURNISHED TIN 23 4
+Brand#34 ECONOMY PLATED BRASS 9 4
+Brand#34 ECONOMY PLATED BRASS 14 4
+Brand#34 ECONOMY PLATED COPPER 3 4
+Brand#34 ECONOMY PLATED NICKEL 45 4
+Brand#34 ECONOMY PLATED TIN 14 4
+Brand#34 ECONOMY PLATED TIN 45 4
+Brand#34 ECONOMY POLISHED BRASS 45 4
+Brand#34 LARGE ANODIZED BRASS 14 4
+Brand#34 LARGE ANODIZED BRASS 23 4
+Brand#34 LARGE ANODIZED BRASS 36 4
+Brand#34 LARGE ANODIZED NICKEL 3 4
+Brand#34 LARGE ANODIZED TIN 49 4
+Brand#34 LARGE BRUSHED BRASS 49 4
+Brand#34 LARGE BRUSHED COPPER 23 4
+Brand#34 LARGE BRUSHED NICKEL 23 4
+Brand#34 LARGE BRUSHED STEEL 14 4
+Brand#34 LARGE BRUSHED STEEL 19 4
+Brand#34 LARGE BRUSHED TIN 9 4
+Brand#34 LARGE BURNISHED BRASS 23 4
+Brand#34 LARGE BURNISHED COPPER 3 4
+Brand#34 LARGE BURNISHED COPPER 36 4
+Brand#34 LARGE BURNISHED NICKEL 19 4
+Brand#34 LARGE PLATED BRASS 23 4
+Brand#34 LARGE PLATED BRASS 36 4
+Brand#34 LARGE PLATED BRASS 45 4
+Brand#34 LARGE PLATED COPPER 23 4
+Brand#34 LARGE PLATED COPPER 49 4
+Brand#34 LARGE PLATED STEEL 49 4
+Brand#34 LARGE POLISHED NICKEL 49 4
+Brand#34 MEDIUM ANODIZED COPPER 36 4
+Brand#34 MEDIUM ANODIZED TIN 3 4
+Brand#34 MEDIUM BRUSHED BRASS 49 4
+Brand#34 MEDIUM BRUSHED COPPER 9 4
+Brand#34 MEDIUM BRUSHED NICKEL 9 4
+Brand#34 MEDIUM BRUSHED NICKEL 23 4
+Brand#34 MEDIUM BRUSHED TIN 3 4
+Brand#34 MEDIUM BRUSHED TIN 14 4
+Brand#34 MEDIUM BURNISHED STEEL 45 4
+Brand#34 MEDIUM BURNISHED STEEL 49 4
+Brand#34 MEDIUM PLATED COPPER 36 4
+Brand#34 MEDIUM PLATED TIN 3 4
+Brand#34 MEDIUM PLATED TIN 14 4
+Brand#34 PROMO ANODIZED COPPER 45 4
+Brand#34 PROMO ANODIZED NICKEL 14 4
+Brand#34 PROMO ANODIZED STEEL 49 4
+Brand#34 PROMO ANODIZED TIN 14 4
+Brand#34 PROMO BRUSHED BRASS 9 4
+Brand#34 PROMO BRUSHED BRASS 23 4
+Brand#34 PROMO BRUSHED COPPER 36 4
+Brand#34 PROMO BRUSHED STEEL 36 4
+Brand#34 PROMO BURNISHED BRASS 49 4
+Brand#34 PROMO BURNISHED STEEL 3 4
+Brand#34 PROMO PLATED BRASS 9 4
+Brand#34 PROMO PLATED STEEL 49 4
+Brand#34 PROMO POLISHED BRASS 23 4
+Brand#34 PROMO POLISHED NICKEL 3 4
+Brand#34 PROMO POLISHED NICKEL 36 4
+Brand#34 SMALL ANODIZED BRASS 36 4
+Brand#34 SMALL ANODIZED COPPER 45 4
+Brand#34 SMALL ANODIZED NICKEL 14 4
+Brand#34 SMALL ANODIZED NICKEL 36 4
+Brand#34 SMALL ANODIZED STEEL 3 4
+Brand#34 SMALL ANODIZED STEEL 19 4
+Brand#34 SMALL ANODIZED STEEL 23 4
+Brand#34 SMALL ANODIZED STEEL 36 4
+Brand#34 SMALL BRUSHED BRASS 14 4
+Brand#34 SMALL BRUSHED BRASS 36 4
+Brand#34 SMALL BRUSHED NICKEL 14 4
+Brand#34 SMALL BRUSHED NICKEL 36 4
+Brand#34 SMALL BRUSHED NICKEL 45 4
+Brand#34 SMALL BRUSHED TIN 9 4
+Brand#34 SMALL BRUSHED TIN 23 4
+Brand#34 SMALL BRUSHED TIN 36 4
+Brand#34 SMALL BURNISHED COPPER 9 4
+Brand#34 SMALL BURNISHED TIN 36 4
+Brand#34 SMALL PLATED BRASS 14 4
+Brand#34 SMALL PLATED COPPER 36 4
+Brand#34 SMALL PLATED TIN 45 4
+Brand#34 SMALL POLISHED NICKEL 14 4
+Brand#34 SMALL POLISHED NICKEL 45 4
+Brand#34 SMALL POLISHED TIN 9 4
+Brand#34 SMALL POLISHED TIN 14 4
+Brand#34 SMALL POLISHED TIN 19 4
+Brand#34 STANDARD ANODIZED BRASS 23 4
+Brand#34 STANDARD ANODIZED BRASS 36 4
+Brand#34 STANDARD ANODIZED COPPER 45 4
+Brand#34 STANDARD ANODIZED NICKEL 36 4
+Brand#34 STANDARD ANODIZED STEEL 9 4
+Brand#34 STANDARD ANODIZED STEEL 49 4
+Brand#34 STANDARD ANODIZED TIN 9 4
+Brand#34 STANDARD BRUSHED BRASS 19 4
+Brand#34 STANDARD BRUSHED BRASS 23 4
+Brand#34 STANDARD BRUSHED NICKEL 23 4
+Brand#34 STANDARD BRUSHED STEEL 3 4
+Brand#34 STANDARD BRUSHED TIN 19 4
+Brand#34 STANDARD BURNISHED COPPER 45 4
+Brand#34 STANDARD BURNISHED NICKEL 19 4
+Brand#34 STANDARD BURNISHED NICKEL 45 4
+Brand#34 STANDARD BURNISHED STEEL 36 4
+Brand#34 STANDARD BURNISHED TIN 45 4
+Brand#34 STANDARD PLATED BRASS 9 4
+Brand#34 STANDARD PLATED COPPER 9 4
+Brand#34 STANDARD PLATED NICKEL 36 4
+Brand#35 ECONOMY ANODIZED COPPER 3 4
+Brand#35 ECONOMY ANODIZED STEEL 45 4
+Brand#35 ECONOMY BRUSHED BRASS 3 4
+Brand#35 ECONOMY BRUSHED NICKEL 49 4
+Brand#35 ECONOMY BRUSHED STEEL 23 4
+Brand#35 ECONOMY BRUSHED STEEL 45 4
+Brand#35 ECONOMY BRUSHED TIN 14 4
+Brand#35 ECONOMY BRUSHED TIN 23 4
+Brand#35 ECONOMY BURNISHED NICKEL 19 4
+Brand#35 ECONOMY BURNISHED STEEL 36 4
+Brand#35 ECONOMY BURNISHED TIN 9 4
+Brand#35 ECONOMY BURNISHED TIN 19 4
+Brand#35 ECONOMY BURNISHED TIN 49 4
+Brand#35 ECONOMY POLISHED COPPER 9 4
+Brand#35 ECONOMY POLISHED TIN 19 4
+Brand#35 LARGE ANODIZED BRASS 3 4
+Brand#35 LARGE ANODIZED BRASS 23 4
+Brand#35 LARGE ANODIZED COPPER 49 4
+Brand#35 LARGE ANODIZED STEEL 36 4
+Brand#35 LARGE ANODIZED TIN 9 4
+Brand#35 LARGE BRUSHED COPPER 9 4
+Brand#35 LARGE BRUSHED COPPER 23 4
+Brand#35 LARGE BRUSHED STEEL 3 4
+Brand#35 LARGE BRUSHED STEEL 9 4
+Brand#35 LARGE BURNISHED BRASS 36 4
+Brand#35 LARGE BURNISHED BRASS 45 4
+Brand#35 LARGE BURNISHED COPPER 23 4
+Brand#35 LARGE BURNISHED NICKEL 23 4
+Brand#35 LARGE PLATED BRASS 9 4
+Brand#35 LARGE PLATED COPPER 36 4
+Brand#35 LARGE POLISHED BRASS 49 4
+Brand#35 LARGE POLISHED STEEL 9 4
+Brand#35 LARGE POLISHED TIN 14 4
+Brand#35 MEDIUM ANODIZED BRASS 9 4
+Brand#35 MEDIUM ANODIZED BRASS 36 4
+Brand#35 MEDIUM ANODIZED COPPER 9 4
+Brand#35 MEDIUM BRUSHED BRASS 14 4
+Brand#35 MEDIUM BRUSHED COPPER 9 4
+Brand#35 MEDIUM BRUSHED COPPER 36 4
+Brand#35 MEDIUM BURNISHED BRASS 49 4
+Brand#35 MEDIUM BURNISHED NICKEL 45 4
+Brand#35 MEDIUM BURNISHED TIN 36 4
+Brand#35 MEDIUM PLATED BRASS 23 4
+Brand#35 MEDIUM PLATED COPPER 9 4
+Brand#35 MEDIUM PLATED NICKEL 45 4
+Brand#35 MEDIUM PLATED NICKEL 49 4
+Brand#35 MEDIUM PLATED STEEL 49 4
+Brand#35 PROMO ANODIZED COPPER 49 4
+Brand#35 PROMO ANODIZED NICKEL 19 4
+Brand#35 PROMO ANODIZED NICKEL 23 4
+Brand#35 PROMO ANODIZED TIN 3 4
+Brand#35 PROMO ANODIZED TIN 14 4
+Brand#35 PROMO BRUSHED BRASS 49 4
+Brand#35 PROMO BRUSHED NICKEL 14 4
+Brand#35 PROMO BRUSHED NICKEL 19 4
+Brand#35 PROMO BURNISHED BRASS 3 4
+Brand#35 PROMO BURNISHED STEEL 3 4
+Brand#35 PROMO PLATED BRASS 19 4
+Brand#35 PROMO PLATED COPPER 14 4
+Brand#35 PROMO PLATED STEEL 23 4
+Brand#35 PROMO PLATED STEEL 36 4
+Brand#35 PROMO PLATED TIN 19 4
+Brand#35 PROMO POLISHED BRASS 9 4
+Brand#35 PROMO POLISHED BRASS 36 4
+Brand#35 PROMO POLISHED NICKEL 36 4
+Brand#35 PROMO POLISHED STEEL 23 4
+Brand#35 PROMO POLISHED TIN 36 4
+Brand#35 PROMO POLISHED TIN 45 4
+Brand#35 SMALL ANODIZED COPPER 9 4
+Brand#35 SMALL ANODIZED STEEL 19 4
+Brand#35 SMALL ANODIZED TIN 19 4
+Brand#35 SMALL BRUSHED BRASS 36 4
+Brand#35 SMALL BRUSHED STEEL 49 4
+Brand#35 SMALL BRUSHED TIN 3 4
+Brand#35 SMALL BRUSHED TIN 19 4
+Brand#35 SMALL BRUSHED TIN 23 4
+Brand#35 SMALL BURNISHED BRASS 23 4
+Brand#35 SMALL BURNISHED STEEL 36 4
+Brand#35 SMALL BURNISHED TIN 3 4
+Brand#35 SMALL BURNISHED TIN 36 4
+Brand#35 SMALL BURNISHED TIN 49 4
+Brand#35 SMALL PLATED BRASS 23 4
+Brand#35 SMALL PLATED STEEL 14 4
+Brand#35 SMALL POLISHED BRASS 36 4
+Brand#35 SMALL POLISHED STEEL 3 4
+Brand#35 SMALL POLISHED STEEL 49 4
+Brand#35 SMALL POLISHED TIN 23 4
+Brand#35 SMALL POLISHED TIN 45 4
+Brand#35 STANDARD ANODIZED NICKEL 14 4
+Brand#35 STANDARD ANODIZED STEEL 23 4
+Brand#35 STANDARD ANODIZED STEEL 45 4
+Brand#35 STANDARD ANODIZED TIN 9 4
+Brand#35 STANDARD ANODIZED TIN 19 4
+Brand#35 STANDARD BRUSHED BRASS 3 4
+Brand#35 STANDARD BRUSHED BRASS 23 4
+Brand#35 STANDARD BRUSHED BRASS 36 4
+Brand#35 STANDARD BRUSHED COPPER 36 4
+Brand#35 STANDARD BRUSHED NICKEL 36 4
+Brand#35 STANDARD BRUSHED NICKEL 49 4
+Brand#35 STANDARD BRUSHED TIN 9 4
+Brand#35 STANDARD BURNISHED BRASS 9 4
+Brand#35 STANDARD BURNISHED BRASS 19 4
+Brand#35 STANDARD BURNISHED BRASS 23 4
+Brand#35 STANDARD BURNISHED COPPER 36 4
+Brand#35 STANDARD BURNISHED STEEL 14 4
+Brand#35 STANDARD PLATED COPPER 19 4
+Brand#35 STANDARD PLATED NICKEL 23 4
+Brand#35 STANDARD PLATED STEEL 14 4
+Brand#35 STANDARD PLATED STEEL 23 4
+Brand#35 STANDARD PLATED TIN 49 4
+Brand#35 STANDARD POLISHED NICKEL 23 4
+Brand#35 STANDARD POLISHED TIN 23 4
+Brand#35 STANDARD POLISHED TIN 45 4
+Brand#41 ECONOMY ANODIZED STEEL 49 4
+Brand#41 ECONOMY BRUSHED BRASS 3 4
+Brand#41 ECONOMY BRUSHED COPPER 36 4
+Brand#41 ECONOMY BRUSHED NICKEL 23 4
+Brand#41 ECONOMY BRUSHED STEEL 36 4
+Brand#41 ECONOMY BRUSHED STEEL 45 4
+Brand#41 ECONOMY BRUSHED TIN 14 4
+Brand#41 ECONOMY PLATED COPPER 3 4
+Brand#41 ECONOMY PLATED STEEL 3 4
+Brand#41 ECONOMY PLATED TIN 23 4
+Brand#41 ECONOMY POLISHED COPPER 19 4
+Brand#41 ECONOMY POLISHED NICKEL 9 4
+Brand#41 ECONOMY POLISHED NICKEL 14 4
+Brand#41 ECONOMY POLISHED NICKEL 23 4
+Brand#41 ECONOMY POLISHED NICKEL 49 4
+Brand#41 ECONOMY POLISHED STEEL 9 4
+Brand#41 ECONOMY POLISHED STEEL 19 4
+Brand#41 ECONOMY POLISHED STEEL 45 4
+Brand#41 ECONOMY POLISHED TIN 19 4
+Brand#41 LARGE ANODIZED BRASS 14 4
+Brand#41 LARGE ANODIZED BRASS 23 4
+Brand#41 LARGE ANODIZED COPPER 49 4
+Brand#41 LARGE ANODIZED STEEL 3 4
+Brand#41 LARGE ANODIZED STEEL 23 4
+Brand#41 LARGE BRUSHED COPPER 23 4
+Brand#41 LARGE BRUSHED COPPER 49 4
+Brand#41 LARGE BRUSHED STEEL 19 4
+Brand#41 LARGE BURNISHED BRASS 45 4
+Brand#41 LARGE BURNISHED COPPER 3 4
+Brand#41 LARGE BURNISHED NICKEL 23 4
+Brand#41 LARGE BURNISHED TIN 9 4
+Brand#41 LARGE PLATED NICKEL 3 4
+Brand#41 LARGE PLATED NICKEL 23 4
+Brand#41 LARGE PLATED STEEL 9 4
+Brand#41 LARGE PLATED STEEL 36 4
+Brand#41 LARGE PLATED TIN 9 4
+Brand#41 LARGE POLISHED BRASS 36 4
+Brand#41 LARGE POLISHED COPPER 19 4
+Brand#41 LARGE POLISHED COPPER 49 4
+Brand#41 LARGE POLISHED NICKEL 36 4
+Brand#41 LARGE POLISHED STEEL 14 4
+Brand#41 MEDIUM ANODIZED BRASS 9 4
+Brand#41 MEDIUM ANODIZED COPPER 14 4
+Brand#41 MEDIUM ANODIZED NICKEL 3 4
+Brand#41 MEDIUM ANODIZED NICKEL 9 4
+Brand#41 MEDIUM ANODIZED STEEL 14 4
+Brand#41 MEDIUM BRUSHED COPPER 3 4
+Brand#41 MEDIUM BRUSHED TIN 9 4
+Brand#41 MEDIUM BURNISHED COPPER 23 4
+Brand#41 MEDIUM BURNISHED STEEL 9 4
+Brand#41 MEDIUM BURNISHED STEEL 45 4
+Brand#41 MEDIUM BURNISHED TIN 3 4
+Brand#41 MEDIUM PLATED BRASS 19 4
+Brand#41 MEDIUM PLATED BRASS 45 4
+Brand#41 MEDIUM PLATED COPPER 19 4
+Brand#41 MEDIUM PLATED STEEL 19 4
+Brand#41 MEDIUM PLATED STEEL 23 4
+Brand#41 PROMO ANODIZED BRASS 19 4
+Brand#41 PROMO ANODIZED COPPER 9 4
+Brand#41 PROMO ANODIZED NICKEL 9 4
+Brand#41 PROMO BRUSHED BRASS 14 4
+Brand#41 PROMO BRUSHED COPPER 36 4
+Brand#41 PROMO BRUSHED NICKEL 14 4
+Brand#41 PROMO BURNISHED BRASS 49 4
+Brand#41 PROMO BURNISHED NICKEL 36 4
+Brand#41 PROMO BURNISHED TIN 3 4
+Brand#41 PROMO PLATED NICKEL 14 4
+Brand#41 PROMO PLATED NICKEL 45 4
+Brand#41 PROMO PLATED STEEL 3 4
+Brand#41 PROMO PLATED TIN 3 4
+Brand#41 PROMO POLISHED COPPER 23 4
+Brand#41 SMALL ANODIZED BRASS 3 4
+Brand#41 SMALL ANODIZED BRASS 14 4
+Brand#41 SMALL ANODIZED STEEL 45 4
+Brand#41 SMALL ANODIZED TIN 9 4
+Brand#41 SMALL BRUSHED TIN 19 4
+Brand#41 SMALL BURNISHED COPPER 9 4
+Brand#41 SMALL BURNISHED NICKEL 3 4
+Brand#41 SMALL BURNISHED TIN 45 4
+Brand#41 SMALL PLATED COPPER 14 4
+Brand#41 SMALL PLATED COPPER 36 4
+Brand#41 SMALL PLATED COPPER 49 4
+Brand#41 SMALL PLATED TIN 19 4
+Brand#41 SMALL POLISHED COPPER 14 4
+Brand#41 SMALL POLISHED COPPER 19 4
+Brand#41 SMALL POLISHED COPPER 36 4
+Brand#41 SMALL POLISHED TIN 45 4
+Brand#41 STANDARD ANODIZED COPPER 19 4
+Brand#41 STANDARD ANODIZED NICKEL 9 4
+Brand#41 STANDARD ANODIZED STEEL 49 4
+Brand#41 STANDARD ANODIZED TIN 9 4
+Brand#41 STANDARD ANODIZED TIN 36 4
+Brand#41 STANDARD ANODIZED TIN 49 4
+Brand#41 STANDARD BRUSHED BRASS 19 4
+Brand#41 STANDARD BRUSHED NICKEL 3 4
+Brand#41 STANDARD BRUSHED NICKEL 9 4
+Brand#41 STANDARD BRUSHED STEEL 45 4
+Brand#41 STANDARD BRUSHED TIN 45 4
+Brand#41 STANDARD BURNISHED BRASS 23 4
+Brand#41 STANDARD BURNISHED BRASS 36 4
+Brand#41 STANDARD BURNISHED COPPER 49 4
+Brand#41 STANDARD BURNISHED STEEL 45 4
+Brand#41 STANDARD PLATED BRASS 45 4
+Brand#41 STANDARD PLATED NICKEL 14 4
+Brand#41 STANDARD PLATED STEEL 45 4
+Brand#41 STANDARD PLATED TIN 49 4
+Brand#41 STANDARD POLISHED STEEL 9 4
+Brand#41 STANDARD POLISHED STEEL 19 4
+Brand#41 STANDARD POLISHED TIN 45 4
+Brand#42 ECONOMY ANODIZED NICKEL 19 4
+Brand#42 ECONOMY BRUSHED BRASS 14 4
+Brand#42 ECONOMY BRUSHED COPPER 3 4
+Brand#42 ECONOMY BRUSHED COPPER 14 4
+Brand#42 ECONOMY BRUSHED NICKEL 14 4
+Brand#42 ECONOMY BRUSHED STEEL 14 4
+Brand#42 ECONOMY BRUSHED TIN 19 4
+Brand#42 ECONOMY BRUSHED TIN 49 4
+Brand#42 ECONOMY BURNISHED BRASS 19 4
+Brand#42 ECONOMY BURNISHED COPPER 23 4
+Brand#42 ECONOMY BURNISHED NICKEL 14 4
+Brand#42 ECONOMY BURNISHED TIN 14 4
+Brand#42 ECONOMY PLATED COPPER 23 4
+Brand#42 ECONOMY POLISHED BRASS 3 4
+Brand#42 ECONOMY POLISHED COPPER 9 4
+Brand#42 ECONOMY POLISHED STEEL 9 4
+Brand#42 ECONOMY POLISHED STEEL 36 4
+Brand#42 ECONOMY POLISHED TIN 14 4
+Brand#42 LARGE ANODIZED BRASS 49 4
+Brand#42 LARGE ANODIZED COPPER 14 4
+Brand#42 LARGE ANODIZED COPPER 49 4
+Brand#42 LARGE ANODIZED NICKEL 45 4
+Brand#42 LARGE ANODIZED NICKEL 49 4
+Brand#42 LARGE ANODIZED TIN 45 4
+Brand#42 LARGE BRUSHED BRASS 49 4
+Brand#42 LARGE BURNISHED BRASS 45 4
+Brand#42 LARGE BURNISHED BRASS 49 4
+Brand#42 LARGE BURNISHED COPPER 9 4
+Brand#42 LARGE BURNISHED TIN 9 4
+Brand#42 LARGE PLATED BRASS 45 4
+Brand#42 LARGE PLATED COPPER 9 4
+Brand#42 LARGE PLATED NICKEL 36 4
+Brand#42 LARGE PLATED TIN 23 4
+Brand#42 LARGE POLISHED BRASS 9 4
+Brand#42 LARGE POLISHED NICKEL 3 4
+Brand#42 LARGE POLISHED NICKEL 23 4
+Brand#42 LARGE POLISHED STEEL 9 4
+Brand#42 MEDIUM ANODIZED BRASS 23 4
+Brand#42 MEDIUM ANODIZED COPPER 19 4
+Brand#42 MEDIUM ANODIZED NICKEL 14 4
+Brand#42 MEDIUM ANODIZED NICKEL 19 4
+Brand#42 MEDIUM ANODIZED NICKEL 23 4
+Brand#42 MEDIUM ANODIZED STEEL 9 4
+Brand#42 MEDIUM ANODIZED STEEL 14 4
+Brand#42 MEDIUM ANODIZED STEEL 23 4
+Brand#42 MEDIUM ANODIZED TIN 14 4
+Brand#42 MEDIUM ANODIZED TIN 19 4
+Brand#42 MEDIUM BRUSHED COPPER 45 4
+Brand#42 MEDIUM BRUSHED COPPER 49 4
+Brand#42 MEDIUM BRUSHED STEEL 36 4
+Brand#42 MEDIUM BURNISHED COPPER 49 4
+Brand#42 MEDIUM BURNISHED TIN 3 4
+Brand#42 MEDIUM BURNISHED TIN 49 4
+Brand#42 MEDIUM PLATED NICKEL 45 4
+Brand#42 MEDIUM PLATED STEEL 3 4
+Brand#42 MEDIUM PLATED STEEL 23 4
+Brand#42 MEDIUM PLATED STEEL 45 4
+Brand#42 PROMO ANODIZED NICKEL 3 4
+Brand#42 PROMO ANODIZED NICKEL 19 4
+Brand#42 PROMO ANODIZED STEEL 49 4
+Brand#42 PROMO BRUSHED COPPER 45 4
+Brand#42 PROMO BRUSHED STEEL 19 4
+Brand#42 PROMO BRUSHED TIN 45 4
+Brand#42 PROMO BURNISHED COPPER 45 4
+Brand#42 PROMO BURNISHED NICKEL 3 4
+Brand#42 PROMO BURNISHED STEEL 9 4
+Brand#42 PROMO BURNISHED TIN 49 4
+Brand#42 PROMO PLATED BRASS 45 4
+Brand#42 PROMO PLATED NICKEL 23 4
+Brand#42 PROMO PLATED STEEL 19 4
+Brand#42 PROMO PLATED STEEL 45 4
+Brand#42 PROMO POLISHED COPPER 36 4
+Brand#42 PROMO POLISHED NICKEL 3 4
+Brand#42 SMALL ANODIZED BRASS 23 4
+Brand#42 SMALL ANODIZED COPPER 14 4
+Brand#42 SMALL ANODIZED COPPER 19 4
+Brand#42 SMALL ANODIZED NICKEL 23 4
+Brand#42 SMALL BRUSHED TIN 49 4
+Brand#42 SMALL BURNISHED BRASS 3 4
+Brand#42 SMALL BURNISHED BRASS 36 4
+Brand#42 SMALL BURNISHED COPPER 9 4
+Brand#42 SMALL BURNISHED NICKEL 9 4
+Brand#42 SMALL BURNISHED TIN 9 4
+Brand#42 SMALL PLATED NICKEL 9 4
+Brand#42 SMALL PLATED TIN 36 4
+Brand#42 SMALL POLISHED BRASS 3 4
+Brand#42 SMALL POLISHED COPPER 36 4
+Brand#42 SMALL POLISHED NICKEL 23 4
+Brand#42 SMALL POLISHED STEEL 49 4
+Brand#42 SMALL POLISHED TIN 3 4
+Brand#42 STANDARD ANODIZED BRASS 49 4
+Brand#42 STANDARD ANODIZED COPPER 49 4
+Brand#42 STANDARD ANODIZED NICKEL 36 4
+Brand#42 STANDARD ANODIZED NICKEL 45 4
+Brand#42 STANDARD BRUSHED NICKEL 23 4
+Brand#42 STANDARD BURNISHED NICKEL 49 4
+Brand#42 STANDARD BURNISHED STEEL 3 4
+Brand#42 STANDARD BURNISHED TIN 19 4
+Brand#42 STANDARD PLATED BRASS 19 4
+Brand#42 STANDARD PLATED COPPER 9 4
+Brand#42 STANDARD PLATED NICKEL 45 4
+Brand#42 STANDARD PLATED STEEL 3 4
+Brand#42 STANDARD POLISHED BRASS 36 4
+Brand#42 STANDARD POLISHED BRASS 45 4
+Brand#42 STANDARD POLISHED COPPER 14 4
+Brand#42 STANDARD POLISHED NICKEL 45 4
+Brand#42 STANDARD POLISHED TIN 9 4
+Brand#42 STANDARD POLISHED TIN 19 4
+Brand#42 STANDARD POLISHED TIN 23 4
+Brand#42 STANDARD POLISHED TIN 36 4
+Brand#43 ECONOMY ANODIZED COPPER 19 4
+Brand#43 ECONOMY ANODIZED COPPER 45 4
+Brand#43 ECONOMY ANODIZED NICKEL 3 4
+Brand#43 ECONOMY ANODIZED NICKEL 49 4
+Brand#43 ECONOMY ANODIZED STEEL 23 4
+Brand#43 ECONOMY ANODIZED TIN 49 4
+Brand#43 ECONOMY BRUSHED BRASS 49 4
+Brand#43 ECONOMY BRUSHED COPPER 45 4
+Brand#43 ECONOMY BRUSHED NICKEL 9 4
+Brand#43 ECONOMY BURNISHED NICKEL 9 4
+Brand#43 ECONOMY BURNISHED TIN 19 4
+Brand#43 ECONOMY PLATED COPPER 36 4
+Brand#43 ECONOMY PLATED STEEL 9 4
+Brand#43 ECONOMY PLATED TIN 14 4
+Brand#43 ECONOMY PLATED TIN 19 4
+Brand#43 ECONOMY PLATED TIN 49 4
+Brand#43 ECONOMY POLISHED COPPER 19 4
+Brand#43 ECONOMY POLISHED NICKEL 36 4
+Brand#43 ECONOMY POLISHED TIN 14 4
+Brand#43 ECONOMY POLISHED TIN 45 4
+Brand#43 LARGE ANODIZED BRASS 14 4
+Brand#43 LARGE ANODIZED BRASS 36 4
+Brand#43 LARGE ANODIZED COPPER 45 4
+Brand#43 LARGE BRUSHED COPPER 3 4
+Brand#43 LARGE BRUSHED NICKEL 14 4
+Brand#43 LARGE BRUSHED NICKEL 19 4
+Brand#43 LARGE BRUSHED NICKEL 45 4
+Brand#43 LARGE BRUSHED NICKEL 49 4
+Brand#43 LARGE BURNISHED COPPER 3 4
+Brand#43 LARGE BURNISHED TIN 23 4
+Brand#43 LARGE BURNISHED TIN 45 4
+Brand#43 LARGE PLATED BRASS 45 4
+Brand#43 LARGE PLATED STEEL 14 4
+Brand#43 LARGE PLATED TIN 36 4
+Brand#43 LARGE PLATED TIN 45 4
+Brand#43 LARGE POLISHED BRASS 9 4
+Brand#43 LARGE POLISHED COPPER 9 4
+Brand#43 LARGE POLISHED COPPER 19 4
+Brand#43 LARGE POLISHED STEEL 14 4
+Brand#43 LARGE POLISHED TIN 45 4
+Brand#43 MEDIUM ANODIZED BRASS 14 4
+Brand#43 MEDIUM ANODIZED COPPER 36 4
+Brand#43 MEDIUM ANODIZED COPPER 49 4
+Brand#43 MEDIUM ANODIZED STEEL 19 4
+Brand#43 MEDIUM ANODIZED STEEL 36 4
+Brand#43 MEDIUM BRUSHED BRASS 9 4
+Brand#43 MEDIUM BRUSHED BRASS 49 4
+Brand#43 MEDIUM BRUSHED COPPER 3 4
+Brand#43 MEDIUM BRUSHED NICKEL 9 4
+Brand#43 MEDIUM BRUSHED STEEL 23 4
+Brand#43 MEDIUM BURNISHED COPPER 14 4
+Brand#43 MEDIUM BURNISHED COPPER 45 4
+Brand#43 MEDIUM BURNISHED TIN 23 4
+Brand#43 MEDIUM PLATED BRASS 3 4
+Brand#43 MEDIUM PLATED COPPER 14 4
+Brand#43 MEDIUM PLATED NICKEL 36 4
+Brand#43 MEDIUM PLATED NICKEL 45 4
+Brand#43 MEDIUM PLATED TIN 49 4
+Brand#43 PROMO ANODIZED NICKEL 45 4
+Brand#43 PROMO ANODIZED TIN 14 4
+Brand#43 PROMO BRUSHED NICKEL 14 4
+Brand#43 PROMO BRUSHED STEEL 14 4
+Brand#43 PROMO BRUSHED TIN 45 4
+Brand#43 PROMO BURNISHED BRASS 49 4
+Brand#43 PROMO BURNISHED NICKEL 9 4
+Brand#43 PROMO BURNISHED STEEL 3 4
+Brand#43 PROMO BURNISHED STEEL 36 4
+Brand#43 PROMO BURNISHED TIN 36 4
+Brand#43 PROMO PLATED BRASS 19 4
+Brand#43 PROMO PLATED COPPER 45 4
+Brand#43 PROMO PLATED COPPER 49 4
+Brand#43 PROMO PLATED TIN 3 4
+Brand#43 PROMO POLISHED BRASS 19 4
+Brand#43 PROMO POLISHED BRASS 23 4
+Brand#43 PROMO POLISHED NICKEL 49 4
+Brand#43 PROMO POLISHED STEEL 14 4
+Brand#43 PROMO POLISHED STEEL 19 4
+Brand#43 PROMO POLISHED STEEL 23 4
+Brand#43 PROMO POLISHED STEEL 36 4
+Brand#43 SMALL ANODIZED BRASS 19 4
+Brand#43 SMALL ANODIZED NICKEL 9 4
+Brand#43 SMALL BRUSHED NICKEL 3 4
+Brand#43 SMALL BRUSHED NICKEL 9 4
+Brand#43 SMALL BURNISHED BRASS 49 4
+Brand#43 SMALL BURNISHED STEEL 23 4
+Brand#43 SMALL PLATED BRASS 14 4
+Brand#43 SMALL PLATED BRASS 36 4
+Brand#43 SMALL PLATED COPPER 23 4
+Brand#43 SMALL PLATED COPPER 49 4
+Brand#43 SMALL PLATED NICKEL 36 4
+Brand#43 SMALL PLATED NICKEL 49 4
+Brand#43 SMALL PLATED STEEL 14 4
+Brand#43 SMALL PLATED TIN 49 4
+Brand#43 SMALL POLISHED STEEL 19 4
+Brand#43 STANDARD ANODIZED BRASS 3 4
+Brand#43 STANDARD ANODIZED COPPER 49 4
+Brand#43 STANDARD ANODIZED NICKEL 14 4
+Brand#43 STANDARD BRUSHED TIN 14 4
+Brand#43 STANDARD BURNISHED BRASS 23 4
+Brand#43 STANDARD BURNISHED STEEL 19 4
+Brand#43 STANDARD BURNISHED STEEL 23 4
+Brand#43 STANDARD PLATED BRASS 9 4
+Brand#43 STANDARD PLATED BRASS 19 4
+Brand#43 STANDARD PLATED BRASS 49 4
+Brand#43 STANDARD PLATED COPPER 36 4
+Brand#43 STANDARD PLATED NICKEL 14 4
+Brand#43 STANDARD PLATED NICKEL 19 4
+Brand#43 STANDARD PLATED TIN 14 4
+Brand#43 STANDARD POLISHED BRASS 23 4
+Brand#43 STANDARD POLISHED TIN 9 4
+Brand#44 ECONOMY ANODIZED BRASS 3 4
+Brand#44 ECONOMY ANODIZED BRASS 45 4
+Brand#44 ECONOMY ANODIZED NICKEL 36 4
+Brand#44 ECONOMY ANODIZED STEEL 19 4
+Brand#44 ECONOMY BRUSHED COPPER 23 4
+Brand#44 ECONOMY BRUSHED TIN 49 4
+Brand#44 ECONOMY BURNISHED COPPER 19 4
+Brand#44 ECONOMY BURNISHED STEEL 45 4
+Brand#44 ECONOMY PLATED STEEL 19 4
+Brand#44 ECONOMY PLATED STEEL 23 4
+Brand#44 ECONOMY PLATED TIN 23 4
+Brand#44 ECONOMY POLISHED BRASS 23 4
+Brand#44 ECONOMY POLISHED COPPER 9 4
+Brand#44 ECONOMY POLISHED COPPER 45 4
+Brand#44 ECONOMY POLISHED NICKEL 14 4
+Brand#44 ECONOMY POLISHED NICKEL 23 4
+Brand#44 ECONOMY POLISHED STEEL 49 4
+Brand#44 ECONOMY POLISHED TIN 23 4
+Brand#44 ECONOMY POLISHED TIN 36 4
+Brand#44 LARGE ANODIZED BRASS 19 4
+Brand#44 LARGE ANODIZED TIN 3 4
+Brand#44 LARGE ANODIZED TIN 14 4
+Brand#44 LARGE BRUSHED TIN 3 4
+Brand#44 LARGE BRUSHED TIN 23 4
+Brand#44 LARGE BURNISHED BRASS 23 4
+Brand#44 LARGE BURNISHED BRASS 49 4
+Brand#44 LARGE BURNISHED COPPER 3 4
+Brand#44 LARGE BURNISHED COPPER 19 4
+Brand#44 LARGE BURNISHED COPPER 36 4
+Brand#44 LARGE BURNISHED TIN 14 4
+Brand#44 LARGE PLATED BRASS 9 4
+Brand#44 LARGE PLATED BRASS 49 4
+Brand#44 LARGE PLATED NICKEL 14 4
+Brand#44 LARGE PLATED STEEL 14 4
+Brand#44 LARGE PLATED TIN 19 4
+Brand#44 LARGE PLATED TIN 23 4
+Brand#44 LARGE POLISHED STEEL 23 4
+Brand#44 LARGE POLISHED STEEL 49 4
+Brand#44 MEDIUM ANODIZED COPPER 45 4
+Brand#44 MEDIUM ANODIZED NICKEL 45 4
+Brand#44 MEDIUM BRUSHED BRASS 49 4
+Brand#44 MEDIUM BRUSHED COPPER 3 4
+Brand#44 MEDIUM BRUSHED COPPER 45 4
+Brand#44 MEDIUM BRUSHED STEEL 19 4
+Brand#44 MEDIUM BRUSHED TIN 49 4
+Brand#44 MEDIUM BURNISHED COPPER 45 4
+Brand#44 MEDIUM BURNISHED NICKEL 23 4
+Brand#44 MEDIUM BURNISHED TIN 23 4
+Brand#44 MEDIUM PLATED COPPER 14 4
+Brand#44 PROMO ANODIZED COPPER 23 4
+Brand#44 PROMO ANODIZED STEEL 36 4
+Brand#44 PROMO BRUSHED COPPER 23 4
+Brand#44 PROMO BRUSHED COPPER 36 4
+Brand#44 PROMO BRUSHED TIN 19 4
+Brand#44 PROMO PLATED BRASS 3 4
+Brand#44 PROMO PLATED COPPER 36 4
+Brand#44 PROMO PLATED STEEL 3 4
+Brand#44 PROMO PLATED STEEL 36 4
+Brand#44 PROMO PLATED STEEL 49 4
+Brand#44 PROMO POLISHED BRASS 3 4
+Brand#44 PROMO POLISHED BRASS 19 4
+Brand#44 PROMO POLISHED COPPER 45 4
+Brand#44 PROMO POLISHED STEEL 36 4
+Brand#44 PROMO POLISHED TIN 9 4
+Brand#44 SMALL ANODIZED COPPER 23 4
+Brand#44 SMALL ANODIZED STEEL 23 4
+Brand#44 SMALL ANODIZED TIN 45 4
+Brand#44 SMALL BRUSHED COPPER 14 4
+Brand#44 SMALL BRUSHED STEEL 45 4
+Brand#44 SMALL BURNISHED COPPER 14 4
+Brand#44 SMALL BURNISHED COPPER 49 4
+Brand#44 SMALL BURNISHED NICKEL 14 4
+Brand#44 SMALL BURNISHED STEEL 23 4
+Brand#44 SMALL BURNISHED TIN 49 4
+Brand#44 SMALL PLATED BRASS 36 4
+Brand#44 SMALL PLATED COPPER 19 4
+Brand#44 SMALL PLATED NICKEL 3 4
+Brand#44 SMALL POLISHED COPPER 3 4
+Brand#44 SMALL POLISHED COPPER 49 4
+Brand#44 SMALL POLISHED STEEL 3 4
+Brand#44 STANDARD ANODIZED BRASS 3 4
+Brand#44 STANDARD ANODIZED COPPER 3 4
+Brand#44 STANDARD ANODIZED NICKEL 3 4
+Brand#44 STANDARD ANODIZED NICKEL 36 4
+Brand#44 STANDARD ANODIZED STEEL 14 4
+Brand#44 STANDARD ANODIZED TIN 3 4
+Brand#44 STANDARD ANODIZED TIN 9 4
+Brand#44 STANDARD ANODIZED TIN 36 4
+Brand#44 STANDARD BRUSHED COPPER 36 4
+Brand#44 STANDARD BRUSHED COPPER 45 4
+Brand#44 STANDARD BRUSHED TIN 9 4
+Brand#44 STANDARD BRUSHED TIN 49 4
+Brand#44 STANDARD BURNISHED COPPER 9 4
+Brand#44 STANDARD BURNISHED STEEL 23 4
+Brand#44 STANDARD PLATED BRASS 14 4
+Brand#44 STANDARD PLATED BRASS 23 4
+Brand#44 STANDARD PLATED BRASS 49 4
+Brand#44 STANDARD PLATED COPPER 14 4
+Brand#44 STANDARD POLISHED NICKEL 19 4
+Brand#44 STANDARD POLISHED TIN 9 4
+Brand#51 ECONOMY ANODIZED BRASS 9 4
+Brand#51 ECONOMY ANODIZED BRASS 23 4
+Brand#51 ECONOMY ANODIZED NICKEL 3 4
+Brand#51 ECONOMY ANODIZED NICKEL 23 4
+Brand#51 ECONOMY ANODIZED STEEL 19 4
+Brand#51 ECONOMY ANODIZED STEEL 23 4
+Brand#51 ECONOMY ANODIZED STEEL 49 4
+Brand#51 ECONOMY BRUSHED BRASS 3 4
+Brand#51 ECONOMY BRUSHED BRASS 49 4
+Brand#51 ECONOMY BRUSHED NICKEL 14 4
+Brand#51 ECONOMY BRUSHED STEEL 45 4
+Brand#51 ECONOMY BRUSHED TIN 36 4
+Brand#51 ECONOMY BURNISHED BRASS 14 4
+Brand#51 ECONOMY BURNISHED COPPER 45 4
+Brand#51 ECONOMY PLATED NICKEL 49 4
+Brand#51 ECONOMY PLATED TIN 36 4
+Brand#51 ECONOMY POLISHED COPPER 9 4
+Brand#51 ECONOMY POLISHED STEEL 14 4
+Brand#51 ECONOMY POLISHED STEEL 49 4
+Brand#51 LARGE ANODIZED COPPER 9 4
+Brand#51 LARGE ANODIZED COPPER 49 4
+Brand#51 LARGE ANODIZED NICKEL 14 4
+Brand#51 LARGE ANODIZED STEEL 36 4
+Brand#51 LARGE BRUSHED NICKEL 3 4
+Brand#51 LARGE BRUSHED NICKEL 9 4
+Brand#51 LARGE BURNISHED BRASS 19 4
+Brand#51 LARGE BURNISHED BRASS 36 4
+Brand#51 LARGE BURNISHED COPPER 14 4
+Brand#51 LARGE BURNISHED NICKEL 14 4
+Brand#51 LARGE PLATED BRASS 36 4
+Brand#51 LARGE POLISHED COPPER 14 4
+Brand#51 LARGE POLISHED NICKEL 23 4
+Brand#51 LARGE POLISHED NICKEL 36 4
+Brand#51 LARGE POLISHED STEEL 19 4
+Brand#51 MEDIUM ANODIZED COPPER 9 4
+Brand#51 MEDIUM ANODIZED STEEL 3 4
+Brand#51 MEDIUM BRUSHED BRASS 36 4
+Brand#51 MEDIUM BRUSHED BRASS 45 4
+Brand#51 MEDIUM BRUSHED STEEL 3 4
+Brand#51 MEDIUM BRUSHED TIN 36 4
+Brand#51 MEDIUM BURNISHED NICKEL 3 4
+Brand#51 MEDIUM BURNISHED NICKEL 36 4
+Brand#51 MEDIUM BURNISHED STEEL 14 4
+Brand#51 MEDIUM BURNISHED TIN 9 4
+Brand#51 MEDIUM PLATED STEEL 19 4
+Brand#51 MEDIUM PLATED TIN 3 4
+Brand#51 PROMO ANODIZED NICKEL 14 4
+Brand#51 PROMO ANODIZED STEEL 23 4
+Brand#51 PROMO ANODIZED TIN 19 4
+Brand#51 PROMO BRUSHED BRASS 23 4
+Brand#51 PROMO BRUSHED COPPER 45 4
+Brand#51 PROMO BRUSHED STEEL 45 4
+Brand#51 PROMO BRUSHED TIN 9 4
+Brand#51 PROMO BURNISHED BRASS 19 4
+Brand#51 PROMO BURNISHED BRASS 23 4
+Brand#51 PROMO BURNISHED NICKEL 14 4
+Brand#51 PROMO PLATED BRASS 3 4
+Brand#51 PROMO PLATED BRASS 23 4
+Brand#51 PROMO PLATED TIN 19 4
+Brand#51 PROMO PLATED TIN 23 4
+Brand#51 PROMO POLISHED BRASS 23 4
+Brand#51 PROMO POLISHED COPPER 9 4
+Brand#51 PROMO POLISHED NICKEL 9 4
+Brand#51 PROMO POLISHED STEEL 49 4
+Brand#51 SMALL ANODIZED STEEL 14 4
+Brand#51 SMALL BRUSHED BRASS 23 4
+Brand#51 SMALL BRUSHED TIN 19 4
+Brand#51 SMALL BURNISHED NICKEL 23 4
+Brand#51 SMALL PLATED COPPER 49 4
+Brand#51 SMALL PLATED NICKEL 3 4
+Brand#51 SMALL PLATED NICKEL 14 4
+Brand#51 SMALL PLATED STEEL 45 4
+Brand#51 SMALL POLISHED NICKEL 14 4
+Brand#51 SMALL POLISHED NICKEL 23 4
+Brand#51 SMALL POLISHED STEEL 3 4
+Brand#51 SMALL POLISHED STEEL 19 4
+Brand#51 SMALL POLISHED STEEL 49 4
+Brand#51 STANDARD ANODIZED NICKEL 3 4
+Brand#51 STANDARD ANODIZED NICKEL 49 4
+Brand#51 STANDARD BRUSHED BRASS 3 4
+Brand#51 STANDARD BRUSHED COPPER 3 4
+Brand#51 STANDARD BRUSHED NICKEL 19 4
+Brand#51 STANDARD BRUSHED STEEL 36 4
+Brand#51 STANDARD BURNISHED COPPER 19 4
+Brand#51 STANDARD BURNISHED NICKEL 49 4
+Brand#51 STANDARD BURNISHED STEEL 23 4
+Brand#51 STANDARD BURNISHED STEEL 36 4
+Brand#51 STANDARD BURNISHED TIN 45 4
+Brand#51 STANDARD PLATED BRASS 36 4
+Brand#51 STANDARD PLATED BRASS 49 4
+Brand#51 STANDARD PLATED COPPER 14 4
+Brand#51 STANDARD PLATED COPPER 23 4
+Brand#51 STANDARD POLISHED BRASS 14 4
+Brand#51 STANDARD POLISHED BRASS 45 4
+Brand#51 STANDARD POLISHED STEEL 36 4
+Brand#51 STANDARD POLISHED STEEL 49 4
+Brand#51 STANDARD POLISHED TIN 45 4
+Brand#52 ECONOMY ANODIZED BRASS 14 4
+Brand#52 ECONOMY ANODIZED BRASS 23 4
+Brand#52 ECONOMY ANODIZED COPPER 36 4
+Brand#52 ECONOMY ANODIZED NICKEL 49 4
+Brand#52 ECONOMY ANODIZED STEEL 19 4
+Brand#52 ECONOMY BRUSHED COPPER 49 4
+Brand#52 ECONOMY BURNISHED BRASS 36 4
+Brand#52 ECONOMY BURNISHED COPPER 19 4
+Brand#52 ECONOMY BURNISHED COPPER 45 4
+Brand#52 ECONOMY BURNISHED NICKEL 19 4
+Brand#52 ECONOMY BURNISHED STEEL 36 4
+Brand#52 ECONOMY PLATED TIN 14 4
+Brand#52 ECONOMY PLATED TIN 23 4
+Brand#52 ECONOMY POLISHED BRASS 23 4
+Brand#52 ECONOMY POLISHED BRASS 45 4
+Brand#52 ECONOMY POLISHED NICKEL 36 4
+Brand#52 ECONOMY POLISHED STEEL 49 4
+Brand#52 LARGE ANODIZED COPPER 14 4
+Brand#52 LARGE ANODIZED NICKEL 3 4
+Brand#52 LARGE ANODIZED NICKEL 45 4
+Brand#52 LARGE ANODIZED TIN 45 4
+Brand#52 LARGE BRUSHED COPPER 19 4
+Brand#52 LARGE BRUSHED NICKEL 3 4
+Brand#52 LARGE BRUSHED NICKEL 19 4
+Brand#52 LARGE BRUSHED NICKEL 23 4
+Brand#52 LARGE BRUSHED STEEL 49 4
+Brand#52 LARGE BRUSHED TIN 14 4
+Brand#52 LARGE BURNISHED NICKEL 9 4
+Brand#52 LARGE BURNISHED TIN 23 4
+Brand#52 LARGE BURNISHED TIN 45 4
+Brand#52 LARGE PLATED BRASS 14 4
+Brand#52 LARGE PLATED COPPER 14 4
+Brand#52 LARGE PLATED COPPER 19 4
+Brand#52 LARGE PLATED NICKEL 45 4
+Brand#52 LARGE PLATED STEEL 9 4
+Brand#52 LARGE PLATED TIN 9 4
+Brand#52 LARGE POLISHED NICKEL 19 4
+Brand#52 LARGE POLISHED NICKEL 23 4
+Brand#52 LARGE POLISHED NICKEL 36 4
+Brand#52 LARGE POLISHED TIN 9 4
+Brand#52 MEDIUM ANODIZED COPPER 36 4
+Brand#52 MEDIUM ANODIZED STEEL 14 4
+Brand#52 MEDIUM ANODIZED TIN 3 4
+Brand#52 MEDIUM ANODIZED TIN 49 4
+Brand#52 MEDIUM BRUSHED COPPER 9 4
+Brand#52 MEDIUM BRUSHED NICKEL 9 4
+Brand#52 MEDIUM BRUSHED STEEL 23 4
+Brand#52 MEDIUM BRUSHED STEEL 49 4
+Brand#52 MEDIUM BURNISHED STEEL 23 4
+Brand#52 MEDIUM BURNISHED TIN 45 4
+Brand#52 MEDIUM BURNISHED TIN 49 4
+Brand#52 MEDIUM PLATED BRASS 36 4
+Brand#52 MEDIUM PLATED STEEL 9 4
+Brand#52 MEDIUM PLATED STEEL 49 4
+Brand#52 MEDIUM PLATED TIN 9 4
+Brand#52 MEDIUM PLATED TIN 49 4
+Brand#52 PROMO ANODIZED BRASS 9 4
+Brand#52 PROMO ANODIZED BRASS 23 4
+Brand#52 PROMO ANODIZED BRASS 36 4
+Brand#52 PROMO ANODIZED NICKEL 45 4
+Brand#52 PROMO ANODIZED STEEL 36 4
+Brand#52 PROMO BRUSHED COPPER 3 4
+Brand#52 PROMO BRUSHED NICKEL 3 4
+Brand#52 PROMO BRUSHED NICKEL 49 4
+Brand#52 PROMO BRUSHED STEEL 14 4
+Brand#52 PROMO BRUSHED TIN 3 4
+Brand#52 PROMO BRUSHED TIN 19 4
+Brand#52 PROMO BRUSHED TIN 36 4
+Brand#52 PROMO BURNISHED COPPER 49 4
+Brand#52 PROMO BURNISHED NICKEL 9 4
+Brand#52 PROMO BURNISHED STEEL 9 4
+Brand#52 PROMO BURNISHED STEEL 23 4
+Brand#52 PROMO BURNISHED TIN 19 4
+Brand#52 PROMO BURNISHED TIN 36 4
+Brand#52 PROMO PLATED BRASS 19 4
+Brand#52 PROMO PLATED BRASS 45 4
+Brand#52 PROMO PLATED BRASS 49 4
+Brand#52 PROMO PLATED COPPER 9 4
+Brand#52 PROMO PLATED NICKEL 3 4
+Brand#52 PROMO PLATED NICKEL 23 4
+Brand#52 PROMO POLISHED NICKEL 14 4
+Brand#52 PROMO POLISHED NICKEL 49 4
+Brand#52 PROMO POLISHED TIN 36 4
+Brand#52 SMALL ANODIZED BRASS 3 4
+Brand#52 SMALL ANODIZED BRASS 14 4
+Brand#52 SMALL ANODIZED COPPER 3 4
+Brand#52 SMALL ANODIZED NICKEL 36 4
+Brand#52 SMALL ANODIZED STEEL 9 4
+Brand#52 SMALL ANODIZED STEEL 19 4
+Brand#52 SMALL BRUSHED NICKEL 19 4
+Brand#52 SMALL BRUSHED STEEL 23 4
+Brand#52 SMALL BRUSHED TIN 14 4
+Brand#52 SMALL BRUSHED TIN 19 4
+Brand#52 SMALL BURNISHED NICKEL 14 4
+Brand#52 SMALL BURNISHED NICKEL 49 4
+Brand#52 SMALL BURNISHED TIN 9 4
+Brand#52 SMALL POLISHED BRASS 36 4
+Brand#52 SMALL POLISHED BRASS 49 4
+Brand#52 SMALL POLISHED TIN 45 4
+Brand#52 STANDARD ANODIZED BRASS 45 4
+Brand#52 STANDARD BRUSHED BRASS 23 4
+Brand#52 STANDARD BRUSHED COPPER 14 4
+Brand#52 STANDARD BRUSHED TIN 36 4
+Brand#52 STANDARD BURNISHED BRASS 49 4
+Brand#52 STANDARD BURNISHED STEEL 19 4
+Brand#52 STANDARD BURNISHED TIN 9 4
+Brand#52 STANDARD BURNISHED TIN 19 4
+Brand#52 STANDARD PLATED NICKEL 36 4
+Brand#52 STANDARD PLATED STEEL 36 4
+Brand#52 STANDARD POLISHED BRASS 36 4
+Brand#52 STANDARD POLISHED COPPER 45 4
+Brand#52 STANDARD POLISHED STEEL 19 4
+Brand#52 STANDARD POLISHED TIN 19 4
+Brand#53 ECONOMY ANODIZED BRASS 45 4
+Brand#53 ECONOMY ANODIZED COPPER 9 4
+Brand#53 ECONOMY ANODIZED NICKEL 3 4
+Brand#53 ECONOMY ANODIZED NICKEL 19 4
+Brand#53 ECONOMY ANODIZED STEEL 45 4
+Brand#53 ECONOMY ANODIZED TIN 14 4
+Brand#53 ECONOMY ANODIZED TIN 36 4
+Brand#53 ECONOMY BRUSHED TIN 45 4
+Brand#53 ECONOMY BURNISHED BRASS 14 4
+Brand#53 ECONOMY BURNISHED COPPER 45 4
+Brand#53 ECONOMY BURNISHED NICKEL 3 4
+Brand#53 ECONOMY BURNISHED NICKEL 49 4
+Brand#53 ECONOMY BURNISHED TIN 45 4
+Brand#53 ECONOMY PLATED BRASS 3 4
+Brand#53 ECONOMY PLATED NICKEL 14 4
+Brand#53 ECONOMY PLATED STEEL 23 4
+Brand#53 ECONOMY PLATED STEEL 36 4
+Brand#53 ECONOMY POLISHED TIN 36 4
+Brand#53 LARGE ANODIZED NICKEL 49 4
+Brand#53 LARGE ANODIZED STEEL 19 4
+Brand#53 LARGE BRUSHED COPPER 3 4
+Brand#53 LARGE BRUSHED COPPER 14 4
+Brand#53 LARGE BRUSHED NICKEL 23 4
+Brand#53 LARGE BRUSHED NICKEL 36 4
+Brand#53 LARGE BRUSHED TIN 36 4
+Brand#53 LARGE BURNISHED BRASS 45 4
+Brand#53 LARGE BURNISHED COPPER 19 4
+Brand#53 LARGE BURNISHED COPPER 36 4
+Brand#53 LARGE BURNISHED NICKEL 23 4
+Brand#53 LARGE BURNISHED STEEL 19 4
+Brand#53 LARGE BURNISHED STEEL 23 4
+Brand#53 LARGE PLATED BRASS 9 4
+Brand#53 LARGE PLATED BRASS 45 4
+Brand#53 LARGE PLATED BRASS 49 4
+Brand#53 LARGE PLATED COPPER 23 4
+Brand#53 LARGE PLATED NICKEL 23 4
+Brand#53 LARGE PLATED NICKEL 49 4
+Brand#53 LARGE PLATED STEEL 49 4
+Brand#53 LARGE PLATED TIN 14 4
+Brand#53 LARGE POLISHED COPPER 49 4
+Brand#53 LARGE POLISHED STEEL 36 4
+Brand#53 LARGE POLISHED TIN 9 4
+Brand#53 MEDIUM ANODIZED BRASS 23 4
+Brand#53 MEDIUM ANODIZED STEEL 14 4
+Brand#53 MEDIUM ANODIZED STEEL 36 4
+Brand#53 MEDIUM ANODIZED TIN 3 4
+Brand#53 MEDIUM ANODIZED TIN 9 4
+Brand#53 MEDIUM BRUSHED BRASS 3 4
+Brand#53 MEDIUM BRUSHED COPPER 3 4
+Brand#53 MEDIUM BRUSHED NICKEL 14 4
+Brand#53 MEDIUM BRUSHED NICKEL 36 4
+Brand#53 MEDIUM BRUSHED NICKEL 49 4
+Brand#53 MEDIUM BRUSHED STEEL 45 4
+Brand#53 MEDIUM BURNISHED BRASS 3 4
+Brand#53 MEDIUM BURNISHED BRASS 36 4
+Brand#53 MEDIUM BURNISHED TIN 9 4
+Brand#53 MEDIUM BURNISHED TIN 14 4
+Brand#53 MEDIUM BURNISHED TIN 36 4
+Brand#53 MEDIUM PLATED BRASS 23 4
+Brand#53 MEDIUM PLATED COPPER 14 4
+Brand#53 MEDIUM PLATED NICKEL 45 4
+Brand#53 MEDIUM PLATED TIN 19 4
+Brand#53 MEDIUM PLATED TIN 45 4
+Brand#53 PROMO ANODIZED BRASS 36 4
+Brand#53 PROMO ANODIZED NICKEL 3 4
+Brand#53 PROMO ANODIZED NICKEL 19 4
+Brand#53 PROMO BRUSHED BRASS 45 4
+Brand#53 PROMO BRUSHED COPPER 3 4
+Brand#53 PROMO BRUSHED COPPER 23 4
+Brand#53 PROMO BRUSHED COPPER 45 4
+Brand#53 PROMO BURNISHED BRASS 23 4
+Brand#53 PROMO BURNISHED BRASS 36 4
+Brand#53 PROMO BURNISHED NICKEL 23 4
+Brand#53 PROMO BURNISHED STEEL 23 4
+Brand#53 PROMO BURNISHED STEEL 49 4
+Brand#53 PROMO PLATED TIN 19 4
+Brand#53 PROMO PLATED TIN 23 4
+Brand#53 PROMO PLATED TIN 36 4
+Brand#53 PROMO POLISHED STEEL 23 4
+Brand#53 PROMO POLISHED TIN 3 4
+Brand#53 SMALL ANODIZED COPPER 23 4
+Brand#53 SMALL ANODIZED COPPER 36 4
+Brand#53 SMALL ANODIZED COPPER 49 4
+Brand#53 SMALL ANODIZED NICKEL 36 4
+Brand#53 SMALL BRUSHED BRASS 36 4
+Brand#53 SMALL BRUSHED COPPER 3 4
+Brand#53 SMALL BRUSHED TIN 3 4
+Brand#53 SMALL BRUSHED TIN 36 4
+Brand#53 SMALL BURNISHED BRASS 9 4
+Brand#53 SMALL BURNISHED BRASS 49 4
+Brand#53 SMALL BURNISHED COPPER 19 4
+Brand#53 SMALL BURNISHED COPPER 45 4
+Brand#53 SMALL PLATED BRASS 9 4
+Brand#53 SMALL PLATED COPPER 3 4
+Brand#53 SMALL PLATED NICKEL 14 4
+Brand#53 SMALL POLISHED NICKEL 19 4
+Brand#53 SMALL POLISHED STEEL 36 4
+Brand#53 SMALL POLISHED TIN 23 4
+Brand#53 STANDARD ANODIZED BRASS 14 4
+Brand#53 STANDARD ANODIZED NICKEL 9 4
+Brand#53 STANDARD ANODIZED NICKEL 23 4
+Brand#53 STANDARD ANODIZED NICKEL 45 4
+Brand#53 STANDARD ANODIZED STEEL 45 4
+Brand#53 STANDARD BRUSHED COPPER 3 4
+Brand#53 STANDARD BRUSHED NICKEL 23 4
+Brand#53 STANDARD BRUSHED TIN 14 4
+Brand#53 STANDARD BURNISHED NICKEL 49 4
+Brand#53 STANDARD BURNISHED STEEL 9 4
+Brand#53 STANDARD PLATED BRASS 36 4
+Brand#53 STANDARD PLATED COPPER 45 4
+Brand#53 STANDARD PLATED NICKEL 36 4
+Brand#53 STANDARD PLATED STEEL 3 4
+Brand#53 STANDARD PLATED STEEL 49 4
+Brand#53 STANDARD PLATED TIN 23 4
+Brand#53 STANDARD POLISHED STEEL 3 4
+Brand#54 ECONOMY ANODIZED BRASS 9 4
+Brand#54 ECONOMY ANODIZED BRASS 45 4
+Brand#54 ECONOMY ANODIZED COPPER 9 4
+Brand#54 ECONOMY ANODIZED STEEL 19 4
+Brand#54 ECONOMY BRUSHED BRASS 45 4
+Brand#54 ECONOMY BRUSHED NICKEL 19 4
+Brand#54 ECONOMY BRUSHED STEEL 3 4
+Brand#54 ECONOMY BRUSHED TIN 19 4
+Brand#54 ECONOMY BURNISHED BRASS 45 4
+Brand#54 ECONOMY BURNISHED COPPER 14 4
+Brand#54 ECONOMY BURNISHED NICKEL 9 4
+Brand#54 ECONOMY BURNISHED NICKEL 36 4
+Brand#54 ECONOMY BURNISHED STEEL 36 4
+Brand#54 ECONOMY BURNISHED TIN 9 4
+Brand#54 ECONOMY BURNISHED TIN 14 4
+Brand#54 ECONOMY BURNISHED TIN 23 4
+Brand#54 ECONOMY PLATED TIN 23 4
+Brand#54 ECONOMY POLISHED BRASS 9 4
+Brand#54 ECONOMY POLISHED BRASS 19 4
+Brand#54 ECONOMY POLISHED COPPER 23 4
+Brand#54 ECONOMY POLISHED STEEL 23 4
+Brand#54 ECONOMY POLISHED TIN 3 4
+Brand#54 LARGE ANODIZED BRASS 14 4
+Brand#54 LARGE ANODIZED BRASS 49 4
+Brand#54 LARGE ANODIZED TIN 9 4
+Brand#54 LARGE BRUSHED BRASS 14 4
+Brand#54 LARGE BRUSHED STEEL 9 4
+Brand#54 LARGE BRUSHED STEEL 23 4
+Brand#54 LARGE BRUSHED TIN 14 4
+Brand#54 LARGE BURNISHED BRASS 49 4
+Brand#54 LARGE BURNISHED COPPER 19 4
+Brand#54 LARGE BURNISHED NICKEL 14 4
+Brand#54 LARGE BURNISHED TIN 14 4
+Brand#54 LARGE PLATED BRASS 19 4
+Brand#54 LARGE PLATED BRASS 23 4
+Brand#54 LARGE POLISHED BRASS 19 4
+Brand#54 LARGE POLISHED BRASS 23 4
+Brand#54 LARGE POLISHED NICKEL 3 4
+Brand#54 LARGE POLISHED NICKEL 14 4
+Brand#54 LARGE POLISHED STEEL 19 4
+Brand#54 LARGE POLISHED TIN 3 4
+Brand#54 LARGE POLISHED TIN 9 4
+Brand#54 LARGE POLISHED TIN 36 4
+Brand#54 MEDIUM ANODIZED NICKEL 9 4
+Brand#54 MEDIUM ANODIZED NICKEL 14 4
+Brand#54 MEDIUM ANODIZED NICKEL 36 4
+Brand#54 MEDIUM BRUSHED NICKEL 9 4
+Brand#54 MEDIUM BRUSHED NICKEL 19 4
+Brand#54 MEDIUM BURNISHED STEEL 3 4
+Brand#54 MEDIUM BURNISHED STEEL 19 4
+Brand#54 MEDIUM BURNISHED STEEL 23 4
+Brand#54 MEDIUM PLATED BRASS 3 4
+Brand#54 MEDIUM PLATED NICKEL 45 4
+Brand#54 PROMO ANODIZED NICKEL 45 4
+Brand#54 PROMO BRUSHED BRASS 3 4
+Brand#54 PROMO BRUSHED STEEL 23 4
+Brand#54 PROMO BRUSHED TIN 14 4
+Brand#54 PROMO BURNISHED COPPER 49 4
+Brand#54 PROMO BURNISHED TIN 9 4
+Brand#54 PROMO PLATED BRASS 14 4
+Brand#54 PROMO PLATED NICKEL 3 4
+Brand#54 PROMO PLATED STEEL 19 4
+Brand#54 PROMO PLATED TIN 23 4
+Brand#54 PROMO PLATED TIN 49 4
+Brand#54 PROMO POLISHED BRASS 3 4
+Brand#54 PROMO POLISHED NICKEL 9 4
+Brand#54 PROMO POLISHED TIN 49 4
+Brand#54 SMALL ANODIZED COPPER 49 4
+Brand#54 SMALL ANODIZED NICKEL 9 4
+Brand#54 SMALL ANODIZED NICKEL 36 4
+Brand#54 SMALL ANODIZED TIN 19 4
+Brand#54 SMALL BRUSHED BRASS 14 4
+Brand#54 SMALL BRUSHED BRASS 19 4
+Brand#54 SMALL BRUSHED BRASS 36 4
+Brand#54 SMALL BRUSHED COPPER 3 4
+Brand#54 SMALL BRUSHED COPPER 9 4
+Brand#54 SMALL BRUSHED COPPER 19 4
+Brand#54 SMALL BRUSHED TIN 9 4
+Brand#54 SMALL BRUSHED TIN 36 4
+Brand#54 SMALL BURNISHED COPPER 9 4
+Brand#54 SMALL BURNISHED COPPER 36 4
+Brand#54 SMALL BURNISHED STEEL 14 4
+Brand#54 SMALL BURNISHED STEEL 19 4
+Brand#54 SMALL BURNISHED TIN 9 4
+Brand#54 SMALL BURNISHED TIN 36 4
+Brand#54 SMALL PLATED BRASS 23 4
+Brand#54 SMALL PLATED COPPER 9 4
+Brand#54 SMALL PLATED COPPER 36 4
+Brand#54 SMALL PLATED COPPER 49 4
+Brand#54 SMALL PLATED NICKEL 9 4
+Brand#54 SMALL PLATED TIN 23 4
+Brand#54 SMALL PLATED TIN 36 4
+Brand#54 SMALL POLISHED BRASS 9 4
+Brand#54 SMALL POLISHED COPPER 9 4
+Brand#54 SMALL POLISHED TIN 9 4
+Brand#54 STANDARD ANODIZED BRASS 3 4
+Brand#54 STANDARD ANODIZED BRASS 9 4
+Brand#54 STANDARD ANODIZED COPPER 3 4
+Brand#54 STANDARD ANODIZED TIN 3 4
+Brand#54 STANDARD BRUSHED COPPER 3 4
+Brand#54 STANDARD BRUSHED NICKEL 45 4
+Brand#54 STANDARD BRUSHED TIN 36 4
+Brand#54 STANDARD BURNISHED BRASS 23 4
+Brand#54 STANDARD BURNISHED BRASS 49 4
+Brand#54 STANDARD BURNISHED COPPER 19 4
+Brand#54 STANDARD BURNISHED NICKEL 23 4
+Brand#54 STANDARD BURNISHED STEEL 45 4
+Brand#54 STANDARD PLATED BRASS 3 4
+Brand#54 STANDARD PLATED BRASS 45 4
+Brand#54 STANDARD PLATED BRASS 49 4
+Brand#54 STANDARD PLATED STEEL 3 4
+Brand#54 STANDARD POLISHED BRASS 36 4
+Brand#54 STANDARD POLISHED STEEL 3 4
+Brand#54 STANDARD POLISHED STEEL 14 4
+Brand#54 STANDARD POLISHED STEEL 45 4
+Brand#55 ECONOMY ANODIZED BRASS 3 4
+Brand#55 ECONOMY BRUSHED BRASS 19 4
+Brand#55 ECONOMY BRUSHED COPPER 9 4
+Brand#55 ECONOMY BRUSHED COPPER 23 4
+Brand#55 ECONOMY BRUSHED COPPER 45 4
+Brand#55 ECONOMY BRUSHED STEEL 23 4
+Brand#55 ECONOMY BURNISHED NICKEL 36 4
+Brand#55 ECONOMY BURNISHED NICKEL 45 4
+Brand#55 ECONOMY BURNISHED TIN 45 4
+Brand#55 ECONOMY PLATED NICKEL 19 4
+Brand#55 ECONOMY POLISHED NICKEL 9 4
+Brand#55 LARGE BRUSHED BRASS 23 4
+Brand#55 LARGE BRUSHED BRASS 45 4
+Brand#55 LARGE BRUSHED COPPER 49 4
+Brand#55 LARGE BRUSHED NICKEL 9 4
+Brand#55 LARGE BRUSHED NICKEL 14 4
+Brand#55 LARGE BURNISHED BRASS 3 4
+Brand#55 LARGE BURNISHED COPPER 14 4
+Brand#55 LARGE BURNISHED COPPER 36 4
+Brand#55 LARGE PLATED BRASS 45 4
+Brand#55 LARGE PLATED COPPER 19 4
+Brand#55 LARGE PLATED NICKEL 9 4
+Brand#55 LARGE PLATED STEEL 9 4
+Brand#55 LARGE PLATED TIN 9 4
+Brand#55 LARGE PLATED TIN 14 4
+Brand#55 LARGE PLATED TIN 23 4
+Brand#55 LARGE POLISHED NICKEL 3 4
+Brand#55 LARGE POLISHED STEEL 36 4
+Brand#55 LARGE POLISHED STEEL 45 4
+Brand#55 MEDIUM ANODIZED COPPER 9 4
+Brand#55 MEDIUM BRUSHED BRASS 3 4
+Brand#55 MEDIUM BRUSHED NICKEL 23 4
+Brand#55 MEDIUM BRUSHED TIN 45 4
+Brand#55 MEDIUM BURNISHED BRASS 23 4
+Brand#55 MEDIUM BURNISHED COPPER 36 4
+Brand#55 MEDIUM BURNISHED NICKEL 3 4
+Brand#55 MEDIUM BURNISHED STEEL 14 4
+Brand#55 MEDIUM BURNISHED STEEL 36 4
+Brand#55 MEDIUM PLATED NICKEL 23 4
+Brand#55 PROMO ANODIZED COPPER 14 4
+Brand#55 PROMO ANODIZED COPPER 49 4
+Brand#55 PROMO ANODIZED STEEL 36 4
+Brand#55 PROMO ANODIZED TIN 23 4
+Brand#55 PROMO BRUSHED NICKEL 36 4
+Brand#55 PROMO BRUSHED STEEL 3 4
+Brand#55 PROMO BRUSHED STEEL 36 4
+Brand#55 PROMO BRUSHED TIN 9 4
+Brand#55 PROMO BURNISHED COPPER 3 4
+Brand#55 PROMO BURNISHED STEEL 14 4
+Brand#55 PROMO BURNISHED TIN 23 4
+Brand#55 PROMO BURNISHED TIN 49 4
+Brand#55 PROMO PLATED COPPER 3 4
+Brand#55 PROMO PLATED NICKEL 3 4
+Brand#55 PROMO PLATED NICKEL 14 4
+Brand#55 PROMO PLATED NICKEL 23 4
+Brand#55 PROMO PLATED TIN 3 4
+Brand#55 PROMO POLISHED COPPER 3 4
+Brand#55 SMALL ANODIZED BRASS 19 4
+Brand#55 SMALL ANODIZED NICKEL 45 4
+Brand#55 SMALL BRUSHED COPPER 14 4
+Brand#55 SMALL BRUSHED COPPER 45 4
+Brand#55 SMALL BURNISHED BRASS 14 4
+Brand#55 SMALL BURNISHED TIN 3 4
+Brand#55 SMALL BURNISHED TIN 49 4
+Brand#55 SMALL PLATED BRASS 45 4
+Brand#55 SMALL PLATED COPPER 23 4
+Brand#55 SMALL PLATED COPPER 36 4
+Brand#55 SMALL PLATED COPPER 45 4
+Brand#55 SMALL PLATED COPPER 49 4
+Brand#55 SMALL PLATED NICKEL 9 4
+Brand#55 SMALL PLATED STEEL 9 4
+Brand#55 SMALL PLATED TIN 14 4
+Brand#55 SMALL PLATED TIN 36 4
+Brand#55 SMALL POLISHED NICKEL 45 4
+Brand#55 SMALL POLISHED STEEL 19 4
+Brand#55 SMALL POLISHED TIN 19 4
+Brand#55 STANDARD ANODIZED BRASS 36 4
+Brand#55 STANDARD ANODIZED BRASS 49 4
+Brand#55 STANDARD ANODIZED STEEL 19 4
+Brand#55 STANDARD ANODIZED TIN 36 4
+Brand#55 STANDARD ANODIZED TIN 49 4
+Brand#55 STANDARD BRUSHED BRASS 36 4
+Brand#55 STANDARD BRUSHED COPPER 3 4
+Brand#55 STANDARD BRUSHED COPPER 9 4
+Brand#55 STANDARD BRUSHED COPPER 23 4
+Brand#55 STANDARD BRUSHED STEEL 19 4
+Brand#55 STANDARD BRUSHED TIN 23 4
+Brand#55 STANDARD BRUSHED TIN 45 4
+Brand#55 STANDARD BURNISHED BRASS 19 4
+Brand#55 STANDARD BURNISHED NICKEL 3 4
+Brand#55 STANDARD BURNISHED NICKEL 36 4
+Brand#55 STANDARD BURNISHED STEEL 19 4
+Brand#55 STANDARD PLATED BRASS 23 4
+Brand#55 STANDARD PLATED NICKEL 9 4
+Brand#55 STANDARD PLATED TIN 36 4
+Brand#55 STANDARD POLISHED BRASS 3 4
+Brand#55 STANDARD POLISHED BRASS 49 4
+Brand#55 STANDARD POLISHED COPPER 19 4
+Brand#55 STANDARD POLISHED COPPER 36 4
+Brand#55 STANDARD POLISHED NICKEL 14 4
+Brand#55 STANDARD POLISHED STEEL 9 4
+Brand#55 STANDARD POLISHED STEEL 36 4
+Brand#12 LARGE BURNISHED NICKEL 14 3
+Brand#12 PROMO POLISHED TIN 3 3
+Brand#21 MEDIUM ANODIZED TIN 9 3
+Brand#22 PROMO BRUSHED BRASS 19 3
+Brand#22 PROMO BURNISHED COPPER 14 3
+Brand#43 STANDARD BRUSHED BRASS 23 3
+Brand#44 MEDIUM ANODIZED NICKEL 9 3
+Brand#53 MEDIUM BURNISHED BRASS 49 3
diff --git a/vortex-sqllogictest/slt/tpch/results/q17.slt.no b/vortex-sqllogictest/slt/tpch/results/q17.slt.no
new file mode 100644
index 00000000000..52839576290
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q17.slt.no
@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query R
+select
+        sum(l_extendedprice) / 7.0 as avg_yearly
+from
+    lineitem,
+    part
+where
+        p_partkey = l_partkey
+  and p_brand = 'Brand#23'
+  and p_container = 'MED BOX'
+  and l_quantity < (
+    select
+            0.2 * avg(l_quantity)
+    from
+        lineitem
+    where
+            l_partkey = p_partkey
+);
+----
+23512.752857142856
diff --git a/vortex-sqllogictest/slt/tpch/results/q18.slt.no b/vortex-sqllogictest/slt/tpch/results/q18.slt.no
new file mode 100644
index 00000000000..9fe4a4829f6
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q18.slt.no
@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TIIDRR
+select
+    c_name,
+    c_custkey,
+    o_orderkey,
+    o_orderdate,
+    o_totalprice,
+    sum(l_quantity)
+from
+    customer,
+    orders,
+    lineitem
+where
+        o_orderkey in (
+        select
+            l_orderkey
+        from
+            lineitem
+        group by
+            l_orderkey having
+                sum(l_quantity) > 300
+    )
+  and c_custkey = o_custkey
+  and o_orderkey = l_orderkey
+group by
+    c_name,
+    c_custkey,
+    o_orderkey,
+    o_orderdate,
+    o_totalprice
+order by
+    o_totalprice desc,
+    o_orderdate
+limit 100;
+----
+Customer#000001639 1639 502886 1994-04-12 456423.88 312
+Customer#000006655 6655 29158 1995-10-21 452805.02 305
+Customer#000014110 14110 565574 1995-09-24 425099.85 301
+Customer#000001775 1775 6882 1997-04-09 408368.1 303
+Customer#000011459 11459 551136 1993-05-19 386812.74 308
diff --git a/vortex-sqllogictest/slt/tpch/results/q19.slt.no b/vortex-sqllogictest/slt/tpch/results/q19.slt.no
new file mode 100644
index 00000000000..fa7c3eda3b5
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q19.slt.no
@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query R
+select
+    sum(l_extendedprice* (1 - l_discount)) as revenue
+from
+    lineitem,
+    part
+where
+    (
+                p_partkey = l_partkey
+            and p_brand = 'Brand#12'
+            and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG')
+            and l_quantity >= 1 and l_quantity <= 1 + 10
+            and p_size between 1 and 5
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        )
+   or
+    (
+                p_partkey = l_partkey
+            and p_brand = 'Brand#23'
+            and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK')
+            and l_quantity >= 10 and l_quantity <= 10 + 10
+            and p_size between 1 and 10
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        )
+   or
+    (
+                p_partkey = l_partkey
+            and p_brand = 'Brand#34'
+            and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG')
+            and l_quantity >= 20 and l_quantity <= 20 + 10
+            and p_size between 1 and 15
+            and l_shipmode in ('AIR', 'AIR REG')
+            and l_shipinstruct = 'DELIVER IN PERSON'
+        );
+----
+168597.286
diff --git a/vortex-sqllogictest/slt/tpch/results/q2.slt.no b/vortex-sqllogictest/slt/tpch/results/q2.slt.no
new file mode 100644
index 00000000000..85585a6e91e
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q2.slt.no
@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query RTTITTTT
+select
+    s_acctbal,
+    s_name,
+    n_name,
+    p_partkey,
+    p_mfgr,
+    s_address,
+    s_phone,
+    s_comment
+from
+    part,
+    supplier,
+    partsupp,
+    nation,
+    region
+where
+        p_partkey = ps_partkey
+  and s_suppkey = ps_suppkey
+  and p_size = 15
+  and p_type like '%BRASS'
+  and s_nationkey = n_nationkey
+  and n_regionkey = r_regionkey
+  and r_name = 'EUROPE'
+  and ps_supplycost = (
+    select
+        min(ps_supplycost)
+    from
+        partsupp,
+        supplier,
+        nation,
+        region
+    where
+            p_partkey = ps_partkey
+      and s_suppkey = ps_suppkey
+      and s_nationkey = n_nationkey
+      and n_regionkey = r_regionkey
+      and r_name = 'EUROPE'
+)
+order by
+    s_acctbal desc,
+    n_name,
+    s_name,
+    p_partkey
+limit 100;
+----
+9828.21 Supplier#000000647 UNITED KINGDOM 13120 Manufacturer#5 x5U7MBZmwfG9 33-258-202-4782 s the slyly even ideas poach fluffily 
+9508.37 Supplier#000000070 FRANCE 3563 Manufacturer#1 INWNH2w,OOWgNDq0BRCcBwOMQc6PdFDc4 16-821-608-1166 ests sleep quickly express ideas. ironic ideas haggle about the final T
+9508.37 Supplier#000000070 FRANCE 17268 Manufacturer#4 INWNH2w,OOWgNDq0BRCcBwOMQc6PdFDc4 16-821-608-1166 ests sleep quickly express ideas. ironic ideas haggle about the final T
+9453.01 Supplier#000000802 ROMANIA 10021 Manufacturer#5 ,6HYXb4uaHITmtMBj4Ak57Pd 29-342-882-6463 gular frets. permanently special multipliers believe blithely alongs
+9453.01 Supplier#000000802 ROMANIA 13275 Manufacturer#4 ,6HYXb4uaHITmtMBj4Ak57Pd 29-342-882-6463 gular frets. permanently special multipliers believe blithely alongs
+9192.1 Supplier#000000115 UNITED KINGDOM 13325 Manufacturer#1 nJ 2t0f7Ve,wL1,6WzGBJLNBUCKlsV 33-597-248-1220 es across the carefully express accounts boost caref
+9032.15 Supplier#000000959 GERMANY 4958 Manufacturer#4 8grA EHBnwOZhO 17-108-642-3106 nding dependencies nag furiou
+8702.02 Supplier#000000333 RUSSIA 11810 Manufacturer#3 MaVf XgwPdkiX4nfJGOis8Uu2zKiIZH 32-508-202-6136 oss the deposits cajole carefully even pinto beans. regular foxes detect alo
+8615.5 Supplier#000000812 FRANCE 10551 Manufacturer#2 8qh4tezyScl5bidLAysvutB,,ZI2dn6xP 16-585-724-6633 y quickly regular deposits? quickly pending packages after the caref
+8615.5 Supplier#000000812 FRANCE 13811 Manufacturer#4 8qh4tezyScl5bidLAysvutB,,ZI2dn6xP 16-585-724-6633 y quickly regular deposits? quickly pending packages after the caref
+8488.53 Supplier#000000367 RUSSIA 6854 Manufacturer#4 E Sv9brQVf43Mzz 32-458-198-9557 ages. carefully final excuses nag finally. carefully ironic deposits abov
+8430.52 Supplier#000000646 FRANCE 11384 Manufacturer#3 IUzsmT,2oBgjhWP2TlXTL6IkJH,4h,1SJRt 16-601-220-5489 ites among the always final ideas kindle according to the theodolites. notornis in
+8271.39 Supplier#000000146 RUSSIA 4637 Manufacturer#5 rBDNgCr04x0sfdzD5,gFOutCiG2 32-792-619-3155 s cajole quickly special requests. quickly enticing theodolites h
+8096.98 Supplier#000000574 RUSSIA 323 Manufacturer#4 2O8 sy9g2mlBOuEjzj0pA2pevk, 32-866-246-8752 ully after the regular requests. slyly final dependencies wake slyly along the busy deposit
+7392.78 Supplier#000000170 UNITED KINGDOM 7655 Manufacturer#2 RtsXQ,SunkA XHy9 33-803-340-5398 ake carefully across the quickly
+7205.2 Supplier#000000477 GERMANY 10956 Manufacturer#5 VtaNKN5Mqui5yh7j2ldd5waf 17-180-144-7991  excuses wake express deposits. furiously careful asymptotes according to the carefull
+6820.35 Supplier#000000007 UNITED KINGDOM 13217 Manufacturer#5 s,4TicNGB4uO6PaSqNBUq 33-990-965-2201 s unwind silently furiously regular courts. final requests are deposits. requests wake quietly blit
+6721.7 Supplier#000000954 FRANCE 4191 Manufacturer#3 P3O5p UFz1QsLmZX 16-537-341-8517 ect blithely blithely final acco
+6329.9 Supplier#000000996 GERMANY 10735 Manufacturer#2 Wx4dQwOAwWjfSCGupfrM 17-447-811-3282  ironic forges cajole blithely agai
+6173.87 Supplier#000000408 RUSSIA 18139 Manufacturer#1 qcor1u,vJXAokjnL5,dilyYNmh 32-858-724-2950 blithely pending packages cajole furiously slyly pending notornis. slyly final 
+5364.99 Supplier#000000785 RUSSIA 13784 Manufacturer#4 W VkHBpQyD3qjQjWGpWicOpmILFehmEdWy67kUGY 32-297-653-2203  packages boost carefully. express ideas along
+5069.27 Supplier#000000328 GERMANY 16327 Manufacturer#1 SMm24d WG62 17-231-513-5721 he unusual ideas. slyly final packages a
+4941.88 Supplier#000000321 ROMANIA 7320 Manufacturer#5 pLngFl5yeMcHyov 29-573-279-1406 y final requests impress s
+4672.25 Supplier#000000239 RUSSIA 12238 Manufacturer#1 XO101kgHrJagK2FL1U6QCaTE ncCsMbeuTgK6o8 32-396-654-6826 arls wake furiously deposits. even, regular depen
+4586.49 Supplier#000000680 RUSSIA 5679 Manufacturer#3 UhvDfdEfJh,Qbe7VZb8uSGO2TU 0jEa6nXZXE 32-522-382-1620  the regularly regular dependencies. carefully bold excuses under th
+4518.31 Supplier#000000149 FRANCE 18344 Manufacturer#5 pVyWsjOidpHKp4NfKU4yLeym 16-660-553-2456 ts detect along the foxes. final Tiresias are. idly pending deposits haggle; even, blithe pin
+4315.15 Supplier#000000509 FRANCE 18972 Manufacturer#2 SF7dR8V5pK 16-298-154-3365 ronic orbits are furiously across the requests. quickly express ideas across the special, bold
+3526.53 Supplier#000000553 FRANCE 8036 Manufacturer#4 a,liVofXbCJ 16-599-552-3755 lar dinos nag slyly brave
+3526.53 Supplier#000000553 FRANCE 17018 Manufacturer#3 a,liVofXbCJ 16-599-552-3755 lar dinos nag slyly brave
+3294.68 Supplier#000000350 GERMANY 4841 Manufacturer#4 KIFxV73eovmwhh 17-113-181-4017 e slyly special foxes. furiously unusual deposits detect carefully carefully ruthless foxes. quick
+2972.26 Supplier#000000016 RUSSIA 1015 Manufacturer#4 YjP5C55zHDXL7LalK27zfQnwejdpin4AMpvh 32-822-502-4215 ously express ideas haggle quickly dugouts? fu
+2963.09 Supplier#000000840 ROMANIA 3080 Manufacturer#2 iYzUIypKhC0Y 29-781-337-5584 eep blithely regular dependencies. blithely regular platelets sublate alongside o
+2221.25 Supplier#000000771 ROMANIA 13981 Manufacturer#2 lwZ I15rq9kmZXUNhl 29-986-304-9006 nal foxes eat slyly about the fluffily permanent id
+1381.97 Supplier#000000104 FRANCE 18103 Manufacturer#3 Dcl4yGrzqv3OPeRO49bKh78XmQEDR7PBXIs0m 16-434-972-6922 gular ideas. bravely bold deposits haggle through the carefully final deposits. slyly unusual idea
+906.07 Supplier#000000138 ROMANIA 8363 Manufacturer#4 utbplAm g7RmxVfYoNdhcrQGWuzRqPe0qHSwbKw 29-533-434-6776 ickly unusual requests cajole. accounts above the furiously special excuses 
+765.69 Supplier#000000799 RUSSIA 11276 Manufacturer#2 jwFN7ZB3T9sMF 32-579-339-1495 nusual requests. furiously unusual epitaphs integrate. slyly 
+727.89 Supplier#000000470 ROMANIA 6213 Manufacturer#3 XckbzsAgBLbUkdfjgJEPjmUMTM8ebSMEvI 29-165-289-1523 gular excuses. furiously regular excuses sleep slyly caref
+683.07 Supplier#000000651 RUSSIA 4888 Manufacturer#4 oWekiBV6s,1g 32-181-426-4490 ly regular requests cajole abou
+167.56 Supplier#000000290 FRANCE 2037 Manufacturer#1 6Bk06GVtwZaKqg01 16-675-286-5102  the theodolites. ironic, ironic deposits above 
+91.39 Supplier#000000949 UNITED KINGDOM 9430 Manufacturer#2 a,UE,6nRVl2fCphkOoetR1ajIzAEJ1Aa1G1HV 33-332-697-2768 pinto beans. carefully express requests hagg
+-314.06 Supplier#000000510 ROMANIA 17242 Manufacturer#4 VmXQl ,vY8JiEseo8Mv4zscvNCfsY 29-207-852-3454  bold deposits. carefully even d
+-820.89 Supplier#000000409 GERMANY 2156 Manufacturer#5 LyXUYFz7aXrvy65kKAbTatGzGS,NDBcdtD 17-719-517-9836 y final, slow theodolites. furiously regular req
+-845.44 Supplier#000000704 ROMANIA 9926 Manufacturer#5 hQvlBqbqqnA5Dgo1BffRBX78tkkRu 29-300-896-5991 ctions. carefully sly requ
+-942.73 Supplier#000000563 GERMANY 5797 Manufacturer#1 Rc7U1cRUhYs03JD 17-108-537-2691 slyly furiously final decoys; silent, special realms poach f
diff --git a/vortex-sqllogictest/slt/tpch/results/q20.slt.no b/vortex-sqllogictest/slt/tpch/results/q20.slt.no
new file mode 100644
index 00000000000..2d7298eb082
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q20.slt.no
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TT
+select
+    s_name,
+    s_address
+from
+    supplier,
+    nation
+where
+        s_suppkey in (
+        select
+            ps_suppkey
+        from
+            partsupp
+        where
+                ps_partkey in (
+                select
+                    p_partkey
+                from
+                    part
+                where
+                        p_name like 'forest%'
+            )
+          and ps_availqty > (
+            select
+                    0.5 * sum(l_quantity)
+            from
+                lineitem
+            where
+                    l_partkey = ps_partkey
+              and l_suppkey = ps_suppkey
+              and l_shipdate >= date '1994-01-01'
+              and l_shipdate < date '1994-01-01' + interval '1' year
+        )
+    )
+  and s_nationkey = n_nationkey
+  and n_name = 'CANADA'
+order by
+    s_name;
+----
+Supplier#000000157 ,mEGorBfVIm
+Supplier#000000197 YC2Acon6kjY3zj3Fbxs2k4Vdf7X0cd2F
+Supplier#000000287 7a9SP7qW5Yku5PvSg
+Supplier#000000378 FfbhyCxWvcPrO8ltp9
+Supplier#000000530 0qwCMwobKY OcmLyfRXlagA8ukENJv,
+Supplier#000000555 TfB,a5bfl3Ah 3Z 74GqnNs6zKVGM
+Supplier#000000557 jj0wUYh9K3fG5Jhdhrkuy ,4
+Supplier#000000729 pqck2ppy758TQpZCUAjPvlU55K3QjfL7Bi
+Supplier#000000935 ij98czM 2KzWe7dDTOxB8sq0UfCdvrX
diff --git a/vortex-sqllogictest/slt/tpch/results/q21.slt.no b/vortex-sqllogictest/slt/tpch/results/q21.slt.no
new file mode 100644
index 00000000000..c6b01df174e
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q21.slt.no
@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TI
+select
+    s_name,
+    count(*) as numwait
+from
+    supplier,
+    lineitem l1,
+    orders,
+    nation
+where
+        s_suppkey = l1.l_suppkey
+  and o_orderkey = l1.l_orderkey
+  and o_orderstatus = 'F'
+  and l1.l_receiptdate > l1.l_commitdate
+  and exists (
+        select
+            *
+        from
+            lineitem l2
+        where
+                l2.l_orderkey = l1.l_orderkey
+          and l2.l_suppkey <> l1.l_suppkey
+    )
+  and not exists (
+        select
+            *
+        from
+            lineitem l3
+        where
+                l3.l_orderkey = l1.l_orderkey
+          and l3.l_suppkey <> l1.l_suppkey
+          and l3.l_receiptdate > l3.l_commitdate
+    )
+  and s_nationkey = n_nationkey
+  and n_name = 'SAUDI ARABIA'
+group by
+    s_name
+order by
+    numwait desc,
+    s_name
+limit 100;
+----
+Supplier#000000445 16
+Supplier#000000825 16
+Supplier#000000709 15
+Supplier#000000762 15
+Supplier#000000357 14
+Supplier#000000399 14
+Supplier#000000496 14
+Supplier#000000977 13
+Supplier#000000144 12
+Supplier#000000188 12
+Supplier#000000415 12
+Supplier#000000472 12
+Supplier#000000633 12
+Supplier#000000708 12
+Supplier#000000889 12
+Supplier#000000380 11
+Supplier#000000602 11
+Supplier#000000659 11
+Supplier#000000821 11
+Supplier#000000929 11
+Supplier#000000262 10
+Supplier#000000460 10
+Supplier#000000486 10
+Supplier#000000669 10
+Supplier#000000718 10
+Supplier#000000778 10
+Supplier#000000167 9
+Supplier#000000578 9
+Supplier#000000673 9
+Supplier#000000687 9
+Supplier#000000074 8
+Supplier#000000565 8
+Supplier#000000648 8
+Supplier#000000918 8
+Supplier#000000427 7
+Supplier#000000503 7
+Supplier#000000610 7
+Supplier#000000670 7
+Supplier#000000811 7
+Supplier#000000114 6
+Supplier#000000379 6
+Supplier#000000436 6
+Supplier#000000500 6
+Supplier#000000660 6
+Supplier#000000788 6
+Supplier#000000846 6
+Supplier#000000920 4
diff --git a/vortex-sqllogictest/slt/tpch/results/q22.slt.no b/vortex-sqllogictest/slt/tpch/results/q22.slt.no
new file mode 100644
index 00000000000..ed9bce64583
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q22.slt.no
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TIR
+select
+    cntrycode,
+    count(*) as numcust,
+    sum(c_acctbal) as totacctbal
+from
+    (
+        select
+            substring(c_phone from 1 for 2) as cntrycode,
+            c_acctbal
+        from
+            customer
+        where
+                substring(c_phone from 1 for 2) in
+                ('13', '31', '23', '29', '30', '18', '17')
+          and c_acctbal > (
+            select
+                avg(c_acctbal)
+            from
+                customer
+            where
+                    c_acctbal > 0.00
+              and substring(c_phone from 1 for 2) in
+                  ('13', '31', '23', '29', '30', '18', '17')
+        )
+          and not exists (
+                select
+                    *
+                from
+                    orders
+                where
+                        o_custkey = c_custkey
+            )
+    ) as custsale
+group by
+    cntrycode
+order by
+    cntrycode;
+----
+13 94 714035.05
+17 96 722560.15
+18 99 738012.52
+23 93 708285.25
+29 85 632693.46
+30 87 646748.02
+31 87 647372.5
diff --git a/vortex-sqllogictest/slt/tpch/results/q3.slt.no b/vortex-sqllogictest/slt/tpch/results/q3.slt.no
new file mode 100644
index 00000000000..53ef230c504
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q3.slt.no
@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query IRDI
+select
+    l_orderkey,
+    sum(l_extendedprice * (1 - l_discount)) as revenue,
+    o_orderdate,
+    o_shippriority
+from
+    customer,
+    orders,
+    lineitem
+where
+        c_mktsegment = 'BUILDING'
+  and c_custkey = o_custkey
+  and l_orderkey = o_orderkey
+  and o_orderdate < date '1995-03-15'
+  and l_shipdate > date '1995-03-15'
+group by
+    l_orderkey,
+    o_orderdate,
+    o_shippriority
+order by
+    revenue desc,
+    o_orderdate
+limit 10;
+----
+223140 355369.0698 1995-03-14 0
+584291 354494.7318 1995-02-21 0
+405063 353125.4577 1995-03-03 0
+573861 351238.277 1995-03-09 0
+554757 349181.7426 1995-03-14 0
+506021 321075.581 1995-03-10 0
+121604 318576.4154 1995-03-07 0
+108514 314967.0754 1995-02-20 0
+462502 312604.542 1995-03-08 0
+178727 309728.9306 1995-02-25 0
+
diff --git a/vortex-sqllogictest/slt/tpch/results/q4.slt.no b/vortex-sqllogictest/slt/tpch/results/q4.slt.no
new file mode 100644
index 00000000000..f1b81615e31
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q4.slt.no
@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TI
+select
+    o_orderpriority,
+    count(*) as order_count
+from
+    orders
+where
+        o_orderdate >= date '1993-07-01'
+  and o_orderdate < date '1993-07-01' + interval '3' month
+  and exists (
+        select
+            *
+        from
+            lineitem
+        where
+                l_orderkey = o_orderkey
+          and l_commitdate < l_receiptdate
+    )
+group by
+    o_orderpriority
+order by
+    o_orderpriority;
+----
+1-URGENT 999
+2-HIGH 997
+3-MEDIUM 1031
+4-NOT SPECIFIED 989
+5-LOW 1077
diff --git a/vortex-sqllogictest/slt/tpch/results/q5.slt.no b/vortex-sqllogictest/slt/tpch/results/q5.slt.no
new file mode 100644
index 00000000000..da099db90e3
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q5.slt.no
@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TR
+select
+    n_name,
+    sum(l_extendedprice * (1 - l_discount)) as revenue
+from
+    customer,
+    orders,
+    lineitem,
+    supplier,
+    nation,
+    region
+where
+        c_custkey = o_custkey
+  and l_orderkey = o_orderkey
+  and l_suppkey = s_suppkey
+  and c_nationkey = s_nationkey
+  and s_nationkey = n_nationkey
+  and n_regionkey = r_regionkey
+  and r_name = 'ASIA'
+  and o_orderdate >= date '1994-01-01'
+  and o_orderdate < date '1995-01-01'
+group by
+    n_name
+order by
+    revenue desc;
+----
+CHINA 7822103
+INDIA 6376121.5085
+JAPAN 6000077.2184
+INDONESIA 5580475.4027
+VIETNAM 4497840.5466
diff --git a/vortex-sqllogictest/slt/tpch/results/q6.slt.no b/vortex-sqllogictest/slt/tpch/results/q6.slt.no
new file mode 100644
index 00000000000..ebb56ec0591
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q6.slt.no
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query R
+select
+    sum(l_extendedprice * l_discount) as revenue
+from
+    lineitem
+where
+        l_shipdate >= date '1994-01-01'
+  and l_shipdate < date '1995-01-01'
+  and l_discount between 0.06 - 0.01 and 0.06 + 0.01
+  and l_quantity < 24;
+----
+11803420.2534
diff --git a/vortex-sqllogictest/slt/tpch/results/q7.slt.no b/vortex-sqllogictest/slt/tpch/results/q7.slt.no
new file mode 100644
index 00000000000..0d6db607f39
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q7.slt.no
@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TTIR
+select
+    supp_nation,
+    cust_nation,
+    l_year,
+    sum(volume) as revenue
+from
+    (
+        select
+            n1.n_name as supp_nation,
+            n2.n_name as cust_nation,
+            extract(year from l_shipdate) as l_year,
+            l_extendedprice * (1 - l_discount) as volume
+        from
+            supplier,
+            lineitem,
+            orders,
+            customer,
+            nation n1,
+            nation n2
+        where
+                s_suppkey = l_suppkey
+          and o_orderkey = l_orderkey
+          and c_custkey = o_custkey
+          and s_nationkey = n1.n_nationkey
+          and c_nationkey = n2.n_nationkey
+          and (
+                (n1.n_name = 'FRANCE' and n2.n_name = 'GERMANY')
+                or (n1.n_name = 'GERMANY' and n2.n_name = 'FRANCE')
+            )
+          and l_shipdate between date '1995-01-01' and date '1996-12-31'
+    ) as shipping
+group by
+    supp_nation,
+    cust_nation,
+    l_year
+order by
+    supp_nation,
+    cust_nation,
+    l_year;
+----
+FRANCE GERMANY 1995 4637235.1501
+FRANCE GERMANY 1996 5224779.5736
+GERMANY FRANCE 1995 6232818.7037
+GERMANY FRANCE 1996 5557312.1121
diff --git a/vortex-sqllogictest/slt/tpch/results/q8.slt.no b/vortex-sqllogictest/slt/tpch/results/q8.slt.no
new file mode 100644
index 00000000000..fd354dcbbe6
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q8.slt.no
@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query IR
+select
+    o_year,
+    sum(case
+            when nation = 'BRAZIL' then volume
+            else 0
+        end) / sum(volume) as mkt_share
+from
+    (
+        select
+            extract(year from o_orderdate) as o_year,
+            l_extendedprice * (1 - l_discount) as volume,
+            n2.n_name as nation
+        from
+            part,
+            supplier,
+            lineitem,
+            orders,
+            customer,
+            nation n1,
+            nation n2,
+            region
+        where
+                p_partkey = l_partkey
+          and s_suppkey = l_suppkey
+          and l_orderkey = o_orderkey
+          and o_custkey = c_custkey
+          and c_nationkey = n1.n_nationkey
+          and n1.n_regionkey = r_regionkey
+          and r_name = 'AMERICA'
+          and s_nationkey = n2.n_nationkey
+          and o_orderdate between date '1995-01-01' and date '1996-12-31'
+          and p_type = 'ECONOMY ANODIZED STEEL'
+    ) as all_nations
+group by
+    o_year
+order by
+    o_year;
+----
+1995 0.02864874
+1996 0.01825027
diff --git a/vortex-sqllogictest/slt/tpch/results/q9.slt.no b/vortex-sqllogictest/slt/tpch/results/q9.slt.no
new file mode 100644
index 00000000000..d20e85c4473
--- /dev/null
+++ b/vortex-sqllogictest/slt/tpch/results/q9.slt.no
@@ -0,0 +1,212 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+query TIR
+select
+    nation,
+    o_year,
+    sum(amount) as sum_profit
+from
+    (
+        select
+            n_name as nation,
+            extract(year from o_orderdate) as o_year,
+            l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity as amount
+        from
+            part,
+            supplier,
+            lineitem,
+            partsupp,
+            orders,
+            nation
+        where
+                s_suppkey = l_suppkey
+          and ps_suppkey = l_suppkey
+          and ps_partkey = l_partkey
+          and p_partkey = l_partkey
+          and o_orderkey = l_orderkey
+          and s_nationkey = n_nationkey
+          and p_name like '%green%'
+    ) as profit
+group by
+    nation,
+    o_year
+order by
+    nation,
+    o_year desc;
+----
+ALGERIA 1998 2321785.3682
+ALGERIA 1997 3685016.8589
+ALGERIA 1996 4276597.4253
+ALGERIA 1995 4418370.4154
+ALGERIA 1994 3864849.9521
+ALGERIA 1993 3541051.3865
+ALGERIA 1992 4310013.3482
+ARGENTINA 1998 2685983.8005
+ARGENTINA 1997 4242147.8124
+ARGENTINA 1996 3907867.0103
+ARGENTINA 1995 4605921.5011
+ARGENTINA 1994 3542096.1564
+ARGENTINA 1993 3949965.9388
+ARGENTINA 1992 4521180.4695
+BRAZIL 1998 2778730.3931
+BRAZIL 1997 4642037.4687
+BRAZIL 1996 4530304.6034
+BRAZIL 1995 4502344.8657
+BRAZIL 1994 4875806.5015
+BRAZIL 1993 4687478.6531
+BRAZIL 1992 5035200.0464
+CANADA 1998 2194509.0465
+CANADA 1997 3482197.9521
+CANADA 1996 3712231.2814
+CANADA 1995 4014814.8476
+CANADA 1994 4145304.4855
+CANADA 1993 3787069.6045
+CANADA 1992 4168009.4201
+CHINA 1998 3398578.0001
+CHINA 1997 6358959.3338
+CHINA 1996 6435158.3229
+CHINA 1995 6174776.2113
+CHINA 1994 6385751.0812
+CHINA 1993 5765034.1194
+CHINA 1992 6324034.2379
+EGYPT 1998 2333148.3334
+EGYPT 1997 3661244.2731
+EGYPT 1996 3765371.2368
+EGYPT 1995 4094744.2925
+EGYPT 1994 3566508.0818
+EGYPT 1993 3725283.7747
+EGYPT 1992 3373762.3335
+ETHIOPIA 1998 1953927.2682
+ETHIOPIA 1997 3285786.3266
+ETHIOPIA 1996 3525028.7952
+ETHIOPIA 1995 3781674.8911
+ETHIOPIA 1994 3037409.436
+ETHIOPIA 1993 3008978.2677
+ETHIOPIA 1992 2721203.2355
+FRANCE 1998 2604373.8805
+FRANCE 1997 3982872.0488
+FRANCE 1996 3622479.2413
+FRANCE 1995 4479939.702
+FRANCE 1994 3531013.1981
+FRANCE 1993 4086437.3102
+FRANCE 1992 3637792.1333
+GERMANY 1998 3291023.2965
+GERMANY 1997 5139337.3443
+GERMANY 1996 4799810.4577
+GERMANY 1995 5405785.7978
+GERMANY 1994 4555556.4592
+GERMANY 1993 4428195.1019
+GERMANY 1992 4656148.4204
+INDIA 1998 2591288.1874
+INDIA 1997 5159562.7033
+INDIA 1996 5307258.3049
+INDIA 1995 5148208.7902
+INDIA 1994 5164001.9582
+INDIA 1993 4321398.4388
+INDIA 1992 5297703.6935
+INDONESIA 1998 3094900.1597
+INDONESIA 1997 5719773.0358
+INDONESIA 1996 6037238.5993
+INDONESIA 1995 5266783.4899
+INDONESIA 1994 5470762.8729
+INDONESIA 1993 6189826.6613
+INDONESIA 1992 4414623.1549
+IRAN 1998 3214864.1209
+IRAN 1997 3688049.0691
+IRAN 1996 3621649.2247
+IRAN 1995 4420783.4205
+IRAN 1994 4373984.6523
+IRAN 1993 3731301.7814
+IRAN 1992 4417133.3662
+IRAQ 1998 2338859.4099
+IRAQ 1997 3622681.5643
+IRAQ 1996 4762291.8722
+IRAQ 1995 4558092.7359
+IRAQ 1994 4951604.1699
+IRAQ 1993 3830077.9911
+IRAQ 1992 3938636.4874
+JAPAN 1998 1849535.0802
+JAPAN 1997 4068688.8537
+JAPAN 1996 4044774.7597
+JAPAN 1995 4793005.8027
+JAPAN 1994 4114717.0568
+JAPAN 1993 3614468.7485
+JAPAN 1992 4266694.47
+JORDAN 1998 1811488.0719
+JORDAN 1997 2951297.8678
+JORDAN 1996 3302528.3067
+JORDAN 1995 3221813.999
+JORDAN 1994 2417892.0921
+JORDAN 1993 3107641.7661
+JORDAN 1992 3316379.0585
+KENYA 1998 2579075.419
+KENYA 1997 2929194.2317
+KENYA 1996 3569129.5619
+KENYA 1995 3542889.1087
+KENYA 1994 3983095.3994
+KENYA 1993 3713988.9708
+KENYA 1992 3304641.834
+MOROCCO 1998 1815334.818
+MOROCCO 1997 3693214.8447
+MOROCCO 1996 4116175.923
+MOROCCO 1995 3515127.1402
+MOROCCO 1994 4003072.112
+MOROCCO 1993 3599199.6679
+MOROCCO 1992 3958335.4224
+MOZAMBIQUE 1998 1620428.7346
+MOZAMBIQUE 1997 2802166.6473
+MOZAMBIQUE 1996 2409955.1755
+MOZAMBIQUE 1995 2771602.6274
+MOZAMBIQUE 1994 2548226.2158
+MOZAMBIQUE 1993 2843748.9053
+MOZAMBIQUE 1992 2556501.0943
+PERU 1998 2036430.3602
+PERU 1997 4064142.4091
+PERU 1996 4068678.5671
+PERU 1995 4657694.8412
+PERU 1994 4731959.4655
+PERU 1993 4144006.661
+PERU 1992 3754635.0078
+ROMANIA 1998 1992773.6811
+ROMANIA 1997 2854639.868
+ROMANIA 1996 3139337.3029
+ROMANIA 1995 3222153.3776
+ROMANIA 1994 3222844.319
+ROMANIA 1993 3488994.0288
+ROMANIA 1992 3029274.442
+RUSSIA 1998 2339865.6635
+RUSSIA 1997 4153619.5424
+RUSSIA 1996 3772067.4041
+RUSSIA 1995 4704988.8607
+RUSSIA 1994 4479082.8694
+RUSSIA 1993 4767719.9791
+RUSSIA 1992 4533465.559
+SAUDI ARABIA 1998 3386948.9564
+SAUDI ARABIA 1997 5425980.3373
+SAUDI ARABIA 1996 5227607.1677
+SAUDI ARABIA 1995 4506731.6411
+SAUDI ARABIA 1994 4698658.7425
+SAUDI ARABIA 1993 5493626.5285
+SAUDI ARABIA 1992 4573560.015
+UNITED KINGDOM 1998 2252021.5137
+UNITED KINGDOM 1997 4343926.8026
+UNITED KINGDOM 1996 4189476.3065
+UNITED KINGDOM 1995 4469569.8829
+UNITED KINGDOM 1994 4410094.6264
+UNITED KINGDOM 1993 4054677.105
+UNITED KINGDOM 1992 3978688.8831
+UNITED STATES 1998 2238771.5581
+UNITED STATES 1997 4135581.5734
+UNITED STATES 1996 3624013.266
+UNITED STATES 1995 3892244.5172
+UNITED STATES 1994 3289224.1138
+UNITED STATES 1993 3626170.2028
+UNITED STATES 1992 3993973.4997
+VIETNAM 1998 1924313.4862
+VIETNAM 1997 3436195.3709
+VIETNAM 1996 4017288.8927
+VIETNAM 1995 3644054.1372
+VIETNAM 1994 4141277.6665
+VIETNAM 1993 2556114.1693
+VIETNAM 1992 4090524.4905
diff --git a/vortex-sqllogictest/src/duckdb.rs b/vortex-sqllogictest/src/duckdb.rs
index f9ec15e3fd6..c340769fa47 100644
--- a/vortex-sqllogictest/src/duckdb.rs
+++ b/vortex-sqllogictest/src/duckdb.rs
@@ -2,17 +2,21 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::process::Command;
+use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 
 use async_trait::async_trait;
+use bigdecimal::BigDecimal;
 use datafusion_sqllogictest::DFColumnType;
 use indicatif::ProgressBar;
 use sqllogictest::DBOutput;
 use sqllogictest::runner::AsyncDB;
 use vortex::error::VortexError;
+use vortex::error::VortexExpect;
 use vortex_duckdb::duckdb::Connection;
 use vortex_duckdb::duckdb::Database;
+use vortex_duckdb::duckdb::ExtractedValue;
 use vortex_duckdb::duckdb::LogicalType;
 use vortex_duckdb::duckdb::LogicalTypeRef;
 use vortex_duckdb::duckdb::Value;
@@ -79,12 +83,15 @@ impl DuckDB {
             DFColumnType::Boolean
         } else if type_id == LogicalType::float32().as_type_id()
             || type_id == LogicalType::float64().as_type_id()
+            || logical_type.is_decimal()
         {
             DFColumnType::Float
         } else if type_id == LogicalType::timestamp().as_type_id()
             || type_id == LogicalType::timestamp_tz().as_type_id()
         {
             DFColumnType::Timestamp
+        } else if type_id == LogicalType::date().as_type_id() {
+            DFColumnType::DateTime
         } else {
             DFColumnType::Another
         }
@@ -118,7 +125,9 @@ impl AsyncDB for DuckDB {
                         for col_idx in 0..chunk.column_count() {
                             let vector = chunk.get_vector(col_idx);
                             match vector.get_value(row_idx, chunk.len()) {
-                                Some(value) => current_row.push(value.to_string()),
+                                Some(value) => {
+                                    current_row.push(ValueDisplayAdapter(value).to_string())
+                                }
                                 None => current_row
                                     .push(Value::null(&vector.logical_type()).to_string()),
                             }
@@ -151,3 +160,172 @@ impl AsyncDB for DuckDB {
         tokio::process::Command::from(command).output().await
     }
 }
+
+/// Rounds a floating-point value via BigDecimal to 12 decimal places,
+/// matching the behavior of `big_decimal_to_str` from `datafusion_sqllogictest`.
+fn big_decimal_to_str(value: BigDecimal) -> String {
+    value.round(12).normalized().to_plain_string()
+}
+
+fn f32_to_str(value: f32) -> String {
+    if value.is_nan() {
+        "NaN".to_string()
+    } else if value == f32::INFINITY {
+        "Infinity".to_string()
+    } else if value == f32::NEG_INFINITY {
+        "-Infinity".to_string()
+    } else {
+        big_decimal_to_str(
+            BigDecimal::from_str(&value.to_string())
+                .ok()
+                .vortex_expect("value can't be parsed to decimal"),
+        )
+    }
+}
+
+fn f64_to_str(value: f64) -> String {
+    if value.is_nan() {
+        "NaN".to_string()
+    } else if value == f64::INFINITY {
+        "Infinity".to_string()
+    } else if value == f64::NEG_INFINITY {
+        "-Infinity".to_string()
+    } else {
+        big_decimal_to_str(
+            BigDecimal::from_str(&value.to_string())
+                .ok()
+                .vortex_expect("value can't be parsed to decimal"),
+        )
+    }
+}
+
+fn decimal_to_str(value: i128, scale: i8) -> String {
+    let bd = BigDecimal::new(value.into(), scale as i64);
+    big_decimal_to_str(bd)
+}
+
+fn varchar_to_str(value: &str) -> String {
+    if value.is_empty() {
+        "(empty)".to_string()
+    } else {
+        value.trim_end_matches('\n').replace('\0', "\\0")
+    }
+}
+
+/// Adapter type to control how duckdb values are displayed.
+/// Matches the behavior of `cell_to_string` from `datafusion_sqllogictest`.
+struct ValueDisplayAdapter(Value);
+
+impl std::fmt::Display for ValueDisplayAdapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.0.extract() {
+            ExtractedValue::Null => write!(f, "NULL"),
+            ExtractedValue::TinyInt(v) => write!(f, "{v}"),
+            ExtractedValue::SmallInt(v) => write!(f, "{v}"),
+            ExtractedValue::Integer(v) => write!(f, "{v}"),
+            ExtractedValue::BigInt(v) => write!(f, "{v}"),
+            ExtractedValue::HugeInt(v) => write!(f, "{v}"),
+            ExtractedValue::UTinyInt(v) => write!(f, "{v}"),
+            ExtractedValue::USmallInt(v) => write!(f, "{v}"),
+            ExtractedValue::UInteger(v) => write!(f, "{v}"),
+            ExtractedValue::UBigInt(v) => write!(f, "{v}"),
+            ExtractedValue::UHugeInt(v) => write!(f, "{v}"),
+            ExtractedValue::Float(v) => write!(f, "{}", f32_to_str(v)),
+            ExtractedValue::Double(v) => write!(f, "{}", f64_to_str(v)),
+            ExtractedValue::Boolean(v) => write!(f, "{v}"),
+            ExtractedValue::Varchar(s) => write!(f, "{}", varchar_to_str(s.as_str())),
+            ExtractedValue::Decimal(_, scale, value) => {
+                write!(f, "{}", decimal_to_str(value, scale))
+            }
+            // For types not specially handled by cell_to_string (dates, times, timestamps,
+            // blobs, lists), delegate to DuckDB's native string representation.
+            ExtractedValue::Blob(_)
+            | ExtractedValue::Date(_)
+            | ExtractedValue::Time(_)
+            | ExtractedValue::TimestampNs(_)
+            | ExtractedValue::Timestamp(_)
+            | ExtractedValue::TimestampMs(_)
+            | ExtractedValue::TimestampS(_)
+            | ExtractedValue::List(_) => write!(f, "{}", self.0),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_duckdb::duckdb::Value;
+
+    use super::ValueDisplayAdapter;
+
+    fn display(value: Value) -> String {
+        ValueDisplayAdapter(value).to_string()
+    }
+
+    #[test]
+    fn test_null() {
+        assert_eq!(display(Value::sql_null()), "NULL");
+    }
+
+    #[rstest]
+    #[case(true, "true")]
+    #[case(false, "false")]
+    fn test_bool(#[case] input: bool, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case(0i32, "0")]
+    #[case(42i32, "42")]
+    #[case(-1i32, "-1")]
+    fn test_integer(#[case] input: i32, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case(0i64, "0")]
+    #[case(i64::MAX, "9223372036854775807")]
+    #[case(i64::MIN, "-9223372036854775808")]
+    fn test_bigint(#[case] input: i64, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case(0.0f64, "0")]
+    #[case(0.1, "0.1")]
+    #[case(1.0 / 3.0, "0.333333333333")]
+    #[case(f64::NAN, "NaN")]
+    #[case(f64::INFINITY, "Infinity")]
+    #[case(f64::NEG_INFINITY, "-Infinity")]
+    #[case(-0.5, "-0.5")]
+    fn test_double(#[case] input: f64, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case(0.0f32, "0")]
+    #[case(0.1f32, "0.1")]
+    #[case(f32::NAN, "NaN")]
+    #[case(f32::INFINITY, "Infinity")]
+    #[case(f32::NEG_INFINITY, "-Infinity")]
+    fn test_float(#[case] input: f32, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case("hello", "hello")]
+    #[case("", "(empty)")]
+    #[case("trailing\n", "trailing")]
+    fn test_varchar(#[case] input: &str, #[case] expected: &str) {
+        assert_eq!(display(Value::from(input)), expected);
+    }
+
+    #[rstest]
+    #[case(12345, 2, "123.45")]
+    #[case(100, 0, "100")]
+    #[case(1, 1, "0.1")]
+    #[case(-12345, 2, "-123.45")]
+    fn test_decimal(#[case] value: i128, #[case] scale: i8, #[case] expected: &str) {
+        assert_eq!(display(Value::new_decimal(18, scale, value)), expected);
+    }
+}
diff --git a/vortex-tensor/Cargo.toml b/vortex-tensor/Cargo.toml
new file mode 100644
index 00000000000..9f94a0c2d3d
--- /dev/null
+++ b/vortex-tensor/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "vortex-tensor"
+authors = { workspace = true }
+categories = { workspace = true }
+description = "Vortex tensor 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]
+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 }
+
+half = { workspace = true }
+itertools = { workspace = true }
+num-traits = { workspace = true }
+prost = { workspace = true }
+rand = { workspace = true }
+
+[dev-dependencies]
+rand_distr = { workspace = true }
+rstest = { workspace = true }
diff --git a/vortex-tensor/public-api.lock b/vortex-tensor/public-api.lock
new file mode 100644
index 00000000000..8a14e2204f0
--- /dev/null
+++ b/vortex-tensor/public-api.lock
@@ -0,0 +1,631 @@
+pub mod vortex_tensor
+
+pub mod vortex_tensor::encodings
+
+pub mod vortex_tensor::encodings::turboquant
+
+pub struct vortex_tensor::encodings::turboquant::TurboQuant
+
+impl vortex_tensor::encodings::turboquant::TurboQuant
+
+pub const vortex_tensor::encodings::turboquant::TurboQuant::ID: vortex_array::array::ArrayId
+
+pub const vortex_tensor::encodings::turboquant::TurboQuant::MAX_BIT_WIDTH: u8
+
+pub const vortex_tensor::encodings::turboquant::TurboQuant::MAX_CENTROIDS: usize
+
+pub const vortex_tensor::encodings::turboquant::TurboQuant::MIN_DIMENSION: u32
+
+pub unsafe fn vortex_tensor::encodings::turboquant::TurboQuant::new_array_unchecked(dtype: vortex_array::dtype::DType, codes: vortex_array::array::erased::ArrayRef, centroids: vortex_array::array::erased::ArrayRef, rotation_signs: vortex_array::array::erased::ArrayRef) -> vortex_tensor::encodings::turboquant::TurboQuantArray
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::try_new_array(dtype: vortex_array::dtype::DType, codes: vortex_array::array::erased::ArrayRef, centroids: vortex_array::array::erased::ArrayRef, rotation_signs: vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<vortex_tensor::encodings::turboquant::TurboQuantArray>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::validate_dtype(dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<vortex_tensor::vector::VectorMatcherMetadata>
+
+impl core::clone::Clone for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::clone(&self) -> vortex_tensor::encodings::turboquant::TurboQuant
+
+impl core::fmt::Debug for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::array::vtable::VTable for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub type vortex_tensor::encodings::turboquant::TurboQuant::ArrayData = vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub type vortex_tensor::encodings::turboquant::TurboQuant::OperationsVTable = vortex_tensor::encodings::turboquant::TurboQuant
+
+pub type vortex_tensor::encodings::turboquant::TurboQuant::ValidityVTable = vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::buffer(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> vortex_array::buffer::BufferHandle
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::buffer_name(_array: vortex_array::array::view::ArrayView<'_, Self>, _idx: usize) -> core::option::Option<alloc::string::String>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::deserialize(&self, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], _buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::array::typed::ArrayParts<Self>>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::execute(array: vortex_array::array::typed::Array<Self>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::execute_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::id(&self) -> vortex_array::array::ArrayId
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::nbuffers(_array: vortex_array::array::view::ArrayView<'_, Self>) -> usize
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::reduce_parent(array: vortex_array::array::view::ArrayView<'_, Self>, parent: &vortex_array::array::erased::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::serialize(array: vortex_array::array::view::ArrayView<'_, Self>, _session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::slot_name(_array: vortex_array::array::view::ArrayView<'_, Self>, idx: usize) -> alloc::string::String
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::validate(&self, data: &Self::ArrayData, dtype: &vortex_array::dtype::DType, len: usize, slots: &[core::option::Option<vortex_array::array::erased::ArrayRef>]) -> vortex_error::VortexResult<()>
+
+impl vortex_array::array::vtable::operations::OperationsVTable<vortex_tensor::encodings::turboquant::TurboQuant> for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::scalar_at(array: vortex_array::array::view::ArrayView<'_, vortex_tensor::encodings::turboquant::TurboQuant>, index: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
+
+impl vortex_array::array::vtable::validity::ValidityVTable<vortex_tensor::encodings::turboquant::TurboQuant> for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::validity(_array: vortex_array::array::view::ArrayView<'_, vortex_tensor::encodings::turboquant::TurboQuant>) -> vortex_error::VortexResult<vortex_array::validity::Validity>
+
+impl vortex_array::arrays::dict::take::TakeExecute for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::take(array: vortex_array::array::view::ArrayView<'_, vortex_tensor::encodings::turboquant::TurboQuant>, indices: &vortex_array::array::erased::ArrayRef, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+impl vortex_array::arrays::slice::SliceReduce for vortex_tensor::encodings::turboquant::TurboQuant
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuant::slice(array: vortex_array::array::view::ArrayView<'_, vortex_tensor::encodings::turboquant::TurboQuant>, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::erased::ArrayRef>>
+
+pub struct vortex_tensor::encodings::turboquant::TurboQuantConfig
+
+pub vortex_tensor::encodings::turboquant::TurboQuantConfig::bit_width: u8
+
+pub vortex_tensor::encodings::turboquant::TurboQuantConfig::num_rounds: u8
+
+pub vortex_tensor::encodings::turboquant::TurboQuantConfig::seed: core::option::Option<u64>
+
+impl core::clone::Clone for vortex_tensor::encodings::turboquant::TurboQuantConfig
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantConfig::clone(&self) -> vortex_tensor::encodings::turboquant::TurboQuantConfig
+
+impl core::default::Default for vortex_tensor::encodings::turboquant::TurboQuantConfig
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantConfig::default() -> Self
+
+impl core::fmt::Debug for vortex_tensor::encodings::turboquant::TurboQuantConfig
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantConfig::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_tensor::encodings::turboquant::TurboQuantData
+
+impl vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::bit_width(&self) -> u8
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::dimension(&self) -> u32
+
+pub unsafe fn vortex_tensor::encodings::turboquant::TurboQuantData::new_unchecked(dimension: u32, bit_width: u8, num_rounds: u8) -> Self
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::num_rounds(&self) -> u8
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::padded_dim(&self) -> u32
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::try_new(dimension: u32, bit_width: u8, num_rounds: u8) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::validate(dtype: &vortex_array::dtype::DType, codes: &vortex_array::array::erased::ArrayRef, centroids: &vortex_array::array::erased::ArrayRef, rotation_signs: &vortex_array::array::erased::ArrayRef) -> vortex_error::VortexResult<()>
+
+impl core::clone::Clone for vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::clone(&self) -> vortex_tensor::encodings::turboquant::TurboQuantData
+
+impl core::fmt::Debug for vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl vortex_array::hash::ArrayEq for vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::array_eq(&self, other: &Self, _precision: vortex_array::hash::Precision) -> bool
+
+impl vortex_array::hash::ArrayHash for vortex_tensor::encodings::turboquant::TurboQuantData
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantData::array_hash<H: core::hash::Hasher>(&self, state: &mut H, _precision: vortex_array::hash::Precision)
+
+pub struct vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+impl core::clone::Clone for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::clone(&self) -> vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+impl core::cmp::Eq for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+impl core::cmp::PartialEq for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::eq(&self, other: &vortex_tensor::encodings::turboquant::TurboQuantScheme) -> bool
+
+impl core::fmt::Debug for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::marker::Copy for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+impl core::marker::StructuralPartialEq for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+impl vortex_compressor::scheme::Scheme for vortex_tensor::encodings::turboquant::TurboQuantScheme
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::compress(&self, compressor: &vortex_compressor::compressor::CascadingCompressor, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::expected_compression_ratio(&self, data: &mut vortex_compressor::stats::cache::ArrayAndStats, _ctx: vortex_compressor::ctx::CompressorContext) -> vortex_compressor::estimate::CompressionEstimate
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::matches(&self, canonical: &vortex_array::canonical::Canonical) -> bool
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantScheme::scheme_name(&self) -> &'static str
+
+pub trait vortex_tensor::encodings::turboquant::TurboQuantArrayExt: vortex_array::array::typed::TypedArrayRef<vortex_tensor::encodings::turboquant::TurboQuant>
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantArrayExt::centroids(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantArrayExt::codes(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_tensor::encodings::turboquant::TurboQuantArrayExt::rotation_signs(&self) -> &vortex_array::array::erased::ArrayRef
+
+impl<T: vortex_array::array::typed::TypedArrayRef<vortex_tensor::encodings::turboquant::TurboQuant>> vortex_tensor::encodings::turboquant::TurboQuantArrayExt for T
+
+pub fn T::centroids(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn T::codes(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn T::rotation_signs(&self) -> &vortex_array::array::erased::ArrayRef
+
+pub fn vortex_tensor::encodings::turboquant::turboquant_encode(ext: vortex_array::array::view::ArrayView<'_, vortex_array::arrays::extension::vtable::Extension>, config: &vortex_tensor::encodings::turboquant::TurboQuantConfig, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub unsafe fn vortex_tensor::encodings::turboquant::turboquant_encode_unchecked(ext: vortex_array::array::view::ArrayView<'_, vortex_array::arrays::extension::vtable::Extension>, config: &vortex_tensor::encodings::turboquant::TurboQuantConfig, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub type vortex_tensor::encodings::turboquant::TurboQuantArray = vortex_array::array::typed::Array<vortex_tensor::encodings::turboquant::TurboQuant>
+
+pub mod vortex_tensor::fixed_shape
+
+pub struct vortex_tensor::fixed_shape::AnyFixedShapeTensor
+
+impl vortex_array::dtype::extension::matcher::Matcher for vortex_tensor::fixed_shape::AnyFixedShapeTensor
+
+pub type vortex_tensor::fixed_shape::AnyFixedShapeTensor::Match<'a> = vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+pub fn vortex_tensor::fixed_shape::AnyFixedShapeTensor::try_match<'a>(ext_dtype: &'a vortex_array::dtype::extension::erased::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+pub struct vortex_tensor::fixed_shape::FixedShapeTensor
+
+impl core::clone::Clone for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::clone(&self) -> vortex_tensor::fixed_shape::FixedShapeTensor
+
+impl core::cmp::Eq for vortex_tensor::fixed_shape::FixedShapeTensor
+
+impl core::cmp::PartialEq for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::eq(&self, other: &vortex_tensor::fixed_shape::FixedShapeTensor) -> bool
+
+impl core::default::Default for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::default() -> vortex_tensor::fixed_shape::FixedShapeTensor
+
+impl core::fmt::Debug for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_tensor::fixed_shape::FixedShapeTensor
+
+impl vortex_array::dtype::extension::vtable::ExtVTable for vortex_tensor::fixed_shape::FixedShapeTensor
+
+pub type vortex_tensor::fixed_shape::FixedShapeTensor::Metadata = vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub type vortex_tensor::fixed_shape::FixedShapeTensor::NativeValue<'a> = &'a vortex_array::scalar::scalar_value::ScalarValue
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::deserialize_metadata(&self, metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::serialize_metadata(&self, metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::unpack_native<'a>(_ext_dtype: &'a vortex_array::dtype::extension::typed::ExtDType<Self>, storage_value: &'a vortex_array::scalar::scalar_value::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensor::validate_dtype(ext_dtype: &vortex_array::dtype::extension::typed::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub struct vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+impl vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'_>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'_>::element_ptype(&self) -> vortex_array::dtype::ptype::PType
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'_>::list_size(&self) -> usize
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'_>::metadata(&self) -> &vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+impl<'a> core::clone::Clone for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>::clone(&self) -> vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+impl<'a> core::cmp::Eq for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+impl<'a> core::cmp::PartialEq for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>::eq(&self, other: &vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>) -> bool
+
+impl<'a> core::fmt::Debug for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::marker::Copy for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+impl<'a> core::marker::StructuralPartialEq for vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>
+
+pub struct vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+impl vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::dim_names(&self) -> core::option::Option<&[alloc::string::String]>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::logical_shape(&self) -> &[usize]
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::ndim(&self) -> usize
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::new(shape: alloc::vec::Vec<usize>) -> Self
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::permutation(&self) -> core::option::Option<&[usize]>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::physical_shape(&self) -> impl core::iter::traits::iterator::Iterator<Item = usize> + '_
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::strides(&self) -> impl core::iter::traits::iterator::Iterator<Item = usize> + '_
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::with_dim_names(self, names: alloc::vec::Vec<alloc::string::String>) -> vortex_error::VortexResult<Self>
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::with_permutation(self, permutation: alloc::vec::Vec<usize>) -> vortex_error::VortexResult<Self>
+
+impl core::clone::Clone for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::clone(&self) -> vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+impl core::cmp::Eq for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+impl core::cmp::PartialEq for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::eq(&self, other: &vortex_tensor::fixed_shape::FixedShapeTensorMetadata) -> bool
+
+impl core::fmt::Debug for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub fn vortex_tensor::fixed_shape::FixedShapeTensorMetadata::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_tensor::fixed_shape::FixedShapeTensorMetadata
+
+pub mod vortex_tensor::matcher
+
+pub enum vortex_tensor::matcher::TensorMatch<'a>
+
+pub vortex_tensor::matcher::TensorMatch::FixedShapeTensor(vortex_tensor::fixed_shape::FixedShapeTensorMatcherMetadata<'a>)
+
+pub vortex_tensor::matcher::TensorMatch::Vector(vortex_tensor::vector::VectorMatcherMetadata)
+
+impl vortex_tensor::matcher::TensorMatch<'_>
+
+pub fn vortex_tensor::matcher::TensorMatch<'_>::element_ptype(self) -> vortex_array::dtype::ptype::PType
+
+pub fn vortex_tensor::matcher::TensorMatch<'_>::list_size(self) -> usize
+
+impl<'a> core::clone::Clone for vortex_tensor::matcher::TensorMatch<'a>
+
+pub fn vortex_tensor::matcher::TensorMatch<'a>::clone(&self) -> vortex_tensor::matcher::TensorMatch<'a>
+
+impl<'a> core::cmp::Eq for vortex_tensor::matcher::TensorMatch<'a>
+
+impl<'a> core::cmp::PartialEq for vortex_tensor::matcher::TensorMatch<'a>
+
+pub fn vortex_tensor::matcher::TensorMatch<'a>::eq(&self, other: &vortex_tensor::matcher::TensorMatch<'a>) -> bool
+
+impl<'a> core::fmt::Debug for vortex_tensor::matcher::TensorMatch<'a>
+
+pub fn vortex_tensor::matcher::TensorMatch<'a>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::marker::Copy for vortex_tensor::matcher::TensorMatch<'a>
+
+impl<'a> core::marker::StructuralPartialEq for vortex_tensor::matcher::TensorMatch<'a>
+
+pub struct vortex_tensor::matcher::AnyTensor
+
+impl vortex_array::dtype::extension::matcher::Matcher for vortex_tensor::matcher::AnyTensor
+
+pub type vortex_tensor::matcher::AnyTensor::Match<'a> = vortex_tensor::matcher::TensorMatch<'a>
+
+pub fn vortex_tensor::matcher::AnyTensor::try_match<'a>(ext_dtype: &'a vortex_array::dtype::extension::erased::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+pub mod vortex_tensor::scalar_fns
+
+pub mod vortex_tensor::scalar_fns::cosine_similarity
+
+pub struct vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity
+
+impl vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::new(options: &vortex_tensor::scalar_fns::ApproxOptions) -> vortex_array::scalar_fn::typed::ScalarFn<vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity>
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::try_new_array(options: &vortex_tensor::scalar_fns::ApproxOptions, lhs: vortex_array::array::erased::ArrayRef, rhs: vortex_array::array::erased::ArrayRef, len: usize) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+impl core::clone::Clone for vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::clone(&self) -> vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity
+
+impl vortex_array::scalar_fn::vtable::ScalarFnVTable for vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity
+
+pub type vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::Options = vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::vtable::Arity
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::vtable::ChildName
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::vtable::ExecutionArgs, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::expression::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::is_fallible(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::is_null_sensitive(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::expression::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::expression::Expression>>
+
+pub mod vortex_tensor::scalar_fns::inner_product
+
+pub struct vortex_tensor::scalar_fns::inner_product::InnerProduct
+
+impl vortex_tensor::scalar_fns::inner_product::InnerProduct
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::new(options: &vortex_tensor::scalar_fns::ApproxOptions) -> vortex_array::scalar_fn::typed::ScalarFn<vortex_tensor::scalar_fns::inner_product::InnerProduct>
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::try_new_array(options: &vortex_tensor::scalar_fns::ApproxOptions, lhs: vortex_array::array::erased::ArrayRef, rhs: vortex_array::array::erased::ArrayRef, len: usize) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+impl core::clone::Clone for vortex_tensor::scalar_fns::inner_product::InnerProduct
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::clone(&self) -> vortex_tensor::scalar_fns::inner_product::InnerProduct
+
+impl vortex_array::scalar_fn::vtable::ScalarFnVTable for vortex_tensor::scalar_fns::inner_product::InnerProduct
+
+pub type vortex_tensor::scalar_fns::inner_product::InnerProduct::Options = vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::vtable::Arity
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::vtable::ChildName
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::execute(&self, options: &Self::Options, args: &dyn vortex_array::scalar_fn::vtable::ExecutionArgs, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::expression::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::is_fallible(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::is_null_sensitive(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_tensor::scalar_fns::inner_product::InnerProduct::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::expression::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::expression::Expression>>
+
+pub mod vortex_tensor::scalar_fns::l2_denorm
+
+pub struct vortex_tensor::scalar_fns::l2_denorm::L2Denorm
+
+impl vortex_tensor::scalar_fns::l2_denorm::L2Denorm
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::new(options: &vortex_tensor::scalar_fns::ApproxOptions) -> vortex_array::scalar_fn::typed::ScalarFn<vortex_tensor::scalar_fns::l2_denorm::L2Denorm>
+
+pub unsafe fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::new_array_unchecked(options: &vortex_tensor::scalar_fns::ApproxOptions, normalized: vortex_array::array::erased::ArrayRef, norms: vortex_array::array::erased::ArrayRef, len: usize) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::try_new_array(options: &vortex_tensor::scalar_fns::ApproxOptions, normalized: vortex_array::array::erased::ArrayRef, norms: vortex_array::array::erased::ArrayRef, len: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+impl core::clone::Clone for vortex_tensor::scalar_fns::l2_denorm::L2Denorm
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::clone(&self) -> vortex_tensor::scalar_fns::l2_denorm::L2Denorm
+
+impl vortex_array::scalar_fn::vtable::ScalarFnVTable for vortex_tensor::scalar_fns::l2_denorm::L2Denorm
+
+pub type vortex_tensor::scalar_fns::l2_denorm::L2Denorm::Options = vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::vtable::Arity
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::vtable::ChildName
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::vtable::ExecutionArgs, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::expression::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::is_fallible(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::is_null_sensitive(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::L2Denorm::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::expression::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::expression::Expression>>
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::normalize_as_l2_denorm(options: &vortex_tensor::scalar_fns::ApproxOptions, input: vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+pub fn vortex_tensor::scalar_fns::l2_denorm::validate_l2_normalized_rows(input: vortex_array::array::erased::ArrayRef, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<()>
+
+pub mod vortex_tensor::scalar_fns::l2_norm
+
+pub struct vortex_tensor::scalar_fns::l2_norm::L2Norm
+
+impl vortex_tensor::scalar_fns::l2_norm::L2Norm
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::new(options: &vortex_tensor::scalar_fns::ApproxOptions) -> vortex_array::scalar_fn::typed::ScalarFn<vortex_tensor::scalar_fns::l2_norm::L2Norm>
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::try_new_array(options: &vortex_tensor::scalar_fns::ApproxOptions, child: vortex_array::array::erased::ArrayRef, len: usize) -> vortex_error::VortexResult<vortex_array::arrays::scalar_fn::vtable::ScalarFnArray>
+
+impl core::clone::Clone for vortex_tensor::scalar_fns::l2_norm::L2Norm
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::clone(&self) -> vortex_tensor::scalar_fns::l2_norm::L2Norm
+
+impl vortex_array::scalar_fn::vtable::ScalarFnVTable for vortex_tensor::scalar_fns::l2_norm::L2Norm
+
+pub type vortex_tensor::scalar_fns::l2_norm::L2Norm::Options = vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::arity(&self, _options: &Self::Options) -> vortex_array::scalar_fn::vtable::Arity
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::child_name(&self, _options: &Self::Options, child_idx: usize) -> vortex_array::scalar_fn::vtable::ChildName
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::execute(&self, _options: &Self::Options, args: &dyn vortex_array::scalar_fn::vtable::ExecutionArgs, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::array::erased::ArrayRef>
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::fmt_sql(&self, _options: &Self::Options, expr: &vortex_array::expr::expression::Expression, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::id(&self) -> vortex_array::scalar_fn::ScalarFnId
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::is_fallible(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::is_null_sensitive(&self, _options: &Self::Options) -> bool
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::return_dtype(&self, _options: &Self::Options, arg_dtypes: &[vortex_array::dtype::DType]) -> vortex_error::VortexResult<vortex_array::dtype::DType>
+
+pub fn vortex_tensor::scalar_fns::l2_norm::L2Norm::validity(&self, _options: &Self::Options, expression: &vortex_array::expr::expression::Expression) -> vortex_error::VortexResult<core::option::Option<vortex_array::expr::expression::Expression>>
+
+pub enum vortex_tensor::scalar_fns::ApproxOptions
+
+pub vortex_tensor::scalar_fns::ApproxOptions::Approximate
+
+pub vortex_tensor::scalar_fns::ApproxOptions::Exact
+
+impl vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::is_approx(&self) -> bool
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::is_exact(&self) -> bool
+
+impl core::clone::Clone for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::clone(&self) -> vortex_tensor::scalar_fns::ApproxOptions
+
+impl core::cmp::Eq for vortex_tensor::scalar_fns::ApproxOptions
+
+impl core::cmp::PartialEq for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::eq(&self, other: &vortex_tensor::scalar_fns::ApproxOptions) -> bool
+
+impl core::default::Default for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::default() -> vortex_tensor::scalar_fns::ApproxOptions
+
+impl core::fmt::Debug for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_tensor::scalar_fns::ApproxOptions
+
+pub fn vortex_tensor::scalar_fns::ApproxOptions::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_tensor::scalar_fns::ApproxOptions
+
+pub mod vortex_tensor::vector
+
+pub struct vortex_tensor::vector::AnyVector
+
+impl vortex_array::dtype::extension::matcher::Matcher for vortex_tensor::vector::AnyVector
+
+pub type vortex_tensor::vector::AnyVector::Match<'a> = vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::AnyVector::try_match<'a>(ext_dtype: &'a vortex_array::dtype::extension::erased::ExtDTypeRef) -> core::option::Option<Self::Match>
+
+pub struct vortex_tensor::vector::Vector
+
+impl core::clone::Clone for vortex_tensor::vector::Vector
+
+pub fn vortex_tensor::vector::Vector::clone(&self) -> vortex_tensor::vector::Vector
+
+impl core::cmp::Eq for vortex_tensor::vector::Vector
+
+impl core::cmp::PartialEq for vortex_tensor::vector::Vector
+
+pub fn vortex_tensor::vector::Vector::eq(&self, other: &vortex_tensor::vector::Vector) -> bool
+
+impl core::default::Default for vortex_tensor::vector::Vector
+
+pub fn vortex_tensor::vector::Vector::default() -> vortex_tensor::vector::Vector
+
+impl core::fmt::Debug for vortex_tensor::vector::Vector
+
+pub fn vortex_tensor::vector::Vector::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_tensor::vector::Vector
+
+pub fn vortex_tensor::vector::Vector::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_tensor::vector::Vector
+
+impl vortex_array::dtype::extension::vtable::ExtVTable for vortex_tensor::vector::Vector
+
+pub type vortex_tensor::vector::Vector::Metadata = vortex_array::extension::EmptyMetadata
+
+pub type vortex_tensor::vector::Vector::NativeValue<'a> = &'a vortex_array::scalar::scalar_value::ScalarValue
+
+pub fn vortex_tensor::vector::Vector::deserialize_metadata(&self, _metadata: &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_tensor::vector::Vector::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_tensor::vector::Vector::serialize_metadata(&self, _metadata: &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_tensor::vector::Vector::unpack_native<'a>(_ext_dtype: &'a vortex_array::dtype::extension::typed::ExtDType<Self>, storage_value: &'a vortex_array::scalar::scalar_value::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_tensor::vector::Vector::validate_dtype(ext_dtype: &vortex_array::dtype::extension::typed::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub struct vortex_tensor::vector::VectorMatcherMetadata
+
+impl vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::dimensions(&self) -> u32
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::element_ptype(&self) -> vortex_array::dtype::ptype::PType
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::try_new(element_ptype: vortex_array::dtype::ptype::PType, dimensions: u32) -> vortex_error::VortexResult<Self>
+
+impl core::clone::Clone for vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::clone(&self) -> vortex_tensor::vector::VectorMatcherMetadata
+
+impl core::cmp::Eq for vortex_tensor::vector::VectorMatcherMetadata
+
+impl core::cmp::PartialEq for vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::eq(&self, other: &vortex_tensor::vector::VectorMatcherMetadata) -> bool
+
+impl core::fmt::Debug for vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::vector::VectorMatcherMetadata::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+
+impl core::marker::Copy for vortex_tensor::vector::VectorMatcherMetadata
+
+impl core::marker::StructuralPartialEq for vortex_tensor::vector::VectorMatcherMetadata
+
+pub fn vortex_tensor::initialize(session: &vortex_session::VortexSession)
diff --git a/vortex-tensor/src/encodings/mod.rs b/vortex-tensor/src/encodings/mod.rs
new file mode 100644
index 00000000000..7c75269b632
--- /dev/null
+++ b/vortex-tensor/src/encodings/mod.rs
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Encodings for the different tensor types.
+
+// TODO(connor):
+// pub mod norm; // Unit-normalized vectors.
+// pub mod spherical; // Spherical transform on unit-normalized vectors.
+
+pub mod turboquant;
diff --git a/vortex-tensor/src/encodings/turboquant/array/centroids.rs b/vortex-tensor/src/encodings/turboquant/array/centroids.rs
new file mode 100644
index 00000000000..e3027d0a58a
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/array/centroids.rs
@@ -0,0 +1,332 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Max-Lloyd centroid computation for TurboQuant scalar quantizers.
+//!
+//! Pre-computes optimal scalar quantizer centroids for the marginal distribution of coordinates
+//! after random rotation of a unit-norm vector. In high dimensions, each coordinate of a randomly
+//! rotated 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.
+
+use std::sync::LazyLock;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_utils::aliases::dash_map::DashMap;
+
+use crate::encodings::turboquant::TurboQuant;
+
+/// 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 numerical integration points for computing conditional expectations.
+const INTEGRATION_POINTS: usize = 1000;
+
+// TODO(connor): Maybe we should just store an `ArrayRef` here?
+/// Global centroid cache keyed by (dimension, bit_width).
+static CENTROID_CACHE: LazyLock<DashMap<(u32, u8), Vec<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 random rotation in
+/// `dimension`-dimensional space.
+pub fn get_centroids(dimension: u32, bit_width: u8) -> VortexResult<Vec<f32>> {
+    vortex_ensure!(
+        (1..=TurboQuant::MAX_BIT_WIDTH).contains(&bit_width),
+        "TurboQuant bit_width must be 1-{}, got {bit_width}",
+        TurboQuant::MAX_BIT_WIDTH
+    );
+    vortex_ensure!(
+        dimension >= TurboQuant::MIN_DIMENSION,
+        "TurboQuant dimension must be >= {}, got {dimension}",
+        TurboQuant::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 rotated 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.
+fn max_lloyd_centroids(dimension: u32, bit_width: u8) -> Vec<f32> {
+    debug_assert!((1..=TurboQuant::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);
+
+    // Initialize centroids uniformly on [-1, 1].
+    let mut centroids: Vec<f64> = (0..num_centroids)
+        .map(|idx| -1.0 + (2.0 * (idx as f64) + 1.0) / (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_POINTS as f64;
+
+    let mut numerator = 0.0;
+    let mut denominator = 0.0;
+
+    for step in 0..=INTEGRATION_POINTS {
+        let x_val = lo + (step as f64) * dx;
+        let weight = pdf_unnormalized(x_val, exponent);
+
+        let trap_weight = if step == 0 || step == INTEGRATION_POINTS {
+            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))`.
+#[inline]
+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 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_boundaries`] for the corresponding
+/// centroids. Uses binary search on the midpoints, avoiding distance comparisons
+/// in the inner loop.
+#[inline]
+pub 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
+        "boundaries must be sorted"
+    );
+
+    #[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 = 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 = 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 = 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 = get_centroids(dim, bits)?;
+        for &val in &centroids {
+            assert!(
+                (-1.0..=1.0).contains(&val),
+                "centroid out of [-1, 1]: {val}",
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn centroids_cached() -> VortexResult<()> {
+        let c1 = get_centroids(128, 2)?;
+        let c2 = get_centroids(128, 2)?;
+        assert_eq!(c1, c2);
+        Ok(())
+    }
+
+    #[test]
+    fn find_nearest_basic() -> VortexResult<()> {
+        let centroids = 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!(get_centroids(128, 0).is_err());
+        assert!(get_centroids(128, 9).is_err());
+        assert!(get_centroids(1, 2).is_err());
+        assert!(get_centroids(127, 2).is_err());
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/array/data.rs b/vortex-tensor/src/encodings/turboquant/array/data.rs
new file mode 100644
index 00000000000..dd1867eb598
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/array/data.rs
@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use vortex_array::ArrayRef;
+use vortex_array::TypedArrayRef;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+use crate::encodings::turboquant::array::slots::Slot;
+use crate::encodings::turboquant::vtable::TurboQuant;
+
+/// TurboQuant array data.
+///
+/// TurboQuant is a lossy vector quantization encoding for [`Vector`](crate::vector::Vector)
+/// extension arrays. It stores quantized coordinate codes for unit-norm vectors, along with shared
+/// codebook centroids and the parameters of the current structured rotation.
+///
+/// Norms should be stored externally in the [`L2Denorm`](crate::scalar_fns::l2_denorm::L2Denorm)
+/// `ScalarFnArray` wrapper.
+///
+/// See the [module docs](crate::encodings::turboquant) for algorithmic details.
+///
+/// Note that degenerate TurboQuant arrays have zero rows and `bit_width == 0`, with all slots
+/// empty.
+#[derive(Clone, Debug)]
+pub struct TurboQuantData {
+    /// The vector dimension `d`, cached from the `FixedSizeList` storage dtype's list size.
+    ///
+    /// Stored as a convenience field to avoid repeatedly extracting it from `dtype`.
+    pub(crate) dimension: u32,
+
+    /// The number of bits per coordinate (0-8), derived from `log2(centroids.len())`.
+    ///
+    /// This is 0 for degenerate empty arrays.
+    pub(crate) bit_width: u8,
+
+    /// The number of sign-diagonal + WHT rounds in the structured rotation.
+    ///
+    /// This is 0 for degenerate empty arrays.
+    pub(crate) num_rounds: u8,
+}
+
+impl Display for TurboQuantData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "dimension: {}, bit_width: {}, num_rounds: {}",
+            self.dimension, self.bit_width, self.num_rounds
+        )
+    }
+}
+
+impl TurboQuantData {
+    /// Build a `TurboQuantData` with validation.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - `dimension` is less than [`MIN_DIMENSION`](TurboQuant::MIN_DIMENSION).
+    /// - `bit_width` is greater than [`MAX_BIT_WIDTH`](TurboQuant::MAX_BIT_WIDTH).
+    pub fn try_new(dimension: u32, bit_width: u8, num_rounds: u8) -> VortexResult<Self> {
+        vortex_ensure!(
+            dimension >= TurboQuant::MIN_DIMENSION,
+            "TurboQuant requires dimension >= {}, got {dimension}",
+            TurboQuant::MIN_DIMENSION
+        );
+        vortex_ensure!(
+            bit_width <= TurboQuant::MAX_BIT_WIDTH,
+            "bit_width is expected to be between 0 and {}, got {bit_width}",
+            TurboQuant::MAX_BIT_WIDTH
+        );
+
+        Ok(Self {
+            dimension,
+            bit_width,
+            num_rounds,
+        })
+    }
+
+    /// Build a `TurboQuantData` without validation.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure:
+    ///
+    /// - `dimension` is >= [`MIN_DIMENSION`](TurboQuant::MIN_DIMENSION).
+    /// - `bit_width` is in the range `[0, MAX_BIT_WIDTH]`.
+    /// - `num_rounds` is >= 1 (or 0 for degenerate empty arrays).
+    ///
+    /// Violating these invariants may produce incorrect results during decompression.
+    pub unsafe fn new_unchecked(dimension: u32, bit_width: u8, num_rounds: u8) -> Self {
+        Self {
+            dimension,
+            bit_width,
+            num_rounds,
+        }
+    }
+
+    /// Validates the components that would be used to create a `TurboQuantData`.
+    ///
+    /// This function checks all the invariants required by [`new_unchecked`](Self::new_unchecked).
+    pub fn validate(
+        dtype: &DType,
+        codes: &ArrayRef,
+        centroids: &ArrayRef,
+        rotation_signs: &ArrayRef,
+    ) -> VortexResult<()> {
+        let vector_metadata = TurboQuant::validate_dtype(dtype)?;
+        let dimension = vector_metadata.dimensions();
+        let padded_dim = dimension.next_power_of_two();
+
+        // TurboQuant arrays are always non-nullable. Nullability should be handled by the external
+        // L2Denorm ScalarFnArray wrapper.
+        vortex_ensure!(
+            !dtype.is_nullable(),
+            "TurboQuant dtype must be non-nullable, got {dtype}",
+        );
+
+        // Codes must be a non-nullable FixedSizeList<u8> with list_size == padded_dim.
+        let expected_codes_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            padded_dim,
+            Nullability::NonNullable,
+        );
+        vortex_ensure_eq!(
+            *codes.dtype(),
+            expected_codes_dtype,
+            "codes dtype does not match expected {expected_codes_dtype}",
+        );
+
+        // Centroids are always f32 regardless of element type.
+        let centroids_dtype = DType::Primitive(PType::F32, Nullability::NonNullable);
+        vortex_ensure_eq!(
+            *centroids.dtype(),
+            centroids_dtype,
+            "centroids dtype must be non-nullable f32",
+        );
+
+        // Rotation signs must be a FixedSizeList<u8> with list_size == padded_dim. The FSL length
+        // is the number of rotation rounds.
+        let expected_signs_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            padded_dim,
+            Nullability::NonNullable,
+        );
+        vortex_ensure_eq!(
+            *rotation_signs.dtype(),
+            expected_signs_dtype,
+            "rotation_signs dtype does not match expected {expected_signs_dtype}",
+        );
+        // Degenerate (empty) case: all children must be empty, and bit_width is 0.
+        let num_rows = codes.len();
+        if num_rows == 0 {
+            vortex_ensure!(
+                centroids.is_empty(),
+                "degenerate TurboQuant must have empty centroids, got length {}",
+                centroids.len()
+            );
+            vortex_ensure!(
+                rotation_signs.is_empty(),
+                "degenerate TurboQuant must have empty rotation_signs, got length {}",
+                rotation_signs.len()
+            );
+            return Ok(());
+        }
+
+        vortex_ensure!(
+            !rotation_signs.is_empty(),
+            "rotation_signs must have at least 1 round"
+        );
+
+        // Non-degenerate: derive and validate bit_width from centroids.
+        let num_centroids = centroids.len();
+        vortex_ensure!(
+            num_centroids.is_power_of_two()
+                && (2..=TurboQuant::MAX_CENTROIDS).contains(&num_centroids),
+            "centroids length must be a power of 2 in [2, {}], got {num_centroids}",
+            TurboQuant::MAX_CENTROIDS
+        );
+
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "Guaranteed to be [1,8] by the preceding power-of-2 and range checks."
+        )]
+        let bit_width = num_centroids.trailing_zeros() as u8;
+        vortex_ensure!(
+            (1..=TurboQuant::MAX_BIT_WIDTH).contains(&bit_width),
+            "derived bit_width must be 1-{}, got {bit_width}",
+            TurboQuant::MAX_BIT_WIDTH
+        );
+
+        Ok(())
+    }
+
+    pub(crate) fn make_slots(
+        codes: ArrayRef,
+        centroids: ArrayRef,
+        rotation_signs: ArrayRef,
+    ) -> Vec<Option<ArrayRef>> {
+        let mut slots = vec![None; Slot::COUNT];
+        slots[Slot::Codes as usize] = Some(codes);
+        slots[Slot::Centroids as usize] = Some(centroids);
+        slots[Slot::RotationSigns as usize] = Some(rotation_signs);
+        slots
+    }
+
+    /// The vector dimension `d`, as stored in the [`Vector`](crate::vector::Vector) extension
+    /// dtype's `FixedSizeList` storage.
+    pub fn dimension(&self) -> u32 {
+        self.dimension
+    }
+
+    /// MSE bits per coordinate (1-MAX_BIT_WIDTH for non-empty arrays, 0 for degenerate empty arrays).
+    pub fn bit_width(&self) -> u8 {
+        self.bit_width
+    }
+
+    /// The number of sign-diagonal + WHT rounds in the structured rotation.
+    pub fn num_rounds(&self) -> u8 {
+        self.num_rounds
+    }
+
+    /// Padded dimension (next power of 2 >= [`dimension`](Self::dimension)).
+    ///
+    /// The current Walsh-Hadamard-based structured rotation requires power-of-2 input, so
+    /// non-power-of-2 dimensions are zero-padded to this value.
+    pub fn padded_dim(&self) -> u32 {
+        self.dimension.next_power_of_two()
+    }
+}
+
+pub trait TurboQuantArrayExt: TypedArrayRef<TurboQuant> {
+    fn codes(&self) -> &ArrayRef {
+        self.as_ref().slots()[Slot::Codes as usize]
+            .as_ref()
+            .vortex_expect("TurboQuantArray codes slot")
+    }
+
+    fn centroids(&self) -> &ArrayRef {
+        self.as_ref().slots()[Slot::Centroids as usize]
+            .as_ref()
+            .vortex_expect("TurboQuantArray centroids slot")
+    }
+
+    fn rotation_signs(&self) -> &ArrayRef {
+        self.as_ref().slots()[Slot::RotationSigns as usize]
+            .as_ref()
+            .vortex_expect("TurboQuantArray rotation_signs slot")
+    }
+}
+
+impl<T: TypedArrayRef<TurboQuant>> TurboQuantArrayExt for T {}
diff --git a/vortex-tensor/src/encodings/turboquant/array/mod.rs b/vortex-tensor/src/encodings/turboquant/array/mod.rs
new file mode 100644
index 00000000000..e82313f1dc6
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/array/mod.rs
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! TurboQuant array definition: stores quantized coordinate codes, norms, centroids (codebook),
+//! and rotation signs.
+
+pub(crate) mod data;
+pub(crate) mod slots;
+
+pub(crate) mod centroids;
+pub(crate) mod rotation;
diff --git a/vortex-tensor/src/encodings/turboquant/array/rotation.rs b/vortex-tensor/src/encodings/turboquant/array/rotation.rs
new file mode 100644
index 00000000000..57c236c821a
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/array/rotation.rs
@@ -0,0 +1,428 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Deterministic random rotation for TurboQuant.
+//!
+//! The TurboQuant paper analyzes a full random orthogonal rotation. The current implementation
+//! uses a cheaper structured Walsh-Hadamard-based surrogate instead of a dense d x d matrix.
+//!
+//! Concretely, this applies three rounds of random sign diagonals interleaved with the Fast
+//! Walsh-Hadamard Transform (FWHT): `D3 * H * D2 * H * D1 * H`, followed by normalization. This is
+//! a SORF-style structured approximation to a random orthogonal matrix, chosen for O(d log d)
+//! encode/decode cost and compact serialized parameters.
+//!
+//! 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 rand::RngExt;
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+
+/// IEEE 754 sign bit mask for f32.
+const F32_SIGN_BIT: u32 = 0x8000_0000;
+
+/// A Walsh-Hadamard-based structured surrogate for a random orthogonal rotation.
+pub struct RotationMatrix {
+    /// 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 RotationMatrix {
+    /// Create a new structured Walsh-Hadamard-based rotation from a deterministic seed.
+    pub fn try_new(seed: u64, 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();
+        let mut rng = StdRng::seed_from_u64(seed);
+
+        let mut sign_masks = Vec::with_capacity(num_rounds * padded_dim);
+        for _ in 0..num_rounds {
+            sign_masks.extend(gen_random_sign_masks(&mut rng, padded_dim));
+        }
+
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "Intentional f64 -> f32 truncation for normalization factor."
+        )]
+        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,
+        })
+    }
+
+    /// Apply forward rotation: `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 inverse rotation: `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);
+    }
+
+    /// Returns the number of sign-diagonal + WHT rounds.
+    pub fn num_rounds(&self) -> usize {
+        self.num_rounds
+    }
+
+    /// 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 structured rotation: `D_k · H · ... · D₁ · H · x`, with normalization.
+    fn apply_srht(&self, buf: &mut [f32]) {
+        for round in 0..self.num_rounds {
+            let offset = round * self.padded_dim;
+            apply_signs_xor(buf, &self.sign_masks[offset..offset + self.padded_dim]);
+            walsh_hadamard_transform(buf);
+        }
+
+        let norm = self.norm_factor;
+        buf.iter_mut().for_each(|val| *val *= norm);
+    }
+
+    /// Apply the inverse structured rotation.
+    ///
+    /// Forward is: `norm · H · D_k · H · ... · D₁ · H`.
+    /// 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);
+            let offset = round * self.padded_dim;
+            apply_signs_xor(buf, &self.sign_masks[offset..offset + self.padded_dim]);
+        }
+
+        let norm = self.norm_factor;
+        buf.iter_mut().for_each(|val| *val *= norm);
+    }
+
+    /// 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)`.
+    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 [`RotationMatrix`] 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.
+    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
+                };
+            }
+        }
+
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "Intentional f64 -> f32 truncation for normalization factor."
+        )]
+        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 a vector of random XOR sign masks.
+fn gen_random_sign_masks(rng: &mut StdRng, len: usize) -> Vec<u32> {
+    (0..len)
+        .map(|_| {
+            if rng.random_bool(0.5) {
+                0u32 // +1: no-op
+            } else {
+                F32_SIGN_BIT // -1: flip sign bit
+            }
+        })
+        .collect()
+}
+
+/// Apply 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.
+#[inline]
+fn apply_signs_xor(buf: &mut [f32], masks: &[u32]) {
+    for (val, &mask) in buf.iter_mut().zip(masks.iter()) {
+        *val = f32::from_bits(val.to_bits() ^ mask);
+    }
+}
+
+/// 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.
+#[inline(always)]
+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::*;
+
+    #[test]
+    fn deterministic_from_seed() -> VortexResult<()> {
+        let r1 = RotationMatrix::try_new(42, 64, 3)?;
+        let r2 = RotationMatrix::try_new(42, 64, 3)?;
+        let pd = r1.padded_dim();
+
+        let mut input = vec![0.0f32; pd];
+        for i in 0..64 {
+            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(())
+    }
+
+    /// Verify roundtrip is exact to f32 precision across many dimensions and round counts,
+    /// including non-power-of-two dimensions that require padding.
+    #[rstest]
+    #[case(32, 3)]
+    #[case(64, 3)]
+    #[case(100, 3)]
+    #[case(128, 1)]
+    #[case(128, 2)]
+    #[case(128, 3)]
+    #[case(128, 5)]
+    #[case(256, 3)]
+    #[case(512, 3)]
+    #[case(768, 3)]
+    #[case(1024, 3)]
+    fn roundtrip_exact(#[case] dim: usize, #[case] num_rounds: usize) -> VortexResult<()> {
+        let rot = RotationMatrix::try_new(42, 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(128, 1)]
+    #[case(128, 3)]
+    #[case(128, 5)]
+    #[case(768, 3)]
+    fn preserves_norm(#[case] dim: usize, #[case] num_rounds: usize) -> VortexResult<()> {
+        let rot = RotationMatrix::try_new(7, 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 rotation output.
+    #[rstest]
+    #[case(64, 3)]
+    #[case(128, 1)]
+    #[case(128, 3)]
+    #[case(128, 5)]
+    #[case(768, 3)]
+    fn sign_export_import_roundtrip(
+        #[case] dim: usize,
+        #[case] num_rounds: usize,
+    ) -> VortexResult<()> {
+        let rot = RotationMatrix::try_new(42, dim, num_rounds)?;
+        let padded_dim = rot.padded_dim();
+
+        let signs_u8 = rot.export_inverse_signs_u8();
+        let rot2 = RotationMatrix::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 rotation 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 rotation 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/encodings/turboquant/array/slots.rs b/vortex-tensor/src/encodings/turboquant/array/slots.rs
new file mode 100644
index 00000000000..c4fe7e0c5bf
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/array/slots.rs
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+/// Slot positions for TurboQuantArray children.
+///
+/// Norms are not stored in the TurboQuantArray. They live in the external [`L2Denorm`]
+/// ScalarFnArray wrapper returned by [`turboquant_encode`].
+///
+/// [`L2Denorm`]: crate::scalar_fns::l2_denorm::L2Denorm
+/// [`turboquant_encode`]: crate::encodings::turboquant::turboquant_encode
+#[repr(usize)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Slot {
+    Codes = 0,
+    Centroids = 1,
+    RotationSigns = 2,
+}
+
+impl Slot {
+    pub(crate) const COUNT: usize = 3;
+
+    pub(crate) fn name(self) -> &'static str {
+        match self {
+            Self::Codes => "codes",
+            Self::Centroids => "centroids",
+            Self::RotationSigns => "rotation_signs",
+        }
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Self {
+        match idx {
+            0 => Self::Codes,
+            1 => Self::Centroids,
+            2 => Self::RotationSigns,
+            _ => vortex_error::vortex_panic!("invalid slot index {idx}"),
+        }
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/compute/mod.rs b/vortex-tensor/src/encodings/turboquant/compute/mod.rs
new file mode 100644
index 00000000000..eab759ef0b9
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/compute/mod.rs
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Compute pushdown implementations for TurboQuant.
+
+mod ops;
+mod slice;
+mod take;
+
+pub(crate) mod rules;
+
+use num_traits::Float;
+use num_traits::FromPrimitive;
+use vortex_error::VortexExpect;
+
+/// 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.
+pub(crate) fn float_from_f32<T: Float + FromPrimitive>(v: f32) -> T {
+    FromPrimitive::from_f32(v).vortex_expect("f32-to-float conversion is infallible")
+}
diff --git a/vortex-tensor/src/encodings/turboquant/compute/ops.rs b/vortex-tensor/src/encodings/turboquant/compute/ops.rs
new file mode 100644
index 00000000000..4999816319b
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/compute/ops.rs
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::slice::SliceReduce;
+use vortex_array::scalar::Scalar;
+use vortex_array::vtable::OperationsVTable;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use crate::encodings::turboquant::TurboQuant;
+
+impl OperationsVTable<TurboQuant> for TurboQuant {
+    fn scalar_at(
+        array: ArrayView<'_, TurboQuant>,
+        index: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        // Slice to single row, decompress that one row.
+        let Some(sliced) = <TurboQuant as SliceReduce>::slice(array, index..index + 1)? else {
+            vortex_bail!("slice returned None for index {index}")
+        };
+        let decoded = sliced.execute::<ExtensionArray>(ctx)?;
+        decoded.scalar_at(0)
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/compute/rules.rs b/vortex-tensor/src/encodings/turboquant/compute/rules.rs
new file mode 100644
index 00000000000..39919a8c1ec
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/compute/rules.rs
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::arrays::dict::TakeExecuteAdaptor;
+use vortex_array::arrays::slice::SliceReduceAdaptor;
+use vortex_array::kernel::ParentKernelSet;
+use vortex_array::optimizer::rules::ParentRuleSet;
+
+use crate::encodings::turboquant::TurboQuant;
+
+pub(crate) static RULES: ParentRuleSet<TurboQuant> =
+    ParentRuleSet::new(&[ParentRuleSet::lift(&SliceReduceAdaptor(TurboQuant))]);
+
+pub(crate) static PARENT_KERNELS: ParentKernelSet<TurboQuant> =
+    ParentKernelSet::new(&[ParentKernelSet::lift(&TakeExecuteAdaptor(TurboQuant))]);
diff --git a/vortex-tensor/src/encodings/turboquant/compute/slice.rs b/vortex-tensor/src/encodings/turboquant/compute/slice.rs
new file mode 100644
index 00000000000..c19f604e36a
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/compute/slice.rs
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::Range;
+
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::IntoArray;
+use vortex_array::arrays::slice::SliceReduce;
+use vortex_error::VortexResult;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::TurboQuantArrayExt;
+
+impl SliceReduce for TurboQuant {
+    fn slice(
+        array: ArrayView<'_, TurboQuant>,
+        range: Range<usize>,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let sliced_codes = array.codes().slice(range)?;
+
+        Ok(Some(
+            TurboQuant::try_new_array(
+                array.dtype().clone(),
+                sliced_codes,
+                array.centroids().clone(),
+                array.rotation_signs().clone(),
+            )?
+            .into_array(),
+        ))
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/compute/take.rs b/vortex-tensor/src/encodings/turboquant/compute/take.rs
new file mode 100644
index 00000000000..19a2e65e393
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/compute/take.rs
@@ -0,0 +1,33 @@
+// 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::arrays::dict::TakeExecute;
+use vortex_error::VortexResult;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::TurboQuantArrayExt;
+
+impl TakeExecute for TurboQuant {
+    fn take(
+        array: ArrayView<'_, TurboQuant>,
+        indices: &ArrayRef,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        // FSL children handle per-row take natively.
+        let taken_codes = array.codes().take(indices.clone())?;
+
+        Ok(Some(
+            TurboQuant::try_new_array(
+                array.dtype().clone(),
+                taken_codes,
+                array.centroids().clone(),
+                array.rotation_signs().clone(),
+            )?
+            .into_array(),
+        ))
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/metadata.rs b/vortex-tensor/src/encodings/turboquant/metadata.rs
new file mode 100644
index 00000000000..b4a7a8aef08
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/metadata.rs
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Protobuf-backed metadata for TurboQuant encoding.
+
+use prost::Message;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+use crate::encodings::turboquant::TurboQuant;
+
+/// Serialized metadata for TurboQuant arrays.
+#[derive(Clone, PartialEq, Message)]
+pub(super) struct TurboQuantMetadata {
+    /// The number of bits per coordinate, which must be <= [`TurboQuant::MAX_BIT_WIDTH`].
+    #[prost(uint32, required, tag = "1")]
+    bit_width: u32,
+
+    /// The number of sign-diagonal + WHT rounds in the structured rotation.
+    #[prost(uint32, required, tag = "2")]
+    num_rounds: u32,
+}
+
+impl TurboQuantMetadata {
+    /// Creates metadata for the given bit width and number of rotation rounds.
+    pub(super) fn new(bit_width: u8, num_rounds: u8) -> Self {
+        Self {
+            bit_width: u32::from(bit_width),
+            num_rounds: u32::from(num_rounds),
+        }
+    }
+
+    /// Returns the validated TurboQuant bit width.
+    pub(super) fn bit_width(&self) -> VortexResult<u8> {
+        let bit_width = u8::try_from(self.bit_width).map_err(|_| {
+            vortex_err!(
+                "TurboQuant bit_width must fit into u8, got {}",
+                self.bit_width
+            )
+        })?;
+        vortex_ensure!(
+            bit_width <= TurboQuant::MAX_BIT_WIDTH,
+            "bit_width is expected to be between 0 and {}, got {bit_width}",
+            TurboQuant::MAX_BIT_WIDTH
+        );
+
+        Ok(bit_width)
+    }
+
+    /// Returns the validated number of rotation rounds.
+    ///
+    /// Returns 0 for degenerate (empty) arrays, which is validated at a higher level.
+    pub(super) fn num_rounds(&self) -> VortexResult<u8> {
+        u8::try_from(self.num_rounds).map_err(|_| {
+            vortex_err!(
+                "TurboQuant num_rounds must fit into u8, got {}",
+                self.num_rounds
+            )
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prost::Message;
+    use rstest::rstest;
+    use vortex_error::VortexResult;
+
+    use super::TurboQuantMetadata;
+
+    #[rstest]
+    #[case(0, 0)]
+    #[case(0, 3)]
+    #[case(3, 1)]
+    #[case(8, 3)]
+    #[case(8, 5)]
+    fn protobuf_metadata_roundtrip(
+        #[case] bit_width: u8,
+        #[case] num_rounds: u8,
+    ) -> VortexResult<()> {
+        let bytes = TurboQuantMetadata::new(bit_width, num_rounds).encode_to_vec();
+        let decoded = TurboQuantMetadata::decode(bytes.as_slice())?;
+        assert_eq!(decoded.bit_width()?, bit_width);
+        assert_eq!(decoded.num_rounds()?, num_rounds);
+
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/encodings/turboquant/mod.rs b/vortex-tensor/src/encodings/turboquant/mod.rs
new file mode 100644
index 00000000000..ff3259788e9
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/mod.rs
@@ -0,0 +1,156 @@
+// 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 `TurboQuantArray` stores only the quantized unit-norm vector data (codes, centroids,
+//! rotation signs). Per-vector L2 norms are stored separately in an [`L2Denorm`] ScalarFnArray
+//! wrapper. The [`turboquant_encode`] function returns this wrapper:
+//!
+//! ```text
+//! ScalarFnArray(L2Denorm, [TurboQuantArray, norms])
+//! ```
+//!
+//! When executed, the TQ array decompresses to unit-norm vectors, and the [`L2Denorm`] function
+//! lazily re-applies the stored norms to reconstruct the original magnitudes.
+//!
+//! [`L2Denorm`]: crate::scalar_fns::l2_denorm::L2Denorm
+//! [`turboquant_encode`]: crate::encodings::turboquant::turboquant_encode
+//!
+//! 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. 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::arrays::Extension;
+//! 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_buffer::BufferMut;
+//! use vortex_array::session::ArraySession;
+//! use vortex_session::VortexSession;
+//! use vortex_tensor::encodings::turboquant::{TurboQuantConfig, turboquant_encode_unchecked};
+//! use vortex_tensor::scalar_fns::ApproxOptions;
+//! use vortex_tensor::scalar_fns::l2_denorm::normalize_as_l2_denorm;
+//! 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 ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())
+//!     .unwrap().erased();
+//! let ext = ExtensionArray::new(ext_dtype, fsl.into_array());
+//!
+//! // Normalize, then quantize the normalized child at 2 bits per coordinate.
+//! let session = VortexSession::empty().with::<ArraySession>();
+//! let mut ctx = session.create_execution_ctx();
+//! let l2_denorm = normalize_as_l2_denorm(
+//!     &ApproxOptions::Exact, ext.into_array(), &mut ctx,
+//! ).unwrap();
+//! let normalized = l2_denorm.child_at(0).clone();
+//!
+//! let normalized_ext = normalized.as_opt::<Extension>().unwrap();
+//! let config = TurboQuantConfig { bit_width: 2, seed: Some(42), num_rounds: 3 };
+//! // SAFETY: We just normalized the input.
+//! let tq = unsafe {
+//!     turboquant_encode_unchecked(normalized_ext, &config, &mut ctx).unwrap()
+//! };
+//!
+//! // Verify compression: 100 vectors x 128 dims x 4 bytes = 51200 bytes input.
+//! assert!(tq.nbytes() < 51200);
+//! ```
+
+mod array;
+pub use array::data::TurboQuantArrayExt;
+pub use array::data::TurboQuantData;
+
+pub(crate) mod compute;
+
+mod metadata;
+
+mod vtable;
+
+pub use vtable::TurboQuant;
+pub use vtable::TurboQuantArray;
+
+mod scheme;
+pub use scheme::TurboQuantScheme;
+pub use scheme::compress::TurboQuantConfig;
+pub use scheme::compress::turboquant_encode;
+pub use scheme::compress::turboquant_encode_unchecked;
+
+#[cfg(test)]
+mod tests;
diff --git a/vortex-tensor/src/encodings/turboquant/scheme/compress.rs b/vortex-tensor/src/encodings/turboquant/scheme/compress.rs
new file mode 100644
index 00000000000..f787a80cbf7
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/scheme/compress.rs
@@ -0,0 +1,312 @@
+// 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`](super::TurboQuantScheme) calls before invoking this function.
+
+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::extension::ExtensionArrayExt;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_fastlanes::bitpack_compress::bitpack_encode;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::array::centroids::compute_centroid_boundaries;
+use crate::encodings::turboquant::array::centroids::find_nearest_centroid;
+use crate::encodings::turboquant::array::centroids::get_centroids;
+use crate::encodings::turboquant::array::rotation::RotationMatrix;
+use crate::encodings::turboquant::vtable::TurboQuantArray;
+use crate::scalar_fns::l2_denorm::validate_l2_normalized_rows;
+
+/// Configuration for TurboQuant encoding.
+#[derive(Clone, Debug)]
+pub struct TurboQuantConfig {
+    /// Bits per coordinate (1-8).
+    pub bit_width: u8,
+    /// Optional seed for the rotation matrix. If None, the default seed is used.
+    pub seed: Option<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: TurboQuant::MAX_BIT_WIDTH,
+            seed: Some(42),
+            num_rounds: 3,
+        }
+    }
+}
+
+/// Extract elements from a FixedSizeListArray as a flat f32 PrimitiveArray for quantization.
+///
+/// All quantization (rotation, centroid lookup) happens in f32. f16 is upcast; f64 is truncated.
+fn extract_f32_elements(
+    fsl: &FixedSizeListArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<PrimitiveArray> {
+    let elements = fsl.elements();
+    let primitive = elements.clone().execute::<PrimitiveArray>(ctx)?;
+    let ptype = primitive.ptype();
+
+    match ptype {
+        PType::F16 => Ok(primitive
+            .as_slice::<half::f16>()
+            .iter()
+            .map(|&v| f32::from(v))
+            .collect()),
+        PType::F32 => Ok(primitive),
+        PType::F64 => Ok(primitive
+            .as_slice::<f64>()
+            .iter()
+            .map(|&v| {
+                #[expect(
+                    clippy::cast_possible_truncation,
+                    reason = "TurboQuant quantization operates in f32, so f64 inputs are intentionally downcast"
+                )]
+                let v = v as f32;
+                v
+            })
+            .collect()),
+        _ => vortex_bail!("TurboQuant requires float elements, got {ptype:?}"),
+    }
+}
+
+/// Shared intermediate results from the quantization loop.
+struct QuantizationResult {
+    rotation: RotationMatrix,
+    centroids: Vec<f32>,
+    all_indices: BufferMut<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 =
+        usize::try_from(fsl.list_size()).vortex_expect("u32 FixedSizeList dimension fits in usize");
+    let num_rows = fsl.len();
+
+    let rotation = RotationMatrix::try_new(seed, dimension, num_rounds as usize)?;
+    let padded_dim = rotation.padded_dim();
+    let padded_dim_u32 =
+        u32::try_from(padded_dim).vortex_expect("padded_dim stays representable as u32");
+
+    let f32_elements = extract_f32_elements(fsl, ctx)?;
+
+    let centroids = 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::<f32>();
+    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 {
+        rotation,
+        centroids,
+        all_indices,
+        padded_dim,
+    })
+}
+
+/// Build a `TurboQuantArray` from quantization results.
+///
+/// The `ext_dtype` must be a non-nullable [`Vector`](crate::vector::Vector) extension dtype.
+fn build_turboquant(
+    num_rows: usize,
+    core: QuantizationResult,
+    ext_dtype: &DType,
+) -> VortexResult<TurboQuantArray> {
+    let padded_dim = core.padded_dim;
+    let padded_dim_u32 =
+        u32::try_from(padded_dim).vortex_expect("padded_dim stays representable as u32");
+    let codes_elements =
+        PrimitiveArray::new::<u8>(core.all_indices.freeze(), Validity::NonNullable);
+    let codes = FixedSizeListArray::try_new(
+        codes_elements.into_array(),
+        padded_dim_u32,
+        Validity::NonNullable,
+        num_rows,
+    )?
+    .into_array();
+
+    // TODO(perf): `get_centroids` returns Vec<f32>; could avoid the copy by
+    // supporting Buffer::from(Vec<T>) or caching as Buffer directly.
+    let mut centroids_buf = BufferMut::<f32>::with_capacity(core.centroids.len());
+    centroids_buf.extend_from_slice(&core.centroids);
+    let centroids_array =
+        PrimitiveArray::new::<f32>(centroids_buf.freeze(), Validity::NonNullable).into_array();
+
+    let rotation_signs = bitpack_rotation_signs(&core.rotation)?;
+
+    TurboQuant::try_new_array(ext_dtype.clone(), codes, centroids_array, rotation_signs)
+}
+
+/// Encode a non-nullable, L2-normalized [`Vector`](crate::vector::Vector) extension array into a
+/// [`TurboQuantArray`].
+///
+/// The input must be a non-nullable Vector extension array whose rows are already unit-norm.
+/// **Null vectors are not supported.** The caller must normalize and strip nullability before
+/// calling this function, for example via [`normalize_as_l2_denorm`].
+///
+/// This function validates that every row is L2-normalized (or is exactly 0.0). Use
+/// [`turboquant_encode_unchecked`] to skip this check when the caller has just performed
+/// normalization.
+///
+/// The returned array is a plain [`TurboQuantArray`] that decompresses to unit-norm vectors.
+/// The caller is responsible for wrapping it in an [`L2Denorm`] ScalarFnArray if the original
+/// magnitudes need to be restored.
+///
+/// [`normalize_as_l2_denorm`]: crate::scalar_fns::l2_denorm::normalize_as_l2_denorm
+/// [`L2Denorm`]: crate::scalar_fns::l2_denorm::L2Denorm
+pub fn turboquant_encode(
+    ext: ArrayView<Extension>,
+    config: &TurboQuantConfig,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let ext_dtype = ext.dtype().clone();
+
+    vortex_ensure!(
+        !ext_dtype.is_nullable(),
+        "TurboQuant input must be non-nullable (normalize first via L2Denorm), got {ext_dtype}",
+    );
+
+    validate_l2_normalized_rows(ext.as_ref().clone(), ctx)?;
+
+    // SAFETY: We just validated that the input is non-nullable and all rows are unit-norm.
+    unsafe { turboquant_encode_unchecked(ext, config, ctx) }
+}
+
+/// Encode a non-nullable, L2-normalized [`Vector`](crate::vector::Vector) extension array into a
+/// [`TurboQuantArray`], 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 <= TurboQuant::MAX_BIT_WIDTH,
+        "bit_width must be 1-{}, got {}",
+        TurboQuant::MAX_BIT_WIDTH,
+        config.bit_width
+    );
+    let dimension = fsl.list_size();
+    vortex_ensure!(
+        dimension >= TurboQuant::MIN_DIMENSION,
+        "TurboQuant requires dimension >= {}, got {dimension}",
+        TurboQuant::MIN_DIMENSION
+    );
+
+    if fsl.is_empty() {
+        let padded_dim = dimension.next_power_of_two();
+        let empty_codes = FixedSizeListArray::try_new(
+            PrimitiveArray::empty::<u8>(Nullability::NonNullable).into_array(),
+            padded_dim,
+            Validity::NonNullable,
+            0,
+        )?;
+
+        let empty_centroids = PrimitiveArray::empty::<f32>(Nullability::NonNullable);
+        let empty_signs = FixedSizeListArray::try_new(
+            PrimitiveArray::empty::<u8>(Nullability::NonNullable).into_array(),
+            padded_dim,
+            Validity::NonNullable,
+            0,
+        )?;
+
+        return Ok(TurboQuant::try_new_array(
+            ext_dtype,
+            empty_codes.into_array(),
+            empty_centroids.into_array(),
+            empty_signs.into_array(),
+        )?
+        .into_array());
+    }
+
+    let seed = config.seed.unwrap_or(42);
+    let num_rows = fsl.len();
+    let core = turboquant_quantize_core(&fsl, seed, config.bit_width, config.num_rounds, ctx)?;
+
+    Ok(build_turboquant(num_rows, core, &ext_dtype)?.into_array())
+}
+
+/// Export rotation signs as a `FixedSizeListArray` wrapping a 1-bit [`BitPackedArray`].
+///
+/// The rotation matrix's `num_rounds * padded_dim` sign values are exported as 0/1 u8 values in
+/// inverse application order, bitpacked to 1 bit per sign, then wrapped in a
+/// `FixedSizeListArray` with `list_size = padded_dim` and `len = num_rounds`.
+fn bitpack_rotation_signs(rotation: &RotationMatrix) -> VortexResult<ArrayRef> {
+    let signs_u8 = rotation.export_inverse_signs_u8();
+    let num_rounds = rotation.num_rounds();
+    let padded_dim = u32::try_from(rotation.padded_dim()).vortex_expect("padded_dim fits in u32");
+
+    let mut buf = BufferMut::<u8>::with_capacity(signs_u8.len());
+    buf.extend_from_slice(&signs_u8);
+    let prim = PrimitiveArray::new::<u8>(buf.freeze(), Validity::NonNullable);
+    let bitpacked = bitpack_encode(&prim, 1, None)?;
+
+    let fsl = FixedSizeListArray::try_new(
+        bitpacked.into_array(),
+        padded_dim,
+        Validity::NonNullable,
+        num_rounds,
+    )?;
+    Ok(fsl.into_array())
+}
diff --git a/vortex-tensor/src/encodings/turboquant/scheme/decompress.rs b/vortex-tensor/src/encodings/turboquant/scheme/decompress.rs
new file mode 100644
index 00000000000..2e92ced88e1
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/scheme/decompress.rs
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! TurboQuant decoding (dequantization) logic.
+//!
+//! Decompression produces unit-norm vectors. The original magnitudes are restored externally
+//! by the [`L2Denorm`](crate::scalar_fns::l2_denorm::L2Denorm) ScalarFnArray wrapper.
+
+use num_traits::Float;
+use num_traits::FromPrimitive;
+use vortex_array::Array;
+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::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::Nullability;
+use vortex_array::match_each_float_ptype;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexResult;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::TurboQuantArrayExt;
+use crate::encodings::turboquant::array::rotation::RotationMatrix;
+use crate::encodings::turboquant::compute::float_from_f32;
+use crate::vector::AnyVector;
+
+/// Decompress a `TurboQuantArray` into a unit-norm [`Vector`] extension array.
+///
+/// The returned array is an [`ExtensionArray`] with the (non-nullable) Vector dtype wrapping a
+/// `FixedSizeListArray` of the original vector element type. Each vector has unit L2 norm; the
+/// original magnitudes are restored by the [`L2Denorm`](crate::scalar_fns::l2_denorm::L2Denorm)
+/// ScalarFnArray wrapper.
+///
+/// [`Vector`]: crate::vector::Vector
+pub fn execute_decompress(
+    array: Array<TurboQuant>,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let dim = array.dimension() as usize;
+    let padded_dim = array.padded_dim() as usize;
+    let num_rows = array.len();
+    let ext_dtype = array.dtype().as_extension().clone();
+    let element_ptype = ext_dtype.metadata::<AnyVector>().element_ptype();
+
+    if num_rows == 0 {
+        match_each_float_ptype!(element_ptype, |T| {
+            let elements = PrimitiveArray::empty::<T>(Nullability::NonNullable);
+            let fsl = FixedSizeListArray::try_new(
+                elements.into_array(),
+                array.dimension(),
+                Validity::NonNullable,
+                0,
+            )?;
+
+            return Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array());
+        })
+    }
+
+    // Read stored centroids (always f32).
+    let centroids_prim = array.centroids().clone().execute::<PrimitiveArray>(ctx)?;
+    let centroids = centroids_prim.as_slice::<f32>();
+
+    // The rotation signs are stored as a FixedSizeListArray wrapping bitpacked u8 values.
+    // We unwrap to the flat elements, then FastLanes SIMD-unpacks the 1-bit values into u8 0/1.
+    // These are expanded to u32 XOR masks once (amortized over all rows), enabling branchless
+    // XOR-based sign application in the per-row structured-rotation hot loop.
+    let num_rounds = array.num_rounds() as usize;
+    let signs_fsl = array
+        .rotation_signs()
+        .clone()
+        .execute::<FixedSizeListArray>(ctx)?;
+    let signs_prim = signs_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let rotation = RotationMatrix::from_u8_slice(signs_prim.as_slice::<u8>(), dim, num_rounds)?;
+
+    // Unpack codes from FixedSizeListArray -> flat u8 elements.
+    let codes_fsl = array.codes().clone().execute::<FixedSizeListArray>(ctx)?;
+    let codes_prim = codes_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let indices = codes_prim.as_slice::<u8>();
+
+    // MSE decode: dequantize (f32) -> inverse rotate (f32) -> cast to T.
+    // The rotation and centroid lookup always happen in f32. The final output is cast to the
+    // Vector's element type to match the original storage dtype. No norm scaling is applied here;
+    // that is handled by the external L2Denorm wrapper.
+    match_each_float_ptype!(element_ptype, |T| {
+        decompress_typed::<T>(centroids, &rotation, indices, dim, padded_dim, num_rows).and_then(
+            |elements| {
+                let fsl = FixedSizeListArray::try_new(
+                    elements.into_array(),
+                    array.dimension(),
+                    Validity::NonNullable,
+                    num_rows,
+                )?;
+                Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array())
+            },
+        )
+    })
+}
+
+/// Typed decompress: dequantizes in f32 and produces unit-norm output as `T`.
+fn decompress_typed<T: NativePType + Float + FromPrimitive>(
+    centroids: &[f32],
+    rotation: &RotationMatrix,
+    indices: &[u8],
+    dim: usize,
+    padded_dim: usize,
+    num_rows: usize,
+) -> VortexResult<PrimitiveArray> {
+    let mut output = BufferMut::<T>::with_capacity(num_rows * dim);
+    let mut dequantized = vec![0.0f32; padded_dim];
+    let mut unrotated = vec![0.0f32; padded_dim];
+
+    for row in 0..num_rows {
+        let row_indices = &indices[row * padded_dim..(row + 1) * padded_dim];
+
+        for idx in 0..padded_dim {
+            dequantized[idx] = centroids[row_indices[idx] as usize];
+        }
+
+        rotation.inverse_rotate(&dequantized, &mut unrotated);
+
+        for idx in 0..dim {
+            output.push(float_from_f32::<T>(unrotated[idx]));
+        }
+    }
+
+    Ok(PrimitiveArray::new::<T>(
+        output.freeze(),
+        Validity::NonNullable,
+    ))
+}
diff --git a/vortex-tensor/src/encodings/turboquant/scheme/mod.rs b/vortex-tensor/src/encodings/turboquant/scheme/mod.rs
new file mode 100644
index 00000000000..c3beb2a6993
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/scheme/mod.rs
@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! TurboQuant compression scheme and decompression.
+//!
+//! The scheme first normalizes the input via [`normalize_as_l2_denorm`], then encodes the
+//! normalized child via [`turboquant_encode`]. The result is:
+//!
+//! ```text
+//! ScalarFnArray(L2Denorm, [TurboQuantArray, norms])
+//! ```
+//!
+//! [`normalize_as_l2_denorm`]: crate::scalar_fns::l2_denorm::normalize_as_l2_denorm
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Extension;
+use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
+use vortex_compressor::CascadingCompressor;
+use vortex_compressor::ctx::CompressorContext;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::scheme::Scheme;
+use vortex_compressor::stats::ArrayAndStats;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::TurboQuantConfig;
+use crate::encodings::turboquant::turboquant_encode_unchecked;
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+use crate::scalar_fns::l2_denorm::normalize_as_l2_denorm;
+
+pub(super) mod compress;
+pub(super) mod decompress;
+
+/// 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;
+        };
+
+        TurboQuant::validate_dtype(ext.dtype()).is_ok()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> CompressionEstimate {
+        let len = data.array().len();
+        let dtype = data.array().dtype();
+
+        let vector_metadata =
+            TurboQuant::validate_dtype(dtype).vortex_expect("invalid dtype for TurboQuant");
+        let element_ptype = vector_metadata.element_ptype();
+        let bit_width: u8 = element_ptype
+            .bit_width()
+            .try_into()
+            .vortex_expect("invalid bit width for TurboQuant");
+        let dimension = vector_metadata.dimensions();
+
+        CompressionEstimate::Ratio(estimate_compression_ratio(bit_width, dimension, len))
+    }
+
+    fn compress(
+        &self,
+        compressor: &CascadingCompressor,
+        data: &mut ArrayAndStats,
+        _ctx: CompressorContext,
+    ) -> VortexResult<ArrayRef> {
+        let ext_array = data
+            .array()
+            .as_opt::<Extension>()
+            .vortex_expect("expected an extension array");
+
+        let mut ctx = compressor.execution_ctx();
+
+        // Normalize first: produces L2Denorm(normalized_vectors, norms).
+        let l2_denorm =
+            normalize_as_l2_denorm(&ApproxOptions::Exact, ext_array.as_ref().clone(), &mut ctx)?;
+        let normalized = l2_denorm.child_at(0).clone();
+        let norms = l2_denorm.child_at(1).clone();
+        let num_rows = l2_denorm.len();
+
+        // Quantize the normalized child.
+        let normalized_ext = normalized
+            .as_opt::<Extension>()
+            .vortex_expect("normalized child should be an Extension array");
+        let config = TurboQuantConfig::default();
+        // SAFETY: We just normalized the input via `normalize_as_l2_denorm`, so all rows are
+        // guaranteed to be unit-norm (or zero for originally-null rows).
+        let tq = unsafe { turboquant_encode_unchecked(normalized_ext, &config, &mut 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(&ApproxOptions::Exact, tq, norms, num_rows) }?
+                .into_array(),
+        )
+    }
+}
+
+/// Estimate the compression ratio for TurboQuant MSE encoding with the default config.
+fn estimate_compression_ratio(bits_per_element: u8, dimensions: u32, num_vectors: usize) -> f64 {
+    let config = TurboQuantConfig::default();
+    let padded_dim = dimensions.next_power_of_two() as usize;
+
+    // Per-vector: MSE codes per padded coordinate, plus one f32 norm.
+    let compressed_bits_per_vector = 32 // norm is always f32
+        + (config.bit_width as usize) * padded_dim; // MSE codes
+
+    // Shared overhead: codebook centroids (2^bit_width f32 values) and
+    // rotation signs (num_rounds * padded_dim bits).
+    let num_centroids = 1usize << config.bit_width;
+    debug_assert!(num_centroids <= TurboQuant::MAX_CENTROIDS);
+    let overhead_bits = num_centroids * 32 // centroids are always f32
+        + config.num_rounds as usize * padded_dim; // rotation signs, 1 bit each
+
+    let compressed_size_bits = compressed_bits_per_vector * num_vectors + overhead_bits;
+
+    let uncompressed_size_bits = bits_per_element as usize * dimensions as usize * num_vectors;
+    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 ~4-6x.
+    /// f32 input at 1024-d (no padding) should give higher ratio since no waste.
+    #[rstest]
+    #[case::f32_768d(32, 768, 1000, 2.5, 4.0)]
+    #[case::f32_1024d(32, 1024, 1000, 3.5, 5.0)]
+    #[case::f32_1536d(32, 1536, 1000, 2.5, 4.0)]
+    #[case::f32_128d(32, 128, 1000, 3.0, 5.0)]
+    #[case::f64_768d(64, 768, 1000, 5.0, 7.0)]
+    #[case::f16_768d(16, 768, 1000, 1.2, 2.0)]
+    fn compression_ratio_in_expected_range(
+        #[case] bits_per_element: u8,
+        #[case] dim: u32,
+        #[case] num_vectors: usize,
+        #[case] min_ratio: f64,
+        #[case] max_ratio: f64,
+    ) {
+        let ratio = estimate_compression_ratio(bits_per_element, dim, num_vectors);
+        assert!(
+            ratio > min_ratio && ratio < max_ratio,
+            "ratio {ratio:.2} not in [{min_ratio}, {max_ratio}] for \
+             {bits_per_element}-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] bits_per_element: u8,
+        #[case] dim: u32,
+        #[case] num_vectors: usize,
+    ) {
+        let ratio = estimate_compression_ratio(bits_per_element, dim, num_vectors);
+        assert!(
+            ratio > 1.0,
+            "ratio {ratio:.4} <= 1.0 for {bits_per_element}-bit, dim={dim}, n={num_vectors}"
+        );
+    }
+
+    /// 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.rs b/vortex-tensor/src/encodings/turboquant/tests.rs
new file mode 100644
index 00000000000..8e633469a3d
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/tests.rs
@@ -0,0 +1,1260 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::LazyLock;
+
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use rand_distr::Distribution;
+use rand_distr::Normal;
+use rstest::rstest;
+use vortex_array::ArrayRef;
+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::arrays::ScalarFnVTable;
+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::dtype::extension::ExtDType;
+use vortex_array::extension::EmptyMetadata;
+use vortex_array::session::ArraySession;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::encodings::turboquant::TurboQuantArrayExt;
+use crate::encodings::turboquant::TurboQuantConfig;
+use crate::encodings::turboquant::array::rotation::RotationMatrix;
+use crate::encodings::turboquant::turboquant_encode;
+use crate::encodings::turboquant::turboquant_encode_unchecked;
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+use crate::scalar_fns::l2_denorm::normalize_as_l2_denorm;
+use crate::scalar_fns::l2_norm::L2Norm;
+use crate::vector::Vector;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+/// Create a FixedSizeListArray of random f32 vectors (i.i.d. standard normal) 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 (i.i.d. standard normal).
+fn make_fsl(num_rows: usize, dim: usize, seed: u64) -> 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::NonNullable,
+        num_rows,
+    )
+    .unwrap()
+}
+
+/// Wrap a `FixedSizeListArray` in a `Vector` extension array.
+fn make_vector_ext(fsl: &FixedSizeListArray) -> ExtensionArray {
+    let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())
+        .unwrap()
+        .erased();
+    ExtensionArray::new(ext_dtype, fsl.clone().into_array())
+}
+
+/// Full encode pipeline: normalize, then TQ-encode, then wrap in L2Denorm.
+///
+/// This mirrors what `TurboQuantScheme::compress()` does: normalize via `normalize_as_l2_denorm`,
+/// then quantize the normalized child via `turboquant_encode_unchecked`, then reassemble.
+fn normalize_and_encode(
+    ext: &ExtensionArray,
+    config: &TurboQuantConfig,
+    ctx: &mut vortex_array::ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let l2_denorm = normalize_as_l2_denorm(&ApproxOptions::Exact, ext.as_ref().clone(), 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("normalized child should be an Extension array");
+    // SAFETY: We just normalized the input via `normalize_as_l2_denorm`.
+    let tq = unsafe { turboquant_encode_unchecked(normalized_ext, config, ctx)? };
+
+    Ok(
+        unsafe { L2Denorm::new_array_unchecked(&ApproxOptions::Exact, tq, norms, num_rows) }?
+            .into_array(),
+    )
+}
+
+/// Unwrap an L2Denorm ScalarFnArray into its TQ child and norms child.
+fn unwrap_l2denorm(encoded: &ArrayRef) -> (ArrayRef, ArrayRef) {
+    let sfn = encoded
+        .as_opt::<ScalarFnVTable>()
+        .expect("expected ScalarFnArray");
+    let tq_child = sfn.child_at(0).clone();
+    let norms_child = sfn.child_at(1).clone();
+    (tq_child, norms_child)
+}
+
+fn theoretical_mse_bound(bit_width: u8) -> f32 {
+    let sqrt3_pi_over_2 = (3.0f32).sqrt() * std::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 ext = make_vector_ext(fsl);
+    let encoded = normalize_and_encode(&ext, 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))
+}
+
+fn empty_turboquant_parts(
+    dim: u32,
+) -> VortexResult<(vortex_array::dtype::DType, ArrayRef, ArrayRef, ArrayRef)> {
+    let fsl = make_fsl(0, dim as usize, 42);
+    let ext = make_vector_ext(&fsl);
+
+    let codes = FixedSizeListArray::try_new(
+        PrimitiveArray::empty::<u8>(Nullability::NonNullable).into_array(),
+        dim,
+        Validity::NonNullable,
+        0,
+    )?
+    .into_array();
+    let centroids = PrimitiveArray::empty::<f32>(Nullability::NonNullable).into_array();
+    let rotation_signs = FixedSizeListArray::try_new(
+        PrimitiveArray::empty::<u8>(Nullability::NonNullable).into_array(),
+        dim,
+        Validity::NonNullable,
+        0,
+    )?
+    .into_array();
+
+    // TQ dtype is non-nullable.
+    Ok((
+        ext.dtype().as_nonnullable(),
+        codes,
+        centroids,
+        rotation_signs,
+    ))
+}
+
+fn normalized_child(
+    ext: &ExtensionArray,
+    ctx: &mut vortex_array::ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    Ok(
+        normalize_as_l2_denorm(&ApproxOptions::Exact, ext.as_ref().clone(), ctx)?
+            .child_at(0)
+            .clone(),
+    )
+}
+
+// -----------------------------------------------------------------------
+// Roundtrip tests
+// -----------------------------------------------------------------------
+
+#[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: Some(123),
+        num_rounds: 3,
+    };
+    let (original, decoded) = encode_decode(&fsl, &config)?;
+    assert_eq!(decoded.len(), original.len());
+    Ok(())
+}
+
+#[test]
+fn empty_try_new_rejects_invalid_centroids_dtype() -> VortexResult<()> {
+    let (dtype, codes, _centroids, rotation_signs) = empty_turboquant_parts(128)?;
+    let wrong_centroids = PrimitiveArray::empty::<f64>(Nullability::NonNullable).into_array();
+
+    let err = TurboQuant::try_new_array(dtype, codes, wrong_centroids, rotation_signs).unwrap_err();
+
+    assert!(
+        err.to_string()
+            .contains("centroids dtype must be non-nullable f32")
+    );
+    Ok(())
+}
+
+#[test]
+fn empty_try_new_rejects_invalid_rotation_signs_dtype() -> VortexResult<()> {
+    let (dtype, codes, centroids, _rotation_signs) = empty_turboquant_parts(128)?;
+    let wrong_rotation_signs = PrimitiveArray::empty::<u8>(Nullability::NonNullable).into_array();
+
+    let err = TurboQuant::try_new_array(dtype, codes, centroids, wrong_rotation_signs).unwrap_err();
+
+    assert!(
+        err.to_string()
+            .contains("rotation_signs dtype does not match")
+    );
+    Ok(())
+}
+
+// -----------------------------------------------------------------------
+// MSE quality tests
+// -----------------------------------------------------------------------
+
+#[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: Some(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: Some(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: Some(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: Some(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(())
+}
+
+// -----------------------------------------------------------------------
+// Edge cases
+// -----------------------------------------------------------------------
+
+#[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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_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 fsl = make_fsl_small(dim);
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 2,
+        seed: Some(0),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    assert!(turboquant_encode(ext.as_view(), &config, &mut ctx).is_err());
+}
+
+#[test]
+fn checked_encode_accepts_normalized_f16_input() -> VortexResult<()> {
+    let num_rows = 10;
+    let dim = 128;
+    let mut rng = StdRng::seed_from_u64(99);
+    let normal = Normal::new(0.0f32, 1.0).unwrap();
+
+    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()
+            .expect("somehow got dimension greater than u32::MAX"),
+        Validity::NonNullable,
+        num_rows,
+    )?;
+
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(42),
+        num_rounds: 3,
+    };
+
+    let mut ctx = SESSION.create_execution_ctx();
+    let normalized = normalized_child(&ext, &mut ctx)?;
+    let normalized_ext = normalized
+        .as_opt::<Extension>()
+        .vortex_expect("normalized child should be an Extension array");
+
+    let encoded = turboquant_encode(normalized_ext, &config, &mut ctx)?;
+    assert_eq!(encoded.len(), num_rows);
+    Ok(())
+}
+
+fn make_fsl_small(dim: usize) -> FixedSizeListArray {
+    let mut buf = BufferMut::<f32>::with_capacity(dim);
+    for i in 0..dim {
+        buf.push(i as f32 + 1.0);
+    }
+    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::NonNullable,
+        1,
+    )
+    .unwrap()
+}
+
+/// Verify that all-zero vectors roundtrip correctly (norm == 0 branch).
+#[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()
+            .expect("somehow got dimension greater than u32::MAX"),
+        Validity::NonNullable,
+        num_rows,
+    )?;
+
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(42),
+        num_rounds: 3,
+    };
+    let (original, decoded) = encode_decode(&fsl, &config)?;
+    // All-zero vectors should decode to all-zero (norm=0 -> 0 * anything = 0).
+    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(())
+}
+
+/// Verify that f64 input is accepted and encoded (converted to f32 internally).
+#[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).unwrap();
+
+    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()
+            .expect("somehow got dimension greater than u32::MAX"),
+        Validity::NonNullable,
+        num_rows,
+    )?;
+
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(42),
+        num_rounds: 3,
+    };
+    // Verify encoding succeeds with f64 input (f64->f32 conversion).
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, norms_child) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+    assert_eq!(norms_child.len(), num_rows);
+    assert_eq!(tq.dimension() as usize, dim);
+    Ok(())
+}
+
+/// Verify that f16 input is accepted and encoded (upcast to f32 internally).
+#[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).unwrap();
+
+    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()
+            .expect("somehow got dimension greater than u32::MAX"),
+        Validity::NonNullable,
+        num_rows,
+    )?;
+
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(42),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, norms_child) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+    assert_eq!(norms_child.len(), num_rows);
+    assert_eq!(tq.dimension() as usize, dim);
+
+    // Verify roundtrip: decode and check reconstruction is reasonable.
+    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(())
+}
+
+// -----------------------------------------------------------------------
+// Verification tests for stored metadata
+// -----------------------------------------------------------------------
+
+/// Verify that the centroids stored in the array match what `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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, _norms) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+
+    let mut ctx = SESSION.create_execution_ctx();
+    let stored_centroids_prim = tq.centroids().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let stored = stored_centroids_prim.as_slice::<f32>();
+
+    let padded_dim = tq.padded_dim();
+    let computed = crate::encodings::turboquant::array::centroids::get_centroids(padded_dim, 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 stored rotation signs produce identical decode to seed-based decode.
+#[test]
+fn stored_rotation_signs_produce_correct_decode() -> VortexResult<()> {
+    let fsl = make_fsl(20, 128, 42);
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(123),
+        num_rounds: 4,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, _norms) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+
+    // Decode via the full L2Denorm path (TQ decompress + norm scaling).
+    let mut ctx = SESSION.create_execution_ctx();
+    let decoded_ext = encoded.execute::<ExtensionArray>(&mut ctx)?;
+    let decoded_fsl = decoded_ext
+        .storage_array()
+        .clone()
+        .execute::<FixedSizeListArray>(&mut ctx)?;
+    let decoded = decoded_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(&mut ctx)?;
+    let decoded_slice = decoded.as_slice::<f32>();
+
+    // Verify stored signs match seed-derived signs.
+    let rot_from_seed = RotationMatrix::try_new(123, 128, 4)?;
+    let expected_u8 = rot_from_seed.export_inverse_signs_u8();
+    let stored_signs_fsl = tq
+        .rotation_signs()
+        .clone()
+        .execute::<FixedSizeListArray>(&mut ctx)?;
+    let stored_signs = stored_signs_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(&mut ctx)?;
+    let stored_u8 = stored_signs.as_slice::<u8>();
+
+    assert_eq!(expected_u8.len(), stored_u8.len());
+    for i in 0..expected_u8.len() {
+        assert_eq!(expected_u8[i], stored_u8[i], "Sign mismatch at index {i}");
+    }
+
+    // Also verify decode output is non-empty and has expected size.
+    assert_eq!(decoded_slice.len(), 20 * 128);
+    Ok(())
+}
+
+// -----------------------------------------------------------------------
+// Compute pushdown tests
+// -----------------------------------------------------------------------
+
+#[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: Some(123),
+        num_rounds: 4,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_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: Some(123),
+        num_rounds: 2,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_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.scalar_at(i)?;
+        let actual = encoded.scalar_at(i)?;
+        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: Some(123),
+        num_rounds: 5,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (_tq_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
+        );
+    }
+    Ok(())
+}
+
+#[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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, norms_child) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+
+    // Compute exact cosine similarity from original data.
+    let input_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let input_f32 = input_prim.as_slice::<f32>();
+
+    // Read quantized codes, norms, and centroids for approximate computation.
+    let mut ctx = SESSION.create_execution_ctx();
+    let pd = tq.padded_dim() as usize;
+    let norms_prim = norms_child.execute::<PrimitiveArray>(&mut ctx)?;
+    let norms = norms_prim.as_slice::<f32>();
+    let codes_fsl = tq.codes().clone().execute::<FixedSizeListArray>(&mut ctx)?;
+    let codes_prim = codes_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(&mut ctx)?;
+    let all_codes = codes_prim.as_slice::<u8>();
+    let centroids_prim = tq.centroids().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let centroid_vals = centroids_prim.as_slice::<f32>();
+
+    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);
+
+        // Approximate cosine similarity in quantized domain.
+        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>()
+        };
+
+        // At 4-bit, the theoretical MSE bound per coordinate is ~0.0106 (Theorem 1). For cosine
+        // similarity (bounded [-1, 1]), the error is bounded roughly by 2*sqrt(MSE) ~ 0.2. We use
+        // 0.15 as a tighter empirical bound.
+        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.
+///
+/// NOTE: The MSE quantizer (TurboQuant_mse) has inherent **multiplicative bias** for inner
+/// products — the quantized dot product systematically over- or under-estimates the true value.
+/// This is a fundamental property: the paper's `TurboQuant_prod` variant adds QJL specifically
+/// to debias inner products, but we only implement the MSE-only variant.
+///
+/// Even at 8-bit (near-lossless reconstruction, MSE ~4e-5), the quantized-domain dot product
+/// can have ~10-15% relative error due to this bias. This tolerance is therefore intentionally
+/// loose — we're testing that the approximation is in the right ballpark, not that it's precise.
+///
+/// TODO(connor): Revisit these tolerances when we have TurboQuant_prod (QJL debiasing).
+#[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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, norms_child) = unwrap_l2denorm(&encoded);
+    let tq = tq_child.as_opt::<TurboQuant>().unwrap();
+
+    let input_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let input_f32 = input_prim.as_slice::<f32>();
+
+    let mut ctx = SESSION.create_execution_ctx();
+    let pd = tq.padded_dim() as usize;
+    let norms_prim = norms_child.execute::<PrimitiveArray>(&mut ctx)?;
+    let norms = norms_prim.as_slice::<f32>();
+    let codes_fsl = tq.codes().clone().execute::<FixedSizeListArray>(&mut ctx)?;
+    let codes_prim = codes_fsl
+        .elements()
+        .clone()
+        .execute::<PrimitiveArray>(&mut ctx)?;
+    let all_codes = codes_prim.as_slice::<u8>();
+    let centroids_prim = tq.centroids().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let centroid_vals = centroids_prim.as_slice::<f32>();
+
+    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;
+
+        // See doc comment above: 15% relative error is expected due to MSE quantizer bias.
+        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(())
+}
+
+/// Roundtrip at large embedding dimensions to validate padding and SRHT at common sizes.
+///
+/// NOTE: The theoretical MSE bound (Theorem 1) is proved for Haar-distributed random orthogonal
+/// matrices, not SRHT. The SRHT is a practical O(d log d) approximation that doesn't exactly
+/// satisfy the Haar assumption, so empirical MSE can slightly exceed the theoretical bound. We
+/// use a 2x multiplier to account for this gap.
+///
+/// The 1024-d case uses 5-bit instead of 4-bit because at 4-bit the SRHT approximation error
+/// at d=1024 pushes MSE ~20% above the 1x theoretical bound (0.0127 vs bound 0.0106).
+///
+/// TODO(connor): Revisit after Stage 2 block decomposition — at d=768 with block_size=256,
+/// the per-block SRHT will be lower-dimensional and may have different error characteristics.
+#[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: Some(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 (see doc comment above).
+    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 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: Some(123),
+        num_rounds: 2,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+
+    // The encoded TurboQuant array should claim a Vector extension dtype.
+    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(())
+}
+
+// -----------------------------------------------------------------------
+// Nullable vector tests
+// -----------------------------------------------------------------------
+
+/// Encode a nullable Vector array and verify roundtrip preserves validity and non-null values.
+#[test]
+fn nullable_vectors_roundtrip() -> VortexResult<()> {
+    // Rows 2, 5, 7 are null.
+    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: Some(123),
+        num_rounds: 4,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+
+    assert_eq!(encoded.len(), 10);
+    assert!(encoded.dtype().is_nullable());
+
+    // Check validity of the encoded array.
+    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}"
+        );
+    }
+
+    // Decode and verify non-null rows have correct data.
+    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>();
+
+    // Original f32 elements for non-null row comparison.
+    let orig_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let orig_f32 = orig_prim.as_slice::<f32>();
+
+    // Non-null rows should have reasonable reconstruction (within MSE bounds).
+    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();
+        // 3-bit normalized MSE should be well under the theoretical bound.
+        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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (_tq_child, norms_child) = unwrap_l2denorm(&encoded);
+
+    let norms_validity = norms_child.validity()?;
+    for i in 0..5 {
+        let expected = i % 2 == 0; // rows 0, 2, 4 are valid
+        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<()> {
+    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: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+
+    // Compute L2Norm on the encoded array.
+    let norm_sfn = L2Norm::try_new_array(&ApproxOptions::Exact, encoded, 5)?;
+    let norms: PrimitiveArray = norm_sfn.into_array().execute(&mut ctx)?;
+
+    // Null rows should have null norms, valid rows should have correct norms.
+    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)?, "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)?, "row {row} should be null");
+        }
+    }
+    Ok(())
+}
+
+/// Verify that slicing a nullable TurboQuant array preserves validity.
+#[test]
+fn nullable_slice_preserves_validity() -> VortexResult<()> {
+    // Rows 2, 5, 7 are null.
+    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: Some(123),
+        num_rounds: 2,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+
+    // Slice rows 1..6 -> [true, false, true, true, false].
+    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(())
+}
+
+// -----------------------------------------------------------------------
+// Serde roundtrip tests
+// -----------------------------------------------------------------------
+
+/// Verify that a TurboQuant array (extracted from the L2Denorm wrapper) survives
+/// serialize/deserialize.
+///
+/// TODO(connor): ScalarFnArray cannot be serialized yet, so we test the TQ child directly.
+#[test]
+fn serde_roundtrip() -> VortexResult<()> {
+    use vortex_array::ArrayContext;
+    use vortex_array::ArrayEq;
+    use vortex_array::Precision;
+    use vortex_array::serde::SerializeOptions;
+    use vortex_array::serde::SerializedArray;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_fastlanes::BitPacked;
+    use vortex_session::registry::ReadContext;
+
+    let fsl = make_fsl(20, 128, 42);
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 3,
+        seed: Some(123),
+        num_rounds: 5,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    let (tq_child, _norms) = unwrap_l2denorm(&encoded);
+
+    let dtype = tq_child.dtype().clone();
+    let len = tq_child.len();
+
+    // Serialize the TQ child.
+    let array_ctx = ArrayContext::empty();
+    let serde_session = VortexSession::empty().with::<ArraySession>();
+    serde_session.arrays().register(TurboQuant);
+    let serialized =
+        tq_child.serialize(&array_ctx, &serde_session, &SerializeOptions::default())?;
+
+    let mut concat = ByteBufferMut::empty();
+    for buf in serialized {
+        concat.extend_from_slice(buf.as_ref());
+    }
+
+    // Deserialize. The session needs TurboQuant and BitPacked (for rotation signs) registered.
+    serde_session.arrays().register(BitPacked);
+
+    let parts = SerializedArray::try_from(concat.freeze())?;
+    let decoded = parts.decode(
+        &dtype,
+        len,
+        &ReadContext::new(array_ctx.to_ids()),
+        &serde_session,
+    )?;
+
+    assert!(
+        decoded.array_eq(&tq_child, Precision::Value),
+        "serde roundtrip did not preserve array equality"
+    );
+    Ok(())
+}
+
+/// Verify that a degenerate (empty) TurboQuant array survives serialize/deserialize.
+#[test]
+fn serde_roundtrip_empty() -> VortexResult<()> {
+    use vortex_array::ArrayContext;
+    use vortex_array::ArrayEq;
+    use vortex_array::Precision;
+    use vortex_array::serde::SerializeOptions;
+    use vortex_array::serde::SerializedArray;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_buffer::ByteBufferMut;
+    use vortex_fastlanes::BitPacked;
+    use vortex_session::registry::ReadContext;
+
+    let fsl = make_fsl(0, 128, 42);
+    let ext = make_vector_ext(&fsl);
+    let config = TurboQuantConfig {
+        bit_width: 2,
+        seed: Some(123),
+        num_rounds: 3,
+    };
+    let mut ctx = SESSION.create_execution_ctx();
+    let encoded = normalize_and_encode(&ext, &config, &mut ctx)?;
+    assert_eq!(encoded.len(), 0);
+    let (tq_child, _norms) = unwrap_l2denorm(&encoded);
+
+    let dtype = tq_child.dtype().clone();
+    let len = tq_child.len();
+
+    let serde_session = VortexSession::empty().with::<ArraySession>();
+    serde_session.arrays().register(TurboQuant);
+    serde_session.arrays().register(BitPacked);
+
+    let array_ctx = ArrayContext::empty();
+    let serialized =
+        tq_child.serialize(&array_ctx, &serde_session, &SerializeOptions::default())?;
+
+    let mut concat = ByteBufferMut::empty();
+    for buf in serialized {
+        concat.extend_from_slice(buf.as_ref());
+    }
+
+    let parts = SerializedArray::try_from(concat.freeze())?;
+    let decoded = parts.decode(
+        &dtype,
+        len,
+        &ReadContext::new(array_ctx.to_ids()),
+        &serde_session,
+    )?;
+
+    assert!(
+        decoded.array_eq(&tq_child, Precision::Value),
+        "serde roundtrip did not preserve array equality"
+    );
+    Ok(())
+}
diff --git a/vortex-tensor/src/encodings/turboquant/vtable.rs b/vortex-tensor/src/encodings/turboquant/vtable.rs
new file mode 100644
index 00000000000..b673dea6ba5
--- /dev/null
+++ b/vortex-tensor/src/encodings/turboquant/vtable.rs
@@ -0,0 +1,382 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! VTable implementation for TurboQuant encoding.
+
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use prost::Message;
+use vortex_array::Array;
+use vortex_array::ArrayEq;
+use vortex_array::ArrayHash;
+use vortex_array::ArrayId;
+use vortex_array::ArrayParts;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+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::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::serde::ArrayChildren;
+use vortex_array::validity::Validity;
+use vortex_array::vtable::VTable;
+use vortex_array::vtable::ValidityVTable;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+use vortex_error::vortex_err;
+use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
+
+use crate::encodings::turboquant::TurboQuantData;
+use crate::encodings::turboquant::array::slots::Slot;
+use crate::encodings::turboquant::compute::rules::PARENT_KERNELS;
+use crate::encodings::turboquant::compute::rules::RULES;
+use crate::encodings::turboquant::metadata::TurboQuantMetadata;
+use crate::encodings::turboquant::scheme::decompress::execute_decompress;
+use crate::vector::AnyVector;
+use crate::vector::VectorMatcherMetadata;
+
+/// Encoding marker type for TurboQuant.
+#[derive(Clone, Debug)]
+pub struct TurboQuant;
+
+impl TurboQuant {
+    pub const ID: ArrayId = ArrayId::new_ref("vortex.turboquant");
+
+    /// 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 << (Self::MAX_BIT_WIDTH as usize);
+
+    /// Validates that `dtype` is a [`Vector`](crate::vector::Vector) extension type with
+    /// dimension >= [`MIN_DIMENSION`](Self::MIN_DIMENSION).
+    ///
+    /// Returns the validated vector metadata on success.
+    pub fn validate_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 >= Self::MIN_DIMENSION,
+            "TurboQuant requires dimension >= {}, got {dimensions}",
+            Self::MIN_DIMENSION
+        );
+
+        Ok(vector_metadata)
+    }
+
+    /// Creates a new [`TurboQuantArray`].
+    ///
+    /// The `dtype` must be a non-nullable [`Vector`](crate::vector::Vector) extension type.
+    /// Nullability is handled externally by the [`L2Denorm`](crate::scalar_fns::l2_denorm::L2Denorm)
+    /// ScalarFnArray wrapper.
+    ///
+    /// Internally calls [`TurboQuantData::validate`] and [`TurboQuantData::try_new`], then
+    /// delegates to [`new_array_unchecked`](Self::new_array_unchecked).
+    pub fn try_new_array(
+        dtype: DType,
+        codes: ArrayRef,
+        centroids: ArrayRef,
+        rotation_signs: ArrayRef,
+    ) -> VortexResult<TurboQuantArray> {
+        TurboQuantData::validate(&dtype, &codes, &centroids, &rotation_signs)?;
+
+        Ok(unsafe { Self::new_array_unchecked(dtype, codes, centroids, rotation_signs) })
+    }
+
+    /// Creates a new [`TurboQuantArray`] without validation.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure all invariants required by [`TurboQuantData::validate`] hold:
+    ///
+    /// - `dtype` is a non-nullable [`Vector`](crate::vector::Vector) extension type with
+    ///   dimension >= [`MIN_DIMENSION`](Self::MIN_DIMENSION).
+    /// - `codes` is a non-nullable `FixedSizeList<u8>` with `list_size == padded_dim`.
+    /// - `centroids` is a non-nullable `Primitive<f32>` with a power-of-2 length in
+    ///   `[2, MAX_CENTROIDS]` (or empty for degenerate arrays).
+    /// - `rotation_signs` is a non-nullable `FixedSizeList<u8>` with `list_size == padded_dim`.
+    ///
+    /// Violating these invariants may produce incorrect results during decompression or panics
+    /// during array access.
+    pub unsafe fn new_array_unchecked(
+        dtype: DType,
+        codes: ArrayRef,
+        centroids: ArrayRef,
+        rotation_signs: ArrayRef,
+    ) -> TurboQuantArray {
+        #[cfg(debug_assertions)]
+        TurboQuantData::validate(&dtype, &codes, &centroids, &rotation_signs)
+            .vortex_expect("[DEBUG ASSERTION]: TurboQuantData arrays are invalid");
+
+        let len = codes.len();
+
+        let dimension = dtype
+            .as_extension_opt()
+            .vortex_expect("we validated the dtype")
+            .metadata_opt::<AnyVector>()
+            .vortex_expect("we validated that this is a vector")
+            .dimensions();
+
+        let bit_width = if centroids.is_empty() {
+            0
+        } else {
+            #[expect(
+                clippy::cast_possible_truncation,
+                reason = "bit_width is guaranteed <= 8"
+            )]
+            (centroids.len().trailing_zeros() as u8)
+        };
+
+        #[expect(
+            clippy::cast_possible_truncation,
+            reason = "num_rounds fits in u8 by the caller's invariants"
+        )]
+        let num_rounds = rotation_signs.len() as u8;
+
+        // SAFETY: The caller guarantees that dimension, bit_width, and num_rounds satisfy the
+        // invariants documented on `TurboQuantData::new_unchecked`.
+        let data = unsafe { TurboQuantData::new_unchecked(dimension, bit_width, num_rounds) };
+        let parts = ArrayParts::new(TurboQuant, dtype, len, data)
+            .with_slots(TurboQuantData::make_slots(codes, centroids, rotation_signs));
+
+        // SAFETY: The caller guarantees the parts are logically consistent.
+        unsafe { Array::from_parts_unchecked(parts) }
+    }
+}
+
+/// A [`TurboQuant`]-encoded Vortex array.
+pub type TurboQuantArray = Array<TurboQuant>;
+
+impl VTable for TurboQuant {
+    type ArrayData = TurboQuantData;
+    type OperationsVTable = TurboQuant;
+    type ValidityVTable = TurboQuant;
+
+    fn id(&self) -> ArrayId {
+        Self::ID
+    }
+
+    fn validate(
+        &self,
+        data: &Self::ArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure_eq!(
+            slots.len(),
+            Slot::COUNT,
+            "TurboQuantArray got incorrect amount of slots",
+        );
+
+        // Even if the array is degenerate (empty), the arrays still have to exist
+        // (they will be empty).
+        let codes = slots[Slot::Codes as usize]
+            .as_ref()
+            .ok_or_else(|| vortex_err!("TurboQuantArray missing codes slot"))?;
+        let centroids = slots[Slot::Centroids as usize]
+            .as_ref()
+            .ok_or_else(|| vortex_err!("TurboQuantArray missing centroids slot"))?;
+        let rotation_signs = slots[Slot::RotationSigns as usize]
+            .as_ref()
+            .ok_or_else(|| vortex_err!("TurboQuantArray missing rotation_signs slot"))?;
+
+        vortex_ensure_eq!(
+            codes.len(),
+            len,
+            "TurboQuant codes length does not match outer length",
+        );
+
+        TurboQuantData::validate(dtype, codes, centroids, rotation_signs)?;
+
+        vortex_ensure_eq!(data.dimension, Self::validate_dtype(dtype)?.dimensions());
+
+        let expected_bit_width = if centroids.is_empty() {
+            0
+        } else {
+            u8::try_from(centroids.len().trailing_zeros())
+                .map_err(|_| vortex_err!("centroids bit_width does not fit in u8"))?
+        };
+        vortex_ensure_eq!(
+            data.bit_width,
+            expected_bit_width,
+            "TurboQuant bit_width does not match centroids slot",
+        );
+
+        // Verify num_rounds matches the rotation_signs FSL length.
+        let expected_num_rounds = u8::try_from(rotation_signs.len())
+            .map_err(|_| vortex_err!("rotation_signs num_rounds does not fit in u8"))?;
+        vortex_ensure_eq!(
+            data.num_rounds,
+            expected_num_rounds,
+            "TurboQuant num_rounds does not match rotation_signs slot",
+        );
+
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<Self>, idx: usize) -> BufferHandle {
+        vortex_panic!("TurboQuantArray buffer index {idx} out of bounds")
+    }
+
+    fn buffer_name(_array: ArrayView<Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(
+            TurboQuantMetadata::new(array.bit_width, array.num_rounds).encode_to_vec(),
+        ))
+    }
+
+    fn deserialize(
+        &self,
+        dtype: &DType,
+        len: usize,
+        metadata: &[u8],
+        _buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        let metadata = TurboQuantMetadata::decode(metadata)?;
+        let bit_width = metadata.bit_width()?;
+        let num_rounds = metadata.num_rounds()?;
+
+        // bit_width == 0 and num_rounds == 0 are only valid for degenerate (empty) arrays.
+        vortex_ensure!(
+            bit_width > 0 || len == 0,
+            "bit_width == 0 is only valid for empty arrays, got len={len}"
+        );
+        vortex_ensure!(
+            num_rounds > 0 || len == 0,
+            "num_rounds == 0 is only valid for empty arrays, got len={len}"
+        );
+
+        // Validate and derive dimension from the Vector extension dtype.
+        let vector_metadata = TurboQuant::validate_dtype(dtype)?;
+        let dimensions = vector_metadata.dimensions();
+
+        // TurboQuant arrays are always non-nullable.
+        vortex_ensure!(
+            !dtype.is_nullable(),
+            "TurboQuant dtype must be non-nullable during deserialization"
+        );
+
+        let padded_dim = dimensions.next_power_of_two();
+
+        // Get the codes array (indices into the codebook). Codes are always non-nullable.
+        let codes_ptype = DType::Primitive(PType::U8, Nullability::NonNullable);
+        let codes_dtype =
+            DType::FixedSizeList(Arc::new(codes_ptype), padded_dim, Nullability::NonNullable);
+        let codes_array = children.get(0, &codes_dtype, len)?;
+
+        // Get the centroids array (codebook).
+        let num_centroids = if bit_width == 0 {
+            0 // A degenerate TQ array.
+        } else {
+            1usize << bit_width
+        };
+        let centroids_dtype = DType::Primitive(PType::F32, Nullability::NonNullable);
+        let centroids = children.get(1, &centroids_dtype, num_centroids)?;
+
+        // Get the rotation signs array (FixedSizeList<u8> with list_size = padded_dim).
+        let signs_len = if len == 0 { 0 } else { num_rounds as usize };
+        let signs_dtype = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            padded_dim,
+            Nullability::NonNullable,
+        );
+        let rotation_signs = children.get(2, &signs_dtype, signs_len)?;
+
+        Ok(ArrayParts::new(
+            TurboQuant,
+            dtype.clone(),
+            len,
+            TurboQuantData {
+                dimension: dimensions,
+                bit_width,
+                num_rounds,
+            },
+        )
+        .with_slots(TurboQuantData::make_slots(
+            codes_array,
+            centroids,
+            rotation_signs,
+        )))
+    }
+
+    fn slot_name(_array: ArrayView<Self>, idx: usize) -> String {
+        Slot::from_index(idx).name().to_string()
+    }
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(execute_decompress(array, ctx)?))
+    }
+
+    fn execute_parent(
+        array: ArrayView<Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        PARENT_KERNELS.execute(array, parent, child_idx, ctx)
+    }
+
+    fn reduce_parent(
+        array: ArrayView<Self>,
+        parent: &ArrayRef,
+        child_idx: usize,
+    ) -> VortexResult<Option<ArrayRef>> {
+        RULES.evaluate(array, parent, child_idx)
+    }
+}
+
+impl ValidityVTable<TurboQuant> for TurboQuant {
+    fn validity(_array: ArrayView<'_, TurboQuant>) -> VortexResult<Validity> {
+        // TurboQuant arrays are always non-nullable. This method is only called when the dtype is
+        // nullable, which should never happen for TQ arrays.
+        Ok(Validity::NonNullable)
+    }
+}
+
+impl ArrayHash for TurboQuantData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+        self.dimension.hash(state);
+        self.bit_width.hash(state);
+        self.num_rounds.hash(state);
+    }
+}
+
+impl ArrayEq for TurboQuantData {
+    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+        self.dimension == other.dimension
+            && self.bit_width == other.bit_width
+            && self.num_rounds == other.num_rounds
+    }
+}
diff --git a/vortex-tensor/src/fixed_shape/matcher.rs b/vortex-tensor/src/fixed_shape/matcher.rs
new file mode 100644
index 00000000000..5248ca6514b
--- /dev/null
+++ b/vortex-tensor/src/fixed_shape/matcher.rs
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::dtype::DType;
+use vortex_array::dtype::PType;
+use vortex_array::dtype::extension::ExtDTypeRef;
+use vortex_array::dtype::extension::Matcher;
+use vortex_error::VortexExpect;
+use vortex_error::vortex_panic;
+
+use crate::fixed_shape::FixedShapeTensor;
+use crate::fixed_shape::FixedShapeTensorMetadata;
+
+pub struct AnyFixedShapeTensor;
+
+/// Convenience metadata for fixed-shape tensors.
+///
+/// Fixed-shape tensors already store their logical metadata directly, but callers also often need
+/// the flattened storage list size and element primitive type from the storage dtype.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FixedShapeTensorMatcherMetadata<'a> {
+    /// The logical fixed-shape tensor metadata stored on the extension dtype.
+    metadata: &'a FixedShapeTensorMetadata,
+
+    /// The primitive element type of the tensor storage.
+    ///
+    /// Fixed-shape tensors currently require non-nullable primitive elements.
+    element_ptype: PType,
+
+    /// The flattened element count for each tensor row in storage order.
+    ///
+    /// This matches the `FixedSizeList` list size in the storage dtype, which is the product of
+    /// the logical shape dimensions.
+    flat_list_size: usize,
+}
+
+impl Matcher for AnyFixedShapeTensor {
+    type Match<'a> = FixedShapeTensorMatcherMetadata<'a>;
+
+    fn try_match<'a>(ext_dtype: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
+        if !ext_dtype.is::<FixedShapeTensor>() {
+            return None;
+        }
+
+        let metadata = ext_dtype
+            .metadata_opt::<FixedShapeTensor>()
+            .vortex_expect("`FixedShapeTensor` type somehow did not have metadata");
+
+        let DType::FixedSizeList(element_dtype, list_size, _) = ext_dtype.storage_dtype() else {
+            vortex_panic!(
+                "`FixedShapeTensor` type somehow did not have a `FixedSizeList` storage type"
+            )
+        };
+
+        assert!(
+            element_dtype.is_primitive(),
+            "element dtype must be primitive"
+        );
+        assert!(
+            !element_dtype.is_nullable(),
+            "element dtype must be non-nullable"
+        );
+
+        Some(FixedShapeTensorMatcherMetadata {
+            metadata,
+            element_ptype: element_dtype.as_ptype(),
+            flat_list_size: *list_size as usize,
+        })
+    }
+}
+
+impl FixedShapeTensorMatcherMetadata<'_> {
+    /// Returns the underlying fixed-shape tensor metadata.
+    pub fn metadata(&self) -> &FixedShapeTensorMetadata {
+        self.metadata
+    }
+
+    /// Returns the tensor element type.
+    pub fn element_ptype(&self) -> PType {
+        self.element_ptype
+    }
+
+    /// Returns the flattened element count for each tensor row.
+    pub fn list_size(&self) -> usize {
+        self.flat_list_size
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    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::*;
+    use crate::vector::Vector;
+
+    fn tensor_storage_dtype(element_ptype: PType, list_size: u32) -> DType {
+        DType::FixedSizeList(
+            Arc::new(DType::Primitive(element_ptype, Nullability::NonNullable)),
+            list_size,
+            Nullability::NonNullable,
+        )
+    }
+
+    #[test]
+    fn matches_fixed_shape_tensor_dtype_metadata() -> VortexResult<()> {
+        let ext_dtype = ExtDType::<FixedShapeTensor>::try_new(
+            FixedShapeTensorMetadata::new(vec![2, 3, 4]),
+            tensor_storage_dtype(PType::F32, 24),
+        )?
+        .erased();
+
+        let metadata = ext_dtype.metadata::<AnyFixedShapeTensor>();
+        assert_eq!(metadata.element_ptype(), PType::F32);
+        assert_eq!(metadata.list_size(), 24);
+        assert_eq!(metadata.metadata().logical_shape(), &[2, 3, 4]);
+        Ok(())
+    }
+
+    #[test]
+    fn does_not_match_vector() -> VortexResult<()> {
+        let ext_dtype =
+            ExtDType::<Vector>::try_new(EmptyMetadata, tensor_storage_dtype(PType::F32, 24))?
+                .erased();
+
+        assert!(ext_dtype.metadata_opt::<AnyFixedShapeTensor>().is_none());
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/fixed_shape/metadata.rs b/vortex-tensor/src/fixed_shape/metadata.rs
new file mode 100644
index 00000000000..264d18453c4
--- /dev/null
+++ b/vortex-tensor/src/fixed_shape/metadata.rs
@@ -0,0 +1,379 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt;
+
+use itertools::Either;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+/// Metadata for a `FixedShapeTensor` extension type.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FixedShapeTensorMetadata {
+    /// The logical shape of the tensor.
+    ///
+    /// `logical_shape[i]` is the size of the `i`-th logical dimension. When a `permutation` is
+    /// present, the physical shape (i.e., the row-major memory layout) is derived as
+    /// `physical_shape[permutation[i]] = logical_shape[i]`.
+    ///
+    /// May be empty (0D scalar tensor) or contain dimensions of size 0 (degenerate tensor).
+    logical_shape: Vec<usize>,
+
+    /// Optional names for each logical dimension. Each name corresponds to an entry in
+    /// `logical_shape`.
+    ///
+    /// If names exist, there must be an equal number of names to logical dimensions.
+    dim_names: Option<Vec<String>>,
+
+    /// The permutation of the tensor's dimensions. `permutation[i]` is the physical dimension
+    /// index that logical dimension `i` maps to.
+    ///
+    /// If this is `None`, then the logical and physical layouts are identical, equivalent to
+    /// the identity permutation `[0, 1, ..., N-1]`.
+    permutation: Option<Vec<usize>>,
+}
+
+impl FixedShapeTensorMetadata {
+    /// Creates a new [`FixedShapeTensorMetadata`] with the given logical `shape`.
+    ///
+    /// Use [`with_dim_names`](Self::with_dim_names) and
+    /// [`with_permutation`](Self::with_permutation) to further configure the metadata.
+    pub fn new(shape: Vec<usize>) -> Self {
+        Self {
+            logical_shape: shape,
+            dim_names: None,
+            permutation: None,
+        }
+    }
+
+    /// Sets the dimension names for this tensor. An empty vec is normalized to `None` since a
+    /// 0-dimensional tensor has no dimensions to name.
+    ///
+    /// The number of names must match the number of logical dimensions.
+    pub fn with_dim_names(mut self, names: Vec<String>) -> VortexResult<Self> {
+        if !names.is_empty() {
+            vortex_ensure_eq!(
+                names.len(),
+                self.logical_shape.len(),
+                "dim_names length ({}) must match logical_shape length ({})",
+                names.len(),
+                self.logical_shape.len()
+            );
+            self.dim_names = Some(names);
+        }
+
+        Ok(self)
+    }
+
+    /// Sets the permutation for this tensor. An empty vec is normalized to `None` since a
+    /// 0-dimensional tensor has no dimensions to permute.
+    ///
+    /// The permutation must be a valid permutation of `[0, 1, ..., N-1]` where `N` is the
+    /// number of logical dimensions.
+    pub fn with_permutation(mut self, permutation: Vec<usize>) -> VortexResult<Self> {
+        if !permutation.is_empty() {
+            vortex_ensure_eq!(
+                permutation.len(),
+                self.logical_shape.len(),
+                "permutation length ({}) must match logical_shape length ({})",
+                permutation.len(),
+                self.logical_shape.len()
+            );
+
+            // Verify this is actually a permutation of [0..N).
+            let mut seen = vec![false; permutation.len()];
+            for &p in &permutation {
+                vortex_ensure!(
+                    p < permutation.len(),
+                    "permutation index {p} is out of range for {} dimensions",
+                    permutation.len()
+                );
+                vortex_ensure!(!seen[p], "permutation contains duplicate index {p}");
+                seen[p] = true;
+            }
+
+            self.permutation = Some(permutation);
+        }
+
+        Ok(self)
+    }
+
+    /// Returns the number of dimensions (rank) of the tensor.
+    pub fn ndim(&self) -> usize {
+        self.logical_shape.len()
+    }
+
+    /// Returns the logical dimensions of the tensor as a slice.
+    pub fn logical_shape(&self) -> &[usize] {
+        &self.logical_shape
+    }
+
+    /// Returns the dimension names, if set.
+    pub fn dim_names(&self) -> Option<&[String]> {
+        self.dim_names.as_deref()
+    }
+
+    /// Returns the permutation, if set.
+    pub fn permutation(&self) -> Option<&[usize]> {
+        self.permutation.as_deref()
+    }
+
+    /// Returns an iterator over the physical shape of the tensor.
+    ///
+    /// The physical shape describes the row-major memory layout. It is derived from the logical
+    /// shape by placing each logical dimension's size at its physical position:
+    /// `physical_shape[permutation[i]] = logical_shape[i]`.
+    ///
+    /// When no permutation is present, the physical shape is identical to the logical shape.
+    pub fn physical_shape(&self) -> impl Iterator<Item = usize> + '_ {
+        let ndim = self.logical_shape.len();
+        let permutation = self.permutation.as_deref();
+
+        match permutation {
+            None => Either::Left(self.logical_shape.iter().copied()),
+            Some(perm) => Either::Right(
+                (0..ndim).map(move |p| self.logical_shape[Self::inverse_perm(perm, p)]),
+            ),
+        }
+    }
+
+    /// Returns an iterator over the strides for each logical dimension of the tensor.
+    ///
+    /// The stride for a logical dimension is the number of elements to skip in the flat backing
+    /// array in order to move one step along that logical dimension.
+    ///
+    /// When a permutation is present, the physical memory is laid out in row-major order over the
+    /// physical dimensions (the logical dimensions reordered by the permutation), so the strides
+    /// are derived from that physical layout.
+    pub fn strides(&self) -> impl Iterator<Item = usize> + '_ {
+        let ndim = self.logical_shape.len();
+        let permutation = self.permutation.as_deref();
+
+        match permutation {
+            None => Either::Left(
+                (0..ndim).map(|i| self.logical_shape[i + 1..].iter().product::<usize>()),
+            ),
+            Some(permutation) => {
+                Either::Right((0..ndim).map(|i| self.permuted_stride(i, permutation)))
+            }
+        }
+    }
+
+    /// Computes the stride for logical dimension `i` given a `permutation`.
+    ///
+    /// The stride is the product of `logical_shape[j]` for all logical dimensions `j` whose
+    /// physical position (`perm[j]`) comes after the physical position of dimension `i`
+    /// (`perm[i]`).
+    fn permuted_stride(&self, i: usize, perm: &[usize]) -> usize {
+        let phys = perm[i];
+
+        // Each call scans the full permutation, making `strides()` O(ndim^2) overall. Tensor rank
+        // is typically small, so avoiding a Vec allocation is a net win.
+        perm.iter()
+            .enumerate()
+            .filter(|&(_, &p)| p > phys)
+            .map(|(l, _)| self.logical_shape[l])
+            .product::<usize>()
+    }
+
+    /// Returns the logical dimension index that maps to physical position `p`. This is the
+    /// inverse of the permutation: if `perm[i] == p`, returns `i`.
+    ///
+    /// Each call is a linear scan of `perm`, making callers that invoke this for every physical
+    /// position O(ndim^2) overall. Tensor rank is typically small (2–5), so avoiding a Vec
+    /// allocation for the full inverse permutation is a net win.
+    fn inverse_perm(perm: &[usize], p: usize) -> usize {
+        perm.iter()
+            .position(|&pi| pi == p)
+            .vortex_expect("permutation must contain every physical position exactly once")
+    }
+}
+
+impl fmt::Display for FixedShapeTensorMetadata {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Tensor(")?;
+
+        match &self.dim_names {
+            Some(names) => {
+                for (i, (dim, name)) in self.logical_shape.iter().zip(names.iter()).enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{name}: {dim}")?;
+                }
+            }
+            None => {
+                for (i, dim) in self.logical_shape.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{dim}")?;
+                }
+            }
+        }
+
+        if let Some(perm) = &self.permutation {
+            for (i, p) in perm.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{p}")?;
+            }
+            write!(f, "]")?;
+        }
+
+        write!(f, ")")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+
+    use super::*;
+
+    /// Reference implementation that computes permuted strides in an explicit, step-by-step way.
+    ///
+    /// 1. Build the physical shape: `physical_shape[perm[i]] = logical_shape[i]`.
+    /// 2. Compute row-major strides over the physical shape.
+    /// 3. Map back to logical: `logical_stride[i] = physical_strides[perm[i]]`.
+    fn slow_strides(shape: &[usize], perm: &[usize]) -> Vec<usize> {
+        let ndim = shape.len();
+
+        // Derive the physical shape from the logical shape and the permutation.
+        let mut physical_shape = vec![0usize; ndim];
+        for l in 0..ndim {
+            physical_shape[perm[l]] = shape[l];
+        }
+
+        // Compute row-major strides over the physical shape.
+        let mut physical_strides = vec![1usize; ndim];
+        for i in (0..ndim.saturating_sub(1)).rev() {
+            physical_strides[i] = physical_strides[i + 1] * physical_shape[i + 1];
+        }
+
+        // Map physical strides back to logical dimension order.
+        (0..ndim).map(|l| physical_strides[perm[l]]).collect()
+    }
+
+    // -- Row-major strides (no permutation) --
+
+    #[rstest]
+    #[case::scalar_0d(vec![],        vec![])]
+    #[case::vector_1d(vec![5],       vec![1])]
+    #[case::matrix_2d(vec![3, 4],    vec![4, 1])]
+    #[case::tensor_3d(vec![2, 3, 4], vec![12, 4, 1])]
+    #[case::zero_dim( vec![3, 0, 4], vec![0, 4, 1])]
+    fn strides_row_major(#[case] shape: Vec<usize>, #[case] expected: Vec<usize>) {
+        let m = FixedShapeTensorMetadata::new(shape);
+        assert_eq!(m.strides().collect::<Vec<_>>(), expected);
+    }
+
+    // -- Permuted strides --
+    //
+    // Each case is checked against the expected value and cross-validated against the
+    // `slow_strides` reference implementation.
+
+    #[rstest]
+    // 2D transpose: physical shape = [4, 3].
+    #[case::transpose_2d(vec![3, 4],    vec![1, 0],    vec![1, 3])]
+    // 3D: physical shape = [3, 4, 2].
+    #[case::perm_3d_201( vec![2, 3, 4], vec![2, 0, 1], vec![1, 8, 2])]
+    // 3D with zero-sized dimension: physical shape = [4, 3, 0].
+    #[case::zero_dim(    vec![3, 0, 4], vec![1, 2, 0], vec![0, 1, 0])]
+    fn strides_permuted(
+        #[case] shape: Vec<usize>,
+        #[case] perm: Vec<usize>,
+        #[case] expected: Vec<usize>,
+    ) -> VortexResult<()> {
+        let m = FixedShapeTensorMetadata::new(shape.clone()).with_permutation(perm.clone())?;
+        let actual: Vec<usize> = m.strides().collect();
+        assert_eq!(actual, expected);
+        assert_eq!(actual, slow_strides(&shape, &perm));
+        Ok(())
+    }
+
+    #[test]
+    fn strides_identity_permutation_matches_row_major() -> VortexResult<()> {
+        let row_major = FixedShapeTensorMetadata::new(vec![2, 3, 4]);
+        let identity =
+            FixedShapeTensorMetadata::new(vec![2, 3, 4]).with_permutation(vec![0, 1, 2])?;
+        assert_eq!(
+            row_major.strides().collect::<Vec<_>>(),
+            identity.strides().collect::<Vec<_>>(),
+        );
+        Ok(())
+    }
+
+    /// Cross-validates the fast `permuted_stride` against the reference `slow_strides` across a
+    /// broader set of shapes and permutations.
+    #[rstest]
+    #[case::perm_3d_120(vec![2, 3, 4],    vec![1, 2, 0])]
+    #[case::perm_3d_021(vec![2, 3, 4],    vec![0, 2, 1])]
+    #[case::identity_3d(vec![2, 3, 4],    vec![0, 1, 2])]
+    #[case::zero_lead(  vec![0, 3, 4],    vec![2, 0, 1])]
+    #[case::rev_4d(     vec![2, 3, 4, 5], vec![3, 2, 1, 0])]
+    #[case::swap_4d(    vec![2, 3, 4, 5], vec![1, 0, 3, 2])]
+    #[case::half_4d(    vec![2, 3, 4, 5], vec![2, 3, 0, 1])]
+    fn strides_match_slow_reference(
+        #[case] shape: Vec<usize>,
+        #[case] perm: Vec<usize>,
+    ) -> VortexResult<()> {
+        let m = FixedShapeTensorMetadata::new(shape.clone()).with_permutation(perm.clone())?;
+        assert_eq!(m.strides().collect::<Vec<_>>(), slow_strides(&shape, &perm));
+        Ok(())
+    }
+
+    // -- Physical shape --
+
+    #[test]
+    fn physical_shape_no_permutation() {
+        let m = FixedShapeTensorMetadata::new(vec![2, 3, 4]);
+        assert_eq!(m.physical_shape().collect::<Vec<_>>(), vec![2, 3, 4]);
+    }
+
+    #[rstest]
+    // Logical [3, 4] with perm [1, 0] → physical [4, 3].
+    #[case::transpose_2d(vec![3, 4],    vec![1, 0],    vec![4, 3])]
+    // Logical [2, 3, 4] with perm [2, 0, 1] → physical [3, 4, 2].
+    #[case::perm_3d(     vec![2, 3, 4], vec![2, 0, 1], vec![3, 4, 2])]
+    // Identity: physical = logical.
+    #[case::identity(    vec![2, 3, 4], vec![0, 1, 2], vec![2, 3, 4])]
+    // Logical [3, 0, 4] with perm [1, 2, 0] → physical [4, 3, 0].
+    #[case::zero_dim(    vec![3, 0, 4], vec![1, 2, 0], vec![4, 3, 0])]
+    fn physical_shape_permuted(
+        #[case] shape: Vec<usize>,
+        #[case] perm: Vec<usize>,
+        #[case] expected: Vec<usize>,
+    ) -> VortexResult<()> {
+        let m = FixedShapeTensorMetadata::new(shape).with_permutation(perm)?;
+        assert_eq!(m.physical_shape().collect::<Vec<_>>(), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn dim_names_wrong_length() {
+        let result = FixedShapeTensorMetadata::new(vec![2, 3]).with_dim_names(vec!["x".into()]);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn permutation_wrong_length() {
+        let result = FixedShapeTensorMetadata::new(vec![2, 3]).with_permutation(vec![0]);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn permutation_out_of_range() {
+        let result = FixedShapeTensorMetadata::new(vec![2, 3]).with_permutation(vec![0, 5]);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn permutation_duplicate_index() {
+        let result = FixedShapeTensorMetadata::new(vec![2, 3]).with_permutation(vec![0, 0]);
+        assert!(result.is_err());
+    }
+}
diff --git a/vortex-tensor/src/fixed_shape/mod.rs b/vortex-tensor/src/fixed_shape/mod.rs
new file mode 100644
index 00000000000..48f991517ec
--- /dev/null
+++ b/vortex-tensor/src/fixed_shape/mod.rs
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Fixed-shape Tensor extension type.
+
+/// The VTable for the Tensor extension type.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct FixedShapeTensor;
+
+mod matcher;
+pub use matcher::AnyFixedShapeTensor;
+pub use matcher::FixedShapeTensorMatcherMetadata;
+
+mod metadata;
+pub use metadata::FixedShapeTensorMetadata;
+
+mod proto;
+mod vtable;
diff --git a/vortex-tensor/src/fixed_shape/proto.rs b/vortex-tensor/src/fixed_shape/proto.rs
new file mode 100644
index 00000000000..9d89c56bcec
--- /dev/null
+++ b/vortex-tensor/src/fixed_shape/proto.rs
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Protobuf serialization for [`FixedShapeTensorMetadata`].
+
+use prost::Message;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::fixed_shape::FixedShapeTensorMetadata;
+
+/// Protobuf representation of [`FixedShapeTensorMetadata`].
+///
+/// Protobuf does not distinguish between an absent repeated field and an empty one (both will
+/// deserialize as an empty `Vec`). This is fine because the semantic meaning is unambiguous:
+///
+/// - `logical_shape` empty: 0-dimensional (scalar) tensor.
+/// - `dim_names` empty: no dimension names (`None`).
+/// - `permutation` empty: no permutation, i.e., identity layout (`None`).
+#[derive(Clone, PartialEq, Message)]
+struct FixedShapeTensorMetadataProto {
+    /// The size of each logical dimension. Empty for a 0-dimensional scalar tensor.
+    #[prost(uint32, repeated, tag = "1")]
+    logical_shape: Vec<u32>,
+
+    /// Optional human-readable names for each logical dimension. When present, must have the
+    /// same length as `logical_shape`. Empty means no names are set.
+    #[prost(string, repeated, tag = "2")]
+    dim_names: Vec<String>,
+
+    /// Optional dimension permutation mapping logical to physical indices. When present, must
+    /// be a permutation of `[0, 1, ..., N-1]`. Empty means identity (row-major) layout.
+    #[prost(uint32, repeated, tag = "3")]
+    permutation: Vec<u32>,
+}
+
+/// Serializes [`FixedShapeTensorMetadata`] to protobuf bytes.
+pub(crate) fn serialize(metadata: &FixedShapeTensorMetadata) -> Vec<u8> {
+    let logical_shape = metadata
+        .logical_shape()
+        .iter()
+        .map(|&d| u32::try_from(d).vortex_expect("dimension size exceeds u32"))
+        .collect();
+
+    let dim_names = metadata.dim_names().map(|n| n.to_vec()).unwrap_or_default();
+
+    let permutation = metadata
+        .permutation()
+        .map(|p| {
+            p.iter()
+                .map(|&i| u32::try_from(i).vortex_expect("permutation index exceeds u32"))
+                .collect()
+        })
+        .unwrap_or_default();
+
+    let proto = FixedShapeTensorMetadataProto {
+        logical_shape,
+        dim_names,
+        permutation,
+    };
+    proto.encode_to_vec()
+}
+
+/// Deserializes [`FixedShapeTensorMetadata`] from protobuf bytes.
+///
+/// For 0-dimensional tensors, all three repeated fields are empty, which correctly produces a
+/// metadata with an empty shape and no names or permutation.
+pub(crate) fn deserialize(bytes: &[u8]) -> VortexResult<FixedShapeTensorMetadata> {
+    let proto = FixedShapeTensorMetadataProto::decode(bytes).map_err(|e| vortex_err!("{e}"))?;
+
+    let logical_shape = proto
+        .logical_shape
+        .into_iter()
+        .map(|d| d as usize)
+        .collect();
+    let mut m = FixedShapeTensorMetadata::new(logical_shape);
+
+    // Note that this is fine for 0 dimensions since if we do not have any dimensions, we cannot
+    // have any names or permutations.
+    if !proto.dim_names.is_empty() {
+        m = m.with_dim_names(proto.dim_names)?;
+    }
+    if !proto.permutation.is_empty() {
+        let permutation = proto.permutation.into_iter().map(|i| i as usize).collect();
+        m = m.with_permutation(permutation)?;
+    }
+
+    Ok(m)
+}
diff --git a/vortex-tensor/src/fixed_shape/vtable.rs b/vortex-tensor/src/fixed_shape/vtable.rs
new file mode 100644
index 00000000000..21ab1ef5336
--- /dev/null
+++ b/vortex-tensor/src/fixed_shape/vtable.rs
@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+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::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+use crate::fixed_shape::FixedShapeTensor;
+use crate::fixed_shape::FixedShapeTensorMetadata;
+use crate::fixed_shape::proto;
+
+impl ExtVTable for FixedShapeTensor {
+    type Metadata = FixedShapeTensorMetadata;
+
+    // TODO(connor): This is just a placeholder for now!!!
+    type NativeValue<'a> = &'a ScalarValue;
+
+    fn id(&self) -> ExtId {
+        ExtId::new_ref("vortex.tensor.fixed_shape_tensor")
+    }
+
+    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(proto::serialize(metadata))
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        proto::deserialize(metadata)
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        let storage_dtype = ext_dtype.storage_dtype();
+        let DType::FixedSizeList(element_dtype, list_size, _nullability) = storage_dtype else {
+            vortex_bail!(
+                "FixedShapeTensor storage dtype must be a FixedSizeList, got {storage_dtype}"
+            );
+        };
+
+        // Note that these constraints may be relaxed in the future.
+        vortex_ensure!(
+            element_dtype.is_primitive(),
+            "FixedShapeTensor element dtype must be primitive, got {element_dtype} \
+             (may change in the future)"
+        );
+        vortex_ensure!(
+            !element_dtype.is_nullable(),
+            "FixedShapeTensor element dtype must be non-nullable (may change in the future)"
+        );
+
+        let element_count: usize = ext_dtype.metadata().logical_shape().iter().product();
+        vortex_ensure_eq!(
+            element_count,
+            *list_size as usize,
+            "FixedShapeTensor logical shape product ({element_count}) does not match \
+             FixedSizeList size ({list_size})"
+        );
+
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        _ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        // TODO(connor): This is just a placeholder. However, even if we have a dedicated native
+        // type for a singular tensor, we do not need to validate anything as any backing memory
+        // should be valid for a given tensor.
+        Ok(storage_value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_array::dtype::extension::ExtVTable;
+    use vortex_error::VortexResult;
+
+    use crate::fixed_shape::FixedShapeTensor;
+    use crate::fixed_shape::FixedShapeTensorMetadata;
+
+    /// Serializes and deserializes the given metadata through protobuf, asserting equality.
+    fn assert_roundtrip(metadata: &FixedShapeTensorMetadata) -> VortexResult<()> {
+        let vtable = FixedShapeTensor;
+        let bytes = vtable.serialize_metadata(metadata)?;
+        let deserialized = vtable.deserialize_metadata(&bytes)?;
+        assert_eq!(&deserialized, metadata);
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::scalar_0d(FixedShapeTensorMetadata::new(vec![]))]
+    #[case::shape_only(FixedShapeTensorMetadata::new(vec![2, 3, 4]))]
+    fn roundtrip_simple(#[case] metadata: FixedShapeTensorMetadata) -> VortexResult<()> {
+        assert_roundtrip(&metadata)
+    }
+
+    #[rstest]
+    #[case::with_permutation(
+        FixedShapeTensorMetadata::new(vec![2, 3, 4])
+            .with_permutation(vec![2, 0, 1])
+    )]
+    #[case::with_dim_names(
+        FixedShapeTensorMetadata::new(vec![3, 4])
+            .with_dim_names(vec!["rows".into(), "cols".into()])
+    )]
+    #[case::all_fields(
+        FixedShapeTensorMetadata::new(vec![2, 3, 4])
+            .with_dim_names(vec!["x".into(), "y".into(), "z".into()])
+            .and_then(|m| m.with_permutation(vec![1, 2, 0]))
+    )]
+    fn roundtrip_with_options(
+        #[case] metadata: VortexResult<FixedShapeTensorMetadata>,
+    ) -> VortexResult<()> {
+        assert_roundtrip(&metadata?)
+    }
+}
diff --git a/vortex-tensor/src/lib.rs b/vortex-tensor/src/lib.rs
new file mode 100644
index 00000000000..a4577f6d262
--- /dev/null
+++ b/vortex-tensor/src/lib.rs
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Types and functionality for working with tensors, vectors, and related mathematical constructs
+//! including unit vectors, spherical coordinates, and similarity measures such as cosine
+//! similarity.
+
+use vortex_array::dtype::session::DTypeSessionExt;
+use vortex_array::scalar_fn::session::ScalarFnSessionExt;
+use vortex_array::session::ArraySessionExt;
+use vortex_session::VortexSession;
+
+use crate::encodings::turboquant::TurboQuant;
+use crate::fixed_shape::FixedShapeTensor;
+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::vector::Vector;
+
+pub mod matcher;
+pub mod scalar_fns;
+
+pub mod fixed_shape;
+pub mod vector;
+
+pub mod encodings;
+
+mod utils;
+
+/// Initialize the Vortex tensor library with a Vortex session.
+pub fn initialize(session: &VortexSession) {
+    session.dtypes().register(Vector);
+    session.dtypes().register(FixedShapeTensor);
+
+    session.arrays().register(TurboQuant);
+
+    session.scalar_fns().register(CosineSimilarity);
+    session.scalar_fns().register(InnerProduct);
+    session.scalar_fns().register(L2Denorm);
+    session.scalar_fns().register(L2Norm);
+}
diff --git a/vortex-tensor/src/matcher.rs b/vortex-tensor/src/matcher.rs
new file mode 100644
index 00000000000..973562be3da
--- /dev/null
+++ b/vortex-tensor/src/matcher.rs
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Matcher for tensor-like extension types.
+
+use vortex_array::dtype::PType;
+use vortex_array::dtype::extension::ExtDTypeRef;
+use vortex_array::dtype::extension::Matcher;
+
+use crate::fixed_shape::AnyFixedShapeTensor;
+use crate::fixed_shape::FixedShapeTensorMatcherMetadata;
+use crate::vector::AnyVector;
+use crate::vector::VectorMatcherMetadata;
+
+/// Matcher for any tensor-like extension type.
+///
+/// Currently the different kinds of tensors that are available are:
+///
+/// - `FixedShapeTensor`
+/// - `Vector`
+pub struct AnyTensor;
+
+/// The matched variant of a tensor-like extension type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TensorMatch<'a> {
+    /// A [`FixedShapeTensor`](crate::fixed_shape::FixedShapeTensor) extension type.
+    FixedShapeTensor(FixedShapeTensorMatcherMetadata<'a>),
+
+    /// A [`Vector`](crate::vector::Vector) extension type.
+    ///
+    /// Note that we store an owned type here wrapping (copyable) data from the dtype.
+    Vector(VectorMatcherMetadata),
+}
+
+impl TensorMatch<'_> {
+    /// Returns the tensor element type for this tensor-like dtype.
+    pub fn element_ptype(self) -> PType {
+        match self {
+            Self::FixedShapeTensor(metadata) => metadata.element_ptype(),
+            Self::Vector(metadata) => metadata.element_ptype(),
+        }
+    }
+
+    /// Returns the flattened element count for each logical tensor row.
+    pub fn list_size(self) -> usize {
+        match self {
+            Self::FixedShapeTensor(metadata) => metadata.list_size(),
+            Self::Vector(metadata) => metadata.dimensions() as usize,
+        }
+    }
+}
+
+impl Matcher for AnyTensor {
+    type Match<'a> = TensorMatch<'a>;
+
+    fn try_match<'a>(ext_dtype: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
+        if let Some(metadata) = ext_dtype.metadata_opt::<AnyFixedShapeTensor>() {
+            return Some(TensorMatch::FixedShapeTensor(metadata));
+        }
+
+        // Special logic for vectors to get convenience metadata (instead of `EmptyMetadata`).
+        if let Some(metadata) = ext_dtype.metadata_opt::<AnyVector>() {
+            return Some(TensorMatch::Vector(metadata));
+        }
+
+        None
+    }
+}
diff --git a/vortex-tensor/src/scalar_fns/cosine_similarity.rs b/vortex-tensor/src/scalar_fns/cosine_similarity.rs
new file mode 100644
index 00000000000..39c8b135e43
--- /dev/null
+++ b/vortex-tensor/src/scalar_fns/cosine_similarity.rs
@@ -0,0 +1,586 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Cosine similarity expression for tensor-like types.
+
+use std::fmt::Formatter;
+
+use num_traits::Zero;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::ScalarFnArray;
+use vortex_array::arrays::scalar_fn::ExactScalarFn;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::expr::Expression;
+use vortex_array::expr::and;
+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::ScalarFn;
+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_ensure;
+
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::inner_product::InnerProduct;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+use crate::scalar_fns::l2_norm::L2Norm;
+use crate::utils::extract_l2_denorm_children;
+use crate::utils::validate_tensor_float_input;
+
+/// Cosine similarity between two columns.
+///
+/// Computes `dot(a, b) / (||a|| * ||b||)` over the flat backing buffer of each tensor or vector.
+/// The shape and permutation do not affect the result because cosine similarity only depends on the
+/// element values, not their logical arrangement.
+///
+/// Both inputs must be tensor-like extension arrays ([`FixedShapeTensor`] or [`Vector`]) with the
+/// same dtype and a float element type. The output is a float column of the same float type.
+///
+/// [`FixedShapeTensor`]: crate::fixed_shape::FixedShapeTensor
+/// [`Vector`]: crate::vector::Vector
+#[derive(Clone)]
+pub struct CosineSimilarity;
+
+impl CosineSimilarity {
+    /// Creates a new [`ScalarFn`] wrapping the cosine similarity operation with the given
+    /// [`ApproxOptions`] controlling approximation behavior.
+    pub fn new(options: &ApproxOptions) -> ScalarFn<CosineSimilarity> {
+        ScalarFn::new(CosineSimilarity, options.clone())
+    }
+
+    /// Constructs a [`ScalarFnArray`] that lazily computes the cosine similarity between `lhs` and
+    /// `rhs`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
+    /// mismatches).
+    pub fn try_new_array(
+        options: &ApproxOptions,
+        lhs: ArrayRef,
+        rhs: ArrayRef,
+        len: usize,
+    ) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(CosineSimilarity::new(options).erased(), vec![lhs, rhs], len)
+    }
+}
+
+impl ScalarFnVTable for CosineSimilarity {
+    type Options = ApproxOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.tensor.cosine_similarity")
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Exact(2)
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        match child_idx {
+            0 => ChildName::from("lhs"),
+            1 => ChildName::from("rhs"),
+            _ => unreachable!("CosineSimilarity must have exactly two children"),
+        }
+    }
+
+    fn fmt_sql(
+        &self,
+        _options: &Self::Options,
+        expr: &Expression,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
+        write!(f, "cosine_similarity(")?;
+        expr.child(0).fmt_sql(f)?;
+        write!(f, ", ")?;
+        expr.child(1).fmt_sql(f)?;
+        write!(f, ")")
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
+        let lhs = &arg_dtypes[0];
+        let rhs = &arg_dtypes[1];
+
+        // Both must have the same dtype (ignoring top-level nullability).
+        vortex_ensure!(
+            lhs.eq_ignore_nullability(rhs),
+            "CosineSimilarity requires both inputs to have the same dtype, got {lhs} and {rhs}"
+        );
+
+        // We don't need to look at rhs anymore since we know lhs and rhs are equal.
+        let tensor_match = validate_tensor_float_input(lhs)?;
+        let ptype = tensor_match.element_ptype();
+
+        let nullability = Nullability::from(lhs.is_nullable() || rhs.is_nullable());
+        Ok(DType::Primitive(ptype, nullability))
+    }
+
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let mut lhs_ref = args.get(0)?;
+        let mut rhs_ref = args.get(1)?;
+        let len = args.row_count();
+
+        // Check if any of our children have be already normalized.
+        {
+            let lhs_is_denorm = lhs_ref.is::<ExactScalarFn<L2Denorm>>();
+            let rhs_is_denorm = rhs_ref.is::<ExactScalarFn<L2Denorm>>();
+
+            if lhs_is_denorm && rhs_is_denorm {
+                return self.execute_both_denorm(options, &lhs_ref, &rhs_ref, len, ctx);
+            } else if lhs_is_denorm || rhs_is_denorm {
+                if rhs_is_denorm {
+                    (lhs_ref, rhs_ref) = (rhs_ref, lhs_ref);
+                }
+                return self.execute_one_denorm(options, &lhs_ref, &rhs_ref, len, ctx);
+            }
+        }
+
+        // Compute combined validity.
+        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(options, lhs_ref.clone(), len)?;
+        let norm_rhs_arr = L2Norm::try_new_array(options, rhs_ref.clone(), len)?;
+        let dot_arr = InnerProduct::try_new_array(options, lhs_ref, rhs_ref, len)?;
+
+        // 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.
+        let dot: PrimitiveArray = dot_arr.into_array().execute(ctx)?;
+        let norm_l: PrimitiveArray = norm_lhs_arr.into_array().execute(ctx)?;
+        let norm_r: PrimitiveArray = norm_rhs_arr.into_array().execute(ctx)?;
+
+        // TODO(connor): Ideally we would have a `SafeDiv` binary numeric operation.
+        // TODO(connor): This can be written in a more SIMD-friendly manner.
+        match_each_float_ptype!(dot.ptype(), |T| {
+            let dots = dot.as_slice::<T>();
+            let norms_l = norm_l.as_slice::<T>();
+            let norms_r = norm_r.as_slice::<T>();
+            let buffer: Buffer<T> = (0..len)
+                .map(|i| {
+                    let denom = norms_l[i] * norms_r[i];
+
+                    if denom == T::zero() {
+                        T::zero()
+                    } else {
+                        dots[i] / denom
+                    }
+                })
+                .collect();
+
+            // SAFETY: The buffer length equals `len`, which matches the source validity length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+
+    fn validity(
+        &self,
+        _options: &Self::Options,
+        expression: &Expression,
+    ) -> VortexResult<Option<Expression>> {
+        // The result is null if either input tensor is null.
+        let lhs_validity = expression.child(0).validity()?;
+        let rhs_validity = expression.child(1).validity()?;
+
+        Ok(Some(and(lhs_validity, rhs_validity)))
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        false
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
+
+impl CosineSimilarity {
+    /// Both sides are `L2Denorm`: norms cancel, so `cosine_similarity = dot(n_l, n_r)`.
+    fn execute_both_denorm(
+        &self,
+        options: &ApproxOptions,
+        lhs_ref: &ArrayRef,
+        rhs_ref: &ArrayRef,
+        len: usize,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let validity = lhs_ref.validity()?.and(rhs_ref.validity()?)?;
+
+        let (normalized_l, _) = extract_l2_denorm_children(lhs_ref);
+        let (normalized_r, _) = extract_l2_denorm_children(rhs_ref);
+
+        // Dot product of already-normalized children IS the cosine similarity.
+        let dot =
+            InnerProduct::try_new_array(options, normalized_l, normalized_r, len)?.into_array();
+
+        if !matches!(validity, Validity::NonNullable) {
+            // Masking always changes the nullability to nullable.
+            dot.mask(validity.to_array(len))
+        } else {
+            Ok(dot)
+        }
+    }
+
+    /// One side is `L2Denorm`: `cosine_similarity = dot(n, b) / ||b||`.
+    ///
+    /// The caller must pass the denorm array as `denorm_ref` and the plain array as `plain_ref`.
+    fn execute_one_denorm(
+        &self,
+        options: &ApproxOptions,
+        denorm_ref: &ArrayRef,
+        plain_ref: &ArrayRef,
+        len: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let validity = denorm_ref.validity()?.and(plain_ref.validity()?)?;
+
+        let (normalized, _) = extract_l2_denorm_children(denorm_ref);
+
+        let dot_arr = InnerProduct::try_new_array(options, normalized, plain_ref.clone(), len)?;
+        let norm_arr = L2Norm::try_new_array(options, plain_ref.clone(), len)?;
+        let dot: PrimitiveArray = dot_arr.into_array().execute(ctx)?;
+        let plain_norm: PrimitiveArray = norm_arr.into_array().execute(ctx)?;
+
+        // TODO(connor): Ideally we would have a `SafeDiv` binary numeric operation.
+        // TODO(connor): This can be written in a more SIMD-friendly manner.
+        match_each_float_ptype!(dot.ptype(), |T| {
+            let dots = dot.as_slice::<T>();
+            let norms = plain_norm.as_slice::<T>();
+            let buffer: Buffer<T> = (0..len)
+                .map(|i| {
+                    if norms[i] == T::zero() {
+                        T::zero()
+                    } else {
+                        dots[i] / norms[i]
+                    }
+                })
+                .collect();
+
+            // SAFETY: The buffer length equals `len`, which matches the source validity length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use rstest::rstest;
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::MaskedArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::ScalarFnArray;
+    use vortex_array::scalar_fn::ScalarFn;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::scalar_fns::ApproxOptions;
+    use crate::scalar_fns::cosine_similarity::CosineSimilarity;
+    use crate::scalar_fns::l2_denorm::L2Denorm;
+    use crate::utils::test_helpers::assert_close;
+    use crate::utils::test_helpers::constant_tensor_array;
+    use crate::utils::test_helpers::constant_vector_array;
+    use crate::utils::test_helpers::tensor_array;
+    use crate::utils::test_helpers::vector_array;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    /// 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>> {
+        let scalar_fn = ScalarFn::new(CosineSimilarity, ApproxOptions::Exact).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::<f64>().to_vec())
+    }
+
+    #[test]
+    fn unit_vectors_1d() -> VortexResult<()> {
+        let lhs = tensor_array(
+            &[3],
+            &[
+                1.0, 0.0, 0.0, // Tensor 1
+                0.0, 1.0, 0.0, // Tensor 2
+            ],
+        )?;
+        let rhs = tensor_array(
+            &[3],
+            &[
+                1.0, 0.0, 0.0, // Tensor 1
+                1.0, 0.0, 0.0, // Tensor 2
+            ],
+        )?;
+
+        // Row 0: identical -> 1.0, row 1: orthogonal -> 0.0.
+        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 0.0]);
+        Ok(())
+    }
+
+    /// Single-row cosine similarity for various vector pairs.
+    #[rstest]
+    // Antiparallel -> -1.0.
+    #[case::opposite(&[3], &[1.0, 0.0, 0.0],  &[-1.0, 0.0, 0.0], &[-1.0])]
+    // dot=24, both magnitudes=5 -> 24/25 = 0.96.
+    #[case::non_unit(&[2], &[3.0, 4.0],        &[4.0, 3.0],       &[0.96])]
+    // Zero vector -> guarded to 0.0.
+    #[case::zero_norm(&[2], &[0.0, 0.0],       &[1.0, 0.0],       &[0.0])]
+    fn single_row(
+        #[case] shape: &[usize],
+        #[case] lhs_elems: &[f64],
+        #[case] rhs_elems: &[f64],
+        #[case] expected: &[f64],
+    ) -> VortexResult<()> {
+        let lhs = tensor_array(shape, lhs_elems)?;
+        let rhs = tensor_array(shape, rhs_elems)?;
+        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, expected);
+        Ok(())
+    }
+
+    /// Self-similarity across various tensor shapes should always produce 1.0.
+    #[rstest]
+    // 2x3 matrix, flattened to 6 elements.
+    #[case::matrix_2d(
+        &[2, 3],
+        &[
+            1.0, 0.0, 0.0, // row 0
+            0.0, 0.0, 0.0, // row 1
+        ],
+    )]
+    // 2x2x2 tensor, 8 elements.
+    #[case::tensor_3d(&[2, 2, 2], &[1.0; 8])]
+    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]);
+        Ok(())
+    }
+
+    #[test]
+    fn scalar_0d() -> VortexResult<()> {
+        // 0-dimensional tensor: each "tensor" is a single scalar value.
+        let lhs = tensor_array(&[], &[5.0, 3.0])?;
+        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]);
+        Ok(())
+    }
+
+    #[test]
+    fn many_rows() -> VortexResult<()> {
+        // 5 tensors of shape [4] compared against themselves -> all 1.0.
+        let lhs = tensor_array(
+            &[4],
+            &[
+                1.0, 2.0, 3.0, 4.0, // tensor 0
+                0.0, 1.0, 0.0, 0.0, // tensor 1
+                5.0, 0.0, 5.0, 0.0, // tensor 2
+                1.0, 1.0, 1.0, 1.0, // tensor 3
+                0.0, 0.0, 0.0, 7.0, // tensor 4
+            ],
+        )?;
+        let rhs = lhs.clone();
+
+        assert_close(
+            &eval_cosine_similarity(lhs, rhs, 5)?,
+            &[1.0, 1.0, 1.0, 1.0, 1.0],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn constant_query_tensor() -> VortexResult<()> {
+        // Compare 4 tensors of shape [3] against a single constant query tensor [1,0,0].
+        let data = tensor_array(
+            &[3],
+            &[
+                1.0, 0.0, 0.0, // tensor 0
+                0.0, 1.0, 0.0, // tensor 1
+                0.0, 0.0, 1.0, // tensor 2
+                1.0, 0.0, 0.0, // tensor 3
+            ],
+        )?;
+        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],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn vector_unit_vectors() -> VortexResult<()> {
+        let lhs = vector_array(
+            3,
+            &[
+                1.0, 0.0, 0.0, // vector 0
+                0.0, 1.0, 0.0, // vector 1
+            ],
+        )?;
+        let rhs = vector_array(
+            3,
+            &[
+                1.0, 0.0, 0.0, // vector 0
+                1.0, 0.0, 0.0, // vector 1
+            ],
+        )?;
+
+        // Row 0: identical -> 1.0, row 1: orthogonal -> 0.0.
+        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 0.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn vector_constant_query() -> VortexResult<()> {
+        let data = vector_array(
+            3,
+            &[
+                1.0, 0.0, 0.0, // vector 0
+                0.0, 1.0, 0.0, // vector 1
+                0.0, 0.0, 1.0, // vector 2
+                1.0, 0.0, 0.0, // vector 3
+            ],
+        )?;
+        let query = constant_vector_array(&[1.0, 0.0, 0.0], 4)?;
+
+        assert_close(
+            &eval_cosine_similarity(data, query, 4)?,
+            &[1.0, 0.0, 0.0, 1.0],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn null_input_row() -> VortexResult<()> {
+        // 2 rows of dim-2 vectors. Row 1 of rhs is masked as null.
+        let lhs = tensor_array(&[2], &[3.0, 4.0, 1.0, 0.0])?;
+        let rhs = tensor_array(&[2], &[3.0, 4.0, 0.0, 1.0])?;
+        let rhs = MaskedArray::try_new(rhs, Validity::from_iter([true, false]))?.into_array();
+
+        let scalar_fn = ScalarFn::new(CosineSimilarity, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
+
+        // Row 0: self-similarity = 1.0, row 1: null.
+        assert!(prim.is_valid(0)?);
+        assert!(!prim.is_valid(1)?);
+        assert_close(&[prim.as_slice::<f64>()[0]], &[1.0]);
+        Ok(())
+    }
+
+    /// Creates an `L2Denorm` scalar function array from pre-normalized elements and norms.
+    fn l2_denorm_array(
+        shape: &[usize],
+        normalized_elements: &[f64],
+        norms: &[f64],
+    ) -> VortexResult<ArrayRef> {
+        let len = norms.len();
+        let normalized = tensor_array(shape, normalized_elements)?;
+        let norms = PrimitiveArray::from_iter(norms.iter().copied()).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+        Ok(
+            L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, len, &mut ctx)?
+                .into_array(),
+        )
+    }
+
+    #[test]
+    fn both_denorm_self_similarity() -> VortexResult<()> {
+        // [3.0, 4.0] has norm 5.0, normalized [0.6, 0.8].
+        // [1.0, 0.0] has norm 1.0, normalized [1.0, 0.0].
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+
+        // Self-similarity should always be 1.0.
+        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 1.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn both_denorm_orthogonal() -> VortexResult<()> {
+        // [3.0, 0.0] normalized [1.0, 0.0], norm 3.0.
+        // [0.0, 4.0] normalized [0.0, 1.0], norm 4.0.
+        let lhs = l2_denorm_array(&[2], &[1.0, 0.0], &[3.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.0, 1.0], &[4.0])?;
+
+        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[0.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn both_denorm_zero_norm() -> VortexResult<()> {
+        // Zero-norm row: normalized is [0.0, 0.0], norm is 0.0.
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8, 0.0, 0.0], &[5.0, 0.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+
+        // 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]);
+        Ok(())
+    }
+
+    #[test]
+    fn one_side_denorm_lhs() -> VortexResult<()> {
+        // LHS is L2Denorm([0.6, 0.8], 5.0) representing [3.0, 4.0].
+        // RHS is plain [3.0, 4.0].
+        // cosine_similarity([3.0, 4.0], [3.0, 4.0]) = 1.0.
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0])?;
+        let rhs = tensor_array(&[2], &[3.0, 4.0])?;
+
+        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[1.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn one_side_denorm_rhs() -> VortexResult<()> {
+        // LHS is plain [1.0, 0.0], RHS is L2Denorm([0.6, 0.8], 5.0) representing [3.0, 4.0].
+        // cosine_similarity([1.0, 0.0], [3.0, 4.0]) = 3.0 / (1.0 * 5.0) = 0.6.
+        let lhs = tensor_array(&[2], &[1.0, 0.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0])?;
+
+        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[0.6]);
+        Ok(())
+    }
+
+    #[test]
+    fn both_denorm_null_norms() -> VortexResult<()> {
+        // Row 0: valid, row 1: null (via nullable norms on rhs).
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+
+        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 mut ctx = SESSION.create_execution_ctx();
+        let rhs =
+            L2Denorm::try_new_array(&ApproxOptions::Exact, normalized_r, norms_r, 2, &mut ctx)?
+                .into_array();
+
+        let scalar_fn = ScalarFn::new(CosineSimilarity, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
+
+        assert!(prim.is_valid(0)?);
+        assert!(!prim.is_valid(1)?);
+        assert_close(&[prim.as_slice::<f64>()[0]], &[1.0]);
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/scalar_fns/inner_product.rs b/vortex-tensor/src/scalar_fns/inner_product.rs
new file mode 100644
index 00000000000..da1b62e6ca1
--- /dev/null
+++ b/vortex-tensor/src/scalar_fns/inner_product.rs
@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Inner product expression for tensor-like types.
+
+use std::fmt::Formatter;
+
+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::PrimitiveArray;
+use vortex_array::arrays::ScalarFnArray;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::scalar_fn::ExactScalarFn;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::Nullability;
+use vortex_array::expr::Expression;
+use vortex_array::expr::and;
+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::ScalarFn;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+use crate::matcher::AnyTensor;
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+use crate::utils::extract_flat_elements;
+use crate::utils::extract_l2_denorm_children;
+
+/// Inner product (dot product) between two columns.
+///
+/// Computes `sum(a_i * b_i)` over the flat backing buffer of each tensor or vector. For vectors
+/// this is the standard dot product; for higher-rank ([`FixedShapeTensor`]) arrays this is the
+/// Frobenius inner product.
+///
+/// Both inputs must be tensor-like extension arrays ([`FixedShapeTensor`] or [`Vector`]) with the
+/// same dtype and a float element type. The output is a float column of the same float type.
+///
+/// [`FixedShapeTensor`]: crate::fixed_shape::FixedShapeTensor
+/// [`Vector`]: crate::vector::Vector
+#[derive(Clone)]
+pub struct InnerProduct;
+
+impl InnerProduct {
+    /// Creates a new [`ScalarFn`] wrapping the inner product operation with the given
+    /// [`ApproxOptions`] controlling approximation behavior.
+    pub fn new(options: &ApproxOptions) -> ScalarFn<InnerProduct> {
+        ScalarFn::new(InnerProduct, options.clone())
+    }
+
+    /// Constructs a [`ScalarFnArray`] that lazily computes the inner product between `lhs` and
+    /// `rhs`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
+    /// mismatches).
+    pub fn try_new_array(
+        options: &ApproxOptions,
+        lhs: ArrayRef,
+        rhs: ArrayRef,
+        len: usize,
+    ) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(InnerProduct::new(options).erased(), vec![lhs, rhs], len)
+    }
+}
+
+impl ScalarFnVTable for InnerProduct {
+    type Options = ApproxOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.tensor.inner_product")
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Exact(2)
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        match child_idx {
+            0 => ChildName::from("lhs"),
+            1 => ChildName::from("rhs"),
+            _ => unreachable!("InnerProduct must have exactly two children"),
+        }
+    }
+
+    fn fmt_sql(
+        &self,
+        _options: &Self::Options,
+        expr: &Expression,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
+        write!(f, "inner_product(")?;
+        expr.child(0).fmt_sql(f)?;
+        write!(f, ", ")?;
+        expr.child(1).fmt_sql(f)?;
+        write!(f, ")")
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
+        let lhs = &arg_dtypes[0];
+        let rhs = &arg_dtypes[1];
+
+        // Both must have the same dtype (ignoring top-level nullability).
+        vortex_ensure!(
+            lhs.eq_ignore_nullability(rhs),
+            "InnerProduct requires both inputs to have the same dtype, got {lhs} and {rhs}"
+        );
+
+        // Both inputs must be tensor-like extension types.
+        let lhs_ext = lhs
+            .as_extension_opt()
+            .ok_or_else(|| vortex_err!("InnerProduct lhs must be an extension type, got {lhs}"))?;
+
+        vortex_ensure!(
+            lhs_ext.is::<AnyTensor>(),
+            "InnerProduct inputs must be an `AnyTensor`, got {lhs}"
+        );
+
+        let tensor_match = lhs_ext
+            .metadata_opt::<AnyTensor>()
+            .ok_or_else(|| vortex_err!("InnerProduct inputs must be an `AnyTensor`, got {lhs}"))?;
+        let ptype = tensor_match.element_ptype();
+        // TODO(connor): This should support integer tensors!
+        vortex_ensure!(
+            ptype.is_float(),
+            "InnerProduct element dtype must be a float primitive, got {ptype}"
+        );
+
+        let nullability = Nullability::from(lhs.is_nullable() || rhs.is_nullable());
+        Ok(DType::Primitive(ptype, nullability))
+    }
+
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let mut lhs_ref = args.get(0)?;
+        let mut rhs_ref = args.get(1)?;
+        let len = args.row_count();
+
+        // Check if any of our children have be already normalized.
+        {
+            let lhs_is_denorm = lhs_ref.is::<ExactScalarFn<L2Denorm>>();
+            let rhs_is_denorm = rhs_ref.is::<ExactScalarFn<L2Denorm>>();
+
+            if lhs_is_denorm && rhs_is_denorm {
+                return self.execute_both_denorm(options, &lhs_ref, &rhs_ref, len, ctx);
+            } else if lhs_is_denorm || rhs_is_denorm {
+                if rhs_is_denorm {
+                    (lhs_ref, rhs_ref) = (rhs_ref, lhs_ref);
+                }
+                return self.execute_one_denorm(options, &lhs_ref, &rhs_ref, len, ctx);
+            }
+        }
+
+        // Compute combined validity.
+        let validity = lhs_ref.validity()?.and(rhs_ref.validity()?)?;
+
+        // Canonicalize so we can perform the math directly.
+        let lhs: ExtensionArray = lhs_ref.execute(ctx)?;
+        let rhs: ExtensionArray = rhs_ref.execute(ctx)?;
+
+        // We validated that both inputs have the same type.
+        let ext = lhs.dtype().as_extension();
+        let tensor_match = ext
+            .metadata_opt::<AnyTensor>()
+            .vortex_expect("we already validated this in `return_dtype`");
+        let dimensions = tensor_match.list_size();
+
+        // Extract the storage array from each extension input. We pass the storage (FSL) rather
+        // than the extension array to avoid canonicalizing the extension wrapper.
+        let lhs_storage = lhs.storage_array();
+        let rhs_storage = rhs.storage_array();
+
+        let lhs_flat = extract_flat_elements(lhs_storage, dimensions, ctx)?;
+        let rhs_flat = extract_flat_elements(rhs_storage, dimensions, ctx)?;
+
+        match_each_float_ptype!(lhs_flat.ptype(), |T| {
+            let buffer: Buffer<T> = (0..len)
+                .map(|i| inner_product_row(lhs_flat.row::<T>(i), rhs_flat.row::<T>(i)))
+                .collect();
+
+            // SAFETY: The buffer length equals `row_count`, which matches the source validity
+            // length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+
+    fn validity(
+        &self,
+        _options: &Self::Options,
+        expression: &Expression,
+    ) -> VortexResult<Option<Expression>> {
+        // The result is null if either input tensor is null.
+        let lhs_validity = expression.child(0).validity()?;
+        let rhs_validity = expression.child(1).validity()?;
+
+        Ok(Some(and(lhs_validity, rhs_validity)))
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        false
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
+
+impl InnerProduct {
+    /// Both sides are `L2Denorm`: `inner_product = s_l * s_r * dot(n_l, n_r)`.
+    fn execute_both_denorm(
+        &self,
+        options: &ApproxOptions,
+        lhs_ref: &ArrayRef,
+        rhs_ref: &ArrayRef,
+        len: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let validity = lhs_ref.validity()?.and(rhs_ref.validity()?)?;
+
+        let (normalized_l, norms_l) = extract_l2_denorm_children(lhs_ref);
+        let (normalized_r, norms_r) = extract_l2_denorm_children(rhs_ref);
+
+        let norms_l: PrimitiveArray = norms_l.execute(ctx)?;
+        let norms_r: PrimitiveArray = norms_r.execute(ctx)?;
+
+        let dot: PrimitiveArray =
+            InnerProduct::try_new_array(options, normalized_l, normalized_r, len)?
+                .into_array()
+                .execute(ctx)?;
+
+        match_each_float_ptype!(dot.ptype(), |T| {
+            let dots = dot.as_slice::<T>();
+            let nl = norms_l.as_slice::<T>();
+            let nr = norms_r.as_slice::<T>();
+            let buffer: Buffer<T> = (0..len).map(|i| nl[i] * nr[i] * dots[i]).collect();
+
+            // SAFETY: The buffer length equals `len`, which matches the source validity length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+
+    /// One side is `L2Denorm`: `inner_product = s * dot(n, other)`.
+    ///
+    /// The caller must pass the denorm array as `denorm_ref` and the plain array as `plain_ref`.
+    fn execute_one_denorm(
+        &self,
+        options: &ApproxOptions,
+        denorm_ref: &ArrayRef,
+        plain_ref: &ArrayRef,
+        len: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let validity = denorm_ref.validity()?.and(plain_ref.validity()?)?;
+
+        let (normalized, norms) = extract_l2_denorm_children(denorm_ref);
+        let denorm_norms: PrimitiveArray = norms.execute(ctx)?;
+
+        let dot: PrimitiveArray =
+            InnerProduct::try_new_array(options, normalized, plain_ref.clone(), len)?
+                .into_array()
+                .execute(ctx)?;
+
+        match_each_float_ptype!(dot.ptype(), |T| {
+            let dots = dot.as_slice::<T>();
+            let ns = denorm_norms.as_slice::<T>();
+            let buffer: Buffer<T> = (0..len).map(|i| ns[i] * dots[i]).collect();
+
+            // SAFETY: The buffer length equals `len`, which matches the source validity length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+}
+
+/// Computes the inner product (dot product) of two equal-length float slices.
+///
+/// Returns `sum(a_i * b_i)`.
+fn inner_product_row<T: Float + NativePType>(a: &[T], b: &[T]) -> T {
+    a.iter()
+        .zip(b.iter())
+        .map(|(&x, &y)| x * y)
+        .fold(T::zero(), |acc, v| acc + v)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use rstest::rstest;
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::MaskedArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::ScalarFnArray;
+    use vortex_array::scalar_fn::ScalarFn;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::scalar_fns::ApproxOptions;
+    use crate::scalar_fns::inner_product::InnerProduct;
+    use crate::scalar_fns::l2_denorm::L2Denorm;
+    use crate::utils::test_helpers::assert_close;
+    use crate::utils::test_helpers::tensor_array;
+    use crate::utils::test_helpers::vector_array;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    /// 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>> {
+        let scalar_fn = ScalarFn::new(InnerProduct, ApproxOptions::Exact).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::<f64>().to_vec())
+    }
+
+    /// Single-row inner product for various vector pairs.
+    #[rstest]
+    // Orthogonal: [1, 0] . [0, 1] = 0.
+    #[case::orthogonal(&[2], &[1.0, 0.0], &[0.0, 1.0], &[0.0])]
+    // Parallel: [3, 4] . [3, 4] = 9 + 16 = 25.
+    #[case::parallel(&[2], &[3.0, 4.0], &[3.0, 4.0], &[25.0])]
+    // Antiparallel: [1, 2] . [-1, -2] = -1 + -4 = -5.
+    #[case::antiparallel(&[2], &[1.0, 2.0], &[-1.0, -2.0], &[-5.0])]
+    // Scaled: [2, 0] . [3, 0] = 6.
+    #[case::scaled(&[2], &[2.0, 0.0], &[3.0, 0.0], &[6.0])]
+    fn single_row(
+        #[case] shape: &[usize],
+        #[case] lhs_elems: &[f64],
+        #[case] rhs_elems: &[f64],
+        #[case] expected: &[f64],
+    ) -> VortexResult<()> {
+        let lhs = tensor_array(shape, lhs_elems)?;
+        let rhs = tensor_array(shape, rhs_elems)?;
+        assert_close(&eval_inner_product(lhs, rhs, 1)?, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn multiple_rows() -> VortexResult<()> {
+        let lhs = tensor_array(
+            &[3],
+            &[
+                1.0, 0.0, 0.0, // tensor 0
+                3.0, 4.0, 0.0, // tensor 1
+                1.0, 1.0, 1.0, // tensor 2
+            ],
+        )?;
+        let rhs = tensor_array(
+            &[3],
+            &[
+                0.0, 1.0, 0.0, // tensor 0: dot = 0
+                3.0, 4.0, 0.0, // tensor 1: dot = 25
+                2.0, 2.0, 2.0, // tensor 2: dot = 6
+            ],
+        )?;
+        assert_close(&eval_inner_product(lhs, rhs, 3)?, &[0.0, 25.0, 6.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn vector_inner_product() -> VortexResult<()> {
+        let lhs = vector_array(
+            2,
+            &[
+                3.0, 4.0, // vector 0
+                1.0, 0.0, // vector 1
+            ],
+        )?;
+        let rhs = vector_array(
+            2,
+            &[
+                3.0, 4.0, // vector 0: dot = 25
+                0.0, 1.0, // vector 1: dot = 0
+            ],
+        )?;
+        assert_close(&eval_inner_product(lhs, rhs, 2)?, &[25.0, 0.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn null_input_row() -> VortexResult<()> {
+        // 3 rows of dim-2 vectors. Row 1 of lhs is masked as null.
+        let lhs = tensor_array(&[2], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0])?;
+        let rhs = tensor_array(&[2], &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0])?;
+        let lhs = MaskedArray::try_new(lhs, Validity::from_iter([true, false, true]))?.into_array();
+
+        let scalar_fn = ScalarFn::new(InnerProduct, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
+
+        // Row 0: 1*7 + 2*8 = 23, row 1: null, row 2: 5*11 + 6*12 = 127.
+        assert!(prim.is_valid(0)?);
+        assert!(!prim.is_valid(1)?);
+        assert!(prim.is_valid(2)?);
+        assert_close(&[prim.as_slice::<f64>()[0]], &[23.0]);
+        assert_close(&[prim.as_slice::<f64>()[2]], &[127.0]);
+        Ok(())
+    }
+
+    #[test]
+    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(&ApproxOptions::Exact, lhs, rhs, 2);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    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(&ApproxOptions::Exact, lhs, rhs, 1);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    /// Creates an `L2Denorm` scalar function array from pre-normalized elements and norms.
+    fn l2_denorm_array(
+        shape: &[usize],
+        normalized_elements: &[f64],
+        norms: &[f64],
+    ) -> VortexResult<ArrayRef> {
+        use vortex_array::IntoArray;
+
+        let len = norms.len();
+        let normalized = tensor_array(shape, normalized_elements)?;
+        let norms = PrimitiveArray::from_iter(norms.iter().copied()).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+        Ok(
+            L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, len, &mut ctx)?
+                .into_array(),
+        )
+    }
+
+    #[test]
+    fn both_denorm() -> VortexResult<()> {
+        // LHS: [3.0, 4.0] = L2Denorm([0.6, 0.8], 5.0).
+        // RHS: [1.0, 0.0] = L2Denorm([1.0, 0.0], 1.0).
+        // dot([3.0, 4.0], [1.0, 0.0]) = 3.0.
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0])?;
+        let rhs = l2_denorm_array(&[2], &[1.0, 0.0], &[1.0])?;
+
+        // 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]);
+        Ok(())
+    }
+
+    #[test]
+    fn both_denorm_multiple_rows() -> VortexResult<()> {
+        // Row 0: [3.0, 4.0] dot [3.0, 4.0] = 25.0.
+        // Row 1: [1.0, 0.0] dot [0.0, 1.0] = 0.0.
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 0.0, 1.0], &[5.0, 1.0])?;
+
+        assert_close(&eval_inner_product(lhs, rhs, 2)?, &[25.0, 0.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn one_side_denorm_lhs() -> VortexResult<()> {
+        // LHS: L2Denorm([0.6, 0.8], 5.0) representing [3.0, 4.0].
+        // RHS: plain [1.0, 2.0].
+        // dot([3.0, 4.0], [1.0, 2.0]) = 3.0 + 8.0 = 11.0.
+        let lhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0])?;
+        let rhs = tensor_array(&[2], &[1.0, 2.0])?;
+
+        assert_close(&eval_inner_product(lhs, rhs, 1)?, &[11.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn one_side_denorm_rhs() -> VortexResult<()> {
+        // LHS: plain [1.0, 2.0].
+        // RHS: L2Denorm([0.6, 0.8], 5.0) representing [3.0, 4.0].
+        // dot([1.0, 2.0], [3.0, 4.0]) = 3.0 + 8.0 = 11.0.
+        let lhs = tensor_array(&[2], &[1.0, 2.0])?;
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0])?;
+
+        assert_close(&eval_inner_product(lhs, rhs, 1)?, &[11.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn both_denorm_null_norms() -> VortexResult<()> {
+        // Row 0: valid, row 1: null (via nullable norms on lhs).
+        let normalized_l = tensor_array(&[2], &[0.6, 0.8, 1.0, 0.0])?;
+        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(&ApproxOptions::Exact, normalized_l, norms_l, 2, &mut ctx)?
+                .into_array();
+        let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0])?;
+
+        let scalar_fn = ScalarFn::new(InnerProduct, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        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.
+        assert!(prim.is_valid(0)?);
+        assert!(!prim.is_valid(1)?);
+        assert_close(&[prim.as_slice::<f64>()[0]], &[25.0]);
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/scalar_fns/l2_denorm.rs b/vortex-tensor/src/scalar_fns/l2_denorm.rs
new file mode 100644
index 00000000000..04a348ff7d8
--- /dev/null
+++ b/vortex-tensor/src/scalar_fns/l2_denorm.rs
@@ -0,0 +1,745 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! L2 denormalization expression for tensor-like types.
+
+use std::fmt::Formatter;
+
+use num_traits::ToPrimitive;
+use num_traits::Zero;
+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::dtype::DType;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::PType;
+use vortex_array::expr::Expression;
+use vortex_array::expr::and;
+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::ScalarFn;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+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_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+
+use crate::matcher::AnyTensor;
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::l2_norm::L2Norm;
+use crate::utils::extract_flat_elements;
+use crate::utils::validate_tensor_float_input;
+
+/// Re-applies L2 norms to a normalized tensor column.
+///
+/// Computes `normalized * norm` on each row over the flat backing buffer of each tensor-like type.
+///
+/// The normalized input must be a tensor-like extension array with a float element type and each
+/// non-null row is semantically required to already be L2-normalized.
+///
+/// The norms input must be a primitive float column with the same element type as the normalized
+/// tensor elements.
+#[derive(Clone)]
+pub struct L2Denorm;
+
+impl L2Denorm {
+    /// Creates a new [`ScalarFn`] wrapping the L2 denormalization operation with the given
+    /// [`ApproxOptions`] controlling approximation behavior.
+    ///
+    /// This is a low-level scalar-function descriptor constructor. To build a semantically valid
+    /// [`L2Denorm`] array, prefer [`try_new_array`](Self::try_new_array).
+    pub fn new(options: &ApproxOptions) -> ScalarFn<L2Denorm> {
+        ScalarFn::new(L2Denorm, options.clone())
+    }
+
+    /// Constructs a validated [`ScalarFnArray`] that lazily re-applies `norms` to `normalized`.
+    ///
+    /// This is the correct constructor for [`L2Denorm`] arrays. In addition to the structural
+    /// checks performed by [`ScalarFnArray::try_new`], it validates that every valid row of the
+    /// `normalized` child has L2 norm `1.0` (or `0.0` for zero rows), within the tolerance implied
+    /// by the child element precision. It also validates that stored norms are non-negative, and
+    /// that any row with stored norm `0.0` has an all-zero normalized row.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
+    /// mismatches) or if the `normalized` child is not row-wise L2-normalized.
+    pub fn try_new_array(
+        options: &ApproxOptions,
+        normalized: ArrayRef,
+        norms: ArrayRef,
+        len: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ScalarFnArray> {
+        let result = ScalarFnArray::try_new(
+            L2Denorm::new(options).erased(),
+            vec![normalized.clone(), norms.clone()],
+            len,
+        )?;
+
+        validate_l2_denorm_children(normalized, norms, ctx)?;
+
+        Ok(result)
+    }
+
+    /// Constructs an [`L2Denorm`] array without validating that the `normalized` child is actually
+    /// row-wise L2-normalized.
+    ///
+    /// This escape hatch is intended for advanced callers that already established, or
+    /// intentionally relax, the normalized-child invariant. Structural validation still runs via
+    /// [`ScalarFnArray::try_new`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the `normalized` child is semantically suitable for L2
+    /// denormalization, which typically means every valid row is unit-norm or zero. Violating this
+    /// invariant will not cause memory unsafety, but may produce incorrect results.
+    pub unsafe fn new_array_unchecked(
+        options: &ApproxOptions,
+        normalized: ArrayRef,
+        norms: ArrayRef,
+        len: usize,
+    ) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(
+            L2Denorm::new(options).erased(),
+            vec![normalized, norms],
+            len,
+        )
+    }
+}
+
+impl ScalarFnVTable for L2Denorm {
+    type Options = ApproxOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::new_ref("vortex.tensor.l2_denorm")
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Exact(2)
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        match child_idx {
+            0 => ChildName::from("normalized"),
+            1 => ChildName::from("norms"),
+            _ => unreachable!("L2Denorm must have exactly two children"),
+        }
+    }
+
+    fn fmt_sql(
+        &self,
+        _options: &Self::Options,
+        expr: &Expression,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
+        write!(f, "l2_denorm(")?;
+        expr.child(0).fmt_sql(f)?;
+        write!(f, ", ")?;
+        expr.child(1).fmt_sql(f)?;
+        write!(f, ")")
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
+        let normalized = &arg_dtypes[0];
+        let norms = &arg_dtypes[1];
+
+        let tensor_match = validate_tensor_float_input(normalized)?;
+        let element_ptype = tensor_match.element_ptype();
+
+        let DType::Primitive(norms_ptype, _) = norms else {
+            vortex_bail!("L2Denorm norms must be a primitive float array, got {norms}");
+        };
+        vortex_ensure_eq!(
+            *norms_ptype,
+            element_ptype,
+            "L2Denorm norms dtype must match normalized element dtype ({element_ptype}), \
+                got {norms_ptype}",
+        );
+
+        Ok(normalized.union_nullability(norms.nullability()))
+    }
+
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let normalized: ExtensionArray = args.get(0)?.execute(ctx)?;
+        let norms: PrimitiveArray = args.get(1)?.execute(ctx)?;
+        let row_count = args.row_count();
+
+        let tensor_match = normalized
+            .dtype()
+            .as_extension()
+            .metadata_opt::<AnyTensor>()
+            .vortex_expect("we already validated this in `return_dtype`");
+        let tensor_flat_size = tensor_match.list_size();
+
+        let validity = normalized.as_ref().validity()?.and(norms.validity()?)?;
+        let output_dtype = normalized
+            .dtype()
+            .union_nullability(norms.dtype().nullability());
+        let flat = extract_flat_elements(normalized.storage_array(), tensor_flat_size, ctx)?;
+
+        // TODO(connor): Theoretically we could model this as a multiplication between the
+        // normalized array and a `RunEnd(Sequence(0, dimensions), norms)`. But since we have
+        // already canonicalized the array, it is probably not faster to do that.
+        match_each_float_ptype!(flat.ptype(), |T| {
+            let norms = norms.as_slice::<T>();
+
+            let elements: Buffer<T> = (0..row_count)
+                .flat_map(|i| {
+                    let norm = norms[i];
+                    flat.row::<T>(i).iter().map(move |&x| x * norm)
+                })
+                .collect();
+
+            build_tensor_array(
+                output_dtype,
+                tensor_flat_size,
+                row_count,
+                validity,
+                elements,
+            )
+        })
+    }
+
+    fn validity(
+        &self,
+        _options: &Self::Options,
+        expression: &Expression,
+    ) -> VortexResult<Option<Expression>> {
+        let normalized_validity = expression.child(0).validity()?;
+        let norms_validity = expression.child(1).validity()?;
+
+        Ok(Some(and(normalized_validity, norms_validity)))
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        false
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
+
+/// Builds an unexecuted [`L2Denorm`] expression by normalizing `input` and reattaching the exact
+/// norms as the norms child.
+///
+/// The returned array is a lazy `L2Denorm(normalized, norms)` scalar function array.
+///
+/// # Normalized child
+///
+/// The normalized child is always **non-nullable** with [`Validity::NonNullable`]. Every non-null
+/// row with a positive L2 norm is divided by its norm to produce a unit-norm vector.
+///
+/// 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).
+///
+/// # Nullability
+///
+/// Nullability is tracked entirely by the norms child. Null input rows produce null norms via
+/// [`L2Norm`]'s validity propagation. When the [`L2Denorm`] wrapper is executed, its validity is
+/// `and(normalized_validity, norms_validity)`, which correctly identifies originally-null rows
+/// since the normalized child is all-valid and the norms child carries the original nulls.
+pub fn normalize_as_l2_denorm(
+    options: &ApproxOptions,
+    input: ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ScalarFnArray> {
+    let row_count = input.len();
+    let tensor_match = validate_tensor_float_input(input.dtype())?;
+    let tensor_flat_size = tensor_match.list_size();
+
+    let norms_sfn = L2Norm::try_new_array(options, input.clone(), row_count)?;
+    let norms_array: ArrayRef = norms_sfn.into_array().execute(ctx)?;
+    let norms: PrimitiveArray = norms_array.clone().execute(ctx)?;
+    let norms_validity = norms.validity()?;
+
+    let input: ExtensionArray = input.execute(ctx)?;
+    let normalized_dtype = input.dtype().as_nonnullable();
+    let flat = extract_flat_elements(input.storage_array(), tensor_flat_size, ctx)?;
+
+    let normalized = match_each_float_ptype!(flat.ptype(), |T| {
+        let norm_values = norms.as_slice::<T>();
+
+        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 norm = norm_values[i];
+
+            // SAFETY: We allocated `row_count * tensor_flat_size` capacity and push exactly
+            // `tensor_flat_size` elements per row.
+
+            // Null rows must be explicitly zeroed out.
+            if !is_valid || norm == T::zero() {
+                unsafe { elements.push_n_unchecked(T::zero(), tensor_flat_size) };
+            } else {
+                for &x in flat.row::<T>(i) {
+                    unsafe { elements.push_unchecked(x / norm) };
+                }
+            }
+        }
+
+        build_tensor_array(
+            normalized_dtype,
+            tensor_flat_size,
+            row_count,
+            Validity::NonNullable,
+            elements.freeze(),
+        )
+    })?;
+
+    // TODO(connor): Need to figure out a way to not run validation.
+    L2Denorm::try_new_array(options, normalized, norms_array, row_count, ctx)
+}
+
+/// Rebuilds a tensor-like extension array from flat primitive elements.
+///
+/// # Errors
+///
+/// Returns an error if the elements are invalid (have incorrect lengths for the
+/// `FixedSizeListArray` storage array).
+fn build_tensor_array<T: NativePType>(
+    dtype: DType,
+    tensor_flat_size: usize,
+    row_count: usize,
+    validity: Validity,
+    elements: Buffer<T>,
+) -> VortexResult<ArrayRef> {
+    let list_size =
+        u32::try_from(tensor_flat_size).vortex_expect("tensor flat size must fit into `u32`");
+
+    // SAFETY: Validity has no length (because tensor elements are always non-nullable).
+    let elements = unsafe { PrimitiveArray::new_unchecked(elements, Validity::NonNullable) };
+
+    let storage =
+        FixedSizeListArray::try_new(elements.into_array(), list_size, validity, row_count)?;
+
+    Ok(ExtensionArray::new(dtype.as_extension().clone(), storage.into_array()).into_array())
+}
+
+/// Returns the acceptable unit-norm drift for the given element precision.
+fn unit_norm_tolerance(element_ptype: PType) -> f64 {
+    match element_ptype {
+        PType::F16 => 2e-3,
+        PType::F32 => 2e-6,
+        PType::F64 => 1e-10,
+        _ => unreachable!("L2Denorm requires float elements, got {element_ptype:?}"),
+    }
+}
+
+/// Validates that every valid row of `input` is already L2-normalized (either length 1 or 0).
+pub fn validate_l2_normalized_rows(input: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<()> {
+    validate_l2_normalized_rows_impl(input, None, ctx)
+}
+
+/// Validates that the `normalized` and `norms` children jointly satisfy the [`L2Denorm`]
+/// invariants, which are:
+///
+/// - All vectors in the normalized array have length 1 or 0.
+/// - If the vector has a norm of 0, then the vector must be all 0s.
+fn validate_l2_denorm_children(
+    normalized: ArrayRef,
+    norms: ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    validate_l2_normalized_rows_impl(normalized, Some(norms), ctx)
+}
+
+fn validate_l2_normalized_rows_impl(
+    normalized: ArrayRef,
+    norms: Option<ArrayRef>,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let row_count = normalized.len();
+    if row_count == 0 {
+        return Ok(());
+    }
+
+    let tensor_match = validate_tensor_float_input(normalized.dtype())?;
+    let element_ptype = tensor_match.element_ptype();
+    let tolerance = unit_norm_tolerance(element_ptype);
+    let tensor_flat_size = tensor_match.list_size();
+
+    let normalized: ExtensionArray = normalized.execute(ctx)?;
+    let normalized_validity = normalized.as_ref().validity()?;
+    let flat = extract_flat_elements(normalized.storage_array(), tensor_flat_size, ctx)?;
+    let norms = norms
+        .map(|norms| norms.execute::<PrimitiveArray>(ctx))
+        .transpose()?;
+
+    let combined_validity = match &norms {
+        Some(norms) => normalized_validity.and(norms.validity()?)?,
+        None => normalized_validity,
+    };
+
+    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)? {
+                continue;
+            }
+
+            let (row_norm_sq, is_zero_row) =
+                flat.row::<T>(i)
+                    .iter()
+                    .fold((0.0f64, true), |(sum_sq, is_zero), x| {
+                        let value = ToPrimitive::to_f64(x).unwrap_or(f64::NAN);
+                        (sum_sq + value * value, is_zero && value.abs() <= tolerance)
+                    });
+            let row_norm = row_norm_sq.sqrt();
+
+            vortex_ensure!(
+                row_norm == 0.0 || (row_norm - 1.0).abs() <= tolerance,
+                "L2Denorm normalized child must have L2 norm 1.0 or 0.0, but row {i} has \
+                 {row_norm:.6}",
+            );
+
+            if let Some(stored_norms) = stored_norms {
+                let stored_norm_f64 = ToPrimitive::to_f64(&stored_norms[i]).unwrap_or(f64::NAN);
+                vortex_ensure!(
+                    stored_norm_f64 >= 0.0,
+                    "L2Denorm norms must be non-negative, but row {i} has {stored_norm_f64:.6}",
+                );
+
+                if stored_norm_f64 == 0.0 {
+                    vortex_ensure!(
+                        is_zero_row,
+                        "L2Denorm normalized child must be all zeros when norms row {i} is 0.0",
+                    );
+                }
+            }
+        }
+    });
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    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::MaskedArray;
+    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::dtype::DType;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_array::extension::EmptyMetadata;
+    use vortex_array::extension::datetime::Date;
+    use vortex_array::extension::datetime::TimeUnit;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::fixed_shape::FixedShapeTensor;
+    use crate::fixed_shape::FixedShapeTensorMetadata;
+    use crate::scalar_fns::ApproxOptions;
+    use crate::scalar_fns::l2_denorm::L2Denorm;
+    use crate::scalar_fns::l2_denorm::normalize_as_l2_denorm;
+    use crate::scalar_fns::l2_denorm::validate_l2_normalized_rows;
+    use crate::utils::test_helpers::assert_close;
+    use crate::utils::test_helpers::constant_tensor_array;
+    use crate::utils::test_helpers::constant_vector_array;
+    use crate::utils::test_helpers::tensor_array;
+    use crate::utils::test_helpers::vector_array;
+    use crate::vector::Vector;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    /// 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> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let result =
+            L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, len, &mut ctx)?;
+        result.into_array().execute(&mut ctx)
+    }
+
+    fn integer_tensor_array(shape: &[usize], elements: &[i32]) -> VortexResult<ArrayRef> {
+        let list_size: u32 = shape.iter().product::<usize>().max(1).try_into().unwrap();
+        let row_count = elements.len() / list_size as usize;
+
+        let elems: ArrayRef = Buffer::copy_from(elements).into_array();
+        let fsl = FixedSizeListArray::new(elems, list_size, Validity::NonNullable, row_count);
+
+        let metadata = FixedShapeTensorMetadata::new(shape.to_vec());
+        let ext_dtype =
+            ExtDType::<FixedShapeTensor>::try_new(metadata, fsl.dtype().clone())?.erased();
+
+        Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array())
+    }
+
+    fn non_tensor_extension_array() -> VortexResult<ArrayRef> {
+        let storage = PrimitiveArray::from_iter([1i32, 2]).into_array();
+        let ext_dtype =
+            ExtDType::<Date>::try_new(TimeUnit::Days, storage.dtype().clone())?.erased();
+        Ok(ExtensionArray::new(ext_dtype, storage).into_array())
+    }
+
+    fn f16_vector_array(dim: u32, elements: &[f32]) -> VortexResult<ArrayRef> {
+        let row_count = elements.len() / dim as usize;
+        let values: Vec<_> = elements.iter().copied().map(half::f16::from_f32).collect();
+        let elems: ArrayRef = Buffer::copy_from(values.as_slice()).into_array();
+        let fsl = FixedSizeListArray::new(elems, dim, Validity::NonNullable, row_count);
+
+        let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())?.erased();
+        Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array())
+    }
+
+    fn tensor_snapshot(array: ArrayRef) -> VortexResult<(DType, Vec<bool>, Vec<f64>)> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let ext: ExtensionArray = array.execute(&mut ctx)?;
+        let validity = (0..ext.len())
+            .map(|i| ext.is_valid(i))
+            .collect::<VortexResult<Vec<_>>>()?;
+        let storage: FixedSizeListArray = ext.storage_array().clone().execute(&mut ctx)?;
+        let elements: PrimitiveArray = storage.elements().clone().execute(&mut ctx)?;
+        Ok((
+            ext.dtype().clone(),
+            validity,
+            elements.as_slice::<f64>().to_vec(),
+        ))
+    }
+
+    fn assert_tensor_arrays_eq(actual: ArrayRef, expected: ArrayRef) -> VortexResult<()> {
+        let (actual_dtype, actual_validity, actual_elements) = tensor_snapshot(actual)?;
+        let (expected_dtype, expected_validity, expected_elements) = tensor_snapshot(expected)?;
+
+        assert_eq!(actual_dtype, expected_dtype);
+        assert_eq!(actual_validity, expected_validity);
+        assert_close(&actual_elements, &expected_elements);
+        Ok(())
+    }
+
+    #[test]
+    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 expected = vector_array(3, &[3.0, 4.0, 0.0, 0.0, 0.0, 0.0])?;
+
+        assert_tensor_arrays_eq(actual, expected)?;
+        Ok(())
+    }
+
+    #[test]
+    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 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)?;
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_null_propagation() -> VortexResult<()> {
+        let lhs = vector_array(2, &[0.6, 0.8, 1.0, 0.0, 0.0, 0.0])?;
+        let lhs = MaskedArray::try_new(lhs, Validity::from_iter([true, false, true]))?.into_array();
+
+        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 storage: FixedSizeListArray = actual.storage_array().clone().execute(&mut ctx)?;
+        let elements: PrimitiveArray = storage.elements().clone().execute(&mut ctx)?;
+
+        assert!(actual.is_valid(0)?);
+        assert!(!actual.is_valid(1)?);
+        assert!(!actual.is_valid(2)?);
+        assert_close(&elements.as_slice::<f64>()[..2], &[3.0, 4.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_rejects_non_extension_lhs() {
+        let lhs = PrimitiveArray::from_iter([1.0f64, 2.0]).into_array();
+        let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
+
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, lhs, rhs, 2, &mut ctx);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn l2_denorm_rejects_non_tensor_extension_lhs() -> VortexResult<()> {
+        let lhs = non_tensor_extension_array()?;
+        let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
+
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, lhs, rhs, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_rejects_integer_tensor_lhs() -> VortexResult<()> {
+        let lhs = integer_tensor_array(&[2], &[1, 2, 3, 4])?;
+        let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
+
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, lhs, rhs, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_rejects_mismatched_rhs_ptype() -> VortexResult<()> {
+        let lhs = vector_array(2, &[1.0, 0.0, 0.0, 1.0])?;
+        let rhs = PrimitiveArray::from_iter([1.0f32, 1.0]).into_array();
+
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, lhs, rhs, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn validate_l2_normalized_rows_accepts_normalized_f16_input() -> VortexResult<()> {
+        let input = f16_vector_array(2, &[3.0, 4.0, 0.0, 0.0])?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input, &mut ctx)?;
+        validate_l2_normalized_rows(roundtrip.child_at(0).clone(), &mut ctx)?;
+        Ok(())
+    }
+
+    #[test]
+    fn validate_l2_normalized_rows_rejects_unnormalized_input() -> VortexResult<()> {
+        let input = vector_array(2, &[3.0, 4.0, 1.0, 0.0])?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = validate_l2_normalized_rows(input, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_try_new_array_rejects_unnormalized_child() -> VortexResult<()> {
+        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 mut ctx = SESSION.create_execution_ctx();
+
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_try_new_array_rejects_nonzero_row_with_zero_norm() -> VortexResult<()> {
+        let normalized = vector_array(2, &[1.0, 0.0, 0.0, 0.0])?;
+        let norms = PrimitiveArray::from_iter([0.0f64, 0.0]).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_try_new_array_rejects_negative_norms() -> VortexResult<()> {
+        let normalized = vector_array(2, &[1.0, 0.0, 0.0, 1.0])?;
+        let norms = PrimitiveArray::from_iter([1.0f64, -1.0]).into_array();
+        let mut ctx = SESSION.create_execution_ctx();
+
+        let result = L2Denorm::try_new_array(&ApproxOptions::Exact, normalized, norms, 2, &mut ctx);
+        assert!(result.is_err());
+        Ok(())
+    }
+
+    #[test]
+    fn l2_denorm_new_array_unchecked_accepts_unnormalized_child() -> VortexResult<()> {
+        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(&ApproxOptions::Exact, normalized, norms, 2) };
+        assert!(result.is_ok());
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_as_l2_denorm_roundtrips_vectors() -> VortexResult<()> {
+        let input = vector_array(3, &[3.0, 4.0, 0.0, 0.0, 0.0, 0.0])?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input.clone(), &mut ctx)?;
+        let actual = roundtrip.into_array().execute(&mut ctx)?;
+
+        assert_tensor_arrays_eq(actual, input)?;
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_as_l2_denorm_roundtrips_fixed_shape_tensors() -> VortexResult<()> {
+        let input = tensor_array(&[2, 2], &[1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 0.0, 0.0])?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input.clone(), &mut ctx)?;
+        let actual = roundtrip.into_array().execute(&mut ctx)?;
+
+        assert_tensor_arrays_eq(actual, input)?;
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_as_l2_denorm_supports_constant_tensors() -> VortexResult<()> {
+        let input = constant_tensor_array(&[2], &[3.0, 4.0], 3)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input.clone(), &mut ctx)?;
+        let actual = roundtrip.into_array().execute(&mut ctx)?;
+
+        assert_tensor_arrays_eq(actual, input)?;
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_as_l2_denorm_supports_constant_vectors() -> VortexResult<()> {
+        let input = constant_vector_array(&[3.0, 4.0], 2)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input.clone(), &mut ctx)?;
+        let actual = roundtrip.into_array().execute(&mut ctx)?;
+
+        assert_tensor_arrays_eq(actual, input)?;
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_as_l2_denorm_uses_zero_rows_for_zero_norms() -> VortexResult<()> {
+        let input = vector_array(2, &[0.0, 0.0, 3.0, 4.0])?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let roundtrip = normalize_as_l2_denorm(&ApproxOptions::Exact, input.clone(), &mut ctx)?;
+        let normalized: ExtensionArray = roundtrip.child_at(0).clone().execute(&mut ctx)?;
+        let storage: FixedSizeListArray = normalized.storage_array().clone().execute(&mut ctx)?;
+        let elements: PrimitiveArray = storage.elements().clone().execute(&mut ctx)?;
+        let actual = roundtrip.into_array().execute(&mut ctx)?;
+
+        assert_close(&elements.as_slice::<f64>()[..2], &[0.0, 0.0]);
+        assert_tensor_arrays_eq(actual, input)?;
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/scalar_fns/l2_norm.rs b/vortex-tensor/src/scalar_fns/l2_norm.rs
new file mode 100644
index 00000000000..2632c07cffd
--- /dev/null
+++ b/vortex-tensor/src/scalar_fns/l2_norm.rs
@@ -0,0 +1,281 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! L2 norm expression for tensor-like types.
+
+use std::fmt::Formatter;
+
+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::PrimitiveArray;
+use vortex_array::arrays::ScalarFnArray;
+use vortex_array::arrays::ScalarFnVTable as ScalarFnArrayVTable;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::Nullability;
+use vortex_array::expr::Expression;
+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::ScalarFn;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure_eq;
+
+use crate::matcher::AnyTensor;
+use crate::scalar_fns::ApproxOptions;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+use crate::utils::extract_flat_elements;
+use crate::utils::validate_tensor_float_input;
+
+/// L2 norm (Euclidean norm) of a tensor or vector column.
+///
+/// Computes `||v|| = sqrt(sum(v_i^2))` over the flat backing buffer of each tensor-like type.
+///
+/// The input must be a tensor-like extension array with a float element type. The output is a float
+/// column of the same float type.
+#[derive(Clone)]
+pub struct L2Norm;
+
+impl L2Norm {
+    /// Creates a new [`ScalarFn`] wrapping the L2 norm operation with the given [`ApproxOptions`]
+    /// controlling approximation behavior.
+    pub fn new(options: &ApproxOptions) -> ScalarFn<L2Norm> {
+        ScalarFn::new(L2Norm, options.clone())
+    }
+
+    /// Constructs a [`ScalarFnArray`] that lazily computes the L2 norm over `child`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
+    /// mismatches).
+    pub fn try_new_array(
+        options: &ApproxOptions,
+        child: ArrayRef,
+        len: usize,
+    ) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(L2Norm::new(options).erased(), vec![child], len)
+    }
+}
+
+impl ScalarFnVTable for L2Norm {
+    type Options = ApproxOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.tensor.l2_norm")
+    }
+
+    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("input"),
+            _ => unreachable!("L2Norm must have exactly one child"),
+        }
+    }
+
+    fn fmt_sql(
+        &self,
+        _options: &Self::Options,
+        expr: &Expression,
+        f: &mut Formatter<'_>,
+    ) -> std::fmt::Result {
+        write!(f, "l2_norm(")?;
+        expr.child(0).fmt_sql(f)?;
+        write!(f, ")")
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
+        let input_dtype = &arg_dtypes[0];
+        let tensor_match = validate_tensor_float_input(input_dtype)?;
+        let ptype = tensor_match.element_ptype();
+
+        let nullability = Nullability::from(input_dtype.is_nullable());
+        Ok(DType::Primitive(ptype, nullability))
+    }
+
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input_ref = args.get(0)?;
+        let row_count = args.row_count();
+
+        let ext = input_ref.dtype().as_extension();
+        let tensor_match = ext
+            .metadata_opt::<AnyTensor>()
+            .vortex_expect("we already validated this in `return_dtype`");
+        let tensor_flat_size = tensor_match.list_size();
+        let element_ptype = tensor_match.element_ptype();
+
+        // L2Norm(L2Denorm(normalized, norms)) == norms, since normalized vectors have unit norm
+        // and L2 norms are non-negative. This avoids decompressing the TQ child just to recompute
+        // norms that are already stored.
+        if let Some(sfn) = input_ref.as_opt::<ScalarFnArrayVTable>()
+            && sfn.scalar_fn().as_opt::<L2Denorm>().is_some()
+        {
+            let norms: PrimitiveArray = sfn.child_at(1).clone().execute(ctx)?;
+
+            vortex_ensure_eq!(
+                norms.dtype(),
+                &DType::Primitive(element_ptype, input_ref.dtype().nullability())
+            );
+
+            return Ok(norms.into_array());
+        }
+
+        let input: ExtensionArray = input_ref.execute(ctx)?;
+        let validity = input.as_ref().validity()?;
+
+        let storage = input.storage_array();
+        let flat = extract_flat_elements(storage, tensor_flat_size, ctx)?;
+
+        match_each_float_ptype!(flat.ptype(), |T| {
+            let buffer: Buffer<T> = (0..row_count)
+                .map(|i| l2_norm_row(flat.row::<T>(i)))
+                .collect();
+
+            // SAFETY: The buffer length equals `row_count`, which matches the source validity
+            // length.
+            Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
+        })
+    }
+
+    fn validity(
+        &self,
+        _options: &Self::Options,
+        expression: &Expression,
+    ) -> VortexResult<Option<Expression>> {
+        // The result is null if the input tensor is null.
+        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
+    }
+}
+
+/// Computes the L2 norm (Euclidean norm) of a float slice.
+///
+/// Returns `sqrt(sum(v_i^2))`. A zero-length or all-zero input produces `0.0`.
+fn l2_norm_row<T: Float + NativePType>(v: &[T]) -> T {
+    let mut sum_sq = T::zero();
+    for &x in v {
+        sum_sq = sum_sq + x * x;
+    }
+    sum_sq.sqrt()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use rstest::rstest;
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::MaskedArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::ScalarFnArray;
+    use vortex_array::scalar_fn::ScalarFn;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::scalar_fns::ApproxOptions;
+    use crate::scalar_fns::l2_norm::L2Norm;
+    use crate::utils::test_helpers::assert_close;
+    use crate::utils::test_helpers::tensor_array;
+    use crate::utils::test_helpers::vector_array;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+    /// 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>> {
+        let scalar_fn = ScalarFn::new(L2Norm, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![input], len)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
+        Ok(prim.as_slice::<f64>().to_vec())
+    }
+
+    #[rstest]
+    #[case::three_four_five(&[2], &[3.0, 4.0], &[5.0])]
+    #[case::zero_vector(&[3], &[0.0, 0.0, 0.0], &[0.0])]
+    #[case::single_element(&[1], &[7.0], &[7.0])]
+    #[case::negative_elements(&[2], &[-3.0, -4.0], &[5.0])]
+    fn known_norms(
+        #[case] shape: &[usize],
+        #[case] elements: &[f64],
+        #[case] expected: &[f64],
+    ) -> VortexResult<()> {
+        let arr = tensor_array(shape, elements)?;
+        assert_close(&eval_l2_norm(arr, 1)?, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn multiple_rows() -> VortexResult<()> {
+        let arr = tensor_array(
+            &[3],
+            &[
+                3.0, 4.0, 0.0, // norm = 5.0
+                0.0, 0.0, 0.0, // norm = 0.0
+                1.0, 1.0, 1.0, // norm = sqrt(3)
+            ],
+        )?;
+        assert_close(&eval_l2_norm(arr, 3)?, &[5.0, 0.0, 3.0_f64.sqrt()]);
+        Ok(())
+    }
+
+    #[test]
+    fn vector_multiple_rows() -> VortexResult<()> {
+        let arr = vector_array(
+            3,
+            &[
+                1.0, 0.0, 0.0, // norm = 1.0
+                3.0, 4.0, 0.0, // norm = 5.0
+            ],
+        )?;
+        assert_close(&eval_l2_norm(arr, 2)?, &[1.0, 5.0]);
+        Ok(())
+    }
+
+    #[test]
+    fn null_input_row() -> VortexResult<()> {
+        // 2 rows of dim-2 vectors. Row 1 is masked as null.
+        let arr = tensor_array(&[2], &[3.0, 4.0, 0.0, 0.0])?;
+        let arr = MaskedArray::try_new(arr, Validity::from_iter([true, false]))?.into_array();
+
+        let scalar_fn = ScalarFn::new(L2Norm, ApproxOptions::Exact).erased();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![arr], 2)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
+
+        // Row 0: norm = 5.0, row 1: null.
+        assert!(prim.is_valid(0)?);
+        assert!(!prim.is_valid(1)?);
+        assert_close(&[prim.as_slice::<f64>()[0]], &[5.0]);
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/scalar_fns/mod.rs b/vortex-tensor/src/scalar_fns/mod.rs
new file mode 100644
index 00000000000..32db845a6e2
--- /dev/null
+++ b/vortex-tensor/src/scalar_fns/mod.rs
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Scalar function expressions defined on tensor and tensor-like extension types.
+
+use std::fmt;
+
+pub mod cosine_similarity;
+pub mod inner_product;
+pub mod l2_denorm;
+pub mod l2_norm;
+
+/// Options for tensor-related expressions that might have error.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+pub enum ApproxOptions {
+    /// Computes the exact result.
+    #[default]
+    Exact,
+    /// Allows approximate results.
+    Approximate,
+}
+
+impl ApproxOptions {
+    /// Returns `true` if the option is [`Exact`](Self::Exact).
+    pub fn is_exact(&self) -> bool {
+        matches!(self, Self::Exact)
+    }
+
+    /// Returns `true` if the option is [`Approximate`](Self::Approximate).
+    pub fn is_approx(&self) -> bool {
+        matches!(self, Self::Approximate)
+    }
+}
+
+impl fmt::Display for ApproxOptions {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Exact => write!(f, "Exact"),
+            Self::Approximate => write!(f, "Approximate"),
+        }
+    }
+}
diff --git a/vortex-tensor/src/utils.rs b/vortex-tensor/src/utils.rs
new file mode 100644
index 00000000000..4d78597c962
--- /dev/null
+++ b/vortex-tensor/src/utils.rs
@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+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::FixedSizeListArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::scalar_fn::ExactScalarFn;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::PType;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+use crate::matcher::AnyTensor;
+use crate::matcher::TensorMatch;
+use crate::scalar_fns::l2_denorm::L2Denorm;
+
+/// Validates that `input_dtype` is a float-valued tensor-like extension dtype.
+pub fn validate_tensor_float_input(input_dtype: &DType) -> VortexResult<TensorMatch<'_>> {
+    let ext = input_dtype
+        .as_extension_opt()
+        .ok_or_else(|| vortex_err!("expected an extension type, got {input_dtype}"))?;
+
+    let tensor_match = ext
+        .metadata_opt::<AnyTensor>()
+        .ok_or_else(|| vortex_err!("expected an `AnyTensor`, got {input_dtype}"))?;
+
+    let ptype = tensor_match.element_ptype();
+    vortex_ensure!(
+        ptype.is_float(),
+        "expected a float element dtype, got {ptype}",
+    );
+
+    Ok(tensor_match)
+}
+
+/// 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
+/// constant input materializes only a single row (stride=0), while a full array uses
+/// stride=list_size.
+pub struct FlatElements {
+    elems: PrimitiveArray,
+    stride: usize,
+    list_size: usize,
+}
+
+impl FlatElements {
+    /// Returns the [`PType`] of the underlying elements.
+    #[must_use]
+    pub fn ptype(&self) -> PType {
+        self.elems.ptype()
+    }
+
+    /// Returns the `i`-th row as a typed slice of length `list_size`.
+    #[must_use]
+    pub fn row<T: NativePType>(&self, i: usize) -> &[T] {
+        let slice = self.elems.as_slice::<T>();
+        &slice[i * self.stride..][..self.list_size]
+    }
+}
+
+/// Extracts the flat primitive elements from a tensor storage array (FixedSizeList).
+///
+/// When the input is a [`ConstantArray`] (e.g., a literal query vector), only a single row is
+/// materialized to avoid expanding it to the full column length.
+pub fn extract_flat_elements(
+    storage: &ArrayRef,
+    list_size: usize,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<FlatElements> {
+    if let Some(constant) = storage.as_opt::<Constant>() {
+        // Rewrite the array as a length 1 array so when we canonicalize, we do not duplicate a huge
+        // amount of data.
+        let single = ConstantArray::new(constant.scalar().clone(), 1).into_array();
+        let fsl: FixedSizeListArray = single.execute(ctx)?;
+        let elems: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
+        return Ok(FlatElements {
+            elems,
+            stride: 0,
+            list_size,
+        });
+    }
+
+    // Otherwise we have to fully expand all of the data.
+    let fsl: FixedSizeListArray = storage.clone().execute(ctx)?;
+    let elems: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
+    Ok(FlatElements {
+        elems,
+        stride: list_size,
+        list_size,
+    })
+}
+
+/// Extracts the `(normalized, norms)` children from an [`L2Denorm`] scalar function array.
+///
+/// [`L2Denorm`]: crate::scalar_fns::l2_denorm::L2Denorm
+pub fn extract_l2_denorm_children(array: &ArrayRef) -> (ArrayRef, ArrayRef) {
+    let sfn = array
+        .as_opt::<ExactScalarFn<L2Denorm>>()
+        .vortex_expect("expected ScalarFnArray wrapping L2Denorm");
+    (
+        sfn.nth_child(0)
+            .vortex_expect("L2Denorm missing normalized array"),
+        sfn.nth_child(1).vortex_expect("L2Denorm missing norms"),
+    )
+}
+
+#[cfg(test)]
+pub mod test_helpers {
+    use vortex_array::ArrayRef;
+    use vortex_array::IntoArray;
+    use vortex_array::arrays::ConstantArray;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::FixedSizeListArray;
+    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::scalar::Scalar;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::Buffer;
+    use vortex_error::VortexResult;
+
+    use crate::fixed_shape::FixedShapeTensor;
+    use crate::fixed_shape::FixedShapeTensorMetadata;
+    use crate::vector::Vector;
+
+    /// Builds a [`FixedShapeTensor`] extension array from flat f64 elements and a logical shape.
+    ///
+    /// The number of rows is inferred from the total element count divided by the product of the
+    /// shape dimensions. For 0-dimensional tensors (scalar), each element is one row.
+    pub fn tensor_array(shape: &[usize], elements: &[f64]) -> VortexResult<ArrayRef> {
+        let list_size: u32 = shape.iter().product::<usize>().max(1).try_into().unwrap();
+        let row_count = elements.len() / list_size as usize;
+
+        let elems: ArrayRef = Buffer::copy_from(elements).into_array();
+        let fsl = FixedSizeListArray::new(elems, list_size, Validity::NonNullable, row_count);
+
+        let metadata = FixedShapeTensorMetadata::new(shape.to_vec());
+        let ext_dtype =
+            ExtDType::<FixedShapeTensor>::try_new(metadata, fsl.dtype().clone())?.erased();
+
+        Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array())
+    }
+
+    /// Builds a [`Vector`] extension array from flat f64 elements and a vector dimension size.
+    pub fn vector_array(dim: u32, elements: &[f64]) -> VortexResult<ArrayRef> {
+        let row_count = elements.len() / dim as usize;
+
+        let elems: ArrayRef = Buffer::copy_from(elements).into_array();
+        let fsl = FixedSizeListArray::new(elems, dim, Validity::NonNullable, row_count);
+
+        let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())?.erased();
+
+        Ok(ExtensionArray::new(ext_dtype, fsl.into_array()).into_array())
+    }
+
+    /// Builds a [`FixedShapeTensor`] extension array whose storage is a [`ConstantArray`],
+    /// representing a single query tensor broadcast to `len` rows.
+    pub fn constant_tensor_array(
+        shape: &[usize],
+        elements: &[f64],
+        len: usize,
+    ) -> VortexResult<ArrayRef> {
+        let element_dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+
+        let children: Vec<Scalar> = elements
+            .iter()
+            .map(|&v| Scalar::primitive(v, Nullability::NonNullable))
+            .collect();
+        let storage_scalar =
+            Scalar::fixed_size_list(element_dtype, children, Nullability::NonNullable);
+
+        let storage = ConstantArray::new(storage_scalar, len).into_array();
+
+        let metadata = FixedShapeTensorMetadata::new(shape.to_vec());
+        let ext_dtype =
+            ExtDType::<FixedShapeTensor>::try_new(metadata, storage.dtype().clone())?.erased();
+
+        Ok(ExtensionArray::new(ext_dtype, storage).into_array())
+    }
+
+    /// Builds a [`Vector`] extension array whose storage is a [`ConstantArray`], representing a
+    /// single query vector broadcast to `len` rows.
+    pub fn constant_vector_array(elements: &[f64], len: usize) -> VortexResult<ArrayRef> {
+        let element_dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
+
+        let children: Vec<Scalar> = elements
+            .iter()
+            .map(|&v| Scalar::primitive(v, Nullability::NonNullable))
+            .collect();
+        let storage_scalar =
+            Scalar::fixed_size_list(element_dtype, children, Nullability::NonNullable);
+
+        let storage = ConstantArray::new(storage_scalar, len).into_array();
+
+        let ext_dtype =
+            ExtDType::<Vector>::try_new(EmptyMetadata, storage.dtype().clone())?.erased();
+
+        Ok(ExtensionArray::new(ext_dtype, storage).into_array())
+    }
+
+    /// Asserts that each element in `actual` is within `1e-10` of the corresponding `expected`
+    /// value, with support for NaN (NaN == NaN is considered equal).
+    #[track_caller]
+    pub fn assert_close(actual: &[f64], expected: &[f64]) {
+        assert_eq!(
+            actual.len(),
+            expected.len(),
+            "length mismatch: got {} elements, expected {}",
+            actual.len(),
+            expected.len()
+        );
+
+        for (i, (a, e)) in actual.iter().zip(expected).enumerate() {
+            if a.is_nan() && e.is_nan() {
+                continue;
+            }
+            assert!(
+                (a - e).abs() < 1e-10,
+                "element {i}: got {a}, expected {e} (diff = {})",
+                (a - e).abs()
+            );
+        }
+    }
+}
diff --git a/vortex-tensor/src/vector/matcher.rs b/vortex-tensor/src/vector/matcher.rs
new file mode 100644
index 00000000000..0da5384f303
--- /dev/null
+++ b/vortex-tensor/src/vector/matcher.rs
@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::dtype::DType;
+use vortex_array::dtype::PType;
+use vortex_array::dtype::extension::ExtDTypeRef;
+use vortex_array::dtype::extension::Matcher;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
+
+use crate::vector::Vector;
+
+pub struct AnyVector;
+
+/// Convenience metadata for vectors.
+///
+/// Unlike `FixedShapeTensor`, the [`Vector`] type has `EmptyMetadata` as its metadata because all
+/// of the important information is already stored in the dtype.
+///
+/// However, it is quite inconvenient to repeatedly unwrap the dtype to get the element type of the
+/// vector and the number of dimensions.
+///
+/// Thus, we allow the matcher to return this metadata so that we can access this information more
+/// easily.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct VectorMatcherMetadata {
+    /// The element type of the vectors. Note that vector elements are _always_ non-nullable.
+    ///
+    /// This MUST be a floating point type (f16, f32, f64).
+    element_ptype: PType,
+
+    /// The number of dimensions of the vector. This is always fixed.
+    dimensions: u32,
+}
+
+impl Matcher for AnyVector {
+    type Match<'a> = VectorMatcherMetadata;
+
+    fn try_match<'a>(ext_dtype: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
+        if !ext_dtype.is::<Vector>() {
+            return None;
+        }
+
+        let DType::FixedSizeList(element_dtype, list_size, _) = ext_dtype.storage_dtype() else {
+            vortex_panic!("`Vector` type somehow did not have a `FixedSizeList` storage type")
+        };
+
+        let dimensions = *list_size;
+
+        assert!(element_dtype.is_float(), "element dtype must be primitive");
+        assert!(
+            !element_dtype.is_nullable(),
+            "element dtype must be non-nullable"
+        );
+        let element_ptype = element_dtype.as_ptype();
+
+        let vector_metadata = VectorMatcherMetadata::try_new(element_ptype, dimensions)
+            .vortex_expect("`Vector` type somehow did not have float elements");
+
+        Some(vector_metadata)
+    }
+}
+
+impl VectorMatcherMetadata {
+    /// Tries to create a new `VectorMatcherMetadata`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the element type is not a float.
+    pub fn try_new(element_ptype: PType, dimensions: u32) -> VortexResult<Self> {
+        vortex_ensure!(element_ptype.is_float());
+
+        Ok(Self {
+            element_ptype,
+            dimensions,
+        })
+    }
+
+    /// Returns the element type of the vectors.
+    pub fn element_ptype(&self) -> PType {
+        self.element_ptype
+    }
+
+    /// Returns the number of dimensions of the vector.
+    pub fn dimensions(&self) -> u32 {
+        self.dimensions
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    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::*;
+    use crate::fixed_shape::FixedShapeTensor;
+    use crate::fixed_shape::FixedShapeTensorMetadata;
+
+    fn vector_storage_dtype(element_ptype: PType, dimensions: u32) -> DType {
+        DType::FixedSizeList(
+            Arc::new(DType::Primitive(element_ptype, Nullability::NonNullable)),
+            dimensions,
+            Nullability::NonNullable,
+        )
+    }
+
+    #[test]
+    fn matches_vector_dtype_metadata() -> VortexResult<()> {
+        let ext_dtype =
+            ExtDType::<Vector>::try_new(EmptyMetadata, vector_storage_dtype(PType::F32, 256))?
+                .erased();
+
+        let metadata = ext_dtype.metadata::<AnyVector>();
+        assert_eq!(metadata.element_ptype(), PType::F32);
+        assert_eq!(metadata.dimensions(), 256);
+        Ok(())
+    }
+
+    #[test]
+    fn does_not_match_fixed_shape_tensor() -> VortexResult<()> {
+        let ext_dtype = ExtDType::<FixedShapeTensor>::try_new(
+            FixedShapeTensorMetadata::new(vec![16, 16]),
+            vector_storage_dtype(PType::F32, 256),
+        )?
+        .erased();
+
+        assert!(ext_dtype.metadata_opt::<AnyVector>().is_none());
+        Ok(())
+    }
+}
diff --git a/vortex-tensor/src/vector/mod.rs b/vortex-tensor/src/vector/mod.rs
new file mode 100644
index 00000000000..3c6a8a8c8cc
--- /dev/null
+++ b/vortex-tensor/src/vector/mod.rs
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Vector extension type for fixed-length float vectors (e.g., embeddings).
+
+/// The Vector extension type.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct Vector;
+
+mod matcher;
+
+pub use matcher::AnyVector;
+pub use matcher::VectorMatcherMetadata;
+
+mod vtable;
diff --git a/vortex-tensor/src/vector/vtable.rs b/vortex-tensor/src/vector/vtable.rs
new file mode 100644
index 00000000000..2dda05b7363
--- /dev/null
+++ b/vortex-tensor/src/vector/vtable.rs
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+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;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+
+use crate::vector::Vector;
+
+impl ExtVTable for Vector {
+    type Metadata = EmptyMetadata;
+
+    // TODO(connor): This is just a placeholder for now.
+    type NativeValue<'a> = &'a ScalarValue;
+
+    fn id(&self) -> ExtId {
+        ExtId::new_ref("vortex.tensor.vector")
+    }
+
+    fn serialize_metadata(&self, _metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(Vec::new())
+    }
+
+    fn deserialize_metadata(&self, _metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        Ok(EmptyMetadata)
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        let storage_dtype = ext_dtype.storage_dtype();
+        let DType::FixedSizeList(element_dtype, _list_size, _nullability) = storage_dtype else {
+            vortex_bail!("Vector storage dtype must be a FixedSizeList, got {storage_dtype}");
+        };
+
+        vortex_ensure!(
+            element_dtype.is_float(),
+            "Vector element dtype must be a float, got {element_dtype}"
+        );
+        vortex_ensure!(
+            !element_dtype.is_nullable(),
+            "Vector element dtype must be non-nullable"
+        );
+
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        _ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        Ok(storage_value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use rstest::rstest;
+    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::vector::Vector;
+
+    /// Constructs a `FixedSizeList` storage dtype with the given float [`PType`], list size, and
+    /// [`Nullability`].
+    fn vector_storage_dtype(ptype: PType, size: u32, nullability: Nullability) -> DType {
+        DType::FixedSizeList(
+            Arc::new(DType::Primitive(ptype, Nullability::NonNullable)),
+            size,
+            nullability,
+        )
+    }
+
+    #[rstest]
+    #[case::f16(PType::F16)]
+    #[case::f32(PType::F32)]
+    #[case::f64(PType::F64)]
+    fn validate_accepts_float_types(#[case] ptype: PType) -> VortexResult<()> {
+        let storage = vector_storage_dtype(ptype, 128, Nullability::NonNullable);
+        ExtDType::<Vector>::try_new(EmptyMetadata, storage)?;
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::nullable(Nullability::Nullable)]
+    #[case::non_nullable(Nullability::NonNullable)]
+    fn validate_accepts_any_outer_nullability(
+        #[case] nullability: Nullability,
+    ) -> VortexResult<()> {
+        let storage = vector_storage_dtype(PType::F32, 128, nullability);
+        ExtDType::<Vector>::try_new(EmptyMetadata, storage)?;
+        Ok(())
+    }
+
+    #[test]
+    fn validate_rejects_non_fsl() {
+        let storage = DType::Primitive(PType::F32, Nullability::NonNullable);
+        assert!(ExtDType::<Vector>::try_new(EmptyMetadata, storage).is_err());
+    }
+
+    #[test]
+    fn validate_rejects_integer_elements() {
+        let storage = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::U32, Nullability::NonNullable)),
+            128,
+            Nullability::NonNullable,
+        );
+        assert!(ExtDType::<Vector>::try_new(EmptyMetadata, storage).is_err());
+    }
+
+    #[test]
+    fn validate_rejects_nullable_elements() {
+        let storage = DType::FixedSizeList(
+            Arc::new(DType::Primitive(PType::F32, Nullability::Nullable)),
+            128,
+            Nullability::NonNullable,
+        );
+        assert!(ExtDType::<Vector>::try_new(EmptyMetadata, storage).is_err());
+    }
+
+    #[test]
+    fn roundtrip_metadata() -> VortexResult<()> {
+        let vtable = Vector;
+        let bytes = vtable.serialize_metadata(&EmptyMetadata)?;
+        assert!(bytes.is_empty());
+        let deserialized = vtable.deserialize_metadata(&bytes)?;
+        assert_eq!(deserialized, EmptyMetadata);
+        Ok(())
+    }
+}
diff --git a/vortex-test/compat-gen/Cargo.toml b/vortex-test/compat-gen/Cargo.toml
new file mode 100644
index 00000000000..62906843e8b
--- /dev/null
+++ b/vortex-test/compat-gen/Cargo.toml
@@ -0,0 +1,52 @@
+[package]
+name = "vortex-compat"
+authors = { workspace = true }
+description = "Backward-compatibility fixture generation and checking for Vortex"
+edition = { workspace = true }
+homepage = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+publish = false
+repository = { workspace = true }
+rust-version = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+[[bin]]
+name = "vortex-compat"
+path = "src/main.rs"
+
+[dependencies]
+# Vortex crates
+vortex = { workspace = true, features = ["files", "tokio", "zstd"] }
+vortex-array = { workspace = true, features = ["_test-harness"] }
+vortex-buffer = { workspace = true }
+vortex-error = { workspace = true }
+vortex-session = { workspace = true }
+
+# TPC-H generation
+arrow-array = { workspace = true }
+tpchgen = { workspace = true }
+tpchgen-arrow = { workspace = true }
+
+# ClickBench parquet reading + writing
+arrow-select = { workspace = true }
+bytes = { workspace = true }
+parquet = { workspace = true }
+
+# Async runtime
+futures = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+
+# HTTP fetching (for ClickBench fixture setup)
+reqwest = { workspace = true }
+
+# CLI + serialization
+clap = { workspace = true, features = ["derive"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+sha2 = { workspace = true }
+tempfile = { workspace = true }
diff --git a/vortex-test/compat-gen/DESIGN.md b/vortex-test/compat-gen/DESIGN.md
new file mode 100644
index 00000000000..56b655eae64
--- /dev/null
+++ b/vortex-test/compat-gen/DESIGN.md
@@ -0,0 +1,224 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!--SPDX-FileCopyrightText: Copyright the Vortex contributors -->
+
+# Vortex Backward-Compatibility Testing
+
+## The Problem
+
+Vortex is a columnar file format. Users write `.vortex` files with one
+version of the library and expect to read them in any future version. 
+We need back-compat!
+
+## The Solution
+
+We maintain a library of `.vortex` fixture files, one set per released
+version, stored in S3. A test reads every old fixture with the current reader
+and compares the decoded values against a known-good oracle. If any fixture
+from any version decodes to the wrong values, the test fails.
+
+## How Fixtures Work
+
+A fixture is a small `.vortex` file with known contents. The expected
+contents are defined by a Rust function — `build()` — that deterministically
+constructs the arrays. The same `build()` code is used at both ends:
+
+- **At publish time:** `build()` produces arrays -> the writer serializes them
+  to a `.vortex` file -> the file is uploaded to S3.
+- **At check time:** `build()` produces the same arrays -> the reader decodes
+  the old file -> the two are compared value-by-value.
+
+If the reader is correct, the values match. If a code change breaks
+decoding, they don't.
+
+### The oracle question
+
+"Isn't comparing against `build()` circular? What if `build()` itself
+changes?"
+
+`build()` is the specification — it defines what the fixture *should*
+contain. The contract is that `build()` for a given fixture name is immutable
+once defined. It must never change its output. If someone modifies it, the
+check fails loudly against every old version.
+
+### Fixture evolution
+
+Because `build()` is immutable, you cannot add a column to an existing
+fixture or change its schema. To test a new type, encoding, or structural
+pattern, create a **new fixture file** with a new name.
+
+## Fixture Trait
+
+Every fixture implements this trait in Rust:
+
+```rust
+pub trait Fixture {
+    /// Filename, e.g. "primitives.vortex".
+    fn name(&self) -> &str;
+
+    /// Human-readable description.
+    fn description(&self) -> &str;
+
+    /// Optional async setup (download external data, etc).
+    /// Called before build(). Default is a no-op.
+    fn setup(&self, _tmp_dir: &Path) -> VortexResult<()> { Ok(()) }
+
+    /// Build the expected arrays. Must be deterministic.
+    /// Returns a Vec to support chunked fixtures (multiple chunks).
+    fn build(&self, tmp_dir: &Path) -> VortexResult<Vec<ArrayRef>>;
+}
+```
+
+All fixtures are registered in `all_fixtures()` in `src/fixtures/mod.rs`.
+
+### Current fixture suite
+
+| Fixture | File | Description |
+|---------|------|-------------|
+| Primitives | `primitives.vortex` | u8-u64, i32, i64, f32, f64 at min/mid/max |
+| Strings | `strings.vortex` | Empty, ASCII, multibyte (Japanese), emoji |
+| Booleans | `booleans.vortex` | Mixed true/false |
+| Nullable | `nullable.vortex` | Nullable int and string columns with interspersed nulls |
+| Nested Struct | `struct_nested.vortex` | Two-level struct-in-struct |
+| Chunked | `chunked.vortex` | 3 chunks of 1000 rows, deterministic values |
+| TPC-H Lineitem | `tpch_lineitem.vortex` | TPC-H lineitem at SF 0.01 |
+| TPC-H Orders | `tpch_orders.vortex` | TPC-H orders at SF 0.01 |
+| ClickBench Hits | `clickbench_hits_1k.vortex` | First 1000 rows of ClickBench hits |
+
+### Adding a new fixture
+
+1. Create a struct implementing `Fixture` in `src/fixtures/`.
+2. Register it in `all_fixtures()` in `src/fixtures/mod.rs`.
+3. Run `cargo run -p vortex-compat --release -- generate --output /tmp/test` to verify.
+4. Publish — the orchestrator merges the manifest so the new fixture gets
+   `since` set to the current version.
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────┐
+│  Python orchestrator (compat.py)                 │
+│  Version-agnostic: S3, manifests, worktrees      │
+│                                                  │
+│  Commands: publish, check, generate, list,       │
+│            validate-manifest                     │
+└──────────────────┬───────────────────────────────┘
+                   │ invokes
+┌──────────────────▼───────────────────────────────┐
+│  Rust binary (vortex-compat)                     │
+│  Version-specific: builds arrays, writes/reads   │
+│  .vortex files, compares arrays                  │
+│                                                  │
+│  Commands: generate, check                       │
+└──────────────────────────────────────────────────┘
+```
+
+**Why the split?** Only the Rust binary links against Vortex. When Vortex
+APIs change across versions, only this small binary needs to recompile. The
+Python orchestrator handles S3, manifests, git worktrees, and additive-only
+enforcement without touching Vortex code.
+
+### Rust binary: `vortex-compat`
+
+See [README.md](README.md) for CLI usage.
+
+#### Adapter module (`src/adapter.rs`)
+
+The only code that calls Vortex file I/O APIs directly:
+
+```rust
+pub fn write_file(path: &Path, chunks: Vec<ArrayRef>) -> VortexResult<()>;
+pub fn read_file(bytes: ByteBuffer) -> VortexResult<Vec<ArrayRef>>;
+```
+
+Uses the Epoch C API (`session.write_options()` /
+`session.open_options().open_buffer()`), valid from v0.58.0 through HEAD.
+
+### Python orchestrator: `compat.py`
+
+See [README.md](README.md) for CLI usage.
+
+## Store Format
+
+### `versions.json`
+
+A JSON array of version strings:
+
+```json
+["0.62.0", "0.63.0"]
+```
+
+### Directory layout
+
+```
+store/
+├── versions.json
+├── v0.62.0/
+│   └── arrays/
+│       ├── manifest.json
+│       ├── primitives.vortex
+│       └── ...
+└── v0.63.0/
+    └── arrays/
+        ├── manifest.json
+        └── ...
+```
+
+Each version gets a directory named `v{version}` with an `arrays/`
+subdirectory for fixture files. Re-publishing overwrites the existing
+directory.
+
+### Per-version manifest
+
+```json
+{
+  "version": "0.63.0",
+  "generated_at": "2026-03-14T08:00:00Z",
+  "fixtures": [
+    {
+      "name": "primitives.vortex",
+      "description": "All primitive types with boundary values",
+      "since": "0.62.0"
+    }
+  ]
+}
+```
+
+The `since` field tracks which version introduced each fixture. It is carried
+forward automatically by manifest merging — when publishing version N, the
+orchestrator reads version N-1's manifest and preserves existing `since`
+values.
+
+## CI Workflows
+
+### Fixture upload (`.github/workflows/compat-gen-upload.yml`)
+
+Used to upload fixtures for each new release. Triggered via **manual
+dispatch** with an optional `git_ref` input (defaults to HEAD).
+
+Two-phase workflow:
+
+1. **dry-run** — auto-detects the version from the nearest git tag, builds
+   fixtures, and prints what would be uploaded.
+2. **upload** — requires manual approval via the `compat-upload` GitHub
+   environment, then performs the actual upload to S3.
+
+### Compat validation (`.github/workflows/compat-validation.yml`)
+
+Validates the current code against previously published fixtures. Runs weekly
+(Monday 6am UTC) and via manual dispatch with a `mode` input:
+
+| Mode | Behavior |
+|------|----------|
+| `last` (default) | Compare against the most recent published release only |
+| `all` | Compare against all previously published versions (pre-release check) |
+
+## Known Limitations
+
+**Does catch:** schema deserialization breaks, encoding algorithm changes
+that corrupt values, null bitmap changes, UTF-8/multibyte handling, chunk
+boundary regressions, struct field ordering, encoding removal.
+
+**Does not catch:** predicate pushdown (no filters applied), column
+projection (reads all columns), missing DType coverage (no decimal, temporal,
+list, binary, extension), degenerate cases (empty files, all-null, float
+specials), partial reads / mmap.
diff --git a/vortex-test/compat-gen/README.md b/vortex-test/compat-gen/README.md
new file mode 100644
index 00000000000..e91101a0d2e
--- /dev/null
+++ b/vortex-test/compat-gen/README.md
@@ -0,0 +1,153 @@
+# vortex-compat
+
+Backward-compatibility testing for the Vortex file format. Ensures the
+current reader can always decode `.vortex` files written by any older
+released version.
+
+See [DESIGN.md](DESIGN.md) for full architecture and design rationale.
+
+## Quick Start
+
+```bash
+# Generate fixtures locally
+cargo run -p vortex-compat --release -- generate --output /tmp/fixtures
+
+# Check fixtures against current reader
+cargo run -p vortex-compat --release -- check --dir /tmp/fixtures --mode exact
+
+# Publish to S3 (requires AWS credentials)
+python scripts/compat.py publish
+
+# Check all published versions
+python scripts/compat.py check
+
+# Publish from a historical tag via git worktree
+python scripts/compat.py publish --git-ref v0.62.0
+
+# Local-only workflow (no S3)
+python scripts/compat.py publish --store /tmp/compat-store
+python scripts/compat.py check --store /tmp/compat-store
+```
+
+## Rust Binary: `vortex-compat`
+
+A thin binary with two commands. It has **no** knowledge of versions, S3,
+manifests, or orchestration.
+
+**Output protocol:** progress/diagnostics to stderr, structured JSON to
+stdout (`check` only).
+
+### `generate --output <DIR> [--exclude <CSV>]`
+
+Three phases:
+
+1. **Setup** — run each fixture's `setup()` concurrently via
+   `tokio::spawn_blocking`. Used by TPC-H and ClickBench fixtures to
+   download external data.
+2. **Build** — construct arrays in parallel threads via `std::thread::scope`.
+   All must succeed before any files are written.
+3. **Write** — serialize each fixture's arrays as a `.vortex` file, then
+   write `fixtures.json` listing all generated files.
+
+Output:
+```
+<DIR>/
+├── fixtures.json
+├── primitives.vortex
+├── strings.vortex
+└── ...
+```
+
+`fixtures.json` format:
+```json
+{
+  "fixtures": [
+    {"name": "primitives.vortex", "description": "..."},
+    {"name": "strings.vortex", "description": "..."}
+  ]
+}
+```
+
+### `check --dir <DIR> --mode <MODE> [--exclude <CSV>]`
+
+For each `.vortex` file in the directory:
+
+1. Run `setup()` + `build()` to reconstruct expected arrays from current code
+2. Read the file bytes and decode via `adapter::read_file()`
+3. Combine chunks into `ChunkedArray` and compare with `assert_arrays_eq!`
+
+JSON result to stdout:
+```json
+{
+  "passed": ["primitives.vortex"],
+  "failed": [{"name": "foo.vortex", "error": "mismatch at row 42"}],
+  "skipped": ["old_fixture.vortex"]
+}
+```
+
+Check modes:
+
+| Mode | Extra files in dir | Missing fixtures |
+|------|--------------------|------------------|
+| `superset` (default) | Error | Skipped |
+| `exact` | Error | Error |
+| `subset` | Skipped | Error |
+
+Use `superset` when checking old versions (they may be missing newly-added
+fixtures). Use `exact` for the current version.
+
+## Python Orchestrator: `compat.py`
+
+### `publish [--git-ref <REF>] [--store <SPEC>] [--dry-run] [--exclude <CSV>]`
+
+1. Detect version from nearest git tag at HEAD (or `<REF>`)
+2. Generate fixtures (from current tree, or from a worktree at `<REF>`)
+3. Fetch previous version's manifest, merge `since` values, enforce additive-only
+4. Upload `.vortex` files + `manifest.json` to `v{version}/arrays/`
+5. Update `versions.json`
+
+### `check [--versions <CSV>] [--store <SPEC>] [--exclude <CSV>]`
+
+1. Read `versions.json` from store
+2. For each version, download `arrays/manifest.json` + all `.vortex` files
+3. Run `vortex-compat check --dir <tmpdir> --mode superset`
+4. Aggregate results, exit 1 if any failures
+
+### `generate --output <DIR> [--git-ref <REF>] [--exclude <CSV>]`
+
+Generate fixtures locally without publishing. Writes `.vortex` files and a
+`manifest.json`.
+
+### `list [--store <SPEC>] [--version <VER>]`
+
+Without `--version`: print all version numbers.
+With `--version`: print that version's `manifest.json`.
+
+### `validate-manifest [--store <SPEC>]`
+
+Walk all versions in order and verify no fixtures were removed between
+consecutive versions (additive-only property).
+
+### Store abstraction
+
+| Spec | Type | Auth |
+|------|------|------|
+| `s3://vortex-compat-fixtures` (default) | S3 | Public reads (HTTPS), AWS creds for writes |
+| `/tmp/compat` | Local directory | None |
+
+### Git worktree workflow
+
+`--git-ref` automates publishing from historical releases:
+
+```bash
+python compat.py publish --git-ref v0.62.0
+```
+
+This creates a worktree at the tag, builds the binary against that code,
+generates fixtures, then cleans up.
+
+### Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `VORTEX_COMPAT_BIN` | Path to pre-built `vortex-compat` binary. Skips `cargo run`. |
diff --git a/vortex-test/compat-gen/scripts/compat.py b/vortex-test/compat-gen/scripts/compat.py
new file mode 100644
index 00000000000..e94b509747d
--- /dev/null
+++ b/vortex-test/compat-gen/scripts/compat.py
@@ -0,0 +1,1070 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+# /// script
+# dependencies = ["jsonschema"]
+# ///
+
+"""
+Vortex backward-compatibility orchestrator.
+
+Manages fixture versions in S3 (or local directories) by calling the thin
+`vortex-compat` Rust binary for generation and checking.  The Rust binary
+handles only two things: generating .vortex files and comparing them.
+Everything else (versioning, S3 upload/download, manifest merging) lives here.
+
+Quick start:
+    # Generate + publish for HEAD (version auto-detected from latest tag)
+    uv run compat.py publish
+
+    # Publish from an older tag
+    uv run compat.py publish --git-ref v0.62.0
+
+    # Check all published versions against current code
+    uv run compat.py check
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import UTC, datetime
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import urlopen
+
+import jsonschema
+
+DEFAULT_STORE = "s3://vortex-compat-fixtures"
+CARGO_BIN = "vortex-compat"
+
+EPILOG = """\
+environment variables:
+  VORTEX_COMPAT_BIN    Path to a pre-built vortex-compat binary.
+                       Skips `cargo run` when set.
+
+store spec:
+  Local path           --store /tmp/compat-store
+  S3 bucket            --store s3://my-bucket
+
+  Default: s3://vortex-compat-fixtures
+  S3 reads are public HTTPS; writes need AWS credentials (env or IAM role).
+
+version detection:
+  The version is always derived from a git tag. By default, HEAD's nearest
+  tag is used (via `git describe --tags --abbrev=0`). Use --git-ref to
+  target a different ref (e.g. v0.62.0). The 'v' prefix is stripped to
+  produce the version string (v0.63.0 -> 0.63.0).
+
+examples:
+  # Publish from HEAD (version from latest tag)
+  uv run compat.py publish
+  uv run compat.py publish --dry-run
+
+  # Publish using an older tag for version detection
+  uv run compat.py publish --git-ref v0.62.0
+
+  # Add new fixtures to an existing version (hash-verified)
+  uv run compat.py publish --update
+  uv run compat.py publish --update --dry-run
+
+  # Generate locally without publishing
+  uv run compat.py generate --output /tmp/fixtures
+  uv run compat.py generate --output /tmp/fixtures --git-ref v0.62.0
+
+  # Check all versions, or specific ones
+  uv run compat.py check
+  uv run compat.py check --mode last
+  uv run compat.py check --versions 0.62.0,0.63.0
+
+  # Inspect store contents
+  uv run compat.py list
+  uv run compat.py list 0.62.0
+
+  # Validate additive-only manifest property
+  uv run compat.py validate-manifest
+"""
+
+
+# ---------------------------------------------------------------------------
+# Store abstraction
+# ---------------------------------------------------------------------------
+
+
+class Store:
+    """Abstract base for fixture stores."""
+
+    def read(self, key: str) -> bytes | None:
+        raise NotImplementedError
+
+    def write(self, key: str, data: bytes) -> None:
+        raise NotImplementedError
+
+    def write_file(self, key: str, local_path: Path) -> None:
+        raise NotImplementedError
+
+    def list_versions(self) -> list[str]:
+        raise NotImplementedError
+
+    def display_name(self) -> str:
+        raise NotImplementedError
+
+
+class LocalStore(Store):
+    """Fixture store backed by a local directory."""
+
+    def __init__(self, root: Path):
+        self.root = root
+
+    def read(self, key: str) -> bytes | None:
+        path = self.root / key
+        if not path.exists():
+            return None
+        return path.read_bytes()
+
+    def write(self, key: str, data: bytes) -> None:
+        path = self.root / key
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+
+    def write_file(self, key: str, local_path: Path) -> None:
+        dest = self.root / key
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(local_path, dest)
+
+    def list_versions(self) -> list[str]:
+        versions_data = self.read("versions.json")
+        if versions_data:
+            return json.loads(versions_data)
+        if not self.root.exists():
+            return []
+        # Fall back to directory listing.
+        versions = []
+        for entry in self.root.iterdir():
+            if entry.is_dir() and entry.name.startswith("v"):
+                manifest = entry / "arrays" / "manifest.json"
+                if manifest.exists():
+                    versions.append(entry.name[1:])  # strip 'v' prefix
+        versions.sort(key=_version_sort_key)
+        return versions
+
+    def display_name(self) -> str:
+        return str(self.root)
+
+
+class S3Store(Store):
+    """Fixture store backed by an S3 bucket (public reads, aws cli writes)."""
+
+    def __init__(self, bucket: str):
+        self.bucket = bucket
+        self.https_base = f"https://{bucket}.s3.amazonaws.com"
+
+    def read(self, key: str) -> bytes | None:
+        url = f"{self.https_base}/{key}"
+        for attempt in range(3):
+            try:
+                with urlopen(url, timeout=10) as resp:
+                    return resp.read()
+            except HTTPError as e:
+                if e.code in (403, 404):
+                    return None
+                raise
+            except (URLError, ConnectionError, TimeoutError):
+                if attempt < 2:
+                    time.sleep(1 * (attempt + 1))
+                    continue
+                raise
+
+    def write(self, key: str, data: bytes) -> None:
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            f.write(data)
+            tmp_path = f.name
+        try:
+            self.write_file(key, Path(tmp_path))
+        finally:
+            os.unlink(tmp_path)
+
+    def write_file(self, key: str, local_path: Path) -> None:
+        dest = f"s3://{self.bucket}/{key}"
+        _info(f"  {local_path.name} -> {dest}")
+        subprocess.run(
+            ["aws", "s3", "cp", str(local_path), dest],
+            check=True,
+        )
+
+    def list_versions(self) -> list[str]:
+        data = self.read("versions.json")
+        if data:
+            return json.loads(data)
+        return []
+
+    def display_name(self) -> str:
+        return f"s3://{self.bucket}"
+
+
+class DryRunStore(Store):
+    """Wrapper that validates write credentials without actually uploading.
+
+    Reads are delegated to the inner store. Writes use ``aws s3 cp --dryrun``
+    (for S3 stores) so that IAM permissions are verified, but no data is
+    written.  For local stores, writes are silently skipped.
+    """
+
+    def __init__(self, inner: Store):
+        self.inner = inner
+
+    def read(self, key: str) -> bytes | None:
+        return self.inner.read(key)
+
+    def write(self, key: str, data: bytes) -> None:
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            f.write(data)
+            tmp_path = f.name
+        try:
+            self.write_file(key, Path(tmp_path))
+        finally:
+            os.unlink(tmp_path)
+
+    def write_file(self, key: str, local_path: Path) -> None:
+        if isinstance(self.inner, S3Store):
+            dest = f"s3://{self.inner.bucket}/{key}"
+            _info(f"  {local_path.name} -> {dest} (dry-run)")
+            subprocess.run(
+                ["aws", "s3", "cp", str(local_path), dest, "--dryrun"],
+                check=True,
+            )
+        else:
+            _info(f"  dry-run: would write {key}")
+
+    def list_versions(self) -> list[str]:
+        return self.inner.list_versions()
+
+    def display_name(self) -> str:
+        return self.inner.display_name()
+
+
+def _parse_store(spec: str) -> Store:
+    """Parse a store specification into a Store instance."""
+    if spec.startswith("s3://"):
+        return S3Store(spec[5:])
+    return LocalStore(Path(spec))
+
+
+# ---------------------------------------------------------------------------
+# Version detection
+# ---------------------------------------------------------------------------
+
+
+def _version_from_ref(git_ref: str | None = None) -> str:
+    """Derive a version string from a git ref.
+
+    If git_ref is None, uses HEAD. Finds the nearest tag and strips the 'v' prefix.
+    For example, tag 'v0.63.0' yields version '0.63.0'.
+    """
+    cmd = ["git", "describe", "--tags", "--abbrev=0"]
+    if git_ref:
+        cmd.append(git_ref)
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        ref_msg = f" ref '{git_ref}'" if git_ref else ""
+        print(
+            f"error: could not detect version from git{ref_msg}: {result.stderr.strip()}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    tag = result.stdout.strip()
+    # Strip 'v' prefix if present.
+    version = re.sub(r"^v", "", tag)
+    _info(f"detected version {version} (from tag {tag})")
+    return version
+
+
+# ---------------------------------------------------------------------------
+# Manifest helpers
+# ---------------------------------------------------------------------------
+
+
+MANIFEST_SCHEMA = {
+    "type": "object",
+    "required": ["version", "generated_at", "fixtures"],
+    "properties": {
+        "version": {"type": "string"},
+        "generated_at": {"type": "string"},
+        "fixtures": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["name"],
+                "properties": {
+                    "name": {"type": "string"},
+                    "description": {"type": "string"},
+                    "sha256": {"type": "string"},
+                },
+            },
+        },
+    },
+}
+
+
+def _validate_manifest(manifest: dict, version: str) -> None:
+    """Validate manifest against the JSON schema."""
+    try:
+        jsonschema.validate(manifest, MANIFEST_SCHEMA)
+    except jsonschema.ValidationError as e:
+        raise ValueError(
+            f"v{version} manifest: {e.message} (at path: {'/'.join(str(p) for p in e.absolute_path)})"
+        ) from e
+
+
+def _read_manifest(store: Store, version: str) -> dict | None:
+    # Try new path first, then legacy path.
+    data = store.read(f"v{version}/arrays/manifest.json")
+    prefix = f"v{version}/arrays"
+    if data is None:
+        data = store.read(f"v{version}/manifest.json")
+        prefix = f"v{version}"
+    if data is None:
+        return None
+    manifest = json.loads(data)
+
+    # Upgrade legacy format: flat list of filenames -> new object format.
+    if isinstance(manifest.get("fixtures"), list) and manifest["fixtures"] and isinstance(manifest["fixtures"][0], str):
+        _info(f"  upgrading legacy manifest format for v{version}")
+        manifest["fixtures"] = [{"name": n, "description": "", "sha256": ""} for n in manifest["fixtures"]]
+
+    _validate_manifest(manifest, version)
+    # Stash the prefix so callers know where to fetch fixture files.
+    manifest["_prefix"] = prefix
+    return manifest
+
+
+def _merge_manifest(
+    store: Store,
+    fixtures_json: dict,
+    version: str,
+    prev_version: str | None,
+) -> dict:
+    """Build a manifest for `version`, using sha256 from Rust-generated fixtures.json."""
+    entries = []
+    prev_names: set[str] = set()
+
+    if prev_version:
+        prev_manifest = _read_manifest(store, prev_version)
+        if prev_manifest:
+            prev_names = {e["name"] for e in prev_manifest["fixtures"]}
+
+    for f in fixtures_json["fixtures"]:
+        entries.append({"name": f["name"], "description": f["description"], "sha256": f["sha256"]})
+
+    # Additive-only enforcement.
+    current_names = {e["name"] for e in entries}
+    missing = [n for n in prev_names if n not in current_names]
+    if missing:
+        print(
+            f"error: fixtures removed since v{prev_version}: {', '.join(missing)}",
+            file=sys.stderr,
+        )
+        print("Fixtures must never be removed.", file=sys.stderr)
+        sys.exit(1)
+
+    return {
+        "version": version,
+        "generated_at": datetime.now(UTC).isoformat(),
+        "fixtures": entries,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+
+def cmd_generate(args: argparse.Namespace) -> None:
+    """Generate fixtures locally, then write a proper manifest."""
+    output = Path(args.output)
+    version = _version_from_ref(args.git_ref)
+
+    _run_rust_generate(output, profile=args.profile)
+
+    # Read fixtures.json (with sha256 from Rust) and write a versioned manifest.
+    fixtures_json = json.loads((output / "fixtures.json").read_text())
+    entries = []
+    for f in fixtures_json["fixtures"]:
+        entries.append({"name": f["name"], "description": f["description"], "sha256": f["sha256"]})
+    manifest = {
+        "version": version,
+        "generated_at": datetime.now(UTC).isoformat(),
+        "fixtures": entries,
+    }
+    (output / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
+    _info(f"wrote manifest.json for v{version}")
+
+
+def cmd_publish(args: argparse.Namespace) -> None:
+    """Generate fixtures and publish to a store."""
+    store = _parse_store(args.store)
+    git_ref = args.git_ref
+    version = _version_from_ref(git_ref)
+
+    versions = store.list_versions()
+
+    if args.update:
+        _publish_update(store, version, versions, args)
+    else:
+        _publish_full(store, version, versions, args)
+
+
+def _publish_full(
+    store: Store,
+    version: str,
+    versions: list[str],
+    args: argparse.Namespace,
+) -> None:
+    """Full publish: upload all fixtures for a new version."""
+    if version in versions and not args.force:
+        _info(f"error: v{version} already exists in {store.display_name()}")
+        _info("use --force to overwrite an existing version")
+        sys.exit(1)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        output = Path(tmpdir) / "fixtures"
+
+        _info("generating fixtures...")
+        _run_rust_generate(output, profile=args.profile)
+
+        fixtures_json = json.loads((output / "fixtures.json").read_text())
+
+        prev = _find_prev_version(versions, version)
+        if prev:
+            _info(f"previous version: {prev}")
+
+        manifest = _merge_manifest(store, fixtures_json, version, prev)
+        manifest_json = json.dumps(manifest, indent=2) + "\n"
+
+        write_store = _write_store(
+            store,
+            args,
+            f"\nabout to upload {len(manifest['fixtures'])} fixtures for v{version} to {store.display_name()}",
+        )
+
+        _parallel_upload(
+            write_store,
+            [(f"v{version}/arrays/{e['name']}", output / e["name"]) for e in manifest["fixtures"]],
+        )
+
+        write_store.write(f"v{version}/arrays/manifest.json", manifest_json.encode())
+
+        if version not in versions:
+            versions.append(version)
+            versions.sort(key=_version_sort_key)
+        write_store.write("versions.json", (json.dumps(versions, indent=2) + "\n").encode())
+
+
+def _publish_update(
+    store: Store,
+    version: str,
+    versions: list[str],
+    args: argparse.Namespace,
+) -> None:
+    """Incremental update: add new fixtures to an existing version (hash-verified)."""
+    if version not in versions:
+        _info(f"error: v{version} not found in {store.display_name()}, use publish without --update for new versions")
+        sys.exit(1)
+
+    existing_manifest = _read_manifest(store, version)
+    if existing_manifest is None:
+        _info(f"error: v{version} has no manifest in {store.display_name()}")
+        sys.exit(1)
+
+    prefix = existing_manifest.pop("_prefix")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        output = Path(tmpdir) / "fixtures"
+
+        _info("generating fixtures...")
+        _run_rust_generate(output, profile=args.profile)
+
+        fixtures_json = json.loads((output / "fixtures.json").read_text())
+
+        # Compare each generated fixture against the store.
+        new_fixtures: list[str] = []
+        for f in fixtures_json["fixtures"]:
+            name = f["name"]
+            local_path = output / name
+            local_hash = hashlib.sha256(local_path.read_bytes()).hexdigest()
+            remote_data = store.read(f"{prefix}/{name}")
+
+            if remote_data is not None:
+                remote_hash = hashlib.sha256(remote_data).hexdigest()
+                if local_hash != remote_hash:
+                    _info(f"error: hash mismatch for {name}: local={local_hash[:12]} remote={remote_hash[:12]}")
+                    sys.exit(1)
+                else:
+                    _info(f"  {name}: unchanged (sha256 match)")
+            else:
+                new_fixtures.append(name)
+                _info(f"  {name}: NEW")
+
+        if not new_fixtures:
+            _info("no new fixtures to add")
+            return
+
+        write_store = _write_store(
+            store,
+            args,
+            f"\nabout to upload {len(new_fixtures)} new fixture(s) for v{version} to {store.display_name()}",
+        )
+
+        new_fixture_names = set(new_fixtures)
+        _parallel_upload(
+            write_store,
+            [(f"{prefix}/{name}", output / name) for name in new_fixtures],
+        )
+
+        # Merge manifest: keep existing entries, add new ones.
+        new_entries = existing_manifest["fixtures"][:]
+        for f in fixtures_json["fixtures"]:
+            if f["name"] in new_fixture_names:
+                new_entries.append({"name": f["name"], "description": f["description"], "sha256": f["sha256"]})
+
+        updated_manifest = {
+            "version": version,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "fixtures": new_entries,
+        }
+        write_store.write(f"{prefix}/manifest.json", (json.dumps(updated_manifest, indent=2) + "\n").encode())
+
+
+def cmd_check(args: argparse.Namespace) -> None:
+    """Download fixtures from store and check with Rust binary."""
+    store = _parse_store(args.store)
+
+    if args.versions and args.mode != "all":
+        print("error: --versions and --mode are mutually exclusive", file=sys.stderr)
+        sys.exit(1)
+
+    if args.versions:
+        versions = [v.strip() for v in args.versions.split(",")]
+    else:
+        versions = store.list_versions()
+        if args.mode == "last" and versions:
+            versions = versions[-1:]
+
+    if not versions:
+        _info("no versions found in store")
+        sys.exit(1)
+
+    _info(f"found versions.json at {store.display_name()}/versions.json: {versions}")
+    _info(f"checking {len(versions)} version(s): {', '.join(versions)}")
+
+    total_passed = 0
+    total_failed = 0
+    total_skipped = 0
+    all_failures: list[tuple[str, str, str]] = []
+
+    for version in versions:
+        _info(f"\n--- v{version} ---")
+        manifest = _read_manifest(store, version)
+        if manifest is None:
+            _info(f"  v{version}: no manifest found at v{version}/arrays/manifest.json or v{version}/manifest.json")
+            all_failures.append((version, "(manifest)", "manifest not found"))
+            total_failed += 1
+            continue
+
+        prefix = manifest.pop("_prefix", f"v{version}/arrays")
+        _info(f"  manifest: {prefix}/manifest.json ({len(manifest['fixtures'])} fixtures)")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmppath = Path(tmpdir)
+
+            _info(f"  downloading {len(manifest['fixtures'])} fixtures...")
+            download_failures = _parallel_download(store, manifest["fixtures"], prefix, tmppath)
+            for name, error in download_failures:
+                _info(f"  v{version}: {name} {error}")
+                all_failures.append((version, name, error))
+                total_failed += 1
+
+            _info(f"  checking v{version}...")
+            result = _run_rust_check(tmppath, mode="superset", profile=args.profile)
+
+            passed = len(result.get("passed", []))
+            failed_list = result.get("failed", [])
+            skipped = len(result.get("skipped", []))
+            total_passed += passed
+            total_failed += len(failed_list)
+            total_skipped += skipped
+
+            if failed_list:
+                _info(f"  v{version}: {passed} passed, {len(failed_list)} FAILED, {skipped} skipped")
+                for f in failed_list:
+                    _info(f"    FAIL {f['name']}: {f['error']}")
+                    all_failures.append((version, f["name"], f["error"]))
+            else:
+                _info(f"  v{version}: {passed} passed, {skipped} skipped")
+
+    _info(f"\nresult: {total_passed} passed, {total_failed} failed, {total_skipped} skipped")
+    if all_failures:
+        sys.exit(1)
+
+
+def cmd_list(args: argparse.Namespace) -> None:
+    """List versions or show a version's manifest."""
+    store = _parse_store(args.store)
+
+    if args.version:
+        manifest = _read_manifest(store, args.version)
+        if manifest is None:
+            print(f"no manifest found for v{args.version}", file=sys.stderr)
+            sys.exit(1)
+        print(json.dumps(manifest, indent=2))
+    else:
+        versions = store.list_versions()
+        if not versions:
+            _info("(no versions)")
+        for v in versions:
+            print(v)
+
+
+def cmd_verify(args: argparse.Namespace) -> None:
+    """Verify fixture file integrity against manifest sha256 hashes."""
+    store = _parse_store(args.store)
+    versions = store.list_versions()
+
+    if not versions:
+        _info("no versions found")
+        sys.exit(1)
+
+    _info(f"verifying {len(versions)} version(s) in {store.display_name()}...")
+
+    total_ok = 0
+    errors: list[str] = []
+
+    for version in versions:
+        _info(f"\n--- v{version} ---")
+        manifest = _read_manifest(store, version)
+        if manifest is None:
+            msg = f"v{version}: manifest not found"
+            _info(f"  FAIL: {msg}")
+            errors.append(msg)
+            continue
+
+        prefix = manifest.pop("_prefix", f"v{version}/arrays")
+
+        for entry in manifest["fixtures"]:
+            name = entry["name"]
+            expected_hash = entry.get("sha256")
+            data = store.read(f"{prefix}/{name}")
+
+            if data is None:
+                msg = f"v{version}/{name}: file missing from store"
+                _info(f"  FAIL: {msg}")
+                errors.append(msg)
+                continue
+
+            if expected_hash is None:
+                msg = f"v{version}/{name}: no sha256 in manifest"
+                _info(f"  FAIL: {msg}")
+                errors.append(msg)
+                continue
+
+            actual_hash = hashlib.sha256(data).hexdigest()
+            if actual_hash != expected_hash:
+                msg = f"v{version}/{name}: sha256 mismatch expected={expected_hash[:12]} actual={actual_hash[:12]}"
+                _info(f"  FAIL: {msg}")
+                errors.append(msg)
+            else:
+                _info(f"  {name}: ok ({len(data)} bytes)")
+                total_ok += 1
+
+    _info(f"\nresult: {total_ok} ok, {len(errors)} failed")
+    if errors:
+        for e in errors:
+            _info(f"  {e}")
+        sys.exit(1)
+    else:
+        _info("all fixtures verified.")
+
+
+def cmd_validate_manifest(args: argparse.Namespace) -> None:
+    """Check that manifests are additive-only across all versions."""
+    store = _parse_store(args.store)
+    versions = store.list_versions()
+
+    if not versions:
+        _info("no versions found")
+        return
+
+    _info(f"validating {len(versions)} version(s)...")
+
+    prev_names: set[str] | None = None
+    prev_version: str | None = None
+    errors: list[str] = []
+
+    for version in versions:
+        manifest = _read_manifest(store, version)
+        if manifest is None:
+            _info(f"  v{version}: no manifest, skipping")
+            continue
+        names = {e["name"] for e in manifest["fixtures"]}
+
+        if prev_names is not None:
+            missing = prev_names - names
+            if missing:
+                msg = f"v{version} missing from v{prev_version}: {', '.join(sorted(missing))}"
+                _info(f"  FAIL: {msg}")
+                errors.append(msg)
+            else:
+                new = len(names) - len(prev_names)
+                extra = f" (+{new} new)" if new > 0 else ""
+                _info(f"  v{prev_version} -> v{version}: ok ({len(names)} fixtures{extra})")
+        else:
+            _info(f"  v{version}: {len(names)} fixtures (first)")
+
+        prev_names = names
+        prev_version = version
+
+    if errors:
+        _info(f"\n{len(errors)} error(s)")
+        sys.exit(1)
+    else:
+        _info("\nall manifests are additive-only.")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _write_store(store: Store, args: argparse.Namespace, prompt: str) -> Store:
+    """Return a DryRunStore wrapper or the real store, with optional confirmation."""
+    if args.dry_run:
+        return DryRunStore(store)
+    if not args.yes:
+        _info(prompt)
+        answer = input("proceed? [y/N] ").strip().lower()
+        if answer not in ("y", "yes"):
+            _info("aborted")
+            sys.exit(1)
+    return store
+
+
+def _parallel_upload(store: Store, items: list[tuple[str, Path]], max_workers: int = 8) -> None:
+    """Upload files to the store in parallel."""
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(store.write_file, key, local): key for key, local in items}
+        for future in as_completed(futures):
+            future.result()
+
+
+def _parallel_download(
+    store: Store,
+    fixtures: list[dict],
+    prefix: str,
+    dest: Path,
+    max_workers: int = 8,
+) -> list[tuple[str, str]]:
+    """Download fixture files from the store in parallel.
+
+    Returns a list of (name, error) for any failures.
+    """
+    failures: list[tuple[str, str]] = []
+    total_bytes = 0
+
+    def _download_one(entry: dict) -> tuple[str, bytes | None]:
+        name = entry["name"]
+        data = store.read(f"{prefix}/{name}")
+        return name, data
+
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(_download_one, entry): entry["name"] for entry in fixtures}
+        for future in as_completed(futures):
+            name, data = future.result()
+            if data is None:
+                failures.append((name, f"not found at {prefix}/{name}"))
+            else:
+                (dest / name).write_bytes(data)
+                total_bytes += len(data)
+
+    _info(f"  downloaded {len(fixtures) - len(failures)} fixtures ({total_bytes} bytes)")
+    return failures
+
+
+def _build_compat_bin(profile: str = "release") -> str:
+    """Build vortex-compat and return the path to the binary.
+
+    If VORTEX_COMPAT_BIN is set, skips the build and returns that path.
+    Otherwise runs `cargo build` with visible output, then locates the binary.
+    """
+    bin_path = os.environ.get("VORTEX_COMPAT_BIN")
+    if bin_path:
+        return bin_path
+
+    _info(f"building vortex-compat ({profile})...")
+    _run_cmd(["cargo", "build", "-p", CARGO_BIN, "--profile", profile], check=True)
+
+    # Ask cargo where the binary is.
+    result = subprocess.run(
+        ["cargo", "metadata", "--format-version=1", "--no-deps"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    target_dir = json.loads(result.stdout)["target_directory"]
+    # Cargo puts "dev" profile binaries in "debug/", all others in "<profile>/".
+    dir_name = "debug" if profile == "dev" else profile
+    bin_path = str(Path(target_dir) / dir_name / CARGO_BIN)
+    return bin_path
+
+
+def _run_rust_generate(output: Path, profile: str = "release") -> None:
+    """Run `vortex-compat generate --output <dir>`."""
+    bin_path = _build_compat_bin(profile)
+    _run_cmd([bin_path, "generate", "--output", str(output)], check=True)
+
+
+def _run_rust_check(dir: Path, mode: str = "superset", profile: str = "release") -> dict:
+    """Run `vortex-compat check --dir <dir> --mode <mode>` and parse JSON stdout."""
+    bin_path = _build_compat_bin(profile)
+    cmd = [bin_path, "check", "--dir", str(dir), "--mode", mode]
+    _info(f"  $ {' '.join(cmd)}")
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=None, text=True)  # noqa: UP022
+
+    if result.stdout.strip():
+        return json.loads(result.stdout)
+
+    if result.returncode != 0:
+        return {
+            "passed": [],
+            "failed": [{"name": "(all)", "error": "check process failed"}],
+            "skipped": [],
+        }
+    return {"passed": [], "failed": [], "skipped": []}
+
+
+def _run_cmd(cmd: list[str], check: bool = False, cwd: Path | None = None) -> subprocess.CompletedProcess:
+    _info(f"  $ {' '.join(cmd)}")
+    result = subprocess.run(cmd, check=False, cwd=cwd)
+    if check and result.returncode != 0:
+        raise subprocess.CalledProcessError(result.returncode, cmd)
+    return result
+
+
+def _find_prev_version(versions: list[str], current: str) -> str | None:
+    """Find the highest version strictly less than `current`."""
+    current_key = _version_sort_key(current)
+    prev = None
+    for v in versions:
+        if _version_sort_key(v) < current_key:
+            prev = v
+    return prev
+
+
+def _version_sort_key(v: str) -> list[int]:
+    parts = []
+    for p in v.split("."):
+        try:
+            parts.append(int(p))
+        except ValueError:
+            parts.append(0)
+    return parts
+
+
+def _info(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="compat.py",
+        description="Vortex backward-compatibility fixture orchestrator",
+        epilog=EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--profile",
+        default="release",
+        help="Cargo build profile (default: release). Use 'dev' for faster builds.",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    # -- generate --
+    p = sub.add_parser(
+        "generate",
+        help="Generate fixtures locally",
+        description=(
+            "Build all fixture .vortex files using the current binary and write\n"
+            "them to a directory. Version is auto-detected from the nearest git\n"
+            "tag at HEAD (or at --git-ref if specified)."
+        ),
+        epilog=(
+            "examples:\n"
+            "  uv run compat.py generate --output ./out\n"
+            "  uv run compat.py generate --output ./out --git-ref v0.62.0"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--output", required=True, help="Output directory")
+    p.add_argument(
+        "--git-ref",
+        help="Git ref for version detection (e.g. v0.62.0). "
+        "Version is derived from the nearest tag at this ref. "
+        "Fixtures are always built with the current binary.",
+    )
+
+    # -- publish --
+    p = sub.add_parser(
+        "publish",
+        help="Generate and publish fixtures to a store",
+        description=(
+            "Generate fixture files, merge the manifest with the previous version,\n"
+            "and upload everything to the store. Version is auto-detected from the\n"
+            "nearest git tag at HEAD (or at --git-ref)."
+        ),
+        epilog=(
+            "examples:\n"
+            "  uv run compat.py publish\n"
+            "  uv run compat.py publish --dry-run\n"
+            "  uv run compat.py publish --git-ref v0.62.0\n"
+            "  uv run compat.py publish --store /tmp/store"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--store", default=DEFAULT_STORE, help="Store spec (default: %(default)s)")
+    p.add_argument(
+        "--git-ref",
+        help="Git ref for version detection (e.g. v0.62.0). "
+        "Version is derived from the nearest tag at this ref. "
+        "Fixtures are always built with the current binary.",
+    )
+    p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Validate credentials and show what would be uploaded, without writing",
+    )
+    p.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite an existing version in the store",
+    )
+    p.add_argument(
+        "--update",
+        action="store_true",
+        help="Incremental update: add new fixtures to an existing version "
+        "(hash-verified, skips unchanged files, errors on mismatches)",
+    )
+    p.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+
+    # -- check --
+    p = sub.add_parser(
+        "check",
+        help="Validate fixtures from a store against current code",
+        description=(
+            "Download fixtures for each version from the store, then use the\n"
+            "current vortex-compat binary to verify they can still be read and\n"
+            "match expectations."
+        ),
+        epilog=(
+            "examples:\n"
+            "  uv run compat.py check\n"
+            "  uv run compat.py check --mode last\n"
+            "  uv run compat.py check --versions 0.62.0,0.63.0\n"
+            "  uv run compat.py check --store /tmp/store"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--store", default=DEFAULT_STORE, help="Store spec (default: %(default)s)")
+    p.add_argument(
+        "--versions",
+        help="Comma-separated versions to check (mutually exclusive with --mode)",
+    )
+    p.add_argument(
+        "--mode",
+        choices=["all", "last"],
+        default="all",
+        help="Which versions to check: 'all' (default) or 'last' (most recent only). "
+        "Mutually exclusive with --versions.",
+    )
+
+    # -- list --
+    p = sub.add_parser(
+        "list",
+        help="List versions or show a version's manifest",
+        description="Inspect the contents of a fixture store.",
+        epilog=(
+            "examples:\n"
+            "  uv run compat.py list\n"
+            "  uv run compat.py list 0.62.0\n"
+            "  uv run compat.py list --store /tmp/store"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--store", default=DEFAULT_STORE, help="Store spec (default: %(default)s)")
+    p.add_argument("version", nargs="?", help="Show manifest for this version")
+
+    # -- verify --
+    p = sub.add_parser(
+        "verify",
+        help="Verify fixture file integrity against manifest sha256 hashes",
+        description=(
+            "Download every fixture file for every version and verify its\n"
+            "SHA-256 hash matches the manifest. Also checks that all files\n"
+            "listed in manifests are present in the store."
+        ),
+        epilog=("examples:\n  uv run compat.py verify\n  uv run compat.py verify --store /tmp/store"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--store", default=DEFAULT_STORE, help="Store spec (default: %(default)s)")
+
+    # -- validate-manifest --
+    p = sub.add_parser(
+        "validate-manifest",
+        help="Check additive-only property across all versions",
+        description=(
+            "Verify that no fixtures were removed between consecutive versions.\n"
+            "New fixtures are allowed; removals are errors."
+        ),
+        epilog=(
+            "examples:\n  uv run compat.py validate-manifest\n  uv run compat.py validate-manifest --store /tmp/store"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--store", default=DEFAULT_STORE, help="Store spec (default: %(default)s)")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    commands = {
+        "generate": cmd_generate,
+        "publish": cmd_publish,
+        "check": cmd_check,
+        "list": cmd_list,
+        "verify": cmd_verify,
+        "validate-manifest": cmd_validate_manifest,
+    }
+    commands[args.command](args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/vortex-test/compat-gen/src/adapter.rs b/vortex-test/compat-gen/src/adapter.rs
new file mode 100644
index 00000000000..9e29d6d69f0
--- /dev/null
+++ b/vortex-test/compat-gen/src/adapter.rs
@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+// Epoch C adapter — for Vortex v0.58.0 through HEAD
+//
+// Write: session.write_options(), returns WriteSummary, takes &mut sink
+// Read:  session.open_options().open_buffer(buf) (sync), into_array_stream() (async)
+
+use std::path::Path;
+use std::sync::Arc;
+
+use futures::stream;
+use tokio::runtime::Runtime;
+use vortex::VortexSessionDefault;
+use vortex::array::ArrayRef;
+use vortex::array::MaskFuture;
+use vortex::array::expr::root;
+use vortex::file::OpenOptionsSessionExt;
+use vortex::file::WriteOptionsSessionExt;
+use vortex::io::session::RuntimeSessionExt;
+use vortex::layout::LayoutStrategy;
+use vortex::layout::layouts::flat::Flat;
+use vortex::layout::layouts::flat::writer::FlatLayoutStrategy;
+use vortex_array::expr::stats::Stat;
+use vortex_array::stream::ArrayStreamAdapter;
+use vortex_array::stream::ArrayStreamExt;
+use vortex_buffer::ByteBuffer;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+use vortex_session::VortexSession;
+
+fn runtime() -> VortexResult<Runtime> {
+    Runtime::new().map_err(|e| vortex_err!("failed to create tokio runtime: {e}"))
+}
+
+/// Compute all statistics on every node in the array tree.
+///
+/// The flat layout writer does not compute stats itself — it only serializes stats already
+/// cached on each array node. This function walks the entire tree and forces computation of
+/// all stats so they are present in the serialized output.
+pub fn compute_all_stats(array: &ArrayRef) -> VortexResult<()> {
+    let all_stats: Vec<Stat> = Stat::all().collect();
+    for node in array.depth_first_traversal() {
+        let computed = node.statistics().compute_all(&all_stats)?;
+        node.statistics().set_iter(computed.into_iter());
+    }
+    Ok(())
+}
+
+/// Write a sequence of array chunks as a `.vortex` file with no compression.
+///
+/// Uses `FlatLayoutStrategy` directly — no repartitioning, no zone maps, no dictionary
+/// encoding, no compression. Each chunk is serialized as a single flat segment.
+pub fn write_file(path: &Path, chunk: ArrayRef) -> VortexResult<()> {
+    write_compressed(path, chunk, Arc::new(FlatLayoutStrategy::default()))
+}
+
+/// Write a sequence of array chunks to an in-memory `.vortex` byte buffer with no compression.
+pub fn write_file_to_bytes(chunk: ArrayRef) -> VortexResult<ByteBuffer> {
+    write_compressed_to_bytes(chunk, Arc::new(FlatLayoutStrategy::default()))
+}
+
+/// Write a `.vortex` file using a caller-provided layout strategy (compressor pipeline).
+pub fn write_compressed(
+    path: &Path,
+    chunk: ArrayRef,
+    strategy: Arc<dyn LayoutStrategy>,
+) -> VortexResult<()> {
+    let stream = ArrayStreamAdapter::new(chunk.dtype().clone(), stream::iter([Ok(chunk)]));
+
+    runtime()?.block_on(async {
+        let session = VortexSession::default().with_tokio();
+        let mut file = tokio::fs::File::create(path)
+            .await
+            .map_err(|e| vortex_err!("failed to create {}: {e}", path.display()))?;
+        let _summary = session
+            .write_options()
+            .with_strategy(strategy)
+            .write(&mut file, stream)
+            .await?;
+        Ok(())
+    })
+}
+
+/// Write a `.vortex` file into an in-memory byte buffer using a caller-provided layout strategy.
+pub fn write_compressed_to_bytes(
+    chunk: ArrayRef,
+    strategy: Arc<dyn LayoutStrategy>,
+) -> VortexResult<ByteBuffer> {
+    let stream = ArrayStreamAdapter::new(chunk.dtype().clone(), stream::iter([Ok(chunk)]));
+
+    runtime()?.block_on(async {
+        let session = VortexSession::default().with_tokio();
+        let mut bytes = Vec::new();
+        let _summary = session
+            .write_options()
+            .with_strategy(strategy)
+            .write(&mut bytes, stream)
+            .await?;
+        Ok(ByteBuffer::from(bytes))
+    })
+}
+
+/// Read a `.vortex` file from bytes, returning the arrays.
+pub fn read_file(bytes: ByteBuffer) -> VortexResult<ArrayRef> {
+    runtime()?.block_on(async {
+        let session = VortexSession::default().with_tokio();
+        let file = session.open_options().open_buffer(bytes)?;
+        file.scan()?.into_array_stream()?.read_all().await
+    })
+}
+
+/// Open a `.vortex` file and fully decode every array in the layout tree, including
+/// auxiliary data like zone maps and dictionaries.
+///
+/// Walks the entire layout tree and for each leaf `FlatLayout`, reads the segment
+/// and calls `ArrayParts::decode()` to fully deserialize the array. This exercises
+/// every segment in the file — not just the data path that a plain `scan()` touches.
+/// If any segment is corrupt or any array fails to decode, this will error.
+pub fn read_layout_tree(bytes: ByteBuffer) -> VortexResult<()> {
+    runtime()?.block_on(async {
+        let session = VortexSession::default().with_tokio();
+        let file = session.open_options().open_buffer(bytes)?;
+        let root_layout = Arc::clone(file.footer().layout());
+        let segment_source = file.segment_source();
+
+        for layout_result in root_layout.depth_first_traversal() {
+            let layout = layout_result?;
+            if layout.as_opt::<Flat>().is_none() {
+                continue;
+            }
+            let row_count = layout.row_count();
+            if row_count == 0 {
+                continue;
+            }
+            let reader = layout.new_reader("".into(), Arc::clone(&segment_source), &session)?;
+            let len =
+                usize::try_from(row_count).map_err(|e| vortex_err!("row count overflow: {e}"))?;
+            reader
+                .projection_evaluation(&(0..row_count), &root(), MaskFuture::new_true(len))?
+                .await?;
+        }
+
+        Ok(())
+    })
+}
diff --git a/vortex-test/compat-gen/src/check.rs b/vortex-test/compat-gen/src/check.rs
new file mode 100644
index 00000000000..7533ee9dab7
--- /dev/null
+++ b/vortex-test/compat-gen/src/check.rs
@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::path::Path;
+
+use clap::ValueEnum;
+use serde::Serialize;
+use vortex_array::assert_arrays_eq;
+use vortex_buffer::ByteBuffer;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+
+use crate::adapter;
+use crate::fixtures::all_fixtures;
+
+/// How to handle mismatches between directory and known fixtures.
+#[derive(Clone, ValueEnum)]
+pub enum Mode {
+    /// Directory must match fixtures exactly.
+    Exact,
+    /// Directory may have extra files (skip), but all known must be present.
+    Subset,
+    /// Directory may be missing files (skip), but no unknown files allowed.
+    Superset,
+}
+
+#[derive(Serialize)]
+struct CheckResult {
+    passed: Vec<String>,
+    failed: Vec<FailedFixture>,
+    skipped: Vec<String>,
+}
+
+#[derive(Serialize)]
+struct FailedFixture {
+    name: String,
+    error: String,
+}
+
+/// Check `.vortex` files in `dir` against in-memory fixtures.
+///
+/// For each known fixture, generates fresh files in a temp directory via
+/// `fixture.write(tmp_dir)`, then reads both the stored file and fresh file,
+/// decodes them, and compares the arrays.
+///
+/// Prints JSON result to stdout, human-readable progress to stderr.
+/// Returns error if any fixture failed or if mode constraints are violated.
+pub fn check(dir: &Path, mode: Mode, exclude: &[String]) -> VortexResult<()> {
+    let fixtures = all_fixtures();
+    let fixtures: Vec<_> = fixtures
+        .into_iter()
+        .filter(|f| {
+            let name = f.name();
+            !exclude.iter().any(|pat| name.contains(pat.as_str()))
+        })
+        .collect();
+
+    if !exclude.is_empty() {
+        eprintln!("excluding: {}", exclude.join(", "));
+    }
+
+    // Generate fresh fixtures into a temp directory.
+    let tmp_dir = tempfile::tempdir().map_err(|e| vortex_err!("failed to create temp dir: {e}"))?;
+
+    eprintln!("generating fresh fixtures for comparison...");
+    for fixture in &fixtures {
+        fixture.write(tmp_dir.path())?;
+    }
+
+    // Collect .vortex files in the check directory.
+    let dir_files: Vec<String> = std::fs::read_dir(dir)
+        .map_err(|e| vortex_err!("failed to read dir {}: {e}", dir.display()))?
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            let name = entry.file_name().to_string_lossy().to_string();
+            name.ends_with(".vortex").then_some(name)
+        })
+        .collect();
+
+    // Collect all fixture names (each fixture may produce multiple files).
+    let fresh_files: Vec<String> = std::fs::read_dir(tmp_dir.path())
+        .map_err(|e| vortex_err!("failed to read tmp dir: {e}"))?
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            let name = entry.file_name().to_string_lossy().to_string();
+            name.ends_with(".vortex").then_some(name)
+        })
+        .collect();
+
+    let mut result = CheckResult {
+        passed: Vec::new(),
+        failed: Vec::new(),
+        skipped: Vec::new(),
+    };
+
+    // Check for unknown files in the directory.
+    for file_name in &dir_files {
+        if !fresh_files.contains(file_name) {
+            match mode {
+                Mode::Exact | Mode::Superset => {
+                    result.failed.push(FailedFixture {
+                        name: file_name.clone(),
+                        error: "unknown fixture (not in current fixture set)".to_string(),
+                    });
+                }
+                Mode::Subset => {
+                    eprintln!("  skip {file_name} (unknown)");
+                    result.skipped.push(file_name.clone());
+                }
+            }
+        }
+    }
+
+    // Check each known fixture file.
+    for fresh_name in &fresh_files {
+        let stored_path = dir.join(fresh_name);
+        if !stored_path.exists() {
+            match mode {
+                Mode::Exact | Mode::Subset => {
+                    result.failed.push(FailedFixture {
+                        name: fresh_name.clone(),
+                        error: "file missing from directory".to_string(),
+                    });
+                }
+                Mode::Superset => {
+                    eprintln!("  skip {fresh_name} (missing)");
+                    result.skipped.push(fresh_name.clone());
+                }
+            }
+            continue;
+        }
+
+        eprintln!("  checking {fresh_name}...");
+
+        // Read the stored file.
+        let stored_bytes = match std::fs::read(&stored_path) {
+            Ok(b) => ByteBuffer::from(b),
+            Err(e) => {
+                result.failed.push(FailedFixture {
+                    name: fresh_name.clone(),
+                    error: format!("failed to read stored file: {e}"),
+                });
+                continue;
+            }
+        };
+
+        // Read the fresh file.
+        let fresh_path = tmp_dir.path().join(fresh_name);
+        let fresh_bytes = match std::fs::read(&fresh_path) {
+            Ok(b) => ByteBuffer::from(b),
+            Err(e) => {
+                result.failed.push(FailedFixture {
+                    name: fresh_name.clone(),
+                    error: format!("failed to read fresh file: {e}"),
+                });
+                continue;
+            }
+        };
+
+        // Validate the full layout tree of the stored file (reads every segment
+        // including zone maps, dictionaries, etc.).
+        if let Err(e) = adapter::read_layout_tree(stored_bytes.clone()) {
+            result.failed.push(FailedFixture {
+                name: fresh_name.clone(),
+                error: format!("stored file layout tree invalid: {e}"),
+            });
+            continue;
+        }
+
+        // Scan data arrays from both files and compare.
+        let stored_array = match adapter::read_file(stored_bytes) {
+            Ok(a) => a,
+            Err(e) => {
+                result.failed.push(FailedFixture {
+                    name: fresh_name.clone(),
+                    error: format!("failed to decode stored vortex file: {e}"),
+                });
+                continue;
+            }
+        };
+        let fresh_array = match adapter::read_file(fresh_bytes) {
+            Ok(a) => a,
+            Err(e) => {
+                result.failed.push(FailedFixture {
+                    name: fresh_name.clone(),
+                    error: format!("failed to decode fresh vortex file: {e}"),
+                });
+                continue;
+            }
+        };
+
+        assert_arrays_eq!(stored_array, fresh_array);
+        eprintln!("  pass {fresh_name}");
+        result.passed.push(fresh_name.clone());
+    }
+
+    // Print JSON result to stdout.
+    let json = serde_json::to_string_pretty(&result)
+        .map_err(|e| vortex_err!("failed to serialize result: {e}"))?;
+    println!("{json}");
+
+    // Summary to stderr.
+    eprintln!(
+        "\nresult: {} passed, {} failed, {} skipped",
+        result.passed.len(),
+        result.failed.len(),
+        result.skipped.len()
+    );
+
+    if !result.failed.is_empty() {
+        for f in &result.failed {
+            eprintln!("  FAIL {}: {}", f.name, f.error);
+        }
+        vortex_bail!("{} fixture(s) failed", result.failed.len());
+    }
+
+    Ok(())
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs b/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs
new file mode 100644
index 00000000000..7cae6944463
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/datasets/clickbench.rs
@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use arrow_array::RecordBatch;
+use bytes::Bytes;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ChunkedArray;
+use vortex_array::arrow::FromArrowArray;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::fixtures::DatasetFixture;
+
+// TODO: Upload the pre-sampled 5k parquet to R2 and download it in a build.rs instead of
+// downloading the full ~112MB partition 0 at runtime.
+const CLICKBENCH_URL: &str =
+    "https://pub-3ba949c0f0354ac18db1f0f14f0a2c52.r2.dev/clickbench/parquet_many/hits_0.parquet";
+
+/// Deterministic offsets (seed=42) into clickbench hits partition 0.
+const SAMPLE_OFFSETS: [usize; 5] = [26225, 116739, 288389, 670487, 777572];
+const ROWS_PER_OFFSET: usize = 1000;
+
+const MAX_RETRIES: u32 = 3;
+
+/// Returns the path to `data/clickbench_hits_5k.parquet` relative to the crate root,
+/// downloading and sampling from the full dataset if it doesn't already exist.
+fn cached_clickbench_parquet() -> VortexResult<PathBuf> {
+    let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let data_dir = crate_dir.join("data");
+    let dest = data_dir.join("clickbench_hits_5k.parquet");
+
+    if dest.exists() {
+        return Ok(dest);
+    }
+
+    fs::create_dir_all(&data_dir).map_err(|e| vortex_err!("failed to create data dir: {e}"))?;
+
+    // Download full partition 0 to a temp file.
+    let source_bytes = download_with_retries(CLICKBENCH_URL)?;
+
+    // Sample 5k rows and write to dest.
+    sample_and_write(&source_bytes, &dest)?;
+
+    Ok(dest)
+}
+
+fn download_with_retries(url: &str) -> VortexResult<Bytes> {
+    let client = reqwest::blocking::Client::builder()
+        .timeout(std::time::Duration::from_secs(300))
+        .build()
+        .map_err(|e| vortex_err!("failed to build HTTP client: {e}"))?;
+
+    for attempt in 1..=MAX_RETRIES {
+        match client.get(url).send() {
+            Ok(response) if response.status().is_success() => {
+                return response
+                    .bytes()
+                    .map_err(|e| vortex_err!("failed to read response body: {e}"));
+            }
+            Ok(response) if response.status().is_client_error() => {
+                return Err(vortex_err!(
+                    "HTTP {}: failed to download {url}",
+                    response.status()
+                ));
+            }
+            Ok(response) => {
+                eprintln!(
+                    "Download attempt {attempt}/{MAX_RETRIES} failed: HTTP {} for {url}",
+                    response.status()
+                );
+            }
+            Err(e) => {
+                eprintln!("Download attempt {attempt}/{MAX_RETRIES} failed: {e}");
+            }
+        }
+
+        if attempt < MAX_RETRIES {
+            let delay = std::time::Duration::from_secs(2u64.pow(attempt));
+            std::thread::sleep(delay);
+        }
+    }
+
+    Err(vortex_err!(
+        "failed to download {url} after {MAX_RETRIES} attempts"
+    ))
+}
+
+#[expect(clippy::cast_possible_truncation)]
+fn sample_and_write(source_bytes: &[u8], dest: &std::path::Path) -> VortexResult<()> {
+    let source_bytes = Bytes::copy_from_slice(source_bytes);
+    let builder = ParquetRecordBatchReaderBuilder::try_new(source_bytes.clone())
+        .map_err(|e| vortex_err!("failed to open source parquet: {e}"))?;
+    let metadata = Arc::clone(builder.metadata());
+
+    let total_rows: usize = metadata
+        .row_groups()
+        .iter()
+        .map(|rg| rg.num_rows() as usize)
+        .sum();
+
+    // Build (row_group_index, local_offset, count) ranges for each sample window.
+    let mut ranges: Vec<(usize, usize, usize)> = Vec::new();
+    for &offset in &SAMPLE_OFFSETS {
+        let end = (offset + ROWS_PER_OFFSET).min(total_rows);
+        let mut remaining = end - offset;
+        let mut global_pos = 0usize;
+
+        for (rg_idx, rg_meta) in metadata.row_groups().iter().enumerate() {
+            let rg_rows = rg_meta.num_rows() as usize;
+            let rg_end = global_pos + rg_rows;
+
+            if offset < rg_end && global_pos < end {
+                let local_start = offset.saturating_sub(global_pos);
+                let local_end = (local_start + remaining).min(rg_rows);
+                let count = local_end - local_start;
+                if count > 0 {
+                    ranges.push((rg_idx, local_start, count));
+                    remaining -= count;
+                }
+            }
+            global_pos = rg_end;
+            if remaining == 0 {
+                break;
+            }
+        }
+    }
+
+    // Read each range and collect batches.
+    let mut sampled_batches: Vec<RecordBatch> = Vec::new();
+    for &(rg_idx, local_offset, count) in &ranges {
+        let reader = ParquetRecordBatchReaderBuilder::try_new(source_bytes.clone())
+            .map_err(|e| vortex_err!("failed to open parquet for sampling: {e}"))?
+            .with_row_groups(vec![rg_idx])
+            .with_offset(local_offset)
+            .with_limit(count)
+            .with_batch_size(count)
+            .build()
+            .map_err(|e| vortex_err!("failed to build parquet reader: {e}"))?;
+
+        for batch in reader {
+            sampled_batches
+                .push(batch.map_err(|e| vortex_err!("failed to read parquet batch: {e}"))?);
+        }
+    }
+
+    // Write sampled batches to a parquet file.
+    let schema = sampled_batches[0].schema();
+    let combined = arrow_select::concat::concat_batches(&schema, &sampled_batches)
+        .map_err(|e| vortex_err!("failed to concat batches: {e}"))?;
+
+    let file =
+        fs::File::create(dest).map_err(|e| vortex_err!("failed to create output parquet: {e}"))?;
+    let mut writer = parquet::arrow::ArrowWriter::try_new(file, schema, None)
+        .map_err(|e| vortex_err!("failed to create parquet writer: {e}"))?;
+    writer
+        .write(&combined)
+        .map_err(|e| vortex_err!("failed to write parquet: {e}"))?;
+    writer
+        .close()
+        .map_err(|e| vortex_err!("failed to close parquet writer: {e}"))?;
+
+    Ok(())
+}
+
+struct ClickBenchHits5kFixture;
+
+impl DatasetFixture for ClickBenchHits5kFixture {
+    fn name(&self) -> &str {
+        "clickbench_hits_5k"
+    }
+
+    fn description(&self) -> &str {
+        "5000 rows (5x1000 from random offsets) of ClickBench hits dataset with wide schema of primitives and strings"
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let path = cached_clickbench_parquet()?;
+        let file_bytes = fs::read(&path)
+            .map_err(|e| vortex_err!("failed to read cached parquet at {}: {e}", path.display()))?;
+        let bytes = Bytes::from(file_bytes);
+
+        let reader = ParquetRecordBatchReaderBuilder::try_new(bytes)
+            .map_err(|e| vortex_err!("failed to open parquet: {e}"))?
+            .with_batch_size(1000)
+            .build()
+            .map_err(|e| vortex_err!("failed to build parquet reader: {e}"))?;
+
+        let batches: Vec<RecordBatch> = reader
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| vortex_err!("failed to read parquet batches: {e}"))?;
+
+        Ok(ChunkedArray::from_iter(
+            batches
+                .into_iter()
+                .map(|batch| ArrayRef::from_arrow(batch, false))
+                .collect::<VortexResult<Vec<_>>>()?,
+        )
+        .into_array())
+    }
+}
+
+pub fn fixtures() -> Vec<Box<dyn DatasetFixture>> {
+    vec![Box::new(ClickBenchHits5kFixture)]
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/datasets/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/datasets/mod.rs
new file mode 100644
index 00000000000..c799bc7a380
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/datasets/mod.rs
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod clickbench;
+#[allow(clippy::cast_possible_truncation)]
+mod tpch;
+
+use crate::fixtures::DatasetFixture;
+
+/// All dataset-derived fixtures.
+pub fn fixtures() -> Vec<Box<dyn DatasetFixture>> {
+    let mut fixtures = Vec::new();
+    fixtures.extend(tpch::fixtures());
+    fixtures.extend(clickbench::fixtures());
+    fixtures
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex::compressor::BtrBlocksCompressorBuilder;
+    use vortex::file::WriteStrategyBuilder;
+
+    use super::fixtures;
+    use crate::adapter;
+
+    fn is_clickbench_fixture(name: &str) -> bool {
+        name.contains("clickbench")
+    }
+
+    #[test]
+    fn roundtrip_non_clickbench_fixtures_to_bytes() {
+        for dataset in fixtures()
+            .into_iter()
+            .filter(|fixture| !is_clickbench_fixture(fixture.name()))
+        {
+            let array = dataset.build().unwrap();
+            let regular_bytes = adapter::write_compressed_to_bytes(
+                array.clone(),
+                WriteStrategyBuilder::default().build(),
+            )
+            .unwrap();
+            let _regular = adapter::read_file(regular_bytes).unwrap();
+
+            let compact_bytes = adapter::write_compressed_to_bytes(
+                array,
+                WriteStrategyBuilder::default()
+                    .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
+                    .build(),
+            )
+            .unwrap();
+            let _compact = adapter::read_file(compact_bytes).unwrap();
+        }
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/datasets/tpch.rs b/vortex-test/compat-gen/src/fixtures/arrays/datasets/tpch.rs
new file mode 100644
index 00000000000..9d831bef143
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/datasets/tpch.rs
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use arrow_array::RecordBatch;
+use tpchgen::generators::LineItemGenerator;
+use tpchgen::generators::OrderGenerator;
+use tpchgen_arrow::RecordBatchIterator;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ChunkedArray;
+use vortex_array::arrow::FromArrowArray;
+use vortex_error::VortexResult;
+
+use crate::fixtures::DatasetFixture;
+
+const SCALE_FACTOR: f64 = 0.01;
+
+fn collect_batches_as_vortex(iter: impl RecordBatchIterator) -> VortexResult<ArrayRef> {
+    let batches: Vec<RecordBatch> = iter.collect();
+    Ok(ChunkedArray::from_iter(
+        batches
+            .into_iter()
+            .map(|batch| ArrayRef::from_arrow(batch, false))
+            .collect::<VortexResult<Vec<_>>>()?,
+    )
+    .into_array())
+}
+
+struct TpchLineitemFixture;
+
+impl DatasetFixture for TpchLineitemFixture {
+    fn name(&self) -> &str {
+        "tpch_lineitem"
+    }
+
+    fn description(&self) -> &str {
+        "TPC-H lineitem table at scale factor 0.01 with decimals, dates, and strings"
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let generator = LineItemGenerator::new(SCALE_FACTOR, 1, 1);
+        let arrow_iter = tpchgen_arrow::LineItemArrow::new(generator).with_batch_size(65_536);
+        collect_batches_as_vortex(arrow_iter)
+    }
+}
+
+struct TpchOrdersFixture;
+
+impl DatasetFixture for TpchOrdersFixture {
+    fn name(&self) -> &str {
+        "tpch_orders"
+    }
+
+    fn description(&self) -> &str {
+        "TPC-H orders table at scale factor 0.01 with decimals, dates, and strings"
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let generator = OrderGenerator::new(SCALE_FACTOR, 1, 1);
+        let arrow_iter = tpchgen_arrow::OrderArrow::new(generator).with_batch_size(65_536);
+        collect_batches_as_vortex(arrow_iter)
+    }
+}
+
+pub fn fixtures() -> Vec<Box<dyn DatasetFixture>> {
+    vec![Box::new(TpchLineitemFixture), Box::new(TpchOrdersFixture)]
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/mod.rs
new file mode 100644
index 00000000000..1447bc4da4c
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/mod.rs
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod datasets;
+mod synthetic;
+
+use super::DatasetFixture;
+use super::FlatLayoutFixture;
+
+/// All synthetic (flat-layout) fixtures.
+pub fn synthetic_fixtures() -> Vec<Box<dyn FlatLayoutFixture>> {
+    synthetic::fixtures()
+}
+
+/// All dataset fixtures.
+pub fn dataset_fixtures() -> Vec<Box<dyn DatasetFixture>> {
+    datasets::fixtures()
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/bool.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/bool.rs
new file mode 100644
index 00000000000..e710438a2ce
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/bool.rs
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Bool;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct BooleansFixture;
+
+impl FlatLayoutFixture for BooleansFixture {
+    fn name(&self) -> &str {
+        "booleans.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Boolean arrays with mixed true/false values including a nullable column"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Bool::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let bools = BoolArray::from_iter([true, false, true, true, false]);
+        let nullable_bools =
+            BoolArray::from_iter([Some(true), None, Some(false), None, Some(true)]);
+        let all_true = BoolArray::from_iter([true, true, true, true, true]);
+        let all_false = BoolArray::from_iter([false, false, false, false, false]);
+        let all_null: BoolArray = BoolArray::from_iter([None::<bool>, None, None, None, None]);
+        let arr = StructArray::try_new(
+            FieldNames::from(["flag", "nullable_flag", "all_true", "all_false", "all_null"]),
+            vec![
+                bools.into_array(),
+                nullable_bools.into_array(),
+                all_true.into_array(),
+                all_false.into_array(),
+                all_null.into_array(),
+            ],
+            5,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/chunked.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/chunked.rs
new file mode 100644
index 00000000000..683d5b809a3
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/chunked.rs
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ChunkedArray;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ChunkedFixture;
+
+impl FlatLayoutFixture for ChunkedFixture {
+    fn name(&self) -> &str {
+        "chunked.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "ChunkedArray with variable-size chunks containing nullable data"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Primitive::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // Variable chunk sizes: 500, 1000, 250
+        let chunk_sizes: [u32; 3] = [500, 1000, 250];
+        let mut offset = 0u32;
+
+        let chunks = chunk_sizes
+            .iter()
+            .map(|&size| {
+                let ids: PrimitiveArray = (offset..offset + size).collect();
+                let nullable_vals = PrimitiveArray::from_option_iter(
+                    (offset..offset + size)
+                        .map(|i| if i % 7 == 0 { None } else { Some(i as i64 * 3) }),
+                );
+                offset += size;
+                Ok(StructArray::try_new(
+                    FieldNames::from(["id", "nullable_val"]),
+                    vec![ids.into_array(), nullable_vals.into_array()],
+                    size as usize,
+                    Validity::NonNullable,
+                )?
+                .into_array())
+            })
+            .collect::<VortexResult<Vec<_>>>()?;
+
+        Ok(ChunkedArray::from_iter(chunks).into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/datetime.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/datetime.rs
new file mode 100644
index 00000000000..9571136ca38
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/datetime.rs
@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Extension;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::TemporalArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::extension::datetime::TimeUnit;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct DateTimeFixture;
+
+impl FlatLayoutFixture for DateTimeFixture {
+    fn name(&self) -> &str {
+        "datetime.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Temporal arrays covering timestamps, dates, and times with various units"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Extension::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // Timestamps in seconds (i64): 2024-01-01T00:00:00Z, 2024-06-15T12:30:00Z, 2024-12-31T23:59:59Z
+        let ts_seconds = TemporalArray::new_timestamp(
+            PrimitiveArray::new(
+                buffer![1704067200i64, 1718451000, 1735689599],
+                Validity::NonNullable,
+            )
+            .into_array(),
+            TimeUnit::Seconds,
+            None,
+        );
+
+        // Timestamps in milliseconds with timezone (i64)
+        let ts_millis_tz = TemporalArray::new_timestamp(
+            PrimitiveArray::new(
+                buffer![1704067200000i64, 1718451000000, 1735689599000],
+                Validity::NonNullable,
+            )
+            .into_array(),
+            TimeUnit::Milliseconds,
+            Some(Arc::from("UTC")),
+        );
+
+        // Nullable timestamps in microseconds (i64)
+        let ts_nullable = TemporalArray::new_timestamp(
+            PrimitiveArray::from_option_iter([
+                Some(1704067200000000i64),
+                None,
+                Some(1735689599000000i64),
+            ])
+            .into_array(),
+            TimeUnit::Microseconds,
+            None,
+        );
+
+        // Date in days since epoch (i32): 2024-01-01, 2024-06-15, 2024-12-31
+        let date_days = TemporalArray::new_date(
+            PrimitiveArray::new(buffer![19723i32, 19889, 19723 + 365], Validity::NonNullable)
+                .into_array(),
+            TimeUnit::Days,
+        );
+
+        // Time in seconds since midnight (i32): 00:00:00, 12:30:00, 23:59:59
+        let time_secs = TemporalArray::new_time(
+            PrimitiveArray::new(buffer![0i32, 45000, 86399], Validity::NonNullable).into_array(),
+            TimeUnit::Seconds,
+        );
+
+        // Timestamps in nanoseconds (i64)
+        let ts_nanos = TemporalArray::new_timestamp(
+            PrimitiveArray::new(
+                buffer![
+                    1704067200000000000i64,
+                    1718451000000000000,
+                    1735689599000000000
+                ],
+                Validity::NonNullable,
+            )
+            .into_array(),
+            TimeUnit::Nanoseconds,
+            None,
+        );
+
+        // Timestamps with non-UTC timezone
+        let ts_eastern = TemporalArray::new_timestamp(
+            PrimitiveArray::new(
+                buffer![1704067200i64, 1718451000, 1735689599],
+                Validity::NonNullable,
+            )
+            .into_array(),
+            TimeUnit::Seconds,
+            Some(Arc::from("America/New_York")),
+        );
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "ts_seconds",
+                "ts_millis_tz",
+                "ts_nullable_micros",
+                "date_days",
+                "time_seconds",
+                "ts_nanos",
+                "ts_eastern",
+            ]),
+            vec![
+                ts_seconds.into_array(),
+                ts_millis_tz.into_array(),
+                ts_nullable.into_array(),
+                date_days.into_array(),
+                time_secs.into_array(),
+                ts_nanos.into_array(),
+                ts_eastern.into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/decimal.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/decimal.rs
new file mode 100644
index 00000000000..d7e261cdbf4
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/decimal.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Decimal;
+use vortex_array::arrays::DecimalArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::DecimalDType;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct DecimalFixture;
+
+impl FlatLayoutFixture for DecimalFixture {
+    fn name(&self) -> &str {
+        "decimal.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Decimal arrays with varying precisions and scales, including nullable variants"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Decimal::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // Decimal(5,2) stored as i32: represents 123.45, -678.90, 0.01
+        let dec_5_2 = DecimalArray::new(
+            buffer![12345i32, -67890, 1],
+            DecimalDType::new(5, 2),
+            Validity::NonNullable,
+        );
+
+        // Decimal(10,4) stored as i64: represents 123456.7890, -0.0001, 999999.9999
+        let dec_10_4 = DecimalArray::new(
+            buffer![1234567890i64, -1, 9999999999],
+            DecimalDType::new(10, 4),
+            Validity::NonNullable,
+        );
+
+        // Decimal(18,0) stored as i64: large integers
+        let dec_18_0 = DecimalArray::new(
+            buffer![0i64, 999_999_999_999_999_999, -999_999_999_999_999_999],
+            DecimalDType::new(18, 0),
+            Validity::NonNullable,
+        );
+
+        // Nullable Decimal(7,3) stored as i32
+        let dec_nullable = DecimalArray::from_option_iter(
+            [Some(1234567i32), None, Some(-9999999)],
+            DecimalDType::new(7, 3),
+        );
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["dec_5_2", "dec_10_4", "dec_18_0", "dec_nullable_7_3"]),
+            vec![
+                dec_5_2.into_array(),
+                dec_10_4.into_array(),
+                dec_18_0.into_array(),
+                dec_nullable.into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/fixed_size_list.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/fixed_size_list.rs
new file mode 100644
index 00000000000..c1c2e615b76
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/fixed_size_list.rs
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::FixedSizeList;
+use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct FixedSizeListFixture;
+
+impl FlatLayoutFixture for FixedSizeListFixture {
+    fn name(&self) -> &str {
+        "fixed_size_list.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Fixed-size list arrays (e.g. 3-element vectors)"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![FixedSizeList::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // 4 vectors of 3 f64 each
+        let elements = PrimitiveArray::new(
+            buffer![
+                1.0f64, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0
+            ],
+            Validity::NonNullable,
+        );
+        let fsl = FixedSizeListArray::try_new(elements.into_array(), 3, Validity::NonNullable, 4)?;
+
+        // Nullable FSL: 4 vectors of 2 i32, second entry is null
+        let nullable_elements = PrimitiveArray::new(
+            buffer![10i32, 20, 0, 0, 50, 60, 70, 80],
+            Validity::NonNullable,
+        );
+        let nullable_fsl = FixedSizeListArray::try_new(
+            nullable_elements.into_array(),
+            2,
+            Validity::from_iter([true, false, true, true]),
+            4,
+        )?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["vectors", "nullable_vectors"]),
+            vec![fsl.into_array(), nullable_fsl.into_array()],
+            4,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/list.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/list.rs
new file mode 100644
index 00000000000..dd09e002630
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/list.rs
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::List;
+use vortex_array::arrays::ListArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ListFixture;
+
+impl FlatLayoutFixture for ListFixture {
+    fn name(&self) -> &str {
+        "list.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Variable-length list arrays with integer and string elements"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![List::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // List of i32: [[1,2,3], [4,5], [6], [7,8,9,10]]
+        let elements = PrimitiveArray::new(
+            buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            Validity::NonNullable,
+        );
+        let offsets = PrimitiveArray::new(buffer![0i64, 3, 5, 6, 10], Validity::NonNullable);
+        let int_list = ListArray::try_new(
+            elements.into_array(),
+            offsets.into_array(),
+            Validity::NonNullable,
+        )?;
+
+        // List of strings: [["a","b"], ["hello"], [], ["x","y","z"]]
+        let str_elements = VarBinArray::from_strs(vec!["a", "b", "hello", "x", "y", "z"]);
+        let str_offsets = PrimitiveArray::new(buffer![0i64, 2, 3, 3, 6], Validity::NonNullable);
+        let str_list = ListArray::try_new(
+            str_elements.into_array(),
+            str_offsets.into_array(),
+            Validity::NonNullable,
+        )?;
+
+        // Nullable list of i32: [[100,200], null, [], [300]]
+        let nullable_elements =
+            PrimitiveArray::new(buffer![100i32, 200, 300], Validity::NonNullable);
+        let nullable_offsets =
+            PrimitiveArray::new(buffer![0i64, 2, 2, 2, 3], Validity::NonNullable);
+        let nullable_int_list = ListArray::try_new(
+            nullable_elements.into_array(),
+            nullable_offsets.into_array(),
+            Validity::from_iter([true, false, true, true]),
+        )?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["int_list", "str_list", "nullable_int_list"]),
+            vec![
+                int_list.into_array(),
+                str_list.into_array(),
+                nullable_int_list.into_array(),
+            ],
+            4,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/listview.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/listview.rs
new file mode 100644
index 00000000000..0a9ab2191ef
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/listview.rs
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ListView;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ListViewFixture;
+
+impl FlatLayoutFixture for ListViewFixture {
+    fn name(&self) -> &str {
+        "listview.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "ListView arrays with integer and string elements"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![ListView::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        // ListView of i32: [[1,2,3], [4,5], [6], [7,8,9,10]]
+        let int_elements = PrimitiveArray::new(
+            buffer![1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            Validity::NonNullable,
+        );
+        let int_offsets = PrimitiveArray::new(buffer![0u32, 3, 5, 6], Validity::NonNullable);
+        let int_sizes = PrimitiveArray::new(buffer![3u32, 2, 1, 4], Validity::NonNullable);
+        let int_listview = ListViewArray::try_new(
+            int_elements.into_array(),
+            int_offsets.into_array(),
+            int_sizes.into_array(),
+            Validity::NonNullable,
+        )?;
+
+        // ListView of strings: [["a","b"], ["hello"], [], ["x","y","z"]]
+        let str_elements = VarBinArray::from_strs(vec!["a", "b", "hello", "x", "y", "z"]);
+        let str_offsets = PrimitiveArray::new(buffer![0u32, 2, 3, 3], Validity::NonNullable);
+        let str_sizes = PrimitiveArray::new(buffer![2u32, 1, 0, 3], Validity::NonNullable);
+        let str_listview = ListViewArray::try_new(
+            str_elements.into_array(),
+            str_offsets.into_array(),
+            str_sizes.into_array(),
+            Validity::NonNullable,
+        )?;
+
+        // Nullable ListView of i32: [[10,20], null, [30], [40,50,60]]
+        let nullable_elements =
+            PrimitiveArray::new(buffer![10i32, 20, 30, 40, 50, 60], Validity::NonNullable);
+        let nullable_offsets = PrimitiveArray::new(buffer![0u32, 2, 2, 3], Validity::NonNullable);
+        let nullable_sizes = PrimitiveArray::new(buffer![2u32, 0, 1, 3], Validity::NonNullable);
+        let nullable_listview = ListViewArray::try_new(
+            nullable_elements.into_array(),
+            nullable_offsets.into_array(),
+            nullable_sizes.into_array(),
+            Validity::from_iter([true, false, true, true]),
+        )?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["int_listview", "str_listview", "nullable_int_listview"]),
+            vec![
+                int_listview.into_array(),
+                str_listview.into_array(),
+                nullable_listview.into_array(),
+            ],
+            4,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/mod.rs
new file mode 100644
index 00000000000..f76803f5764
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/mod.rs
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Per-array-type synthetic fixtures.
+//!
+//! Each fixture exercises a core Vortex array type with boundary values and nullable variants.
+
+mod bool;
+mod chunked;
+mod datetime;
+mod decimal;
+mod fixed_size_list;
+mod list;
+mod listview;
+mod null;
+mod primitive;
+mod struct_nested;
+mod varbin;
+mod varbinview;
+
+use crate::fixtures::FlatLayoutFixture;
+
+/// All per-array-type fixtures.
+pub fn fixtures() -> Vec<Box<dyn FlatLayoutFixture>> {
+    vec![
+        Box::new(primitive::PrimitivesFixture),
+        Box::new(varbin::VarBinFixture),
+        Box::new(varbinview::VarBinViewFixture),
+        Box::new(bool::BooleansFixture),
+        Box::new(struct_nested::StructNestedFixture),
+        Box::new(chunked::ChunkedFixture),
+        Box::new(list::ListFixture),
+        Box::new(fixed_size_list::FixedSizeListFixture),
+        Box::new(null::NullFixture),
+        Box::new(datetime::DateTimeFixture),
+        Box::new(decimal::DecimalFixture),
+        Box::new(listview::ListViewFixture),
+    ]
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/null.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/null.rs
new file mode 100644
index 00000000000..0d937a1c225
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/null.rs
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Null;
+use vortex_array::arrays::NullArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct NullFixture;
+
+impl FlatLayoutFixture for NullFixture {
+    fn name(&self) -> &str {
+        "null.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "All-null column using NullArray alongside an integer column"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Null::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let null_col = NullArray::new(10);
+        let int_col = PrimitiveArray::new(
+            buffer![0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            Validity::NonNullable,
+        );
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["nulls", "ids"]),
+            vec![null_col.into_array(), int_col.into_array()],
+            10,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/primitive.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/primitive.rs
new file mode 100644
index 00000000000..f77d5f42f39
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/primitive.rs
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Primitive;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct PrimitivesFixture;
+
+impl FlatLayoutFixture for PrimitivesFixture {
+    fn name(&self) -> &str {
+        "primitives.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "All primitive types (u8-u64, i32, i64, f32, f64) including a nullable i32 column"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Primitive::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "u8",
+                "u16",
+                "u32",
+                "u64",
+                "i32",
+                "i64",
+                "f32",
+                "f64",
+                "nullable_i32",
+                "f32_special",
+                "f64_special",
+            ]),
+            vec![
+                PrimitiveArray::new(buffer![0u8, 128, 255], Validity::NonNullable).into_array(),
+                PrimitiveArray::new(buffer![0u16, 32768, 65535], Validity::NonNullable)
+                    .into_array(),
+                PrimitiveArray::new(
+                    buffer![0u32, 2_147_483_648, 4_294_967_295],
+                    Validity::NonNullable,
+                )
+                .into_array(),
+                PrimitiveArray::new(
+                    buffer![0u64, 9_223_372_036_854_775_808, u64::MAX],
+                    Validity::NonNullable,
+                )
+                .into_array(),
+                PrimitiveArray::new(buffer![i32::MIN, 0i32, i32::MAX], Validity::NonNullable)
+                    .into_array(),
+                PrimitiveArray::new(buffer![i64::MIN, 0i64, i64::MAX], Validity::NonNullable)
+                    .into_array(),
+                PrimitiveArray::new(buffer![f32::MIN, 0.0f32, f32::MAX], Validity::NonNullable)
+                    .into_array(),
+                PrimitiveArray::new(buffer![f64::MIN, 0.0f64, f64::MAX], Validity::NonNullable)
+                    .into_array(),
+                PrimitiveArray::from_option_iter([Some(1i32), None, Some(42)]).into_array(),
+                // Special float values: NaN, infinities, negative zero, subnormal
+                PrimitiveArray::new(
+                    buffer![f32::NAN, f32::INFINITY, f32::NEG_INFINITY],
+                    Validity::NonNullable,
+                )
+                .into_array(),
+                PrimitiveArray::new(
+                    buffer![f64::NAN, -0.0f64, f64::MIN_POSITIVE / 2.0],
+                    Validity::NonNullable,
+                )
+                .into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/struct_nested.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/struct_nested.rs
new file mode 100644
index 00000000000..cc02d856aab
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/struct_nested.rs
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::Struct;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct StructNestedFixture;
+
+impl FlatLayoutFixture for StructNestedFixture {
+    fn name(&self) -> &str {
+        "struct_nested.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Nested struct: outer struct containing an inner struct with primitive and string fields"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Struct::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let inner = StructArray::try_new(
+            FieldNames::from(["a", "b"]),
+            vec![
+                PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array(),
+                VarBinArray::from_strs(vec!["x", "y", "z"]).into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?;
+
+        // Nullable inner struct: second row is null at the struct level.
+        let nullable_inner = StructArray::try_new(
+            FieldNames::from(["c", "d"]),
+            vec![
+                PrimitiveArray::new(buffer![100i64, 0, 300], Validity::NonNullable).into_array(),
+                PrimitiveArray::new(buffer![1.0f32, 0.0, 3.0], Validity::NonNullable).into_array(),
+            ],
+            3,
+            Validity::from_iter([true, false, true]),
+        )?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from(["inner", "nullable_inner", "value"]),
+            vec![
+                inner.into_array(),
+                nullable_inner.into_array(),
+                PrimitiveArray::new(buffer![1.1f64, 2.2, 3.3], Validity::NonNullable).into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbin.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbin.rs
new file mode 100644
index 00000000000..72ac683ee44
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbin.rs
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBin;
+use vortex_array::arrays::VarBinArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct VarBinFixture;
+
+impl FlatLayoutFixture for VarBinFixture {
+    fn name(&self) -> &str {
+        "varbin.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "VarBin-encoded strings including empty, unicode, emoji, and a nullable column"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![VarBin::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let strings = VarBinArray::from_strs(vec!["", "hello", "こんにちは", "\u{1f980}"]);
+        let nullable_strings =
+            VarBinArray::from_nullable_strs(vec![Some("hello"), None, Some("world"), Some("")]);
+        let arr = StructArray::try_new(
+            FieldNames::from(["text", "nullable_text"]),
+            vec![strings.into_array(), nullable_strings.into_array()],
+            4,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbinview.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbinview.rs
new file mode 100644
index 00000000000..f795dafce49
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/arrays/varbinview.rs
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinView;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::dtype::FieldNames;
+use vortex_array::validity::Validity;
+use vortex_error::VortexResult;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct VarBinViewFixture;
+
+impl FlatLayoutFixture for VarBinViewFixture {
+    fn name(&self) -> &str {
+        "varbinview.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "VarBinView-encoded strings including empty, unicode, emoji, long (>12 byte) strings, and a nullable column"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![VarBinView::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let strings = VarBinViewArray::from_iter_bin(vec!["", "hello", "こんにちは", "\u{1f980}"]);
+        let nullable_strings = VarBinViewArray::from_iter_nullable_str(vec![
+            Some("hello"),
+            None,
+            Some("world"),
+            Some(""),
+        ]);
+        // Strings >12 bytes exercise VarBinView's buffer-reference mechanism (out-of-line storage).
+        let long_strings = VarBinViewArray::from_iter_str(vec![
+            "short",
+            "this string is definitely longer than twelve bytes",
+            "another-long-string-that-exceeds-inline-limit",
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789",
+        ]);
+        let arr = StructArray::try_new(
+            FieldNames::from(["text", "nullable_text", "long_text"]),
+            vec![
+                strings.into_array(),
+                nullable_strings.into_array(),
+                long_strings.into_array(),
+            ],
+            4,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alp.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alp.rs
new file mode 100644
index 00000000000..cf20093cf21
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alp.rs
@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::alp_encode;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct AlpFixture;
+
+fn special_f64(i: usize) -> f64 {
+    match i % 9 {
+        0 => 0.0,
+        1 => -0.0,
+        2 => f64::from_bits(0x7ff8_0000_0000_0001),
+        3 => f64::from_bits(0x7ff8_0000_0000_1234),
+        4 => f64::from_bits(0xfff8_0000_0000_5678),
+        5 => f64::INFINITY,
+        6 => f64::NEG_INFINITY,
+        7 => f64::MIN_POSITIVE,
+        _ => -f64::from_bits(1),
+    }
+}
+
+fn special_f32(i: usize) -> f32 {
+    match i % 9 {
+        0 => 0.0,
+        1 => -0.0,
+        2 => f32::from_bits(0x7fc0_0001),
+        3 => f32::from_bits(0x7fc0_1234),
+        4 => f32::from_bits(0xffc0_5678),
+        5 => f32::INFINITY,
+        6 => f32::NEG_INFINITY,
+        7 => f32::MIN_POSITIVE,
+        _ => -f32::from_bits(1),
+    }
+}
+
+impl FlatLayoutFixture for AlpFixture {
+    fn name(&self) -> &str {
+        "alp.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Near-integer floats and decimal-like prices for ALP encoding (f32 + f64)"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![ALP::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let f64_prices: PrimitiveArray = (0..N).map(|i| 100.0 + (i as f64) * 0.25).collect();
+        let f32_near_int: PrimitiveArray = (0..N).map(|i| i as f32).collect();
+        let f64_negative_near_int: PrimitiveArray = (0..N)
+            .map(|i| -(i as f64) - ((i % 7) as f64) * 0.000_1)
+            .collect();
+        let f64_currency: PrimitiveArray = (0..N).map(|i| ((i % 10000) as f64) / 100.0).collect();
+        let f64_nullable = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i % 10 != 0).then_some(50.0 + (i as f64) * 0.125)),
+        );
+        let f64_patched: PrimitiveArray = (0..N)
+            .map(|i| {
+                if i % 100 == 0 {
+                    std::f64::consts::PI * (i as f64 + 1.0)
+                } else {
+                    (i as f64) * 0.01
+                }
+            })
+            .collect();
+        let f64_patch_heavy: PrimitiveArray = (0..N)
+            .map(|i| {
+                if i % 7 == 0 || i % 11 == 0 {
+                    10_000.0 + (i as f64).powi(2)
+                } else {
+                    250.0 + ((i % 37) as f64) * 0.01
+                }
+            })
+            .collect();
+        let f64_special_values: PrimitiveArray = (0..N).map(special_f64).collect();
+        let f32_special_values: PrimitiveArray = (0..N).map(special_f32).collect();
+        let f64_extremes: PrimitiveArray = (0..N)
+            .map(|i| match i % 10 {
+                0 => f64::MAX,
+                1 => f64::MIN,
+                2 => f64::EPSILON,
+                3 => -f64::EPSILON,
+                4 => f64::MIN_POSITIVE,
+                5 => -f64::MIN_POSITIVE,
+                6 => std::f64::consts::PI,
+                7 => -std::f64::consts::E,
+                8 => f64::from_bits(1),
+                _ => -f64::from_bits(2),
+            })
+            .collect();
+        let f64_boundary_specials: PrimitiveArray = (0..N)
+            .map(|i| match i {
+                0 => f64::from_bits(0x7ff8_0000_0000_0001),
+                1 => -0.0,
+                511 => f64::INFINITY,
+                512 => f64::NEG_INFINITY,
+                513 => f64::from_bits(0xfff8_0000_0000_5678),
+                1023 => f64::from_bits(1),
+                _ => 12.5 + (i as f64) * 0.000_001,
+            })
+            .collect();
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "f64_prices",
+                "f32_near_int",
+                "f64_negative_near_int",
+                "f64_currency",
+                "f64_nullable",
+                "f64_patched",
+                "f64_patch_heavy",
+                "f64_special_values",
+                "f32_special_values",
+                "f64_extremes",
+                "f64_boundary_specials",
+            ]),
+            vec![
+                alp_encode(&f64_prices, None)?.into_array(),
+                alp_encode(&f32_near_int, None)?.into_array(),
+                alp_encode(&f64_negative_near_int, None)?.into_array(),
+                alp_encode(&f64_currency, None)?.into_array(),
+                alp_encode(&f64_nullable, None)?.into_array(),
+                alp_encode(&f64_patched, None)?.into_array(),
+                alp_encode(&f64_patch_heavy, None)?.into_array(),
+                alp_encode(&f64_special_values, None)?.into_array(),
+                alp_encode(&f32_special_values, None)?.into_array(),
+                alp_encode(&f64_extremes, None)?.into_array(),
+                alp_encode(&f64_boundary_specials, None)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alprd.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alprd.rs
new file mode 100644
index 00000000000..a6ca54363b6
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/alprd.rs
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::alp::ALPRD;
+use vortex::encodings::alp::RDEncoder;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct AlprdFixture;
+
+fn special_f64(i: usize) -> f64 {
+    match i % 9 {
+        0 => 0.0,
+        1 => -0.0,
+        2 => f64::from_bits(0x7ff8_0000_0000_0001),
+        3 => f64::from_bits(0x7ff8_0000_0000_1234),
+        4 => f64::from_bits(0xfff8_0000_0000_5678),
+        5 => f64::INFINITY,
+        6 => f64::NEG_INFINITY,
+        7 => f64::MIN_POSITIVE,
+        _ => -f64::from_bits(1),
+    }
+}
+
+impl FlatLayoutFixture for AlprdFixture {
+    fn name(&self) -> &str {
+        "alprd.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Real-valued doubles with small deltas for ALPRD encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![ALPRD::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let sensor: PrimitiveArray = (0..N)
+            .map(|i| {
+                let noise = ((i * 7 + 13) % 100) as f64 / 1000.0;
+                98.6 + noise
+            })
+            .collect();
+
+        let drift: PrimitiveArray = (0..N)
+            .map(|i| 1000.0 + (i as f64) * 0.001 + ((i * 3) % 7) as f64 * 0.0001)
+            .collect();
+        let constant_series: PrimitiveArray = std::iter::repeat_n(12.125f64, N).collect();
+        let decreasing: PrimitiveArray = (0..N)
+            .map(|i| 512.0 - (i as f64) * 0.000_5 - ((i * 5 % 13) as f64) * 0.000_01)
+            .collect();
+        let oscillating: PrimitiveArray = (0..N)
+            .map(|i| {
+                let phase = ((i % 9) as i32 - 4) as f64;
+                -0.25 + phase * 0.000_1 + (i as f64) * 0.000_001
+            })
+            .collect();
+        let periodic_resets: PrimitiveArray = (0..N)
+            .map(|i| {
+                let block = i / 64;
+                let offset = i % 64;
+                block as f64 * 10.0 + (offset as f64) * 0.000_2
+            })
+            .collect();
+
+        let sensor_nullable_vals: Vec<f64> = (0..N)
+            .map(|i| {
+                let noise = ((i * 11 + 3) % 100) as f64 / 1000.0;
+                37.0 + noise
+            })
+            .collect();
+        let sensor_nullable = PrimitiveArray::from_option_iter((0..N).map(|i| {
+            if i % 13 == 0 {
+                None
+            } else {
+                let noise = ((i * 11 + 3) % 100) as f64 / 1000.0;
+                Some(37.0 + noise)
+            }
+        }));
+        let special_values: PrimitiveArray = (0..N)
+            .map(|i| {
+                if i % 16 == 0 {
+                    special_f64(i)
+                } else {
+                    42.125 + ((i * 5 % 17) as f64) * 0.000_01
+                }
+            })
+            .collect();
+        let boundary_specials: PrimitiveArray = (0..N)
+            .map(|i| match i {
+                0 => f64::from_bits(0x7ff8_0000_0000_0001),
+                1 => -0.0,
+                511 => f64::INFINITY,
+                512 => f64::NEG_INFINITY,
+                513 => f64::from_bits(0xfff8_0000_0000_5678),
+                1023 => f64::from_bits(1),
+                _ => 9.875 + ((i * 3 % 11) as f64) * 0.000_1,
+            })
+            .collect();
+        let nullable_special_vals: Vec<f64> = (0..N)
+            .map(|i| {
+                if i % 32 == 7 {
+                    special_f64(i)
+                } else {
+                    11.5 + ((i * 13 % 19) as f64) * 0.000_01
+                }
+            })
+            .collect();
+        let nullable_specials = PrimitiveArray::from_option_iter((0..N).map(|i| {
+            if i % 29 == 0 || i == 0 || i == N - 1 {
+                None
+            } else {
+                Some(nullable_special_vals[i])
+            }
+        }));
+
+        let sensor_enc = RDEncoder::new::<f64>(sensor.as_slice::<f64>());
+        let drift_enc = RDEncoder::new::<f64>(drift.as_slice::<f64>());
+        let constant_enc = RDEncoder::new::<f64>(constant_series.as_slice::<f64>());
+        let decreasing_enc = RDEncoder::new::<f64>(decreasing.as_slice::<f64>());
+        let oscillating_enc = RDEncoder::new::<f64>(oscillating.as_slice::<f64>());
+        let periodic_resets_enc = RDEncoder::new::<f64>(periodic_resets.as_slice::<f64>());
+        let nullable_enc = RDEncoder::new::<f64>(&sensor_nullable_vals);
+        let special_enc = RDEncoder::new::<f64>(special_values.as_slice::<f64>());
+        let boundary_enc = RDEncoder::new::<f64>(boundary_specials.as_slice::<f64>());
+        let nullable_special_enc = RDEncoder::new::<f64>(&nullable_special_vals);
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "sensor",
+                "drift",
+                "constant_series",
+                "decreasing",
+                "oscillating",
+                "periodic_resets",
+                "sensor_nullable",
+                "special_values",
+                "boundary_specials",
+                "nullable_specials",
+            ]),
+            vec![
+                sensor_enc.encode(&sensor).into_array(),
+                drift_enc.encode(&drift).into_array(),
+                constant_enc.encode(&constant_series).into_array(),
+                decreasing_enc.encode(&decreasing).into_array(),
+                oscillating_enc.encode(&oscillating).into_array(),
+                periodic_resets_enc.encode(&periodic_resets).into_array(),
+                nullable_enc.encode(&sensor_nullable).into_array(),
+                special_enc.encode(&special_values).into_array(),
+                boundary_enc.encode(&boundary_specials).into_array(),
+                nullable_special_enc.encode(&nullable_specials).into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bitpacked.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bitpacked.rs
new file mode 100644
index 00000000000..c0dc53817b3
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bitpacked.rs
@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::bitpack_compress::bitpack_encode;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct BitPackedFixture;
+
+impl FlatLayoutFixture for BitPackedFixture {
+    fn name(&self) -> &str {
+        "bitpacked.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Small unsigned integers that fit in fewer bits than their type width"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![BitPacked::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let u32_8bit: PrimitiveArray = (0..N as u32).map(|i| i % 256).collect();
+        let u64_12bit: PrimitiveArray = (0..N as u64).map(|i| i % 4096).collect();
+        let u16_4bit: PrimitiveArray = (0..N as u16).map(|i| i % 16).collect();
+        let u16_1bit: PrimitiveArray = (0..N as u16).map(|i| i % 2).collect();
+        let u32_nullable = PrimitiveArray::from_option_iter(
+            (0..N as u32).map(|i| (i % 8 != 0).then_some(i % 128)),
+        );
+        let u32_all_zero: PrimitiveArray = std::iter::repeat_n(0u32, N).collect();
+        let u16_all_equal: PrimitiveArray = std::iter::repeat_n(7u16, N).collect();
+        let u16_15bit: PrimitiveArray =
+            (0..N as u16).map(|i| i.wrapping_mul(97) & 0x7fff).collect();
+        let u32_31bit: PrimitiveArray = (0..N as u32)
+            .map(|i| i.wrapping_mul(65_537) & 0x7fff_ffff)
+            .collect();
+        let u64_63bit: PrimitiveArray = (0..N as u64)
+            .map(|i| i.wrapping_mul(1_099_511_627_791) & 0x7fff_ffff_ffff_ffff)
+            .collect();
+        let u8_3bit: PrimitiveArray = (0..N).map(|i| (i % 8) as u8).collect();
+        let u8_5bit: PrimitiveArray = (0..N).map(|i| (i % 32) as u8).collect();
+        let u16_9bit: PrimitiveArray = (0..N as u16).map(|i| i % 512).collect();
+        let u32_17bit: PrimitiveArray = (0..N as u32).map(|i| i % 131_072).collect();
+        let u16_head_tail_nulls = PrimitiveArray::from_option_iter((0..N as u16).map(|i| {
+            if i < 8 || i >= N as u16 - 8 {
+                None
+            } else {
+                Some(i % 32)
+            }
+        }));
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "u32_8bit",
+                "u64_12bit",
+                "u16_4bit",
+                "u16_1bit",
+                "u32_nullable",
+                "u32_all_zero",
+                "u16_all_equal",
+                "u16_15bit",
+                "u32_31bit",
+                "u64_63bit",
+                "u8_3bit",
+                "u8_5bit",
+                "u16_9bit",
+                "u32_17bit",
+                "u16_head_tail_nulls",
+            ]),
+            vec![
+                bitpack_encode(&u32_8bit, 8, None)?.into_array(),
+                bitpack_encode(&u64_12bit, 12, None)?.into_array(),
+                bitpack_encode(&u16_4bit, 4, None)?.into_array(),
+                bitpack_encode(&u16_1bit, 1, None)?.into_array(),
+                bitpack_encode(&u32_nullable, 7, None)?.into_array(),
+                bitpack_encode(&u32_all_zero, 1, None)?.into_array(),
+                bitpack_encode(&u16_all_equal, 3, None)?.into_array(),
+                bitpack_encode(&u16_15bit, 15, None)?.into_array(),
+                bitpack_encode(&u32_31bit, 31, None)?.into_array(),
+                bitpack_encode(&u64_63bit, 63, None)?.into_array(),
+                bitpack_encode(&u8_3bit, 3, None)?.into_array(),
+                bitpack_encode(&u8_5bit, 5, None)?.into_array(),
+                bitpack_encode(&u16_9bit, 9, None)?.into_array(),
+                bitpack_encode(&u32_17bit, 17, None)?.into_array(),
+                bitpack_encode(&u16_head_tail_nulls, 5, None)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bytebool.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bytebool.rs
new file mode 100644
index 00000000000..53cf79463d6
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/bytebool.rs
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::BoolArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::bool::BoolArrayExt;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::bytebool::ByteBool;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ByteBoolFixture;
+
+impl FlatLayoutFixture for ByteBoolFixture {
+    fn name(&self) -> &str {
+        "bytebool.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Boolean arrays for ByteBool encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![ByteBool::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let alternating: Vec<bool> = (0..N).map(|i| i % 2 == 0).collect();
+        let mostly_true: Vec<bool> = (0..N).map(|i| i % 100 != 0).collect();
+        let mixed: Vec<bool> = (0..N).map(|i| (i * 7 + 3) % 5 > 1).collect();
+        let nullable_vals: Vec<bool> = (0..N).map(|i| i % 3 == 0).collect();
+        let nullable_validity =
+            Validity::from(BoolArray::from_iter((0..N).map(|i| i % 5 != 0)).to_bit_buffer());
+        let all_false: Vec<bool> = vec![false; N];
+        let all_true: Vec<bool> = vec![true; N];
+        let all_null_vals: Vec<bool> = vec![false; N];
+        let single_flip: Vec<bool> = (0..N).map(|i| i != N / 2).collect();
+        let sparse_true: Vec<bool> = (0..N).map(|i| i % 127 == 0).collect();
+        let edge_null_vals: Vec<bool> = (0..N).map(|i| i % 4 == 0).collect();
+        let edge_null_validity = Validity::from(
+            BoolArray::from_iter((0..N).map(|i| (8..N - 8).contains(&i))).to_bit_buffer(),
+        );
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "alternating",
+                "mostly_true",
+                "mixed",
+                "nullable_bool",
+                "all_false",
+                "all_true",
+                "all_null",
+                "single_flip",
+                "sparse_true",
+                "edge_nulls",
+            ]),
+            vec![
+                ByteBool::from_vec(alternating, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(mostly_true, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(mixed, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(nullable_vals, nullable_validity).into_array(),
+                ByteBool::from_vec(all_false, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(all_true, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(all_null_vals, Validity::AllInvalid).into_array(),
+                ByteBool::from_vec(single_flip, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(sparse_true, Validity::NonNullable).into_array(),
+                ByteBool::from_vec(edge_null_vals, edge_null_validity).into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/constant.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/constant.rs
new file mode 100644
index 00000000000..64feb357093
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/constant.rs
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::Constant;
+use vortex::array::arrays::ConstantArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::TemporalArray;
+use vortex::array::dtype::DType;
+use vortex::array::dtype::DecimalDType;
+use vortex::array::dtype::FieldNames;
+use vortex::array::dtype::Nullability;
+use vortex::array::extension::datetime::TimeUnit;
+use vortex::array::scalar::DecimalValue;
+use vortex::array::scalar::Scalar;
+use vortex::array::validity::Validity;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ConstantFixture;
+
+impl FlatLayoutFixture for ConstantFixture {
+    fn name(&self) -> &str {
+        "constant.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Constant-value columns (int, float, string, bool, null) for Constant encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Constant::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let const_i32 = ConstantArray::new(42i32, N);
+        let const_f64 = ConstantArray::new(99.99f64, N);
+        let const_bool = ConstantArray::new(true, N);
+        let const_str = ConstantArray::new("constant_value", N);
+        let const_zero = ConstantArray::new(0u64, N);
+        let const_neg = ConstantArray::new(-1i64, N);
+        let const_null = ConstantArray::new(Scalar::null(DType::Null), N);
+        let const_nullable_i32 =
+            ConstantArray::new(Scalar::primitive(42i32, Nullability::Nullable), N);
+        let const_long_utf8 = ConstantArray::new(
+            Scalar::utf8(
+                "constant-value-with-a-longer-inline-boundary-crossing-payload".to_string(),
+                Nullability::NonNullable,
+            ),
+            N,
+        );
+        let const_binary = ConstantArray::new(
+            Scalar::binary(
+                vec![0u8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
+                Nullability::NonNullable,
+            ),
+            N,
+        );
+        let const_decimal = ConstantArray::new(
+            Scalar::decimal(
+                DecimalValue::I64(123_456),
+                DecimalDType::new(10, 2),
+                Nullability::NonNullable,
+            ),
+            N,
+        );
+        let timestamp_scalar = TemporalArray::new_timestamp(
+            PrimitiveArray::from_iter([1_704_067_200_000i64]).into_array(),
+            TimeUnit::Milliseconds,
+            Some("UTC".into()),
+        )
+        .into_array()
+        .scalar_at(0)?;
+        let const_timestamp = ConstantArray::new(timestamp_scalar, N);
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "const_i32",
+                "const_f64",
+                "const_bool",
+                "const_str",
+                "const_zero",
+                "const_neg",
+                "const_null",
+                "const_nullable_i32",
+                "const_long_utf8",
+                "const_binary",
+                "const_decimal",
+                "const_timestamp",
+            ]),
+            vec![
+                const_i32.into_array(),
+                const_f64.into_array(),
+                const_bool.into_array(),
+                const_str.into_array(),
+                const_zero.into_array(),
+                const_neg.into_array(),
+                const_null.into_array(),
+                const_nullable_i32.into_array(),
+                const_long_utf8.into_array(),
+                const_binary.into_array(),
+                const_decimal.into_array(),
+                const_timestamp.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/datetimeparts.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/datetimeparts.rs
new file mode 100644
index 00000000000..bfbf2cba21c
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/datetimeparts.rs
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::TemporalArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::extension::datetime::TimeUnit;
+use vortex::array::validity::Validity;
+use vortex::encodings::datetime_parts::DateTimeParts;
+use vortex::encodings::datetime_parts::split_temporal;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct DateTimePartsFixture;
+
+fn encode_temporal(temporal: TemporalArray) -> VortexResult<ArrayRef> {
+    let dtype = temporal.dtype().clone();
+    let parts = split_temporal(temporal)?;
+    Ok(DateTimeParts::try_new(dtype, parts.days, parts.seconds, parts.subseconds)?.into_array())
+}
+
+impl FlatLayoutFixture for DateTimePartsFixture {
+    fn name(&self) -> &str {
+        "datetimeparts.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Timestamp arrays for DateTimeParts encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![DateTimeParts::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let base_us: i64 = 1_704_067_200_000_000;
+        let ts_us: PrimitiveArray = (0..N as i64).map(|i| base_us + i * 3_600_000_000).collect();
+        let ts_us_arr =
+            TemporalArray::new_timestamp(ts_us.into_array(), TimeUnit::Microseconds, None);
+
+        let base_ns: i64 = 1_704_067_200_000_000_000;
+        let ts_ns: PrimitiveArray = (0..N as i64).map(|i| base_ns + i * 1_000_000_000).collect();
+        let ts_ns_arr =
+            TemporalArray::new_timestamp(ts_ns.into_array(), TimeUnit::Nanoseconds, None);
+
+        let base_ms: i64 = 1_704_067_200_000;
+        let ts_ms: PrimitiveArray = (0..N as i64).map(|i| base_ms + i * 1000).collect();
+        let ts_ms_arr =
+            TemporalArray::new_timestamp(ts_ms.into_array(), TimeUnit::Milliseconds, None);
+
+        let ts_us_nullable = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i % 10 != 0).then(|| base_us + i * 60_000_000)),
+        );
+        let ts_us_nullable_arr =
+            TemporalArray::new_timestamp(ts_us_nullable.into_array(), TimeUnit::Microseconds, None);
+
+        let base_s: i64 = 1_704_067_200;
+        let ts_s: PrimitiveArray = (0..N as i64).map(|i| base_s + i * 86400).collect();
+        let ts_s_arr = TemporalArray::new_timestamp(ts_s.into_array(), TimeUnit::Seconds, None);
+        let ts_ms_tz: PrimitiveArray = (0..N as i64).map(|i| base_ms + i * 60_000).collect();
+        let ts_ms_tz_arr = TemporalArray::new_timestamp(
+            ts_ms_tz.into_array(),
+            TimeUnit::Milliseconds,
+            Some("UTC".into()),
+        );
+        let ts_pre_1970: PrimitiveArray = (0..N as i64).map(|i| -86_400_000 + i * 1000).collect();
+        let ts_pre_1970_arr =
+            TemporalArray::new_timestamp(ts_pre_1970.into_array(), TimeUnit::Milliseconds, None);
+        let ts_day_boundary: PrimitiveArray = (0..N as i64)
+            .map(|i| base_ms + (i / 4) * 86_400_000 + [0, 999, 1000, 86_399_999][(i % 4) as usize])
+            .collect();
+        let ts_day_boundary_arr = TemporalArray::new_timestamp(
+            ts_day_boundary.into_array(),
+            TimeUnit::Milliseconds,
+            None,
+        );
+        let ts_ns_subsecond: PrimitiveArray = (0..N as i64)
+            .map(|i| {
+                base_ns + (i / 4) * 1_000_000_000 + [0, 1, 999_999, 999_999_999][(i % 4) as usize]
+            })
+            .collect();
+        let ts_ns_subsecond_arr =
+            TemporalArray::new_timestamp(ts_ns_subsecond.into_array(), TimeUnit::Nanoseconds, None);
+        let ts_head_tail_null = PrimitiveArray::from_option_iter((0..N as i64).map(|i| {
+            if i < 8 || i >= N as i64 - 8 {
+                None
+            } else {
+                Some(base_ms + i * 1000)
+            }
+        }));
+        let ts_head_tail_null_arr = TemporalArray::new_timestamp(
+            ts_head_tail_null.into_array(),
+            TimeUnit::Milliseconds,
+            None,
+        );
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "ts_us",
+                "ts_ns",
+                "ts_ms",
+                "ts_us_nullable",
+                "ts_s",
+                "ts_ms_tz",
+                "ts_pre_1970",
+                "ts_day_boundary",
+                "ts_ns_subsecond",
+                "ts_head_tail_null",
+            ]),
+            vec![
+                encode_temporal(ts_us_arr)?,
+                encode_temporal(ts_ns_arr)?,
+                encode_temporal(ts_ms_arr)?,
+                encode_temporal(ts_us_nullable_arr)?,
+                encode_temporal(ts_s_arr)?,
+                encode_temporal(ts_ms_tz_arr)?,
+                encode_temporal(ts_pre_1970_arr)?,
+                encode_temporal(ts_day_boundary_arr)?,
+                encode_temporal(ts_ns_subsecond_arr)?,
+                encode_temporal(ts_head_tail_null_arr)?,
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/decimal_byte_parts.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/decimal_byte_parts.rs
new file mode 100644
index 00000000000..723df6c5378
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/decimal_byte_parts.rs
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::DecimalDType;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::decimal_byte_parts::DecimalByteParts;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct DecimalBytePartsFixture;
+
+impl FlatLayoutFixture for DecimalBytePartsFixture {
+    fn name(&self) -> &str {
+        "decimal_byte_parts.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Fixed-precision decimal arrays for DecimalByteParts encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![DecimalByteParts::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let decimal_dtype = DecimalDType::new(10, 2);
+        let values: PrimitiveArray = (0..N as i64).map(|i| i * 100 + (i % 100)).collect();
+        let msp_arr = values.into_array();
+        let decimal_arr = DecimalByteParts::try_new(msp_arr, decimal_dtype)?;
+
+        let hi_prec_dtype = DecimalDType::new(18, 6);
+        let hi_prec_values: PrimitiveArray = (0..N as i64)
+            .map(|i| i * 1_000_000 + (i * 7 % 999_999))
+            .collect();
+        let hi_prec_msp = hi_prec_values.into_array();
+        let hi_prec_arr = DecimalByteParts::try_new(hi_prec_msp, hi_prec_dtype)?;
+
+        let neg_dtype = DecimalDType::new(10, 2);
+        let neg_values: PrimitiveArray = (0..N as i64).map(|i| -5000 + (i * 3 % 10000)).collect();
+        let neg_msp = neg_values.into_array();
+        let neg_arr = DecimalByteParts::try_new(neg_msp, neg_dtype)?;
+        let nullable_dtype = DecimalDType::new(12, 4);
+        let nullable_values = PrimitiveArray::from_option_iter((0..N as i64).map(|i| {
+            if i % 11 == 0 {
+                None
+            } else {
+                Some((i - 500) * 10_000)
+            }
+        }))
+        .into_array();
+        let nullable_arr = DecimalByteParts::try_new(nullable_values, nullable_dtype)?;
+        let zero_dtype = DecimalDType::new(10, 2);
+        let zero_arr = DecimalByteParts::try_new(
+            std::iter::repeat_n(0i64, N)
+                .collect::<PrimitiveArray>()
+                .into_array(),
+            zero_dtype,
+        )?;
+        let crossing_dtype = DecimalDType::new(12, 3);
+        let crossing_values: PrimitiveArray = (0..N as i64).map(|i| (i % 200) - 100).collect();
+        let crossing_arr = DecimalByteParts::try_new(crossing_values.into_array(), crossing_dtype)?;
+        let trailing_zero_dtype = DecimalDType::new(18, 4);
+        let trailing_zero_values: PrimitiveArray =
+            (0..N as i64).map(|i| (i % 1000) * 10_000).collect();
+        let trailing_zero_arr =
+            DecimalByteParts::try_new(trailing_zero_values.into_array(), trailing_zero_dtype)?;
+        let near_limit_dtype = DecimalDType::new(18, 0);
+        let near_limit_values: PrimitiveArray =
+            (0..N as i64).map(|i| 900_000_000_000_000_000 - i).collect();
+        let near_limit_arr =
+            DecimalByteParts::try_new(near_limit_values.into_array(), near_limit_dtype)?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "dec_10_2",
+                "dec_18_6",
+                "dec_negative",
+                "dec_nullable",
+                "dec_zero",
+                "dec_crossing",
+                "dec_trailing_zero",
+                "dec_near_limit",
+            ]),
+            vec![
+                decimal_arr.into_array(),
+                hi_prec_arr.into_array(),
+                neg_arr.into_array(),
+                nullable_arr.into_array(),
+                zero_arr.into_array(),
+                crossing_arr.into_array(),
+                trailing_zero_arr.into_array(),
+                near_limit_arr.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/delta.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/delta.rs
new file mode 100644
index 00000000000..f69e54c4631
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/delta.rs
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::VortexSessionDefault;
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::VortexSessionExecute;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::fastlanes::Delta;
+use vortex::error::VortexResult;
+use vortex_session::VortexSession;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+#[expect(dead_code)]
+pub struct DeltaFixture;
+
+impl FlatLayoutFixture for DeltaFixture {
+    fn name(&self) -> &str {
+        "delta.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Monotonically increasing unsigned integers for Delta encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Delta::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let session = VortexSession::default();
+        let mut ctx = session.create_execution_ctx();
+
+        let monotonic_u64: PrimitiveArray = (0..N as u64).map(|i| i * 3 + 1000).collect();
+        let constant_delta_u32: PrimitiveArray = (0..N as u32).collect();
+        let large_stride_u64: PrimitiveArray = (0..N as u64).map(|i| i * 1_000_000).collect();
+        let monotonic_u16: PrimitiveArray = (0..N as u16).map(|i| i / 2).collect();
+        let monotonic_u8: PrimitiveArray = (0..N).map(|i| (i / 4) as u8).collect();
+        let large_base_u64: PrimitiveArray =
+            (0..N as u64).map(|i| 10_000_000_000 + i * 10).collect();
+        let all_zero_deltas: PrimitiveArray = std::iter::repeat_n(777u64, N).collect();
+        let irregular_monotone: PrimitiveArray = (0..N as u64)
+            .scan(0u64, |state, i| {
+                *state += (i % 7) + 1;
+                Some(*state)
+            })
+            .collect();
+        let near_overflow_base: PrimitiveArray = (0..N as u64)
+            .map(|i| u64::MAX - ((N as u64 - i) * 2))
+            .collect();
+        let nullable_monotone = PrimitiveArray::from_option_iter((0..N as u64).map(|i| {
+            if i < 8 || i >= N as u64 - 8 {
+                None
+            } else {
+                Some(50_000 + i * 4)
+            }
+        }));
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "monotonic_u64",
+                "constant_delta_u32",
+                "large_stride_u64",
+                "monotonic_u16",
+                "monotonic_u8",
+                "large_base_u64",
+                "all_zero_deltas",
+                "irregular_monotone",
+                "near_overflow_base",
+                "nullable_monotone",
+            ]),
+            vec![
+                Delta::try_from_primitive_array(&monotonic_u64, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&constant_delta_u32, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&large_stride_u64, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&monotonic_u16, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&monotonic_u8, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&large_base_u64, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&all_zero_deltas, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&irregular_monotone, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&near_overflow_base, &mut ctx)?.into_array(),
+                Delta::try_from_primitive_array(&nullable_monotone, &mut ctx)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/dict.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/dict.rs
new file mode 100644
index 00000000000..84107b08b2a
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/dict.rs
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinArray;
+use vortex::array::builders::dict::dict_encode;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct DictFixture;
+
+impl FlatLayoutFixture for DictFixture {
+    fn name(&self) -> &str {
+        "dict.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Low-cardinality repeated values (strings and integers) for Dict encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Dict::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let categories = ["red", "green", "blue", "yellow", "purple"];
+        let str_values: Vec<&str> = (0..N).map(|i| categories[i % categories.len()]).collect();
+        let str_col = VarBinArray::from_strs(str_values);
+
+        let int_col: PrimitiveArray = (0..N as i32).map(|i| (i % 10) * 100).collect();
+
+        let nullable_values: Vec<Option<&str>> = (0..N)
+            .map(|i| (i % 7 != 0).then_some(categories[i % categories.len()]))
+            .collect();
+        let nullable_col = VarBinArray::from_nullable_strs(nullable_values);
+
+        let single_val: Vec<&str> = (0..N).map(|_| "only_value").collect();
+        let single_col = VarBinArray::from_strs(single_val);
+
+        let bool_cat: Vec<&str> = (0..N)
+            .map(|i| if i % 3 == 0 { "yes" } else { "no" })
+            .collect();
+        let bool_cat_col = VarBinArray::from_strs(bool_cat);
+        let all_null_col =
+            VarBinArray::from_nullable_strs((0..N).map(|_| None::<&str>).collect::<Vec<_>>());
+        let single_non_null_col = VarBinArray::from_nullable_strs(
+            (0..N)
+                .map(|i| (i == N / 2).then_some("lonely"))
+                .collect::<Vec<_>>(),
+        );
+        let threshold_255_values: Vec<String> =
+            (0..N).map(|i| format!("u255-{}", i % 255)).collect();
+        let threshold_255_refs: Vec<&str> =
+            threshold_255_values.iter().map(String::as_str).collect();
+        let threshold_255_col = VarBinArray::from_strs(threshold_255_refs);
+        let threshold_256_values: Vec<String> =
+            (0..N).map(|i| format!("u256-{}", i % 256)).collect();
+        let threshold_256_refs: Vec<&str> =
+            threshold_256_values.iter().map(String::as_str).collect();
+        let threshold_256_col = VarBinArray::from_strs(threshold_256_refs);
+        let threshold_257_values: Vec<String> =
+            (0..N).map(|i| format!("u257-{}", i % 257)).collect();
+        let threshold_257_refs: Vec<&str> =
+            threshold_257_values.iter().map(String::as_str).collect();
+        let threshold_257_col = VarBinArray::from_strs(threshold_257_refs);
+        let long_values: Vec<String> = (0..N)
+            .map(|i| format!("long-dict-value-{i:04}-{:08x}-suffix", i * 17))
+            .collect();
+        let long_refs: Vec<&str> = long_values.iter().map(String::as_str).collect();
+        let long_col = VarBinArray::from_strs(long_refs);
+        let insertion_values = ["late", "first", "middle", "early", "last"];
+        let insertion_ordered: Vec<&str> = (0..N)
+            .map(|i| insertion_values[(i * 7 + 3) % insertion_values.len()])
+            .collect();
+        let insertion_ordered_col = VarBinArray::from_strs(insertion_ordered);
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "str_cat",
+                "int_cat",
+                "nullable_cat",
+                "single_cat",
+                "bool_cat",
+                "all_null",
+                "single_non_null",
+                "threshold_255",
+                "threshold_256",
+                "threshold_257",
+                "long_values",
+                "insertion_ordered",
+            ]),
+            vec![
+                dict_encode(&str_col.into_array())?.into_array(),
+                dict_encode(&int_col.into_array())?.into_array(),
+                dict_encode(&nullable_col.into_array())?.into_array(),
+                dict_encode(&single_col.into_array())?.into_array(),
+                dict_encode(&bool_cat_col.into_array())?.into_array(),
+                dict_encode(&all_null_col.into_array())?.into_array(),
+                dict_encode(&single_non_null_col.into_array())?.into_array(),
+                dict_encode(&threshold_255_col.into_array())?.into_array(),
+                dict_encode(&threshold_256_col.into_array())?.into_array(),
+                dict_encode(&threshold_257_col.into_array())?.into_array(),
+                dict_encode(&long_col.into_array())?.into_array(),
+                dict_encode(&insertion_ordered_col.into_array())?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/for_.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/for_.rs
new file mode 100644
index 00000000000..3c1a96b6bb1
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/for_.rs
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::fastlanes::FoR;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct FoRFixture;
+
+impl FlatLayoutFixture for FoRFixture {
+    fn name(&self) -> &str {
+        "for.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Integers clustered around a base value for Frame-of-Reference encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![FoR::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let clustered_i32: PrimitiveArray = (0..N as i32).map(|i| 1_000_000 + (i % 100)).collect();
+        let clustered_u64: PrimitiveArray =
+            (0..N as u64).map(|i| 10_000_000_000 + (i % 256)).collect();
+        let clustered_i64: PrimitiveArray =
+            (0..N as i64).map(|i| 1_704_067_200 + (i % 3600)).collect();
+        let negative_i32: PrimitiveArray = (0..N as i32).map(|i| -1_000_000 + (i % 50)).collect();
+        let nullable_i32 = PrimitiveArray::from_option_iter(
+            (0..N as i32).map(|i| (i % 11 != 0).then_some(500_000 + (i % 200))),
+        );
+        let clustered_i16: PrimitiveArray = (0..N as i16).map(|i| 10000 + (i % 30)).collect();
+        let constant_offsets: PrimitiveArray = std::iter::repeat_n(123_456i32, N).collect();
+        let zero_crossing_i32: PrimitiveArray = (0..N as i32).map(|i| -512 + (i % 1024)).collect();
+        let far_outlier_i64: PrimitiveArray = (0..N as i64)
+            .map(|i| {
+                if i == 0 {
+                    9_000_000_000
+                } else {
+                    1_000_000 + (i % 8)
+                }
+            })
+            .collect();
+        let near_max_u64: PrimitiveArray =
+            (0..N as u64).map(|i| u64::MAX - 2048 + (i % 512)).collect();
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "clustered_i32",
+                "clustered_u64",
+                "clustered_i64",
+                "negative_i32",
+                "nullable_i32",
+                "clustered_i16",
+                "constant_offsets",
+                "zero_crossing_i32",
+                "far_outlier_i64",
+                "near_max_u64",
+            ]),
+            vec![
+                FoR::encode(clustered_i32)?.into_array(),
+                FoR::encode(clustered_u64)?.into_array(),
+                FoR::encode(clustered_i64)?.into_array(),
+                FoR::encode(negative_i32)?.into_array(),
+                FoR::encode(nullable_i32)?.into_array(),
+                FoR::encode(clustered_i16)?.into_array(),
+                FoR::encode(constant_offsets)?.into_array(),
+                FoR::encode(zero_crossing_i32)?.into_array(),
+                FoR::encode(far_outlier_i64)?.into_array(),
+                FoR::encode(near_max_u64)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/fsst.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/fsst.rs
new file mode 100644
index 00000000000..91d0f8dce07
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/fsst.rs
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::fsst::FSST;
+use vortex::encodings::fsst::fsst_compress;
+use vortex::encodings::fsst::fsst_train_compressor;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct FsstFixture;
+
+impl FlatLayoutFixture for FsstFixture {
+    fn name(&self) -> &str {
+        "fsst.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Strings with common substrings/prefixes for FSST encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![FSST::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let prefixes = [
+            "https://example.com/api/v1/users/",
+            "https://example.com/api/v1/orders/",
+            "https://example.com/api/v1/products/",
+            "https://example.com/api/v2/users/",
+        ];
+        let urls: Vec<String> = (0..N)
+            .map(|i| format!("{}{}", prefixes[i % prefixes.len()], i))
+            .collect();
+        let url_refs: Vec<&str> = urls.iter().map(|s| s.as_str()).collect();
+        let url_col = VarBinArray::from_strs(url_refs);
+
+        let severities = ["INFO", "WARN", "ERROR", "DEBUG"];
+        let components = ["auth", "db", "cache", "api"];
+        let logs: Vec<String> = (0..N)
+            .map(|i| {
+                format!(
+                    "[{}] {}: request processed in {}ms",
+                    severities[i % severities.len()],
+                    components[i % components.len()],
+                    i % 1000
+                )
+            })
+            .collect();
+        let log_refs: Vec<&str> = logs.iter().map(|s| s.as_str()).collect();
+        let log_col = VarBinArray::from_strs(log_refs);
+
+        let nullable_urls: Vec<Option<String>> = (0..N)
+            .map(|i| (i % 7 != 0).then(|| format!("{}{}", prefixes[i % prefixes.len()], i * 3)))
+            .collect();
+        let nullable_refs: Vec<Option<&str>> = nullable_urls.iter().map(|s| s.as_deref()).collect();
+        let nullable_col = VarBinArray::from_nullable_strs(nullable_refs);
+
+        let short_tokens = ["a", "bb", "ccc", "dd", "e"];
+        let short_strs: Vec<&str> = (0..N)
+            .map(|i| short_tokens[i % short_tokens.len()])
+            .collect();
+        let short_col = VarBinArray::from_strs(short_strs);
+        let empty_and_unicode_values =
+            ["", "こんにちは", "😀", "naive", "façade", "résumé", "مرحبا"];
+        let empty_and_unicode: Vec<&str> = (0..N)
+            .map(|i| empty_and_unicode_values[i % empty_and_unicode_values.len()])
+            .collect();
+        let empty_and_unicode_col = VarBinArray::from_strs(empty_and_unicode);
+        let suffix_shared_values: Vec<String> = (0..N)
+            .map(|i| format!("prefix-{:04}-common-suffix", i % 64))
+            .collect();
+        let suffix_shared_refs: Vec<&str> =
+            suffix_shared_values.iter().map(String::as_str).collect();
+        let suffix_shared_col = VarBinArray::from_strs(suffix_shared_refs);
+        let high_entropy_values: Vec<String> = (0..N)
+            .map(|i| format!("{:016x}{:016x}", i.wrapping_mul(97), i.wrapping_mul(13_579)))
+            .collect();
+        let high_entropy_refs: Vec<&str> = high_entropy_values.iter().map(String::as_str).collect();
+        let high_entropy_col = VarBinArray::from_strs(high_entropy_refs);
+        let all_null_clustered = VarBinArray::from_nullable_strs(
+            (0..N)
+                .map(|i| {
+                    if !(16..N - 16).contains(&i) {
+                        None
+                    } else {
+                        Some("clustered-null-middle")
+                    }
+                })
+                .collect::<Vec<_>>(),
+        );
+
+        let url_comp = fsst_train_compressor(&url_col);
+        let log_comp = fsst_train_compressor(&log_col);
+        let nullable_comp = fsst_train_compressor(&nullable_col);
+        let short_comp = fsst_train_compressor(&short_col);
+        let empty_and_unicode_comp = fsst_train_compressor(&empty_and_unicode_col);
+        let suffix_shared_comp = fsst_train_compressor(&suffix_shared_col);
+        let high_entropy_comp = fsst_train_compressor(&high_entropy_col);
+        let all_null_clustered_comp = fsst_train_compressor(&all_null_clustered);
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "urls",
+                "logs",
+                "nullable_urls",
+                "short_strs",
+                "empty_and_unicode",
+                "suffix_shared",
+                "high_entropy",
+                "all_null_clustered",
+            ]),
+            vec![
+                fsst_compress(&url_col, url_col.len(), url_col.dtype(), &url_comp).into_array(),
+                fsst_compress(&log_col, log_col.len(), log_col.dtype(), &log_comp).into_array(),
+                fsst_compress(
+                    &nullable_col,
+                    nullable_col.len(),
+                    nullable_col.dtype(),
+                    &nullable_comp,
+                )
+                .into_array(),
+                fsst_compress(&short_col, short_col.len(), short_col.dtype(), &short_comp)
+                    .into_array(),
+                fsst_compress(
+                    &empty_and_unicode_col,
+                    empty_and_unicode_col.len(),
+                    empty_and_unicode_col.dtype(),
+                    &empty_and_unicode_comp,
+                )
+                .into_array(),
+                fsst_compress(
+                    &suffix_shared_col,
+                    suffix_shared_col.len(),
+                    suffix_shared_col.dtype(),
+                    &suffix_shared_comp,
+                )
+                .into_array(),
+                fsst_compress(
+                    &high_entropy_col,
+                    high_entropy_col.len(),
+                    high_entropy_col.dtype(),
+                    &high_entropy_comp,
+                )
+                .into_array(),
+                fsst_compress(
+                    &all_null_clustered,
+                    all_null_clustered.len(),
+                    all_null_clustered.dtype(),
+                    &all_null_clustered_comp,
+                )
+                .into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/mod.rs
new file mode 100644
index 00000000000..b6c18064e0f
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/mod.rs
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Per-encoding synthetic fixtures.
+//!
+//! Each fixture produces data patterns designed to exercise a specific stable encoding.
+
+mod alp;
+mod alprd;
+mod bitpacked;
+mod bytebool;
+mod constant;
+mod datetimeparts;
+mod decimal_byte_parts;
+mod delta;
+mod dict;
+mod for_;
+mod fsst;
+mod patched;
+mod pco;
+mod rle;
+mod runend;
+mod sequence;
+mod sparse;
+mod zigzag;
+mod zstd;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub(crate) const N: usize = 1024;
+
+/// All per-encoding fixtures.
+pub fn fixtures() -> Vec<Box<dyn FlatLayoutFixture>> {
+    vec![
+        Box::new(alp::AlpFixture),
+        Box::new(alprd::AlprdFixture),
+        Box::new(bitpacked::BitPackedFixture),
+        Box::new(bytebool::ByteBoolFixture),
+        Box::new(datetimeparts::DateTimePartsFixture),
+        Box::new(decimal_byte_parts::DecimalBytePartsFixture),
+        // Re-enable this once delta is stable
+        // Box::new(delta::DeltaFixture),
+        Box::new(dict::DictFixture),
+        Box::new(fsst::FsstFixture),
+        Box::new(for_::FoRFixture),
+        Box::new(patched::PatchedFixture),
+        Box::new(pco::PcoFixture),
+        Box::new(rle::RleFixture),
+        Box::new(runend::RunEndFixture),
+        Box::new(sequence::SequenceFixture),
+        Box::new(sparse::SparseFixture),
+        Box::new(zstd::ZstdFixture),
+        Box::new(zigzag::ZigZagFixture),
+        Box::new(constant::ConstantFixture),
+    ]
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/patched.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/patched.rs
new file mode 100644
index 00000000000..b9a43dfb1e2
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/patched.rs
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::ArrayId;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Patched;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::patches::Patches;
+use vortex_array::vtable::ArrayVTable;
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct PatchedFixture;
+
+impl FlatLayoutFixture for PatchedFixture {
+    fn name(&self) -> &str {
+        "patched.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "A set of patches to apply on top of an inner array"
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let mut ctx = ExecutionCtx::new(VortexSession::empty());
+
+        let array = PrimitiveArray::from_option_iter((0u64..2048).map(Some)).into_array();
+        let patches = Patches::new(
+            2048,
+            0,
+            PrimitiveArray::from_iter([0u32, 1024, 1025, 1026]).into_array(),
+            PrimitiveArray::from_option_iter([Some(1u64), Some(2), Some(3), Some(4)]).into_array(),
+            None,
+        )?;
+
+        Ok(Patched::from_array_and_patches(array, &patches, &mut ctx)?.into_array())
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Patched.id()]
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/pco.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/pco.rs
new file mode 100644
index 00000000000..33dd4b78e37
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/pco.rs
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::pco::Pco;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct PcoFixture;
+
+impl FlatLayoutFixture for PcoFixture {
+    fn name(&self) -> &str {
+        "pco.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Various numeric patterns for Pco (patas compression) encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Pco::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let irregular_i64: PrimitiveArray =
+            (0..N as i64).map(|i| i * i + (i % 17) * 1000).collect();
+        let smooth_f64: PrimitiveArray = (0..N)
+            .map(|i| {
+                let t = i as f64 / N as f64;
+                t * t * (3.0 - 2.0 * t) * 100.0
+            })
+            .collect();
+        let pattern_u32: PrimitiveArray = (0..N as u32)
+            .map(|i| i.wrapping_mul(2_654_435_761) % 65536)
+            .collect();
+        let nullable_f32 = PrimitiveArray::from_option_iter(
+            (0..N).map(|i| (i % 9 != 0).then_some((i as f32) * 0.1 + ((i * 3 % 7) as f32) * 0.01)),
+        );
+        let negative_i32: PrimitiveArray = (0..N as i32).map(|i| -10_000 + (i % 257)).collect();
+        let constant_u16: PrimitiveArray = std::iter::repeat_n(17u16, N).collect();
+        let spike_outliers: PrimitiveArray = (0..N)
+            .map(|i| {
+                if i % 257 == 0 {
+                    1_000_000.0 + i as f64
+                } else {
+                    std::f64::consts::PI
+                }
+            })
+            .collect();
+        let narrow_i16: PrimitiveArray = (0..N as i16).map(|i| (i % 17) - 8).collect();
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "irregular_i64",
+                "smooth_f64",
+                "pattern_u32",
+                "nullable_f32",
+                "negative_i32",
+                "constant_u16",
+                "spike_outliers",
+                "narrow_i16",
+            ]),
+            vec![
+                Pco::from_primitive(&irregular_i64, 8, 0)?.into_array(),
+                Pco::from_primitive(&smooth_f64, 8, 0)?.into_array(),
+                Pco::from_primitive(&pattern_u32, 8, 0)?.into_array(),
+                Pco::from_primitive(&nullable_f32, 8, 0)?.into_array(),
+                Pco::from_primitive(&negative_i32, 8, 0)?.into_array(),
+                Pco::from_primitive(&constant_u16, 8, 0)?.into_array(),
+                Pco::from_primitive(&spike_outliers, 8, 0)?.into_array(),
+                Pco::from_primitive(&narrow_i16, 8, 0)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/rle.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/rle.rs
new file mode 100644
index 00000000000..46235ed1fa0
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/rle.rs
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::fastlanes::RLE;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct RleFixture;
+
+impl FlatLayoutFixture for RleFixture {
+    fn name(&self) -> &str {
+        "rle.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Primitive data with long runs of repeated values for RLE encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![RLE::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let runs_i32: PrimitiveArray = (0..N as i32).map(|i| i / 64).collect();
+        let single_run: PrimitiveArray = std::iter::repeat_n(42u64, N).collect();
+        let nullable_runs = PrimitiveArray::from_option_iter(
+            (0..N as i32).map(|i| (i / 64 % 3 != 0).then_some(i / 64 * 10)),
+        );
+        let alternating_singletons: PrimitiveArray = (0..N as u16).collect();
+        let boundary_run_lengths = [31usize, 32, 63, 64, 127, 128];
+        let mut exact_boundary_runs_vec = Vec::with_capacity(N);
+        let mut boundary_value = 0u16;
+        while exact_boundary_runs_vec.len() < N {
+            for run_len in boundary_run_lengths {
+                let take = run_len.min(N - exact_boundary_runs_vec.len());
+                exact_boundary_runs_vec.extend(std::iter::repeat_n(boundary_value, take));
+                boundary_value = boundary_value.wrapping_add(1);
+                if exact_boundary_runs_vec.len() == N {
+                    break;
+                }
+            }
+        }
+        let exact_boundary_runs: PrimitiveArray = exact_boundary_runs_vec.into_iter().collect();
+        let giant_final_run: PrimitiveArray = (0..N as u32)
+            .map(|i| if i < 32 { i } else { 999 })
+            .collect();
+        let all_null_i32 = PrimitiveArray::from_option_iter((0..N).map(|_| None::<i32>));
+        let short_runs_u8: PrimitiveArray = (0..N).map(|i| (i / 16) as u8).collect();
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "runs_i32",
+                "single_run",
+                "nullable_runs",
+                "alternating_singletons",
+                "exact_boundary_runs",
+                "giant_final_run",
+                "all_null_i32",
+                "short_runs_u8",
+            ]),
+            vec![
+                RLE::encode(&runs_i32)?.into_array(),
+                RLE::encode(&single_run)?.into_array(),
+                RLE::encode(&nullable_runs)?.into_array(),
+                RLE::encode(&alternating_singletons)?.into_array(),
+                RLE::encode(&exact_boundary_runs)?.into_array(),
+                RLE::encode(&giant_final_run)?.into_array(),
+                RLE::encode(&all_null_i32)?.into_array(),
+                RLE::encode(&short_runs_u8)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/runend.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/runend.rs
new file mode 100644
index 00000000000..e5594edcc7f
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/runend.rs
@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::BoolArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::runend::compress::runend_encode;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct RunEndFixture;
+
+impl FlatLayoutFixture for RunEndFixture {
+    fn name(&self) -> &str {
+        "runend.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Data with variable-length runs for RunEnd encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![RunEnd::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let run_lengths = [1usize, 5, 10, 50, 100];
+        let mut values = Vec::with_capacity(N);
+        let mut run_idx = 0i64;
+        let mut rl_idx = 0;
+        while values.len() < N {
+            let run_len = run_lengths[rl_idx % run_lengths.len()].min(N - values.len());
+            for _ in 0..run_len {
+                values.push(run_idx);
+            }
+            run_idx += 1;
+            rl_idx += 1;
+        }
+        let run_prim: PrimitiveArray = values.into_iter().collect();
+        let (run_ends, run_values) = runend_encode(run_prim.as_view());
+        let run_col = RunEnd::try_new(run_ends.into_array(), run_values)?;
+
+        let statuses = ["open", "closed", "pending", "cancelled"];
+        let mut status_values = Vec::new();
+        let mut status_ends = Vec::new();
+        let mut s_idx = 0;
+        let mut remaining = N;
+        let mut status_end = 0u16;
+        while remaining > 0 {
+            let run_len = (32 + s_idx * 7 % 64).min(remaining);
+            status_values.push(statuses[s_idx % statuses.len()]);
+            status_end += run_len as u16;
+            status_ends.push(status_end);
+            s_idx += 1;
+            remaining -= run_len;
+        }
+        let status_ends_prim: PrimitiveArray = status_ends.into_iter().collect();
+        let status_col = RunEnd::try_new(
+            status_ends_prim.into_array(),
+            VarBinArray::from_strs(status_values).into_array(),
+        )?;
+
+        let uniform_prim: PrimitiveArray = (0..N as i32).map(|i| i / 64).collect();
+        let (uniform_ends, uniform_values) = runend_encode(uniform_prim.as_view());
+        let uniform_col = RunEnd::try_new(uniform_ends.into_array(), uniform_values)?;
+
+        let bool_ends: PrimitiveArray = (1..=N / 32).map(|i| (i * 32) as u16).collect();
+        let bool_values =
+            BoolArray::from_iter((0..bool_ends.len()).map(|i| i % 2 == 0)).into_array();
+        let bool_runs = RunEnd::try_new(bool_ends.into_array(), bool_values)?;
+        let nullable_run_values = PrimitiveArray::from_option_iter([
+            Some(10i32),
+            None,
+            Some(-5),
+            Some(77),
+            None,
+            Some(0),
+        ]);
+        let nullable_runs = RunEnd::try_new(
+            PrimitiveArray::from_iter([16u16, 64, 128, 256, 512, N as u16]).into_array(),
+            nullable_run_values.into_array(),
+        )?;
+        let single_run = RunEnd::try_new(
+            PrimitiveArray::from_iter([N as u64]).into_array(),
+            PrimitiveArray::from_iter([1234i64]).into_array(),
+        )?;
+        let singleton_values: PrimitiveArray = (0..N as i16).map(|i| i - 512).collect();
+        let singleton_ends: PrimitiveArray = (1..=N as u16).collect();
+        let alternating_singletons =
+            RunEnd::try_new(singleton_ends.into_array(), singleton_values.into_array())?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "run_values",
+                "statuses",
+                "uniform_runs",
+                "bool_runs",
+                "nullable_runs",
+                "single_run",
+                "alternating_singletons",
+            ]),
+            vec![
+                run_col.into_array(),
+                status_col.into_array(),
+                uniform_col.into_array(),
+                bool_runs.into_array(),
+                nullable_runs.into_array(),
+                single_run.into_array(),
+                alternating_singletons.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sequence.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sequence.rs
new file mode 100644
index 00000000000..61bd87252fb
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sequence.rs
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::dtype::Nullability;
+use vortex::array::validity::Validity;
+use vortex::encodings::sequence::Sequence;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct SequenceFixture;
+
+impl FlatLayoutFixture for SequenceFixture {
+    fn name(&self) -> &str {
+        "sequence.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Arithmetic sequences (0,1,2,... and stepped) for Sequence encoding, including nullable"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Sequence::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let row_ids = Sequence::try_new_typed::<u64>(0, 1, Nullability::NonNullable, N)?;
+        let stepped = Sequence::try_new_typed::<i32>(0, 5, Nullability::NonNullable, N)?;
+        let offset = Sequence::try_new_typed::<i64>(1000, 1, Nullability::NonNullable, N)?;
+        let decreasing = Sequence::try_new_typed::<i64>(10000, -3, Nullability::NonNullable, N)?;
+        let large_step = Sequence::try_new_typed::<u32>(0, 1000, Nullability::NonNullable, N)?;
+        let zero_step = Sequence::try_new_typed::<i32>(7, 0, Nullability::NonNullable, N)?;
+        let zero_crossing = Sequence::try_new_typed::<i32>(-512, 1, Nullability::NonNullable, N)?;
+        let near_overflow =
+            Sequence::try_new_typed::<u64>(u64::MAX - N as u64, 1, Nullability::NonNullable, N)?;
+        let small_negative_i16 =
+            Sequence::try_new_typed::<i16>(1200, -2, Nullability::NonNullable, N)?;
+        let nullable_i64 = Sequence::try_new_typed::<i64>(0, 2, Nullability::Nullable, N)?;
+        let nullable_u32 = Sequence::try_new_typed::<u32>(100, 7, Nullability::Nullable, N)?;
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "row_ids",
+                "stepped",
+                "offset",
+                "decreasing",
+                "large_step",
+                "zero_step",
+                "zero_crossing",
+                "near_overflow",
+                "small_negative_i16",
+                "nullable_i64",
+                "nullable_u32",
+            ]),
+            vec![
+                row_ids.into_array(),
+                stepped.into_array(),
+                offset.into_array(),
+                decreasing.into_array(),
+                large_step.into_array(),
+                zero_step.into_array(),
+                zero_crossing.into_array(),
+                near_overflow.into_array(),
+                small_negative_i16.into_array(),
+                nullable_i64.into_array(),
+                nullable_u32.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sparse.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sparse.rs
new file mode 100644
index 00000000000..eeff8c36c1b
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/sparse.rs
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::BoolArray;
+use vortex::array::arrays::ConstantArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::dtype::Nullability;
+use vortex::array::scalar::Scalar;
+use vortex::array::validity::Validity;
+use vortex::encodings::sparse::Sparse;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct SparseFixture;
+
+impl FlatLayoutFixture for SparseFixture {
+    fn name(&self) -> &str {
+        "sparse.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Mostly-null or mostly-default arrays with sparse non-default values"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Sparse::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let sparse_i64_col = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i % 50 == 0).then_some(i * 1000)),
+        );
+
+        let sparse_str: Vec<Option<&str>> = (0..N)
+            .map(|i| (i % 20 == 0).then_some("rare_value"))
+            .collect();
+        let sparse_str_col = VarBinArray::from_nullable_strs(sparse_str);
+
+        let sparse_bool_col = BoolArray::from_iter((0..N).map(|i| (i % 100 == 0).then_some(true)));
+
+        let sparse_f64 = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i % 100 == 0).then_some(i as f64 * 2.71)),
+        );
+
+        let sparse_boundary = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i == 0 || i == (N as i64 - 1) || i % 200 == 0).then(|| i * 7)),
+        );
+        let explicit_fill_values = PrimitiveArray::from_option_iter(
+            (0..N as i32).map(|i| if i % 75 == 0 { Some(99) } else { Some(10) }),
+        );
+        let all_default = ConstantArray::new(10i32, N).into_array();
+        let clustered_edges = PrimitiveArray::from_option_iter(
+            (0..N as i64).map(|i| (i < 8 || i >= N as i64 - 8).then(|| i * 9)),
+        );
+        let almost_dense = PrimitiveArray::from_option_iter(
+            (0..N as i32).map(|i| if i % 32 == 0 { None } else { Some((i % 5) + 1) }),
+        );
+        let mixed_null_and_values = PrimitiveArray::from_option_iter((0..N as i32).map(|i| {
+            if i % 17 == 0 {
+                None
+            } else if i % 19 == 0 {
+                Some(77)
+            } else {
+                Some(0)
+            }
+        }));
+        let mixed_null_fill = Scalar::null(mixed_null_and_values.dtype().clone());
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "sparse_i64",
+                "sparse_str",
+                "sparse_bool",
+                "sparse_f64",
+                "sparse_boundary",
+                "explicit_fill_values",
+                "all_default",
+                "clustered_edges",
+                "almost_dense",
+                "mixed_null_and_values",
+            ]),
+            vec![
+                Sparse::encode(&sparse_i64_col.into_array(), None)?,
+                Sparse::encode(&sparse_str_col.into_array(), None)?,
+                Sparse::encode(&sparse_bool_col.into_array(), None)?,
+                Sparse::encode(&sparse_f64.into_array(), None)?,
+                Sparse::encode(&sparse_boundary.into_array(), None)?,
+                Sparse::encode(
+                    &explicit_fill_values.into_array(),
+                    Some(Scalar::primitive(10i32, Nullability::Nullable)),
+                )?,
+                Sparse::encode(&all_default, Some(Scalar::from(10i32)))?,
+                Sparse::encode(&clustered_edges.into_array(), None)?,
+                Sparse::encode(
+                    &almost_dense.into_array(),
+                    Some(Scalar::primitive(0i32, Nullability::Nullable)),
+                )?,
+                Sparse::encode(&mixed_null_and_values.into_array(), Some(mixed_null_fill))?,
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zigzag.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zigzag.rs
new file mode 100644
index 00000000000..2e1bb972f5d
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zigzag.rs
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::zigzag::ZigZag;
+use vortex::encodings::zigzag::zigzag_encode;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ZigZagFixture;
+
+impl FlatLayoutFixture for ZigZagFixture {
+    fn name(&self) -> &str {
+        "zigzag.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Signed integers with small absolute values for ZigZag encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![ZigZag::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let alternating_i32: PrimitiveArray = (0..N as i32)
+            .map(|i| {
+                let v = i / 2 + 1;
+                if i % 2 == 0 { v } else { -v }
+            })
+            .collect();
+        let small_i64: PrimitiveArray = (0..N as i64).map(|i| (i % 21) - 10).collect();
+        let deltas_i32: PrimitiveArray = (0..N as i32).map(|i| -(i % 50)).collect();
+        let small_i16: PrimitiveArray = (0..N as i16).map(|i| (i % 11) - 5).collect();
+        let small_i8: PrimitiveArray = (0..N).map(|i| ((i % 9) as i8) - 4).collect();
+        let nullable_zigzag = PrimitiveArray::from_option_iter(
+            (0..N as i32).map(|i| (i % 6 != 0).then_some((i % 15) - 7)),
+        );
+        let extremes_i32: PrimitiveArray = (0..N)
+            .map(|i| match i % 4 {
+                0 => i32::MIN,
+                1 => i32::MAX,
+                2 => -1,
+                _ => 1,
+            })
+            .collect();
+        let zero_heavy_outliers: PrimitiveArray = (0..N as i64)
+            .map(|i| if i % 257 == 0 { i64::MAX / 1024 - i } else { 0 })
+            .collect();
+        let repeated_negative: PrimitiveArray = std::iter::repeat_n(-42i32, N).collect();
+        let zero_crossing: PrimitiveArray = (0..N as i32).map(|i| -512 + (i % 1024)).collect();
+        let head_tail_nulls = PrimitiveArray::from_option_iter((0..N as i32).map(|i| {
+            if i < 8 || i >= N as i32 - 8 {
+                None
+            } else {
+                Some((i % 21) - 10)
+            }
+        }));
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "alternating_i32",
+                "small_i64",
+                "deltas_i32",
+                "small_i16",
+                "small_i8",
+                "nullable_zigzag",
+                "extremes_i32",
+                "zero_heavy_outliers",
+                "repeated_negative",
+                "zero_crossing",
+                "head_tail_nulls",
+            ]),
+            vec![
+                zigzag_encode(alternating_i32)?.into_array(),
+                zigzag_encode(small_i64)?.into_array(),
+                zigzag_encode(deltas_i32)?.into_array(),
+                zigzag_encode(small_i16)?.into_array(),
+                zigzag_encode(small_i8)?.into_array(),
+                zigzag_encode(nullable_zigzag)?.into_array(),
+                zigzag_encode(extremes_i32)?.into_array(),
+                zigzag_encode(zero_heavy_outliers)?.into_array(),
+                zigzag_encode(repeated_negative)?.into_array(),
+                zigzag_encode(zero_crossing)?.into_array(),
+                zigzag_encode(head_tail_nulls)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zstd.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zstd.rs
new file mode 100644
index 00000000000..655cbba8c06
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/encodings/zstd.rs
@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinViewArray;
+use vortex::array::dtype::FieldNames;
+use vortex::array::validity::Validity;
+use vortex::encodings::zstd::Zstd;
+use vortex::error::VortexResult;
+
+use super::N;
+use crate::fixtures::FlatLayoutFixture;
+
+pub struct ZstdFixture;
+
+impl FlatLayoutFixture for ZstdFixture {
+    fn name(&self) -> &str {
+        "zstd.vortex"
+    }
+
+    fn description(&self) -> &str {
+        "Primitive and string arrays compressed with Zstd encoding"
+    }
+
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![Zstd::ID]
+    }
+
+    fn build(&self) -> VortexResult<ArrayRef> {
+        let ints: PrimitiveArray = (0..N as i32).map(|i| i / 8).collect();
+        let floats: PrimitiveArray = (0..N)
+            .map(|i| {
+                if i % 257 == 0 {
+                    100_000.0 + i as f64
+                } else {
+                    std::f64::consts::PI
+                }
+            })
+            .collect();
+        let nullable_i64 = PrimitiveArray::from_option_iter((0..N as i64).map(|i| {
+            if i % 9 == 0 {
+                None
+            } else {
+                Some(10_000 + i * 3)
+            }
+        }));
+        let utf8 = VarBinViewArray::from_iter_str((0..N).map(|i| {
+            if i % 3 == 0 {
+                "https://example.com/path"
+            } else if i % 3 == 1 {
+                "hello-world"
+            } else {
+                "compression-fixture"
+            }
+        }));
+        let nullable_utf8 = VarBinViewArray::from_iter_nullable_str((0..N).map(|i| {
+            if i % 11 == 0 {
+                None
+            } else if i % 2 == 0 {
+                Some("nullable-zstd-string")
+            } else {
+                Some("another-string")
+            }
+        }));
+        // Highly compressible: all zeros
+        let all_zeros: PrimitiveArray = std::iter::repeat_n(0i64, N).collect();
+        // All-null column
+        let all_null_i32 = PrimitiveArray::from_option_iter((0..N).map(|_| None::<i32>));
+        // Pseudo-random data (low compressibility)
+        let pseudo_random: PrimitiveArray =
+            (0..N as u32).map(|i| i.wrapping_mul(2654435761)).collect();
+
+        let arr = StructArray::try_new(
+            FieldNames::from([
+                "ints",
+                "floats",
+                "nullable_i64",
+                "utf8",
+                "nullable_utf8",
+                "all_zeros",
+                "all_null_i32",
+                "pseudo_random",
+            ]),
+            vec![
+                Zstd::from_primitive(&ints, 3, 128)?.into_array(),
+                Zstd::from_primitive(&floats, 3, 128)?.into_array(),
+                Zstd::from_primitive(&nullable_i64, 3, 128)?.into_array(),
+                Zstd::from_var_bin_view(&utf8, 3, 128)?.into_array(),
+                Zstd::from_var_bin_view(&nullable_utf8, 3, 128)?.into_array(),
+                Zstd::from_primitive(&all_zeros, 3, 128)?.into_array(),
+                Zstd::from_primitive(&all_null_i32, 3, 128)?.into_array(),
+                Zstd::from_primitive(&pseudo_random, 3, 128)?.into_array(),
+            ],
+            N,
+            Validity::NonNullable,
+        )?;
+        Ok(arr.into_array())
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs
new file mode 100644
index 00000000000..3c3ffcb80d6
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/arrays/synthetic/mod.rs
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod arrays;
+#[allow(clippy::cast_possible_truncation)]
+mod encodings;
+
+use crate::fixtures::FlatLayoutFixture;
+
+/// All synthetic fixtures (arrays + encodings).
+pub fn fixtures() -> Vec<Box<dyn FlatLayoutFixture>> {
+    let mut fixtures = Vec::new();
+    fixtures.extend(arrays::fixtures());
+    fixtures.extend(encodings::fixtures());
+    fixtures
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::assert_arrays_eq;
+
+    use super::fixtures;
+    use crate::adapter;
+    use crate::fixtures::check_expected_encodings;
+
+    #[test]
+    fn roundtrip_fixtures_to_bytes() {
+        for fixture in fixtures() {
+            let array = fixture.build().unwrap();
+            check_expected_encodings(&array, fixture.as_ref()).unwrap();
+            let bytes = adapter::write_file_to_bytes(array.clone()).unwrap();
+            let roundtripped = adapter::read_file(bytes).unwrap();
+            assert_arrays_eq!(array, roundtripped);
+        }
+    }
+}
diff --git a/vortex-test/compat-gen/src/fixtures/mod.rs b/vortex-test/compat-gen/src/fixtures/mod.rs
new file mode 100644
index 00000000000..edf0dd47e37
--- /dev/null
+++ b/vortex-test/compat-gen/src/fixtures/mod.rs
@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod arrays;
+
+use std::path::Path;
+use std::sync::Arc;
+
+use vortex::array::ArrayId;
+use vortex::array::ArrayRef;
+use vortex::compressor::BtrBlocksCompressorBuilder;
+use vortex::file::WriteStrategyBuilder;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use crate::adapter;
+use crate::adapter::compute_all_stats;
+use crate::manifest::FixtureEntry;
+
+/// Top-level trait that the runner (compat-gen / compat-validate) interacts with.
+pub trait Fixture {
+    /// Filename for this fixture, e.g. "primitives.vortex" or "tpch_lineitem.regular.vortex".
+    fn name(&self) -> &str;
+
+    /// A short human-readable description of what this fixture tests.
+    fn description(&self) -> &str;
+
+    /// Generate the fixture file(s) into `dir`, returning manifest entries.
+    fn write(&self, dir: &Path) -> VortexResult<Vec<FixtureEntry>>;
+}
+
+/// A deterministic fixture that produces a single array written via flat layout (no compression).
+pub trait FlatLayoutFixture {
+    /// The filename for this fixture, e.g. "primitives.vortex".
+    fn name(&self) -> &str;
+
+    /// A short human-readable description of what this fixture tests.
+    fn description(&self) -> &str;
+
+    /// Build the expected arrays. Must be deterministic under all versions of vortex.
+    fn build(&self) -> VortexResult<ArrayRef>;
+
+    /// Encoding IDs that must appear somewhere in the array tree produced by [`Self::build`].
+    ///
+    /// Only include encodings that the fixture is specifically testing, not incidental ones
+    /// (e.g. a primitives fixture should not list struct even if it wraps values in one).
+    ///
+    /// An empty slice (the default) disables the check.
+    fn expected_encodings(&self) -> Vec<ArrayId> {
+        vec![]
+    }
+}
+
+/// A fixture backed by a real-world dataset that produces multiple chunks.
+///
+/// Each dataset fixture is written twice: once with the default (BtrBlocks) compressor
+/// and once with compact encodings (Pco + Zstd).
+pub trait DatasetFixture {
+    /// Base name without strategy suffix, e.g. "tpch_lineitem".
+    fn name(&self) -> &str;
+
+    /// A short human-readable description of what this fixture tests.
+    fn description(&self) -> &str;
+
+    /// Build the dataset as a chunked array. Must be deterministic.
+    fn build(&self) -> VortexResult<ArrayRef>;
+}
+
+// ---------------------------------------------------------------------------
+// Adapters
+// ---------------------------------------------------------------------------
+
+/// Adapts a [`FlatLayoutFixture`] into a [`Fixture`] by writing through the flat layout strategy.
+pub struct FlatLayoutAdapter(pub Box<dyn FlatLayoutFixture>);
+
+impl Fixture for FlatLayoutAdapter {
+    fn name(&self) -> &str {
+        self.0.name()
+    }
+
+    fn description(&self) -> &str {
+        self.0.description()
+    }
+
+    fn write(&self, dir: &Path) -> VortexResult<Vec<FixtureEntry>> {
+        let array = self.0.build()?;
+        check_expected_encodings(&array, self.0.as_ref())?;
+        compute_all_stats(&array)?;
+        let path = dir.join(self.name());
+        adapter::write_file(&path, array)?;
+        Ok(vec![FixtureEntry {
+            name: self.name().to_string(),
+            description: self.description().to_string(),
+        }])
+    }
+}
+
+/// Adapts a [`DatasetFixture`] into a [`Fixture`] by writing through the compressor pipeline.
+pub struct DatasetFixtureAdapter {
+    inner: Arc<dyn DatasetFixture>,
+    compact: bool,
+    file_name: String,
+}
+
+impl DatasetFixtureAdapter {
+    /// Create a pair of fixtures: one with the default strategy and one with compact encodings.
+    pub fn pair(fixture: Box<dyn DatasetFixture>) -> [Box<dyn Fixture>; 2] {
+        let inner: Arc<dyn DatasetFixture> = Arc::from(fixture);
+        let base = inner.name().to_string();
+        [
+            Box::new(DatasetFixtureAdapter {
+                inner: Arc::clone(&inner),
+                compact: false,
+                file_name: format!("{base}.regular.vortex"),
+            }),
+            Box::new(DatasetFixtureAdapter {
+                inner,
+                compact: true,
+                file_name: format!("{base}.compact.vortex"),
+            }),
+        ]
+    }
+}
+
+impl Fixture for DatasetFixtureAdapter {
+    fn name(&self) -> &str {
+        &self.file_name
+    }
+
+    fn description(&self) -> &str {
+        self.inner.description()
+    }
+
+    fn write(&self, dir: &Path) -> VortexResult<Vec<FixtureEntry>> {
+        let array = self.inner.build()?;
+        let path = dir.join(self.name());
+        if self.compact {
+            let strategy = WriteStrategyBuilder::default()
+                .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
+                .build();
+            adapter::write_compressed(&path, array, strategy)?;
+        } else {
+            let strategy = WriteStrategyBuilder::default().build();
+            adapter::write_compressed(&path, array, strategy)?;
+        }
+        Ok(vec![FixtureEntry {
+            name: self.name().to_string(),
+            description: self.description().to_string(),
+        }])
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/// Walk the array tree, collect encoding IDs, and assert that all expected encodings
+/// are present. This is a no-op when [`FlatLayoutFixture::expected_encodings`] returns an empty vec.
+pub fn check_expected_encodings(
+    array: &ArrayRef,
+    fixture: &dyn FlatLayoutFixture,
+) -> VortexResult<()> {
+    let expected = fixture.expected_encodings();
+    if expected.is_empty() {
+        return Ok(());
+    }
+
+    let mut found: Vec<ArrayId> = Vec::new();
+    for node in array.depth_first_traversal() {
+        let id = node.encoding_id();
+        if !found.contains(&id) {
+            found.push(id);
+        }
+    }
+
+    let missing: Vec<&ArrayId> = expected.iter().filter(|id| !found.contains(id)).collect();
+
+    if !missing.is_empty() {
+        vortex_bail!(
+            "fixture '{}' is missing expected encodings: {:?} (found: {:?})",
+            fixture.name(),
+            missing,
+            found,
+        );
+    }
+
+    Ok(())
+}
+
+/// All registered fixtures.
+pub fn all_fixtures() -> Vec<Box<dyn Fixture>> {
+    let mut out: Vec<Box<dyn Fixture>> = Vec::new();
+    for f in arrays::synthetic_fixtures() {
+        out.push(Box::new(FlatLayoutAdapter(f)));
+    }
+    for f in arrays::dataset_fixtures() {
+        out.extend(DatasetFixtureAdapter::pair(f));
+    }
+    out
+}
diff --git a/vortex-test/compat-gen/src/generate.rs b/vortex-test/compat-gen/src/generate.rs
new file mode 100644
index 00000000000..1393866c757
--- /dev/null
+++ b/vortex-test/compat-gen/src/generate.rs
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::path::Path;
+
+use serde::Serialize;
+use sha2::Digest;
+use sha2::Sha256;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::fixtures::all_fixtures;
+
+#[derive(Serialize)]
+struct FixturesJson {
+    fixtures: Vec<FixtureInfo>,
+}
+
+#[derive(Serialize)]
+pub struct FixtureInfo {
+    pub name: String,
+    pub description: String,
+    pub sha256: String,
+}
+
+/// Write all fixture files into `output_dir`, returning name, description, and sha256 for each.
+pub fn write_fixtures(output_dir: &Path, exclude: &[String]) -> VortexResult<Vec<FixtureInfo>> {
+    let fixtures = all_fixtures();
+    let fixtures: Vec<_> = fixtures
+        .into_iter()
+        .filter(|f| {
+            let name = f.name();
+            !exclude.iter().any(|pat| name.contains(pat.as_str()))
+        })
+        .collect();
+
+    if !exclude.is_empty() {
+        eprintln!("excluding: {}", exclude.join(", "));
+    }
+
+    std::fs::create_dir_all(output_dir)
+        .map_err(|e| vortex_err!("failed to create output dir: {e}"))?;
+
+    eprintln!("generating {} fixtures...", fixtures.len());
+
+    let mut infos = Vec::new();
+    for fixture in &fixtures {
+        let entries = fixture.write(output_dir)?;
+        for entry in entries {
+            let path = output_dir.join(&entry.name);
+            let file_bytes = std::fs::read(&path)
+                .map_err(|e| vortex_err!("failed to read back {}: {e}", path.display()))?;
+            let sha256 = format!("{:x}", Sha256::digest(&file_bytes));
+            eprintln!("  wrote {}", entry.name);
+            infos.push(FixtureInfo {
+                name: entry.name,
+                description: entry.description,
+                sha256,
+            });
+        }
+    }
+
+    Ok(infos)
+}
+
+/// Write the `fixtures.json` manifest from previously collected fixture info.
+pub fn write_manifest(output_dir: &Path, infos: Vec<FixtureInfo>) -> VortexResult<()> {
+    let fixtures_json = FixturesJson { fixtures: infos };
+    let json = serde_json::to_string_pretty(&fixtures_json)
+        .map_err(|e| vortex_err!("failed to serialize fixtures.json: {e}"))?;
+    std::fs::write(output_dir.join("fixtures.json"), format!("{json}\n"))
+        .map_err(|e| vortex_err!("failed to write fixtures.json: {e}"))?;
+    eprintln!("  wrote fixtures.json");
+
+    eprintln!(
+        "\ndone: {} fixtures in {}",
+        fixtures_json.fixtures.len(),
+        output_dir.display()
+    );
+    Ok(())
+}
+
+/// Generate all fixtures into `output_dir` and write the manifest.
+pub fn generate(output_dir: &Path, exclude: &[String]) -> VortexResult<()> {
+    let infos = write_fixtures(output_dir, exclude)?;
+    write_manifest(output_dir, infos)
+}
diff --git a/vortex-test/compat-gen/src/lib.rs b/vortex-test/compat-gen/src/lib.rs
new file mode 100644
index 00000000000..d5010905605
--- /dev/null
+++ b/vortex-test/compat-gen/src/lib.rs
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+pub mod adapter;
+pub mod check;
+pub mod fixtures;
+pub mod generate;
+pub mod manifest;
diff --git a/vortex-test/compat-gen/src/main.rs b/vortex-test/compat-gen/src/main.rs
new file mode 100644
index 00000000000..55578e82072
--- /dev/null
+++ b/vortex-test/compat-gen/src/main.rs
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::path::PathBuf;
+
+use clap::Parser;
+use clap::Subcommand;
+use vortex_compat::check;
+use vortex_compat::generate;
+use vortex_error::VortexResult;
+
+#[derive(Parser)]
+#[command(
+    name = "vortex-compat",
+    about = "Generate and check Vortex backward-compatibility fixtures",
+    long_about = "\
+Thin Rust binary for backward-compatibility testing.\n\
+\n\
+This tool generates .vortex fixture files from in-memory test data and \
+checks that existing .vortex files can still be read and match expectations. \
+It is designed to be called by the compat.py orchestrator, which handles \
+versioning, S3 storage, and manifest management.\n\
+\n\
+Output protocol:\n\
+  - Progress / diagnostics go to stderr\n\
+  - Structured JSON results go to stdout (check command only)",
+    after_help = "\
+EXAMPLES:\n\
+  Generate fixtures into a directory:\n\
+    vortex-compat generate --output /tmp/fixtures\n\
+\n\
+  Check fixtures (default, old dir may be missing new fixtures):\n\
+    vortex-compat check --dir /tmp/v0.62.0\n\
+\n\
+  Check fixtures (strict, must match exactly):\n\
+    vortex-compat check --dir /tmp/v0.63.0 --mode exact\n\
+\n\
+  Build and run:\n\
+    cargo run -p vortex-compat --release -- generate --output ./out"
+)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Generate all fixture files into a directory.
+    ///
+    /// Writes one .vortex file per fixture plus a fixtures.json manifest
+    /// listing all generated files. The output directory is created if needed.
+    ///
+    /// Progress is printed to stderr. On success, the output directory
+    /// contains everything needed for `check` to validate.
+    Generate {
+        /// Output directory for .vortex files and fixtures.json.
+        #[arg(long, value_name = "DIR")]
+        output: PathBuf,
+
+        /// Fixture name substrings to exclude (comma-separated, e.g. "clickbench,tpch").
+        #[arg(long, value_delimiter = ',', value_name = "PATTERNS")]
+        exclude: Vec<String>,
+    },
+
+    /// Check .vortex files in a directory against in-memory fixtures.
+    ///
+    /// For each .vortex file, rebuilds the expected array from current code
+    /// and compares it to the file contents. Results are printed as JSON to
+    /// stdout (for machine consumption) and as human-readable summaries to
+    /// stderr.
+    ///
+    /// The --mode flag controls how mismatches between directory contents
+    /// and the current fixture set are handled.
+    Check {
+        /// Directory containing .vortex files to check.
+        #[arg(long, value_name = "DIR")]
+        dir: PathBuf,
+
+        /// How to handle mismatches between directory contents and known fixtures.
+        ///
+        /// superset — directory may be missing files (skipped), no unknown files allowed.
+        ///            Best for checking old versions that predate newly-added fixtures.
+        /// exact    — directory must match current fixtures 1:1. No extras, no missing.
+        /// subset   — directory may have extra files (skipped), all known must be present.
+        #[arg(long, default_value = "superset", value_name = "MODE")]
+        mode: check::Mode,
+
+        /// Fixture name substrings to exclude from checking (comma-separated).
+        #[arg(long, value_delimiter = ',', value_name = "PATTERNS")]
+        exclude: Vec<String>,
+    },
+}
+
+fn main() -> VortexResult<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Generate { output, exclude } => generate::generate(&output, &exclude),
+        Commands::Check { dir, mode, exclude } => check::check(&dir, mode, &exclude),
+    }
+}
diff --git a/vortex-test/compat-gen/src/manifest.rs b/vortex-test/compat-gen/src/manifest.rs
new file mode 100644
index 00000000000..060760c88d2
--- /dev/null
+++ b/vortex-test/compat-gen/src/manifest.rs
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/// One entry in the fixture manifest.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FixtureEntry {
+    /// Filename, e.g. "primitives.vortex".
+    pub name: String,
+    /// Short description of what this fixture tests.
+    pub description: String,
+}
diff --git a/vortex-test/e2e/src/lib.rs b/vortex-test/e2e/src/lib.rs
deleted file mode 100644
index a77421748eb..00000000000
--- a/vortex-test/e2e/src/lib.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! End-to-end tests for Vortex.
-
-#[cfg(test)]
-mod tests {
-    use vortex::VortexSessionDefault;
-    use vortex::array::IntoArray;
-    use vortex::array::arrays::PrimitiveArray;
-    use vortex::array::validity::Validity;
-    use vortex::buffer::Buffer;
-    use vortex::buffer::ByteBufferMut;
-    use vortex::error::VortexResult;
-    use vortex::file::WriteOptionsSessionExt;
-    use vortex::session::VortexSession;
-
-    /// Test that compression produces deterministic results.
-    #[tokio::test]
-    async fn test_compression_determinism() -> VortexResult<()> {
-        // Create a deterministic array with linear-with-noise pattern
-        let values: Vec<i64> = (0i64..100_000).map(|i| i + (i * 7 + 3) % 11).collect();
-
-        let array =
-            PrimitiveArray::new(Buffer::from_iter(values), Validity::NonNullable).into_array();
-
-        // Write concurrently and verify all sizes match expected
-        let futures: Vec<_> = (0..5)
-            .map(|_| {
-                let array = array.clone();
-                async move {
-                    let session = VortexSession::default();
-                    let mut buf = ByteBufferMut::empty();
-                    session
-                        .write_options()
-                        .write(&mut buf, array.to_array_stream())
-                        .await?;
-                    VortexResult::Ok(buf.len())
-                }
-            })
-            .collect();
-
-        #[cfg(feature = "unstable_encodings")]
-        const EXPECTED_SIZE: usize = 216052;
-        #[cfg(not(feature = "unstable_encodings"))]
-        const EXPECTED_SIZE: usize = 216020;
-
-        let sizes = futures::future::try_join_all(futures).await?;
-        for (i, size) in sizes.iter().enumerate() {
-            assert_eq!(
-                *size, EXPECTED_SIZE,
-                "Run {i} compressed the array to {size} bytes instead of the expected {EXPECTED_SIZE}."
-            );
-        }
-
-        Ok(())
-    }
-}
diff --git a/vortex-tui/.gitignore b/vortex-tui/.gitignore
new file mode 100644
index 00000000000..beeb42ab25f
--- /dev/null
+++ b/vortex-tui/.gitignore
@@ -0,0 +1 @@
+web/pkg/
diff --git a/vortex-tui/Cargo.toml b/vortex-tui/Cargo.toml
index a6ef5f61bbc..ad4d0b052f2 100644
--- a/vortex-tui/Cargo.toml
+++ b/vortex-tui/Cargo.toml
@@ -13,32 +13,82 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[features]
+default = ["native"]
+native = [
+    "dep:arrow-array",
+    "dep:arrow-schema",
+    "dep:clap",
+    "dep:crossterm",
+    "dep:datafusion",
+    "dep:env_logger",
+    "dep:indicatif",
+    "dep:parquet",
+    "dep:tokio",
+    "dep:vortex-datafusion",
+    "ratatui/crossterm",
+    "vortex/tokio",
+    "vortex/zstd",
+]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[[bin]]
+name = "vx"
+path = "src/main.rs"
+required-features = ["native"]
+
 [dependencies]
+# Shared dependencies
 anyhow = { workspace = true }
-arrow-array = { workspace = true }
-arrow-schema = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-crossterm = { workspace = true }
-datafusion = { workspace = true }
-env_logger = { version = "0.11" }
 flatbuffers = { workspace = true }
-futures = { workspace = true, features = ["executor"] }
+futures = { workspace = true }
 fuzzy-matcher = { workspace = true }
 humansize = { workspace = true }
-indicatif = { workspace = true, features = ["futures"] }
 itertools = { workspace = true }
-parquet = { workspace = true, features = ["arrow", "async"] }
 ratatui = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 taffy = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread"] }
-vortex = { workspace = true, features = ["tokio"] }
-vortex-datafusion = { workspace = true }
+vortex = { version = "0.1.0", path = "../vortex", default-features = false, features = [
+    "files",
+] }
+
+# Native-only dependencies (gated behind "native" feature)
+arrow-array = { workspace = true, optional = true }
+arrow-schema = { workspace = true, optional = true }
+clap = { workspace = true, features = ["derive"], optional = true }
+crossterm = { workspace = true, features = ["event-stream"], optional = true }
+datafusion = { workspace = true, optional = true }
+env_logger = { workspace = true, optional = true }
+indicatif = { workspace = true, features = ["futures"], optional = true }
+parquet = { workspace = true, features = ["arrow", "async"], optional = true }
+tokio = { workspace = true, features = [
+    "rt-multi-thread",
+    "macros",
+], optional = true }
+vortex-datafusion = { workspace = true, optional = true }
+
+# WASM-only dependencies
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+console_error_panic_hook = "0.1.7"
+js-sys = "0.3.81"
+ratzilla = "0.3"
+wasm-bindgen = "0.2.104"
+wasm-bindgen-futures = { workspace = true }
+web-sys = { version = "0.3.81", features = [
+    "console",
+    "DataTransfer",
+    "Document",
+    "DragEvent",
+    "Element",
+    "File",
+    "FileReader",
+    "HtmlElement",
+    "HtmlInputElement",
+    "Window",
+] }
 
 [lints]
 workspace = true
-
-[[bin]]
-name = "vx"
-path = "src/main.rs"
diff --git a/vortex-tui/Makefile b/vortex-tui/Makefile
new file mode 100644
index 00000000000..317ed0ac610
--- /dev/null
+++ b/vortex-tui/Makefile
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+.PHONY: serve clean-web
+
+web/pkg: src/**/*.rs Cargo.toml
+	wasm-pack build --target web --no-default-features --out-dir web/pkg
+
+serve: web/pkg
+	@echo "Open http://localhost:8000"
+	cd web && python3 -m http.server
+
+clean-web:
+	rm -rf web/pkg
diff --git a/vortex-tui/README.md b/vortex-tui/README.md
index 6a8576565c7..4a220c63fe8 100644
--- a/vortex-tui/README.md
+++ b/vortex-tui/README.md
@@ -107,6 +107,32 @@ vx convert input.parquet --out output.vortex
 vx convert input.parquet --out output.vortex --compress
 ```
 
+## Browser (WASM)
+
+The TUI browser can also run in a web browser via WebAssembly. Users can drag-and-drop a `.vtx`
+file onto a web page and interactively explore it using the same Layout and Segments tabs.
+
+### Quick start
+
+```bash
+# From the vortex-tui directory:
+make serve
+```
+
+This builds the WASM package and starts a local server at `http://localhost:8000`.
+
+Requires `wasm-pack` (`cargo install wasm-pack`).
+
+### How it works
+
+- **Native** builds use `crossterm` for terminal I/O and `CurrentThreadRuntime` (smol-based) for
+  async execution. The `native` feature (enabled by default) pulls in DataFusion, crossterm, and
+  other native-only dependencies.
+- **WASM** builds use [ratzilla](https://github.com/ratatui/ratzilla) (the official ratatui web
+  backend) for rendering and `WasmRuntime` for async execution. Building with
+  `--no-default-features` excludes all native-only dependencies.
+- The Query tab (DataFusion SQL) is only available in native builds.
+
 ## Development
 
 TODO:
diff --git a/vortex-tui/public-api.lock b/vortex-tui/public-api.lock
index bf9f7b41a17..efa1dee3b87 100644
--- a/vortex-tui/public-api.lock
+++ b/vortex-tui/public-api.lock
@@ -94,8 +94,6 @@ pub fn vortex_tui::browse::app::LayoutCursor::dtype(&self) -> &vortex_array::dty
 
 pub fn vortex_tui::browse::app::LayoutCursor::flat_layout_metadata_info(&self) -> alloc::string::String
 
-pub fn vortex_tui::browse::app::LayoutCursor::flatbuffer_size(&self) -> usize
-
 pub fn vortex_tui::browse::app::LayoutCursor::is_stats_table(&self) -> bool
 
 pub fn vortex_tui::browse::app::LayoutCursor::layout(&self) -> &vortex_layout::layout::LayoutRef
diff --git a/vortex-tui/src/browse/app.rs b/vortex-tui/src/browse/app.rs
index b892c529ab4..0a7f13ab277 100644
--- a/vortex-tui/src/browse/app.rs
+++ b/vortex-tui/src/browse/app.rs
@@ -3,29 +3,24 @@
 
 //! Application state and data structures for the TUI browser.
 
-use std::path::Path;
 use std::sync::Arc;
 
-use futures::executor::block_on;
 use ratatui::prelude::Size;
 use ratatui::widgets::ListState;
-use vortex::array::serde::ArrayParts;
+use vortex::array::ArrayRef;
 use vortex::dtype::DType;
 use vortex::error::VortexExpect;
-use vortex::error::VortexResult;
 use vortex::file::Footer;
-use vortex::file::OpenOptionsSessionExt;
 use vortex::file::SegmentSpec;
 use vortex::file::VortexFile;
 use vortex::layout::LayoutRef;
 use vortex::layout::VTable;
-use vortex::layout::layouts::flat::FlatVTable;
-use vortex::layout::layouts::zoned::ZonedVTable;
+use vortex::layout::layouts::flat::Flat;
+use vortex::layout::layouts::zoned::Zoned;
 use vortex::layout::segments::SegmentId;
 use vortex::layout::segments::SegmentSource;
 use vortex::session::VortexSession;
 
-use super::ui::QueryState;
 use super::ui::SegmentGridState;
 
 /// The currently active tab in the TUI browser.
@@ -44,6 +39,7 @@ pub enum Tab {
     Segments,
 
     /// SQL query interface powered by DataFusion.
+    #[cfg(feature = "native")]
     Query,
 }
 
@@ -65,7 +61,7 @@ impl LayoutCursor {
     pub fn new(footer: Footer, segment_source: Arc<dyn SegmentSource>) -> Self {
         Self {
             path: Vec::new(),
-            layout: footer.layout().clone(),
+            layout: Arc::clone(footer.layout()),
             segment_map: Arc::clone(footer.segment_map()),
             footer,
             segment_source,
@@ -80,7 +76,7 @@ impl LayoutCursor {
         segment_source: Arc<dyn SegmentSource>,
         path: Vec<usize>,
     ) -> Self {
-        let mut layout = footer.layout().clone();
+        let mut layout = Arc::clone(footer.layout());
 
         // Traverse the layout tree at each element of the path.
         for component in path.iter().copied() {
@@ -103,7 +99,7 @@ impl LayoutCursor {
         let mut path = self.path.clone();
         path.push(n);
 
-        Self::new_with_path(self.footer.clone(), self.segment_source.clone(), path)
+        Self::new_with_path(self.footer.clone(), Arc::clone(&self.segment_source), path)
     }
 
     /// Create a new cursor pointing at the parent of the current layout.
@@ -113,32 +109,17 @@ impl LayoutCursor {
         let mut path = self.path.clone();
         path.pop();
 
-        Self::new_with_path(self.footer.clone(), self.segment_source.clone(), path)
-    }
-
-    /// Get the size of the array flatbuffer for this layout.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the current layout is not a [`FlatVTable`] layout.
-    pub fn flatbuffer_size(&self) -> usize {
-        let segment_id = self.layout.as_::<FlatVTable>().segment_id();
-        let segment = block_on(self.segment_source.request(segment_id))
-            .vortex_expect("operation should succeed in TUI");
-        ArrayParts::try_from(segment)
-            .vortex_expect("operation should succeed in TUI")
-            .metadata()
-            .len()
+        Self::new_with_path(self.footer.clone(), Arc::clone(&self.segment_source), path)
     }
 
     /// Get a human-readable description of the flat layout metadata.
     ///
     /// # Panics
     ///
-    /// Panics if the current layout is not a [`FlatVTable`] layout.
+    /// Panics if the current layout is not a [`Flat`] layout.
     pub fn flat_layout_metadata_info(&self) -> String {
-        let flat_layout = self.layout.as_::<FlatVTable>();
-        let metadata = FlatVTable::metadata(flat_layout);
+        let flat_layout = self.layout.as_::<Flat>();
+        let metadata = Flat::metadata(flat_layout);
 
         match metadata.0.array_encoding_tree.as_ref() {
             Some(tree) => {
@@ -170,10 +151,10 @@ impl LayoutCursor {
 
     /// Returns `true` if the cursor is currently pointing at a statistics table.
     ///
-    /// A statistics table is the second child of a [`ZonedVTable`] layout.
+    /// A statistics table is the second child of a [`Zoned`] layout.
     pub fn is_stats_table(&self) -> bool {
         let parent = self.parent();
-        parent.layout().is::<ZonedVTable>() && self.path.last().copied().unwrap_or_default() == 1
+        parent.layout().is::<Zoned>() && self.path.last().copied().unwrap_or_default() == 1
     }
 
     /// Get the data type of the current layout.
@@ -222,9 +203,9 @@ pub enum KeyMode {
 ///
 /// The state is preserved when switching between tabs, allowing users to return to their previous
 /// position.
-pub struct AppState<'a> {
+pub struct AppState {
     /// The Vortex session used to read array data during rendering.
-    pub session: &'a VortexSession,
+    pub session: VortexSession,
 
     /// The current input mode (normal navigation or search).
     pub key_mode: KeyMode,
@@ -251,7 +232,7 @@ pub struct AppState<'a> {
     pub layouts_list_state: ListState,
 
     /// State for the segment grid display.
-    pub segment_grid_state: SegmentGridState<'a>,
+    pub segment_grid_state: SegmentGridState,
 
     /// The size of the last rendered frame.
     pub frame_size: Size,
@@ -259,23 +240,35 @@ pub struct AppState<'a> {
     /// Vertical scroll offset for the encoding tree display in flat layout view.
     pub tree_scroll_offset: u16,
 
-    /// State for the Query tab
-    pub query_state: QueryState,
+    /// Cached array data for the current FlatLayout, loaded asynchronously on WASM.
+    pub cached_flat_array: Option<ArrayRef>,
+
+    /// Cached flatbuffer size for the current FlatLayout, loaded asynchronously on WASM.
+    pub cached_flatbuffer_size: Option<usize>,
 
-    /// File path for use in query execution
+    /// State for the Query tab.
+    #[cfg(feature = "native")]
+    pub query_state: super::ui::QueryState,
+
+    /// File path for use in query execution.
+    #[cfg(feature = "native")]
     pub file_path: String,
 }
 
-impl<'a> AppState<'a> {
-    /// Create a new application state by opening a Vortex file.
+impl AppState {
+    /// Create a new application state by opening a Vortex file from a path.
     ///
     /// # Errors
     ///
     /// Returns an error if the file cannot be opened or read.
+    #[cfg(feature = "native")]
     pub async fn new(
-        session: &'a VortexSession,
-        path: impl AsRef<Path>,
-    ) -> VortexResult<AppState<'a>> {
+        session: &VortexSession,
+        path: impl AsRef<std::path::Path>,
+    ) -> vortex::error::VortexResult<AppState> {
+        use vortex::file::OpenOptionsSessionExt;
+
+        let session = session.clone();
         let vxf = session.open_options().open_path(path.as_ref()).await?;
 
         let cursor = LayoutCursor::new(vxf.footer().clone(), vxf.segment_source());
@@ -298,11 +291,45 @@ impl<'a> AppState<'a> {
             segment_grid_state: SegmentGridState::default(),
             frame_size: Size::new(0, 0),
             tree_scroll_offset: 0,
-            query_state: QueryState::default(),
+            cached_flat_array: None,
+            cached_flatbuffer_size: None,
+            query_state: super::ui::QueryState::default(),
             file_path,
         })
     }
 
+    /// Create a new application state from an in-memory buffer.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the buffer does not contain a valid Vortex file.
+    #[cfg(target_arch = "wasm32")]
+    pub fn from_buffer(
+        session: VortexSession,
+        buffer: vortex::buffer::ByteBuffer,
+    ) -> vortex::error::VortexResult<AppState> {
+        use vortex::file::OpenOptionsSessionExt;
+
+        let vxf = session.open_options().open_buffer(buffer)?;
+        let cursor = LayoutCursor::new(vxf.footer().clone(), vxf.segment_source());
+
+        Ok(AppState {
+            session,
+            vxf,
+            cursor,
+            key_mode: KeyMode::default(),
+            search_filter: String::new(),
+            filter: None,
+            current_tab: Tab::default(),
+            layouts_list_state: ListState::default().with_selected(Some(0)),
+            segment_grid_state: SegmentGridState::default(),
+            frame_size: Size::new(0, 0),
+            tree_scroll_offset: 0,
+            cached_flat_array: None,
+            cached_flatbuffer_size: None,
+        })
+    }
+
     /// Clear the current search filter and return to showing all children.
     pub fn clear_search(&mut self) {
         self.search_filter.clear();
@@ -312,8 +339,55 @@ impl<'a> AppState<'a> {
     /// Reset the layout view state after navigating to a different layout.
     ///
     /// This resets the list selection to the first item and clears any scroll offset.
+    /// The caller is responsible for awaiting `load_flat_data()` afterward if the
+    /// new layout is a [`Flat`].
     pub fn reset_layout_view_state(&mut self) {
         self.layouts_list_state = ListState::default().with_selected(Some(0));
         self.tree_scroll_offset = 0;
+        self.cached_flat_array = None;
+        self.cached_flatbuffer_size = None;
+    }
+
+    /// Asynchronously load and cache the flat layout array data and flatbuffer size.
+    #[cfg(feature = "native")]
+    pub(crate) async fn load_flat_data(&mut self) {
+        use vortex::array::MaskFuture;
+        use vortex::array::serde::SerializedArray;
+        use vortex::expr::root;
+
+        let layout = &Arc::clone(self.cursor.layout());
+        let row_count = layout.row_count();
+
+        // Load the array.
+        let reader = layout
+            .new_reader("".into(), self.vxf.segment_source(), &self.session)
+            .vortex_expect("Failed to create reader");
+        let array = reader
+            .projection_evaluation(
+                &(0..row_count),
+                &root(),
+                MaskFuture::new_true(
+                    usize::try_from(row_count).vortex_expect("row_count overflowed usize"),
+                ),
+            )
+            .vortex_expect("Failed to construct projection")
+            .await
+            .vortex_expect("Failed to read flat array");
+        self.cached_flat_array = Some(array);
+
+        // Load the flatbuffer size.
+        let segment_id = layout.as_::<Flat>().segment_id();
+        let segment = self
+            .cursor
+            .segment_source
+            .request(segment_id)
+            .await
+            .vortex_expect("Failed to read segment");
+        self.cached_flatbuffer_size = Some(
+            SerializedArray::try_from(segment)
+                .vortex_expect("Failed to parse segment")
+                .metadata()
+                .len(),
+        );
     }
 }
diff --git a/vortex-tui/src/browse/input.rs b/vortex-tui/src/browse/input.rs
new file mode 100644
index 00000000000..fbcef0a516a
--- /dev/null
+++ b/vortex-tui/src/browse/input.rs
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Platform-agnostic key event abstraction for the TUI browser.
+
+/// A platform-agnostic key event.
+pub(crate) struct InputEvent {
+    /// The key code.
+    pub code: InputKeyCode,
+    /// Whether Ctrl is held.
+    pub ctrl: bool,
+    /// Whether Alt is held.
+    pub alt: bool,
+    /// Whether Shift is held.
+    pub shift: bool,
+}
+
+/// A platform-agnostic key code.
+pub(crate) enum InputKeyCode {
+    /// A character key.
+    Char(char),
+    /// Up arrow.
+    Up,
+    /// Down arrow.
+    Down,
+    /// Left arrow.
+    Left,
+    /// Right arrow.
+    Right,
+    /// Enter/Return.
+    Enter,
+    /// Escape.
+    Esc,
+    /// Tab.
+    Tab,
+    /// Page Up.
+    PageUp,
+    /// Page Down.
+    PageDown,
+    /// Home.
+    Home,
+    /// End.
+    End,
+    /// Backspace.
+    Backspace,
+    /// Delete.
+    Delete,
+    /// Any other unrecognized key.
+    Other,
+}
+
+#[cfg(feature = "native")]
+impl From<crossterm::event::KeyEvent> for InputEvent {
+    fn from(key: crossterm::event::KeyEvent) -> Self {
+        use crossterm::event::KeyCode;
+        use crossterm::event::KeyModifiers;
+
+        let code = match key.code {
+            KeyCode::Char(c) => InputKeyCode::Char(c),
+            KeyCode::Up => InputKeyCode::Up,
+            KeyCode::Down => InputKeyCode::Down,
+            KeyCode::Left => InputKeyCode::Left,
+            KeyCode::Right => InputKeyCode::Right,
+            KeyCode::Enter => InputKeyCode::Enter,
+            KeyCode::Esc => InputKeyCode::Esc,
+            KeyCode::Tab => InputKeyCode::Tab,
+            KeyCode::PageUp => InputKeyCode::PageUp,
+            KeyCode::PageDown => InputKeyCode::PageDown,
+            KeyCode::Home => InputKeyCode::Home,
+            KeyCode::End => InputKeyCode::End,
+            KeyCode::Backspace => InputKeyCode::Backspace,
+            KeyCode::Delete => InputKeyCode::Delete,
+            _ => InputKeyCode::Other,
+        };
+
+        InputEvent {
+            code,
+            ctrl: key.modifiers.contains(KeyModifiers::CONTROL),
+            alt: key.modifiers.contains(KeyModifiers::ALT),
+            shift: key.modifiers.contains(KeyModifiers::SHIFT),
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+impl From<web_sys::KeyboardEvent> for InputEvent {
+    fn from(event: web_sys::KeyboardEvent) -> Self {
+        let key = event.key();
+        let code = if key.len() == 1 {
+            match key.chars().next() {
+                Some(c) => InputKeyCode::Char(c),
+                None => InputKeyCode::Other,
+            }
+        } else {
+            match key.as_str() {
+                "ArrowUp" => InputKeyCode::Up,
+                "ArrowDown" => InputKeyCode::Down,
+                "ArrowLeft" => InputKeyCode::Left,
+                "ArrowRight" => InputKeyCode::Right,
+                "Enter" => InputKeyCode::Enter,
+                "Escape" => InputKeyCode::Esc,
+                "Tab" => InputKeyCode::Tab,
+                "PageUp" => InputKeyCode::PageUp,
+                "PageDown" => InputKeyCode::PageDown,
+                "Home" => InputKeyCode::Home,
+                "End" => InputKeyCode::End,
+                "Backspace" => InputKeyCode::Backspace,
+                "Delete" => InputKeyCode::Delete,
+                _ => InputKeyCode::Other,
+            }
+        };
+
+        InputEvent {
+            code,
+            ctrl: event.ctrl_key(),
+            alt: event.alt_key(),
+            shift: event.shift_key(),
+        }
+    }
+}
diff --git a/vortex-tui/src/browse/mod.rs b/vortex-tui/src/browse/mod.rs
index adeb0bb4da0..fb3d279bfa0 100644
--- a/vortex-tui/src/browse/mod.rs
+++ b/vortex-tui/src/browse/mod.rs
@@ -3,26 +3,16 @@
 
 //! Interactive TUI browser for Vortex files.
 
-use std::path::Path;
-
 use app::AppState;
 use app::KeyMode;
 use app::Tab;
-use crossterm::event;
-use crossterm::event::Event;
-use crossterm::event::KeyCode;
-use crossterm::event::KeyEventKind;
-use crossterm::event::KeyModifiers;
-use ratatui::DefaultTerminal;
-use ui::QueryFocus;
-use ui::SortDirection;
-use ui::render_app;
+use input::InputEvent;
+use input::InputKeyCode;
 use vortex::error::VortexExpect;
-use vortex::error::VortexResult;
-use vortex::layout::layouts::flat::FlatVTable;
-use vortex::session::VortexSession;
+use vortex::layout::layouts::flat::Flat;
 
 pub mod app;
+pub(crate) mod input;
 pub mod ui;
 
 /// Scroll amount for single-line navigation (up/down arrows).
@@ -38,27 +28,7 @@ const SEGMENT_SCROLL_HORIZONTAL_STEP: usize = 20;
 /// Scroll amount for segment grid horizontal jump (Home/End).
 const SEGMENT_SCROLL_HORIZONTAL_JUMP: usize = 200;
 
-// Use the VortexResult and potentially launch a Backtrace.
-async fn run(mut terminal: DefaultTerminal, mut app: AppState<'_>) -> VortexResult<()> {
-    loop {
-        terminal.draw(|frame| render_app(&mut app, frame))?;
-
-        let event = event::read()?;
-        let event_result = match app.key_mode {
-            KeyMode::Normal => handle_normal_mode(&mut app, event),
-            KeyMode::Search => handle_search_mode(&mut app, event),
-        };
-
-        match event_result {
-            HandleResult::Exit => {
-                return Ok(());
-            }
-            HandleResult::Continue => { /* continue execution */ }
-        }
-    }
-}
-
-enum HandleResult {
+pub(crate) enum HandleResult {
     Continue,
     Exit,
 }
@@ -66,7 +36,7 @@ enum HandleResult {
 /// Navigate the layout list up by the given amount.
 fn navigate_layout_up(app: &mut AppState, amount: usize) {
     let amount_u16 = amount.try_into().unwrap_or(u16::MAX);
-    if app.cursor.layout().is::<FlatVTable>() {
+    if app.cursor.layout().is::<Flat>() {
         app.tree_scroll_offset = app.tree_scroll_offset.saturating_sub(amount_u16);
     } else {
         app.layouts_list_state.scroll_up_by(amount_u16);
@@ -76,313 +46,404 @@ fn navigate_layout_up(app: &mut AppState, amount: usize) {
 /// Navigate the layout list down by the given amount.
 fn navigate_layout_down(app: &mut AppState, amount: usize) {
     let amount_u16 = amount.try_into().unwrap_or(u16::MAX);
-    if app.cursor.layout().is::<FlatVTable>() {
+    if app.cursor.layout().is::<Flat>() {
         app.tree_scroll_offset = app.tree_scroll_offset.saturating_add(amount_u16);
     } else {
         app.layouts_list_state.scroll_down_by(amount_u16);
     }
 }
 
+/// Handle a key event in normal input mode.
+///
+/// Returns [`HandleResult::Exit`] if the user pressed the quit key.
 #[allow(clippy::cognitive_complexity)]
-fn handle_normal_mode(app: &mut AppState, event: Event) -> HandleResult {
-    if let Event::Key(key) = event
-        && key.kind == KeyEventKind::Press
+pub(crate) fn handle_normal_mode(app: &mut AppState, event: InputEvent) -> HandleResult {
+    // Check if we're in Query tab with SQL input focus - handle text input first
+    #[cfg(feature = "native")]
     {
-        // Check if we're in Query tab with SQL input focus - handle text input first
+        use ui::QueryFocus;
+        use ui::SortDirection;
+
         let in_sql_input =
             app.current_tab == Tab::Query && app.query_state.focus == QueryFocus::SqlInput;
 
-        // Handle SQL input mode - most keys should type into the input
         if in_sql_input {
-            match (key.code, key.modifiers) {
-                // These keys exit/switch even in SQL input mode
-                (KeyCode::Tab, _) => {
+            match (&event.code, event.ctrl, event.alt, event.shift) {
+                (InputKeyCode::Tab, ..) => {
                     app.current_tab = Tab::Layout;
                 }
-                (KeyCode::Esc, _) => {
+                (InputKeyCode::Esc, ..) => {
                     app.query_state.toggle_focus();
                 }
-                (KeyCode::Enter, _) => {
-                    // Execute the SQL query with COUNT(*) for pagination
+                (InputKeyCode::Enter, ..) => {
                     app.query_state.sort_column = None;
                     app.query_state.sort_direction = SortDirection::None;
-                    let file_path = app.file_path.clone();
-                    app.query_state
-                        .execute_initial_query(app.session, &file_path);
-                    // Switch focus to results table after executing
+                    app.query_state.prepare_initial_query();
                     app.query_state.focus = QueryFocus::ResultsTable;
                 }
-                // Navigation keys
-                (KeyCode::Left, _) => app.query_state.move_cursor_left(),
-                (KeyCode::Right, _) => app.query_state.move_cursor_right(),
-                (KeyCode::Home, _) => app.query_state.move_cursor_start(),
-                (KeyCode::End, _) => app.query_state.move_cursor_end(),
-                // Control key shortcuts
-                (KeyCode::Char('a'), KeyModifiers::CONTROL) => app.query_state.move_cursor_start(),
-                (KeyCode::Char('e'), KeyModifiers::CONTROL) => app.query_state.move_cursor_end(),
-                (KeyCode::Char('u'), KeyModifiers::CONTROL) => app.query_state.clear_input(),
-                (KeyCode::Char('b'), KeyModifiers::CONTROL) => app.query_state.move_cursor_left(),
-                (KeyCode::Char('f'), KeyModifiers::CONTROL) => app.query_state.move_cursor_right(),
-                (KeyCode::Char('d'), KeyModifiers::CONTROL) => {
-                    app.query_state.delete_char_forward()
-                }
-                // Delete keys
-                (KeyCode::Backspace, _) => app.query_state.delete_char(),
-                (KeyCode::Delete, _) => app.query_state.delete_char_forward(),
-                // All other characters get typed into the input
-                (KeyCode::Char(c), KeyModifiers::NONE | KeyModifiers::SHIFT) => {
-                    app.query_state.insert_char(c);
+                (InputKeyCode::Left, ..) => app.query_state.move_cursor_left(),
+                (InputKeyCode::Right, ..) => app.query_state.move_cursor_right(),
+                (InputKeyCode::Home, ..) => app.query_state.move_cursor_start(),
+                (InputKeyCode::End, ..) => app.query_state.move_cursor_end(),
+                (InputKeyCode::Char('a'), true, ..) => app.query_state.move_cursor_start(),
+                (InputKeyCode::Char('e'), true, ..) => app.query_state.move_cursor_end(),
+                (InputKeyCode::Char('u'), true, ..) => app.query_state.clear_input(),
+                (InputKeyCode::Char('b'), true, ..) => app.query_state.move_cursor_left(),
+                (InputKeyCode::Char('f'), true, ..) => app.query_state.move_cursor_right(),
+                (InputKeyCode::Char('d'), true, ..) => app.query_state.delete_char_forward(),
+                (InputKeyCode::Backspace, ..) => app.query_state.delete_char(),
+                (InputKeyCode::Delete, ..) => app.query_state.delete_char_forward(),
+                (InputKeyCode::Char(c), false, false, _) => {
+                    app.query_state.insert_char(*c);
                 }
                 _ => {}
             }
             return HandleResult::Continue;
         }
+    }
 
-        // Normal mode handling for all other cases
-        match (key.code, key.modifiers) {
-            (KeyCode::Char('q'), _) => {
-                return HandleResult::Exit;
-            }
-            (KeyCode::Tab, _) => {
-                app.current_tab = match app.current_tab {
-                    Tab::Layout => Tab::Segments,
-                    Tab::Segments => Tab::Query,
-                    Tab::Query => Tab::Layout,
-                };
-            }
+    match (&event.code, event.ctrl, event.alt, event.shift) {
+        (InputKeyCode::Char('q'), ..) => {
+            return HandleResult::Exit;
+        }
+        (InputKeyCode::Tab, ..) => {
+            app.current_tab = match app.current_tab {
+                Tab::Layout => Tab::Segments,
+                #[cfg(feature = "native")]
+                Tab::Segments => Tab::Query,
+                #[cfg(feature = "native")]
+                Tab::Query => Tab::Layout,
+                #[cfg(not(feature = "native"))]
+                Tab::Segments => Tab::Layout,
+            };
+        }
 
-            // Query tab: '[' for previous page
-            (KeyCode::Char('['), KeyModifiers::NONE) => {
-                if app.current_tab == Tab::Query {
-                    app.query_state
-                        .prev_page(app.session, &app.file_path.clone());
-                }
+        #[cfg(feature = "native")]
+        (InputKeyCode::Char('['), false, false, _) => {
+            if app.current_tab == Tab::Query {
+                app.query_state.prepare_prev_page();
             }
+        }
 
-            // Query tab: ']' for next page
-            (KeyCode::Char(']'), KeyModifiers::NONE) => {
-                if app.current_tab == Tab::Query {
-                    app.query_state
-                        .next_page(app.session, &app.file_path.clone());
-                }
+        #[cfg(feature = "native")]
+        (InputKeyCode::Char(']'), false, false, _) => {
+            if app.current_tab == Tab::Query {
+                app.query_state.prepare_next_page();
             }
+        }
 
-            (KeyCode::Up | KeyCode::Char('k'), _) | (KeyCode::Char('p'), KeyModifiers::CONTROL) => {
-                match app.current_tab {
-                    Tab::Layout => navigate_layout_up(app, SCROLL_LINE),
-                    Tab::Segments => app.segment_grid_state.scroll_up(SEGMENT_SCROLL_LINE),
-                    Tab::Query => {
-                        app.query_state.table_state.select_previous();
-                    }
-                }
-            }
-            (KeyCode::Down | KeyCode::Char('j'), _)
-            | (KeyCode::Char('n'), KeyModifiers::CONTROL) => match app.current_tab {
-                Tab::Layout => navigate_layout_down(app, SCROLL_LINE),
-                Tab::Segments => app.segment_grid_state.scroll_down(SEGMENT_SCROLL_LINE),
-                Tab::Query => {
-                    app.query_state.table_state.select_next();
-                }
-            },
-            (KeyCode::PageUp, _) | (KeyCode::Char('v'), KeyModifiers::ALT) => {
-                match app.current_tab {
-                    Tab::Layout => navigate_layout_up(app, SCROLL_PAGE),
-                    Tab::Segments => app.segment_grid_state.scroll_up(SEGMENT_SCROLL_PAGE),
-                    Tab::Query => {
-                        app.query_state
-                            .prev_page(app.session, &app.file_path.clone());
-                    }
-                }
+        (InputKeyCode::Up, ..)
+        | (InputKeyCode::Char('k'), false, false, _)
+        | (InputKeyCode::Char('p'), true, ..) => match app.current_tab {
+            Tab::Layout => navigate_layout_up(app, SCROLL_LINE),
+            Tab::Segments => app.segment_grid_state.scroll_up(SEGMENT_SCROLL_LINE),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                app.query_state.table_state.select_previous();
             }
-            (KeyCode::PageDown, _) | (KeyCode::Char('v'), KeyModifiers::CONTROL) => {
-                match app.current_tab {
-                    Tab::Layout => navigate_layout_down(app, SCROLL_PAGE),
-                    Tab::Segments => app.segment_grid_state.scroll_down(SEGMENT_SCROLL_PAGE),
-                    Tab::Query => {
-                        app.query_state
-                            .next_page(app.session, &app.file_path.clone());
-                    }
-                }
+        },
+        (InputKeyCode::Down, ..)
+        | (InputKeyCode::Char('j'), false, false, _)
+        | (InputKeyCode::Char('n'), true, ..) => match app.current_tab {
+            Tab::Layout => navigate_layout_down(app, SCROLL_LINE),
+            Tab::Segments => app.segment_grid_state.scroll_down(SEGMENT_SCROLL_LINE),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                app.query_state.table_state.select_next();
             }
-            (KeyCode::Home, _) | (KeyCode::Char('<'), KeyModifiers::ALT) => match app.current_tab {
-                Tab::Layout => app.layouts_list_state.select_first(),
-                Tab::Segments => app
-                    .segment_grid_state
-                    .scroll_left(SEGMENT_SCROLL_HORIZONTAL_JUMP),
+        },
+        (InputKeyCode::PageUp, ..) | (InputKeyCode::Char('v'), _, true, _) => {
+            match app.current_tab {
+                Tab::Layout => navigate_layout_up(app, SCROLL_PAGE),
+                Tab::Segments => app.segment_grid_state.scroll_up(SEGMENT_SCROLL_PAGE),
+                #[cfg(feature = "native")]
                 Tab::Query => {
-                    app.query_state.table_state.select_first();
-                }
-            },
-            (KeyCode::End, _) | (KeyCode::Char('>'), KeyModifiers::ALT) => match app.current_tab {
-                Tab::Layout => app.layouts_list_state.select_last(),
-                Tab::Segments => app
-                    .segment_grid_state
-                    .scroll_right(SEGMENT_SCROLL_HORIZONTAL_JUMP),
-                Tab::Query => {
-                    app.query_state.table_state.select_last();
-                }
-            },
-            (KeyCode::Enter, _) => {
-                if app.current_tab == Tab::Layout && app.cursor.layout().nchildren() > 0 {
-                    // Descend into the layout subtree for the selected child.
-                    let selected = app.layouts_list_state.selected().unwrap_or_default();
-                    app.cursor = app.cursor.child(selected);
-                    app.reset_layout_view_state();
+                    app.query_state.prepare_prev_page();
                 }
             }
-            (KeyCode::Left | KeyCode::Char('h'), _)
-            | (KeyCode::Char('b'), KeyModifiers::CONTROL) => match app.current_tab {
-                Tab::Layout => {
-                    app.cursor = app.cursor.parent();
-                    app.reset_layout_view_state();
-                }
-                Tab::Segments => app
-                    .segment_grid_state
-                    .scroll_left(SEGMENT_SCROLL_HORIZONTAL_STEP),
+        }
+        (InputKeyCode::PageDown, ..) | (InputKeyCode::Char('v'), true, ..) => {
+            match app.current_tab {
+                Tab::Layout => navigate_layout_down(app, SCROLL_PAGE),
+                Tab::Segments => app.segment_grid_state.scroll_down(SEGMENT_SCROLL_PAGE),
+                #[cfg(feature = "native")]
                 Tab::Query => {
-                    app.query_state.horizontal_scroll =
-                        app.query_state.horizontal_scroll.saturating_sub(1);
-                }
-            },
-            (KeyCode::Right | KeyCode::Char('l'), _) | (KeyCode::Char('b'), KeyModifiers::ALT) => {
-                match app.current_tab {
-                    Tab::Layout => {}
-                    Tab::Segments => app
-                        .segment_grid_state
-                        .scroll_right(SEGMENT_SCROLL_HORIZONTAL_STEP),
-                    Tab::Query => {
-                        let max_col = app.query_state.column_count().saturating_sub(1);
-                        if app.query_state.horizontal_scroll < max_col {
-                            app.query_state.horizontal_scroll += 1;
-                        }
-                    }
+                    app.query_state.prepare_next_page();
                 }
             }
-
-            (KeyCode::Char('/'), _) | (KeyCode::Char('s'), KeyModifiers::CONTROL) => {
-                if app.current_tab != Tab::Query {
-                    app.key_mode = KeyMode::Search;
-                }
+        }
+        (InputKeyCode::Home, ..) | (InputKeyCode::Char('<'), _, true, _) => match app.current_tab {
+            Tab::Layout => app.layouts_list_state.select_first(),
+            Tab::Segments => app
+                .segment_grid_state
+                .scroll_left(SEGMENT_SCROLL_HORIZONTAL_JUMP),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                app.query_state.table_state.select_first();
             }
-
-            (KeyCode::Char('s'), KeyModifiers::NONE) => {
-                if app.current_tab == Tab::Query {
-                    // Sort by selected column - modifies the SQL query
-                    let col = app.query_state.selected_column();
-                    app.query_state.apply_sort(app.session, col, &app.file_path);
+        },
+        (InputKeyCode::End, ..) | (InputKeyCode::Char('>'), _, true, _) => match app.current_tab {
+            Tab::Layout => app.layouts_list_state.select_last(),
+            Tab::Segments => app
+                .segment_grid_state
+                .scroll_right(SEGMENT_SCROLL_HORIZONTAL_JUMP),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                app.query_state.table_state.select_last();
+            }
+        },
+        (InputKeyCode::Enter, ..) => {
+            if app.current_tab == Tab::Layout && app.cursor.layout().nchildren() > 0 {
+                let selected = app.layouts_list_state.selected().unwrap_or_default();
+                app.cursor = app.cursor.child(selected);
+                app.reset_layout_view_state();
+            }
+        }
+        (InputKeyCode::Left, ..)
+        | (InputKeyCode::Char('h'), false, false, _)
+        | (InputKeyCode::Char('b'), true, ..) => match app.current_tab {
+            Tab::Layout => {
+                app.cursor = app.cursor.parent();
+                app.reset_layout_view_state();
+            }
+            Tab::Segments => app
+                .segment_grid_state
+                .scroll_left(SEGMENT_SCROLL_HORIZONTAL_STEP),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                app.query_state.horizontal_scroll =
+                    app.query_state.horizontal_scroll.saturating_sub(1);
+            }
+        },
+        (InputKeyCode::Right, ..)
+        | (InputKeyCode::Char('l'), false, false, _)
+        | (InputKeyCode::Char('b'), _, true, _) => match app.current_tab {
+            Tab::Layout => {}
+            Tab::Segments => app
+                .segment_grid_state
+                .scroll_right(SEGMENT_SCROLL_HORIZONTAL_STEP),
+            #[cfg(feature = "native")]
+            Tab::Query => {
+                let max_col = app.query_state.column_count().saturating_sub(1);
+                if app.query_state.horizontal_scroll < max_col {
+                    app.query_state.horizontal_scroll += 1;
                 }
             }
+        },
+
+        (InputKeyCode::Char('/'), ..) | (InputKeyCode::Char('s'), true, ..) => {
+            #[cfg(feature = "native")]
+            if app.current_tab == Tab::Query {
+                // Don't enter search mode from query tab
+            } else {
+                app.key_mode = KeyMode::Search;
+            }
+            #[cfg(not(feature = "native"))]
+            {
+                app.key_mode = KeyMode::Search;
+            }
+        }
 
-            (KeyCode::Esc, _) => {
-                if app.current_tab == Tab::Query {
-                    // Toggle focus in Query tab
-                    app.query_state.toggle_focus();
-                }
+        #[cfg(feature = "native")]
+        (InputKeyCode::Char('s'), false, false, _) => {
+            if app.current_tab == Tab::Query {
+                let col = app.query_state.selected_column();
+                app.query_state.prepare_sort(col);
             }
+        }
 
-            _ => {}
+        #[cfg(feature = "native")]
+        (InputKeyCode::Esc, ..) => {
+            if app.current_tab == Tab::Query {
+                app.query_state.toggle_focus();
+            }
         }
+
+        _ => {}
     }
 
     HandleResult::Continue
 }
 
-fn handle_search_mode(app: &mut AppState, event: Event) -> HandleResult {
-    if let Event::Key(key) = event {
-        match (key.code, key.modifiers) {
-            (KeyCode::Esc, _) | (KeyCode::Char('g'), KeyModifiers::CONTROL) => {
-                app.key_mode = KeyMode::Normal;
-                app.clear_search();
-            }
+/// Handle a key event in search mode.
+pub(crate) fn handle_search_mode(app: &mut AppState, event: InputEvent) -> HandleResult {
+    match (&event.code, event.ctrl, event.alt, event.shift) {
+        (InputKeyCode::Esc, ..) | (InputKeyCode::Char('g'), true, ..) => {
+            app.key_mode = KeyMode::Normal;
+            app.clear_search();
+        }
 
-            (KeyCode::Up, _) | (KeyCode::Char('p'), KeyModifiers::CONTROL) => {
-                if app.current_tab == Tab::Layout {
-                    navigate_layout_up(app, SCROLL_LINE);
-                }
+        (InputKeyCode::Up, ..) | (InputKeyCode::Char('p'), true, ..) => {
+            if app.current_tab == Tab::Layout {
+                navigate_layout_up(app, SCROLL_LINE);
             }
-            (KeyCode::Down, _) | (KeyCode::Char('n'), KeyModifiers::CONTROL) => {
-                if app.current_tab == Tab::Layout {
-                    navigate_layout_down(app, SCROLL_LINE);
-                }
+        }
+        (InputKeyCode::Down, ..) | (InputKeyCode::Char('n'), true, ..) => {
+            if app.current_tab == Tab::Layout {
+                navigate_layout_down(app, SCROLL_LINE);
             }
-            (KeyCode::PageUp, _) | (KeyCode::Char('v'), KeyModifiers::ALT) => {
-                if app.current_tab == Tab::Layout {
-                    navigate_layout_up(app, SCROLL_PAGE);
-                }
+        }
+        (InputKeyCode::PageUp, ..) | (InputKeyCode::Char('v'), _, true, _) => {
+            if app.current_tab == Tab::Layout {
+                navigate_layout_up(app, SCROLL_PAGE);
             }
-            (KeyCode::PageDown, _) | (KeyCode::Char('v'), KeyModifiers::CONTROL) => {
-                if app.current_tab == Tab::Layout {
-                    navigate_layout_down(app, SCROLL_PAGE);
-                }
+        }
+        (InputKeyCode::PageDown, ..) | (InputKeyCode::Char('v'), true, ..) => {
+            if app.current_tab == Tab::Layout {
+                navigate_layout_down(app, SCROLL_PAGE);
             }
-            (KeyCode::Home, _) | (KeyCode::Char('<'), KeyModifiers::ALT) => {
-                if app.current_tab == Tab::Layout {
-                    app.layouts_list_state.select_first();
-                }
+        }
+        (InputKeyCode::Home, ..) | (InputKeyCode::Char('<'), _, true, _) => {
+            if app.current_tab == Tab::Layout {
+                app.layouts_list_state.select_first();
             }
-            (KeyCode::End, _) | (KeyCode::Char('>'), KeyModifiers::ALT) => {
-                if app.current_tab == Tab::Layout {
-                    app.layouts_list_state.select_last();
-                }
+        }
+        (InputKeyCode::End, ..) | (InputKeyCode::Char('>'), _, true, _) => {
+            if app.current_tab == Tab::Layout {
+                app.layouts_list_state.select_last();
             }
+        }
 
-            (KeyCode::Enter, _) => {
-                if app.current_tab == Tab::Layout
-                    && app.cursor.layout().nchildren() > 0
-                    && let Some(selected) = app.layouts_list_state.selected()
-                {
-                    app.cursor = match app.filter.as_ref() {
-                        None => app.cursor.child(selected),
-                        Some(filter) => {
-                            let child_idx = filter
-                                .iter()
-                                .enumerate()
-                                .filter_map(|(idx, show)| show.then_some(idx))
-                                .nth(selected)
-                                .vortex_expect("There must be a selected item in the filter");
-
-                            app.cursor.child(child_idx)
-                        }
-                    };
-
-                    app.reset_layout_view_state();
-                    app.clear_search();
-                    app.key_mode = KeyMode::Normal;
-                }
-            }
+        (InputKeyCode::Enter, ..) => {
+            if app.current_tab == Tab::Layout
+                && app.cursor.layout().nchildren() > 0
+                && let Some(selected) = app.layouts_list_state.selected()
+            {
+                app.cursor = match app.filter.as_ref() {
+                    None => app.cursor.child(selected),
+                    Some(filter) => {
+                        let child_idx = filter
+                            .iter()
+                            .enumerate()
+                            .filter_map(|(idx, show)| show.then_some(idx))
+                            .nth(selected)
+                            .vortex_expect("There must be a selected item in the filter");
+
+                        app.cursor.child(child_idx)
+                    }
+                };
 
-            (KeyCode::Backspace, _) | (KeyCode::Char('h'), KeyModifiers::CONTROL) => {
-                app.search_filter.pop();
+                app.reset_layout_view_state();
+                app.clear_search();
+                app.key_mode = KeyMode::Normal;
             }
+        }
 
-            (KeyCode::Char(c), _) => {
-                app.layouts_list_state.select_first();
-                app.search_filter.push(c);
-            }
+        (InputKeyCode::Backspace, ..) | (InputKeyCode::Char('h'), true, ..) => {
+            app.search_filter.pop();
+        }
 
-            _ => {}
+        (InputKeyCode::Char(c), false, false, _) => {
+            app.layouts_list_state.select_first();
+            app.search_filter.push(*c);
         }
+
+        _ => {}
     }
 
     HandleResult::Continue
 }
 
-// TODO: add tui_logger and have a logs tab so we can see the log output from
-//  doing Vortex things.
+// --- Native-only crossterm event loop ---
+
+#[cfg(feature = "native")]
+mod native {
+    use crossterm::event::Event;
+    use crossterm::event::EventStream;
+    use crossterm::event::KeyEventKind;
+    use futures::StreamExt;
+    use ratatui::DefaultTerminal;
+    use vortex::error::VortexResult;
+    use vortex::session::VortexSession;
+
+    use super::ui::render_app;
+    use super::*;
+
+    async fn run(mut terminal: DefaultTerminal, mut app: AppState) -> VortexResult<()> {
+        // Eagerly load data if the initial layout is flat.
+        if app.cursor.layout().is::<Flat>() {
+            app.load_flat_data().await;
+        }
 
-/// Launch the interactive TUI browser for a Vortex file.
-///
-/// # Errors
-///
-/// Returns an error if the file cannot be opened or if there's a terminal I/O error.
-pub async fn exec_tui(session: &VortexSession, file: impl AsRef<Path>) -> VortexResult<()> {
-    let app = AppState::new(session, file).await?;
+        let mut events = EventStream::new();
+        loop {
+            terminal.draw(|frame| render_app(&mut app, frame))?;
 
-    let mut terminal = ratatui::init();
-    terminal.clear()?;
+            // Take the pending query receiver so we can select! on it
+            // without holding a mutable borrow on app.
+            let pending_rx = app.query_state.pending_rx.take();
 
-    run(terminal, app).await?;
+            let event = if let Some(mut rx) = pending_rx {
+                tokio::select! {
+                    event = events.next() => {
+                        // No query result yet — put the receiver back.
+                        app.query_state.pending_rx = Some(rx);
+                        event
+                    }
+                    result = &mut rx => {
+                        if let Ok(result) = result {
+                            app.query_state.apply_query_result(result);
+                        }
+                        // Re-render immediately to show updated results.
+                        continue;
+                    }
+                }
+            } else {
+                events.next().await
+            };
+
+            let Some(raw_event) = event else {
+                break;
+            };
+            let raw_event = raw_event?;
+
+            if let Event::Key(key) = raw_event {
+                if key.kind != KeyEventKind::Press {
+                    continue;
+                }
+
+                let input = InputEvent::from(key);
+                let result = match app.key_mode {
+                    KeyMode::Normal => handle_normal_mode(&mut app, input),
+                    KeyMode::Search => handle_search_mode(&mut app, input),
+                };
 
-    ratatui::restore();
-    Ok(())
+                if matches!(result, HandleResult::Exit) {
+                    return Ok(());
+                }
+
+                // After handling, load flat data if we navigated to a FlatLayout.
+                if app.cursor.layout().is::<Flat>() && app.cached_flat_array.is_none() {
+                    app.load_flat_data().await;
+                }
+
+                // Spawn any pending query execution as a background task.
+                app.query_state.spawn_pending(&app.session, &app.file_path);
+            }
+        }
+        Ok(())
+    }
+
+    /// Launch the interactive TUI browser for a Vortex file.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the file cannot be opened or if there's a terminal I/O error.
+    pub async fn exec_tui(
+        session: &VortexSession,
+        file: impl AsRef<std::path::Path>,
+    ) -> VortexResult<()> {
+        let app = AppState::new(session, file).await?;
+
+        let mut terminal = ratatui::init();
+        terminal.clear()?;
+
+        run(terminal, app).await?;
+
+        ratatui::restore();
+        Ok(())
+    }
 }
+
+#[cfg(feature = "native")]
+pub use native::exec_tui;
diff --git a/vortex-tui/src/browse/ui/layouts.rs b/vortex-tui/src/browse/ui/layouts.rs
index 7545f432e61..a00c363610e 100644
--- a/vortex-tui/src/browse/ui/layouts.rs
+++ b/vortex-tui/src/browse/ui/layouts.rs
@@ -26,30 +26,25 @@ use ratatui::widgets::StatefulWidget;
 use ratatui::widgets::Table;
 use ratatui::widgets::Widget;
 use ratatui::widgets::Wrap;
-use tokio::runtime::Handle;
-use tokio::task::block_in_place;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
-use vortex::array::MaskFuture;
 use vortex::array::ToCanonical;
+use vortex::array::arrays::struct_::StructArrayExt;
 use vortex::error::VortexExpect;
-use vortex::expr::root;
-use vortex::layout::layouts::flat::FlatVTable;
-use vortex::layout::layouts::zoned::ZonedVTable;
+use vortex::layout::layouts::flat::Flat;
+use vortex::layout::layouts::zoned::Zoned;
 
 use crate::browse::app::AppState;
-use crate::browse::app::LayoutCursor;
 
 /// Render the Layouts tab.
-pub fn render_layouts(app_state: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
+pub fn render_layouts(app_state: &mut AppState, area: Rect, buf: &mut Buffer) {
     let [header_area, detail_area] =
         Layout::vertical([Constraint::Length(10), Constraint::Min(1)]).areas(area);
 
     // Render the header area.
-    render_layout_header(&app_state.cursor, header_area, buf);
+    render_layout_header(app_state, header_area, buf);
 
     // Render the list view if the layout has children
-    if app_state.cursor.layout().is::<FlatVTable>() {
+    if app_state.cursor.layout().is::<Flat>() {
         render_array(
             app_state,
             detail_area,
@@ -61,7 +56,8 @@ pub fn render_layouts(app_state: &mut AppState<'_>, area: Rect, buf: &mut Buffer
     }
 }
 
-fn render_layout_header(cursor: &LayoutCursor, area: Rect, buf: &mut Buffer) {
+fn render_layout_header(app: &AppState, area: Rect, buf: &mut Buffer) {
+    let cursor = &app.cursor;
     let layout_id = cursor.layout().encoding_id();
     let row_count = cursor.layout().row_count();
     let size_formatter = make_format(DECIMAL);
@@ -77,18 +73,20 @@ fn render_layout_header(cursor: &LayoutCursor, area: Rect, buf: &mut Buffer) {
         Text::from(format!("Segment data size: {size}")).bold(),
     ];
 
-    if cursor.layout().is::<FlatVTable>() {
-        rows.push(Text::from(format!(
-            "FlatBuffer Size: {}",
-            size_formatter(cursor.flatbuffer_size())
-        )));
+    if cursor.layout().is::<Flat>() {
+        if let Some(fb_size) = app.cached_flatbuffer_size {
+            rows.push(Text::from(format!(
+                "FlatBuffer Size: {}",
+                size_formatter(fb_size)
+            )));
+        }
 
         // Display metadata info about the flat layout
         let metadata_info = cursor.flat_layout_metadata_info();
         rows.push(Text::from(metadata_info));
     }
 
-    if let Some(layout) = cursor.layout().as_opt::<ZonedVTable>() {
+    if let Some(layout) = cursor.layout().as_opt::<Zoned>() {
         // Push any zone stats.
         let mut line = String::new();
         line.push_str("Statistics: ");
@@ -114,29 +112,19 @@ fn render_layout_header(cursor: &LayoutCursor, area: Rect, buf: &mut Buffer) {
 }
 
 /// Render the inner Array for a FlatLayout.
-fn render_array(app: &AppState<'_>, area: Rect, buf: &mut Buffer, is_stats_table: bool) {
-    let row_count = app.cursor.layout().row_count();
-    let reader = app
-        .cursor
-        .layout()
-        .new_reader("".into(), app.vxf.segment_source(), app.session)
-        .vortex_expect("Failed to create reader");
-
-    // FIXME(ngates): our TUI app should never perform I/O in the render loop...
-    let array = block_in_place(|| {
-        Handle::current().block_on(
-            reader
-                .projection_evaluation(
-                    &(0..row_count),
-                    &root(),
-                    MaskFuture::new_true(
-                        usize::try_from(row_count).vortex_expect("row_count overflowed usize"),
-                    ),
-                )
-                .vortex_expect("Failed to construct projection"),
-        )
-    })
-    .vortex_expect("Failed to read flat array");
+fn render_array(app: &AppState, area: Rect, buf: &mut Buffer, is_stats_table: bool) {
+    // Array data is loaded eagerly when navigating to a FlatLayout (synchronously on
+    // native, asynchronously on WASM) and cached in AppState. The render loop never
+    // performs I/O.
+    let array = match app.cached_flat_array.as_ref() {
+        Some(arr) => arr.clone(),
+        None => {
+            let loading =
+                Paragraph::new("Loading array data...").style(Style::default().fg(Color::DarkGray));
+            Widget::render(loading, area, buf);
+            return;
+        }
+    };
 
     // Show the metadata as JSON. (show count of encoded bytes as well)
     // let metadata_size = array.metadata_bytes().unwrap_or_default().len();
@@ -159,7 +147,11 @@ fn render_array(app: &AppState<'_>, area: Rect, buf: &mut Buffer, is_stats_table
             .chain(struct_array.names().iter().map(|x| x.as_ref()))
             .map(Cell::from)
             .collect::<Row>()
-            .style(Style::default().fg(Color::Green).bg(Color::DarkGray))
+            .style(
+                Style::default()
+                    .fg(Color::Rgb(206, 229, 98))
+                    .bg(Color::DarkGray),
+            )
             .height(1);
 
         assert_eq!(app.cursor.dtype(), array.dtype());
@@ -304,7 +296,12 @@ fn render_child_list_items(
 
     // Render the List view.
     StatefulWidget::render(
-        List::new(list_items).highlight_style(Style::default().black().on_white().bold()),
+        List::new(list_items).highlight_style(
+            Style::default()
+                .fg(Color::Rgb(16, 16, 16))
+                .bg(Color::Rgb(89, 113, 253))
+                .bold(),
+        ),
         inner_area,
         buf,
         &mut app.layouts_list_state,
diff --git a/vortex-tui/src/browse/ui/mod.rs b/vortex-tui/src/browse/ui/mod.rs
index 6080d3940c5..4947b167552 100644
--- a/vortex-tui/src/browse/ui/mod.rs
+++ b/vortex-tui/src/browse/ui/mod.rs
@@ -4,13 +4,18 @@
 //! UI rendering components for the TUI browser.
 
 mod layouts;
+#[cfg(feature = "native")]
 mod query;
 mod segments;
 
 use layouts::render_layouts;
+#[cfg(feature = "native")]
 pub use query::QueryFocus;
+#[cfg(feature = "native")]
 pub use query::QueryState;
+#[cfg(feature = "native")]
 pub use query::SortDirection;
+#[cfg(feature = "native")]
 use query::render_query;
 use ratatui::prelude::*;
 use ratatui::widgets::Block;
@@ -30,7 +35,7 @@ use crate::browse::ui::segments::segments_ui;
 /// - The outer border with title and help text
 /// - The tab bar showing available views
 /// - The content area for the currently selected tab
-pub fn render_app(app: &mut AppState<'_>, frame: &mut Frame<'_>) {
+pub fn render_app(app: &mut AppState, frame: &mut Frame<'_>) {
     // Render the outer tab view, then render the inner frame view.
     let bottom_text = if app.key_mode == KeyMode::Search {
         Line::from(format!(
@@ -47,7 +52,7 @@ pub fn render_app(app: &mut AppState<'_>, frame: &mut Frame<'_>) {
     let shell = Block::default()
         .borders(Borders::ALL)
         .border_type(BorderType::Rounded)
-        .border_style(Style::default().magenta())
+        .border_style(Style::default().fg(Color::Rgb(89, 113, 253)))
         .title_top("Vortex Browser")
         .title_bottom(bottom_text)
         .title_alignment(Alignment::Center);
@@ -67,15 +72,33 @@ pub fn render_app(app: &mut AppState<'_>, frame: &mut Frame<'_>) {
     .areas(inner_area);
 
     // Display a tab indicator.
-    let selected_tab = match app.current_tab {
-        Tab::Layout => 0,
-        Tab::Segments => 1,
-        Tab::Query => 2,
+    #[cfg(feature = "native")]
+    let (selected_tab, tab_names) = {
+        let selected = match app.current_tab {
+            Tab::Layout => 0,
+            Tab::Segments => 1,
+            Tab::Query => 2,
+        };
+        (selected, vec!["File Layout", "Segments", "Query"])
     };
 
-    let tabs = Tabs::new(["File Layout", "Segments", "Query"])
+    #[cfg(not(feature = "native"))]
+    let (selected_tab, tab_names) = {
+        let selected = match app.current_tab {
+            Tab::Layout => 0,
+            Tab::Segments => 1,
+        };
+        (selected, vec!["File Layout", "Segments"])
+    };
+
+    let tabs = Tabs::new(tab_names)
         .style(Style::default().bold().white())
-        .highlight_style(Style::default().bold().black().on_white())
+        .highlight_style(
+            Style::default()
+                .bold()
+                .fg(Color::Rgb(16, 16, 16))
+                .bg(Color::Rgb(89, 113, 253)),
+        )
         .select(Some(selected_tab));
 
     frame.render_widget(tabs, tab_view);
@@ -86,6 +109,7 @@ pub fn render_app(app: &mut AppState<'_>, frame: &mut Frame<'_>) {
             render_layouts(app, app_view, frame.buffer_mut());
         }
         Tab::Segments => segments_ui(app, app_view, frame.buffer_mut()),
+        #[cfg(feature = "native")]
         Tab::Query => render_query(app, app_view, frame.buffer_mut()),
     }
 }
diff --git a/vortex-tui/src/browse/ui/query.rs b/vortex-tui/src/browse/ui/query.rs
index 692edd74423..3c626b47207 100644
--- a/vortex-tui/src/browse/ui/query.rs
+++ b/vortex-tui/src/browse/ui/query.rs
@@ -23,8 +23,8 @@ use ratatui::widgets::StatefulWidget;
 use ratatui::widgets::Table;
 use ratatui::widgets::TableState;
 use ratatui::widgets::Widget;
-use tokio::runtime::Handle;
-use tokio::task::block_in_place;
+use tokio::sync::oneshot;
+use vortex::session::VortexSession;
 
 use crate::browse::app::AppState;
 use crate::datafusion_helper::arrow_value_to_json;
@@ -73,6 +73,12 @@ pub enum QueryFocus {
     ResultsTable,
 }
 
+/// Result from a background query task.
+pub(crate) struct PendingQueryResult {
+    pub row_count: Option<Result<usize, String>>,
+    pub query_result: Result<QueryResults, String>,
+}
+
 /// State for the SQL query interface.
 pub struct QueryState {
     /// The SQL query input text.
@@ -105,6 +111,12 @@ pub struct QueryState {
     pub base_query: String,
     /// ORDER BY clause if any.
     pub order_clause: Option<String>,
+    /// Whether a query execution is pending (needs to be spawned).
+    pending_execution: bool,
+    /// Whether a row count query is needed on next spawn.
+    needs_row_count: bool,
+    /// Receiver for in-flight background query result.
+    pub(crate) pending_rx: Option<oneshot::Receiver<PendingQueryResult>>,
 }
 
 impl Default for QueryState {
@@ -126,6 +138,9 @@ impl Default for QueryState {
             total_row_count: None,
             base_query: "SELECT * FROM data".to_string(),
             order_clause: None,
+            pending_execution: false,
+            needs_row_count: false,
+            pending_rx: None,
         }
     }
 }
@@ -188,13 +203,8 @@ impl QueryState {
         };
     }
 
-    /// Execute initial query - parses SQL, gets total count, fetches first page.
-    pub fn execute_initial_query(
-        &mut self,
-        session: &vortex::session::VortexSession,
-        file_path: &str,
-    ) {
-        self.running = true;
+    /// Prepare initial query - parses SQL, sets flags for async execution.
+    pub fn prepare_initial_query(&mut self) {
         self.error = None;
 
         // Parse the SQL to extract base query, order clause, and page size
@@ -204,27 +214,24 @@ impl QueryState {
         self.page_size = limit.unwrap_or(20);
         self.current_page = 0;
 
-        // Get total row count
-        self.total_row_count = get_row_count(session, file_path, &self.base_query).ok();
-
-        // Build and execute the query
-        self.rebuild_and_execute(session, file_path);
+        self.needs_row_count = true;
+        self.rebuild_sql();
     }
 
-    /// Navigate to next page.
-    pub fn next_page(&mut self, session: &vortex::session::VortexSession, file_path: &str) {
+    /// Prepare navigation to next page.
+    pub fn prepare_next_page(&mut self) {
         let total_pages = self.total_pages();
         if self.current_page + 1 < total_pages {
             self.current_page += 1;
-            self.rebuild_and_execute(session, file_path);
+            self.rebuild_sql();
         }
     }
 
-    /// Navigate to previous page.
-    pub fn prev_page(&mut self, session: &vortex::session::VortexSession, file_path: &str) {
+    /// Prepare navigation to previous page.
+    pub fn prepare_prev_page(&mut self) {
         if self.current_page > 0 {
             self.current_page -= 1;
-            self.rebuild_and_execute(session, file_path);
+            self.rebuild_sql();
         }
     }
 
@@ -236,8 +243,8 @@ impl QueryState {
         }
     }
 
-    /// Build SQL query from current state and execute it.
-    fn rebuild_and_execute(&mut self, session: &vortex::session::VortexSession, file_path: &str) {
+    /// Build SQL query from current state and set the pending execution flag.
+    fn rebuild_sql(&mut self) {
         let offset = self.current_page * self.page_size;
 
         let new_sql = match &self.order_clause {
@@ -260,8 +267,49 @@ impl QueryState {
 
         self.running = true;
         self.error = None;
+        self.pending_execution = true;
+    }
 
-        match execute_query(session, file_path, &self.sql_input) {
+    /// 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`].
+    pub(crate) fn spawn_pending(&mut self, session: &VortexSession, file_path: &str) {
+        if !self.pending_execution {
+            return;
+        }
+        self.pending_execution = false;
+
+        let (tx, rx) = oneshot::channel();
+        let session = session.clone();
+        let file_path = file_path.to_string();
+        let sql = self.sql_input.clone();
+        let base_query = self.base_query.clone();
+        let needs_row_count = self.needs_row_count;
+        self.needs_row_count = false;
+
+        tokio::spawn(async move {
+            let row_count = match needs_row_count {
+                true => Some(get_row_count(&session, &file_path, &base_query).await),
+                false => None,
+            };
+            let query_result = execute_query(&session, &file_path, &sql).await;
+            drop(tx.send(PendingQueryResult {
+                row_count,
+                query_result,
+            }));
+        });
+
+        self.pending_rx = Some(rx);
+    }
+
+    /// Apply a completed background query result to the state.
+    pub(crate) fn apply_query_result(&mut self, result: PendingQueryResult) {
+        if let Some(row_count) = result.row_count {
+            self.total_row_count = row_count.ok();
+        }
+        match result.query_result {
             Ok(results) => {
                 self.results = Some(results);
                 self.table_state.select(Some(0));
@@ -346,13 +394,8 @@ impl QueryState {
             .unwrap_or(0)
     }
 
-    /// Apply sort on a column by modifying the ORDER BY clause and re-executing.
-    pub fn apply_sort(
-        &mut self,
-        session: &vortex::session::VortexSession,
-        column: usize,
-        file_path: &str,
-    ) {
+    /// Prepare sort on a column by modifying the ORDER BY clause and setting execution flag.
+    pub fn prepare_sort(&mut self, column: usize) {
         // Get the column name from results
         let column_name = match &self.results {
             Some(results) if column < results.column_names.len() => {
@@ -384,9 +427,9 @@ impl QueryState {
             Some(format!("ORDER BY \"{column_name}\" {direction}"))
         };
 
-        // Reset to first page and re-execute
+        // Reset to first page and set pending execution
         self.current_page = 0;
-        self.rebuild_and_execute(session, file_path);
+        self.rebuild_sql();
     }
 }
 
@@ -398,64 +441,56 @@ pub struct QueryResults {
 }
 
 /// Execute a SQL query against the Vortex file.
-pub fn execute_query(
-    session: &vortex::session::VortexSession,
+async fn execute_query(
+    session: &VortexSession,
     file_path: &str,
     sql: &str,
 ) -> Result<QueryResults, String> {
-    block_in_place(|| {
-        Handle::current().block_on(async {
-            let batches = execute_vortex_query(session, file_path, sql).await?;
+    let batches = execute_vortex_query(session, file_path, sql).await?;
 
-            let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
+    let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
 
-            let column_names = if let Some(batch) = batches.first() {
-                let schema = batch.schema();
-                schema.fields().iter().map(|f| f.name().clone()).collect()
-            } else {
-                vec![]
-            };
+    let column_names = if let Some(batch) = batches.first() {
+        let schema = batch.schema();
+        schema.fields().iter().map(|f| f.name().clone()).collect()
+    } else {
+        vec![]
+    };
 
-            Ok(QueryResults {
-                batches,
-                total_rows,
-                column_names,
-            })
-        })
+    Ok(QueryResults {
+        batches,
+        total_rows,
+        column_names,
     })
 }
 
 /// Get total row count for a base query using COUNT(*).
-pub fn get_row_count(
-    session: &vortex::session::VortexSession,
+async fn get_row_count(
+    session: &VortexSession,
     file_path: &str,
     base_query: &str,
 ) -> Result<usize, String> {
-    block_in_place(|| {
-        Handle::current().block_on(async {
-            let count_sql = format!("SELECT COUNT(*) as count FROM ({base_query}) AS subquery");
-
-            let batches = execute_vortex_query(session, file_path, &count_sql).await?;
-
-            // Extract count from result
-            if let Some(batch) = batches.first()
-                && batch.num_rows() > 0
-                && batch.num_columns() > 0
-            {
-                use arrow_array::Int64Array;
-                if let Some(arr) = batch.column(0).as_any().downcast_ref::<Int64Array>() {
-                    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
-                    return Ok(arr.value(0) as usize);
-                }
-            }
+    let count_sql = format!("SELECT COUNT(*) as count FROM ({base_query}) AS subquery");
+
+    let batches = execute_vortex_query(session, file_path, &count_sql).await?;
+
+    // Extract count from result
+    if let Some(batch) = batches.first()
+        && batch.num_rows() > 0
+        && batch.num_columns() > 0
+    {
+        use arrow_array::Int64Array;
+        if let Some(arr) = batch.column(0).as_any().downcast_ref::<Int64Array>() {
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            return Ok(arr.value(0) as usize);
+        }
+    }
 
-            Ok(0)
-        })
-    })
+    Ok(0)
 }
 
 /// Render the Query tab UI.
-pub fn render_query(app: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
+pub fn render_query(app: &mut AppState, area: Rect, buf: &mut Buffer) {
     let [input_area, results_area] =
         Layout::vertical([Constraint::Length(5), Constraint::Min(10)]).areas(area);
 
@@ -463,7 +498,7 @@ pub fn render_query(app: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
     render_results_table(app, results_area, buf);
 }
 
-fn render_sql_input(app: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
+fn render_sql_input(app: &mut AppState, area: Rect, buf: &mut Buffer) {
     let is_focused = app.query_state.focus == QueryFocus::SqlInput;
 
     let border_color = if is_focused {
@@ -515,7 +550,7 @@ fn render_sql_input(app: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
     paragraph.render(inner, buf);
 }
 
-fn render_results_table(app: &mut AppState<'_>, area: Rect, buf: &mut Buffer) {
+fn render_results_table(app: &mut AppState, area: Rect, buf: &mut Buffer) {
     let is_focused = app.query_state.focus == QueryFocus::ResultsTable;
 
     let border_color = if is_focused {
diff --git a/vortex-tui/src/browse/ui/segments.rs b/vortex-tui/src/browse/ui/segments.rs
index b8d20dbc2b1..7c11400a421 100644
--- a/vortex-tui/src/browse/ui/segments.rs
+++ b/vortex-tui/src/browse/ui/segments.rs
@@ -40,11 +40,11 @@ use crate::segment_tree::collect_segment_tree;
 /// This struct manages the layout tree and scroll state for displaying segments in a grid view.
 /// The segment tree is lazily computed on first render and cached for subsequent frames.
 #[derive(Debug, Clone, Default)]
-pub struct SegmentGridState<'a> {
+pub struct SegmentGridState {
     /// The computed layout tree for the segment grid, or `None` if not yet computed.
     ///
     /// Contains the taffy layout tree, root node ID, and a map of node contents.
-    pub segment_tree: Option<(TaffyTree<()>, NodeId, HashMap<NodeId, NodeContents<'a>>)>,
+    pub segment_tree: Option<(TaffyTree<()>, NodeId, HashMap<NodeId, NodeContents>)>,
 
     /// State for the horizontal scrollbar widget.
     pub horizontal_scroll_state: ScrollbarState,
@@ -65,7 +65,7 @@ pub struct SegmentGridState<'a> {
     pub max_vertical_scroll: usize,
 }
 
-impl SegmentGridState<'_> {
+impl SegmentGridState {
     /// Scroll the viewport up by the given amount.
     pub fn scroll_up(&mut self, amount: usize) {
         self.vertical_scroll = self.vertical_scroll.saturating_sub(amount);
@@ -102,9 +102,9 @@ impl SegmentGridState<'_> {
 }
 
 #[derive(Debug, Clone)]
-pub struct NodeContents<'a> {
+pub struct NodeContents {
     title: FieldName,
-    contents: Vec<Line<'a>>,
+    contents: Vec<Line<'static>>,
 }
 
 #[expect(
@@ -277,9 +277,9 @@ fn render_tree(
     Some(r)
 }
 
-fn to_display_segment_tree<'a>(
+fn to_display_segment_tree(
     mut segment_tree: SegmentTree,
-) -> anyhow::Result<(TaffyTree<()>, NodeId, HashMap<NodeId, NodeContents<'a>>)> {
+) -> anyhow::Result<(TaffyTree<()>, NodeId, HashMap<NodeId, NodeContents>)> {
     // Extra node for the parent node of the segment specs, and one parent node as the root
     let mut tree = TaffyTree::with_capacity(
         segment_tree
diff --git a/vortex-tui/src/convert.rs b/vortex-tui/src/convert.rs
index 240ed34d8fa..f6798413422 100644
--- a/vortex-tui/src/convert.rs
+++ b/vortex-tui/src/convert.rs
@@ -15,6 +15,7 @@ use tokio::io::AsyncWriteExt;
 use vortex::array::ArrayRef;
 use vortex::array::arrow::FromArrowArray;
 use vortex::array::stream::ArrayStreamAdapter;
+use vortex::compressor::BtrBlocksCompressorBuilder;
 use vortex::dtype::DType;
 use vortex::dtype::arrow::FromArrowType;
 use vortex::error::VortexExpect;
@@ -91,11 +92,11 @@ pub async fn exec_convert(session: &VortexSession, flags: ConvertArgs) -> anyhow
             .boxed();
     }
 
-    let strategy = WriteStrategyBuilder::default();
-    let strategy = match flags.strategy {
-        Strategy::Btrblocks => strategy,
-        Strategy::Compact => strategy.with_compact_encodings(),
-    };
+    let mut strategy = WriteStrategyBuilder::default();
+    if matches!(flags.strategy, Strategy::Compact) {
+        strategy =
+            strategy.with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact());
+    }
 
     let mut file = File::create(output_path).await?;
     session
diff --git a/vortex-tui/src/inspect.rs b/vortex-tui/src/inspect.rs
index d2258e59a4d..bc2e920aea4 100644
--- a/vortex-tui/src/inspect.rs
+++ b/vortex-tui/src/inspect.rs
@@ -210,8 +210,8 @@ async fn exec_inspect_json(
     let footer_json =
         if matches!(mode, InspectMode::Footer) && eof.valid_magic && postscript_json.is_some() {
             inspector.read_footer().await.ok().map(|footer| {
-                let segment_map = footer.segment_map().clone();
-                let root_layout = footer.layout().clone();
+                let segment_map = Arc::clone(footer.segment_map());
+                let root_layout = Arc::clone(footer.layout());
 
                 let mut segment_paths: Vec<Option<Vec<Arc<str>>>> = vec![None; segment_map.len()];
                 let mut queue =
@@ -538,14 +538,14 @@ impl FooterSegments {
 
         println!("\nSegment details:\n");
 
-        let segment_map = self.0.segment_map().clone();
+        let segment_map = Arc::clone(self.0.segment_map());
         if segment_map.is_empty() {
             println!("<no segments>");
             return;
         }
 
         let mut segment_paths: Vec<Option<Vec<Arc<str>>>> = vec![None; segment_map.len()];
-        let root_layout = self.0.layout().clone();
+        let root_layout = Arc::clone(self.0.layout());
 
         let mut queue =
             VecDeque::<(Vec<Arc<str>>, LayoutRef)>::from_iter([(Vec::new(), root_layout)]);
diff --git a/vortex-tui/src/lib.rs b/vortex-tui/src/lib.rs
index 69c5b463e62..7a9aab7191a 100644
--- a/vortex-tui/src/lib.rs
+++ b/vortex-tui/src/lib.rs
@@ -4,7 +4,7 @@
 //! Vortex TUI library for interactively browsing and inspecting Vortex files.
 //!
 //! This crate provides both a CLI tool (`vx`) and a library API for working with Vortex files.
-//! Users can bring their own [`VortexSession`] to enable custom encodings and extensions.
+//! Users can bring their own `VortexSession` to enable custom encodings and extensions.
 //!
 //! # Example
 //!
@@ -13,8 +13,12 @@
 //! use vortex::io::session::RuntimeSessionExt;
 //! use vortex_tui::browse;
 //!
-//! let session = VortexSession::default().with_tokio();
-//! browse::exec_tui(&session, "my_file.vortex").await?;
+//! #[tokio::main]
+//! async fn main() -> anyhow::Result<()> {
+//!     let session = VortexSession::default().with_tokio();
+//!     browse::exec_tui(&session, "my_file.vortex").await?;
+//!     Ok(())
+//! }
 //! ```
 
 #![deny(clippy::missing_errors_doc)]
@@ -22,110 +26,132 @@
 #![deny(clippy::missing_safety_doc)]
 #![deny(missing_docs)]
 
-use std::ffi::OsString;
-use std::path::PathBuf;
-
-use clap::CommandFactory;
-use clap::Parser;
-use vortex::error::VortexExpect;
-use vortex::session::VortexSession;
-
+#[cfg_attr(
+    all(not(feature = "native"), not(target_arch = "wasm32")),
+    allow(dead_code, unused_imports)
+)]
 pub mod browse;
+pub mod segment_tree;
+
+#[cfg(feature = "native")]
 pub mod convert;
+#[cfg(feature = "native")]
 pub mod datafusion_helper;
+#[cfg(feature = "native")]
 pub mod inspect;
+#[cfg(feature = "native")]
 pub mod query;
-pub mod segment_tree;
+#[cfg(feature = "native")]
 pub mod segments;
+#[cfg(feature = "native")]
 pub mod tree;
 
-#[derive(clap::Parser)]
-#[command(version)]
-struct Cli {
-    #[clap(subcommand)]
-    command: Commands,
-}
+#[cfg(target_arch = "wasm32")]
+pub mod wasm;
 
-#[derive(Debug, clap::Subcommand)]
-enum Commands {
-    /// Print tree views of a Vortex file (layout tree or array tree)
-    Tree(tree::TreeArgs),
-    /// Convert a Parquet file to a Vortex file. Chunking occurs on Parquet RowGroup boundaries.
-    Convert(#[command(flatten)] convert::ConvertArgs),
-    /// Interactively browse the Vortex file.
-    Browse { file: PathBuf },
-    /// Inspect Vortex file footer and metadata
-    Inspect(inspect::InspectArgs),
-    /// Execute a SQL query against a Vortex file using DataFusion
-    Query(query::QueryArgs),
-    /// Display segment information for a Vortex file
-    Segments(segments::SegmentsArgs),
-}
+#[cfg(feature = "native")]
+mod native_cli {
+    use std::ffi::OsString;
+    use std::path::PathBuf;
 
-impl Commands {
-    fn file_path(&self) -> &PathBuf {
-        match self {
-            Commands::Tree(args) => match &args.mode {
-                tree::TreeMode::Array { file, .. } => file,
-                tree::TreeMode::Layout { file, .. } => file,
-            },
-            Commands::Browse { file } => file,
-            Commands::Convert(flags) => &flags.file,
-            Commands::Inspect(args) => &args.file,
-            Commands::Query(args) => &args.file,
-            Commands::Segments(args) => &args.file,
-        }
+    use clap::CommandFactory;
+    use clap::Parser;
+    use vortex::error::VortexExpect;
+    use vortex::session::VortexSession;
+
+    #[derive(clap::Parser)]
+    #[command(version)]
+    struct Cli {
+        #[clap(subcommand)]
+        command: Commands,
     }
-}
 
-/// Main entrypoint for `vx` that launches a [`VortexSession`].
-///
-/// Parses arguments from [`std::env::args_os`]. See [`launch_from`] to supply explicit arguments.
-///
-/// # Errors
-///
-/// Raises any errors from subcommands.
-pub async fn launch(session: &VortexSession) -> anyhow::Result<()> {
-    launch_from(session, std::env::args_os()).await
-}
+    #[derive(Debug, clap::Subcommand)]
+    enum Commands {
+        /// Print tree views of a Vortex file (layout tree or array tree)
+        Tree(super::tree::TreeArgs),
+        /// Convert a Parquet file to a Vortex file. Chunking occurs on Parquet RowGroup boundaries.
+        Convert(#[command(flatten)] super::convert::ConvertArgs),
+        /// Interactively browse the Vortex file.
+        Browse { file: PathBuf },
+        /// Inspect Vortex file footer and metadata
+        Inspect(super::inspect::InspectArgs),
+        /// Execute a SQL query against a Vortex file using DataFusion
+        Query(super::query::QueryArgs),
+        /// Display segment information for a Vortex file
+        Segments(super::segments::SegmentsArgs),
+    }
 
-/// Launch `vx` with explicit command-line arguments.
-///
-/// This is useful when embedding the TUI inside another process (e.g. Python) where
-/// [`std::env::args`] may not reflect the intended arguments.
-///
-/// # Errors
-///
-/// Raises any errors from subcommands.
-pub async fn launch_from(
-    session: &VortexSession,
-    args: impl IntoIterator<Item = impl Into<OsString> + Clone>,
-) -> anyhow::Result<()> {
-    let _ = env_logger::try_init();
-
-    let cli = Cli::parse_from(args);
-
-    let path = cli.command.file_path();
-    if !std::fs::exists(path)? {
-        Cli::command()
-            .error(
-                clap::error::ErrorKind::Io,
-                format!(
-                    "File '{}' does not exist.",
-                    path.to_str().vortex_expect("file path")
-                ),
-            )
-            .exit()
+    impl Commands {
+        fn file_path(&self) -> &PathBuf {
+            match self {
+                Commands::Tree(args) => match &args.mode {
+                    super::tree::TreeMode::Array { file, .. } => file,
+                    super::tree::TreeMode::Layout { file, .. } => file,
+                },
+                Commands::Browse { file } => file,
+                Commands::Convert(flags) => &flags.file,
+                Commands::Inspect(args) => &args.file,
+                Commands::Query(args) => &args.file,
+                Commands::Segments(args) => &args.file,
+            }
+        }
     }
 
-    match cli.command {
-        Commands::Tree(args) => tree::exec_tree(session, args).await?,
-        Commands::Convert(flags) => convert::exec_convert(session, flags).await?,
-        Commands::Browse { file } => browse::exec_tui(session, file).await?,
-        Commands::Inspect(args) => inspect::exec_inspect(session, args).await?,
-        Commands::Query(args) => query::exec_query(session, args).await?,
-        Commands::Segments(args) => segments::exec_segments(session, args).await?,
-    };
+    /// Main entrypoint for `vx` that launches a [`VortexSession`].
+    ///
+    /// Parses arguments from [`std::env::args_os`]. See [`launch_from`] to supply explicit arguments.
+    ///
+    /// # Errors
+    ///
+    /// Raises any errors from subcommands.
+    pub async fn launch(session: &VortexSession) -> anyhow::Result<()> {
+        launch_from(session, std::env::args_os()).await
+    }
+
+    /// Launch `vx` with explicit command-line arguments.
+    ///
+    /// This is useful when embedding the TUI inside another process (e.g. Python) where
+    /// [`std::env::args`] may not reflect the intended arguments.
+    ///
+    /// # Errors
+    ///
+    /// Raises any errors from subcommands.
+    pub async fn launch_from(
+        session: &VortexSession,
+        args: impl IntoIterator<Item = impl Into<OsString> + Clone>,
+    ) -> anyhow::Result<()> {
+        let _ = env_logger::try_init();
+
+        let cli = Cli::parse_from(args);
 
-    Ok(())
+        let path = cli.command.file_path();
+        if !std::fs::exists(path)? {
+            Cli::command()
+                .error(
+                    clap::error::ErrorKind::Io,
+                    format!(
+                        "File '{}' does not exist.",
+                        path.to_str().vortex_expect("file path")
+                    ),
+                )
+                .exit()
+        }
+
+        match cli.command {
+            Commands::Tree(args) => super::tree::exec_tree(session, args).await?,
+            Commands::Convert(flags) => super::convert::exec_convert(session, flags).await?,
+            Commands::Browse { file } => super::browse::exec_tui(session, file).await?,
+            Commands::Inspect(args) => super::inspect::exec_inspect(session, args).await?,
+            Commands::Query(args) => super::query::exec_query(session, args).await?,
+            Commands::Segments(args) => super::segments::exec_segments(session, args).await?,
+        };
+
+        Ok(())
+    }
 }
+
+#[cfg(feature = "native")]
+pub use native_cli::launch;
+#[cfg(feature = "native")]
+pub use native_cli::launch_from;
diff --git a/vortex-tui/src/main.rs b/vortex-tui/src/main.rs
index d813ff4dc4f..af872073dd5 100644
--- a/vortex-tui/src/main.rs
+++ b/vortex-tui/src/main.rs
@@ -8,6 +8,6 @@ use vortex_tui::launch;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let session = VortexSession::default().with_tokio();
+    let session = VortexSession::default().with_tokio().allow_unknown();
     launch(&session).await
 }
diff --git a/vortex-tui/src/segment_tree.rs b/vortex-tui/src/segment_tree.rs
index ba8d3f16a6e..fd88650f2fd 100644
--- a/vortex-tui/src/segment_tree.rs
+++ b/vortex-tui/src/segment_tree.rs
@@ -128,7 +128,7 @@ fn segments_by_name_impl(
         .or_default();
 
     for segment_id in root.segment_ids() {
-        let segment_spec = segments[*segment_id as usize].clone();
+        let segment_spec = segments[*segment_id as usize];
         current_segments.push(SegmentDisplay {
             name: name.clone().unwrap_or_else(|| "<unnamed>".into()),
             spec: segment_spec,
diff --git a/vortex-tui/src/tree.rs b/vortex-tui/src/tree.rs
index a8799afea1e..27218d1d8db 100644
--- a/vortex-tui/src/tree.rs
+++ b/vortex-tui/src/tree.rs
@@ -5,6 +5,7 @@
 
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use serde::Serialize;
 use vortex::array::stream::ArrayStreamExt;
@@ -115,7 +116,7 @@ async fn exec_layout_tree(
     let footer = vxf.footer();
 
     if json {
-        let tree = layout_to_json(footer.layout().clone())?;
+        let tree = layout_to_json(Arc::clone(footer.layout()))?;
         let json_output = serde_json::to_string_pretty(&tree)
             .map_err(|e| vortex::error::vortex_err!("Failed to serialize JSON: {e}"))?;
         println!("{json_output}");
diff --git a/vortex-tui/src/wasm.rs b/vortex-tui/src/wasm.rs
new file mode 100644
index 00000000000..8b643161fe2
--- /dev/null
+++ b/vortex-tui/src/wasm.rs
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! WebAssembly entry points for the Vortex TUI browser.
+//!
+//! Provides functions callable from JavaScript to load a Vortex file from a byte array
+//! and display the interactive browser in a web page using ratzilla.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use ratzilla::CanvasBackend;
+use ratzilla::WebRenderer;
+use ratzilla::ratatui::Terminal;
+use vortex::array::MaskFuture;
+use vortex::array::serde::SerializedArray;
+use vortex::error::VortexExpect;
+use vortex::expr::root;
+use vortex::layout::layouts::flat::Flat;
+use vortex::layout::segments::SegmentSource;
+use vortex::session::VortexSession;
+use wasm_bindgen::prelude::*;
+
+use crate::browse::app::AppState;
+use crate::browse::app::KeyMode;
+use crate::browse::handle_normal_mode;
+use crate::browse::handle_search_mode;
+use crate::browse::input::InputEvent;
+use crate::browse::ui::render_app;
+
+/// Initialize the WASM module (sets up panic hook for better error messages).
+#[wasm_bindgen(start)]
+pub fn init() {
+    console_error_panic_hook::set_once();
+}
+
+/// Spawn an async task to load the flat layout array data and cache it in AppState.
+///
+/// This avoids calling `block_on()` in the render loop, which would deadlock in WASM
+/// since the single-threaded event loop can't process spawned tasks while busy-waiting.
+fn maybe_load_flat_data(app: &Rc<RefCell<AppState>>) {
+    let borrowed = app.borrow();
+    if !borrowed.cursor.layout().is::<Flat>() {
+        return;
+    }
+    if borrowed.cached_flat_array.is_some() {
+        return;
+    }
+
+    // Extract everything we need before dropping the borrow.
+    let layout = borrowed.cursor.layout().clone();
+    let segment_source = borrowed.vxf.segment_source();
+    let session = borrowed.session.clone();
+    let row_count = layout.row_count();
+    drop(borrowed);
+
+    let app = app.clone();
+    wasm_bindgen_futures::spawn_local(async move {
+        // Load the array data.
+        let array = load_flat_array(&layout, &segment_source, &session, row_count).await;
+
+        // Load the flatbuffer size.
+        let fb_size = load_flatbuffer_size(&layout, &segment_source).await;
+
+        // Store results — the borrow is safe because spawn_local runs between
+        // animation frames, so the draw_web callback won't be holding it.
+        let mut app = app.borrow_mut();
+        app.cached_flat_array = Some(array);
+        app.cached_flatbuffer_size = Some(fb_size);
+    });
+}
+
+async fn load_flat_array(
+    layout: &vortex::layout::LayoutRef,
+    segment_source: &Arc<dyn SegmentSource>,
+    session: &VortexSession,
+    row_count: u64,
+) -> vortex::array::ArrayRef {
+    let reader = layout
+        .new_reader("".into(), segment_source.clone(), session)
+        .vortex_expect("Failed to create reader");
+    reader
+        .projection_evaluation(
+            &(0..row_count),
+            &root(),
+            MaskFuture::new_true(
+                usize::try_from(row_count).vortex_expect("row_count overflowed usize"),
+            ),
+        )
+        .vortex_expect("Failed to construct projection")
+        .await
+        .vortex_expect("Failed to read flat array")
+}
+
+async fn load_flatbuffer_size(
+    layout: &vortex::layout::LayoutRef,
+    segment_source: &Arc<dyn SegmentSource>,
+) -> usize {
+    let segment_id = layout.as_::<Flat>().segment_id();
+    let segment = segment_source
+        .request(segment_id)
+        .await
+        .vortex_expect("Failed to read segment");
+    SerializedArray::try_from(segment)
+        .vortex_expect("Failed to parse segment")
+        .metadata()
+        .len()
+}
+
+/// Open a Vortex file from raw bytes and launch the interactive browser.
+///
+/// Call this from JavaScript after reading a `.vtx` file (e.g. via drag-and-drop or file input).
+/// The browser UI will be rendered into the DOM.
+#[wasm_bindgen]
+pub fn open_vortex_file(data: &[u8]) -> Result<(), JsValue> {
+    use vortex::VortexSessionDefault;
+    use vortex::buffer::ByteBuffer;
+    use vortex::io::runtime::wasm::WasmRuntime;
+    use vortex::io::session::RuntimeSessionExt;
+
+    let session = VortexSession::default().with_handle(WasmRuntime::handle());
+    let buffer = ByteBuffer::from(data.to_vec());
+    let app = Rc::new(RefCell::new(
+        AppState::from_buffer(session, buffer).map_err(|e| JsValue::from_str(&e.to_string()))?,
+    ));
+
+    // Size the canvas to the CSS viewport. The JS side then scales canvas.width by
+    // devicePixelRatio for crisp high-DPI rendering (ctx.scale(dpr)) without changing
+    // the cell count. Browser zoom changes the viewport, so zooming out gives more
+    // cols/rows and the resize handler recreates the terminal.
+    let window = web_sys::window().ok_or_else(|| JsValue::from_str("no window"))?;
+    let vw = window
+        .inner_width()
+        .ok()
+        .and_then(|v| v.as_f64())
+        .unwrap_or(1200.0);
+    let vh = window
+        .inner_height()
+        .ok()
+        .and_then(|v| v.as_f64())
+        .unwrap_or(800.0);
+    let backend = CanvasBackend::new_with_size(vw as u32, vh as u32)
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let terminal = Terminal::new(backend).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    // Register our own keydown listener so we can call preventDefault() for keys
+    // the browser would otherwise intercept (e.g. Tab switching focus, '/' opening
+    // Firefox's quick-find).
+    {
+        let app_for_keys = app.clone();
+        let closure = Closure::<dyn FnMut(_)>::new(move |event: web_sys::KeyboardEvent| {
+            event.prevent_default();
+
+            {
+                let mut app_mut = app_for_keys.borrow_mut();
+                let input = InputEvent::from(event);
+                match app_mut.key_mode {
+                    KeyMode::Normal => {
+                        handle_normal_mode(&mut app_mut, input);
+                    }
+                    KeyMode::Search => {
+                        handle_search_mode(&mut app_mut, input);
+                    }
+                }
+            }
+            // After handling the key event, trigger async loading if we navigated
+            // to a FlatLayout.
+            maybe_load_flat_data(&app_for_keys);
+        });
+        let document = window
+            .document()
+            .ok_or_else(|| JsValue::from_str("no document"))?;
+        document
+            .add_event_listener_with_callback("keydown", closure.as_ref().unchecked_ref())
+            .map_err(|e| JsValue::from_str(&format!("addEventListener failed: {e:?}")))?;
+        closure.forget();
+    }
+
+    terminal.draw_web(move |frame| {
+        let mut app = app.borrow_mut();
+        render_app(&mut app, frame);
+    });
+
+    Ok(())
+}
diff --git a/vortex-tui/web/index.html b/vortex-tui/web/index.html
new file mode 100644
index 00000000000..5ff3572d200
--- /dev/null
+++ b/vortex-tui/web/index.html
@@ -0,0 +1,141 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: Copyright the Vortex contributors
+-->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Vortex Browser</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <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">
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+<div id="drop-zone">
+    <img src="logo.svg" alt="Vortex" class="logo">
+    <p>Drag and drop a <code>.vtx</code> file here to explore it</p>
+    <p>or</p>
+    <label for="file-input" class="file-label">Choose a file</label>
+    <input type="file" id="file-input" accept=".vtx,.vortex">
+</div>
+<div id="loading" style="display: none;">
+    <p>Loading file...</p>
+</div>
+
+<script type="module">
+    import init, {open_vortex_file} from './pkg/vortex_tui.js';
+
+    const dropZone = document.getElementById('drop-zone');
+    const loading = document.getElementById('loading');
+    const fileInput = document.getElementById('file-input');
+    let fileBytes = null;
+    let wasmReady = false;
+
+    function openFile(bytes) {
+        // Remove any existing canvas from a previous open
+        document.querySelectorAll('canvas').forEach(c => c.remove());
+        open_vortex_file(bytes);
+
+        // Scale canvas to physical pixel resolution for crisp high-DPI rendering.
+        // Cell count is already locked in from Rust (based on CSS viewport size).
+        const canvas = document.querySelector('canvas');
+        if (canvas) {
+            const dpr = window.devicePixelRatio || 1;
+            const cssW = canvas.width;
+            const cssH = canvas.height;
+            canvas.width = cssW * dpr;
+            canvas.height = cssH * dpr;
+            canvas.style.width = cssW + 'px';
+            canvas.style.height = cssH + 'px';
+            const ctx = canvas.getContext('2d');
+            ctx.scale(dpr, dpr);
+            ctx.font = '16px monospace';
+            ctx.textBaseline = 'top';
+        }
+    }
+
+    async function loadFile(file) {
+        dropZone.style.display = 'none';
+        loading.style.display = 'flex';
+
+        try {
+            if (!wasmReady) {
+                await init();
+                wasmReady = true;
+            }
+            const buffer = await file.arrayBuffer();
+            fileBytes = new Uint8Array(buffer);
+            openFile(fileBytes);
+            loading.style.display = 'none';
+        } catch (e) {
+            loading.style.display = 'none';
+            dropZone.style.display = 'flex';
+            alert('Failed to open file: ' + e);
+        }
+    }
+
+    // Re-create terminal on resize/zoom so it fills the screen
+    let resizeTimer;
+    window.addEventListener('resize', () => {
+        if (!fileBytes) return;
+        clearTimeout(resizeTimer);
+        resizeTimer = setTimeout(() => openFile(fileBytes), 150);
+    });
+
+    // Translate mouse wheel scroll into arrow key events for the TUI.
+    // Accumulate pixel deltas and emit one arrow key per LINE_HEIGHT crossed,
+    // same approach as xterm.js and other browser-based terminal emulators.
+    const LINE_HEIGHT = 60;
+    let scrollAccumulator = 0;
+    document.addEventListener('wheel', (e) => {
+        if (!fileBytes) return;
+        e.preventDefault();
+        const delta = e.deltaMode === 1 ? e.deltaY * LINE_HEIGHT : e.deltaY;
+        scrollAccumulator += delta;
+        while (Math.abs(scrollAccumulator) >= LINE_HEIGHT) {
+            const key = scrollAccumulator < 0 ? 'ArrowUp' : 'ArrowDown';
+            document.dispatchEvent(new KeyboardEvent('keydown', { key }));
+            scrollAccumulator -= Math.sign(scrollAccumulator) * LINE_HEIGHT;
+        }
+    }, { passive: false });
+
+    // Prevent browser shortcuts that conflict with TUI keybindings (e.g. Firefox
+    // quick-find on '/')
+    document.addEventListener('keydown', (e) => {
+        if (!fileBytes) return;
+        if (e.key === '/' || e.key === "'") {
+            e.preventDefault();
+        }
+    });
+
+    dropZone.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        dropZone.classList.add('drag-over');
+    });
+
+    dropZone.addEventListener('dragleave', () => {
+        dropZone.classList.remove('drag-over');
+    });
+
+    dropZone.addEventListener('drop', (e) => {
+        e.preventDefault();
+        dropZone.classList.remove('drag-over');
+        const file = e.dataTransfer.files[0];
+        if (file) {
+            loadFile(file);
+        }
+    });
+
+    fileInput.addEventListener('change', (e) => {
+        const file = e.target.files[0];
+        if (file) {
+            loadFile(file);
+        }
+    });
+</script>
+</body>
+</html>
diff --git a/benchmarks-website-v2/public/vortex_black_nobg.svg b/vortex-tui/web/logo.svg
similarity index 98%
rename from benchmarks-website-v2/public/vortex_black_nobg.svg
rename to vortex-tui/web/logo.svg
index f8210102998..a98a0b58508 100644
--- a/benchmarks-website-v2/public/vortex_black_nobg.svg
+++ b/vortex-tui/web/logo.svg
@@ -1,3 +1,7 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: Copyright the Vortex contributors
+-->
 <svg width="830" height="365" viewBox="0 0 830 365" fill="none" xmlns="http://www.w3.org/2000/svg">
 <path fill-rule="evenodd" clip-rule="evenodd" d="M421.132 137.571C430.175 137.571 437.92 139.4 444.366 143.056C450.909 146.712 455.96 151.907 459.52 158.642C463.079 165.376 464.859 173.362 464.859 182.599C464.859 191.739 463.079 199.724 459.52 206.555C455.96 213.289 450.909 218.486 444.366 222.142C437.824 225.797 430.079 227.625 421.132 227.625C412.281 227.625 404.583 225.797 398.041 222.142C391.499 218.389 386.399 213.146 382.743 206.411C379.183 199.676 377.403 191.739 377.403 182.599C377.403 173.459 379.183 165.521 382.743 158.786C386.303 152.051 391.354 146.856 397.896 143.2C404.535 139.448 412.28 137.571 421.132 137.571ZM421.132 149.405C411.703 149.405 404.294 152.34 398.906 158.209C393.615 163.982 390.969 172.112 390.969 182.599C390.969 193.085 393.615 201.263 398.906 207.132C404.294 212.905 411.703 215.791 421.132 215.791C430.657 215.791 438.065 212.904 443.356 207.132C448.648 201.263 451.294 193.085 451.294 182.599C451.294 172.015 448.648 163.837 443.356 158.064C438.065 152.292 430.657 149.405 421.132 149.405Z" fill="url(#paint0_linear_4802_58)"/>
 <path fill-rule="evenodd" clip-rule="evenodd" d="M618.667 137.571C626.845 137.571 633.916 139.255 639.881 142.622C645.846 145.893 650.464 150.56 653.735 156.621C657.103 162.682 658.787 169.851 658.787 178.125V184.186H588.648C589.033 194.095 591.92 201.841 597.308 207.421C602.792 213.001 610.056 215.791 619.1 215.791C625.353 215.791 630.645 214.444 634.975 211.75C639.4 209.056 642.431 205.16 644.066 200.061H657.921C655.708 208.816 651.185 215.599 644.354 220.409C637.62 225.22 629.25 227.625 619.244 227.625C610.393 227.625 602.696 225.797 596.153 222.142C589.611 218.389 584.56 213.097 581 206.267C577.44 199.436 575.66 191.45 575.66 182.31C575.66 173.17 577.44 165.28 581 158.642C584.56 151.907 589.563 146.712 596.009 143.056C602.455 139.4 610.008 137.571 618.667 137.571ZM618.522 149.117C610.729 149.117 604.234 151.282 599.039 155.611C593.94 159.941 590.717 166.002 589.37 173.795H645.653C644.98 166.002 642.238 159.941 637.428 155.611C632.617 151.282 626.315 149.117 618.522 149.117Z" fill="url(#paint1_linear_4802_58)"/>
diff --git a/vortex-tui/web/style.css b/vortex-tui/web/style.css
new file mode 100644
index 00000000000..c6eaccbeca7
--- /dev/null
+++ b/vortex-tui/web/style.css
@@ -0,0 +1,90 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/* SPDX-FileCopyrightText: Copyright the Vortex contributors */
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html, body {
+    background: #101010;
+    color: #ECECEC;
+    font-family: "Geist", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    -webkit-font-smoothing: antialiased;
+    height: 100%;
+    overflow: hidden;
+}
+
+canvas {
+    display: block;
+    position: fixed;
+    top: 0;
+    left: 0;
+}
+
+#drop-zone {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    transition: border-color 0.2s, background-color 0.2s;
+}
+
+#drop-zone.drag-over {
+    background-color: rgba(89, 113, 253, 0.08);
+}
+
+#drop-zone .logo {
+    width: 200px;
+    margin-bottom: 32px;
+    filter: invert(1);
+}
+
+#drop-zone p {
+    margin: 6px 0;
+    color: #888;
+    font-size: 0.95em;
+    line-height: 1.6;
+}
+
+#drop-zone code {
+    background: #1a1a1a;
+    border: 1px solid #333;
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-family: "Geist Mono", monospace;
+    font-size: 0.9em;
+    color: #CEE562;
+}
+
+.file-label {
+    display: inline-block;
+    padding: 10px 28px;
+    background: #5971FD;
+    color: #ffffff;
+    border-radius: 8px;
+    cursor: pointer;
+    font-weight: 500;
+    font-size: 0.95em;
+    margin-top: 12px;
+    transition: background 0.2s;
+}
+
+.file-label:hover {
+    background: #4A5FE5;
+}
+
+#file-input {
+    display: none;
+}
+
+#loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 100vh;
+    font-size: 1.1em;
+    color: #5971FD;
+}
diff --git a/vortex-utils/public-api.lock b/vortex-utils/public-api.lock
index 1e1f063835a..185029d5627 100644
--- a/vortex-utils/public-api.lock
+++ b/vortex-utils/public-api.lock
@@ -69,3 +69,17 @@ pub fn vortex_utils::dyn_traits::DynHash::dyn_hash(&self, state: &mut dyn core::
 impl<T: core::hash::Hash + 'static> vortex_utils::dyn_traits::DynHash for T
 
 pub fn T::dyn_hash(&self, state: &mut dyn core::hash::Hasher)
+
+pub mod vortex_utils::iter
+
+pub trait vortex_utils::iter::ReduceBalancedIterExt: core::iter::traits::iterator::Iterator
+
+pub fn vortex_utils::iter::ReduceBalancedIterExt::reduce_balanced<F>(self, combine: F) -> core::option::Option<Self::Item> where Self::Item: core::clone::Clone, F: core::ops::function::Fn(Self::Item, Self::Item) -> Self::Item
+
+pub fn vortex_utils::iter::ReduceBalancedIterExt::try_reduce_balanced<F, E>(self, combine: F) -> core::result::Result<core::option::Option<Self::Item>, E> where Self::Item: core::clone::Clone, F: core::ops::function::Fn(Self::Item, Self::Item) -> core::result::Result<Self::Item, E>
+
+impl<I: core::iter::traits::iterator::Iterator + core::marker::Sized> vortex_utils::iter::ReduceBalancedIterExt for I
+
+pub fn I::reduce_balanced<F>(self, combine: F) -> core::option::Option<Self::Item> where Self::Item: core::clone::Clone, F: core::ops::function::Fn(Self::Item, Self::Item) -> Self::Item
+
+pub fn I::try_reduce_balanced<F, E>(self, combine: F) -> core::result::Result<core::option::Option<Self::Item>, E> where Self::Item: core::clone::Clone, F: core::ops::function::Fn(Self::Item, Self::Item) -> core::result::Result<Self::Item, E>
diff --git a/vortex-utils/src/env.rs b/vortex-utils/src/env.rs
index 9c4505ea443..19e78e1f12b 100644
--- a/vortex-utils/src/env.rs
+++ b/vortex-utils/src/env.rs
@@ -166,7 +166,7 @@ mod tests {
 
         let key = "VORTEX_TEST_ENV_VAR_WAIT";
         let second_acquired = Arc::new(AtomicBool::new(false));
-        let second_acquired_clone = second_acquired.clone();
+        let second_acquired_clone = Arc::clone(&second_acquired);
 
         // First guard in main thread
         let _guard1 = EnvVarGuard::set(key, "first");
diff --git a/vortex-utils/src/iter.rs b/vortex-utils/src/iter.rs
new file mode 100644
index 00000000000..ec48b235508
--- /dev/null
+++ b/vortex-utils/src/iter.rs
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Iterator extension traits.
+
+/// An extension trait for iterators that provides balanced binary tree reduction.
+///
+/// Unlike [`Iterator::reduce`], which builds a left-leaning linear chain of depth N,
+/// `reduce_balanced` builds a balanced binary tree of depth log(N). This avoids deep
+/// nesting that can cause stack overflows on drop or suboptimal evaluation.
+///
+/// ```text
+/// reduce:          reduce_balanced:
+///     f                  f
+///    / \                / \
+///   f   d              f   f
+///  / \                / \ / \
+/// f   c              a  b c  d
+/// |\
+/// a b
+/// ```
+pub trait ReduceBalancedIterExt: Iterator {
+    /// Like [`Iterator::reduce`], but builds a balanced binary tree instead of a linear chain.
+    ///
+    /// `[a, b, c, d]` becomes `combine(combine(a, b), combine(c, d))`.
+    ///
+    /// Returns `None` if the iterator is empty.
+    fn reduce_balanced<F>(self, combine: F) -> Option<Self::Item>
+    where
+        Self::Item: Clone,
+        F: Fn(Self::Item, Self::Item) -> Self::Item;
+
+    /// Fallible version of [`reduce_balanced`](ReduceBalancedIterExt::reduce_balanced).
+    ///
+    /// Short-circuits on the first error.
+    fn try_reduce_balanced<F, E>(self, combine: F) -> Result<Option<Self::Item>, E>
+    where
+        Self::Item: Clone,
+        F: Fn(Self::Item, Self::Item) -> Result<Self::Item, E>;
+}
+
+impl<I: Iterator + Sized> ReduceBalancedIterExt for I {
+    fn reduce_balanced<F>(self, combine: F) -> Option<Self::Item>
+    where
+        Self::Item: Clone,
+        F: Fn(Self::Item, Self::Item) -> Self::Item,
+    {
+        let mut items: Vec<_> = self.collect();
+        if items.is_empty() {
+            return None;
+        }
+        if items.len() == 1 {
+            return items.pop();
+        }
+
+        while items.len() > 1 {
+            let len = items.len();
+
+            for target_idx in 0..(len / 2) {
+                let item_idx = target_idx * 2;
+                let new = combine(items[item_idx].clone(), items[item_idx + 1].clone());
+                items[target_idx] = new;
+            }
+
+            if !len.is_multiple_of(2) {
+                // Merge the odd element into the last paired element so it stays inside the tree.
+                let lhs = items[(len / 2) - 1].clone();
+                let rhs = items[len - 1].clone();
+                items[len / 2 - 1] = combine(lhs, rhs);
+            }
+
+            items.truncate(len / 2);
+        }
+
+        assert_eq!(items.len(), 1);
+        items.pop()
+    }
+
+    fn try_reduce_balanced<F, E>(self, combine: F) -> Result<Option<Self::Item>, E>
+    where
+        Self::Item: Clone,
+        F: Fn(Self::Item, Self::Item) -> Result<Self::Item, E>,
+    {
+        let mut items: Vec<_> = self.collect();
+        if items.is_empty() {
+            return Ok(None);
+        }
+        if items.len() == 1 {
+            return Ok(items.pop());
+        }
+
+        while items.len() > 1 {
+            let len = items.len();
+
+            for target_idx in 0..(len / 2) {
+                let item_idx = target_idx * 2;
+                let new = combine(items[item_idx].clone(), items[item_idx + 1].clone())?;
+                items[target_idx] = new;
+            }
+
+            if !len.is_multiple_of(2) {
+                let lhs = items[(len / 2) - 1].clone();
+                let rhs = items[len - 1].clone();
+                items[len / 2 - 1] = combine(lhs, rhs)?;
+            }
+
+            items.truncate(len / 2);
+        }
+
+        assert_eq!(items.len(), 1);
+        Ok(items.pop())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_empty() {
+        let result = std::iter::empty::<i32>().reduce_balanced(|a, b| a + b);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_single() {
+        let result = [42].into_iter().reduce_balanced(|a, b| a + b);
+        assert_eq!(result, Some(42));
+    }
+
+    #[test]
+    fn test_two() {
+        let result = [1, 2].into_iter().reduce_balanced(|a, b| a + b);
+        assert_eq!(result, Some(3));
+    }
+
+    #[test]
+    fn test_power_of_two() {
+        let result = [1, 2, 3, 4].into_iter().reduce_balanced(|a, b| a + b);
+        assert_eq!(result, Some(10));
+    }
+
+    #[test]
+    fn test_odd_count() {
+        let result = [1, 2, 3, 4, 5].into_iter().reduce_balanced(|a, b| a + b);
+        assert_eq!(result, Some(15));
+    }
+
+    #[test]
+    fn test_balanced_structure() {
+        // Use string concatenation to verify the tree shape.
+        // [a, b, c, d] should produce ((a+b)+(c+d)), not (((a+b)+c)+d).
+        let result = ["a", "b", "c", "d"]
+            .into_iter()
+            .map(String::from)
+            .reduce_balanced(|a, b| format!("({a}+{b})"));
+        assert_eq!(result, Some("((a+b)+(c+d))".to_string()));
+    }
+
+    #[test]
+    fn test_balanced_structure_odd() {
+        // [a, b, c] should produce ((a+b)+c) — odd element merges into last pair.
+        let result = ["a", "b", "c"]
+            .into_iter()
+            .map(String::from)
+            .reduce_balanced(|a, b| format!("({a}+{b})"));
+        assert_eq!(result, Some("((a+b)+c)".to_string()));
+    }
+
+    #[test]
+    fn test_balanced_structure_five() {
+        // [a, b, c, d, e] => ((a+b)+((c+d)+e))
+        let result = ["a", "b", "c", "d", "e"]
+            .into_iter()
+            .map(String::from)
+            .reduce_balanced(|a, b| format!("({a}+{b})"));
+        assert_eq!(result, Some("((a+b)+((c+d)+e))".to_string()));
+    }
+
+    #[test]
+    fn test_try_reduce_balanced_ok() {
+        let result: Result<_, &str> = [1, 2, 3, 4]
+            .into_iter()
+            .try_reduce_balanced(|a, b| Ok(a + b));
+        assert_eq!(result, Ok(Some(10)));
+    }
+
+    #[test]
+    fn test_try_reduce_balanced_err() {
+        let result: Result<Option<i32>, &str> = [1, 2, 3, 4]
+            .into_iter()
+            .try_reduce_balanced(|a, b| if a + b > 4 { Err("too big") } else { Ok(a + b) });
+        assert_eq!(result, Err("too big"));
+    }
+
+    #[test]
+    fn test_try_reduce_balanced_empty() {
+        let result: Result<_, &str> =
+            std::iter::empty::<i32>().try_reduce_balanced(|a, b| Ok(a + b));
+        assert_eq!(result, Ok(None));
+    }
+
+    #[test]
+    fn test_try_reduce_balanced_single() {
+        let result: Result<_, &str> = [42].into_iter().try_reduce_balanced(|a, b| Ok(a + b));
+        assert_eq!(result, Ok(Some(42)));
+    }
+}
diff --git a/vortex-utils/src/lib.rs b/vortex-utils/src/lib.rs
index 51474faef9a..ff1610ddead 100644
--- a/vortex-utils/src/lib.rs
+++ b/vortex-utils/src/lib.rs
@@ -11,3 +11,4 @@ pub mod debug_with;
 pub mod dyn_traits;
 #[cfg(feature = "_test-harness")]
 pub mod env;
+pub mod iter;
diff --git a/vortex-web/.gitignore b/vortex-web/.gitignore
new file mode 100644
index 00000000000..0fc1c516892
--- /dev/null
+++ b/vortex-web/.gitignore
@@ -0,0 +1,5 @@
+node_modules
+dist
+storybook-static
+src/wasm/pkg
+*.local
diff --git a/vortex-web/.prettierrc.json b/vortex-web/.prettierrc.json
new file mode 100644
index 00000000000..50bf5f7ae21
--- /dev/null
+++ b/vortex-web/.prettierrc.json
@@ -0,0 +1,7 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "printWidth": 100,
+  "tabWidth": 2
+}
diff --git a/vortex-web/.storybook/main.ts b/vortex-web/.storybook/main.ts
new file mode 100644
index 00000000000..169c5bb6be7
--- /dev/null
+++ b/vortex-web/.storybook/main.ts
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { StorybookConfig } from '@storybook/react-vite';
+
+const config: StorybookConfig = {
+  stories: ['../src/**/*.mdx', '../src/**/*.stories.@(js|jsx|mjs|ts|tsx)'],
+  addons: ['@storybook/addon-docs'],
+  framework: '@storybook/react-vite',
+};
+export default config;
diff --git a/vortex-web/.storybook/preview.ts b/vortex-web/.storybook/preview.ts
new file mode 100644
index 00000000000..e120ec5e169
--- /dev/null
+++ b/vortex-web/.storybook/preview.ts
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Preview } from '@storybook/react-vite';
+import '../src/index.css';
+
+const preview: Preview = {
+  globalTypes: {
+    theme: {
+      description: 'Color theme',
+      toolbar: {
+        title: 'Theme',
+        icon: 'paintbrush',
+        items: [
+          { value: 'light', title: 'Light', icon: 'sun' },
+          { value: 'dark', title: 'Dark', icon: 'moon' },
+        ],
+        dynamicTitle: true,
+      },
+    },
+  },
+  initialGlobals: {
+    theme: 'light',
+  },
+  decorators: [
+    (Story, context) => {
+      const theme = context.globals.theme || 'light';
+      document.documentElement.classList.toggle('dark', theme === 'dark');
+      document.documentElement.classList.toggle('light', theme === 'light');
+      return Story();
+    },
+  ],
+  parameters: {
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/i,
+      },
+    },
+  },
+};
+
+export default preview;
diff --git a/vortex-web/README.md b/vortex-web/README.md
new file mode 100644
index 00000000000..ac1a1a53201
--- /dev/null
+++ b/vortex-web/README.md
@@ -0,0 +1,76 @@
+# Vortex Web
+
+A web UI for exploring Vortex data files, built with React, TypeScript, Tailwind CSS, and Rust/WASM.
+
+## Prerequisites
+
+- Node.js 22+
+- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) (for full app development)
+- Rust toolchain (for full app development)
+
+## Getting Started
+
+```bash
+npm install
+```
+
+### Full App (requires Rust + wasm-pack)
+
+```bash
+# Start dev server (builds WASM in debug mode, then starts Vite)
+npm run dev
+```
+
+### Storybook (no Rust/WASM required)
+
+Storybook lets you develop and preview UI components in isolation:
+
+```bash
+npm run storybook
+```
+
+This starts a dev server at http://localhost:6006.
+
+## Scripts
+
+| Command                   | Description                                |
+|---------------------------|--------------------------------------------|
+| `npm run dev`             | Build WASM (debug) + start Vite dev server |
+| `npm run build`           | Production build (WASM release + Vite)     |
+| `npm run storybook`       | Start Storybook dev server on port 6006    |
+| `npm run build-storybook` | Build static Storybook site                |
+| `npm run lint`            | Run ESLint                                 |
+| `npm run lint:fix`        | Run ESLint with auto-fix                   |
+| `npm run typecheck`       | Run TypeScript type checking               |
+| `npm run check`           | Build WASM + lint + typecheck              |
+
+## Writing Stories
+
+Add story files alongside your components as `*.stories.tsx`:
+
+```tsx
+import type {Meta, StoryObj} from '@storybook/react-vite';
+import {MyComponent} from './MyComponent';
+
+const meta: Meta<typeof MyComponent> = {
+    component: MyComponent,
+};
+export default meta;
+
+type Story = StoryObj<typeof MyComponent>;
+
+export const Default: Story = {
+    args: {},
+};
+```
+
+## Project Structure
+
+```
+vortex-web/
+  crate/            # Rust WASM crate (vortex bindings)
+  src/              # React/TypeScript frontend
+    wasm/pkg/       # Generated WASM bindings (not checked in)
+  .storybook/       # Storybook configuration
+  public/           # Static assets
+```
diff --git a/vortex-web/crate/Cargo.lock b/vortex-web/crate/Cargo.lock
new file mode 100644
index 00000000000..2c734c444fb
--- /dev/null
+++ b/vortex-web/crate/Cargo.lock
@@ -0,0 +1,2802 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "arcref"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28f6098a1e8ab66ff91324cce8fea6643101882cf7d09c85acdb1485ecf61e29"
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrow-arith"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7b3141e0ec5145a22d8694ea8b6d6f69305971c4fa1c1a13ef0195aef2d678b"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-array"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c8955af33b25f3b175ee10af580577280b4bd01f7e823d94c7cdef7cf8c9aef"
+dependencies = [
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "hashbrown 0.16.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c697ddca96183182f35b3a18e50b9110b11e916d7b7799cbfd4d34662f2c56c2"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "646bbb821e86fd57189c10b4fcdaa941deaf4181924917b0daa92735baa6ada5"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64",
+ "chrono",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-data"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fdd994a9d28e6365aa78e15da3f3950c0fdcea6b963a12fa1c391afb637b304"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d8f1870e03d4cbed632959498bcc84083b5a24bded52905ae1695bd29da45b"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c872d36b7bf2a6a6a2b40de9156265f0242910791db366a2c17476ba8330d68"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "arrow-select"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68bf3e3efbd1278f770d67e5dc410257300b161b93baedb3aae836144edcaf4b"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-string"
+version = "57.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85e968097061b3c0e9fe3079cf2e703e487890700546b5b0647f60fca1b5a8d8"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-fs"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
+dependencies = [
+ "async-lock",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix",
+ "slab",
+ "windows-sys",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-net"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
+dependencies = [
+ "async-io",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "better_io"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef0a3155e943e341e557863e69a708999c94ede624e37865c8e2a91b94efa78f"
+
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "cc"
+version = "1.2.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "rand_core 0.10.0",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "windows-link",
+]
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "const_for"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c50fcfdf972929aff202c16b80086aa3cfc6a3a820af714096c58c7c1d0582"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "custom-labels"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a750ea4bdb7dbf9584b5d5c668bfa3835f88275781a947b5ea0212945bbdd41f"
+dependencies = [
+ "bindgen",
+ "cc",
+ "libc",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "dtype_dispatch"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab23e69df104e2fd85ee63a533a22d2132ef5975dc6b36f9f3e5a7305e4a8ed7"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "enum-iterator"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4549325971814bda7a44061bf3fe7e487d447cba01e4220a4b454d630d7a016"
+dependencies = [
+ "enum-iterator-derive",
+]
+
+[[package]]
+name = "enum-iterator-derive"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "ext-trait"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d772df1c1a777963712fb68e014235e80863d6a91a85c4e06ba2d16243a310e5"
+dependencies = [
+ "ext-trait-proc_macros",
+]
+
+[[package]]
+name = "ext-trait-proc_macros"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ab7934152eaf26aa5aa9f7371408ad5af4c31357073c9e84c3b9d7f11ad639a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "extension-traits"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a296e5a895621edf9fa8329c83aa1cb69a964643e36cf54d8d7a69b789089537"
+dependencies = [
+ "ext-trait",
+]
+
+[[package]]
+name = "fastlanes"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414cb755aee48ff7b0907995d2949c68c8c17900970076dff6a808e18e592d71"
+dependencies = [
+ "arrayref",
+ "const_for",
+ "num-traits",
+ "paste",
+ "seq-macro",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
+dependencies = [
+ "bitflags",
+ "rustc_version",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "fsst-rs"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdf65e16e100438be0030d113042e07a62bed67203998640ca6fae0404eed71e"
+dependencies = [
+ "rustc-hash",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.0",
+ "wasip2",
+ "wasip3",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "zerocopy",
+]
+
+[[package]]
+name = "handle"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ed72152641d513a6084a3907bfcba3f35ae2d3335c22ce2242969c25ff8e46"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "humansize"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cb51c9a029ddc91b07a787f1d86b53ccfa49b0e86688c946ebe8d3555685dd7"
+dependencies = [
+ "libm",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "inventory"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "009ae045c87e7082cb72dab0ccd01ae075dd00141ddc108f43a0ea150a9e7227"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "jiff"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
+dependencies = [
+ "jiff-static",
+ "jiff-tzdb-platform",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+ "windows-sys",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kanal"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e3953adf0cd667798b396c2fa13552d6d9b3269d7dd1154c4c416442d1ff574"
+dependencies = [
+ "futures-core",
+ "lock_api",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "lending-iterator"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc07588c853b50689205fb5c00498aa681d89828e0ce8cbd965ebc7a5d8ae260"
+dependencies = [
+ "extension-traits",
+ "lending-iterator-proc_macros",
+ "macro_rules_attribute",
+ "never-say-never",
+ "nougat",
+ "polonius-the-crab",
+]
+
+[[package]]
+name = "lending-iterator-proc_macros"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5445dd1c0deb1e97b8a16561d17fc686ca83e8411128fb036e9668a72d51b1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "macro_rules_attribute"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf0c9b980bf4f3a37fd7b1c066941dd1b1d0152ce6ee6e8fe8c49b9f6810d862"
+dependencies = [
+ "macro_rules_attribute-proc_macro",
+ "paste",
+]
+
+[[package]]
+name = "macro_rules_attribute-proc_macro"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58093314a45e00c77d5c508f76e77c3396afbbc0d01506e7fae47b018bac2b1d"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "moka"
+version = "0.12.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
+dependencies = [
+ "async-lock",
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "equivalent",
+ "event-listener",
+ "futures-util",
+ "parking_lot",
+ "portable-atomic",
+ "smallvec",
+ "tagptr",
+ "uuid",
+]
+
+[[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 = "never-say-never"
+version = "6.6.666"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf5a574dadd7941adeaa71823ecba5e28331b8313fb2e1c6a5c7e5981ea53ad6"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "nougat"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97b57b9ced431322f054fc673f1d3c7fa52d80efd9df74ad2fc759f044742510"
+dependencies = [
+ "macro_rules_attribute",
+ "nougat-proc_macros",
+]
+
+[[package]]
+name = "nougat-proc_macros"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c84f77a45e99a2f9b492695d99e1c23844619caa5f3e57647cffacad773ca257"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+dependencies = [
+ "parking_lot_core",
+]
+
+[[package]]
+name = "oneshot"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe21416a02c693fb9f980befcb230ecc70b0b3d1cc4abf88b9675c4c1457f0c"
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "pco"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e89d71ab3c07ed898defa4915bdc2a963131d811a1eab0eeacfac65c94cdeae8"
+dependencies = [
+ "better_io",
+ "dtype_dispatch",
+ "half",
+ "rand_xoshiro",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "polonius-the-crab"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a69ee997a6282f8462abf1e0d8c38c965e968799e912b3bed8c9e8a28c2f9f"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
+dependencies = [
+ "prost",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
+dependencies = [
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.0",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rand_core"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
+
+[[package]]
+name = "rand_xoshiro"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "roaring"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ba9ce64a8f45d7fc86358410bb1a82e8c987504c0d4900e9141d69a9f26c885"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
+name = "sketches-ddsketch"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05e40b6cf54d988dc1a2223531b969c9a9e30906ad90ef64890c27b4bfbb46ea"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "smol"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33bd3e260892199c3ccfc487c88b2da2265080acb316cd920da72fdfd7c599f"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-fs",
+ "async-io",
+ "async-lock",
+ "async-net",
+ "async-process",
+ "blocking",
+ "futures-lite",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "target-features"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
+
+[[package]]
+name = "termtree"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d1330fe7f7f872cd05165130b10602d667b205fd85be09be2814b115d4ced9"
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tokio"
+version = "1.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+dependencies = [
+ "bytes",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "uuid"
+version = "1.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vortex"
+version = "0.1.0"
+dependencies = [
+ "vortex-alp",
+ "vortex-array",
+ "vortex-btrblocks",
+ "vortex-buffer",
+ "vortex-bytebool",
+ "vortex-datetime-parts",
+ "vortex-decimal-byte-parts",
+ "vortex-error",
+ "vortex-fastlanes",
+ "vortex-file",
+ "vortex-flatbuffers",
+ "vortex-fsst",
+ "vortex-io",
+ "vortex-ipc",
+ "vortex-layout",
+ "vortex-mask",
+ "vortex-metrics",
+ "vortex-pco",
+ "vortex-proto",
+ "vortex-runend",
+ "vortex-scan",
+ "vortex-sequence",
+ "vortex-session",
+ "vortex-sparse",
+ "vortex-utils",
+ "vortex-zigzag",
+]
+
+[[package]]
+name = "vortex-alp"
+version = "0.1.0"
+dependencies = [
+ "itertools 0.14.0",
+ "num-traits",
+ "prost",
+ "rustc-hash",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-fastlanes",
+ "vortex-mask",
+ "vortex-session",
+ "vortex-utils",
+]
+
+[[package]]
+name = "vortex-array"
+version = "0.1.0"
+dependencies = [
+ "arcref",
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
+ "async-lock",
+ "bytes",
+ "cfg-if",
+ "enum-iterator",
+ "flatbuffers",
+ "futures",
+ "getrandom 0.4.2",
+ "half",
+ "humansize",
+ "inventory",
+ "itertools 0.14.0",
+ "jiff",
+ "multiversion",
+ "num-traits",
+ "num_enum",
+ "parking_lot",
+ "paste",
+ "pin-project-lite",
+ "prost",
+ "rand",
+ "rustc-hash",
+ "simdutf8",
+ "static_assertions",
+ "termtree",
+ "tracing",
+ "uuid",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-flatbuffers",
+ "vortex-mask",
+ "vortex-proto",
+ "vortex-session",
+ "vortex-utils",
+]
+
+[[package]]
+name = "vortex-btrblocks"
+version = "0.1.0"
+dependencies = [
+ "enum-iterator",
+ "getrandom 0.4.2",
+ "itertools 0.14.0",
+ "num-traits",
+ "rand",
+ "rustc-hash",
+ "tracing",
+ "vortex-alp",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-datetime-parts",
+ "vortex-decimal-byte-parts",
+ "vortex-error",
+ "vortex-fastlanes",
+ "vortex-fsst",
+ "vortex-mask",
+ "vortex-runend",
+ "vortex-sequence",
+ "vortex-sparse",
+ "vortex-utils",
+ "vortex-zigzag",
+]
+
+[[package]]
+name = "vortex-buffer"
+version = "0.1.0"
+dependencies = [
+ "arrow-buffer",
+ "bitvec",
+ "bytes",
+ "itertools 0.14.0",
+ "simdutf8",
+ "vortex-error",
+]
+
+[[package]]
+name = "vortex-bytebool"
+version = "0.1.0"
+dependencies = [
+ "num-traits",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-datetime-parts"
+version = "0.1.0"
+dependencies = [
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-decimal-byte-parts"
+version = "0.1.0"
+dependencies = [
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-error"
+version = "0.1.0"
+dependencies = [
+ "arrow-schema",
+ "flatbuffers",
+ "jiff",
+ "prost",
+]
+
+[[package]]
+name = "vortex-fastlanes"
+version = "0.1.0"
+dependencies = [
+ "arrayref",
+ "fastlanes",
+ "itertools 0.14.0",
+ "lending-iterator",
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-file"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "flatbuffers",
+ "futures",
+ "getrandom 0.4.2",
+ "itertools 0.14.0",
+ "kanal",
+ "moka",
+ "oneshot",
+ "parking_lot",
+ "pin-project-lite",
+ "tracing",
+ "uuid",
+ "vortex-alp",
+ "vortex-array",
+ "vortex-btrblocks",
+ "vortex-buffer",
+ "vortex-bytebool",
+ "vortex-datetime-parts",
+ "vortex-decimal-byte-parts",
+ "vortex-error",
+ "vortex-fastlanes",
+ "vortex-flatbuffers",
+ "vortex-fsst",
+ "vortex-io",
+ "vortex-layout",
+ "vortex-mask",
+ "vortex-metrics",
+ "vortex-pco",
+ "vortex-runend",
+ "vortex-scan",
+ "vortex-sequence",
+ "vortex-session",
+ "vortex-sparse",
+ "vortex-utils",
+ "vortex-zigzag",
+]
+
+[[package]]
+name = "vortex-flatbuffers"
+version = "0.1.0"
+dependencies = [
+ "flatbuffers",
+ "vortex-buffer",
+ "vortex-error",
+]
+
+[[package]]
+name = "vortex-fsst"
+version = "0.1.0"
+dependencies = [
+ "fsst-rs",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-io"
+version = "0.1.0"
+dependencies = [
+ "async-fs",
+ "async-stream",
+ "async-trait",
+ "bytes",
+ "custom-labels",
+ "futures",
+ "getrandom 0.4.2",
+ "glob",
+ "handle",
+ "kanal",
+ "oneshot",
+ "parking_lot",
+ "pin-project-lite",
+ "smol",
+ "tokio",
+ "tracing",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-metrics",
+ "vortex-session",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "vortex-ipc"
+version = "0.1.0"
+dependencies = [
+ "bytes",
+ "flatbuffers",
+ "futures",
+ "itertools 0.14.0",
+ "pin-project-lite",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-flatbuffers",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-layout"
+version = "0.1.0"
+dependencies = [
+ "arcref",
+ "async-stream",
+ "async-trait",
+ "flatbuffers",
+ "futures",
+ "itertools 0.14.0",
+ "kanal",
+ "moka",
+ "once_cell",
+ "oneshot",
+ "parking_lot",
+ "paste",
+ "pin-project-lite",
+ "prost",
+ "rustc-hash",
+ "termtree",
+ "tracing",
+ "uuid",
+ "vortex-array",
+ "vortex-btrblocks",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-flatbuffers",
+ "vortex-io",
+ "vortex-mask",
+ "vortex-metrics",
+ "vortex-sequence",
+ "vortex-session",
+ "vortex-utils",
+]
+
+[[package]]
+name = "vortex-mask"
+version = "0.1.0"
+dependencies = [
+ "itertools 0.14.0",
+ "vortex-buffer",
+ "vortex-error",
+]
+
+[[package]]
+name = "vortex-metrics"
+version = "0.1.0"
+dependencies = [
+ "getrandom 0.4.2",
+ "parking_lot",
+ "sketches-ddsketch",
+]
+
+[[package]]
+name = "vortex-pco"
+version = "0.1.0"
+dependencies = [
+ "pco",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-proto"
+version = "0.1.0"
+dependencies = [
+ "prost",
+ "prost-types",
+]
+
+[[package]]
+name = "vortex-runend"
+version = "0.1.0"
+dependencies = [
+ "arrow-array",
+ "itertools 0.14.0",
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-scan"
+version = "0.1.0"
+dependencies = [
+ "arrow-array",
+ "arrow-schema",
+ "async-trait",
+ "bit-vec",
+ "futures",
+ "itertools 0.14.0",
+ "parking_lot",
+ "roaring",
+ "sketches-ddsketch",
+ "tracing",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-io",
+ "vortex-layout",
+ "vortex-mask",
+ "vortex-metrics",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-sequence"
+version = "0.1.0"
+dependencies = [
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-proto",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-session"
+version = "0.1.0"
+dependencies = [
+ "arcref",
+ "dashmap",
+ "parking_lot",
+ "vortex-error",
+ "vortex-utils",
+]
+
+[[package]]
+name = "vortex-sparse"
+version = "0.1.0"
+dependencies = [
+ "itertools 0.14.0",
+ "num-traits",
+ "prost",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
+[[package]]
+name = "vortex-utils"
+version = "0.1.0"
+dependencies = [
+ "dashmap",
+ "hashbrown 0.16.1",
+ "vortex-error",
+]
+
+[[package]]
+name = "vortex-web-wasm"
+version = "0.1.0"
+dependencies = [
+ "console_error_panic_hook",
+ "js-sys",
+ "vortex",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "vortex-zigzag"
+version = "0.1.0"
+dependencies = [
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+ "zigzag",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zigzag"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70b40401a28d86ce16a330b863b86fd7dbee4d7c940587ab09ab8c019f9e3fdf"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/vortex-web/crate/Cargo.toml b/vortex-web/crate/Cargo.toml
new file mode 100644
index 00000000000..25b16583380
--- /dev/null
+++ b/vortex-web/crate/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "vortex-web-wasm"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.90"
+license = "Apache-2.0"
+description = "WASM bindings for the Vortex web explorer"
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-ipc = { workspace = true }
+arrow-schema = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+vortex = { path = "../../vortex", default-features = false, features = [
+    "files",
+] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+futures = { workspace = true }
+wasm-bindgen = "0.2.104"
+wasm-bindgen-futures = { workspace = true }
+console_error_panic_hook = "0.1.7"
+js-sys = "0.3.81"
+web-sys = { version = "0.3.81", features = [
+    "Blob",
+    "console",
+    "File",
+    "FileReader",
+] }
+
+[lints]
+workspace = true
diff --git a/vortex-web/crate/src/lib.rs b/vortex-web/crate/src/lib.rs
new file mode 100644
index 00000000000..03b36ee4515
--- /dev/null
+++ b/vortex-web/crate/src/lib.rs
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![cfg(target_arch = "wasm32")]
+
+//! WASM bindings for the Vortex web explorer.
+//!
+//! Built with `wasm-pack build --target web` and consumed by the vortex-web frontend.
+
+use std::sync::LazyLock;
+
+use vortex::VortexSessionDefault;
+use vortex::io::runtime::wasm::WasmRuntime;
+use vortex::io::session::RuntimeSessionExt;
+use vortex::session::VortexSession;
+
+mod wasm;
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    VortexSession::default()
+        .with_handle(WasmRuntime::handle())
+        .allow_unknown()
+});
diff --git a/vortex-web/crate/src/wasm.rs b/vortex-web/crate/src/wasm.rs
new file mode 100644
index 00000000000..05e328e5341
--- /dev/null
+++ b/vortex-web/crate/src/wasm.rs
@@ -0,0 +1,851 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::collections::VecDeque;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Context;
+use std::task::Poll;
+
+use arrow_array::RecordBatch;
+use arrow_array::cast::AsArray;
+use arrow_ipc::writer::StreamWriter;
+use arrow_schema::DataType;
+use arrow_schema::Field;
+use arrow_schema::Schema;
+use futures::FutureExt;
+use futures::TryStreamExt;
+use futures::future::BoxFuture;
+use serde::Serialize;
+use vortex::array::ArrayRef;
+use vortex::array::LEGACY_SESSION;
+use vortex::array::VortexSessionExecute;
+use vortex::array::arrow::ArrowArrayExecutor;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::dtype::DType;
+use vortex::array::serde::SerializedArray;
+use vortex::array::session::ArraySessionExt;
+use vortex::array::stream::ArrayStream;
+use vortex::buffer::Alignment;
+use vortex::buffer::ByteBufferMut;
+use vortex::error::VortexResult;
+use vortex::file::OpenOptionsSessionExt;
+use vortex::file::VERSION;
+use vortex::file::VortexFile;
+use vortex::io::CoalesceConfig;
+use vortex::io::VortexReadAt;
+use vortex::layout::LayoutChildType;
+use vortex::layout::LayoutRef;
+use vortex::layout::layouts::flat::Flat;
+use vortex::layout::scan::scan_builder::ScanBuilder;
+use vortex::session::VortexSession;
+use vortex::session::registry::ReadContext;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
+
+use crate::SESSION;
+
+/// Initialize the WASM module (sets up panic hook for better error messages).
+#[wasm_bindgen(start)]
+pub fn init() {
+    console_error_panic_hook::set_once();
+}
+
+/// A `VortexReadAt` backed by a `web_sys::Blob`, enabling lazy range-based reads
+/// via `Blob.slice()` + `arrayBuffer()`.
+struct BlobReadAt {
+    blob: web_sys::Blob,
+    size: u64,
+}
+
+// SAFETY: WASM is single-threaded — Blob is never accessed from multiple threads.
+unsafe impl Send for BlobReadAt {}
+unsafe impl Sync for BlobReadAt {}
+
+/// Wrapper to mark a `JsFuture` as `Send`.
+///
+/// SAFETY: WASM is single-threaded, so `JsFuture` is never accessed from multiple threads.
+struct SendFuture(JsFuture);
+
+unsafe impl Send for SendFuture {}
+
+impl Future for SendFuture {
+    type Output = Result<JsValue, JsValue>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // SAFETY: We never move the inner JsFuture after pinning.
+        unsafe { Pin::new_unchecked(&mut self.0).poll(cx) }
+    }
+}
+
+impl VortexReadAt for BlobReadAt {
+    fn concurrency(&self) -> usize {
+        4
+    }
+
+    fn coalesce_config(&self) -> Option<CoalesceConfig> {
+        Some(CoalesceConfig::in_memory())
+    }
+
+    fn size(&self) -> BoxFuture<'static, VortexResult<u64>> {
+        let size = self.size;
+        async move { Ok(size) }.boxed()
+    }
+
+    fn read_at(
+        &self,
+        offset: u64,
+        length: usize,
+        alignment: Alignment,
+    ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
+        let start = offset as f64;
+        let end = (offset + length as u64) as f64;
+        let slice = self
+            .blob
+            .slice_with_f64_and_f64(start, end)
+            .expect("Blob.slice() failed");
+        // SAFETY: WASM is single-threaded so the non-Send JsFuture is safe to wrap.
+        let future = SendFuture(JsFuture::from(slice.array_buffer()));
+        async move {
+            let array_buffer = future.await.expect("Blob.arrayBuffer() failed");
+            let uint8 = js_sys::Uint8Array::new(&array_buffer);
+            let mut buffer =
+                ByteBufferMut::with_capacity_aligned(uint8.length() as usize, alignment);
+            buffer.extend_from_slice(&uint8.to_vec());
+            Ok(BufferHandle::new_host(buffer.freeze()))
+        }
+        .boxed()
+    }
+}
+
+/// Open a Vortex file from a `File` handle and return a handle for exploration.
+///
+/// The `File` (a `Blob`) is read lazily — only the footer is read at open time.
+#[wasm_bindgen]
+pub async fn open_vortex_file(file: web_sys::File) -> Result<VortexFileHandle, JsValue> {
+    let blob: &web_sys::Blob = file.as_ref();
+    let file_size = blob.size() as usize;
+    let reader = Arc::new(BlobReadAt {
+        blob: blob.clone(),
+        size: file_size as u64,
+    });
+
+    let vxf = SESSION
+        .open_options()
+        .open(reader)
+        .await
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    // Extract the array ReadContext from any FlatLayout in the tree.
+    let array_read_ctx = find_array_read_ctx(vxf.footer().layout());
+
+    Ok(VortexFileHandle {
+        vxf,
+        session: SESSION.clone(),
+        file_size,
+        array_read_ctx,
+    })
+}
+
+/// Walk the layout tree to find the first FlatLayout and extract its ReadContext.
+fn find_array_read_ctx(layout: &LayoutRef) -> Option<ReadContext> {
+    if let Some(flat) = layout.as_opt::<Flat>() {
+        return Some(flat.array_ctx().clone());
+    }
+    if let Ok(children) = layout.children() {
+        for child in children {
+            if let Some(ctx) = find_array_read_ctx(&child) {
+                return Some(ctx);
+            }
+        }
+    }
+    None
+}
+
+/// A handle to an opened Vortex file, exposing metadata to JavaScript.
+#[wasm_bindgen]
+pub struct VortexFileHandle {
+    vxf: VortexFile,
+    session: VortexSession,
+    file_size: usize,
+    array_read_ctx: Option<ReadContext>,
+}
+
+#[wasm_bindgen]
+impl VortexFileHandle {
+    /// The total number of rows in the file.
+    #[wasm_bindgen(getter)]
+    pub fn row_count(&self) -> u64 {
+        self.vxf.row_count()
+    }
+
+    /// The top-level DType of the file as a string.
+    #[wasm_bindgen(getter)]
+    pub fn dtype(&self) -> String {
+        format!("{}", self.vxf.dtype())
+    }
+
+    /// Returns the layout tree as a JSON string matching the TS `LayoutTreeNode` type.
+    pub fn layout_tree(&self) -> Result<String, JsValue> {
+        let root = self.vxf.footer().layout().clone();
+        let tree = build_layout_tree(root, "root".to_string(), 0, &ChildKindJson::Root)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        serde_json::to_string(&tree)
+            .map_err(|e| JsValue::from_str(&format!("JSON serialization failed: {e}")))
+    }
+
+    /// Returns the segment map as a JSON string matching the TS `SegmentMapEntry[]` type.
+    pub fn segment_map(&self) -> Result<String, JsValue> {
+        let footer = self.vxf.footer();
+        let root_layout = footer.layout().clone();
+        let segment_map = footer.segment_map();
+
+        // BFS to map each segment ID to its layout path and column name.
+        let mut segment_paths: Vec<Option<(String, Option<String>)>> =
+            vec![None; segment_map.len()];
+
+        let mut queue: VecDeque<(String, Option<String>, LayoutRef)> =
+            VecDeque::from([(String::from("root"), None, root_layout)]);
+
+        while let Some((path, column, layout)) = queue.pop_front() {
+            for segment in layout.segment_ids() {
+                let idx = *segment as usize;
+                if idx < segment_paths.len() {
+                    segment_paths[idx] = Some((path.clone(), column.clone()));
+                }
+            }
+
+            if let Ok(children) = layout.children() {
+                for (i, child_layout) in children.into_iter().enumerate() {
+                    let child_type = layout.child_type(i);
+                    let child_name = child_type.name();
+                    let child_path = format!("{path}.{child_name}");
+
+                    // Track the column: use this field's name if it's a Field, otherwise
+                    // inherit the parent's column.
+                    let child_column = match &child_type {
+                        LayoutChildType::Field(name) => Some(name.to_string()),
+                        _ => column.clone(),
+                    };
+
+                    queue.push_back((child_path, child_column, child_layout));
+                }
+            }
+        }
+
+        let entries: Vec<SegmentMapEntryJson> = segment_map
+            .iter()
+            .enumerate()
+            .map(|(i, spec)| {
+                let (layout_path, column) = segment_paths[i]
+                    .clone()
+                    .unwrap_or_else(|| (String::from("<unknown>"), None));
+                SegmentMapEntryJson {
+                    index: i,
+                    byte_offset: spec.offset,
+                    byte_length: spec.length,
+                    alignment: *spec.alignment,
+                    column,
+                    layout_path,
+                }
+            })
+            .collect();
+
+        serde_json::to_string(&entries)
+            .map_err(|e| JsValue::from_str(&format!("JSON serialization failed: {e}")))
+    }
+
+    /// Returns file structure info as a JSON string matching the TS `FileStructureInfo` type.
+    pub fn file_structure(&self) -> Result<String, JsValue> {
+        let footer = self.vxf.footer();
+        let segment_map = footer.segment_map();
+
+        let total_data_bytes: u64 = segment_map.iter().map(|s| s.length as u64).sum();
+
+        let total_metadata_bytes =
+            sum_metadata_bytes(footer.layout()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let info = FileStructureJson {
+            file_size: self.file_size as u64,
+            version: VERSION,
+            postscript_size: 64,
+            total_data_bytes,
+            total_metadata_bytes,
+        };
+
+        serde_json::to_string(&info)
+            .map_err(|e| JsValue::from_str(&format!("JSON serialization failed: {e}")))
+    }
+
+    /// Preview data from a specific layout node, returning Arrow IPC stream bytes.
+    ///
+    /// Navigates to the layout node identified by `node_id` (e.g. "root.customer_id.[0]"),
+    /// creates a layout reader, scans up to `row_limit` rows, and returns Arrow IPC bytes.
+    pub async fn preview_data(
+        &self,
+        node_id: &str,
+        row_limit: u32,
+    ) -> Result<js_sys::Uint8Array, JsValue> {
+        let layout = find_layout_by_id(self.vxf.footer().layout(), node_id)
+            .ok_or_else(|| JsValue::from_str(&format!("Layout node not found: {node_id}")))?;
+
+        let segment_source = self.vxf.segment_source();
+        let reader = layout
+            .new_reader(node_id.into(), segment_source, &self.session)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let stream = ScanBuilder::new(self.session.clone(), reader)
+            .with_limit(row_limit as u64)
+            .into_array_stream()
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let dtype = stream.dtype().clone();
+        let chunks: Vec<ArrayRef> = stream
+            .try_collect()
+            .await
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let schema =
+            dtype_to_schema(&dtype, "value").map_err(|e| JsValue::from_str(&e.to_string()))?;
+        let arrow_schema = Arc::new(schema);
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = StreamWriter::try_new(&mut buf, &arrow_schema)
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+            for chunk in chunks {
+                let batch = array_to_record_batch(chunk, &dtype, &arrow_schema)
+                    .map_err(|e| JsValue::from_str(&e.to_string()))?;
+                writer
+                    .write(&batch)
+                    .map_err(|e| JsValue::from_str(&e.to_string()))?;
+            }
+
+            writer
+                .finish()
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+        }
+
+        Ok(js_sys::Uint8Array::from(buf.as_slice()))
+    }
+
+    /// Fetch the array encoding tree for a flat layout node.
+    ///
+    /// Finds the layout by node ID, reads the segment, fully decodes the array
+    /// to extract dtype, child names, and buffer names from the encoding vtables.
+    pub async fn fetch_encoding_tree(&self, node_id: String) -> Result<String, JsValue> {
+        let ctx = self
+            .array_read_ctx
+            .as_ref()
+            .ok_or_else(|| JsValue::from_str("No array ReadContext available"))?;
+
+        let layout = find_layout_by_id(self.vxf.footer().layout(), &node_id)
+            .ok_or_else(|| JsValue::from_str(&format!("Layout node not found: {node_id}")))?;
+
+        let flat = layout
+            .as_opt::<Flat>()
+            .ok_or_else(|| JsValue::from_str("Node is not a flat layout"))?;
+
+        let segment_id = flat.segment_id();
+        let dtype = layout.dtype().clone();
+        let row_count = layout.row_count() as usize;
+
+        let buf = self
+            .vxf
+            .segment_source()
+            .request(segment_id)
+            .await
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let parts =
+            SerializedArray::try_from(buf).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let array = parts
+            .decode(&dtype, row_count, ctx, &self.session)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let tree = build_array_encoding_tree_from_array(&array, &self.session);
+        serde_json::to_string(&tree)
+            .map_err(|e| JsValue::from_str(&format!("JSON serialization failed: {e}")))
+    }
+
+    /// Fetch a buffer from a decoded array node.
+    ///
+    /// `layout_node_id` identifies the flat layout, `array_path` is a list of
+    /// child names to navigate within the decoded array tree (e.g. `["values", "encoded"]`),
+    /// and `buffer_index` selects which buffer of the target array node to return.
+    pub async fn fetch_array_buffer(
+        &self,
+        layout_node_id: String,
+        array_path: Vec<String>,
+        buffer_index: usize,
+    ) -> Result<js_sys::Uint8Array, JsValue> {
+        let ctx = self
+            .array_read_ctx
+            .as_ref()
+            .ok_or_else(|| JsValue::from_str("No array ReadContext available"))?;
+
+        let layout =
+            find_layout_by_id(self.vxf.footer().layout(), &layout_node_id).ok_or_else(|| {
+                JsValue::from_str(&format!("Layout node not found: {layout_node_id}"))
+            })?;
+
+        let flat = layout
+            .as_opt::<Flat>()
+            .ok_or_else(|| JsValue::from_str("Node is not a flat layout"))?;
+
+        let segment_id = flat.segment_id();
+        let dtype = layout.dtype().clone();
+        let row_count = layout.row_count() as usize;
+
+        let buf = self
+            .vxf
+            .segment_source()
+            .request(segment_id)
+            .await
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let parts =
+            SerializedArray::try_from(buf).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let root_array = parts
+            .decode(&dtype, row_count, ctx, &self.session)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        // Navigate the array tree by child names.
+        let mut current = root_array;
+        for child_name in &array_path {
+            let named = current.named_children();
+            let child = named
+                .into_iter()
+                .find(|(name, _)| name == child_name)
+                .map(|(_, arr)| arr)
+                .ok_or_else(|| {
+                    JsValue::from_str(&format!("Array child not found: {child_name}"))
+                })?;
+            current = child;
+        }
+
+        let handles = current.buffer_handles();
+        let handle = handles.get(buffer_index).ok_or_else(|| {
+            JsValue::from_str(&format!(
+                "Buffer index {buffer_index} out of range ({})",
+                handles.len()
+            ))
+        })?;
+
+        Ok(js_sys::Uint8Array::from(handle.as_host().as_slice()))
+    }
+
+    /// Preview data from a specific array node within a flat layout.
+    ///
+    /// Decodes the array from the flat layout's segment, navigates to the
+    /// target array child by name path, and returns Arrow IPC bytes.
+    pub async fn preview_array_data(
+        &self,
+        layout_node_id: String,
+        array_path: Vec<String>,
+        row_limit: u32,
+    ) -> Result<js_sys::Uint8Array, JsValue> {
+        let ctx = self
+            .array_read_ctx
+            .as_ref()
+            .ok_or_else(|| JsValue::from_str("No array ReadContext available"))?;
+
+        let layout =
+            find_layout_by_id(self.vxf.footer().layout(), &layout_node_id).ok_or_else(|| {
+                JsValue::from_str(&format!("Layout node not found: {layout_node_id}"))
+            })?;
+
+        let flat = layout
+            .as_opt::<Flat>()
+            .ok_or_else(|| JsValue::from_str("Node is not a flat layout"))?;
+
+        let segment_id = flat.segment_id();
+        let dtype = layout.dtype().clone();
+        let row_count = layout.row_count() as usize;
+
+        let buf = self
+            .vxf
+            .segment_source()
+            .request(segment_id)
+            .await
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let parts =
+            SerializedArray::try_from(buf).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let root_array = parts
+            .decode(&dtype, row_count, ctx, &self.session)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        // Navigate to the target array node.
+        let mut current = root_array;
+        for child_name in &array_path {
+            let named = current.named_children();
+            let child = named
+                .into_iter()
+                .find(|(name, _)| name == child_name)
+                .map(|(_, arr)| arr)
+                .ok_or_else(|| {
+                    JsValue::from_str(&format!("Array child not found: {child_name}"))
+                })?;
+            current = child;
+        }
+
+        // Slice to row_limit.
+        let len = current.len().min(row_limit as usize);
+        if len < current.len() {
+            current = current
+                .slice(0..len)
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+        }
+
+        // Convert to Arrow IPC.
+        let array_dtype = current.dtype().clone();
+        let schema = dtype_to_schema(&array_dtype, "value")
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+        let arrow_schema = Arc::new(schema);
+
+        let batch = array_to_record_batch(current, &array_dtype, &arrow_schema)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        let mut ipc_buf = Vec::new();
+        {
+            let mut writer = StreamWriter::try_new(&mut ipc_buf, &arrow_schema)
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+            writer
+                .write(&batch)
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+            writer
+                .finish()
+                .map_err(|e| JsValue::from_str(&e.to_string()))?;
+        }
+
+        Ok(js_sys::Uint8Array::from(ipc_buf.as_slice()))
+    }
+}
+
+/// Recursively build the layout tree JSON structure.
+fn build_layout_tree(
+    layout: LayoutRef,
+    id: String,
+    parent_row_offset: u64,
+    child_type: &ChildKindJson,
+) -> VortexResult<LayoutTreeNodeJson> {
+    let row_count = layout.row_count();
+    let children_result = layout.children();
+
+    let mut children_json = Vec::new();
+    if let Ok(children) = children_result {
+        for (i, child_layout) in children.iter().enumerate() {
+            let ct = layout.child_type(i);
+            let child_name = ct.name();
+            let child_id = format!("{id}.{child_name}");
+
+            let child_row_offset = match &ct {
+                LayoutChildType::Chunk((_, rel)) => parent_row_offset + rel,
+                LayoutChildType::Auxiliary(_) => 0,
+                LayoutChildType::Transparent(_) | LayoutChildType::Field(_) => parent_row_offset,
+            };
+
+            let child_kind = match &ct {
+                LayoutChildType::Transparent(name) => ChildKindJson::Transparent {
+                    name: name.to_string(),
+                },
+                LayoutChildType::Auxiliary(name) => ChildKindJson::Auxiliary {
+                    name: name.to_string(),
+                },
+                LayoutChildType::Chunk((idx, row_offset)) => ChildKindJson::Chunk {
+                    chunk_index: *idx,
+                    row_offset: parent_row_offset + row_offset,
+                },
+                LayoutChildType::Field(name) => ChildKindJson::Field {
+                    field_name: name.to_string(),
+                },
+            };
+
+            children_json.push(build_layout_tree(
+                child_layout.clone(),
+                child_id,
+                child_row_offset,
+                &child_kind,
+            )?);
+        }
+    }
+
+    // For flat layouts, extract the array encoding tree if available.
+    let array_encoding_tree = layout.as_opt::<Flat>().and_then(|flat| {
+        let tree_buf = flat.array_tree()?;
+        let ctx = flat.array_ctx();
+        let parts = SerializedArray::from_array_tree(tree_buf.as_ref().to_vec()).ok()?;
+        Some(build_array_encoding_tree(&parts, ctx))
+    });
+
+    Ok(LayoutTreeNodeJson {
+        id,
+        encoding: layout.encoding().id().to_string(),
+        dtype: layout.dtype().to_string(),
+        row_count,
+        row_offset: parent_row_offset,
+        metadata_bytes: layout.metadata().len(),
+        segment_ids: layout.segment_ids().iter().map(|s| **s).collect(),
+        child_type: child_type.clone(),
+        children: children_json,
+        array_encoding_tree,
+    })
+}
+
+/// DFS to sum metadata bytes across all layout nodes.
+fn sum_metadata_bytes(layout: &LayoutRef) -> VortexResult<u64> {
+    let mut total = 0u64;
+    for node in layout.depth_first_traversal() {
+        total += node?.metadata().len() as u64;
+    }
+    Ok(total)
+}
+
+/// Recursively build the array encoding tree from `ArrayParts` (used for inline trees
+/// where we don't have a fully decoded array).
+fn build_array_encoding_tree(parts: &SerializedArray, ctx: &ReadContext) -> ArrayEncodingNodeJson {
+    let encoding = ctx
+        .resolve(parts.encoding_id())
+        .map(|id| id.to_string())
+        .unwrap_or_else(|| format!("unknown({})", parts.encoding_id()));
+
+    let nchildren = parts.nchildren();
+    let children: Vec<ArrayEncodingNodeJson> = (0..nchildren)
+        .map(|i| build_array_encoding_tree(&parts.child(i), ctx))
+        .collect();
+
+    ArrayEncodingNodeJson {
+        encoding,
+        dtype: String::new(),
+        metadata_bytes: parts.metadata().len(),
+        num_buffers: parts.nbuffers(),
+        buffer_lengths: parts.buffer_lengths(),
+        buffer_names: Vec::new(),
+        children,
+        child_names: (0..nchildren).map(|i| format!("child {i}")).collect(),
+    }
+}
+
+/// Recursively build the array encoding tree from a fully decoded array,
+/// extracting dtype, child names, and buffer names from the encoding vtables.
+fn build_array_encoding_tree_from_array(
+    array: &ArrayRef,
+    session: &VortexSession,
+) -> ArrayEncodingNodeJson {
+    let encoding = array.encoding_id().to_string();
+    let dtype = array.dtype().to_string();
+    let buffer_names = array.buffer_names();
+    let buffer_handles = array.buffer_handles();
+    let buffer_lengths: Vec<usize> = buffer_handles.iter().map(|b| b.len()).collect();
+    let metadata_bytes = session
+        .array_serialize(array)
+        .ok()
+        .flatten()
+        .map(|m| m.len())
+        .unwrap_or(0);
+
+    let named_children = array.named_children();
+    let child_names: Vec<String> = named_children
+        .iter()
+        .map(|(name, _)| name.clone())
+        .collect();
+    let children: Vec<ArrayEncodingNodeJson> = named_children
+        .iter()
+        .map(|(_, child)| build_array_encoding_tree_from_array(child, session))
+        .collect();
+
+    ArrayEncodingNodeJson {
+        encoding,
+        dtype,
+        metadata_bytes,
+        num_buffers: buffer_lengths.len(),
+        buffer_lengths,
+        buffer_names,
+        children,
+        child_names,
+    }
+}
+
+/// Navigate the layout tree to find a node by its dot-separated ID path.
+///
+/// IDs match the format: "root.field_name.chunked.[0]" where each segment
+/// corresponds to a `LayoutChildType::name()`.
+fn find_layout_by_id(root: &LayoutRef, node_id: &str) -> Option<LayoutRef> {
+    let segments: Vec<&str> = node_id.split('.').collect();
+    if segments.is_empty() || segments[0] != "root" {
+        return None;
+    }
+    if segments.len() == 1 {
+        return Some(root.clone());
+    }
+
+    let mut current = root.clone();
+    for seg in &segments[1..] {
+        let children = current.children().ok()?;
+        let mut found = false;
+        for (i, child) in children.into_iter().enumerate() {
+            let name = current.child_type(i).name();
+            if name.as_ref() == *seg {
+                current = child;
+                found = true;
+                break;
+            }
+        }
+        if !found {
+            return None;
+        }
+    }
+    Some(current)
+}
+
+/// Downgrade Arrow `*View` types to their non-view equivalents so the JS
+/// `apache-arrow` library can decode them.
+fn downgrade_arrow_type(dt: DataType) -> DataType {
+    match dt {
+        DataType::Utf8View => DataType::LargeUtf8,
+        DataType::BinaryView => DataType::LargeBinary,
+        DataType::Struct(fields) => DataType::Struct(
+            fields
+                .iter()
+                .map(|f| {
+                    Arc::new(Field::new(
+                        f.name(),
+                        downgrade_arrow_type(f.data_type().clone()),
+                        f.is_nullable(),
+                    ))
+                })
+                .collect(),
+        ),
+        DataType::List(f) => DataType::List(Arc::new(Field::new(
+            f.name(),
+            downgrade_arrow_type(f.data_type().clone()),
+            f.is_nullable(),
+        ))),
+        DataType::LargeList(f) => DataType::LargeList(Arc::new(Field::new(
+            f.name(),
+            downgrade_arrow_type(f.data_type().clone()),
+            f.is_nullable(),
+        ))),
+        other => other,
+    }
+}
+
+/// Create an Arrow Schema from a Vortex DType, with view types downgraded.
+fn dtype_to_schema(dtype: &DType, default_name: &str) -> VortexResult<Schema> {
+    let schema = match dtype {
+        DType::Struct(..) => dtype.to_arrow_schema()?,
+        other => {
+            let arrow_dt = other.to_arrow_dtype()?;
+            let nullable = other.is_nullable();
+            Schema::new(vec![Field::new(default_name, arrow_dt, nullable)])
+        }
+    };
+    // Downgrade view types in all fields.
+    Ok(Schema::new(
+        schema
+            .fields()
+            .iter()
+            .map(|f| {
+                Field::new(
+                    f.name(),
+                    downgrade_arrow_type(f.data_type().clone()),
+                    f.is_nullable(),
+                )
+            })
+            .collect::<Vec<_>>(),
+    ))
+}
+
+/// Convert a Vortex ArrayRef into an Arrow RecordBatch using the given schema.
+///
+/// Always uses `execute_arrow` with explicit types to ensure view types are avoided.
+fn array_to_record_batch(
+    array: ArrayRef,
+    dtype: &DType,
+    schema: &Arc<Schema>,
+) -> VortexResult<RecordBatch> {
+    let data_type = match dtype {
+        DType::Struct(..) => DataType::Struct(schema.fields().clone()),
+        _ => schema.field(0).data_type().clone(),
+    };
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let arrow = array.execute_arrow(Some(&data_type), &mut ctx)?;
+    match dtype {
+        DType::Struct(..) => Ok(RecordBatch::from(arrow.as_struct().clone())),
+        _ => Ok(RecordBatch::try_new(schema.clone(), vec![arrow])?),
+    }
+}
+
+// --- JSON serialization types ---
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct LayoutTreeNodeJson {
+    id: String,
+    encoding: String,
+    dtype: String,
+    row_count: u64,
+    row_offset: u64,
+    metadata_bytes: usize,
+    segment_ids: Vec<u32>,
+    child_type: ChildKindJson,
+    children: Vec<LayoutTreeNodeJson>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    array_encoding_tree: Option<ArrayEncodingNodeJson>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ArrayEncodingNodeJson {
+    encoding: String,
+    dtype: String,
+    metadata_bytes: usize,
+    num_buffers: usize,
+    buffer_lengths: Vec<usize>,
+    buffer_names: Vec<String>,
+    children: Vec<ArrayEncodingNodeJson>,
+    child_names: Vec<String>,
+}
+
+#[derive(Serialize, Clone)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+enum ChildKindJson {
+    #[serde(rename_all = "camelCase")]
+    Root,
+    #[serde(rename_all = "camelCase")]
+    Field { field_name: String },
+    #[serde(rename_all = "camelCase")]
+    Chunk { chunk_index: usize, row_offset: u64 },
+    #[serde(rename_all = "camelCase")]
+    Transparent { name: String },
+    #[serde(rename_all = "camelCase")]
+    Auxiliary { name: String },
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SegmentMapEntryJson {
+    index: usize,
+    byte_offset: u64,
+    byte_length: u32,
+    alignment: usize,
+    column: Option<String>,
+    layout_path: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct FileStructureJson {
+    file_size: u64,
+    version: u16,
+    postscript_size: u64,
+    total_data_bytes: u64,
+    total_metadata_bytes: u64,
+}
diff --git a/vortex-web/eslint.config.ts b/vortex-web/eslint.config.ts
new file mode 100644
index 00000000000..ecc2fe28df0
--- /dev/null
+++ b/vortex-web/eslint.config.ts
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import js from "@eslint/js";
+import globals from "globals";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+import prettier from "eslint-config-prettier";
+import storybook from "eslint-plugin-storybook";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config({ ignores: ["dist", "storybook-static"] }, {
+  extends: [js.configs.recommended, ...tseslint.configs.recommended],
+  files: ["**/*.{ts,tsx}"],
+  languageOptions: {
+    ecmaVersion: 2020,
+    globals: globals.browser,
+  },
+  plugins: {
+    "react-hooks": reactHooks,
+    "react-refresh": reactRefresh,
+  },
+  rules: {
+    ...reactHooks.configs.recommended.rules,
+    "react-refresh/only-export-components": [
+      "warn",
+      { allowConstantExport: true },
+    ],
+  },
+}, storybook.configs["flat/recommended"], prettier);
diff --git a/vortex-web/index.html b/vortex-web/index.html
new file mode 100644
index 00000000000..6ed92bb0d33
--- /dev/null
+++ b/vortex-web/index.html
@@ -0,0 +1,23 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!-- SPDX-FileCopyrightText: Copyright the Vortex contributors -->
+
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vortex Explorer</title>
+    <link rel="icon" type="image/svg+xml" href="/logo-icon.svg" />
+
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300&family=Geist:wght@100..900&family=Geist+Mono:wght@100..900&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/vortex-web/package-lock.json b/vortex-web/package-lock.json
new file mode 100644
index 00000000000..1fd57153b0f
--- /dev/null
+++ b/vortex-web/package-lock.json
@@ -0,0 +1,5480 @@
+{
+  "name": "vortex-web",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "vortex-web",
+      "version": "0.1.0",
+      "dependencies": {
+        "@tanstack/react-table": "^8.21.3",
+        "@tanstack/react-virtual": "^3.13.23",
+        "apache-arrow": "^21.1.0",
+        "d3-hierarchy": "^3.1.2",
+        "react": "^19.1.0",
+        "react-dom": "^19.1.0"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.25.0",
+        "@storybook/addon-docs": "^10.3.3",
+        "@storybook/react-vite": "^10.3.3",
+        "@tailwindcss/vite": "^4.1.4",
+        "@types/d3-hierarchy": "^3.1.7",
+        "@types/react": "^19.1.2",
+        "@types/react-dom": "^19.1.2",
+        "@vitejs/plugin-react": "^4.4.1",
+        "eslint": "^9.25.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-react-hooks": "^5.2.0",
+        "eslint-plugin-react-refresh": "^0.4.20",
+        "eslint-plugin-storybook": "^10.3.3",
+        "globals": "^16.0.0",
+        "prettier": "^3.8.1",
+        "storybook": "^10.3.3",
+        "tailwindcss": "^4.1.4",
+        "typescript": "~5.7.0",
+        "typescript-eslint": "^8.30.1",
+        "vite": "^6.3.2"
+      }
+    },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.4.4",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.4.4.tgz",
+      "integrity": "sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==",
+      "dev": true,
+      "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "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",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "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==",
+      "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",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
+      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.5"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.5",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
+      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.14.0",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.5",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
+      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@joshwooding/vite-plugin-react-docgen-typescript": {
+      "version": "0.6.4",
+      "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz",
+      "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^13.0.1",
+        "react-docgen-typescript": "^2.2.2"
+      },
+      "peerDependencies": {
+        "typescript": ">= 4.3.x",
+        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@mdx-js/react": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz",
+      "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdx": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=16",
+        "react": ">=16"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "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==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.0.tgz",
+      "integrity": "sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.0.tgz",
+      "integrity": "sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.0.tgz",
+      "integrity": "sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.0.tgz",
+      "integrity": "sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.0.tgz",
+      "integrity": "sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.0.tgz",
+      "integrity": "sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.0.tgz",
+      "integrity": "sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.0.tgz",
+      "integrity": "sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.0.tgz",
+      "integrity": "sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.0.tgz",
+      "integrity": "sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.0.tgz",
+      "integrity": "sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.0.tgz",
+      "integrity": "sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.0.tgz",
+      "integrity": "sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.0.tgz",
+      "integrity": "sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.0.tgz",
+      "integrity": "sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.0.tgz",
+      "integrity": "sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.0.tgz",
+      "integrity": "sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.0.tgz",
+      "integrity": "sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.0.tgz",
+      "integrity": "sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.0.tgz",
+      "integrity": "sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.0.tgz",
+      "integrity": "sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.0.tgz",
+      "integrity": "sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.0.tgz",
+      "integrity": "sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@storybook/addon-docs": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.3.3.tgz",
+      "integrity": "sha512-trJQTpOtuOEuNv1Rn8X2Sopp5hSPpb0u0soEJ71BZAbxe4d2Y1d/1MYcxBdRKwncum6sCTsnxTpqQ/qvSJKlTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mdx-js/react": "^3.0.0",
+        "@storybook/csf-plugin": "10.3.3",
+        "@storybook/icons": "^2.0.1",
+        "@storybook/react-dom-shim": "10.3.3",
+        "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"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "peerDependencies": {
+        "storybook": "^10.3.3"
+      }
+    },
+    "node_modules/@storybook/builder-vite": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.3.3.tgz",
+      "integrity": "sha512-awspKCTZvXyeV3KabL0id62mFbxR5u/5yyGQultwCiSb2/yVgBfip2MAqLyS850pvTiB6QFVM9deOyd2/G/bEA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@storybook/csf-plugin": "10.3.3",
+        "ts-dedent": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "peerDependencies": {
+        "storybook": "^10.3.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/@storybook/csf-plugin": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.3.3.tgz",
+      "integrity": "sha512-Utlh7zubm+4iOzBBfzLW4F4vD99UBtl2Do4edlzK2F7krQIcFvR2ontjAE8S1FQVLZAC3WHalCOS+Ch8zf3knA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "unplugin": "^2.3.5"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "peerDependencies": {
+        "esbuild": "*",
+        "rollup": "*",
+        "storybook": "^10.3.3",
+        "vite": "*",
+        "webpack": "*"
+      },
+      "peerDependenciesMeta": {
+        "esbuild": {
+          "optional": true
+        },
+        "rollup": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        },
+        "webpack": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@storybook/global": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@storybook/global/-/global-5.0.0.tgz",
+      "integrity": "sha512-FcOqPAXACP0I3oJ/ws6/rrPT9WGhu915Cg8D02a9YxLo0DE9zI+a9A5gRGvmQ09fiWPukqI8ZAEoQEdWUKMQdQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@storybook/icons": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@storybook/icons/-/icons-2.0.1.tgz",
+      "integrity": "sha512-/smVjw88yK3CKsiuR71vNgWQ9+NuY2L+e8X7IMrFjexjm6ZR8ULrV2DRkTA61aV6ryefslzHEGDInGpnNeIocg==",
+      "dev": true,
+      "license": "MIT",
+      "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"
+      }
+    },
+    "node_modules/@storybook/react": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.3.3.tgz",
+      "integrity": "sha512-cGG5TbR8Tdx9zwlpsWyBEfWrejm5iWdYF26EwIhwuKq9GFUTAVrQzo0Rs7Tqc3ZyVhRS/YfsRiWSEH+zmq2JiQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@storybook/global": "^5.0.0",
+        "@storybook/react-dom-shim": "10.3.3",
+        "react-docgen": "^8.0.2",
+        "react-docgen-typescript": "^2.2.2"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "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.3.3",
+        "typescript": ">= 4.9.x"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@storybook/react-dom-shim": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.3.3.tgz",
+      "integrity": "sha512-lkhuh4G3UTreU9M3Iz5Dt32c6U+l/4XuvqLtbe1sDHENZH6aPj7y0b5FwnfHyvuTvYRhtbo29xZrF5Bp9kCC0w==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "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.3.3"
+      }
+    },
+    "node_modules/@storybook/react-vite": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.3.3.tgz",
+      "integrity": "sha512-qHdlBe1hjqFAGXa8JL7bWTLbP/gDqXbWDm+SYCB646NHh5yvVDkZLwigP5Y+UL7M2ASfqFtosnroUK9tcCM2dw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4",
+        "@rollup/pluginutils": "^5.0.2",
+        "@storybook/builder-vite": "10.3.3",
+        "@storybook/react": "10.3.3",
+        "empathic": "^2.0.0",
+        "magic-string": "^0.30.0",
+        "react-docgen": "^8.0.0",
+        "resolve": "^1.22.8",
+        "tsconfig-paths": "^4.2.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "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.3.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/@swc/helpers": {
+      "version": "0.5.20",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.20.tgz",
+      "integrity": "sha512-2egEBHUMasdypIzrprsu8g+OEVd7Vp2MM3a2eVlM/cyFYto0nGz5BX5BTgh/ShZZI9ed+ozEq+Ngt+rgmUs8tw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.2.2.tgz",
+      "integrity": "sha512-pXS+wJ2gZpVXqFaUEjojq7jzMpTGf8rU6ipJz5ovJV6PUGmlJ+jvIwGrzdHdQ80Sg+wmQxUFuoW1UAAwHNEdFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "enhanced-resolve": "^5.19.0",
+        "jiti": "^2.6.1",
+        "lightningcss": "1.32.0",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.2.2"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.2.2.tgz",
+      "integrity": "sha512-qEUA07+E5kehxYp9BVMpq9E8vnJuBHfJEC0vPC5e7iL/hw7HR61aDKoVoKzrG+QKp56vhNZe4qwkRmMC0zDLvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.2.2",
+        "@tailwindcss/oxide-darwin-arm64": "4.2.2",
+        "@tailwindcss/oxide-darwin-x64": "4.2.2",
+        "@tailwindcss/oxide-freebsd-x64": "4.2.2",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.2",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.2.2",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.2.2",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.2.2",
+        "@tailwindcss/oxide-linux-x64-musl": "4.2.2",
+        "@tailwindcss/oxide-wasm32-wasi": "4.2.2",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.2.2",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.2.2"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.2.2.tgz",
+      "integrity": "sha512-dXGR1n+P3B6748jZO/SvHZq7qBOqqzQ+yFrXpoOWWALWndF9MoSKAT3Q0fYgAzYzGhxNYOoysRvYlpixRBBoDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.2.2.tgz",
+      "integrity": "sha512-iq9Qjr6knfMpZHj55/37ouZeykwbDqF21gPFtfnhCCKGDcPI/21FKC9XdMO/XyBM7qKORx6UIhGgg6jLl7BZlg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.2.2.tgz",
+      "integrity": "sha512-BlR+2c3nzc8f2G639LpL89YY4bdcIdUmiOOkv2GQv4/4M0vJlpXEa0JXNHhCHU7VWOKWT/CjqHdTP8aUuDJkuw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.2.2.tgz",
+      "integrity": "sha512-YUqUgrGMSu2CDO82hzlQ5qSb5xmx3RUrke/QgnoEx7KvmRJHQuZHZmZTLSuuHwFf0DJPybFMXMYf+WJdxHy/nQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.2.2.tgz",
+      "integrity": "sha512-FPdhvsW6g06T9BWT0qTwiVZYE2WIFo2dY5aCSpjG/S/u1tby+wXoslXS0kl3/KXnULlLr1E3NPRRw0g7t2kgaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.2.2.tgz",
+      "integrity": "sha512-4og1V+ftEPXGttOO7eCmW7VICmzzJWgMx+QXAJRAhjrSjumCwWqMfkDrNu1LXEQzNAwz28NCUpucgQPrR4S2yw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.2.2.tgz",
+      "integrity": "sha512-oCfG/mS+/+XRlwNjnsNLVwnMWYH7tn/kYPsNPh+JSOMlnt93mYNCKHYzylRhI51X+TbR+ufNhhKKzm6QkqX8ag==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.2.2.tgz",
+      "integrity": "sha512-rTAGAkDgqbXHNp/xW0iugLVmX62wOp2PoE39BTCGKjv3Iocf6AFbRP/wZT/kuCxC9QBh9Pu8XPkv/zCZB2mcMg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.2.2.tgz",
+      "integrity": "sha512-XW3t3qwbIwiSyRCggeO2zxe3KWaEbM0/kW9e8+0XpBgyKU4ATYzcVSMKteZJ1iukJ3HgHBjbg9P5YPRCVUxlnQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.2.2.tgz",
+      "integrity": "sha512-eKSztKsmEsn1O5lJ4ZAfyn41NfG7vzCg496YiGtMDV86jz1q/irhms5O0VrY6ZwTUkFy/EKG3RfWgxSI3VbZ8Q==",
+      "bundleDependencies": [
+        "@napi-rs/wasm-runtime",
+        "@emnapi/core",
+        "@emnapi/runtime",
+        "@tybys/wasm-util",
+        "@emnapi/wasi-threads",
+        "tslib"
+      ],
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.8.1",
+        "@emnapi/runtime": "^1.8.1",
+        "@emnapi/wasi-threads": "^1.1.0",
+        "@napi-rs/wasm-runtime": "^1.1.1",
+        "@tybys/wasm-util": "^0.10.1",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.1.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
+      "version": "1.1.0",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1",
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/tslib": {
+      "version": "2.8.1",
+      "dev": true,
+      "inBundle": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.2.2.tgz",
+      "integrity": "sha512-qPmaQM4iKu5mxpsrWZMOZRgZv1tOZpUm+zdhhQP0VhJfyGGO3aUKdbh3gDZc/dPLQwW4eSqWGrrcWNBZWUWaXQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.2.2.tgz",
+      "integrity": "sha512-1T/37VvI7WyH66b+vqHj/cLwnCxt7Qt3WFu5Q8hk65aOvlwAhs7rAp1VkulBJw/N4tMirXjVnylTR72uI0HGcA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/vite": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.2.2.tgz",
+      "integrity": "sha512-mEiF5HO1QqCLXoNEfXVA1Tzo+cYsrqV7w9Juj2wdUFyW07JRenqMG225MvPwr3ZD9N1bFQj46X7r33iHxLUW0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tailwindcss/node": "4.2.2",
+        "@tailwindcss/oxide": "4.2.2",
+        "tailwindcss": "4.2.2"
+      },
+      "peerDependencies": {
+        "vite": "^5.2.0 || ^6 || ^7 || ^8"
+      }
+    },
+    "node_modules/@tanstack/react-table": {
+      "version": "8.21.3",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-table/-/react-table-8.21.3.tgz",
+      "integrity": "sha512-5nNMTSETP4ykGegmVkhjcS8tTLW6Vl4axfEGQN3v0zdHYbK4UfoqfPChclTrJ4EoK9QynqAu9oUf8VEmrpZ5Ww==",
+      "license": "MIT",
+      "dependencies": {
+        "@tanstack/table-core": "8.21.3"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      },
+      "peerDependencies": {
+        "react": ">=16.8",
+        "react-dom": ">=16.8"
+      }
+    },
+    "node_modules/@tanstack/react-virtual": {
+      "version": "3.13.23",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.13.23.tgz",
+      "integrity": "sha512-XnMRnHQ23piOVj2bzJqHrRrLg4r+F86fuBcwteKfbIjJrtGxb4z7tIvPVAe4B+4UVwo9G4Giuz5fmapcrnZ0OQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@tanstack/virtual-core": "3.13.23"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      },
+      "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"
+      }
+    },
+    "node_modules/@tanstack/table-core": {
+      "version": "8.21.3",
+      "resolved": "https://registry.npmjs.org/@tanstack/table-core/-/table-core-8.21.3.tgz",
+      "integrity": "sha512-ldZXEhOBb8Is7xLs01fR3YEc3DERiz5silj8tnGkFZytt1abEvl/GhUmCE0PMLaMPTa3Jk4HbKmRlHmu+gCftg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      }
+    },
+    "node_modules/@tanstack/virtual-core": {
+      "version": "3.13.23",
+      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.13.23.tgz",
+      "integrity": "sha512-zSz2Z2HNyLjCplANTDyl3BcdQJc2k1+yyFoKhNRmCr7V7dY8o8q5m8uFTI1/Pg1kL+Hgrz6u3Xo6eFUB7l66cg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      }
+    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.9.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
+      "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/command-line-args": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/command-line-args/-/command-line-args-5.2.3.tgz",
+      "integrity": "sha512-uv0aG6R0Y8WHZLTamZwtfsDLVRnOa+n+n5rEvFWL5Na5gZ8V2Teab/duDPFzIIIhs9qizDpcavCusCLJZu62Kw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/command-line-usage": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/command-line-usage/-/command-line-usage-5.0.4.tgz",
+      "integrity": "sha512-BwR5KP3Es/CSht0xqBcUXS3qCAUVXwpRKsV2+arxeb65atasuXG9LykC9Ab10Cw3s2raH92ZqOeILaQbsB2ACg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/d3-hierarchy": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz",
+      "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/doctrine": {
+      "version": "0.0.9",
+      "resolved": "https://registry.npmjs.org/@types/doctrine/-/doctrine-0.0.9.tgz",
+      "integrity": "sha512-eOIHzCUSH7SMfonMG1LsC2f8vxBFtho6NGBznK41R84YzPuvSBzrhEps33IsQiOW9+VL6NQ9DbjQJznk/S4uRA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "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==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.12.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.0.tgz",
+      "integrity": "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.6",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.6.tgz",
+      "integrity": "sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.57.2.tgz",
+      "integrity": "sha512-NZZgp0Fm2IkD+La5PR81sd+g+8oS6JwJje+aRWsDocxHkjyRw0J5L5ZTlN3LI1LlOcGL7ph3eaIUmTXMIjLk0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.12.2",
+        "@typescript-eslint/scope-manager": "8.57.2",
+        "@typescript-eslint/type-utils": "8.57.2",
+        "@typescript-eslint/utils": "8.57.2",
+        "@typescript-eslint/visitor-keys": "8.57.2",
+        "ignore": "^7.0.5",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.57.2",
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.57.2.tgz",
+      "integrity": "sha512-30ScMRHIAD33JJQkgfGW1t8CURZtjc2JpTrq5n2HFhOefbAhb7ucc7xJwdWcrEtqUIYJ73Nybpsggii6GtAHjA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.57.2",
+        "@typescript-eslint/types": "8.57.2",
+        "@typescript-eslint/typescript-estree": "8.57.2",
+        "@typescript-eslint/visitor-keys": "8.57.2",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.57.2.tgz",
+      "integrity": "sha512-FuH0wipFywXRTHf+bTTjNyuNQQsQC3qh/dYzaM4I4W0jrCqjCVuUh99+xd9KamUfmCGPvbO8NDngo/vsnNVqgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.57.2",
+        "@typescript-eslint/types": "^8.57.2",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.57.2.tgz",
+      "integrity": "sha512-snZKH+W4WbWkrBqj4gUNRIGb/jipDW3qMqVJ4C9rzdFc+wLwruxk+2a5D+uoFcKPAqyqEnSb4l2ULuZf95eSkw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.57.2",
+        "@typescript-eslint/visitor-keys": "8.57.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.57.2.tgz",
+      "integrity": "sha512-3Lm5DSM+DCowsUOJC+YqHHnKEfFh5CoGkj5Z31NQSNF4l5wdOwqGn99wmwN/LImhfY3KJnmordBq/4+VDe2eKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.57.2.tgz",
+      "integrity": "sha512-Co6ZCShm6kIbAM/s+oYVpKFfW7LBc6FXoPXjTRQ449PPNBY8U0KZXuevz5IFuuUj2H9ss40atTaf9dlGLzbWZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.57.2",
+        "@typescript-eslint/typescript-estree": "8.57.2",
+        "@typescript-eslint/utils": "8.57.2",
+        "debug": "^4.4.3",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.57.2.tgz",
+      "integrity": "sha512-/iZM6FnM4tnx9csuTxspMW4BOSegshwX5oBDznJ7S4WggL7Vczz5d2W11ecc4vRrQMQHXRSxzrCsyG5EsPPTbA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.57.2.tgz",
+      "integrity": "sha512-2MKM+I6g8tJxfSmFKOnHv2t8Sk3T6rF20A1Puk0svLK+uVapDZB/4pfAeB7nE83uAZrU6OxW+HmOd5wHVdXwXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.57.2",
+        "@typescript-eslint/tsconfig-utils": "8.57.2",
+        "@typescript-eslint/types": "8.57.2",
+        "@typescript-eslint/visitor-keys": "8.57.2",
+        "debug": "^4.4.3",
+        "minimatch": "^10.2.2",
+        "semver": "^7.7.3",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "10.2.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+      "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.57.2.tgz",
+      "integrity": "sha512-krRIbvPK1ju1WBKIefiX+bngPs+odIQUtR7kymzPfo1POVw3jlF+nLkmexdSSd4UCbDcQn+wMBATOOmpBbqgKg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@typescript-eslint/scope-manager": "8.57.2",
+        "@typescript-eslint/types": "8.57.2",
+        "@typescript-eslint/typescript-estree": "8.57.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.57.2.tgz",
+      "integrity": "sha512-zhahknjobV2FiD6Ee9iLbS7OV9zi10rG26odsQdfBO/hjSzUQbkIYgda+iNKK1zNiW2ey+Lf8MU5btN17V3dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.57.2",
+        "eslint-visitor-keys": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz",
+      "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/expect/node_modules/@vitest/pretty-format": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz",
+      "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/expect/node_modules/@vitest/spy": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz",
+      "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/expect/node_modules/@vitest/utils": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz",
+      "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.4",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/expect/node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/apache-arrow": {
+      "version": "21.1.0",
+      "resolved": "https://registry.npmjs.org/apache-arrow/-/apache-arrow-21.1.0.tgz",
+      "integrity": "sha512-kQrYLxhC+NTVVZ4CCzGF6L/uPVOzJmD1T3XgbiUnP7oTeVFOFgEUu6IKNwCDkpFoBVqDKQivlX4RUFqqnWFlEA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@swc/helpers": "^0.5.11",
+        "@types/command-line-args": "^5.2.3",
+        "@types/command-line-usage": "^5.0.4",
+        "@types/node": "^24.0.3",
+        "command-line-args": "^6.0.1",
+        "command-line-usage": "^7.0.1",
+        "flatbuffers": "^25.1.24",
+        "json-bignum": "^0.0.3",
+        "tslib": "^2.6.2"
+      },
+      "bin": {
+        "arrow2csv": "bin/arrow2csv.js"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/array-back": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/array-back/-/array-back-6.2.3.tgz",
+      "integrity": "sha512-SGDvmg6QTYiTxCBkYVmThcoa67uLl35pyzRHdpCGBOcqFy6BtwnphoFPk7LhJshD+Yk1Kt35WGWeZPTgwR4Fhw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/ast-types": {
+      "version": "0.16.1",
+      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.16.1.tgz",
+      "integrity": "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.10",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.10.tgz",
+      "integrity": "sha512-sUoJ3IMxx4AyRqO4MLeHlnGDkyXRoUG0/AI9fjK+vS72ekpV0yWVY7O0BVjmBcRtkNcsAO2QDZ4tdKKGoI6YaQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/bundle-name": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz",
+      "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "run-applescript": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001781",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001781.tgz",
+      "integrity": "sha512-RdwNCyMsNBftLjW6w01z8bKEvT6e/5tpPVEgtn22TiLGlstHOVecsX2KHFkD5e/vRnIE4EGzpuIODb3mtswtkw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chalk-template": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/chalk-template/-/chalk-template-0.4.0.tgz",
+      "integrity": "sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg==",
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk-template?sponsor=1"
+      }
+    },
+    "node_modules/check-error": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
+      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/command-line-args": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-6.0.2.tgz",
+      "integrity": "sha512-AIjYVxrV9X752LmPDLbVYv8aMCuHPSLZJXEo2qo/xJfv+NYhaZ4sMSF01rM+gHPaMgvPM0l5D/F+Qx+i2WfSmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.3",
+        "find-replace": "^5.0.2",
+        "lodash.camelcase": "^4.3.0",
+        "typical": "^7.3.0"
+      },
+      "engines": {
+        "node": ">=12.20"
+      },
+      "peerDependencies": {
+        "@75lb/nature": "latest"
+      },
+      "peerDependenciesMeta": {
+        "@75lb/nature": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/command-line-usage": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/command-line-usage/-/command-line-usage-7.0.4.tgz",
+      "integrity": "sha512-85UdvzTNx/+s5CkSgBm/0hzP80RFHAa7PsfeADE5ezZF3uHz3/Tqj9gIKGT9PTtpycc3Ua64T0oVulGfKxzfqg==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.2",
+        "chalk-template": "^0.4.0",
+        "table-layout": "^4.1.1",
+        "typical": "^7.3.0"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/d3-hierarchy": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz",
+      "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/default-browser": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz",
+      "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bundle-name": "^4.1.0",
+        "default-browser-id": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/default-browser-id": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz",
+      "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/define-lazy-prop": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+      "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.322",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.322.tgz",
+      "integrity": "sha512-vFU34OcrvMcH66T+dYC3G4nURmgfDVewMIu6Q2urXpumAPSMmzvcn04KVVV8Opikq8Vs5nUbO/8laNhNRqSzYw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/empathic": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/empathic/-/empathic-2.0.0.tgz",
+      "integrity": "sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.20.1",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.20.1.tgz",
+      "integrity": "sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.0"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
+      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.2",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.5",
+        "@eslint/js": "9.39.4",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.5",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-config-prettier": {
+      "version": "10.1.8",
+      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz",
+      "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "eslint-config-prettier": "bin/cli.js"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-config-prettier"
+      },
+      "peerDependencies": {
+        "eslint": ">=7.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.2.0.tgz",
+      "integrity": "sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.4.26",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz",
+      "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": ">=8.40"
+      }
+    },
+    "node_modules/eslint-plugin-storybook": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-storybook/-/eslint-plugin-storybook-10.3.3.tgz",
+      "integrity": "sha512-jo8wZvKaJlxxrNvf4hCsROJP3CdlpaLiYewAs5Ww+PJxCrLelIi5XVHWOAgBvvr3H9WDKvUw8xuvqPYqAlpkFg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/utils": "^8.48.0"
+      },
+      "peerDependencies": {
+        "eslint": ">=8",
+        "storybook": "^10.3.3"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-replace": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-5.0.2.tgz",
+      "integrity": "sha512-Y45BAiE3mz2QsrN2fb5QEtO4qb44NcS7en/0y9PEVsg351HsLeVclP8QPMH79Le9sH3rs5RSwJu99W0WPZO43Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "@75lb/nature": "latest"
+      },
+      "peerDependenciesMeta": {
+        "@75lb/nature": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatbuffers": {
+      "version": "25.9.23",
+      "resolved": "https://registry.npmjs.org/flatbuffers/-/flatbuffers-25.9.23.tgz",
+      "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/flatted": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+      "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/glob": {
+      "version": "13.0.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
+      "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "minimatch": "^10.2.2",
+        "minipass": "^7.1.3",
+        "path-scurry": "^2.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/glob/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/glob/node_modules/brace-expansion": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "10.2.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+      "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/globals": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",
+      "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-docker": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz",
+      "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "is-docker": "cli.js"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-inside-container": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz",
+      "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-docker": "^3.0.0"
+      },
+      "bin": {
+        "is-inside-container": "cli.js"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-wsl": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.1.tgz",
+      "integrity": "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-inside-container": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jiti": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
+      "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-bignum": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/json-bignum/-/json-bignum-0.0.3.tgz",
+      "integrity": "sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.camelcase": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.36",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
+      "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/open": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz",
+      "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "default-browser": "^5.2.1",
+        "define-lazy-prop": "^3.0.0",
+        "is-inside-container": "^1.0.0",
+        "wsl-utils": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/path-scurry": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "11.2.7",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz",
+      "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.8.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz",
+      "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
+      "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-docgen": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/react-docgen/-/react-docgen-8.0.3.tgz",
+      "integrity": "sha512-aEZ9qP+/M+58x2qgfSFEWH1BxLyHe5+qkLNJOZQb5iGS017jpbRnoKhNRrXPeA6RfBrZO5wZrT9DMC1UqE1f1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/traverse": "^7.28.0",
+        "@babel/types": "^7.28.2",
+        "@types/babel__core": "^7.20.5",
+        "@types/babel__traverse": "^7.20.7",
+        "@types/doctrine": "^0.0.9",
+        "@types/resolve": "^1.20.2",
+        "doctrine": "^3.0.0",
+        "resolve": "^1.22.1",
+        "strip-indent": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.9.0 || >=22"
+      }
+    },
+    "node_modules/react-docgen-typescript": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/react-docgen-typescript/-/react-docgen-typescript-2.4.0.tgz",
+      "integrity": "sha512-ZtAp5XTO5HRzQctjPU0ybY0RRCQO19X/8fxn3w7y2VVTUbGHDKULPTL4ky3vB05euSgG5NpALhEhDPvQ56wvXg==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": ">= 4.3.x"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz",
+      "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.4"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/recast": {
+      "version": "0.23.11",
+      "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz",
+      "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ast-types": "^0.16.1",
+        "esprima": "~4.0.0",
+        "source-map": "~0.6.1",
+        "tiny-invariant": "^1.3.3",
+        "tslib": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/redent/node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.11",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.0.tgz",
+      "integrity": "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.0",
+        "@rollup/rollup-android-arm64": "4.60.0",
+        "@rollup/rollup-darwin-arm64": "4.60.0",
+        "@rollup/rollup-darwin-x64": "4.60.0",
+        "@rollup/rollup-freebsd-arm64": "4.60.0",
+        "@rollup/rollup-freebsd-x64": "4.60.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.0",
+        "@rollup/rollup-linux-arm64-musl": "4.60.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.0",
+        "@rollup/rollup-linux-loong64-musl": "4.60.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-gnu": "4.60.0",
+        "@rollup/rollup-linux-x64-musl": "4.60.0",
+        "@rollup/rollup-openbsd-x64": "4.60.0",
+        "@rollup/rollup-openharmony-arm64": "4.60.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.0",
+        "@rollup/rollup-win32-x64-gnu": "4.60.0",
+        "@rollup/rollup-win32-x64-msvc": "4.60.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-applescript": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz",
+      "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/storybook": {
+      "version": "10.3.3",
+      "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.3.3.tgz",
+      "integrity": "sha512-tMoRAts9EVqf+mEMPLC6z1DPyHbcPe+CV1MhLN55IKsl0HxNjvVGK44rVPSePbltPE6vIsn4bdRj6CCUt8SJwQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@storybook/global": "^5.0.0",
+        "@storybook/icons": "^2.0.1",
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/user-event": "^14.6.1",
+        "@vitest/expect": "3.2.4",
+        "@vitest/spy": "3.2.4",
+        "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0",
+        "open": "^10.2.0",
+        "recast": "^0.23.5",
+        "semver": "^7.7.3",
+        "use-sync-external-store": "^1.5.0",
+        "ws": "^8.18.0"
+      },
+      "bin": {
+        "storybook": "dist/bin/dispatcher.js"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/storybook"
+      },
+      "peerDependencies": {
+        "prettier": "^2 || ^3"
+      },
+      "peerDependenciesMeta": {
+        "prettier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/storybook/node_modules/@vitest/spy": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz",
+      "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/storybook/node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/strip-indent": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-4.1.1.tgz",
+      "integrity": "sha512-SlyRoSkdh1dYP0PzclLE7r0M9sgbFKKMFXpFRUMNuKhQSbC6VQIGzq3E0qsfvGJaUFJPGv6Ws1NZ/haTAjfbMA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/table-layout": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/table-layout/-/table-layout-4.1.1.tgz",
+      "integrity": "sha512-iK5/YhZxq5GO5z8wb0bY1317uDF3Zjpha0QFFLA8/trAoiLbQD0HUbMesEaxyzUgDxi2QlcbM8IvqOlEjgoXBA==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.2",
+        "wordwrapjs": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/tailwindcss": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.2.2.tgz",
+      "integrity": "sha512-KWBIxs1Xb6NoLdMVqhbhgwZf2PGBpPEiwOqgI4pFIYbNTfBXiKYyWoTsXgBQ9WFg/OlhnvHaY+AEpW7wSmFo2Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tapable": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.2.tgz",
+      "integrity": "sha512-1MOpMXuhGzGL5TTCZFItxCc0AARf1EZFQkGqMm7ERKj8+Hgr5oLvJOVFcC+lRmR8hCe2S3jC4T5D7Vg/d7/fhA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz",
+      "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/ts-api-utils": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
+      "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4"
+      }
+    },
+    "node_modules/ts-dedent": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz",
+      "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.10"
+      }
+    },
+    "node_modules/tsconfig-paths": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
+      "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json5": "^2.2.2",
+        "minimist": "^1.2.6",
+        "strip-bom": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typescript-eslint": {
+      "version": "8.57.2",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.57.2.tgz",
+      "integrity": "sha512-VEPQ0iPgWO/sBaZOU1xo4nuNdODVOajPnTIbog2GKYr31nIlZ0fWPoCQgGfF3ETyBl1vn63F/p50Um9Z4J8O8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/eslint-plugin": "8.57.2",
+        "@typescript-eslint/parser": "8.57.2",
+        "@typescript-eslint/typescript-estree": "8.57.2",
+        "@typescript-eslint/utils": "8.57.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/typical": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/typical/-/typical-7.3.0.tgz",
+      "integrity": "sha512-ya4mg/30vm+DOWfBg4YK3j2WD6TWtRkCbasOJr40CseYENzCUby/7rIvXA99JGsQHeNxLbnXdyLLxKSv3tauFw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "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==",
+      "license": "MIT"
+    },
+    "node_modules/unplugin": {
+      "version": "2.3.11",
+      "resolved": "https://registry.npmjs.org/unplugin/-/unplugin-2.3.11.tgz",
+      "integrity": "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "acorn": "^8.15.0",
+        "picomatch": "^4.0.3",
+        "webpack-virtual-modules": "^0.6.2"
+      },
+      "engines": {
+        "node": ">=18.12.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/use-sync-external-store": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+      "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "6.4.2",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz",
+      "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/webpack-virtual-modules": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz",
+      "integrity": "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/wordwrapjs": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-5.1.1.tgz",
+      "integrity": "sha512-0yweIbkINJodk27gX9LBGMzyQdBDan3s/dEAiwBOj+Mf0PPyWL6/rikalkv8EeD0E8jm4o5RXEOrFTP3NXbhJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/wsl-utils": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/wsl-utils/-/wsl-utils-0.1.0.tgz",
+      "integrity": "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-wsl": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    }
+  }
+}
diff --git a/vortex-web/package.json b/vortex-web/package.json
new file mode 100644
index 00000000000..ae1ea81bd5a
--- /dev/null
+++ b/vortex-web/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "vortex-web",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "wasm": "wasm-pack build crate --dev --target web --out-dir ../src/wasm/pkg",
+    "wasm:release": "wasm-pack build crate --release --target web --out-dir ../src/wasm/pkg",
+    "dev": "npm run wasm && vite",
+    "build": "npm run wasm:release && tsc -b && vite build",
+    "check": "npm run wasm && npm run lint && npm run typecheck",
+    "preview": "vite preview",
+    "format": "prettier --write 'src/**/*.{ts,tsx,css}' '.storybook/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.{ts,tsx,css}' '.storybook/**/*.ts'",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "tsc -b --noEmit",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build"
+  },
+  "dependencies": {
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.13.23",
+    "apache-arrow": "^21.1.0",
+    "d3-hierarchy": "^3.1.2",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.25.0",
+    "@storybook/addon-docs": "^10.3.3",
+    "@storybook/react-vite": "^10.3.3",
+    "@tailwindcss/vite": "^4.1.4",
+    "@types/d3-hierarchy": "^3.1.7",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@vitejs/plugin-react": "^4.4.1",
+    "eslint": "^9.25.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "eslint-plugin-storybook": "^10.3.3",
+    "globals": "^16.0.0",
+    "prettier": "^3.8.1",
+    "storybook": "^10.3.3",
+    "tailwindcss": "^4.1.4",
+    "typescript": "~5.7.0",
+    "typescript-eslint": "^8.30.1",
+    "vite": "^6.3.2"
+  }
+}
diff --git a/vortex-web/public/logo-icon.svg b/vortex-web/public/logo-icon.svg
new file mode 100644
index 00000000000..fc81b26ef11
--- /dev/null
+++ b/vortex-web/public/logo-icon.svg
@@ -0,0 +1,13 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!-- SPDX-FileCopyrightText: Copyright the Vortex contributors -->
+
+<svg width="188" height="188" viewBox="0 0 188 188" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M104.344 120.981L104.346 120.982L113.523 126.281L106.062 187.271L96.7185 181.877L96.7166 181.876L96.4949 181.748L95.9226 181.415L96.0046 180.759L96.0359 180.504L96.0369 180.502L101.908 134.361L64.908 162.796L64.3787 163.204L63.7996 162.871L63.5759 162.742L63.574 162.741L54.4636 157.481L103.552 120.525L104.344 120.981Z" fill="white"/>
+<path d="M81.9109 119.142L82.0808 119.782L82.1453 120.027L84.6521 129.377L84.7175 129.624L84.8884 130.263L37.6785 167.182L36.488 168.116L33.4558 156.802L70.9607 127.763L24.948 121.739L24.0281 121.62L23.7888 120.724L21.0652 110.562L81.9109 119.142Z" fill="white"/>
+<path d="M167.513 149.971L167.874 150.429L168.807 151.62L157.494 154.652L128.455 117.146L122.398 163.415L122.312 164.08L121.664 164.253L121.415 164.318L121.416 164.319L111.255 167.041L119.741 106.854L119.833 106.197L120.473 106.027L130.316 103.39L130.955 103.22L167.513 149.971Z" fill="white"/>
+<path d="M187.964 82.0459L182.44 91.6123L182.107 92.1875L135.054 86.1992L163.897 123.732L163.561 124.312L163.431 124.533L163.432 124.534L158.173 133.645L121.216 84.5557L121.548 83.9824L121.675 83.7617L126.973 74.585L187.964 82.0459Z" fill="white"/>
+<path d="M67.031 102.127L67.5837 102.859L62.2849 112.037L62.2839 112.038L61.825 112.831L0.835693 105.37L6.2312 96.0264L6.35718 95.8057L6.68921 95.2275L7.35034 95.3125L53.7429 101.215L25.4675 64.4189L24.9021 63.6855L30.6267 53.7715L67.031 102.127Z" fill="white"/>
+<path d="M68.9666 81.2158L68.3298 81.3877L68.0828 81.4541L68.0818 81.4551L58.7312 83.959L58.7322 83.96L57.8464 84.1992L19.9949 35.7949L31.3044 32.7637L31.7126 33.2891L60.3435 70.2686L66.489 23.3359L67.1355 23.1641L77.5457 20.374L68.9666 81.2158Z" fill="white"/>
+<path d="M155.344 30.6143L117.838 59.6514L163.851 65.6768H163.853L164.771 65.7988L167.732 76.8535L106.889 68.2744L104.147 58.04L104.146 58.0381L104.081 57.791L103.911 57.1523L152.312 19.3027L155.344 30.6143Z" fill="white"/>
+<path d="M92.0798 5.53906L92.3025 5.66602L92.8796 5.99805L86.8914 53.0518L124.425 24.2109L125.227 24.6758L134.337 29.9355L85.7771 66.4941L85.2478 66.8916L76.071 61.5938L76.0701 61.5928L75.2771 61.1338L82.738 0.144531L92.0798 5.53906Z" fill="white"/>
+</svg>
diff --git a/vortex-web/public/logo.svg b/vortex-web/public/logo.svg
new file mode 100644
index 00000000000..a961bc566a2
--- /dev/null
+++ b/vortex-web/public/logo.svg
@@ -0,0 +1,18 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!-- SPDX-FileCopyrightText: Copyright the Vortex contributors -->
+
+<svg width="653" height="188" viewBox="0 0 653 188" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M335.808 48.7793C344.852 48.7794 352.597 50.6078 359.043 54.2637C365.585 57.9197 370.636 63.1149 374.196 69.8496C377.756 76.5844 379.536 84.5703 379.536 93.8066C379.536 102.947 377.756 110.932 374.196 117.763C370.636 124.497 365.585 129.694 359.043 133.35C352.501 137.005 344.756 138.833 335.808 138.833C326.957 138.833 319.26 137.005 312.718 133.35C306.175 129.597 301.076 124.354 297.42 117.619C293.86 110.884 292.08 102.947 292.08 93.8066C292.08 84.6666 293.86 76.7289 297.42 69.9941C300.979 63.2594 306.031 58.0642 312.573 54.4082C319.212 50.656 326.957 48.7793 335.808 48.7793ZM335.808 60.6133C326.38 60.6133 318.971 63.5481 313.583 69.417C308.291 75.1897 305.645 83.3198 305.645 93.8066C305.645 104.293 308.291 112.471 313.583 118.34C318.971 124.113 326.38 126.999 335.808 126.999C345.333 126.999 352.741 124.112 358.033 118.34C363.324 112.471 365.97 104.293 365.97 93.8066C365.97 83.2234 363.325 75.0451 358.033 69.2725C352.741 63.4999 345.333 60.6134 335.808 60.6133Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M533.344 48.7793C541.521 48.7794 548.592 50.4629 554.557 53.8301C560.522 57.1012 565.141 61.7679 568.412 67.8291C571.779 73.8904 573.464 81.0588 573.464 89.333V95.3936H503.325C503.71 105.303 506.596 113.049 511.984 118.629C517.468 124.209 524.732 126.999 533.776 126.999C540.03 126.999 545.322 125.652 549.651 122.958C554.077 120.264 557.107 116.368 558.743 111.269H572.597C570.385 120.024 565.862 126.807 559.031 131.617C552.296 136.428 543.926 138.833 533.921 138.833C525.069 138.833 517.372 137.005 510.83 133.35C504.288 129.597 499.236 124.305 495.677 117.475C492.117 110.644 490.337 102.658 490.337 93.5176C490.337 84.3776 492.117 76.4882 495.677 69.8496C499.236 63.1149 504.239 57.9197 510.685 54.2637C517.131 50.6076 524.684 48.7793 533.344 48.7793ZM533.199 60.3252C525.406 60.3252 518.911 62.4898 513.716 66.8193C508.617 71.1488 505.394 77.21 504.047 85.0029H560.33C559.656 77.21 556.915 71.1488 552.104 66.8193C547.294 62.4899 540.992 60.3253 533.199 60.3252Z" fill="white"/>
+<path d="M254.398 123.824H254.975L285.282 50.5117H298.847L262.047 137.102H246.461L209.659 50.5117H223.658L254.398 123.824Z" fill="white"/>
+<path d="M465.711 50.5117H489.379V60.9023H465.855V126.422H491.687V137.102H465.134C461.093 137.102 457.917 136.092 455.608 134.071C453.395 131.955 452.289 128.827 452.289 124.69V60.9023H434.191C425.147 60.9023 418.076 64.1737 412.976 69.5615C407.877 74.9493 405.328 82.2611 405.328 91.4971V137.102H391.762V64.9434H384.547V50.5117H399.555V66.3857H405.616C408.117 61.2868 411.87 57.2945 416.873 54.4082C421.972 51.4257 427.986 50.5117 434.913 50.5117H452.433V24.5342H465.711V50.5117Z" fill="white"/>
+<path d="M609.8 83.9932L636.065 50.5117H650.785L618.025 92.6514L652.517 137.102H636.93L609.366 101.6L581.802 137.102H566.793L601.285 92.6514L568.524 50.5117H583.533L609.8 83.9932Z" fill="white"/>
+<path d="M104.344 120.981L104.346 120.982L113.523 126.281L106.062 187.271L96.7185 181.877L96.7166 181.876L96.4949 181.748L95.9226 181.415L96.0046 180.759L96.0359 180.504L96.0369 180.502L101.908 134.361L64.908 162.796L64.3787 163.204L63.7996 162.871L63.5759 162.742L63.574 162.741L54.4636 157.481L103.552 120.525L104.344 120.981Z" fill="white"/>
+<path d="M81.9109 119.142L82.0808 119.782L82.1453 120.027L84.6521 129.377L84.7175 129.624L84.8884 130.263L37.6785 167.182L36.488 168.116L33.4558 156.802L70.9607 127.763L24.948 121.739L24.0281 121.62L23.7888 120.724L21.0652 110.562L81.9109 119.142Z" fill="white"/>
+<path d="M167.513 149.971L167.874 150.429L168.807 151.62L157.494 154.652L128.455 117.146L122.398 163.415L122.312 164.08L121.664 164.253L121.415 164.318L121.416 164.319L111.255 167.041L119.741 106.854L119.833 106.197L120.473 106.027L130.316 103.39L130.955 103.22L167.513 149.971Z" fill="white"/>
+<path d="M187.964 82.0459L182.44 91.6123L182.107 92.1875L135.054 86.1992L163.897 123.732L163.561 124.312L163.431 124.533L163.432 124.534L158.173 133.645L121.216 84.5557L121.548 83.9824L121.675 83.7617L126.973 74.585L187.964 82.0459Z" fill="white"/>
+<path d="M67.031 102.127L67.5837 102.859L62.2849 112.037L62.2839 112.038L61.825 112.831L0.835693 105.37L6.2312 96.0264L6.35718 95.8057L6.68921 95.2275L7.35034 95.3125L53.7429 101.215L25.4675 64.4189L24.9021 63.6855L30.6267 53.7715L67.031 102.127Z" fill="white"/>
+<path d="M68.9666 81.2158L68.3298 81.3877L68.0828 81.4541L68.0818 81.4551L58.7312 83.959L58.7322 83.96L57.8464 84.1992L19.9949 35.7949L31.3044 32.7637L31.7126 33.2891L60.3435 70.2686L66.489 23.3359L67.1355 23.1641L77.5457 20.374L68.9666 81.2158Z" fill="white"/>
+<path d="M155.344 30.6143L117.838 59.6514L163.851 65.6768H163.853L164.771 65.7988L167.732 76.8535L106.889 68.2744L104.147 58.04L104.146 58.0381L104.081 57.791L103.911 57.1523L152.312 19.3027L155.344 30.6143Z" fill="white"/>
+<path d="M92.0798 5.53906L92.3025 5.66602L92.8796 5.99805L86.8914 53.0518L124.425 24.2109L125.227 24.6758L134.337 29.9355L85.7771 66.4941L85.2478 66.8916L76.071 61.5938L76.0701 61.5928L75.2771 61.1338L82.738 0.144531L92.0798 5.53906Z" fill="white"/>
+</svg>
diff --git a/vortex-web/src/App.tsx b/vortex-web/src/App.tsx
new file mode 100644
index 00000000000..07b52b120fe
--- /dev/null
+++ b/vortex-web/src/App.tsx
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useCallback, useEffect, useMemo, useRef, useState, type DragEvent } from 'react';
+import type { VortexFileState, VortexFileContextValue } from './contexts/VortexFileContext';
+import { VortexFileProvider } from './contexts/VortexFileContext';
+import { SelectionProvider } from './contexts/SelectionContext';
+import type { LayoutTreeNode } from './components/swimlane/types';
+import { arrayTreeToLayoutChildren, findNodeById } from './components/swimlane/utils';
+import { FileDropScreen } from './components/explorer/FileDropScreen';
+import { FileHeader } from './components/explorer/FileHeader';
+import { MainArea } from './components/explorer/MainArea';
+import { StatusBar } from './components/explorer/StatusBar';
+import { VortexWorker } from './workers/VortexWorker';
+
+function App() {
+  const [fileState, setFileState] = useState<VortexFileState | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [isDragging, setIsDragging] = useState(false);
+  const dragCounter = useRef(0);
+  const workerRef = useRef<VortexWorker | null>(null);
+
+  useEffect(() => {
+    workerRef.current = new VortexWorker();
+    return () => workerRef.current?.terminate();
+  }, []);
+
+  const openFile = useCallback(async (file: File) => {
+    setError(null);
+    setLoading(true);
+    try {
+      const result = await workerRef.current!.openFile(file);
+      setFileState({
+        fileName: file.name,
+        fileSize: file.size,
+        rowCount: result.rowCount,
+        version: result.fileStructure.version,
+        dtype: result.dtype,
+        layoutTree: result.layoutTree,
+        segments: result.segments,
+        fileStructure: result.fileStructure,
+      });
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+      setFileState(null);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const fetchEncodingTree = useCallback(
+    (nodeId: string) => workerRef.current!.fetchEncodingTree(nodeId),
+    [],
+  );
+
+  const previewData = useCallback(
+    (nodeId: string, rowLimit: number) => workerRef.current!.previewData(nodeId, rowLimit),
+    [],
+  );
+
+  /** Clone a tree, replacing the node at targetId with a modified version. */
+  const cloneTreeWithUpdate = useCallback(
+    (
+      root: LayoutTreeNode,
+      targetId: string,
+      update: (node: LayoutTreeNode) => LayoutTreeNode,
+    ): LayoutTreeNode => {
+      if (root.id === targetId) return update(root);
+      const newChildren = root.children.map((child) =>
+        cloneTreeWithUpdate(child, targetId, update),
+      );
+      if (newChildren === root.children) return root;
+      return { ...root, children: newChildren };
+    },
+    [],
+  );
+
+  const expandArrayTree = useCallback(
+    async (nodeId: string) => {
+      // Fetch the encoding tree (may be async).
+      const arrayTree = await workerRef.current!.fetchEncodingTree(nodeId);
+      if (!arrayTree) return;
+
+      setFileState((prev) => {
+        if (!prev) return prev;
+        const node = findNodeById(prev.layoutTree, nodeId);
+        if (!node || node.encoding !== 'vortex.flat') return prev;
+        if (node.children.some((c) => c.isArrayNode)) return prev;
+
+        const arrayChildren = arrayTreeToLayoutChildren(arrayTree, node);
+        const newTree = cloneTreeWithUpdate(prev.layoutTree, nodeId, (n) => ({
+          ...n,
+          arrayEncodingTree: arrayTree,
+          children: [...n.children, ...arrayChildren],
+        }));
+        return { ...prev, layoutTree: newTree };
+      });
+    },
+    [cloneTreeWithUpdate],
+  );
+
+  const fetchArrayBuffer = useCallback(
+    (layoutNodeId: string, arrayPath: string[], bufferIndex: number) =>
+      workerRef.current!.fetchArrayBuffer(layoutNodeId, arrayPath, bufferIndex),
+    [],
+  );
+
+  const previewArrayData = useCallback(
+    (layoutNodeId: string, arrayPath: string[], rowLimit: number) =>
+      workerRef.current!.previewArrayData(layoutNodeId, arrayPath, rowLimit),
+    [],
+  );
+
+  const fileContextValue = useMemo<VortexFileContextValue | null>(
+    () =>
+      fileState
+        ? {
+            ...fileState,
+            fetchEncodingTree,
+            previewData,
+            expandArrayTree,
+            fetchArrayBuffer,
+            previewArrayData,
+          }
+        : null,
+    [
+      fileState,
+      fetchEncodingTree,
+      previewData,
+      expandArrayTree,
+      fetchArrayBuffer,
+      previewArrayData,
+    ],
+  );
+
+  const closeFile = useCallback(() => setFileState(null), []);
+
+  const handleDragEnter = useCallback((e: DragEvent<HTMLDivElement>) => {
+    e.preventDefault();
+    dragCounter.current++;
+    if (dragCounter.current === 1) setIsDragging(true);
+  }, []);
+
+  const handleDragOver = useCallback((e: DragEvent<HTMLDivElement>) => {
+    e.preventDefault();
+  }, []);
+
+  const handleDragLeave = useCallback((e: DragEvent<HTMLDivElement>) => {
+    e.preventDefault();
+    dragCounter.current--;
+    if (dragCounter.current === 0) setIsDragging(false);
+  }, []);
+
+  const handleDrop = useCallback(
+    (e: DragEvent<HTMLDivElement>) => {
+      e.preventDefault();
+      dragCounter.current = 0;
+      setIsDragging(false);
+      const file = e.dataTransfer.files[0];
+      if (file) openFile(file);
+    },
+    [openFile],
+  );
+
+  if (!fileContextValue) {
+    return <FileDropScreen onFileLoaded={openFile} loading={loading} error={error} />;
+  }
+
+  return (
+    <VortexFileProvider value={fileContextValue!}>
+      <SelectionProvider tree={fileContextValue!.layoutTree}>
+        <div
+          className="flex flex-col h-screen bg-vortex-white dark:bg-vortex-black relative"
+          onDragEnter={handleDragEnter}
+          onDragOver={handleDragOver}
+          onDragLeave={handleDragLeave}
+          onDrop={handleDrop}
+        >
+          <FileHeader onClose={closeFile} />
+          <MainArea />
+          <StatusBar />
+          {isDragging && (
+            <div className="absolute inset-0 z-50 flex items-center justify-center bg-vortex-black/50 dark:bg-black/50 backdrop-blur-sm pointer-events-none">
+              <p className="font-mono text-sm text-white/80">Drop to open file</p>
+            </div>
+          )}
+        </div>
+      </SelectionProvider>
+    </VortexFileProvider>
+  );
+}
+
+export default App;
diff --git a/vortex-web/src/components/DataTable.tsx b/vortex-web/src/components/DataTable.tsx
new file mode 100644
index 00000000000..0b5c65d3922
--- /dev/null
+++ b/vortex-web/src/components/DataTable.tsx
@@ -0,0 +1,451 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useMemo, useRef, useState } from 'react';
+import {
+  useReactTable,
+  getCoreRowModel,
+  getSortedRowModel,
+  flexRender,
+  type ColumnDef,
+  type SortingState,
+} from '@tanstack/react-table';
+import { useVirtualizer } from '@tanstack/react-virtual';
+
+// --- Column statistics ---
+
+interface ColumnStats {
+  kind: 'numeric' | 'string' | 'boolean' | 'other';
+  count: number;
+  nullCount: number;
+  min?: number;
+  max?: number;
+  mean?: number;
+  histogram?: number[];
+  cardinality?: number;
+  trueCount?: number;
+  falseCount?: number;
+}
+
+function computeStats(values: unknown[]): ColumnStats {
+  const count = values.length;
+  let nullCount = 0;
+  const nums: number[] = [];
+  let hasStrings = false;
+  let trueCount = 0;
+  let falseCount = 0;
+  let hasBools = false;
+
+  for (const v of values) {
+    if (v == null) {
+      nullCount++;
+    } else if (typeof v === 'boolean') {
+      hasBools = true;
+      if (v) trueCount++;
+      else falseCount++;
+    } else if (typeof v === 'number' || typeof v === 'bigint') {
+      nums.push(Number(v));
+    } else if (typeof v === 'string') {
+      hasStrings = true;
+    }
+  }
+
+  if (hasBools) {
+    return { kind: 'boolean', count, nullCount, trueCount, falseCount };
+  }
+
+  if (nums.length > 0) {
+    let min = Infinity,
+      max = -Infinity,
+      sum = 0;
+    for (const n of nums) {
+      if (n < min) min = n;
+      if (n > max) max = n;
+      sum += n;
+    }
+    const bins = 20;
+    const histogram = new Array<number>(bins).fill(0);
+    if (max > min) {
+      const range = max - min;
+      for (const n of nums) {
+        const idx = Math.min(bins - 1, Math.floor(((n - min) / range) * bins));
+        histogram[idx]++;
+      }
+    } else {
+      histogram[0] = nums.length;
+    }
+    return { kind: 'numeric', count, nullCount, min, max, mean: sum / nums.length, histogram };
+  }
+
+  if (hasStrings) {
+    const uniq = new Set<string>();
+    for (const v of values) if (typeof v === 'string') uniq.add(v);
+    return { kind: 'string', count, nullCount, cardinality: uniq.size };
+  }
+
+  return { kind: 'other', count, nullCount };
+}
+
+// --- Sparkline ---
+
+function SparkHistogram({ histogram, height = 12 }: { histogram: number[]; height?: number }) {
+  const max = Math.max(...histogram);
+  if (max === 0) return null;
+
+  // Check if all values fell in a single bin (constant column).
+  const nonZero = histogram.filter((v) => v > 0).length;
+  if (nonZero <= 1) {
+    // Render a flat line to indicate constant/single-value.
+    const barW = 2;
+    const gap = 0.5;
+    const w = histogram.length * (barW + gap) - gap;
+    return (
+      <svg width={w} height={height} className="flex-shrink-0 opacity-50">
+        <line
+          x1={0}
+          y1={height / 2}
+          x2={w}
+          y2={height / 2}
+          stroke="currentColor"
+          strokeWidth={1}
+          className="text-vortex-grey-dark"
+        />
+      </svg>
+    );
+  }
+
+  const barW = 2;
+  const gap = 0.5;
+  const w = histogram.length * (barW + gap) - gap;
+  return (
+    <svg width={w} height={height} className="flex-shrink-0 opacity-70">
+      {histogram.map((v, i) => {
+        const barH = Math.max(0.5, (v / max) * height);
+        return (
+          <rect
+            key={i}
+            x={i * (barW + gap)}
+            y={height - barH}
+            width={barW}
+            height={barH}
+            className="fill-vortex-light-blue"
+          />
+        );
+      })}
+    </svg>
+  );
+}
+
+// --- Header summary (inline, compact) ---
+
+function HeaderSummary({ stats }: { stats: ColumnStats }) {
+  if (stats.kind === 'numeric') {
+    const isConst = stats.min === stats.max && stats.nullCount === 0;
+    if (isConst) {
+      return (
+        <span
+          className="text-[8px] text-vortex-grey-dark font-normal opacity-70"
+          title={`constant: ${stats.min}`}
+        >
+          const
+        </span>
+      );
+    }
+    if (stats.histogram) {
+      return <SparkHistogram histogram={stats.histogram} />;
+    }
+  }
+  if (stats.kind === 'boolean') {
+    const total = stats.trueCount! + stats.falseCount!;
+    if (total === 0) return null;
+    const allTrue = stats.falseCount === 0 && stats.nullCount === 0;
+    const allFalse = stats.trueCount === 0 && stats.nullCount === 0;
+    if (allTrue || allFalse)
+      return <span className="text-[8px] text-vortex-grey-dark font-normal opacity-70">const</span>;
+    const pct = Math.round((stats.trueCount! / total) * 100);
+    return (
+      <div
+        className="flex items-center gap-0.5 flex-shrink-0"
+        title={`${stats.trueCount} true, ${stats.falseCount} false`}
+      >
+        <div className="flex h-2 w-8 rounded-sm overflow-hidden">
+          <div className="bg-vortex-light-blue/60" style={{ width: `${pct}%` }} />
+          <div className="bg-vortex-grey-dark/20" style={{ width: `${100 - pct}%` }} />
+        </div>
+        <span className="text-[8px] text-vortex-grey-dark font-normal opacity-70">{pct}%</span>
+      </div>
+    );
+  }
+  if (stats.kind === 'string' && stats.cardinality != null) {
+    if (stats.cardinality === 1 && stats.nullCount === 0) {
+      return <span className="text-[8px] text-vortex-grey-dark font-normal opacity-70">const</span>;
+    }
+    return (
+      <span className="text-[8px] text-vortex-grey-dark font-normal opacity-70">
+        {stats.cardinality}v
+      </span>
+    );
+  }
+  return null;
+}
+
+// --- Header tooltip (shown on hover) ---
+
+function HeaderTooltip({ stats, approximate }: { stats: ColumnStats; approximate: boolean }) {
+  const p = approximate ? '~' : '';
+  const fmt = (n: number) => {
+    const s =
+      Math.abs(n) >= 1e6 || (Math.abs(n) < 0.01 && n !== 0)
+        ? n.toExponential(2)
+        : n.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    return p + s;
+  };
+
+  return (
+    <div className="text-[9px] font-normal text-vortex-fg-light dark:text-vortex-fg space-y-1 font-mono">
+      <div className="text-vortex-grey-dark">
+        {stats.count.toLocaleString()} rows{approximate ? ' (sampled)' : ''}
+      </div>
+      {stats.nullCount > 0 && (
+        <div className="text-vortex-grey-dark">{stats.nullCount.toLocaleString()} nulls</div>
+      )}
+      {stats.kind === 'numeric' && (
+        <>
+          <div>min: {fmt(stats.min!)}</div>
+          <div>max: {fmt(stats.max!)}</div>
+          <div>mean: {fmt(stats.mean!)}</div>
+          {stats.histogram && (
+            <div className="pt-0.5">
+              <SparkHistogram histogram={stats.histogram} height={24} />
+            </div>
+          )}
+        </>
+      )}
+      {stats.kind === 'boolean' && (
+        <>
+          <div>true: {stats.trueCount!.toLocaleString()}</div>
+          <div>false: {stats.falseCount!.toLocaleString()}</div>
+        </>
+      )}
+      {stats.kind === 'string' && <div>{stats.cardinality!.toLocaleString()} distinct values</div>}
+    </div>
+  );
+}
+
+// --- Hoverable header with tooltip ---
+
+function ColumnHeader({
+  name,
+  stats,
+  approximate,
+}: {
+  name: string;
+  stats: ColumnStats;
+  approximate: boolean;
+}) {
+  const [showTip, setShowTip] = useState(false);
+  const timeoutRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+
+  const onEnter = () => {
+    clearTimeout(timeoutRef.current);
+    timeoutRef.current = setTimeout(() => setShowTip(true), 400);
+  };
+  const onLeave = () => {
+    clearTimeout(timeoutRef.current);
+    setShowTip(false);
+  };
+
+  return (
+    <div className="relative" onMouseEnter={onEnter} onMouseLeave={onLeave}>
+      <div className="flex items-center gap-1.5">
+        <span className="truncate">{name}</span>
+        <HeaderSummary stats={stats} />
+      </div>
+      {showTip && (
+        <div className="absolute top-full left-0 mt-1 z-50 bg-vortex-white dark:bg-vortex-black border border-vortex-grey-light/40 dark:border-white/[0.08] rounded shadow-lg px-2 py-1.5 min-w-[120px]">
+          <HeaderTooltip stats={stats} approximate={approximate} />
+        </div>
+      )}
+    </div>
+  );
+}
+
+// --- Formatting ---
+
+function formatCell(value: unknown): string {
+  if (value == null) return '';
+  if (typeof value === 'bigint') return value.toString();
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toLocaleString(undefined, { maximumFractionDigits: 4 });
+  }
+  return String(value);
+}
+
+// --- Main component ---
+
+export type CellRenderer = (value: unknown, row: Record<string, unknown>) => React.ReactNode;
+
+export interface DataTableProps {
+  columns: string[];
+  rows: Record<string, unknown>[];
+  rowHeight?: number;
+  onRowClick?: (rowIndex: number) => void;
+  onRowHover?: (rowIndex: number | null) => void;
+  /** Custom cell renderers keyed by column name. */
+  cellRenderers?: Record<string, CellRenderer>;
+  /** If true, stats are approximate (data was truncated by a row limit). */
+  approximate?: boolean;
+}
+
+export function DataTable({
+  columns,
+  rows,
+  rowHeight = 24,
+  onRowClick,
+  onRowHover,
+  cellRenderers,
+  approximate = false,
+}: DataTableProps) {
+  const [sorting, setSorting] = useState<SortingState>([]);
+  const parentRef = useRef<HTMLDivElement>(null);
+
+  const columnStats = useMemo(() => {
+    const stats: Record<string, ColumnStats> = {};
+    for (const col of columns) {
+      stats[col] = computeStats(rows.map((r) => r[col]));
+    }
+    return stats;
+  }, [columns, rows]);
+
+  const columnDefs = useMemo<ColumnDef<Record<string, unknown>>[]>(
+    () => [
+      {
+        id: '__row_num',
+        header: '#',
+        size: 50,
+        enableSorting: false,
+        cell: (info) => (
+          <span className="text-vortex-grey-dark tabular-nums">{info.row.index}</span>
+        ),
+      },
+      ...columns.map(
+        (col): ColumnDef<Record<string, unknown>> => ({
+          accessorKey: col,
+          header: () => (
+            <ColumnHeader name={col} stats={columnStats[col]} approximate={approximate} />
+          ),
+          cell: (info) => {
+            const renderer = cellRenderers?.[col];
+            if (renderer) {
+              return renderer(info.getValue(), info.row.original);
+            }
+            const val = info.getValue();
+            if (val == null) {
+              return <span className="text-vortex-grey-dark italic">null</span>;
+            }
+            return formatCell(val);
+          },
+          sortingFn: 'auto',
+        }),
+      ),
+    ],
+    [columns, columnStats],
+  );
+
+  const table = useReactTable({
+    data: rows,
+    columns: columnDefs,
+    state: { sorting },
+    onSortingChange: setSorting,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+  });
+
+  const { rows: tableRows } = table.getRowModel();
+
+  const virtualizer = useVirtualizer({
+    count: tableRows.length,
+    getScrollElement: () => parentRef.current,
+    estimateSize: () => rowHeight,
+    overscan: 20,
+  });
+
+  return (
+    <div ref={parentRef} className="h-full w-full overflow-auto">
+      <table className="w-full text-[10px] font-mono border-collapse">
+        <thead className="sticky top-0 z-10">
+          {table.getHeaderGroups().map((headerGroup) => (
+            <tr key={headerGroup.id} className="bg-vortex-grey-lightest dark:bg-vortex-black">
+              {headerGroup.headers.map((header) => (
+                <th
+                  key={header.id}
+                  className="px-2 py-1 text-left font-medium text-vortex-fg-light dark:text-vortex-fg border-b border-r border-vortex-grey-light/30 dark:border-white/[0.06] last:border-r-0 select-none cursor-pointer"
+                  style={{ width: header.getSize() }}
+                  onClick={header.column.getToggleSortingHandler()}
+                >
+                  <div className="flex items-center gap-1">
+                    {header.isPlaceholder
+                      ? null
+                      : flexRender(header.column.columnDef.header, header.getContext())}
+                    {header.column.getIsSorted() === 'asc' && (
+                      <span className="text-vortex-light-blue">▲</span>
+                    )}
+                    {header.column.getIsSorted() === 'desc' && (
+                      <span className="text-vortex-light-blue">▼</span>
+                    )}
+                  </div>
+                </th>
+              ))}
+            </tr>
+          ))}
+        </thead>
+        <tbody>
+          {virtualizer.getVirtualItems().length > 0 && (
+            <tr>
+              <td
+                colSpan={columnDefs.length}
+                style={{ height: virtualizer.getVirtualItems()[0]?.start ?? 0, padding: 0 }}
+              />
+            </tr>
+          )}
+          {virtualizer.getVirtualItems().map((virtualRow) => {
+            const row = tableRows[virtualRow.index];
+            return (
+              <tr
+                key={row.id}
+                className="border-b border-vortex-grey-light/20 dark:border-white/[0.03] hover:bg-vortex-grey-lightest/50 dark:hover:bg-white/[0.02] cursor-default"
+                style={{ height: rowHeight }}
+                onClick={() => onRowClick?.(virtualRow.index)}
+                onMouseEnter={() => onRowHover?.(virtualRow.index)}
+                onMouseLeave={() => onRowHover?.(null)}
+              >
+                {row.getVisibleCells().map((cell) => (
+                  <td
+                    key={cell.id}
+                    className="px-2 text-vortex-fg-light dark:text-vortex-fg/80 truncate max-w-[300px] border-r border-vortex-grey-light/30 dark:border-white/[0.06] last:border-r-0"
+                    title={formatCell(cell.getValue())}
+                  >
+                    {flexRender(cell.column.columnDef.cell, cell.getContext())}
+                  </td>
+                ))}
+              </tr>
+            );
+          })}
+          {virtualizer.getVirtualItems().length > 0 && (
+            <tr>
+              <td
+                colSpan={columnDefs.length}
+                style={{
+                  height:
+                    virtualizer.getTotalSize() - (virtualizer.getVirtualItems().at(-1)?.end ?? 0),
+                  padding: 0,
+                }}
+              />
+            </tr>
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/ThemePicker.tsx b/vortex-web/src/components/ThemePicker.tsx
new file mode 100644
index 00000000000..442e3a4f039
--- /dev/null
+++ b/vortex-web/src/components/ThemePicker.tsx
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type React from 'react';
+import { useTheme, type ThemeChoice } from '../contexts/ThemeContext';
+
+const cycle: ThemeChoice[] = ['dark', 'light', 'system'];
+
+const labels: Record<ThemeChoice, string> = {
+  light: 'Light mode',
+  dark: 'Dark mode',
+  system: 'System theme',
+};
+
+function SunIcon() {
+  return (
+    <svg
+      width="14"
+      height="14"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <circle cx="12" cy="12" r="4" />
+      <path d="M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M6.34 17.66l-1.41 1.41M19.07 4.93l-1.41 1.41" />
+    </svg>
+  );
+}
+
+function MoonIcon() {
+  return (
+    <svg
+      width="14"
+      height="14"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" />
+    </svg>
+  );
+}
+
+function MonitorIcon() {
+  return (
+    <svg
+      width="14"
+      height="14"
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <rect x="2" y="3" width="20" height="14" rx="2" ry="2" />
+      <line x1="8" y1="21" x2="16" y2="21" />
+      <line x1="12" y1="17" x2="12" y2="21" />
+    </svg>
+  );
+}
+
+const icons: Record<ThemeChoice, () => React.JSX.Element> = {
+  light: SunIcon,
+  dark: MoonIcon,
+  system: MonitorIcon,
+};
+
+export function ThemePicker() {
+  const { theme, setTheme } = useTheme();
+
+  const next = () => {
+    const idx = cycle.indexOf(theme);
+    setTheme(cycle[(idx + 1) % cycle.length]);
+  };
+
+  const Icon = icons[theme];
+
+  return (
+    <button
+      onClick={next}
+      className="p-1.5 rounded-md text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg hover:bg-vortex-grey-lightest dark:hover:bg-white/[0.06] transition-colors cursor-pointer"
+      title={labels[theme]}
+      aria-label={labels[theme]}
+    >
+      <Icon />
+    </button>
+  );
+}
diff --git a/vortex-web/src/components/detail/ArraySummaryPane.tsx b/vortex-web/src/components/detail/ArraySummaryPane.tsx
new file mode 100644
index 00000000000..06a2311118a
--- /dev/null
+++ b/vortex-web/src/components/detail/ArraySummaryPane.tsx
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode } from '../swimlane/types';
+import { formatBytes, getNodeDisplayName, shortEncoding } from '../swimlane/utils';
+
+interface ArraySummaryPaneProps {
+  node: LayoutTreeNode;
+}
+
+export function ArraySummaryPane({ node }: ArraySummaryPaneProps) {
+  const name = getNodeDisplayName(node);
+  const totalBufferBytes = (node.bufferLengths ?? []).reduce((s, b) => s + b, 0);
+
+  return (
+    <div className="text-xs space-y-2">
+      <h3 className="font-medium text-vortex-fg-light dark:text-vortex-fg">{name}</h3>
+      <div className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 text-vortex-grey-dark">
+        <span>Encoding</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg" title={node.encoding}>
+          {shortEncoding(node.encoding)}
+        </span>
+        <span>Metadata</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">
+          {formatBytes(node.metadataBytes)}
+        </span>
+        <span>Buffers</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">
+          {(node.bufferLengths ?? []).length}
+        </span>
+        <span>Buffer data</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">
+          {formatBytes(totalBufferBytes)}
+        </span>
+        <span>Children</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{node.children.length}</span>
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/detail/BuffersPane.tsx b/vortex-web/src/components/detail/BuffersPane.tsx
new file mode 100644
index 00000000000..d1d7f527139
--- /dev/null
+++ b/vortex-web/src/components/detail/BuffersPane.tsx
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type { LayoutTreeNode } from '../swimlane/types';
+import { formatBytes, parseArrayNodeId } from '../swimlane/utils';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+
+interface BuffersPaneProps {
+  node: LayoutTreeNode;
+}
+
+export function BuffersPane({ node }: BuffersPaneProps) {
+  const { fetchArrayBuffer } = useVortexFile();
+  const bufferLengths = node.bufferLengths ?? [];
+  const [selectedBuffer, setSelectedBuffer] = useState<number | null>(null);
+  const [bufferData, setBufferData] = useState<Uint8Array | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const bufferNames: string[] = bufferLengths.map((_, i) => node.bufferNames?.[i] ?? `buffer ${i}`);
+
+  const loadBuffer = useCallback(
+    async (index: number) => {
+      setSelectedBuffer(index);
+      setBufferData(null);
+      setError(null);
+      setLoading(true);
+      try {
+        const { layoutNodeId, arrayPath } = parseArrayNodeId(node.id);
+        const data = await fetchArrayBuffer(layoutNodeId, arrayPath, index);
+        setBufferData(data);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : String(e));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [node.id, fetchArrayBuffer],
+  );
+
+  // Auto-select first buffer when node changes.
+  useEffect(() => {
+    setBufferData(null);
+    setError(null);
+    if (bufferLengths.length > 0) {
+      loadBuffer(0);
+    } else {
+      setSelectedBuffer(null);
+    }
+  }, [node.id, bufferLengths.length, loadBuffer]);
+
+  if (bufferLengths.length === 0) {
+    return <div className="text-xs text-vortex-grey-dark p-2.5">No buffers for this node.</div>;
+  }
+
+  return (
+    <div className="flex h-full">
+      {/* Buffer list — left side */}
+      <div className="w-[160px] flex-shrink-0 border-r border-vortex-grey-light/40 dark:border-white/[0.06] overflow-y-auto">
+        {bufferLengths.map((len, i) => (
+          <button
+            key={i}
+            className={`w-full text-left px-2.5 py-1.5 text-xs border-b border-vortex-grey-light/20 dark:border-white/[0.04] hover:bg-vortex-black/[0.03] dark:hover:bg-white/[0.04] ${
+              selectedBuffer === i
+                ? 'bg-vortex-light-blue/10 text-vortex-fg-light dark:text-vortex-fg'
+                : 'text-vortex-grey-dark'
+            }`}
+            onClick={() => loadBuffer(i)}
+          >
+            <div className="font-medium text-vortex-fg-light dark:text-vortex-fg text-[11px]">
+              {bufferNames[i]}
+            </div>
+            <div className="text-[10px] font-mono tabular-nums">{formatBytes(len)}</div>
+          </button>
+        ))}
+      </div>
+
+      {/* Hex viewer — right side */}
+      <div className="flex-1 overflow-auto p-2">
+        {selectedBuffer === null && (
+          <div className="text-xs text-vortex-grey-dark">Select a buffer to view its contents.</div>
+        )}
+        {loading && <div className="text-xs text-vortex-grey-dark">Loading…</div>}
+        {error && <div className="text-xs text-red-500">Error: {error}</div>}
+        {bufferData && <HexView data={bufferData} />}
+      </div>
+    </div>
+  );
+}
+
+const BYTES_PER_ROW = 16;
+const MAX_ROWS = 1024;
+
+interface HexRow {
+  offset: number;
+  bytes: { value: number; absIndex: number }[];
+}
+
+function HexView({ data }: { data: Uint8Array }) {
+  const [hovered, setHovered] = useState<number | null>(null);
+
+  const { rows, truncated } = useMemo(() => {
+    const result: HexRow[] = [];
+    for (let i = 0; i < data.length; i += BYTES_PER_ROW) {
+      const bytes: HexRow['bytes'] = [];
+      const end = Math.min(i + BYTES_PER_ROW, data.length);
+      for (let j = i; j < end; j++) {
+        bytes.push({ value: data[j], absIndex: j });
+      }
+      result.push({ offset: i, bytes });
+    }
+    const isTruncated = result.length > MAX_ROWS;
+    return { rows: isTruncated ? result.slice(0, MAX_ROWS) : result, truncated: isTruncated };
+  }, [data]);
+
+  const hlClass = 'bg-vortex-light-blue/20 rounded-sm';
+
+  return (
+    <div className="font-mono text-[10px] leading-[16px]">
+      {rows.map((row) => (
+        <div key={row.offset} className="flex gap-2 whitespace-pre">
+          {/* Offset */}
+          <span className="text-vortex-grey-dark w-[60px] text-right flex-shrink-0 select-none">
+            {row.offset.toString(16).padStart(8, '0')}
+          </span>
+
+          {/* Hex bytes */}
+          <span className="flex-shrink-0">
+            {Array.from({ length: BYTES_PER_ROW }, (_, j) => {
+              const b = row.bytes[j];
+              if (!b)
+                return (
+                  <span key={j} className="inline-block w-[22px]">
+                    {' '}
+                  </span>
+                );
+              const isHl = hovered === b.absIndex;
+              const gap = j === 8 ? ' ' : '';
+              return (
+                <span key={j}>
+                  {gap}
+                  <span
+                    className={`inline-block w-[22px] text-center text-vortex-fg-light dark:text-vortex-fg cursor-default ${isHl ? hlClass : ''}`}
+                    onMouseEnter={() => setHovered(b.absIndex)}
+                    onMouseLeave={() => setHovered(null)}
+                  >
+                    {b.value.toString(16).padStart(2, '0')}
+                  </span>
+                </span>
+              );
+            })}
+          </span>
+
+          {/* ASCII */}
+          <span className="flex-shrink-0">
+            {Array.from({ length: BYTES_PER_ROW }, (_, j) => {
+              const b = row.bytes[j];
+              if (!b) return <span key={j}> </span>;
+              const isHl = hovered === b.absIndex;
+              const ch = b.value >= 0x20 && b.value < 0x7f ? String.fromCharCode(b.value) : '.';
+              const color = ch === '.' ? 'text-vortex-grey-dark' : 'text-vortex-light-blue';
+              return (
+                <span
+                  key={j}
+                  className={`cursor-default ${color} ${isHl ? hlClass : ''}`}
+                  onMouseEnter={() => setHovered(b.absIndex)}
+                  onMouseLeave={() => setHovered(null)}
+                >
+                  {ch}
+                </span>
+              );
+            })}
+          </span>
+        </div>
+      ))}
+      {truncated && (
+        <div className="text-vortex-grey-dark mt-1">
+          … {Math.ceil(data.length / BYTES_PER_ROW) - MAX_ROWS} more rows (
+          {formatBytes(data.length)} total)
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/detail/DetailPanel.stories.tsx b/vortex-web/src/components/detail/DetailPanel.stories.tsx
new file mode 100644
index 00000000000..ce8a05c9c0c
--- /dev/null
+++ b/vortex-web/src/components/detail/DetailPanel.stories.tsx
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { DetailPanel } from './DetailPanel';
+import { withMockFileContext, withMockSelection } from '../../storybook/decorators';
+import { ordersMock } from '../../mocks/layouts';
+import { generateSegments } from '../../mocks/segments';
+import { generateFileStructure } from '../../mocks/fileStructure';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+
+const layout = ordersMock();
+const segments = generateSegments(layout, 12_400_000);
+const fileStructure = generateFileStructure(segments, 12_400_000);
+
+const mockFileState: VortexFileState = {
+  fileName: 'orders.vortex',
+  fileSize: 12_400_000,
+  rowCount: 100_000,
+  version: 1,
+  dtype: '{order_id=i64, ...}',
+  layoutTree: layout,
+  segments,
+  fileStructure,
+};
+
+const meta: Meta<typeof DetailPanel> = {
+  component: DetailPanel,
+  decorators: [withMockFileContext(mockFileState), withMockSelection(layout)],
+  parameters: {
+    layout: 'padded',
+  },
+};
+export default meta;
+
+type Story = StoryObj<typeof DetailPanel>;
+
+export const NoSelection: Story = {};
diff --git a/vortex-web/src/components/detail/DetailPanel.tsx b/vortex-web/src/components/detail/DetailPanel.tsx
new file mode 100644
index 00000000000..a37ef08ac8d
--- /dev/null
+++ b/vortex-web/src/components/detail/DetailPanel.tsx
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useMemo, useState } from 'react';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import {
+  getNodeDisplayName,
+  findPathToNode,
+  getDtypeCategory,
+  shortEncoding,
+  DTYPE_COLORS,
+} from '../swimlane/utils';
+import { SummaryPane } from './SummaryPane';
+import { ArraySummaryPane } from './ArraySummaryPane';
+import { EncodingPane } from './EncodingPane';
+import { SegmentsPane } from './SegmentsPane';
+import { TreemapPane } from './TreemapPane';
+import { BuffersPane } from './BuffersPane';
+
+type TabId = 'encoding' | 'segments' | 'treemap' | 'buffers';
+
+interface TabDef {
+  id: TabId;
+  label: string;
+}
+
+export function DetailPanel() {
+  const file = useVortexFile();
+  const { state: selection, selectNode, hoverNode } = useSelection();
+  const [activeTab, setActiveTab] = useState<TabId>('segments');
+
+  const isArrayNode = selection.selectedNode?.isArrayNode ?? false;
+
+  const tabs = useMemo<TabDef[]>(() => {
+    const result: TabDef[] = [];
+    if (selection.selectedNode) {
+      if (isArrayNode) {
+        result.push({ id: 'treemap', label: 'Treemap' });
+        if ((selection.selectedNode.bufferLengths ?? []).length > 0) {
+          result.push({ id: 'buffers', label: 'Buffers' });
+        }
+      } else {
+        result.push({ id: 'treemap', label: 'Treemap' });
+        result.push({ id: 'segments', label: 'Segments' });
+        if (selection.selectedNode.children.length === 0) {
+          result.push({ id: 'encoding', label: 'Encoding' });
+        }
+      }
+    }
+    return result;
+  }, [selection.selectedNode, isArrayNode]);
+
+  const selectedPath = useMemo(() => {
+    if (!selection.selectedNodeId) return [];
+    return findPathToNode(file.layoutTree, selection.selectedNodeId);
+  }, [file.layoutTree, selection.selectedNodeId]);
+
+  const hoveredPath = useMemo(() => {
+    if (!selection.hoveredNodeId) return [];
+    return findPathToNode(file.layoutTree, selection.hoveredNodeId);
+  }, [file.layoutTree, selection.hoveredNodeId]);
+
+  const breadcrumb = hoveredPath.length > 0 ? hoveredPath : selectedPath;
+
+  const selectedIdSet = useMemo(() => new Set(selectedPath.map((n) => n.id)), [selectedPath]);
+  const isHoverBreadcrumb = hoveredPath.length > 0;
+
+  const currentTab = tabs.find((t) => t.id === activeTab) ? activeTab : tabs[0]?.id;
+
+  return (
+    <div className="flex flex-col flex-1 min-h-0 h-full bg-vortex-white dark:bg-vortex-black">
+      {/* Breadcrumb + tab bar */}
+      <div className="flex items-center border-b border-vortex-grey-light/40 dark:border-white/[0.06] px-2 flex-shrink-0">
+        {/* Tabs */}
+        <div className="flex">
+          {tabs.map((tab) => (
+            <button
+              key={tab.id}
+              className={`px-2.5 py-1 text-[10px] font-medium border-b-2 transition-colors ${
+                currentTab === tab.id
+                  ? 'border-vortex-light-blue text-vortex-light-blue'
+                  : 'border-transparent text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg'
+              }`}
+              onClick={() => setActiveTab(tab.id)}
+            >
+              {tab.label}
+            </button>
+          ))}
+        </div>
+
+        {/* Breadcrumb — right of tabs */}
+        {breadcrumb.length > 1 && (
+          <div className="flex items-center gap-0.5 ml-auto text-[10px] text-vortex-grey-dark overflow-hidden">
+            {breadcrumb.map((node, i) => {
+              const isLast = i === breadcrumb.length - 1;
+              const isShared = isHoverBreadcrumb && selectedIdSet.has(node.id);
+              const dimClass = isHoverBreadcrumb && !isShared ? 'opacity-50' : '';
+              const prevNode = i > 0 ? breadcrumb[i - 1] : null;
+              const isArrayBoundary = node.isArrayNode && prevNode && !prevNode.isArrayNode;
+              return (
+                <span key={node.id} className={`flex items-center gap-0.5 min-w-0 ${dimClass}`}>
+                  {isArrayBoundary && (
+                    <span
+                      className="opacity-40 flex-shrink-0 mx-0.5"
+                      title={`array: ${shortEncoding(prevNode.encoding)}`}
+                    >
+                      ›
+                    </span>
+                  )}
+                  {i > 0 && !isArrayBoundary && <span className="opacity-40 flex-shrink-0">/</span>}
+                  {isLast && !isHoverBreadcrumb ? (
+                    <span className="text-vortex-fg-light dark:text-vortex-fg truncate">
+                      {getNodeDisplayName(node)}
+                    </span>
+                  ) : (
+                    <button
+                      className="hover:text-vortex-light-blue truncate"
+                      onClick={() => selectNode(node.id)}
+                    >
+                      {getNodeDisplayName(node)}
+                    </button>
+                  )}
+                </span>
+              );
+            })}
+            {(() => {
+              const tip = breadcrumb[breadcrumb.length - 1];
+              if (!tip) return null;
+              const cat = getDtypeCategory(tip.dtype);
+              return (
+                <span
+                  className="ml-1.5 px-1 py-0 rounded text-[9px] font-medium text-white flex-shrink-0"
+                  style={{ backgroundColor: DTYPE_COLORS[cat] }}
+                  title={tip.dtype}
+                >
+                  {cat}
+                </span>
+              );
+            })()}
+          </div>
+        )}
+      </div>
+
+      {/* Main content: tab content (left) + summary sidebar (right) */}
+      <div className="flex flex-1 min-h-0 overflow-hidden">
+        {/* Tab content */}
+        <div className="flex-1 overflow-auto min-w-0">
+          {currentTab === 'encoding' && selection.selectedNode && (
+            <div className="p-2.5">
+              <EncodingPane node={selection.selectedNode} />
+            </div>
+          )}
+          {currentTab === 'segments' && selection.selectedNode && (
+            <SegmentsPane node={selection.selectedNode} segments={file.segments} />
+          )}
+          {currentTab === 'treemap' && selection.selectedNode && (
+            <TreemapPane
+              node={selection.selectedNode}
+              segments={file.segments}
+              onSelectNode={selectNode}
+              onHoverNode={hoverNode}
+            />
+          )}
+          {currentTab === 'buffers' && selection.selectedNode && (
+            <BuffersPane node={selection.selectedNode} />
+          )}
+          {!currentTab && !selection.selectedNode && (
+            <div className="p-2.5 text-xs text-vortex-grey-dark">
+              Select a node to view details.
+            </div>
+          )}
+        </div>
+
+        {/* Summary sidebar — always visible */}
+        <div className="w-[180px] flex-shrink-0 overflow-y-auto border-l border-vortex-grey-light/40 dark:border-white/[0.06] p-2.5">
+          {isArrayNode && selection.selectedNode ? (
+            <ArraySummaryPane node={selection.selectedNode} />
+          ) : (
+            <SummaryPane node={selection.selectedNode} file={file} />
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/detail/EncodingPane.tsx b/vortex-web/src/components/detail/EncodingPane.tsx
new file mode 100644
index 00000000000..d3b17886abd
--- /dev/null
+++ b/vortex-web/src/components/detail/EncodingPane.tsx
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useEffect, useState } from 'react';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import type { LayoutTreeNode, ArrayEncodingNode } from '../swimlane/types';
+import { shortEncoding, formatBytes } from '../swimlane/utils';
+
+interface EncodingPaneProps {
+  node: LayoutTreeNode;
+}
+
+/**
+ * Displays the array encoding tree inside a flat layout.
+ * If the tree is not inlined in the layout metadata, fetches it
+ * asynchronously from the segment data via the worker.
+ */
+export function EncodingPane({ node }: EncodingPaneProps) {
+  const { fetchEncodingTree } = useVortexFile();
+  const [fetchedTree, setFetchedTree] = useState<ArrayEncodingNode | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const tree = node.arrayEncodingTree ?? fetchedTree;
+
+  useEffect(() => {
+    // If already inlined, nothing to fetch.
+    if (node.arrayEncodingTree) return;
+
+    // Need at least one segment to fetch from.
+    if (node.segmentIds.length === 0) return;
+
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    setFetchedTree(null);
+
+    fetchEncodingTree(node.id)
+      .then((result) => {
+        if (!cancelled) setFetchedTree(result);
+      })
+      .catch((err) => {
+        if (!cancelled) setError(err instanceof Error ? err.message : String(err));
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [node.id, node.arrayEncodingTree, node.segmentIds, fetchEncodingTree]);
+
+  if (loading) {
+    return <div className="text-xs text-vortex-grey-dark">Loading encoding tree…</div>;
+  }
+
+  if (error) {
+    return <div className="text-xs text-red-500">Error: {error}</div>;
+  }
+
+  if (!tree) {
+    return (
+      <div className="text-xs text-vortex-grey-dark">
+        No array encoding tree available for this node.
+      </div>
+    );
+  }
+
+  return (
+    <div className="text-xs">
+      <pre className="font-mono text-[10px] text-vortex-grey-dark bg-vortex-grey-lightest dark:bg-white/[0.03] rounded p-2 overflow-auto">
+        {renderArrayTree(tree, 0)}
+      </pre>
+    </div>
+  );
+}
+
+function renderArrayTree(node: ArrayEncodingNode, indent: number): string {
+  const prefix = '  '.repeat(indent);
+  const enc = shortEncoding(node.encoding);
+  const parts = [enc];
+  if (node.bufferLengths.length > 0) {
+    const bufs = node.bufferLengths.map((b) => formatBytes(b)).join(', ');
+    parts.push(`buffers: [${bufs}]`);
+  }
+  if (node.metadataBytes > 0) {
+    parts.push(`meta: ${formatBytes(node.metadataBytes)}`);
+  }
+  const line = `${prefix}${parts.join('  ')}`;
+
+  if (node.children.length === 0) return line;
+
+  const childLines = node.children.map((child) => renderArrayTree(child, indent + 1));
+  return [line, ...childLines].join('\n');
+}
diff --git a/vortex-web/src/components/detail/SegmentsPane.tsx b/vortex-web/src/components/detail/SegmentsPane.tsx
new file mode 100644
index 00000000000..816bb07e1c9
--- /dev/null
+++ b/vortex-web/src/components/detail/SegmentsPane.tsx
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useCallback, useMemo } from 'react';
+import type { LayoutTreeNode, SegmentMapEntry } from '../swimlane/types';
+import { collectSubtreeSegments, findPathToNode, getNodeDisplayName } from '../swimlane/utils';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import { DataTable, type CellRenderer } from '../DataTable';
+
+interface SegmentsPaneProps {
+  node: LayoutTreeNode;
+  segments: SegmentMapEntry[];
+}
+
+export function SegmentsPane({ node, segments }: SegmentsPaneProps) {
+  const file = useVortexFile();
+  const { selectNode, selectSegment, hoverSegment } = useSelection();
+  const subtreeSegmentIds = useMemo(() => new Set(collectSubtreeSegments(node)), [node]);
+
+  const { columns, rows } = useMemo(() => {
+    const filtered = segments.filter((s) => subtreeSegmentIds.has(s.index));
+    const cols = ['index', 'byte_offset', 'byte_length', 'alignment', 'column', 'layout_path'];
+    const rowData = filtered.map((s) => ({
+      index: s.index,
+      byte_offset: s.byteOffset,
+      byte_length: s.byteLength,
+      alignment: s.alignment,
+      column: s.column ?? '',
+      layout_path: s.layoutPath,
+    }));
+    return { columns: cols, rows: rowData };
+  }, [segments, subtreeSegmentIds]);
+
+  const pathRenderer: CellRenderer = useCallback(
+    (_value: unknown, row: Record<string, unknown>) => {
+      const layoutPath = row.layout_path as string;
+      const pathNodes = findPathToNode(file.layoutTree, layoutPath);
+      return (
+        <span className="text-vortex-grey-dark">
+          {pathNodes.map((pathNode, i) => (
+            <span key={pathNode.id}>
+              {i > 0 && <span className="opacity-40">/</span>}
+              <button
+                className="hover:text-vortex-light-blue"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  selectNode(pathNode.id);
+                }}
+              >
+                {getNodeDisplayName(pathNode)}
+              </button>
+            </span>
+          ))}
+        </span>
+      );
+    },
+    [file.layoutTree, selectNode],
+  );
+
+  const handleRowClick = useCallback(
+    (rowIndex: number) => {
+      const row = rows[rowIndex];
+      if (row) selectSegment(row.index as number);
+    },
+    [rows, selectSegment],
+  );
+
+  const handleRowHover = useCallback(
+    (rowIndex: number | null) => {
+      if (rowIndex == null) {
+        hoverSegment(null);
+      } else {
+        const row = rows[rowIndex];
+        if (row) hoverSegment(row.index as number);
+      }
+    },
+    [rows, hoverSegment],
+  );
+
+  if (rows.length === 0) {
+    return <div className="text-xs text-vortex-grey-dark p-2.5">No segments for this node.</div>;
+  }
+
+  return (
+    <div className="h-full">
+      <DataTable
+        columns={columns}
+        rows={rows}
+        onRowClick={handleRowClick}
+        onRowHover={handleRowHover}
+        cellRenderers={{ layout_path: pathRenderer }}
+      />
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/detail/SummaryPane.tsx b/vortex-web/src/components/detail/SummaryPane.tsx
new file mode 100644
index 00000000000..1a0f0eef336
--- /dev/null
+++ b/vortex-web/src/components/detail/SummaryPane.tsx
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode } from '../swimlane/types';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+import {
+  formatBytes,
+  formatRowCount,
+  getNodeDisplayName,
+  collectSubtreeSegments,
+  shortEncoding,
+} from '../swimlane/utils';
+
+function formatNum(n: number): string {
+  return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, '_');
+}
+
+interface SummaryPaneProps {
+  node: LayoutTreeNode | null;
+  file: VortexFileState;
+}
+
+export function SummaryPane({ node, file }: SummaryPaneProps) {
+  if (!node) {
+    // File-level summary
+    return (
+      <div className="text-xs space-y-2">
+        <h3 className="font-medium text-vortex-fg-light dark:text-vortex-fg">File Summary</h3>
+        <div className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 text-vortex-grey-dark">
+          <span>File</span>
+          <span className="text-vortex-fg-light dark:text-vortex-fg">{file.fileName}</span>
+          <span>Size</span>
+          <span className="text-vortex-fg-light dark:text-vortex-fg">
+            {formatBytes(file.fileSize)}
+          </span>
+          <span>Rows</span>
+          <span className="text-vortex-fg-light dark:text-vortex-fg">
+            {formatRowCount(file.rowCount)}
+          </span>
+          <span>Segments</span>
+          <span className="text-vortex-fg-light dark:text-vortex-fg">{file.segments.length}</span>
+          <span>Version</span>
+          <span className="text-vortex-fg-light dark:text-vortex-fg">v{file.version}</span>
+        </div>
+      </div>
+    );
+  }
+
+  // Node-level summary
+  const name = getNodeDisplayName(node);
+  const subtreeSegmentIds = collectSubtreeSegments(node);
+  const reachableSegments = file.segments.filter((s) => subtreeSegmentIds.includes(s.index));
+  const totalBytes = reachableSegments.reduce((sum, s) => sum + s.byteLength, 0);
+
+  return (
+    <div className="text-xs space-y-2">
+      <h3 className="font-medium text-vortex-fg-light dark:text-vortex-fg">{name}</h3>
+      <div className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 text-vortex-grey-dark">
+        <span>Encoding</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg" title={node.encoding}>
+          {shortEncoding(node.encoding)}
+        </span>
+        <span>Rows</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{formatNum(node.rowCount)}</span>
+        <span>Row offset</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">
+          {formatNum(node.rowOffset)}
+        </span>
+        <span>Metadata</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">
+          {formatBytes(node.metadataBytes)}
+        </span>
+        <span>Data size</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{formatBytes(totalBytes)}</span>
+        <span>Segments</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{reachableSegments.length}</span>
+        <span>Children</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{node.children.length}</span>
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/detail/TreemapPane.stories.tsx b/vortex-web/src/components/detail/TreemapPane.stories.tsx
new file mode 100644
index 00000000000..9a97e9c2f52
--- /dev/null
+++ b/vortex-web/src/components/detail/TreemapPane.stories.tsx
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { TreemapPane } from './TreemapPane';
+import { withMockFileContext, withMockSelection } from '../../storybook/decorators';
+import { ordersMock } from '../../mocks/layouts';
+import { generateSegments } from '../../mocks/segments';
+import { generateFileStructure } from '../../mocks/fileStructure';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+
+const layout = ordersMock();
+const segments = generateSegments(layout, 12_400_000);
+const fileStructure = generateFileStructure(segments, 12_400_000);
+
+const mockFileState: VortexFileState = {
+  fileName: 'orders.vortex',
+  fileSize: 12_400_000,
+  rowCount: 100_000,
+  version: 1,
+  dtype: '{order_id=i64, ...}',
+  layoutTree: layout,
+  segments,
+  fileStructure,
+};
+
+const meta: Meta<typeof TreemapPane> = {
+  component: TreemapPane,
+  decorators: [withMockFileContext(mockFileState), withMockSelection(layout)],
+  parameters: {
+    layout: 'fullscreen',
+  },
+};
+export default meta;
+
+type Story = StoryObj<typeof TreemapPane>;
+
+export const RootNode: Story = {
+  args: {
+    node: layout,
+    segments,
+    onSelectNode: (id: string) => console.log('select', id),
+    onHoverNode: (id: string | null) => console.log('hover', id),
+  },
+  decorators: [
+    (Story) => (
+      <div style={{ width: '100%', height: '400px' }}>
+        <Story />
+      </div>
+    ),
+  ],
+};
diff --git a/vortex-web/src/components/detail/TreemapPane.tsx b/vortex-web/src/components/detail/TreemapPane.tsx
new file mode 100644
index 00000000000..55418a972c9
--- /dev/null
+++ b/vortex-web/src/components/detail/TreemapPane.tsx
@@ -0,0 +1,289 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useMemo, useRef, useEffect, useCallback, useState } from 'react';
+import { hierarchy, treemap, treemapSquarify } from 'd3-hierarchy';
+import type { HierarchyRectangularNode } from 'd3-hierarchy';
+import type { LayoutTreeNode, SegmentMapEntry } from '../swimlane/types';
+import {
+  getNodeDisplayName,
+  getDtypeCategory,
+  collectSubtreeSegments,
+  DTYPE_COLORS,
+  formatBytes,
+} from '../swimlane/utils';
+import { useTheme } from '../../contexts/ThemeContext';
+
+interface TreemapPaneProps {
+  node: LayoutTreeNode;
+  segments: SegmentMapEntry[];
+  onSelectNode: (nodeId: string) => void;
+  onHoverNode: (nodeId: string | null) => void;
+}
+
+interface TreeNode {
+  name: string;
+  nodeId: string;
+  color: string;
+  bytes: number;
+  children?: TreeNode[];
+}
+
+type RectNode = HierarchyRectangularNode<TreeNode>;
+
+/** Total buffer bytes for an array node subtree. */
+function arraySubtreeBytes(node: LayoutTreeNode): number {
+  const own = (node.bufferLengths ?? []).reduce((s, b) => s + b, 0);
+  const childBytes = node.children
+    .filter((c) => c.isArrayNode)
+    .reduce((s, c) => s + arraySubtreeBytes(c), 0);
+  return own + childBytes;
+}
+
+function buildTree(node: LayoutTreeNode, segmentMap: Map<number, SegmentMapEntry>): TreeNode {
+  const color = DTYPE_COLORS[getDtypeCategory(node.dtype)];
+  const name = getNodeDisplayName(node);
+
+  // For array nodes, size by buffer bytes; for layout nodes, by segment bytes.
+  // Layout-level treemaps skip array children to avoid eager expansion.
+  const isArray = node.isArrayNode ?? false;
+  const bytes = isArray
+    ? arraySubtreeBytes(node)
+    : collectSubtreeSegments(node).reduce(
+        (sum, id) => sum + (segmentMap.get(id)?.byteLength ?? 0),
+        0,
+      );
+
+  // For layout nodes, skip array children of NON-flat layouts to avoid eager expansion.
+  // Flat layouts and array nodes show all their children (array tree is already fetched).
+  const isFlatOrArray = isArray || node.encoding === 'vortex.flat';
+  const childrenToShow = isFlatOrArray
+    ? node.children
+    : node.children.filter((c) => !c.isArrayNode);
+
+  if (childrenToShow.length === 0) {
+    return { name, nodeId: node.id, color, bytes: Math.max(bytes, 1) };
+  }
+
+  return {
+    name,
+    nodeId: node.id,
+    color,
+    bytes: Math.max(bytes, 1),
+    children: childrenToShow.map((c) => buildTree(c, segmentMap)),
+  };
+}
+
+function resolveThemeColors(choice: 'light' | 'dark' | 'system') {
+  let isDark: boolean;
+  if (choice === 'system') {
+    isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+  } else {
+    isDark = choice === 'dark';
+  }
+  return isDark
+    ? { fg: '#e4e4e8', dim: '#71717a', border: 'rgba(255,255,255,0.12)', highlight: '#2CB9D1' }
+    : { fg: '#18181b', dim: '#71717a', border: 'rgba(0,0,0,0.1)', highlight: '#2CB9D1' };
+}
+
+/** Find the deepest node containing point (px, py), preferring depth >= 1. */
+function hitTest(nodes: RectNode[], px: number, py: number): RectNode | null {
+  let best: RectNode | null = null;
+  for (const n of nodes) {
+    if (n.depth >= 1 && px >= n.x0 && px < n.x1 && py >= n.y0 && py < n.y1) {
+      if (!best || n.depth > best.depth) best = n;
+    }
+  }
+  return best;
+}
+
+/** Collect all nodeIds in a RectNode subtree. */
+function collectRectIds(n: RectNode): Set<string> {
+  const ids = new Set<string>();
+  function walk(node: RectNode) {
+    ids.add(node.data.nodeId);
+    if (node.children) {
+      for (const c of node.children) walk(c);
+    }
+  }
+  walk(n);
+  return ids;
+}
+
+export function TreemapPane({ node, segments, onSelectNode, onHoverNode }: TreemapPaneProps) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const svgRef = useRef<SVGSVGElement>(null);
+  const [size, setSize] = useState<{ w: number; h: number } | null>(null);
+  const [hoveredNodeId, setHoveredNodeId] = useState<string | null>(null);
+  const [selectedNodeId, setSelectedNodeId] = useState<string | null>(null);
+
+  const segmentMap = useMemo(() => new Map(segments.map((s) => [s.index, s])), [segments]);
+
+  const tree = useMemo(() => buildTree(node, segmentMap), [node, segmentMap]);
+  const { theme: themeChoice } = useTheme();
+  const theme = useMemo(() => resolveThemeColors(themeChoice), [themeChoice]);
+
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(([entry]) => {
+      const { width, height } = entry.contentRect;
+      if (width > 0 && height > 0) setSize({ w: width, h: height });
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+
+  // Reset local selection when the treemap root node changes.
+  useEffect(() => {
+    setSelectedNodeId(null);
+  }, [node.id]);
+
+  const nodes = useMemo<RectNode[]>(() => {
+    if (!size) return [];
+    const root = hierarchy(tree)
+      .sum((d) => (d.children ? 0 : d.bytes))
+      .sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
+    treemap<TreeNode>()
+      .size([size.w, size.h])
+      .tile(treemapSquarify)
+      .paddingTop(18)
+      .paddingInner(2)
+      .paddingOuter(1)
+      .round(true)(root);
+    return root.descendants() as RectNode[];
+  }, [tree, size]);
+
+  // Set of nodeIds in the selected depth-1 subtree (for solid highlight).
+  const selectedSubtreeIds = useMemo<Set<string>>(() => {
+    if (!selectedNodeId) return new Set();
+    const selected = nodes.find((n) => n.data.nodeId === selectedNodeId);
+    return selected ? collectRectIds(selected) : new Set();
+  }, [selectedNodeId, nodes]);
+
+  const handleMouseMove = useCallback(
+    (e: React.MouseEvent<SVGSVGElement>) => {
+      const svg = svgRef.current;
+      if (!svg) return;
+      const rect = svg.getBoundingClientRect();
+      const px = e.clientX - rect.left;
+      const py = e.clientY - rect.top;
+      const hit = hitTest(nodes, px, py);
+      const nodeId = hit ? hit.data.nodeId : null;
+      setHoveredNodeId(nodeId);
+      onHoverNode(nodeId);
+    },
+    [nodes, onHoverNode],
+  );
+
+  const handleMouseLeave = useCallback(() => {
+    setHoveredNodeId(null);
+    onHoverNode(null);
+  }, [onHoverNode]);
+
+  const handleClick = useCallback(
+    (e: React.MouseEvent<SVGSVGElement>) => {
+      const svg = svgRef.current;
+      if (!svg) return;
+      const rect = svg.getBoundingClientRect();
+      const px = e.clientX - rect.left;
+      const py = e.clientY - rect.top;
+      const hit = hitTest(nodes, px, py);
+      if (hit) {
+        e.stopPropagation();
+        setSelectedNodeId(hit.data.nodeId);
+      } else {
+        setSelectedNodeId(null);
+      }
+    },
+    [nodes],
+  );
+
+  const handleDoubleClick = useCallback(
+    (e: React.MouseEvent<SVGSVGElement>) => {
+      const svg = svgRef.current;
+      if (!svg) return;
+      const rect = svg.getBoundingClientRect();
+      const px = e.clientX - rect.left;
+      const py = e.clientY - rect.top;
+      const hit = hitTest(nodes, px, py);
+      if (hit) {
+        e.stopPropagation();
+        onSelectNode(hit.data.nodeId);
+      }
+    },
+    [nodes, onSelectNode],
+  );
+
+  return (
+    <div ref={containerRef} className="w-full h-full relative overflow-hidden">
+      {size && (
+        <svg
+          ref={svgRef}
+          width={size.w}
+          height={size.h}
+          className="block cursor-pointer"
+          onMouseMove={handleMouseMove}
+          onMouseLeave={handleMouseLeave}
+          onClick={handleClick}
+          onDoubleClick={handleDoubleClick}
+        >
+          {nodes.map((n) => {
+            const w = n.x1 - n.x0;
+            const h = n.y1 - n.y0;
+            if (w < 1 || h < 1) return null;
+
+            const isLeaf = !n.children || n.children.length === 0;
+            const d = n.data;
+            const isHovered = d.nodeId === hoveredNodeId;
+            const isSelected = selectedSubtreeIds.has(d.nodeId);
+            const maxChars = Math.floor(w / 6);
+            const label =
+              maxChars < 2
+                ? ''
+                : d.name.length > maxChars
+                  ? d.name.slice(0, maxChars - 1) + '\u2026'
+                  : d.name;
+
+            return (
+              <g key={d.nodeId} pointerEvents="none">
+                <rect
+                  x={n.x0}
+                  y={n.y0}
+                  width={w}
+                  height={h}
+                  fill={d.color}
+                  fillOpacity={isSelected ? 0.4 : isLeaf ? 0.18 : 0.06}
+                  stroke={isHovered ? theme.highlight : theme.border}
+                  strokeWidth={isHovered ? 2 : isLeaf ? 0.5 : 1}
+                />
+                {n.depth === 1 && label && h > 14 && (
+                  <text
+                    x={n.x0 + 4}
+                    y={n.y0 + 12}
+                    fill={theme.fg}
+                    fontSize={10}
+                    fontFamily="'Geist Mono', monospace"
+                  >
+                    {label}
+                  </text>
+                )}
+                {n.depth === 1 && w > 50 && h > 28 && (
+                  <text
+                    x={n.x0 + 4}
+                    y={n.y0 + 23}
+                    fill={theme.dim}
+                    fontSize={9}
+                    fontFamily="'Geist Mono', monospace"
+                  >
+                    {formatBytes(d.bytes)}
+                  </text>
+                )}
+              </g>
+            );
+          })}
+        </svg>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/DataPreview.tsx b/vortex-web/src/components/explorer/DataPreview.tsx
new file mode 100644
index 00000000000..41e8efc9d81
--- /dev/null
+++ b/vortex-web/src/components/explorer/DataPreview.tsx
@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useEffect, useMemo, useState } from 'react';
+import { tableFromIPC } from 'apache-arrow';
+import { useSelection } from '../../contexts/SelectionContext';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { parseArrayNodeId } from '../swimlane/utils';
+import { DataTable } from '../DataTable';
+
+const ROW_LIMIT = 5000;
+
+function decodeArrow(ipcBytes: Uint8Array): {
+  columns: string[];
+  rows: Record<string, unknown>[];
+} {
+  const table = tableFromIPC(ipcBytes);
+  const columns = table.schema.fields.map((f) => f.name);
+  const rows: Record<string, unknown>[] = [];
+  for (let i = 0; i < table.numRows; i++) {
+    const row: Record<string, unknown> = {};
+    for (const col of columns) {
+      row[col] = table.getChild(col)?.get(i) ?? null;
+    }
+    rows.push(row);
+  }
+  return { columns, rows };
+}
+
+export function DataPreview() {
+  const { state: selection } = useSelection();
+  const { previewData, previewArrayData } = useVortexFile();
+  const [ipcBytes, setIpcBytes] = useState<Uint8Array | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const selectedNodeId = selection.selectedNodeId;
+  const isArrayNode = selection.selectedNode?.isArrayNode ?? false;
+
+  useEffect(() => {
+    if (!selectedNodeId) {
+      setIpcBytes(null);
+      setError(null);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    const fetchPromise = isArrayNode
+      ? (() => {
+          const { layoutNodeId, arrayPath } = parseArrayNodeId(selectedNodeId);
+          return previewArrayData(layoutNodeId, arrayPath, ROW_LIMIT);
+        })()
+      : previewData(selectedNodeId, ROW_LIMIT);
+
+    fetchPromise
+      .then((bytes) => {
+        if (!cancelled) setIpcBytes(bytes);
+      })
+      .catch((err) => {
+        if (!cancelled) setError(err instanceof Error ? err.message : String(err));
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedNodeId, isArrayNode, previewData, previewArrayData]);
+
+  const decoded = useMemo(() => {
+    if (!ipcBytes) return null;
+    try {
+      return decodeArrow(ipcBytes);
+    } catch (err) {
+      console.error('Arrow decode error:', err);
+      return null;
+    }
+  }, [ipcBytes]);
+
+  if (!selectedNodeId) {
+    return (
+      <div className="h-full flex items-center justify-center text-[11px] text-vortex-grey-dark">
+        Select a node to preview data
+      </div>
+    );
+  }
+
+  if (loading) {
+    return (
+      <div className="h-full flex items-center justify-center text-[11px] text-vortex-grey-dark">
+        Loading preview…
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="h-full flex items-center justify-center text-[11px] text-red-500 px-4 text-center">
+        {error}
+      </div>
+    );
+  }
+
+  if (!decoded || decoded.rows.length === 0) {
+    return (
+      <div className="h-full flex items-center justify-center text-[11px] text-vortex-grey-dark">
+        No data
+      </div>
+    );
+  }
+
+  return (
+    <DataTable
+      columns={decoded.columns}
+      rows={decoded.rows}
+      approximate={decoded.rows.length >= ROW_LIMIT}
+    />
+  );
+}
diff --git a/vortex-web/src/components/explorer/ExplorerShell.stories.tsx b/vortex-web/src/components/explorer/ExplorerShell.stories.tsx
new file mode 100644
index 00000000000..aa8cec1a8bd
--- /dev/null
+++ b/vortex-web/src/components/explorer/ExplorerShell.stories.tsx
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { FileHeader } from './FileHeader';
+import { MainArea } from './MainArea';
+import { StatusBar } from './StatusBar';
+import { withMockFileContext, withMockSelection } from '../../storybook/decorators';
+import { ordersMock } from '../../mocks/layouts';
+import { generateSegments } from '../../mocks/segments';
+import { generateFileStructure } from '../../mocks/fileStructure';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+
+const layout = ordersMock();
+const segments = generateSegments(layout, 12_400_000);
+const fileStructure = generateFileStructure(segments, 12_400_000);
+
+const mockFileState: VortexFileState = {
+  fileName: 'orders.vortex',
+  fileSize: 12_400_000,
+  rowCount: 100_000,
+  version: 1,
+  dtype:
+    '{order_id=i64, is_active=bool, customer={id=i64, name=utf8}, items=list<struct>, amount=f64, metadata=struct, status=utf8}',
+  layoutTree: layout,
+  segments,
+  fileStructure,
+};
+
+/** Full page layout — mirrors App.tsx when a file is loaded */
+function ExplorerPage() {
+  return (
+    <div className="flex flex-col h-screen bg-vortex-white dark:bg-vortex-black">
+      <FileHeader onClose={() => {}} />
+      <MainArea />
+      <StatusBar />
+    </div>
+  );
+}
+
+const meta: Meta<typeof ExplorerPage> = {
+  component: ExplorerPage,
+  parameters: { layout: 'fullscreen' },
+  decorators: [withMockFileContext(mockFileState), withMockSelection(layout)],
+};
+export default meta;
+
+type Story = StoryObj<typeof ExplorerPage>;
+
+export const Default: Story = {};
diff --git a/vortex-web/src/components/explorer/FileDropScreen.tsx b/vortex-web/src/components/explorer/FileDropScreen.tsx
new file mode 100644
index 00000000000..14db31e0c03
--- /dev/null
+++ b/vortex-web/src/components/explorer/FileDropScreen.tsx
@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState, useCallback, type DragEvent, type FormEvent } from 'react';
+import { ThemePicker } from '../ThemePicker';
+
+interface FileDropScreenProps {
+  onFileLoaded: (file: File) => void;
+  loading: boolean;
+  error: string | null;
+}
+
+export function FileDropScreen({ onFileLoaded, loading, error }: FileDropScreenProps) {
+  const [isDragging, setIsDragging] = useState(false);
+  const [url, setUrl] = useState('');
+  const [fetchingUrl, setFetchingUrl] = useState(false);
+  const [urlError, setUrlError] = useState<string | null>(null);
+
+  const handleDragOver = useCallback((e: DragEvent<HTMLDivElement>) => {
+    e.preventDefault();
+    setIsDragging(true);
+  }, []);
+
+  const handleDragLeave = useCallback((e: DragEvent<HTMLDivElement>) => {
+    e.preventDefault();
+    setIsDragging(false);
+  }, []);
+
+  const handleDrop = useCallback(
+    (e: DragEvent<HTMLDivElement>) => {
+      e.preventDefault();
+      setIsDragging(false);
+      const file = e.dataTransfer.files[0];
+      if (file) onFileLoaded(file);
+    },
+    [onFileLoaded],
+  );
+
+  const handleClick = useCallback(() => {
+    const input = document.createElement('input');
+    input.type = 'file';
+    input.accept = '.vortex,.vtx';
+    input.onchange = () => {
+      const file = input.files?.[0];
+      if (file) onFileLoaded(file);
+    };
+    input.click();
+  }, [onFileLoaded]);
+
+  const handleUrlSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault();
+      const trimmed = url.trim();
+      if (!trimmed) return;
+
+      setFetchingUrl(true);
+      setUrlError(null);
+      try {
+        const resp = await fetch(trimmed);
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+        const blob = await resp.blob();
+        const name = trimmed.split('/').pop() ?? 'remote.vortex';
+        const file = new File([blob], name, { type: blob.type });
+        onFileLoaded(file);
+      } catch (err) {
+        setUrlError(err instanceof Error ? err.message : String(err));
+      } finally {
+        setFetchingUrl(false);
+      }
+    },
+    [url, onFileLoaded],
+  );
+
+  const busy = loading || fetchingUrl;
+
+  return (
+    <div className="flex min-h-screen flex-col items-center justify-center text-vortex-fg-light dark:text-vortex-fg relative">
+      <div className="absolute top-3 right-3">
+        <ThemePicker />
+      </div>
+      <h1 className="mb-8 font-funnel text-4xl font-light tracking-tight md:text-6xl">
+        Vortex Explorer
+      </h1>
+
+      <div
+        onDragOver={handleDragOver}
+        onDragLeave={handleDragLeave}
+        onDrop={handleDrop}
+        onClick={handleClick}
+        className={`dashed-top dashed-bottom flex h-64 w-full max-w-lg cursor-pointer flex-col items-center justify-center transition-colors ${
+          isDragging
+            ? 'bg-vortex-light-blue/10'
+            : 'hover:bg-vortex-black/[0.03] dark:hover:bg-white/[0.03]'
+        }`}
+      >
+        {busy ? (
+          <p className="font-mono text-lg text-vortex-grey-dark">
+            {fetchingUrl ? 'Fetching…' : 'Loading…'}
+          </p>
+        ) : (
+          <div className="text-center">
+            <p className="font-mono text-lg text-vortex-grey-dark">
+              Drop a{' '}
+              <code className="rounded bg-vortex-black/[0.06] dark:bg-white/[0.08] px-1.5 py-0.5 text-vortex-light-blue">
+                .vortex
+              </code>{' '}
+              file here
+            </p>
+            <p className="mt-2 font-mono text-sm text-vortex-grey-dark/60">or click to browse</p>
+          </div>
+        )}
+      </div>
+
+      {/* URL input */}
+      <form
+        onSubmit={handleUrlSubmit}
+        className="mt-6 flex w-full max-w-lg gap-2"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <input
+          type="url"
+          value={url}
+          onChange={(e) => setUrl(e.target.value)}
+          placeholder="https://example.com/file.vortex"
+          disabled={busy}
+          className="flex-1 rounded border border-vortex-grey-light/40 dark:border-white/[0.08] bg-transparent px-3 py-1.5 font-mono text-sm text-vortex-fg-light dark:text-vortex-fg placeholder:text-vortex-grey-dark/40 focus:border-vortex-light-blue focus:outline-none disabled:opacity-50"
+        />
+        <button
+          type="submit"
+          disabled={busy || !url.trim()}
+          className="rounded bg-vortex-light-blue px-4 py-1.5 font-mono text-sm text-white hover:opacity-90 disabled:opacity-40 transition-opacity"
+        >
+          Open
+        </button>
+      </form>
+
+      {(error || urlError) && (
+        <p className="mt-4 max-w-lg font-mono text-sm text-vortex-red">{urlError || error}</p>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/FileHeader.stories.tsx b/vortex-web/src/components/explorer/FileHeader.stories.tsx
new file mode 100644
index 00000000000..f01be01db41
--- /dev/null
+++ b/vortex-web/src/components/explorer/FileHeader.stories.tsx
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { FileHeader } from './FileHeader';
+import { withMockFileContext } from '../../storybook/decorators';
+import { ordersMock } from '../../mocks/layouts';
+import { generateSegments } from '../../mocks/segments';
+import { generateFileStructure } from '../../mocks/fileStructure';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+
+const layout = ordersMock();
+const segments = generateSegments(layout, 12_400_000);
+const fileStructure = generateFileStructure(segments, 12_400_000);
+
+const mockFileState: VortexFileState = {
+  fileName: 'orders.vortex',
+  fileSize: 12_400_000,
+  rowCount: 100_000,
+  version: 1,
+  dtype: '{order_id=i64, ...}',
+  layoutTree: layout,
+  segments,
+  fileStructure,
+};
+
+const meta: Meta<typeof FileHeader> = {
+  component: FileHeader,
+  decorators: [withMockFileContext(mockFileState)],
+};
+export default meta;
+
+type Story = StoryObj<typeof FileHeader>;
+
+export const Default: Story = {};
diff --git a/vortex-web/src/components/explorer/FileHeader.tsx b/vortex-web/src/components/explorer/FileHeader.tsx
new file mode 100644
index 00000000000..9dd2f1335db
--- /dev/null
+++ b/vortex-web/src/components/explorer/FileHeader.tsx
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { ThemePicker } from '../ThemePicker';
+
+interface FileHeaderProps {
+  onClose: () => void;
+}
+
+export function FileHeader({ onClose }: FileHeaderProps) {
+  const file = useVortexFile();
+
+  return (
+    <div className="flex items-center gap-3 px-3 py-1.5 border-b border-vortex-grey-light/60 dark:border-white/[0.08] bg-vortex-white dark:bg-vortex-black flex-shrink-0">
+      <span className="font-medium text-sm text-vortex-fg-light dark:text-vortex-fg">
+        {file.fileName}
+      </span>
+      <span
+        className="text-[10px] text-vortex-grey-dark cursor-default"
+        title="Vortex file format version"
+      >
+        v{file.version}
+      </span>
+      <div className="ml-auto flex items-center gap-1">
+        <ThemePicker />
+        <button
+          onClick={onClose}
+          className="p-1.5 rounded-md text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg hover:bg-vortex-grey-lightest dark:hover:bg-white/[0.06] transition-colors cursor-pointer"
+          title="Close file"
+          aria-label="Close file"
+        >
+          <svg
+            width="14"
+            height="14"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+          >
+            <line x1="18" y1="6" x2="6" y2="18" />
+            <line x1="6" y1="6" x2="18" y2="18" />
+          </svg>
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/FileMap.stories.tsx b/vortex-web/src/components/explorer/FileMap.stories.tsx
new file mode 100644
index 00000000000..5f4bebf4798
--- /dev/null
+++ b/vortex-web/src/components/explorer/FileMap.stories.tsx
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { FileMap } from './FileMap';
+import { withMockFileContext, withMockSelection } from '../../storybook/decorators';
+import { ordersMock } from '../../mocks/layouts';
+import { generateSegments } from '../../mocks/segments';
+import { generateFileStructure } from '../../mocks/fileStructure';
+import type { VortexFileState } from '../../contexts/VortexFileContext';
+
+const layout = ordersMock();
+const segments = generateSegments(layout, 12_400_000);
+const fileStructure = generateFileStructure(segments, 12_400_000);
+
+const mockFileState: VortexFileState = {
+  fileName: 'orders.vortex',
+  fileSize: 12_400_000,
+  rowCount: 100_000,
+  version: 1,
+  dtype: '{order_id=i64, ...}',
+  layoutTree: layout,
+  segments,
+  fileStructure,
+};
+
+const meta: Meta<typeof FileMap> = {
+  component: FileMap,
+  decorators: [withMockFileContext(mockFileState), withMockSelection(layout)],
+};
+export default meta;
+
+type Story = StoryObj<typeof FileMap>;
+
+export const Default: Story = {
+  args: { height: 40 },
+};
+
+export const Tall: Story = {
+  args: { height: 80 },
+};
diff --git a/vortex-web/src/components/explorer/FileMap.tsx b/vortex-web/src/components/explorer/FileMap.tsx
new file mode 100644
index 00000000000..4ab0bfdadc6
--- /dev/null
+++ b/vortex-web/src/components/explorer/FileMap.tsx
@@ -0,0 +1,322 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useRef, useEffect, useMemo, useState, useCallback } from 'react';
+import { collectSubtreeSegments, formatBytes } from '../swimlane/utils';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import type { SegmentMapEntry } from '../swimlane/types';
+
+/**
+ * Pixel-level byte map of the file. Height matches one line of text (1lh).
+ *
+ * Three rendering tiers:
+ *  1. Selected segment (if any): bright blue, full opacity.
+ *  2. Other subtree segments: dim blue.
+ *  3. Everything else: neutral base.
+ */
+export function FileMap() {
+  const file = useVortexFile();
+  const { state: selection, hoverNode, selectNode } = useSelection();
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [crosshair, setCrosshair] = useState<number | null>(null);
+  const [byteOffset, setByteOffset] = useState<number | null>(null);
+  const [hoveredSeg, setHoveredSeg] = useState<SegmentMapEntry | null>(null);
+
+  // Segments belonging to the selected subtree, sorted by byte offset
+  const subtreeSegments = useMemo((): SegmentMapEntry[] => {
+    if (!selection.selectedNode) return [];
+    const segIds = new Set(collectSubtreeSegments(selection.selectedNode));
+    return file.segments
+      .filter((s) => segIds.has(s.index))
+      .sort((a, b) => a.byteOffset - b.byteOffset);
+  }, [selection.selectedNode, file.segments]);
+
+  // The single selected segment (if any), sorted for scan
+  const focusedSegment = useMemo((): SegmentMapEntry | null => {
+    if (selection.selectedSegmentIndex == null) return null;
+    return file.segments.find((s) => s.index === selection.selectedSegmentIndex) ?? null;
+  }, [selection.selectedSegmentIndex, file.segments]);
+
+  // Segments for hover preview (from hovered node or hovered segment)
+  const hoverSegments = useMemo((): SegmentMapEntry[] => {
+    if (selection.hoveredNode) {
+      const segIds = new Set(collectSubtreeSegments(selection.hoveredNode));
+      return file.segments
+        .filter((s) => segIds.has(s.index))
+        .sort((a, b) => a.byteOffset - b.byteOffset);
+    }
+    if (selection.hoveredSegmentIndex != null) {
+      const seg = file.segments.find((s) => s.index === selection.hoveredSegmentIndex);
+      return seg ? [seg] : [];
+    }
+    return [];
+  }, [selection.hoveredNode, selection.hoveredSegmentIndex, file.segments]);
+
+  // Paint
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const container = containerRef.current;
+    if (!canvas || !container) return;
+
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    if (width === 0 || height === 0) return;
+
+    const dpr = window.devicePixelRatio || 1;
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return;
+
+    const fileSize = file.fileStructure.fileSize;
+    if (fileSize === 0) return;
+
+    const imgData = ctx.createImageData(width * dpr, height * dpr);
+    const data = imgData.data;
+    const imgW = imgData.width;
+    const imgH = imgData.height;
+
+    const dark =
+      document.documentElement.classList.contains('dark') ||
+      window.matchMedia('(prefers-color-scheme: dark)').matches;
+
+    // Base: neutral
+    const baseR = dark ? 50 : 210;
+    const baseG = dark ? 50 : 210;
+    const baseB = dark ? 50 : 210;
+    const baseA = dark ? 80 : 100;
+
+    // Highlight color (vortex light blue #2CB9D1)
+    const hlR = 44,
+      hlG = 185,
+      hlB = 209;
+
+    const hasSubtree = subtreeSegments.length > 0;
+    const hasHover = hoverSegments.length > 0;
+    const bytesPerPixel = fileSize / width;
+
+    let segIdx = 0;
+    let hoverIdx = 0;
+
+    for (let px = 0; px < width; px++) {
+      const byteStart = px * bytesPerPixel;
+      const byteEnd = (px + 1) * bytesPerPixel;
+
+      // Advance subtree scan
+      while (
+        segIdx < subtreeSegments.length &&
+        subtreeSegments[segIdx].byteOffset + subtreeSegments[segIdx].byteLength <= byteStart
+      ) {
+        segIdx++;
+      }
+
+      // Advance hover scan
+      while (
+        hoverIdx < hoverSegments.length &&
+        hoverSegments[hoverIdx].byteOffset + hoverSegments[hoverIdx].byteLength <= byteStart
+      ) {
+        hoverIdx++;
+      }
+
+      // Check subtree hit
+      let isSubtree = false;
+      if (hasSubtree) {
+        for (let s = segIdx; s < subtreeSegments.length; s++) {
+          if (subtreeSegments[s].byteOffset >= byteEnd) break;
+          isSubtree = true;
+          break;
+        }
+      }
+
+      // Check hover hit
+      let isHovered = false;
+      if (hasHover) {
+        for (let h = hoverIdx; h < hoverSegments.length; h++) {
+          if (hoverSegments[h].byteOffset >= byteEnd) break;
+          isHovered = true;
+          break;
+        }
+      }
+
+      // Check focused segment hit
+      let isFocused = false;
+      if (focusedSegment) {
+        const fStart = focusedSegment.byteOffset;
+        const fEnd = fStart + focusedSegment.byteLength;
+        if (fStart < byteEnd && fEnd > byteStart) {
+          isFocused = true;
+        }
+      }
+
+      let r: number, g: number, b: number, a: number;
+      if (isHovered) {
+        // Hover always wins — bright highlight
+        r = hlR;
+        g = hlG;
+        b = hlB;
+        a = 255;
+      } else if (isFocused) {
+        r = hlR;
+        g = hlG;
+        b = hlB;
+        a = 255;
+      } else if (isSubtree && !focusedSegment) {
+        // No segment selected: all subtree segments are bright
+        r = hlR;
+        g = hlG;
+        b = hlB;
+        a = dark ? 140 : 160;
+      } else if (isSubtree) {
+        // A segment is selected: other subtree segments are dimmed
+        r = hlR;
+        g = hlG;
+        b = hlB;
+        a = dark ? 90 : 110;
+      } else {
+        r = baseR;
+        g = baseG;
+        b = baseB;
+        a = baseA;
+      }
+
+      const dprPxStart = Math.round(px * dpr);
+      const dprPxEnd = Math.round((px + 1) * dpr);
+
+      for (let dpx = dprPxStart; dpx < dprPxEnd && dpx < imgW; dpx++) {
+        for (let dy = 0; dy < imgH; dy++) {
+          const idx = (dy * imgW + dpx) * 4;
+          data[idx] = r;
+          data[idx + 1] = g;
+          data[idx + 2] = b;
+          data[idx + 3] = a;
+        }
+      }
+    }
+
+    ctx.putImageData(imgData, 0, 0);
+  }, [file, subtreeSegments, focusedSegment, hoverSegments]);
+
+  // All segments sorted by byte offset for hit-testing
+  const sortedSegments = useMemo(
+    () => [...file.segments].sort((a, b) => a.byteOffset - b.byteOffset),
+    [file.segments],
+  );
+
+  // Find the segment at a given byte offset using binary search
+  const findSegmentAtByte = useCallback(
+    (byte: number): SegmentMapEntry | null => {
+      let lo = 0;
+      let hi = sortedSegments.length - 1;
+      while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const seg = sortedSegments[mid];
+        if (byte < seg.byteOffset) {
+          hi = mid - 1;
+        } else if (byte >= seg.byteOffset + seg.byteLength) {
+          lo = mid + 1;
+        } else {
+          return seg;
+        }
+      }
+      return null;
+    },
+    [sortedSegments],
+  );
+
+  // Resize observer
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const observer = new ResizeObserver(() => {
+      const canvas = canvasRef.current;
+      if (canvas) canvas.dispatchEvent(new Event('resize'));
+    });
+    observer.observe(container);
+    return () => observer.disconnect();
+  }, []);
+
+  const handleMouseMove = useCallback(
+    (e: React.MouseEvent) => {
+      const container = containerRef.current;
+      if (!container) return;
+      const rect = container.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      setCrosshair(x);
+
+      const fileSize = file.fileStructure.fileSize;
+      const byte = (x / container.clientWidth) * fileSize;
+      setByteOffset(Math.floor(byte));
+
+      const seg = findSegmentAtByte(byte);
+      setHoveredSeg(seg);
+      hoverNode(seg ? seg.layoutPath : null);
+    },
+    [file.fileStructure.fileSize, findSegmentAtByte, hoverNode],
+  );
+
+  const handleMouseLeave = useCallback(() => {
+    setCrosshair(null);
+    setByteOffset(null);
+    setHoveredSeg(null);
+    hoverNode(null);
+  }, [hoverNode]);
+
+  const handleClick = useCallback(
+    (e: React.MouseEvent) => {
+      const container = containerRef.current;
+      if (!container) return;
+      const rect = container.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      const fileSize = file.fileStructure.fileSize;
+      const byte = (x / container.clientWidth) * fileSize;
+      const seg = findSegmentAtByte(byte);
+      if (seg) {
+        selectNode(seg.layoutPath);
+      }
+    },
+    [file.fileStructure.fileSize, findSegmentAtByte, selectNode],
+  );
+
+  return (
+    <div
+      ref={containerRef}
+      className="relative cursor-crosshair flex-shrink-0 h-[1lh] text-[10px] leading-none"
+      onMouseMove={handleMouseMove}
+      onMouseLeave={handleMouseLeave}
+      onClick={handleClick}
+    >
+      <canvas ref={canvasRef} className="block" />
+      {crosshair !== null && (
+        <>
+          <div
+            className="absolute top-0 bottom-0 w-px bg-vortex-black dark:bg-vortex-white opacity-50 pointer-events-none"
+            style={{ left: crosshair }}
+          />
+          {byteOffset !== null && (
+            <div
+              className="absolute bottom-full mb-1 -translate-x-1/2 px-1.5 py-1 rounded text-[9px] bg-vortex-black/90 dark:bg-white/90 text-white dark:text-vortex-black whitespace-nowrap pointer-events-none leading-normal"
+              style={{ left: crosshair }}
+            >
+              {hoveredSeg ? (
+                <div className="flex flex-col gap-0.5">
+                  <span className="font-medium">{hoveredSeg.layoutPath}</span>
+                  <span className="opacity-70">
+                    segment {hoveredSeg.index} &middot; {formatBytes(hoveredSeg.byteLength)} @{' '}
+                    {formatBytes(hoveredSeg.byteOffset)}
+                  </span>
+                </div>
+              ) : (
+                <span className="opacity-70">{formatBytes(byteOffset)}</span>
+              )}
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/MainArea.tsx b/vortex-web/src/components/explorer/MainArea.tsx
new file mode 100644
index 00000000000..a8029e1c0e8
--- /dev/null
+++ b/vortex-web/src/components/explorer/MainArea.tsx
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useCallback, useRef, useState } from 'react';
+import { TreePanel } from './TreePanel';
+import { FileMap } from './FileMap';
+import { DataPreview } from './DataPreview';
+import { DetailPanel } from '../detail/DetailPanel';
+
+const MIN_PANEL_HEIGHT = 120;
+const DEFAULT_PREVIEW_HEIGHT = 200;
+
+/**
+ * Main explorer area: tree panel (left) | detail + filemap + preview (right).
+ *
+ * The preview panel at the bottom is vertically resizable via a drag handle.
+ */
+export function MainArea() {
+  const [previewHeight, setPreviewHeight] = useState(DEFAULT_PREVIEW_HEIGHT);
+  const dragging = useRef(false);
+  const startY = useRef(0);
+  const startHeight = useRef(0);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const onPointerDown = useCallback(
+    (e: React.PointerEvent) => {
+      e.preventDefault();
+      dragging.current = true;
+      startY.current = e.clientY;
+      startHeight.current = previewHeight;
+      (e.target as HTMLElement).setPointerCapture(e.pointerId);
+    },
+    [previewHeight],
+  );
+
+  const onPointerMove = useCallback((e: React.PointerEvent) => {
+    if (!dragging.current) return;
+    const containerHeight = containerRef.current?.clientHeight ?? 600;
+    const maxPreview = containerHeight - MIN_PANEL_HEIGHT;
+    const delta = startY.current - e.clientY;
+    const next = Math.min(maxPreview, Math.max(MIN_PANEL_HEIGHT, startHeight.current + delta));
+    setPreviewHeight(next);
+  }, []);
+
+  const onPointerUp = useCallback(() => {
+    dragging.current = false;
+  }, []);
+
+  return (
+    <div className="flex flex-1 min-h-0 overflow-hidden">
+      {/* Left: tree panel — full height, fixed width */}
+      <div className="w-[260px] flex-shrink-0 h-full overflow-hidden">
+        <TreePanel />
+      </div>
+
+      {/* Right: detail pane, file map, data preview — stacked vertically */}
+      <div ref={containerRef} className="flex-1 flex flex-col min-w-0 h-full overflow-hidden">
+        {/* Detail pane — fills available vertical space, scrolls internally */}
+        <DetailPanel />
+
+        {/* File map strip */}
+        <div className="flex-shrink-0">
+          <FileMap />
+        </div>
+
+        {/* Resize handle */}
+        <div
+          className="flex-shrink-0 h-1 cursor-row-resize border-t border-vortex-grey-light/40 dark:border-white/[0.06] hover:bg-vortex-light-blue/20 active:bg-vortex-light-blue/30 transition-colors"
+          onPointerDown={onPointerDown}
+          onPointerMove={onPointerMove}
+          onPointerUp={onPointerUp}
+        />
+
+        {/* Data preview — resizable bottom section */}
+        <div className="flex-shrink-0 overflow-hidden" style={{ height: previewHeight }}>
+          <DataPreview />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/StatusBar.tsx b/vortex-web/src/components/explorer/StatusBar.tsx
new file mode 100644
index 00000000000..95adf129795
--- /dev/null
+++ b/vortex-web/src/components/explorer/StatusBar.tsx
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useMemo } from 'react';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import { formatBytes, formatRowCount, collectSubtreeSegments } from '../swimlane/utils';
+
+export function StatusBar() {
+  const file = useVortexFile();
+  const { state: selection } = useSelection();
+
+  // Show hovered node stats if hovering, otherwise selected node stats.
+  const activeNode = selection.hoveredNode ?? selection.selectedNode;
+
+  const selectionStats = useMemo(() => {
+    if (!activeNode) return null;
+
+    const segIds = new Set(collectSubtreeSegments(activeNode));
+    const reachable = file.segments.filter((s) => segIds.has(s.index));
+    const totalBytes = reachable.reduce((sum, s) => sum + s.byteLength, 0);
+    const pct =
+      file.fileStructure.fileSize > 0 ? (totalBytes / file.fileStructure.fileSize) * 100 : 0;
+
+    return {
+      rows: activeNode.rowCount,
+      segments: reachable.length,
+      bytes: totalBytes,
+      pct,
+    };
+  }, [activeNode, file.segments, file.fileStructure.fileSize]);
+
+  return (
+    <div className="flex items-center px-3 h-6 flex-shrink-0 border-t border-vortex-grey-light/60 dark:border-white/[0.08] bg-vortex-grey-lightest/50 dark:bg-white/[0.02] text-[10px] text-vortex-grey-dark">
+      {/* File-level stats — left */}
+      <div className="flex items-center gap-3">
+        <Stat label="Rows" value={formatRowCount(file.rowCount)} />
+        <Stat label="Size" value={formatBytes(file.fileSize)} />
+        <Stat label="Segments" value={String(file.segments.length)} />
+      </div>
+
+      <div className="flex-1" />
+
+      {/* Selection stats — right */}
+      {selectionStats && (
+        <div className="flex items-center gap-3">
+          <Stat label="rows" value={formatRowCount(selectionStats.rows)} />
+          <Stat label="segments" value={String(selectionStats.segments)} />
+          <Stat
+            label="bytes"
+            value={`${formatBytes(selectionStats.bytes)} (${selectionStats.pct.toFixed(1)}%)`}
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
+function Stat({ label, value }: { label: string; value: string }) {
+  return (
+    <span className="whitespace-nowrap">
+      <span className="mr-0.5">{label}:</span>
+      <span className="text-vortex-fg-light dark:text-vortex-fg">{value}</span>
+    </span>
+  );
+}
diff --git a/vortex-web/src/components/explorer/TimelineTab.tsx b/vortex-web/src/components/explorer/TimelineTab.tsx
new file mode 100644
index 00000000000..2df69fc6515
--- /dev/null
+++ b/vortex-web/src/components/explorer/TimelineTab.tsx
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState } from 'react';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import { LayoutSwimlane } from '../swimlane/LayoutSwimlane';
+
+export function TimelineTab() {
+  const file = useVortexFile();
+  const { state: selection, selectNode } = useSelection();
+  const [mode, setMode] = useState<'schema' | 'layout'>('schema');
+
+  return (
+    <div className="flex flex-col flex-1 min-h-0">
+      {/* Mode toggle */}
+      <div className="flex items-center gap-2 px-4 py-2 flex-shrink-0">
+        <button
+          className={`px-3 py-1 text-xs rounded ${
+            mode === 'schema'
+              ? 'bg-vortex-light-blue/15 text-vortex-light-blue font-medium'
+              : 'text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg'
+          }`}
+          onClick={() => setMode('schema')}
+        >
+          Schema
+        </button>
+        <button
+          className={`px-3 py-1 text-xs rounded ${
+            mode === 'layout'
+              ? 'bg-vortex-light-blue/15 text-vortex-light-blue font-medium'
+              : 'text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg'
+          }`}
+          onClick={() => setMode('layout')}
+        >
+          Layout
+        </button>
+      </div>
+
+      <LayoutSwimlane
+        layout={file.layoutTree}
+        totalRows={file.rowCount}
+        mode={mode}
+        selectedNodeId={selection.selectedNodeId}
+        onNodeSelect={selectNode}
+        defaultExpanded={['root']}
+      />
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/explorer/TreePanel.tsx b/vortex-web/src/components/explorer/TreePanel.tsx
new file mode 100644
index 00000000000..a0b15e2a042
--- /dev/null
+++ b/vortex-web/src/components/explorer/TreePanel.tsx
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
+import { useVortexFile } from '../../contexts/VortexFileContext';
+import { useSelection } from '../../contexts/SelectionContext';
+import {
+  flattenTree,
+  filterTreeBySearch,
+  findPathToNode,
+  isFlatLayout,
+  findNodeById,
+} from '../swimlane/utils';
+import { TreeRow } from '../swimlane/TreeRow';
+import { TreeSearch } from '../swimlane/TreeSearch';
+
+type TreeMode = 'schema' | 'layout';
+
+export function TreePanel() {
+  const file = useVortexFile();
+  const { state: selection, selectNode, hoverNode } = useSelection();
+  const [mode, setMode] = useState<TreeMode>('schema');
+  const [expanded, setExpanded] = useState<Set<string>>(() => new Set(['root']));
+  const [searchQuery, setSearchQuery] = useState('');
+
+  // Auto-expand ancestors so the selected node is visible, including synthetic group nodes.
+  useEffect(() => {
+    if (!selection.selectedNodeId) return;
+    const path = findPathToNode(file.layoutTree, selection.selectedNodeId);
+    if (path.length === 0) return;
+
+    setExpanded((prev) => {
+      let next = new Set(prev);
+      for (const node of path) next.add(node.id);
+
+      // Iteratively expand group nodes that contain the target until it's visible.
+      for (let attempt = 0; attempt < 5; attempt++) {
+        const rows = flattenTree(file.layoutTree, next, null, mode);
+        if (rows.some((r) => r.node.id === selection.selectedNodeId)) break;
+
+        // Find group rows whose grouped children include the target.
+        let changed = false;
+        for (const row of rows) {
+          if (row.displayKind === 'group' && row.groupedChildren) {
+            if (row.groupedChildren.some((c) => c.id === selection.selectedNodeId)) {
+              next = new Set(next);
+              next.add(row.node.id);
+              changed = true;
+            }
+          }
+        }
+        if (!changed) break;
+      }
+
+      return next;
+    });
+  }, [selection.selectedNodeId, file.layoutTree, mode]);
+
+  // Scroll the selected node into view only when the selection changes.
+  const scrollContainerRef = useRef<HTMLDivElement>(null);
+  const lastScrolledTo = useRef<string | null>(null);
+  useEffect(() => {
+    if (!selection.selectedNodeId || selection.selectedNodeId === lastScrolledTo.current) return;
+    lastScrolledTo.current = selection.selectedNodeId;
+    // Defer to let the DOM update after expansion.
+    requestAnimationFrame(() => {
+      const container = scrollContainerRef.current;
+      if (!container) return;
+      const el = container.querySelector(
+        `[data-node-id="${CSS.escape(selection.selectedNodeId!)}"]`,
+      );
+      el?.scrollIntoView({ block: 'center', behavior: 'smooth' });
+    });
+  }, [selection.selectedNodeId, expanded]);
+
+  const allRows = useMemo(
+    () => flattenTree(file.layoutTree, expanded, null, mode),
+    [file.layoutTree, expanded, mode],
+  );
+
+  const visibleRows = useMemo(
+    () => filterTreeBySearch(allRows, searchQuery, file.layoutTree),
+    [allRows, searchQuery, file.layoutTree],
+  );
+
+  // Compute the set of ancestor node IDs for the hovered node (for dim highlighting in tree)
+  const hoveredAncestorIds = useMemo(() => {
+    if (!selection.hoveredNodeId) return new Set<string>();
+    const path = findPathToNode(file.layoutTree, selection.hoveredNodeId);
+    // Exclude the hovered node itself — it gets full highlight
+    const ids = new Set(path.map((n) => n.id));
+    ids.delete(selection.hoveredNodeId);
+    return ids;
+  }, [selection.hoveredNodeId, file.layoutTree]);
+
+  // When a flat layout node is expanded, lazily attach array encoding children.
+  // Track which nodes we've already requested to avoid re-triggering on tree updates.
+  const expandedArrayRequests = useRef(new Set<string>());
+  useEffect(() => {
+    for (const id of expanded) {
+      if (expandedArrayRequests.current.has(id)) continue;
+      const node = findNodeById(file.layoutTree, id);
+      if (node && isFlatLayout(node) && !node.children.some((c) => c.isArrayNode)) {
+        expandedArrayRequests.current.add(id);
+        file.expandArrayTree(id);
+      }
+    }
+  }, [expanded, file]);
+
+  const toggleExpanded = useCallback((id: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+
+  const handleNodeClick = useCallback(
+    (nodeId: string) => {
+      selectNode(selection.selectedNodeId === nodeId ? null : nodeId);
+    },
+    [selection.selectedNodeId, selectNode],
+  );
+
+  return (
+    <div className="flex flex-col h-full border-r border-vortex-grey-light/60 dark:border-white/[0.08]">
+      {/* Header: mode toggle + search */}
+      <div className="flex items-center gap-2 px-2 py-1.5 flex-shrink-0 border-b border-vortex-grey-light/40 dark:border-white/[0.06]">
+        <ModeToggle mode={mode} onChange={setMode} />
+        <div className="flex-1">
+          <TreeSearch onSearch={setSearchQuery} />
+        </div>
+      </div>
+
+      {/* Tree rows */}
+      <div ref={scrollContainerRef} className="flex-1 overflow-y-auto overflow-x-hidden">
+        {visibleRows.map((row) => (
+          <TreeRow
+            key={row.node.id}
+            row={row}
+            isExpanded={expanded.has(row.node.id)}
+            isSelected={selection.selectedNodeId === row.node.id}
+            isHovered={selection.hoveredNodeId === row.node.id}
+            isHoveredAncestor={hoveredAncestorIds.has(row.node.id)}
+            mode={mode}
+            onToggle={() => toggleExpanded(row.node.id)}
+            onSelect={() => handleNodeClick(row.node.id)}
+            onHover={hoverNode}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+/** Subtle segmented toggle for Schema / Layout mode */
+function ModeToggle({ mode, onChange }: { mode: TreeMode; onChange: (m: TreeMode) => void }) {
+  return (
+    <div className="flex rounded-md bg-vortex-grey-lightest dark:bg-white/[0.06] p-0.5 flex-shrink-0">
+      {(['schema', 'layout'] as const).map((m) => (
+        <button
+          key={m}
+          className={`px-2 py-0.5 text-[10px] rounded-[3px] transition-colors ${
+            mode === m
+              ? 'bg-white dark:bg-white/[0.1] text-vortex-fg-light dark:text-vortex-fg shadow-sm'
+              : 'text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg'
+          }`}
+          onClick={() => onChange(m)}
+        >
+          {m === 'schema' ? 'Schema' : 'Layout'}
+        </button>
+      ))}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/AxisBar.tsx b/vortex-web/src/components/swimlane/AxisBar.tsx
new file mode 100644
index 00000000000..27ad96081ff
--- /dev/null
+++ b/vortex-web/src/components/swimlane/AxisBar.tsx
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useMemo } from 'react';
+import { formatRowCount } from './utils';
+
+interface AxisBarProps {
+  totalRows: number;
+  swimlaneMinWidth: number;
+  rulerPosition: { x: number; row: number } | null;
+  scrollLeft: number;
+  containerWidth: number;
+  axisRef: React.RefObject<HTMLDivElement | null>;
+}
+
+export function AxisBar({
+  totalRows,
+  swimlaneMinWidth,
+  rulerPosition,
+  scrollLeft,
+  containerWidth,
+  axisRef,
+}: AxisBarProps) {
+  const axisTicks = useMemo(() => {
+    const ticks = [];
+    const step = totalRows / 5;
+    for (let i = 0; i <= 5; i++) {
+      ticks.push(Math.round(i * step));
+    }
+    return ticks;
+  }, [totalRows]);
+
+  return (
+    <div className="flex-1 overflow-hidden relative">
+      <div ref={axisRef} className="relative h-[26px]" style={{ minWidth: swimlaneMinWidth }}>
+        {axisTicks.map((tick) => (
+          <div
+            key={tick}
+            className="absolute text-[9px] text-vortex-grey-dark top-1.5"
+            style={{
+              left: `${(tick / totalRows) * 100}%`,
+              transform: 'translateX(-50%)',
+            }}
+          >
+            {formatRowCount(tick)}
+          </div>
+        ))}
+      </div>
+
+      {rulerPosition && (
+        <div
+          className="absolute top-1 bg-vortex-black dark:bg-vortex-white text-vortex-white dark:text-vortex-black px-1.5 py-0.5 rounded text-[10px] font-medium pointer-events-none z-[100] whitespace-nowrap"
+          style={{
+            left: Math.max(0, Math.min(rulerPosition.x - scrollLeft - 20, containerWidth - 50)),
+          }}
+        >
+          {formatRowCount(rulerPosition.row)}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/DtypeLegend.tsx b/vortex-web/src/components/swimlane/DtypeLegend.tsx
new file mode 100644
index 00000000000..11ca38292b9
--- /dev/null
+++ b/vortex-web/src/components/swimlane/DtypeLegend.tsx
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { DTYPE_CATEGORIES, DTYPE_COLORS } from './styles';
+
+export function DtypeLegend() {
+  return (
+    <div className="flex gap-3.5 px-3 py-2 border-t border-vortex-grey-light/40 dark:border-white/[0.06] bg-vortex-white dark:bg-vortex-black text-[11px] text-vortex-grey-dark">
+      {DTYPE_CATEGORIES.map((cat) => (
+        <div key={cat} className="flex items-center gap-1">
+          <div className="w-2.5 h-2.5 rounded" style={{ backgroundColor: DTYPE_COLORS[cat] }} />
+          {cat}
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/LayoutSwimlane.stories.tsx b/vortex-web/src/components/swimlane/LayoutSwimlane.stories.tsx
new file mode 100644
index 00000000000..deacacab73d
--- /dev/null
+++ b/vortex-web/src/components/swimlane/LayoutSwimlane.stories.tsx
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState } from 'react';
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { LayoutSwimlane } from './LayoutSwimlane';
+import { ordersMock, simpleMock, wideMock, deepMock, heavyChunksMock } from '../../mocks';
+
+const meta: Meta<typeof LayoutSwimlane> = {
+  component: LayoutSwimlane,
+  parameters: {
+    layout: 'fullscreen',
+  },
+  decorators: [
+    (Story) => (
+      <div className="p-4 max-w-6xl mx-auto" style={{ height: 500 }}>
+        <Story />
+      </div>
+    ),
+  ],
+};
+export default meta;
+
+type Story = StoryObj<typeof LayoutSwimlane>;
+
+const ordersLayout = ordersMock();
+
+export const Orders: Story = {
+  args: {
+    layout: ordersLayout,
+    totalRows: 100000,
+    defaultExpanded: ['root', 'root.customer', 'root.customer.id', 'root.status'],
+    height: 400,
+  },
+};
+
+export const SchemaMode: Story = {
+  args: {
+    layout: ordersLayout,
+    totalRows: 100000,
+    mode: 'schema',
+    defaultExpanded: ['root', 'root.customer'],
+    height: 400,
+  },
+};
+
+export const LayoutMode: Story = {
+  args: {
+    layout: ordersLayout,
+    totalRows: 100000,
+    mode: 'layout',
+    defaultExpanded: ['root', 'root.customer', 'root.customer.id', 'root.status'],
+    height: 400,
+  },
+};
+
+export const SingleFlat: Story = {
+  args: {
+    layout: simpleMock(),
+    totalRows: 10000,
+    height: 100,
+  },
+};
+
+export const WideSchema: Story = {
+  args: {
+    layout: wideMock(),
+    totalRows: 50000,
+    mode: 'schema',
+    defaultExpanded: ['root'],
+    height: 400,
+  },
+};
+
+export const DeepNesting: Story = {
+  args: {
+    layout: deepMock(),
+    totalRows: 25000,
+    mode: 'schema',
+    defaultExpanded: ['root', 'root.user', 'root.user.profile', 'root.user.profile.address'],
+    height: 400,
+  },
+};
+
+export const HeavyChunks: Story = {
+  args: {
+    layout: heavyChunksMock(),
+    totalRows: 1000000,
+    mode: 'layout',
+    defaultExpanded: ['root', 'root.values'],
+    height: 400,
+  },
+};
+
+/** Interactive story demonstrating controlled selection */
+export const WithSelection: StoryObj = {
+  render: () => {
+    const [selectedId, setSelectedId] = useState<string | null>(null);
+    return (
+      <div>
+        <div className="text-xs text-vortex-grey-dark mb-2">Selected: {selectedId ?? 'none'}</div>
+        <LayoutSwimlane
+          layout={ordersLayout}
+          totalRows={100000}
+          defaultExpanded={['root', 'root.customer']}
+          selectedNodeId={selectedId}
+          onNodeSelect={setSelectedId}
+          height={350}
+        />
+      </div>
+    );
+  },
+};
diff --git a/vortex-web/src/components/swimlane/LayoutSwimlane.tsx b/vortex-web/src/components/swimlane/LayoutSwimlane.tsx
new file mode 100644
index 00000000000..65d095e9a53
--- /dev/null
+++ b/vortex-web/src/components/swimlane/LayoutSwimlane.tsx
@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState, useRef, useCallback, useMemo, useEffect } from 'react';
+import type { LayoutTreeNode, FlattenedRow } from './types';
+import { flattenTree, filterTreeBySearch } from './utils';
+import { ROW_HEIGHT, TREE_WIDTH, DEFAULT_SWIMLANE_MIN_WIDTH } from './styles';
+import { TreeRow } from './TreeRow';
+import { TreeSearch } from './TreeSearch';
+import { SwimlaneBar } from './SwimlaneBar';
+import { AxisBar } from './AxisBar';
+import { Tooltip } from './Tooltip';
+
+export interface LayoutSwimlaneProps {
+  /** The root layout tree node to visualize */
+  layout: LayoutTreeNode;
+  /** Total number of rows in the dataset */
+  totalRows: number;
+  /** Initially expanded node IDs */
+  defaultExpanded?: string[];
+  /** Currently selected node ID (controlled) */
+  selectedNodeId?: string | null;
+  /** Callback when a tree/bar node is clicked */
+  onNodeSelect?: (nodeId: string | null) => void;
+  /** Display mode: 'schema' shows logical columns, 'layout' shows full layout tree */
+  mode?: 'schema' | 'layout';
+  /** Minimum width of the swimlane panel */
+  swimlaneMinWidth?: number;
+  /** Height of the scrollable area */
+  height?: number;
+}
+
+export function LayoutSwimlane({
+  layout,
+  totalRows,
+  defaultExpanded = [],
+  selectedNodeId = null,
+  onNodeSelect,
+  mode = 'schema',
+  swimlaneMinWidth = DEFAULT_SWIMLANE_MIN_WIDTH,
+  height,
+}: LayoutSwimlaneProps) {
+  const [expanded, setExpanded] = useState<Set<string>>(() => new Set(defaultExpanded));
+  const [searchQuery, setSearchQuery] = useState('');
+  const [tooltip, setTooltip] = useState<{
+    node: LayoutTreeNode;
+    position: { x: number; y: number };
+  } | null>(null);
+  const [rulerPosition, setRulerPosition] = useState<{ x: number; row: number } | null>(null);
+
+  const treeScrollRef = useRef<HTMLDivElement>(null);
+  const swimlaneScrollRef = useRef<HTMLDivElement>(null);
+  const swimlanePanelRef = useRef<HTMLDivElement>(null);
+  const axisRef = useRef<HTMLDivElement>(null);
+
+  // Flatten the tree
+  const allRows = useMemo(
+    () => flattenTree(layout, expanded, null, mode),
+    [layout, expanded, mode],
+  );
+
+  const visibleRows = useMemo(
+    () => filterTreeBySearch(allRows, searchQuery, layout),
+    [allRows, searchQuery, layout],
+  );
+
+  const toggleExpanded = useCallback((id: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+
+  const handleNodeClick = useCallback(
+    (nodeId: string) => {
+      onNodeSelect?.(selectedNodeId === nodeId ? null : nodeId);
+    },
+    [selectedNodeId, onNodeSelect],
+  );
+
+  const handleTooltip = useCallback(
+    (node: LayoutTreeNode | null, position: { x: number; y: number }) => {
+      setTooltip(node ? { node, position } : null);
+    },
+    [],
+  );
+
+  // Sync vertical scroll between tree and swimlane
+  useEffect(() => {
+    const tree = treeScrollRef.current;
+    const swimlane = swimlaneScrollRef.current;
+    if (!tree || !swimlane) return;
+
+    let syncing = false;
+    const syncScroll = (source: HTMLDivElement, target: HTMLDivElement) => () => {
+      if (syncing) return;
+      syncing = true;
+      target.scrollTop = source.scrollTop;
+      syncing = false;
+    };
+
+    const treeHandler = syncScroll(tree, swimlane);
+    const swimlaneHandler = syncScroll(swimlane, tree);
+    tree.addEventListener('scroll', treeHandler);
+    swimlane.addEventListener('scroll', swimlaneHandler);
+    return () => {
+      tree.removeEventListener('scroll', treeHandler);
+      swimlane.removeEventListener('scroll', swimlaneHandler);
+    };
+  }, []);
+
+  // Sync horizontal scroll between swimlane and axis
+  useEffect(() => {
+    const swimlane = swimlaneScrollRef.current;
+    const axis = axisRef.current;
+    if (!swimlane || !axis) return;
+
+    const handleScroll = () => {
+      axis.style.transform = `translateX(-${swimlane.scrollLeft}px)`;
+    };
+    swimlane.addEventListener('scroll', handleScroll);
+    return () => swimlane.removeEventListener('scroll', handleScroll);
+  }, []);
+
+  // Ruler mouse tracking
+  const handleSwimlaneMouseMove = useCallback(
+    (e: React.MouseEvent) => {
+      const panel = swimlanePanelRef.current;
+      if (!panel) return;
+      const rect = panel.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      const panelWidth = panel.offsetWidth;
+      if (x >= 0 && x <= panelWidth) {
+        const rowNum = (x / panelWidth) * totalRows;
+        setRulerPosition({ x, row: Math.max(0, Math.min(totalRows, rowNum)) });
+      }
+    },
+    [totalRows],
+  );
+
+  const handleSwimlaneMouseLeave = useCallback(() => setRulerPosition(null), []);
+
+  const contentHeight = visibleRows.length * ROW_HEIGHT;
+
+  return (
+    <div className="flex flex-col" style={height ? { height } : { flex: 1, minHeight: 0 }}>
+      {/* Tree + Swimlane */}
+      <div className="flex flex-1 min-h-0">
+        {/* Tree panel */}
+        <div className="flex-shrink-0 flex flex-col min-h-0" style={{ width: TREE_WIDTH }}>
+          <TreeSearch onSearch={setSearchQuery} />
+          <div ref={treeScrollRef} className="flex-1 overflow-y-auto overflow-x-hidden">
+            <div style={{ height: contentHeight }}>
+              {visibleRows.map((row) => (
+                <TreeRow
+                  key={row.node.id}
+                  row={row}
+                  isExpanded={expanded.has(row.node.id)}
+                  isSelected={selectedNodeId === row.node.id}
+                  mode={mode}
+                  onToggle={() => toggleExpanded(row.node.id)}
+                  onSelect={() => handleNodeClick(row.node.id)}
+                />
+              ))}
+            </div>
+          </div>
+        </div>
+
+        {/* Swimlane panel */}
+        <div
+          ref={swimlaneScrollRef}
+          className="flex-1 overflow-auto relative"
+          onMouseMove={handleSwimlaneMouseMove}
+          onMouseLeave={handleSwimlaneMouseLeave}
+        >
+          <div ref={swimlanePanelRef} style={{ minWidth: swimlaneMinWidth, height: contentHeight }}>
+            {visibleRows.map((row) => (
+              <SwimlaneRow
+                key={row.node.id}
+                row={row}
+                totalRows={totalRows}
+                onHover={handleTooltip}
+              />
+            ))}
+
+            {rulerPosition && (
+              <div
+                className="absolute top-0 bottom-0 w-px bg-vortex-black dark:bg-vortex-white opacity-40 pointer-events-none z-[100]"
+                style={{ left: rulerPosition.x }}
+              />
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* Axis */}
+      <div className="flex flex-shrink-0">
+        <div className="flex-shrink-0" style={{ width: TREE_WIDTH }} />
+        <AxisBar
+          totalRows={totalRows}
+          swimlaneMinWidth={swimlaneMinWidth}
+          rulerPosition={rulerPosition}
+          scrollLeft={swimlaneScrollRef.current?.scrollLeft ?? 0}
+          containerWidth={swimlaneScrollRef.current?.offsetWidth ?? 0}
+          axisRef={axisRef}
+        />
+      </div>
+
+      {tooltip && <Tooltip node={tooltip.node} position={tooltip.position} />}
+    </div>
+  );
+}
+
+/** A single swimlane row — just height + bar positioning, no decoration */
+function SwimlaneRow({
+  row,
+  totalRows,
+  onHover,
+}: {
+  row: FlattenedRow;
+  totalRows: number;
+  onHover: (node: LayoutTreeNode | null, position: { x: number; y: number }) => void;
+}) {
+  return (
+    <div className="relative" style={{ height: ROW_HEIGHT }}>
+      {row.displayKind !== 'hiddenIndicator' && (
+        <SwimlaneBar row={row} totalRows={totalRows} onHover={onHover} />
+      )}
+    </div>
+  );
+}
+
+export default LayoutSwimlane;
diff --git a/vortex-web/src/components/swimlane/SplitRegion.tsx b/vortex-web/src/components/swimlane/SplitRegion.tsx
new file mode 100644
index 00000000000..b882efb2506
--- /dev/null
+++ b/vortex-web/src/components/swimlane/SplitRegion.tsx
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import React, { useState } from 'react';
+import type { Split } from './types';
+import { MIN_LABEL_WIDTH } from './styles';
+
+interface SplitRegionProps {
+  split: Split;
+  totalRows: number;
+  swimlaneWidth: number;
+  isSelected: boolean;
+  onClick: (e: React.MouseEvent) => void;
+}
+
+export function SplitRegion({
+  split,
+  totalRows,
+  swimlaneWidth,
+  isSelected,
+  onClick,
+}: SplitRegionProps) {
+  const [isHovered, setIsHovered] = useState(false);
+
+  const left = (split.rowRange[0] / totalRows) * 100;
+  const width = ((split.rowRange[1] - split.rowRange[0]) / totalRows) * 100;
+  const widthPx = ((split.rowRange[1] - split.rowRange[0]) / totalRows) * swimlaneWidth;
+  const showLabel = widthPx >= MIN_LABEL_WIDTH || isSelected || isHovered;
+
+  return (
+    <div
+      className="absolute top-0 bottom-0 cursor-pointer border-r border-vortex-grey-light/40 dark:border-white/[0.06]"
+      style={{
+        left: `${left}%`,
+        width: `${width}%`,
+        backgroundColor: isSelected
+          ? 'rgba(44, 185, 209, 0.08)'
+          : isHovered
+            ? 'rgba(44, 185, 209, 0.03)'
+            : undefined,
+      }}
+      onClick={onClick}
+      onMouseEnter={() => setIsHovered(true)}
+      onMouseLeave={() => setIsHovered(false)}
+    >
+      <div
+        className="absolute top-1 left-1/2 -translate-x-1/2 text-[9px] px-1.5 py-0.5 rounded whitespace-nowrap transition-opacity duration-150 pointer-events-none"
+        style={{
+          color: isSelected ? 'rgba(44, 185, 209, 1)' : 'rgba(143, 143, 143, 1)',
+          backgroundColor: isSelected ? 'rgba(44, 185, 209, 0.15)' : 'rgba(241, 241, 241, 0.9)',
+          opacity: showLabel ? 1 : 0,
+          fontWeight: isSelected ? 500 : 400,
+        }}
+      >
+        {split.id}
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/SwimlaneBar.tsx b/vortex-web/src/components/swimlane/SwimlaneBar.tsx
new file mode 100644
index 00000000000..6c0beef5eb2
--- /dev/null
+++ b/vortex-web/src/components/swimlane/SwimlaneBar.tsx
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import React from 'react';
+import type { LayoutTreeNode, FlattenedRow } from './types';
+import { getDtypeCategory, getNodeRowRange } from './utils';
+import { DTYPE_COLORS, getEncodingStyle } from './styles';
+
+interface SwimlaneBarProps {
+  row: FlattenedRow;
+  totalRows: number;
+  onHover: (node: LayoutTreeNode | null, position: { x: number; y: number }) => void;
+}
+
+export function SwimlaneBar({ row, totalRows, onHover }: SwimlaneBarProps) {
+  const { node, displayKind, groupedChildren } = row;
+  const isLeaf = node.children.length === 0;
+  const isGroup = displayKind === 'group';
+  const style = getEncodingStyle(node.encoding);
+
+  // Group nodes: render rolled-up bars from each grouped child
+  if (isGroup && groupedChildren) {
+    return (
+      <>
+        {groupedChildren.map((child) => {
+          const range = getNodeRowRange(child);
+          const left = (range[0] / totalRows) * 100;
+          const width = ((range[1] - range[0]) / totalRows) * 100;
+          const dtypeCat = getDtypeCategory(child.dtype);
+          const dtypeColor = DTYPE_COLORS[dtypeCat];
+          return (
+            <div
+              key={child.id}
+              className="absolute top-[3px] bottom-[3px] rounded"
+              style={{
+                left: `calc(${left}% + 1px)`,
+                width: `calc(${width}% - 3px)`,
+                backgroundColor: `${dtypeColor}40`,
+                border: `1.5px solid ${dtypeColor}`,
+              }}
+            />
+          );
+        })}
+      </>
+    );
+  }
+
+  const rowRange = getNodeRowRange(node);
+  const left = (rowRange[0] / totalRows) * 100;
+  const width = ((rowRange[1] - rowRange[0]) / totalRows) * 100;
+
+  let barClasses = 'absolute top-[3px] bottom-[3px] rounded transition-[filter] duration-100';
+  const barStyle: React.CSSProperties = {
+    left: `calc(${left}% + 1px)`,
+    width: `calc(${width}% - 3px)`,
+  };
+
+  if (isLeaf) {
+    const dtypeCat = getDtypeCategory(node.dtype);
+    const dtypeColor = DTYPE_COLORS[dtypeCat];
+    barStyle.backgroundColor = `${dtypeColor}40`;
+    barStyle.border = `1.5px solid ${dtypeColor}`;
+    barClasses += ' cursor-pointer';
+  } else {
+    barStyle.border = `1.5px solid ${style.color}40`;
+  }
+
+  const handleMouseEnter = (e: React.MouseEvent) => {
+    if (isLeaf) {
+      (e.currentTarget as HTMLDivElement).style.filter = 'brightness(1.15)';
+      onHover(node, { x: e.clientX, y: e.clientY });
+    }
+  };
+
+  const handleMouseMove = (e: React.MouseEvent) => {
+    if (isLeaf) {
+      onHover(node, { x: e.clientX, y: e.clientY });
+    }
+  };
+
+  const handleMouseLeave = (e: React.MouseEvent) => {
+    if (isLeaf) {
+      (e.currentTarget as HTMLDivElement).style.filter = '';
+      onHover(null, { x: 0, y: 0 });
+    }
+  };
+
+  return (
+    <div
+      className={barClasses}
+      style={barStyle}
+      onMouseEnter={handleMouseEnter}
+      onMouseMove={handleMouseMove}
+      onMouseLeave={handleMouseLeave}
+    />
+  );
+}
diff --git a/vortex-web/src/components/swimlane/Tooltip.tsx b/vortex-web/src/components/swimlane/Tooltip.tsx
new file mode 100644
index 00000000000..45aa1c78600
--- /dev/null
+++ b/vortex-web/src/components/swimlane/Tooltip.tsx
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode } from './types';
+import {
+  getDtypeCategory,
+  formatBytes,
+  getNodeDisplayName,
+  getNodeRowRange,
+  shortEncoding,
+} from './utils';
+import { DTYPE_COLORS } from './styles';
+
+interface TooltipProps {
+  node: LayoutTreeNode;
+  position: { x: number; y: number };
+}
+
+export function Tooltip({ node, position }: TooltipProps) {
+  const rowRange = getNodeRowRange(node);
+  const rows = rowRange[1] - rowRange[0];
+  const dtypeCat = getDtypeCategory(node.dtype);
+  const dtypeColor = DTYPE_COLORS[dtypeCat];
+  const name = getNodeDisplayName(node);
+
+  return (
+    <div
+      className="fixed z-[1000] pointer-events-none max-w-[220px] rounded-lg border border-vortex-grey-light/60 dark:border-white/[0.1] bg-vortex-white dark:bg-[#252528] shadow-lg p-2 text-xs"
+      style={{ left: position.x + 12, top: position.y - 10 }}
+    >
+      <div className="flex items-center gap-1.5 mb-1">
+        <span className="font-medium text-vortex-fg-light dark:text-vortex-fg">{name}</span>
+        <span
+          className="text-[9px] px-1.5 py-0.5 rounded"
+          style={{ color: dtypeColor, backgroundColor: `${dtypeColor}20` }}
+        >
+          {dtypeCat}
+        </span>
+      </div>
+      <div className="grid grid-cols-2 gap-x-2 gap-y-0.5 text-vortex-grey-dark">
+        <span>rows</span>
+        <span className="text-vortex-fg-light dark:text-vortex-fg">{rows.toLocaleString()}</span>
+        {node.dtype && (
+          <>
+            <span>dtype</span>
+            <span className="text-vortex-fg-light dark:text-vortex-fg">{node.dtype}</span>
+          </>
+        )}
+        {node.encoding && (
+          <>
+            <span>encoding</span>
+            <span className="text-vortex-fg-light dark:text-vortex-fg" title={node.encoding}>
+              {shortEncoding(node.encoding)}
+            </span>
+          </>
+        )}
+        {node.metadataBytes > 0 && (
+          <>
+            <span>metadata</span>
+            <span className="text-vortex-fg-light dark:text-vortex-fg">
+              {formatBytes(node.metadataBytes)}
+            </span>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/TreeRow.tsx b/vortex-web/src/components/swimlane/TreeRow.tsx
new file mode 100644
index 00000000000..37f5d845c7f
--- /dev/null
+++ b/vortex-web/src/components/swimlane/TreeRow.tsx
@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { FlattenedRow } from './types';
+import {
+  ROW_HEIGHT,
+  DTYPE_COLORS,
+  getEncodingStyle,
+  getNodeDisplayName,
+  hasExpandableChildren,
+  formatRowRange,
+  getDtypeCategory,
+  shortEncoding,
+} from './utils';
+
+interface TreeRowProps {
+  row: FlattenedRow;
+  isExpanded: boolean;
+  isSelected: boolean;
+  isHovered?: boolean;
+  isHoveredAncestor?: boolean;
+  mode: 'schema' | 'layout';
+  onToggle: () => void;
+  onSelect: () => void;
+  onHover?: (nodeId: string | null) => void;
+}
+
+export function TreeRow({
+  row,
+  isExpanded,
+  isSelected,
+  isHovered,
+  isHoveredAncestor,
+  mode,
+  onToggle,
+  onSelect,
+  onHover,
+}: TreeRowProps) {
+  const { node, depth, displayKind } = row;
+
+  if (displayKind === 'hiddenIndicator') {
+    const name = node.childType.kind === 'transparent' ? node.childType.name : 'hidden';
+    return (
+      <div
+        className="flex items-center text-[10px] text-vortex-grey-dark italic"
+        style={{ height: ROW_HEIGHT, paddingLeft: 6 + depth * 10 }}
+      >
+        <span className="ml-3">{name}</span>
+      </div>
+    );
+  }
+
+  const isGroup = displayKind === 'group';
+  const expandable = hasExpandableChildren(node);
+  const isLeaf = !expandable;
+  const style = getEncodingStyle(node.encoding);
+  const name = getNodeDisplayName(node);
+
+  let badgeText: string;
+  let badgeColor: string;
+  if (isGroup) {
+    badgeText = '···';
+    badgeColor = style.color;
+  } else if (mode === 'schema') {
+    const dtypeCat = getDtypeCategory(node.dtype);
+    const dtypeStr = shortEncoding(node.dtype);
+    badgeText =
+      dtypeCat === 'struct'
+        ? 'struct'
+        : dtypeStr.length > 20
+          ? dtypeStr.slice(0, 18) + '…'
+          : dtypeStr;
+    badgeColor = DTYPE_COLORS[dtypeCat];
+  } else {
+    const ct = node.childType;
+    if (ct.kind === 'chunk') {
+      badgeText = formatRowRange(row.rowRange);
+    } else {
+      badgeText = style.label;
+      if (node.children.length > 0 && node.childType.kind !== 'field') {
+        badgeText += ` (${node.children.length})`;
+      }
+    }
+    badgeColor = style.color;
+  }
+
+  const opacity = isGroup ? 'opacity-50' : isLeaf ? 'opacity-70' : '';
+  const fontStyle = isGroup ? 'italic' : '';
+  const highlightBg = isSelected
+    ? 'bg-vortex-light-blue/10'
+    : isHovered
+      ? 'bg-vortex-light-blue/15'
+      : isHoveredAncestor
+        ? 'bg-vortex-light-blue/5'
+        : '';
+
+  return (
+    <div
+      data-node-id={node.id}
+      className={`flex items-center gap-1.5 text-[11px] whitespace-nowrap hover:bg-vortex-black/[0.03] dark:hover:bg-white/[0.04] cursor-default ${opacity} ${fontStyle} ${highlightBg}`}
+      title={node.isArrayNode ? 'Array encoding node' : undefined}
+      style={{
+        height: ROW_HEIGHT,
+        paddingLeft: 6 + depth * 10,
+        paddingRight: 8,
+        backgroundColor: node.isArrayNode ? 'var(--array-node-bg)' : undefined,
+      }}
+      onClick={onSelect}
+      onMouseEnter={() => onHover?.(node.id)}
+      onMouseLeave={() => onHover?.(null)}
+    >
+      <span
+        className={`text-[8px] w-3 text-vortex-grey-dark ${expandable ? 'cursor-pointer' : ''}`}
+        style={{ opacity: expandable ? 1 : 0 }}
+        onClick={(e) => {
+          e.stopPropagation();
+          if (expandable) onToggle();
+        }}
+      >
+        {isExpanded ? '▼' : '▶'}
+      </span>
+      <span className="flex-1 overflow-hidden text-ellipsis text-vortex-fg-light dark:text-vortex-fg">
+        {name}
+      </span>
+      <span
+        className="text-[9px] px-1.5 py-0.5 rounded max-w-[120px] truncate"
+        style={{ color: badgeColor, backgroundColor: `${badgeColor}15` }}
+      >
+        {badgeText}
+      </span>
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/TreeSearch.tsx b/vortex-web/src/components/swimlane/TreeSearch.tsx
new file mode 100644
index 00000000000..b02613db054
--- /dev/null
+++ b/vortex-web/src/components/swimlane/TreeSearch.tsx
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { useState, useCallback } from 'react';
+
+interface TreeSearchProps {
+  onSearch: (query: string) => void;
+}
+
+export function TreeSearch({ onSearch }: TreeSearchProps) {
+  const [value, setValue] = useState('');
+
+  const handleChange = useCallback(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      const q = e.target.value;
+      setValue(q);
+      onSearch(q);
+    },
+    [onSearch],
+  );
+
+  const handleClear = useCallback(() => {
+    setValue('');
+    onSearch('');
+  }, [onSearch]);
+
+  return (
+    <div className="flex items-center gap-1">
+      <span className="text-[10px] text-vortex-grey-dark">&#x2315;</span>
+      <input
+        type="text"
+        value={value}
+        onChange={handleChange}
+        placeholder="Filter…"
+        className="flex-1 min-w-0 bg-transparent text-[11px] text-vortex-fg-light dark:text-vortex-fg outline-none placeholder:text-vortex-grey-dark/50"
+      />
+      {value && (
+        <button
+          onClick={handleClear}
+          className="text-[10px] text-vortex-grey-dark hover:text-vortex-fg-light dark:hover:text-vortex-fg"
+        >
+          &#x2715;
+        </button>
+      )}
+    </div>
+  );
+}
diff --git a/vortex-web/src/components/swimlane/index.ts b/vortex-web/src/components/swimlane/index.ts
new file mode 100644
index 00000000000..893b6ce2f66
--- /dev/null
+++ b/vortex-web/src/components/swimlane/index.ts
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+// Main component
+export { LayoutSwimlane, default } from './LayoutSwimlane';
+export type { LayoutSwimlaneProps } from './LayoutSwimlane';
+
+// Types
+export type {
+  LayoutTreeNode,
+  LayoutChildKind,
+  SegmentMapEntry,
+  FileStructureInfo,
+  FlattenedRow,
+  DisplayKind,
+  Split,
+  DtypeCategory,
+} from './types';
+
+// Sub-components
+export { TreeRow } from './TreeRow';
+export { TreeSearch } from './TreeSearch';
+export { SwimlaneBar } from './SwimlaneBar';
+export { AxisBar } from './AxisBar';
+export { Tooltip } from './Tooltip';
+export { DtypeLegend } from './DtypeLegend';
+export { SplitRegion } from './SplitRegion';
+
+// Utilities
+export {
+  getDtypeCategory,
+  rangesOverlap,
+  createSplits,
+  formatBytes,
+  formatRowRange,
+  formatRowCount,
+  getNodeDisplayName,
+  getNodeRowRange,
+  getEncodingStyle,
+  hasExpandableChildren,
+  flattenTree,
+  filterTreeBySearch,
+  findNodeById,
+  findPathToNode,
+  collectSubtreeIds,
+  collectSubtreeSegments,
+  ENCODING_STYLES,
+  DTYPE_COLORS,
+  DTYPE_CATEGORIES,
+} from './utils';
diff --git a/vortex-web/src/components/swimlane/styles.ts b/vortex-web/src/components/swimlane/styles.ts
new file mode 100644
index 00000000000..0c82f2cbbf1
--- /dev/null
+++ b/vortex-web/src/components/swimlane/styles.ts
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+// Re-export constants from utils for backward compat, plus any rendering-only constants.
+export {
+  ENCODING_STYLES,
+  getEncodingStyle,
+  DTYPE_COLORS,
+  DTYPE_CATEGORIES,
+  ROW_HEIGHT,
+  MIN_LABEL_WIDTH,
+  GROUP_SIZE,
+} from './utils';
+
+export const TREE_WIDTH = 260;
+export const DEFAULT_SWIMLANE_MIN_WIDTH = 800;
+export const DEFAULT_HEIGHT = 360;
diff --git a/vortex-web/src/components/swimlane/types.ts b/vortex-web/src/components/swimlane/types.ts
new file mode 100644
index 00000000000..50919ad6aea
--- /dev/null
+++ b/vortex-web/src/components/swimlane/types.ts
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+// Unified layout tree type mirroring the Rust Layout trait.
+// Each node represents a layout in the Vortex file format.
+
+export interface LayoutTreeNode {
+  /** Path-based ID, e.g. "root.customer.id.[0]" */
+  id: string;
+  /** Encoding name, e.g. "vortex.flat", "vortex.chunked" */
+  encoding: string;
+  /** DType string, e.g. "i64", "utf8", "{name=utf8, age=i32}" */
+  dtype: string;
+  /** Number of rows in this layout */
+  rowCount: number;
+  /** Absolute row offset in the file */
+  rowOffset: number;
+  /** Size of metadata for this layout in bytes */
+  metadataBytes: number;
+  /** Segment IDs referenced by this layout */
+  segmentIds: number[];
+  /** Relationship of this node to its parent */
+  childType: LayoutChildKind;
+  /** Child layout nodes */
+  children: LayoutTreeNode[];
+  /** For flat layouts: the array encoding tree inside this layout */
+  arrayEncodingTree?: ArrayEncodingNode;
+  /** True if this node represents an array encoding node (not a layout node) */
+  isArrayNode?: boolean;
+  /** Buffer byte lengths for array nodes */
+  bufferLengths?: number[];
+  /** Buffer names for array nodes */
+  bufferNames?: string[];
+}
+
+export interface ArrayEncodingNode {
+  encoding: string;
+  dtype: string;
+  metadataBytes: number;
+  numBuffers: number;
+  bufferLengths: number[];
+  bufferNames: string[];
+  children: ArrayEncodingNode[];
+  childNames: string[];
+}
+
+export type LayoutChildKind =
+  | { kind: 'root' }
+  | { kind: 'field'; fieldName: string }
+  | { kind: 'chunk'; chunkIndex: number; rowOffset: number }
+  | { kind: 'transparent'; name: string }
+  | { kind: 'auxiliary'; name: string };
+
+export interface SegmentMapEntry {
+  index: number;
+  byteOffset: number;
+  byteLength: number;
+  alignment: number;
+  column: string | null;
+  /** Node ID path in the layout tree */
+  layoutPath: string;
+}
+
+export interface FileStructureInfo {
+  fileSize: number;
+  version: number;
+  postscriptSize: number;
+  totalDataBytes: number;
+  totalMetadataBytes: number;
+}
+
+// Rendering types (internal to swimlane)
+
+export type DisplayKind = 'normal' | 'group' | 'hiddenIndicator';
+
+export interface FlattenedRow {
+  node: LayoutTreeNode;
+  depth: number;
+  displayKind: DisplayKind;
+  groupedChildren?: LayoutTreeNode[];
+  rowRange: [number, number];
+}
+
+// Retained from original types
+export type DtypeCategory =
+  | 'bool'
+  | 'int'
+  | 'float'
+  | 'utf8'
+  | 'datetime'
+  | 'struct'
+  | 'list'
+  | 'other';
+
+export interface Split {
+  id: string;
+  rowRange: [number, number];
+}
diff --git a/vortex-web/src/components/swimlane/utils.ts b/vortex-web/src/components/swimlane/utils.ts
new file mode 100644
index 00000000000..605ebbfd30d
--- /dev/null
+++ b/vortex-web/src/components/swimlane/utils.ts
@@ -0,0 +1,584 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type {
+  LayoutTreeNode,
+  ArrayEncodingNode,
+  Split,
+  DtypeCategory,
+  FlattenedRow,
+  DisplayKind,
+} from './types';
+
+// Encoding styles — keyed by encoding string, with fallback for unknown encodings
+export const ENCODING_STYLES: Record<string, { color: string; label: string }> = {
+  'vortex.struct': { color: '#5971FD', label: 'struct' },
+  'vortex.chunked': { color: '#CEE562', label: 'chunked' },
+  'vortex.flat': { color: '#2CB9D1', label: 'flat' },
+  'vortex.dict': { color: '#EEB3E1', label: 'dict' },
+  'vortex.zonemap': { color: '#FB863D', label: 'zonemap' },
+  'vortex.fsst': { color: '#EEB3E1', label: 'fsst' },
+  'vortex.roaring_bool': { color: '#EEB3E1', label: 'roaring' },
+  'vortex.roaring_int': { color: '#2CB9D1', label: 'roaring' },
+  'vortex.alp': { color: '#FB863D', label: 'alp' },
+  'vortex.alp_rd': { color: '#FB863D', label: 'alp-rd' },
+  'vortex.for': { color: '#CEE562', label: 'for' },
+  'vortex.bitpacked': { color: '#CEE562', label: 'bitpacked' },
+  'vortex.runend': { color: '#CEE562', label: 'run-end' },
+  'vortex.runend_bool': { color: '#CEE562', label: 'run-end' },
+  'vortex.zigzag': { color: '#2CB9D1', label: 'zigzag' },
+  'vortex.constant': { color: '#8F8F8F', label: 'const' },
+  'vortex.sparse': { color: '#8F8F8F', label: 'sparse' },
+};
+
+const DEFAULT_ENCODING_STYLE = { color: '#8F8F8F', label: 'unknown' };
+
+export function getEncodingStyle(encoding: string): { color: string; label: string } {
+  return (
+    ENCODING_STYLES[encoding] ?? {
+      ...DEFAULT_ENCODING_STYLE,
+      label: encoding.split('.').pop() ?? encoding,
+    }
+  );
+}
+
+// Dtype colors (for flat chunk bars in swimlane)
+export const DTYPE_COLORS: Record<DtypeCategory, string> = {
+  bool: '#D97BC6',
+  int: '#2CB9D1',
+  float: '#FB863D',
+  utf8: '#5971FD',
+  datetime: '#8BB536',
+  list: '#A78BFA',
+  struct: '#999999',
+  other: '#777777',
+};
+
+export const DTYPE_CATEGORIES: DtypeCategory[] = [
+  'bool',
+  'int',
+  'float',
+  'utf8',
+  'datetime',
+  'list',
+  'struct',
+  'other',
+];
+
+export const ROW_HEIGHT = 26;
+export const MIN_LABEL_WIDTH = 36;
+export const GROUP_SIZE = 10;
+
+/**
+ * Determine dtype category from dtype string
+ */
+export function getDtypeCategory(dtype?: string): DtypeCategory {
+  if (!dtype) return 'other';
+  const d = dtype.toLowerCase();
+  if (d === 'bool' || d === 'boolean') return 'bool';
+  // Struct/list checks first — composite dtypes contain field names that would false-match others.
+  if (d.startsWith('{') || d === 'struct') return 'struct';
+  if (d.includes('list') || d.includes('array')) return 'list';
+  if (d.includes('utf8') || d.includes('string') || d.includes('binary')) return 'utf8';
+  if (d.includes('timestamp') || d.includes('date') || d.includes('time')) return 'datetime';
+  if (d.includes('int') || d.includes('uint') || d.startsWith('i') || d.startsWith('u'))
+    return 'int';
+  if (d.includes('float') || d.includes('double') || d.includes('decimal') || d.startsWith('f'))
+    return 'float';
+  return 'other';
+}
+
+/**
+ * Check if two ranges overlap
+ */
+export function rangesOverlap(a: [number, number], b: [number, number]): boolean {
+  return a[0] < b[1] && b[0] < a[1];
+}
+
+/**
+ * Collect all row boundaries from a LayoutTreeNode tree
+ */
+export function collectBoundaries(node: LayoutTreeNode, set: Set<number> = new Set()): Set<number> {
+  set.add(node.rowOffset);
+  set.add(node.rowOffset + node.rowCount);
+
+  for (const child of node.children) {
+    collectBoundaries(child, set);
+  }
+
+  return set;
+}
+
+/**
+ * Create splits from layout boundaries
+ */
+export function createSplits(layout: LayoutTreeNode): Split[] {
+  const boundaries = Array.from(collectBoundaries(layout)).sort((a, b) => a - b);
+  return boundaries.slice(0, -1).map((start, i) => ({
+    id: `s${i}`,
+    rowRange: [start, boundaries[i + 1]] as [number, number],
+  }));
+}
+
+/**
+ * Get the combined row range of selected splits
+ */
+export function getSelectedRowRange(
+  splits: Split[],
+  selectedSplits: Set<string>,
+): [number, number] | null {
+  if (selectedSplits.size === 0) return null;
+  const selected = splits.filter((s) => selectedSplits.has(s.id));
+  const min = Math.min(...selected.map((s) => s.rowRange[0]));
+  const max = Math.max(...selected.map((s) => s.rowRange[1]));
+  return [min, max];
+}
+
+/**
+ * Get the display name for a layout tree node based on its child type
+ */
+export function getNodeDisplayName(node: LayoutTreeNode): string {
+  const ct = node.childType;
+  switch (ct.kind) {
+    case 'root':
+      return 'root';
+    case 'field':
+      return ct.fieldName;
+    case 'chunk':
+      return `[${ct.chunkIndex}]`;
+    case 'transparent':
+      return ct.name;
+    case 'auxiliary':
+      return ct.name;
+  }
+}
+
+/**
+ * Get a badge label for schema mode
+ */
+export function getSchemaLabel(node: LayoutTreeNode): string {
+  return node.dtype;
+}
+
+/**
+ * Get a badge label for layout mode
+ */
+export function getLayoutLabel(node: LayoutTreeNode): string {
+  const ct = node.childType;
+  switch (ct.kind) {
+    case 'root':
+      return getEncodingStyle(node.encoding).label;
+    case 'field':
+      return `[field] ${getEncodingStyle(node.encoding).label}`;
+    case 'chunk':
+      return `[chunk ${ct.chunkIndex}]`;
+    case 'transparent':
+      return `[transparent: ${ct.name}]`;
+    case 'auxiliary':
+      return `[aux: ${ct.name}]`;
+  }
+}
+
+/**
+ * Check if a node has expandable children
+ */
+export function hasExpandableChildren(node: LayoutTreeNode): boolean {
+  return node.children.length > 0;
+}
+
+/**
+ * Get the row range tuple for a node
+ */
+export function getNodeRowRange(node: LayoutTreeNode): [number, number] {
+  return [node.rowOffset, node.rowOffset + node.rowCount];
+}
+
+/**
+ * Check if a node is a "field" child — used in schema mode to identify logical columns
+ */
+function isFieldChild(node: LayoutTreeNode): boolean {
+  return node.childType.kind === 'field';
+}
+
+/**
+ * In schema mode, find the field-level children, skipping intermediate layout nodes.
+ * Returns the node itself if it has field children, or walks through transparent/chunk/aux
+ * nodes to find them.
+ */
+function collectSchemaChildren(node: LayoutTreeNode): LayoutTreeNode[] {
+  const fieldChildren = node.children.filter(isFieldChild);
+  if (fieldChildren.length > 0) return fieldChildren;
+  // No field children — this is a leaf or layout-only node
+  return [];
+}
+
+/**
+ * Group children into groups of GROUP_SIZE when there are too many.
+ * Returns null if grouping is not needed.
+ */
+export function groupChildren(
+  children: LayoutTreeNode[],
+  parentId: string,
+): { groups: LayoutTreeNode[]; isGrouped: true } | null {
+  if (children.length <= GROUP_SIZE) return null;
+
+  const groups: LayoutTreeNode[] = [];
+  for (let i = 0; i < children.length; i += GROUP_SIZE) {
+    const groupNodes = children.slice(i, Math.min(i + GROUP_SIZE, children.length));
+    const startIdx = i;
+    const endIdx = Math.min(i + GROUP_SIZE - 1, children.length - 1);
+    const firstNode = groupNodes[0];
+    const lastNode = groupNodes[groupNodes.length - 1];
+
+    groups.push({
+      id: `${parentId}_group_${startIdx}_${endIdx}`,
+      encoding: 'group',
+      dtype: '',
+      rowCount: lastNode.rowOffset + lastNode.rowCount - firstNode.rowOffset,
+      rowOffset: firstNode.rowOffset,
+      metadataBytes: 0,
+      segmentIds: [],
+      childType: { kind: 'transparent', name: `chunks ${startIdx}–${endIdx}` },
+      children: groupNodes,
+    });
+  }
+  return { groups, isGrouped: true };
+}
+
+/**
+ * Flatten a layout tree into rows for rendering.
+ *
+ * @param root - The root layout tree node
+ * @param expanded - Set of expanded node IDs
+ * @param selectedRange - Optional selected row range for filtering
+ * @param mode - 'schema' shows logical column hierarchy, 'layout' shows full layout tree
+ */
+export function flattenTree(
+  root: LayoutTreeNode,
+  expanded: Set<string>,
+  selectedRange: [number, number] | null,
+  mode: 'schema' | 'layout',
+): FlattenedRow[] {
+  const result: FlattenedRow[] = [];
+
+  function walk(node: LayoutTreeNode, depth: number) {
+    const rowRange = getNodeRowRange(node);
+    result.push({ node, depth, displayKind: 'normal', rowRange });
+
+    if (!expanded.has(node.id)) return;
+
+    let childrenToShow: LayoutTreeNode[];
+
+    if (mode === 'schema') {
+      // In schema mode, show field children at the top level.
+      // If a field child has no field sub-children, show its layout children when expanded.
+      const schemaChildren = collectSchemaChildren(node);
+      childrenToShow = schemaChildren.length > 0 ? schemaChildren : node.children;
+    } else {
+      childrenToShow = node.children;
+    }
+
+    // Apply chunk grouping if there are many children of the same type
+    const chunkChildren = childrenToShow.filter((c) => c.childType.kind === 'chunk');
+    const nonChunkChildren = childrenToShow.filter((c) => c.childType.kind !== 'chunk');
+
+    // Show non-chunk children first
+    for (const child of nonChunkChildren) {
+      walk(child, depth + 1);
+    }
+
+    // Group chunk children if needed
+    if (chunkChildren.length > 0) {
+      const groupResult = groupChildren(chunkChildren, node.id);
+
+      if (groupResult) {
+        const visibleGroups = selectedRange
+          ? groupResult.groups.filter((g) => rangesOverlap(getNodeRowRange(g), selectedRange))
+          : groupResult.groups;
+
+        for (const group of visibleGroups) {
+          const groupRowRange = getNodeRowRange(group);
+          result.push({
+            node: group,
+            depth: depth + 1,
+            displayKind: 'group',
+            groupedChildren: group.children,
+            rowRange: groupRowRange,
+          });
+
+          if (expanded.has(group.id)) {
+            const visibleInGroup = selectedRange
+              ? group.children.filter((c) => rangesOverlap(getNodeRowRange(c), selectedRange))
+              : group.children;
+
+            for (const child of visibleInGroup) {
+              walk(child, depth + 2);
+            }
+
+            if (selectedRange && visibleInGroup.length < group.children.length) {
+              addHiddenIndicator(
+                group,
+                group.children.length - visibleInGroup.length,
+                depth + 2,
+                'in group',
+              );
+            }
+          }
+        }
+
+        if (selectedRange && visibleGroups.length < groupResult.groups.length) {
+          addHiddenIndicator(
+            node,
+            groupResult.groups.length - visibleGroups.length,
+            depth + 1,
+            'groups',
+          );
+        }
+      } else {
+        const visible = selectedRange
+          ? chunkChildren.filter((c) => rangesOverlap(getNodeRowRange(c), selectedRange))
+          : chunkChildren;
+
+        for (const child of visible) {
+          walk(child, depth + 1);
+        }
+
+        if (selectedRange && visible.length < chunkChildren.length) {
+          addHiddenIndicator(node, chunkChildren.length - visible.length, depth + 1, 'chunks');
+        }
+      }
+    }
+  }
+
+  function addHiddenIndicator(
+    parent: LayoutTreeNode,
+    hiddenCount: number,
+    depth: number,
+    label: string,
+  ) {
+    const indicator: LayoutTreeNode = {
+      id: `${parent.id}_hidden_${label}`,
+      encoding: '',
+      dtype: '',
+      rowCount: parent.rowCount,
+      rowOffset: parent.rowOffset,
+      metadataBytes: 0,
+      segmentIds: [],
+      childType: { kind: 'transparent', name: `${hiddenCount} more ${label}` },
+      children: [],
+    };
+    result.push({
+      node: indicator,
+      depth,
+      displayKind: 'hiddenIndicator' as DisplayKind,
+      rowRange: getNodeRowRange(parent),
+    });
+  }
+
+  walk(root, 0);
+  return result;
+}
+
+/**
+ * Find a node by ID in a layout tree
+ */
+export function findNodeById(root: LayoutTreeNode, id: string): LayoutTreeNode | null {
+  if (root.id === id) return root;
+  for (const child of root.children) {
+    const found = findNodeById(child, id);
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * Find the path from root to a node (inclusive of both endpoints).
+ * Returns an empty array if the node is not found.
+ */
+export function findPathToNode(root: LayoutTreeNode, id: string): LayoutTreeNode[] {
+  if (root.id === id) return [root];
+  for (const child of root.children) {
+    const path = findPathToNode(child, id);
+    if (path.length > 0) return [root, ...path];
+  }
+  return [];
+}
+
+/**
+ * Collect all node IDs in a subtree
+ */
+export function collectSubtreeIds(node: LayoutTreeNode): Set<string> {
+  const ids = new Set<string>();
+  function walk(n: LayoutTreeNode) {
+    ids.add(n.id);
+    for (const child of n.children) walk(child);
+  }
+  walk(node);
+  return ids;
+}
+
+/**
+ * Collect all segment IDs reachable from a subtree
+ */
+export function collectSubtreeSegments(node: LayoutTreeNode): number[] {
+  const segments: number[] = [];
+  function walk(n: LayoutTreeNode) {
+    segments.push(...n.segmentIds);
+    for (const child of n.children) walk(child);
+  }
+  walk(node);
+  return segments;
+}
+
+/**
+ * Filter nodes matching a search query (and their ancestors)
+ */
+export function filterTreeBySearch(
+  rows: FlattenedRow[],
+  query: string,
+  root: LayoutTreeNode,
+): FlattenedRow[] {
+  if (!query.trim()) return rows;
+
+  const lowerQuery = query.toLowerCase();
+  const matchingIds = new Set<string>();
+
+  // Find all matching nodes
+  function findMatches(node: LayoutTreeNode) {
+    const name = getNodeDisplayName(node).toLowerCase();
+    const dtype = node.dtype.toLowerCase();
+    const encoding = node.encoding.toLowerCase();
+    if (name.includes(lowerQuery) || dtype.includes(lowerQuery) || encoding.includes(lowerQuery)) {
+      matchingIds.add(node.id);
+    }
+    for (const child of node.children) findMatches(child);
+  }
+  findMatches(root);
+
+  // Collect ancestors of matching nodes
+  const ancestorIds = new Set<string>();
+  function collectAncestors(node: LayoutTreeNode, path: string[]) {
+    if (matchingIds.has(node.id)) {
+      for (const id of path) ancestorIds.add(id);
+    }
+    for (const child of node.children) {
+      collectAncestors(child, [...path, node.id]);
+    }
+  }
+  collectAncestors(root, []);
+
+  // Collect descendants of matching nodes so expanded children are visible.
+  const descendantIds = new Set<string>();
+  function collectDescendants(node: LayoutTreeNode) {
+    descendantIds.add(node.id);
+    for (const child of node.children) collectDescendants(child);
+  }
+  function findDescendantsOfMatches(node: LayoutTreeNode) {
+    if (matchingIds.has(node.id)) {
+      collectDescendants(node);
+    } else {
+      for (const child of node.children) findDescendantsOfMatches(child);
+    }
+  }
+  findDescendantsOfMatches(root);
+
+  const visibleIds = new Set([...matchingIds, ...ancestorIds, ...descendantIds]);
+  return rows.filter((row) => visibleIds.has(row.node.id));
+}
+
+/**
+ * Strip the `vortex.` prefix from an encoding name for display.
+ */
+export function shortEncoding(encoding: string): string {
+  return encoding.startsWith('vortex.') ? encoding.slice(7) : encoding;
+}
+
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+/**
+ * Format row range to compact string (e.g., "0k–25k")
+ */
+export function formatRowRange(range: [number, number]): string {
+  const fmt = (n: number) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+  return `${fmt(range[0])}–${fmt(range[1])}`;
+}
+
+/**
+ * Format row count to compact string (e.g., "27.1k")
+ */
+export function formatRowCount(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 1000000) return `${(n / 1000).toFixed(1)}k`;
+  return `${(n / 1000000).toFixed(1)}M`;
+}
+
+/**
+ * Convert an ArrayEncodingNode tree into LayoutTreeNode children
+ * so they can appear in the layout tree under a flat layout node.
+ */
+export function arrayTreeToLayoutChildren(
+  arrayTree: ArrayEncodingNode,
+  parentNode: LayoutTreeNode,
+): LayoutTreeNode[] {
+  function convert(node: ArrayEncodingNode, parentId: string, name: string): LayoutTreeNode {
+    const id = `${parentId}.$${name}`;
+
+    const children = node.children.map((child, i) => {
+      const childName = node.childNames[i] ?? `child ${i}`;
+      return convert(child, id, childName);
+    });
+
+    return {
+      id,
+      encoding: node.encoding,
+      dtype: node.dtype || parentNode.dtype,
+      rowCount: parentNode.rowCount,
+      rowOffset: parentNode.rowOffset,
+      metadataBytes: node.metadataBytes,
+      segmentIds: [],
+      childType: { kind: 'field', fieldName: name },
+      children,
+      isArrayNode: true,
+      bufferLengths: node.bufferLengths,
+      bufferNames: node.bufferNames,
+    };
+  }
+
+  // Wrap the entire array tree as a single "array" child of the flat layout.
+  return [convert(arrayTree, parentNode.id, 'array')];
+}
+
+/**
+ * Check if a layout node is a flat layout that can have array children.
+ */
+export function isFlatLayout(node: LayoutTreeNode): boolean {
+  return node.encoding === 'vortex.flat' && !node.isArrayNode;
+}
+
+/**
+ * Parse an array node ID into its layout node ID and array child path.
+ * Array node IDs look like "root.col.$array.$values.$encoded".
+ * The first `$array` segment represents the root of the decoded array tree,
+ * so the WASM-side path skips it: → layoutNodeId: "root.col", arrayPath: ["values", "encoded"]
+ */
+export function parseArrayNodeId(nodeId: string): { layoutNodeId: string; arrayPath: string[] } {
+  const parts = nodeId.split('.');
+  const firstArrayIdx = parts.findIndex((p) => p.startsWith('$'));
+  if (firstArrayIdx === -1) {
+    return { layoutNodeId: nodeId, arrayPath: [] };
+  }
+  // Skip the first $array segment — it represents the decoded root, not a child to navigate to.
+  const arraySegments = parts.slice(firstArrayIdx).map((p) => p.slice(1));
+  return {
+    layoutNodeId: parts.slice(0, firstArrayIdx).join('.'),
+    arrayPath: arraySegments.slice(1),
+  };
+}
diff --git a/vortex-web/src/contexts/SelectionContext.tsx b/vortex-web/src/contexts/SelectionContext.tsx
new file mode 100644
index 00000000000..e44ee6ef008
--- /dev/null
+++ b/vortex-web/src/contexts/SelectionContext.tsx
@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { createContext, useContext, useReducer, useCallback, type ReactNode } from 'react';
+import type { LayoutTreeNode } from '../components/swimlane/types';
+import { findNodeById } from '../components/swimlane/utils';
+
+export interface SelectionState {
+  selectedNodeId: string | null;
+  selectedNode: LayoutTreeNode | null;
+  hoveredNodeId: string | null;
+  hoveredNode: LayoutTreeNode | null;
+  hoveredSegmentIndex: number | null;
+  selectedSegmentIndex: number | null;
+}
+
+type SelectionAction =
+  | { type: 'selectNode'; nodeId: string | null; tree: LayoutTreeNode }
+  | { type: 'hoverNode'; nodeId: string | null; tree: LayoutTreeNode }
+  | { type: 'hoverSegment'; index: number | null }
+  | { type: 'selectSegment'; index: number | null }
+  | { type: 'clearSelection' };
+
+function selectionReducer(state: SelectionState, action: SelectionAction): SelectionState {
+  switch (action.type) {
+    case 'selectNode': {
+      const nodeId = action.nodeId;
+      const node = nodeId ? findNodeById(action.tree, nodeId) : null;
+      return { ...state, selectedNodeId: nodeId, selectedNode: node, selectedSegmentIndex: null };
+    }
+    case 'hoverNode': {
+      const nodeId = action.nodeId;
+      const node = nodeId ? findNodeById(action.tree, nodeId) : null;
+      return { ...state, hoveredNodeId: nodeId, hoveredNode: node, hoveredSegmentIndex: null };
+    }
+    case 'hoverSegment':
+      return { ...state, hoveredSegmentIndex: action.index };
+    case 'selectSegment':
+      return { ...state, selectedSegmentIndex: action.index };
+    case 'clearSelection':
+      return {
+        selectedNodeId: null,
+        selectedNode: null,
+        hoveredNodeId: null,
+        hoveredNode: null,
+        hoveredSegmentIndex: null,
+        selectedSegmentIndex: null,
+      };
+  }
+}
+
+const initialState: SelectionState = {
+  selectedNodeId: null,
+  selectedNode: null,
+  hoveredNodeId: null,
+  hoveredNode: null,
+  hoveredSegmentIndex: null,
+  selectedSegmentIndex: null,
+};
+
+interface SelectionContextValue {
+  state: SelectionState;
+  selectNode: (nodeId: string | null) => void;
+  hoverNode: (nodeId: string | null) => void;
+  hoverSegment: (index: number | null) => void;
+  selectSegment: (index: number | null) => void;
+  clearSelection: () => void;
+}
+
+const SelectionContext = createContext<SelectionContextValue | null>(null);
+
+export function SelectionProvider({
+  tree,
+  children,
+}: {
+  tree: LayoutTreeNode;
+  children: ReactNode;
+}) {
+  const [state, dispatch] = useReducer(selectionReducer, initialState);
+
+  const selectNode = useCallback(
+    (nodeId: string | null) => dispatch({ type: 'selectNode', nodeId, tree }),
+    [tree],
+  );
+
+  const hoverNode = useCallback(
+    (nodeId: string | null) => dispatch({ type: 'hoverNode', nodeId, tree }),
+    [tree],
+  );
+
+  const hoverSegment = useCallback(
+    (index: number | null) => dispatch({ type: 'hoverSegment', index }),
+    [],
+  );
+
+  const selectSegment = useCallback(
+    (index: number | null) => dispatch({ type: 'selectSegment', index }),
+    [],
+  );
+
+  const clearSelection = useCallback(() => dispatch({ type: 'clearSelection' }), []);
+
+  return (
+    <SelectionContext.Provider
+      value={{ state, selectNode, hoverNode, hoverSegment, selectSegment, clearSelection }}
+    >
+      {children}
+    </SelectionContext.Provider>
+  );
+}
+
+export function useSelection(): SelectionContextValue {
+  const ctx = useContext(SelectionContext);
+  if (!ctx) throw new Error('useSelection must be used within SelectionProvider');
+  return ctx;
+}
+
+export { SelectionContext };
diff --git a/vortex-web/src/contexts/ThemeContext.tsx b/vortex-web/src/contexts/ThemeContext.tsx
new file mode 100644
index 00000000000..4230ebef84d
--- /dev/null
+++ b/vortex-web/src/contexts/ThemeContext.tsx
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { createContext, useCallback, useContext, useEffect, useState, type ReactNode } from 'react';
+
+export type ThemeChoice = 'light' | 'dark' | 'system';
+
+interface ThemeContextValue {
+  theme: ThemeChoice;
+  setTheme: (theme: ThemeChoice) => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+const STORAGE_KEY = 'vortex-theme';
+
+function applyTheme(choice: ThemeChoice) {
+  const root = document.documentElement;
+  root.classList.remove('light', 'dark');
+
+  if (choice === 'system') {
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    root.classList.add(prefersDark ? 'dark' : 'light');
+  } else {
+    root.classList.add(choice);
+  }
+}
+
+function getStoredTheme(): ThemeChoice {
+  const stored = localStorage.getItem(STORAGE_KEY);
+  if (stored === 'light' || stored === 'dark' || stored === 'system') return stored;
+  return 'dark';
+}
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+  const [theme, setThemeState] = useState<ThemeChoice>(getStoredTheme);
+
+  const setTheme = useCallback((choice: ThemeChoice) => {
+    localStorage.setItem(STORAGE_KEY, choice);
+    setThemeState(choice);
+    applyTheme(choice);
+  }, []);
+
+  // Apply on mount and listen for system preference changes.
+  useEffect(() => {
+    applyTheme(theme);
+
+    if (theme !== 'system') return;
+
+    const mq = window.matchMedia('(prefers-color-scheme: dark)');
+    const handler = () => applyTheme('system');
+    mq.addEventListener('change', handler);
+    return () => mq.removeEventListener('change', handler);
+  }, [theme]);
+
+  return <ThemeContext.Provider value={{ theme, setTheme }}>{children}</ThemeContext.Provider>;
+}
+
+export function useTheme(): ThemeContextValue {
+  const ctx = useContext(ThemeContext);
+  if (!ctx) throw new Error('useTheme must be used within a ThemeProvider');
+  return ctx;
+}
diff --git a/vortex-web/src/contexts/VortexFileContext.tsx b/vortex-web/src/contexts/VortexFileContext.tsx
new file mode 100644
index 00000000000..f3705aa5fd4
--- /dev/null
+++ b/vortex-web/src/contexts/VortexFileContext.tsx
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { createContext, useContext } from 'react';
+import type {
+  LayoutTreeNode,
+  SegmentMapEntry,
+  FileStructureInfo,
+  ArrayEncodingNode,
+} from '../components/swimlane/types';
+
+export interface VortexFileState {
+  fileName: string;
+  fileSize: number;
+  rowCount: number;
+  version: number;
+  dtype: string;
+  layoutTree: LayoutTreeNode;
+  segments: SegmentMapEntry[];
+  fileStructure: FileStructureInfo;
+}
+
+export interface VortexFileContextValue extends VortexFileState {
+  fetchEncodingTree: (nodeId: string) => Promise<ArrayEncodingNode>;
+  previewData: (nodeId: string, rowLimit: number) => Promise<Uint8Array>;
+  /** Fetch and attach array encoding tree children to a flat layout node. */
+  expandArrayTree: (nodeId: string) => Promise<void>;
+  /** Fetch a buffer from a decoded array node. */
+  fetchArrayBuffer: (
+    layoutNodeId: string,
+    arrayPath: string[],
+    bufferIndex: number,
+  ) => Promise<Uint8Array>;
+  /** Preview data from a specific array node, returning Arrow IPC bytes. */
+  previewArrayData: (
+    layoutNodeId: string,
+    arrayPath: string[],
+    rowLimit: number,
+  ) => Promise<Uint8Array>;
+}
+
+const VortexFileContext = createContext<VortexFileContextValue | null>(null);
+
+export function VortexFileProvider({
+  value,
+  children,
+}: {
+  value: VortexFileContextValue;
+  children: React.ReactNode;
+}) {
+  return <VortexFileContext.Provider value={value}>{children}</VortexFileContext.Provider>;
+}
+
+export function useVortexFile(): VortexFileContextValue {
+  const ctx = useContext(VortexFileContext);
+  if (!ctx) throw new Error('useVortexFile must be used within VortexFileProvider');
+  return ctx;
+}
+
+export { VortexFileContext };
diff --git a/vortex-web/src/index.css b/vortex-web/src/index.css
new file mode 100644
index 00000000000..432e388dca6
--- /dev/null
+++ b/vortex-web/src/index.css
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/* SPDX-FileCopyrightText: Copyright the Vortex contributors */
+
+@import 'tailwindcss';
+
+@custom-variant dark (&:where(.dark, .dark *));
+
+@theme inline {
+  --color-grey: #d4d4d8;
+
+  /* Surface palette */
+  --color-vortex-black: #1a1a1e;
+  --color-vortex-white: #fafafa;
+  --color-vortex-grey: #e4e4e7;
+  --color-vortex-grey-dark: #71717a;
+  --color-vortex-grey-light: #d4d4d8;
+  --color-vortex-grey-lightest: #f4f4f5;
+
+  /* Foreground — separate from surfaces so text contrast is tunable */
+  --color-vortex-fg: #e4e4e8;
+  --color-vortex-fg-light: #18181b;
+
+  /* Accent colors */
+  --color-vortex-green: #cee562;
+  --color-vortex-washed-green: #f1f8d0;
+  --color-vortex-light-blue: #2cb9d1;
+  --color-vortex-washed-light-blue: #d5f1f6;
+  --color-vortex-washed-lighter-blue: #eaf8fa;
+  --color-vortex-blue: #5971fd;
+  --color-vortex-pink: #eeb3e1;
+  --color-vortex-orange: #fb863d;
+  --color-vortex-red: #dc2626;
+
+  --font-sans: 'Geist', sans-serif;
+  --font-mono: 'Geist Mono', monospace;
+  --font-funnel: 'Funnel Display', sans-serif;
+}
+
+html {
+  scrollbar-width: thin;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+.light,
+.light * {
+  scrollbar-color: var(--color-vortex-grey-light) var(--color-vortex-grey-lightest);
+}
+
+.dark,
+.dark * {
+  scrollbar-color: #333338 var(--color-vortex-black);
+}
+
+body {
+  font-family: theme('fontFamily.sans');
+  text-rendering: optimizeLegibility;
+}
+
+/* Default app is dark themed */
+:root:not(.light) {
+  --array-node-bg: rgba(255, 255, 255, 0.03);
+}
+:root:not(.light) body {
+  background: var(--color-vortex-black);
+}
+
+.light {
+  --array-node-bg: rgba(0, 0, 0, 0.025);
+}
+.light body {
+  background: var(--color-vortex-white);
+}
+
+@layer utilities {
+  .dashed-bottom {
+    @apply relative after:absolute after:left-0 after:right-0 after:bottom-0 after:h-px after:bg-[length:16px_1px] after:bg-repeat-x after:bg-[linear-gradient(to_right,currentColor_12px,transparent_4px)] after:opacity-20;
+  }
+
+  .dashed-top {
+    @apply relative before:absolute before:left-0 before:right-0 before:top-0 before:h-px before:bg-[length:16px_1px] before:bg-repeat-x before:bg-[linear-gradient(to_right,currentColor_12px,transparent_4px)] before:opacity-20;
+  }
+
+  .dashed-right {
+    @apply relative after:absolute after:top-0 after:bottom-0 after:right-0 after:w-px after:bg-[length:1px_16px] after:bg-repeat-y after:bg-[linear-gradient(to_bottom,currentColor_12px,transparent_4px)] after:opacity-20;
+  }
+
+  .dashed-left {
+    @apply relative before:absolute before:top-0 before:bottom-0 before:left-0 before:w-px before:bg-[length:1px_16px] before:bg-repeat-y before:bg-[linear-gradient(to_bottom,currentColor_12px,transparent_4px)] before:opacity-20;
+  }
+}
diff --git a/vortex-web/src/main.tsx b/vortex-web/src/main.tsx
new file mode 100644
index 00000000000..6fbdadbfa60
--- /dev/null
+++ b/vortex-web/src/main.tsx
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import './index.css';
+import App from './App.tsx';
+import { ThemeProvider } from './contexts/ThemeContext.tsx';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <ThemeProvider>
+      <App />
+    </ThemeProvider>
+  </StrictMode>,
+);
diff --git a/vortex-web/src/mocks/fileStructure.ts b/vortex-web/src/mocks/fileStructure.ts
new file mode 100644
index 00000000000..02b14e2ece4
--- /dev/null
+++ b/vortex-web/src/mocks/fileStructure.ts
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { FileStructureInfo, SegmentMapEntry } from '../components/swimlane/types';
+
+/**
+ * Generate a FileStructureInfo from segment entries and a total file size.
+ */
+export function generateFileStructure(
+  segments: SegmentMapEntry[],
+  fileSize: number,
+): FileStructureInfo {
+  const totalDataBytes = segments.reduce((sum, s) => sum + s.byteLength, 0);
+
+  const eofSize = 8;
+  const postscriptSize = 64;
+  const footerSize = Math.max(256, segments.length * 16);
+  const layoutSize = Math.max(128, Math.floor(fileSize * 0.02));
+  const dtypeSize = Math.max(64, Math.floor(fileSize * 0.01));
+  const metadataTotal = eofSize + postscriptSize + footerSize + layoutSize + dtypeSize;
+
+  return {
+    fileSize,
+    version: 1,
+    postscriptSize,
+    totalDataBytes,
+    totalMetadataBytes: metadataTotal,
+  };
+}
diff --git a/vortex-web/src/mocks/generators.ts b/vortex-web/src/mocks/generators.ts
new file mode 100644
index 00000000000..ac8b6fb64a7
--- /dev/null
+++ b/vortex-web/src/mocks/generators.ts
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode, LayoutChildKind } from '../components/swimlane/types';
+
+let nextSegmentId = 0;
+
+export function resetSegmentIds() {
+  nextSegmentId = 0;
+}
+
+function allocSegments(count: number): number[] {
+  const ids = [];
+  for (let i = 0; i < count; i++) {
+    ids.push(nextSegmentId++);
+  }
+  return ids;
+}
+
+export function makeFlat(opts: {
+  id: string;
+  childType: LayoutChildKind;
+  dtype: string;
+  rowCount: number;
+  rowOffset: number;
+  metadataBytes?: number;
+}): LayoutTreeNode {
+  return {
+    id: opts.id,
+    encoding: 'vortex.flat',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: opts.metadataBytes ?? 64,
+    segmentIds: allocSegments(1),
+    childType: opts.childType,
+    children: [],
+  };
+}
+
+export function makeChunked(opts: {
+  id: string;
+  childType: LayoutChildKind;
+  dtype: string;
+  rowCount: number;
+  rowOffset: number;
+  chunkCount: number;
+  childEncoding?: string;
+  metadataBytes?: number;
+}): LayoutTreeNode {
+  const rowsPerChunk = Math.ceil(opts.rowCount / opts.chunkCount);
+  const children: LayoutTreeNode[] = [];
+
+  for (let i = 0; i < opts.chunkCount; i++) {
+    const chunkOffset = opts.rowOffset + i * rowsPerChunk;
+    const chunkRows = Math.min(rowsPerChunk, opts.rowOffset + opts.rowCount - chunkOffset);
+    if (chunkRows <= 0) break;
+
+    children.push(
+      makeFlat({
+        id: `${opts.id}.[${i}]`,
+        childType: { kind: 'chunk', chunkIndex: i, rowOffset: chunkOffset },
+        dtype: opts.dtype,
+        rowCount: chunkRows,
+        rowOffset: chunkOffset,
+        metadataBytes: 32,
+      }),
+    );
+  }
+
+  return {
+    id: opts.id,
+    encoding: 'vortex.chunked',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: opts.metadataBytes ?? 128,
+    segmentIds: allocSegments(1),
+    childType: opts.childType,
+    children,
+  };
+}
+
+export function makeStruct(opts: {
+  id: string;
+  childType: LayoutChildKind;
+  dtype: string;
+  rowCount: number;
+  rowOffset: number;
+  fields: LayoutTreeNode[];
+  metadataBytes?: number;
+}): LayoutTreeNode {
+  return {
+    id: opts.id,
+    encoding: 'vortex.struct',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: opts.metadataBytes ?? 96,
+    segmentIds: allocSegments(1),
+    childType: opts.childType,
+    children: opts.fields,
+  };
+}
+
+export function makeDict(opts: {
+  id: string;
+  childType: LayoutChildKind;
+  dtype: string;
+  rowCount: number;
+  rowOffset: number;
+  codesDtype?: string;
+  metadataBytes?: number;
+}): LayoutTreeNode {
+  return {
+    id: opts.id,
+    encoding: 'vortex.dict',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: opts.metadataBytes ?? 64,
+    segmentIds: allocSegments(1),
+    childType: opts.childType,
+    children: [
+      makeFlat({
+        id: `${opts.id}.codes`,
+        childType: { kind: 'transparent', name: 'codes' },
+        dtype: opts.codesDtype ?? 'u16',
+        rowCount: opts.rowCount,
+        rowOffset: opts.rowOffset,
+      }),
+      makeFlat({
+        id: `${opts.id}.values`,
+        childType: { kind: 'transparent', name: 'values' },
+        dtype: opts.dtype,
+        rowCount: opts.rowCount,
+        rowOffset: opts.rowOffset,
+      }),
+    ],
+  };
+}
+
+export function makeZoned(opts: {
+  id: string;
+  childType: LayoutChildKind;
+  dtype: string;
+  rowCount: number;
+  rowOffset: number;
+  zoneCount: number;
+  metadataBytes?: number;
+}): LayoutTreeNode {
+  const rowsPerZone = Math.ceil(opts.rowCount / opts.zoneCount);
+  const children: LayoutTreeNode[] = [];
+
+  // Zones auxiliary child
+  const zoneChildren: LayoutTreeNode[] = [];
+  for (let i = 0; i < opts.zoneCount; i++) {
+    const zoneOffset = opts.rowOffset + i * rowsPerZone;
+    const zoneRows = Math.min(rowsPerZone, opts.rowOffset + opts.rowCount - zoneOffset);
+    if (zoneRows <= 0) break;
+
+    zoneChildren.push(
+      makeFlat({
+        id: `${opts.id}.zones.[${i}]`,
+        childType: { kind: 'chunk', chunkIndex: i, rowOffset: zoneOffset },
+        dtype: opts.dtype,
+        rowCount: zoneRows,
+        rowOffset: zoneOffset,
+      }),
+    );
+  }
+
+  children.push({
+    id: `${opts.id}.data`,
+    encoding: 'vortex.chunked',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: 64,
+    segmentIds: allocSegments(1),
+    childType: { kind: 'transparent', name: 'data' },
+    children: zoneChildren,
+  });
+
+  // Zone map stats (auxiliary)
+  children.push(
+    makeFlat({
+      id: `${opts.id}.zone_map`,
+      childType: { kind: 'auxiliary', name: 'zone_map' },
+      dtype: `{min=${opts.dtype}, max=${opts.dtype}}`,
+      rowCount: opts.zoneCount,
+      rowOffset: 0,
+    }),
+  );
+
+  return {
+    id: opts.id,
+    encoding: 'vortex.zonemap',
+    dtype: opts.dtype,
+    rowCount: opts.rowCount,
+    rowOffset: opts.rowOffset,
+    metadataBytes: opts.metadataBytes ?? 256,
+    segmentIds: allocSegments(1),
+    childType: opts.childType,
+    children,
+  };
+}
diff --git a/vortex-web/src/mocks/index.ts b/vortex-web/src/mocks/index.ts
new file mode 100644
index 00000000000..681e38aace8
--- /dev/null
+++ b/vortex-web/src/mocks/index.ts
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+export { simpleMock, ordersMock, wideMock, deepMock, heavyChunksMock } from './layouts';
+export { generateSegments } from './segments';
+export { generateFileStructure } from './fileStructure';
+export {
+  makeFlat,
+  makeChunked,
+  makeStruct,
+  makeDict,
+  makeZoned,
+  resetSegmentIds,
+} from './generators';
diff --git a/vortex-web/src/mocks/layouts.ts b/vortex-web/src/mocks/layouts.ts
new file mode 100644
index 00000000000..e18c469c7ab
--- /dev/null
+++ b/vortex-web/src/mocks/layouts.ts
@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode } from '../components/swimlane/types';
+import {
+  resetSegmentIds,
+  makeFlat,
+  makeChunked,
+  makeStruct,
+  makeDict,
+  makeZoned,
+} from './generators';
+
+/**
+ * Simple: single flat column
+ */
+export function simpleMock(): LayoutTreeNode {
+  resetSegmentIds();
+  return makeFlat({
+    id: 'root',
+    childType: { kind: 'root' },
+    dtype: 'i64',
+    rowCount: 10000,
+    rowOffset: 0,
+    metadataBytes: 64,
+  });
+}
+
+/**
+ * Orders: 7 columns, mixed encodings — the canonical demo dataset
+ */
+export function ordersMock(): LayoutTreeNode {
+  resetSegmentIds();
+  const totalRows = 100_000;
+
+  return makeStruct({
+    id: 'root',
+    childType: { kind: 'root' },
+    dtype:
+      '{order_id=i64, is_active=bool, customer={id=i64, name=utf8}, items=list<struct>, amount=f64, metadata=struct, status=utf8}',
+    rowCount: totalRows,
+    rowOffset: 0,
+    fields: [
+      makeFlat({
+        id: 'root.order_id',
+        childType: { kind: 'field', fieldName: 'order_id' },
+        dtype: 'i64',
+        rowCount: totalRows,
+        rowOffset: 0,
+        metadataBytes: 64,
+      }),
+      makeFlat({
+        id: 'root.is_active',
+        childType: { kind: 'field', fieldName: 'is_active' },
+        dtype: 'bool',
+        rowCount: totalRows,
+        rowOffset: 0,
+        metadataBytes: 32,
+      }),
+      makeStruct({
+        id: 'root.customer',
+        childType: { kind: 'field', fieldName: 'customer' },
+        dtype: '{id=i64, name=utf8}',
+        rowCount: totalRows,
+        rowOffset: 0,
+        fields: [
+          makeChunked({
+            id: 'root.customer.id',
+            childType: { kind: 'field', fieldName: 'id' },
+            dtype: 'i64',
+            rowCount: totalRows,
+            rowOffset: 0,
+            chunkCount: 50,
+          }),
+          makeChunked({
+            id: 'root.customer.name',
+            childType: { kind: 'field', fieldName: 'name' },
+            dtype: 'utf8',
+            rowCount: totalRows,
+            rowOffset: 0,
+            chunkCount: 8,
+          }),
+        ],
+      }),
+      makeFlat({
+        id: 'root.items',
+        childType: { kind: 'field', fieldName: 'items' },
+        dtype: 'list<struct>',
+        rowCount: totalRows,
+        rowOffset: 0,
+        metadataBytes: 128,
+      }),
+      makeZoned({
+        id: 'root.amount',
+        childType: { kind: 'field', fieldName: 'amount' },
+        dtype: 'f64',
+        rowCount: totalRows,
+        rowOffset: 0,
+        zoneCount: 5,
+      }),
+      makeFlat({
+        id: 'root.metadata',
+        childType: { kind: 'field', fieldName: 'metadata' },
+        dtype: 'struct',
+        rowCount: totalRows,
+        rowOffset: 0,
+        metadataBytes: 256,
+      }),
+      makeDict({
+        id: 'root.status',
+        childType: { kind: 'field', fieldName: 'status' },
+        dtype: 'utf8',
+        rowCount: totalRows,
+        rowOffset: 0,
+      }),
+    ],
+  });
+}
+
+/**
+ * Wide: 200 columns (to test search and scrolling)
+ */
+export function wideMock(): LayoutTreeNode {
+  resetSegmentIds();
+  const totalRows = 50_000;
+  const dtypes = ['i32', 'i64', 'f32', 'f64', 'utf8', 'bool', 'u16', 'u32'];
+
+  const fields: LayoutTreeNode[] = Array.from({ length: 200 }, (_, i) => {
+    const dtype = dtypes[i % dtypes.length];
+    return makeFlat({
+      id: `root.col_${i}`,
+      childType: { kind: 'field', fieldName: `col_${i}` },
+      dtype,
+      rowCount: totalRows,
+      rowOffset: 0,
+    });
+  });
+
+  return makeStruct({
+    id: 'root',
+    childType: { kind: 'root' },
+    dtype: '{...200 columns}',
+    rowCount: totalRows,
+    rowOffset: 0,
+    fields,
+  });
+}
+
+/**
+ * Deep: nested structs (3 levels deep)
+ */
+export function deepMock(): LayoutTreeNode {
+  resetSegmentIds();
+  const totalRows = 25_000;
+
+  return makeStruct({
+    id: 'root',
+    childType: { kind: 'root' },
+    dtype:
+      '{user={profile={address={street=utf8, city=utf8, zip=u32}, name=utf8, age=u8}, orders=list<struct>}}',
+    rowCount: totalRows,
+    rowOffset: 0,
+    fields: [
+      makeStruct({
+        id: 'root.user',
+        childType: { kind: 'field', fieldName: 'user' },
+        dtype: '{profile={...}, orders=list<struct>}',
+        rowCount: totalRows,
+        rowOffset: 0,
+        fields: [
+          makeStruct({
+            id: 'root.user.profile',
+            childType: { kind: 'field', fieldName: 'profile' },
+            dtype: '{address={...}, name=utf8, age=u8}',
+            rowCount: totalRows,
+            rowOffset: 0,
+            fields: [
+              makeStruct({
+                id: 'root.user.profile.address',
+                childType: { kind: 'field', fieldName: 'address' },
+                dtype: '{street=utf8, city=utf8, zip=u32}',
+                rowCount: totalRows,
+                rowOffset: 0,
+                fields: [
+                  makeFlat({
+                    id: 'root.user.profile.address.street',
+                    childType: { kind: 'field', fieldName: 'street' },
+                    dtype: 'utf8',
+                    rowCount: totalRows,
+                    rowOffset: 0,
+                  }),
+                  makeFlat({
+                    id: 'root.user.profile.address.city',
+                    childType: { kind: 'field', fieldName: 'city' },
+                    dtype: 'utf8',
+                    rowCount: totalRows,
+                    rowOffset: 0,
+                  }),
+                  makeFlat({
+                    id: 'root.user.profile.address.zip',
+                    childType: { kind: 'field', fieldName: 'zip' },
+                    dtype: 'u32',
+                    rowCount: totalRows,
+                    rowOffset: 0,
+                  }),
+                ],
+              }),
+              makeFlat({
+                id: 'root.user.profile.name',
+                childType: { kind: 'field', fieldName: 'name' },
+                dtype: 'utf8',
+                rowCount: totalRows,
+                rowOffset: 0,
+              }),
+              makeFlat({
+                id: 'root.user.profile.age',
+                childType: { kind: 'field', fieldName: 'age' },
+                dtype: 'u8',
+                rowCount: totalRows,
+                rowOffset: 0,
+              }),
+            ],
+          }),
+          makeChunked({
+            id: 'root.user.orders',
+            childType: { kind: 'field', fieldName: 'orders' },
+            dtype: 'list<struct>',
+            rowCount: totalRows,
+            rowOffset: 0,
+            chunkCount: 5,
+          }),
+        ],
+      }),
+    ],
+  });
+}
+
+/**
+ * Heavy chunks: a single column with 500 chunks (to test grouping)
+ */
+export function heavyChunksMock(): LayoutTreeNode {
+  resetSegmentIds();
+  const totalRows = 1_000_000;
+
+  return makeStruct({
+    id: 'root',
+    childType: { kind: 'root' },
+    dtype: '{values=i64}',
+    rowCount: totalRows,
+    rowOffset: 0,
+    fields: [
+      makeChunked({
+        id: 'root.values',
+        childType: { kind: 'field', fieldName: 'values' },
+        dtype: 'i64',
+        rowCount: totalRows,
+        rowOffset: 0,
+        chunkCount: 500,
+      }),
+    ],
+  });
+}
diff --git a/vortex-web/src/mocks/segments.ts b/vortex-web/src/mocks/segments.ts
new file mode 100644
index 00000000000..a1c6430d5f5
--- /dev/null
+++ b/vortex-web/src/mocks/segments.ts
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { LayoutTreeNode, SegmentMapEntry } from '../components/swimlane/types';
+import { getNodeDisplayName } from '../components/swimlane/utils';
+
+/**
+ * Generate SegmentMapEntry[] by walking a layout tree and assigning byte offsets.
+ */
+export function generateSegments(root: LayoutTreeNode, fileSize: number): SegmentMapEntry[] {
+  const entries: SegmentMapEntry[] = [];
+
+  // Collect all segment IDs with their layout context
+  function walk(node: LayoutTreeNode, columnPath: string) {
+    const name = getNodeDisplayName(node);
+    const currentPath = columnPath ? `${columnPath}.${name}` : name;
+
+    for (const segId of node.segmentIds) {
+      entries.push({
+        index: segId,
+        byteOffset: 0, // filled in below
+        byteLength: 0,
+        alignment: 64,
+        column: node.childType.kind === 'field' ? node.childType.fieldName : null,
+        layoutPath: node.id,
+      });
+    }
+
+    for (const child of node.children) {
+      walk(child, currentPath);
+    }
+  }
+
+  walk(root, '');
+
+  // Sort by index and assign byte offsets proportionally
+  entries.sort((a, b) => a.index - b.index);
+  const totalSegments = entries.length;
+  if (totalSegments === 0) return entries;
+
+  // Reserve ~10% for metadata at the end
+  const dataRegionSize = Math.floor(fileSize * 0.9);
+  const avgSegmentSize = Math.floor(dataRegionSize / totalSegments);
+
+  let offset = 0;
+  for (const entry of entries) {
+    // Add some variance: segments between 0.5x and 1.5x average size
+    const variance = 0.5 + hashIndex(entry.index) / 0xffff;
+    const segmentSize = Math.max(64, Math.floor(avgSegmentSize * variance));
+    const alignment = 64;
+    // Align offset
+    offset = Math.ceil(offset / alignment) * alignment;
+
+    entry.byteOffset = offset;
+    entry.byteLength = segmentSize;
+    offset += segmentSize;
+  }
+
+  return entries;
+}
+
+function hashIndex(n: number): number {
+  // Simple deterministic hash for variance
+  let h = n * 2654435761;
+  h = ((h >>> 16) ^ h) * 0x45d9f3b;
+  return (h >>> 0) & 0xffff;
+}
diff --git a/vortex-web/src/storybook/decorators.tsx b/vortex-web/src/storybook/decorators.tsx
new file mode 100644
index 00000000000..28483564d18
--- /dev/null
+++ b/vortex-web/src/storybook/decorators.tsx
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type { Decorator } from '@storybook/react-vite';
+import type { VortexFileState } from '../contexts/VortexFileContext';
+import type { LayoutTreeNode } from '../components/swimlane/types';
+import { VortexFileProvider } from '../contexts/VortexFileContext';
+import { SelectionProvider } from '../contexts/SelectionContext';
+
+const EMPTY_TREE: LayoutTreeNode = {
+  id: 'root',
+  encoding: 'vortex.struct',
+  dtype: 'struct',
+  rowCount: 0,
+  rowOffset: 0,
+  metadataBytes: 0,
+  segmentIds: [],
+  childType: { kind: 'root' },
+  children: [],
+};
+
+/**
+ * Storybook decorator that wraps a story in VortexFileContext.Provider
+ */
+export function withMockFileContext(state: VortexFileState): Decorator {
+  const value = {
+    ...state,
+    fetchEncodingTree: () => Promise.reject(new Error('Not implemented in storybook')),
+    previewData: () => Promise.reject(new Error('Not implemented in storybook')),
+    expandArrayTree: () => Promise.resolve(),
+    fetchArrayBuffer: () => Promise.reject(new Error('Not implemented in storybook')),
+    previewArrayData: () => Promise.reject(new Error('Not implemented in storybook')),
+  };
+  return (Story) => (
+    <VortexFileProvider value={value}>
+      <Story />
+    </VortexFileProvider>
+  );
+}
+
+/**
+ * Storybook decorator that wraps a story in both VortexFileContext and SelectionContext
+ */
+export function withMockSelection(tree?: LayoutTreeNode): Decorator {
+  return (Story) => (
+    <SelectionProvider tree={tree ?? EMPTY_TREE}>
+      <Story />
+    </SelectionProvider>
+  );
+}
diff --git a/vortex-array/src/arrow/compute/mod.rs b/vortex-web/src/vite-env.d.ts
similarity index 72%
rename from vortex-array/src/arrow/compute/mod.rs
rename to vortex-web/src/vite-env.d.ts
index 328460554a0..746477400e1 100644
--- a/vortex-array/src/arrow/compute/mod.rs
+++ b/vortex-web/src/vite-env.d.ts
@@ -1,6 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-mod to_arrow;
-
-pub use to_arrow::*;
+/// <reference types="vite/client" />
diff --git a/vortex-web/src/workers/VortexWorker.ts b/vortex-web/src/workers/VortexWorker.ts
new file mode 100644
index 00000000000..5fe90db9f6c
--- /dev/null
+++ b/vortex-web/src/workers/VortexWorker.ts
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import type {
+  LayoutTreeNode,
+  SegmentMapEntry,
+  FileStructureInfo,
+  ArrayEncodingNode,
+} from '../components/swimlane/types';
+
+export interface OpenFileResult {
+  rowCount: number;
+  dtype: string;
+  layoutTree: LayoutTreeNode;
+  segments: SegmentMapEntry[];
+  fileStructure: FileStructureInfo;
+}
+
+interface PendingRequest<T = unknown> {
+  resolve: (value: T) => void;
+  reject: (reason: Error) => void;
+}
+
+/** Typed async wrapper around the Vortex WASM Web Worker. */
+export class VortexWorker {
+  private worker: Worker;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private pending = new Map<number, PendingRequest<any>>();
+  private nextId = 0;
+
+  constructor() {
+    this.worker = new Worker(new URL('./vortex.worker.ts', import.meta.url), { type: 'module' });
+    this.worker.onmessage = (e: MessageEvent) => {
+      const { type, id, data, error } = e.data;
+      const req = this.pending.get(id);
+      if (!req) return;
+      this.pending.delete(id);
+      if (type === 'result') {
+        req.resolve(data);
+      } else {
+        req.reject(new Error(error ?? 'Unknown worker error'));
+      }
+    };
+  }
+
+  /** Open a Vortex file in the worker. The File is structured-cloneable. */
+  openFile(file: File): Promise<OpenFileResult> {
+    const id = this.nextId++;
+    return new Promise<OpenFileResult>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ type: 'open', id, file });
+    });
+  }
+
+  /** Fetch the array encoding tree for a flat layout node by its ID. */
+  fetchEncodingTree(nodeId: string): Promise<ArrayEncodingNode> {
+    const id = this.nextId++;
+    return new Promise<ArrayEncodingNode>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ type: 'fetchEncodingTree', id, nodeId });
+    });
+  }
+
+  /** Fetch a buffer from a decoded array node. */
+  fetchArrayBuffer(
+    layoutNodeId: string,
+    arrayPath: string[],
+    bufferIndex: number,
+  ): Promise<Uint8Array> {
+    const id = this.nextId++;
+    return new Promise<Uint8Array>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({
+        type: 'fetchArrayBuffer',
+        id,
+        layoutNodeId,
+        arrayPath,
+        bufferIndex,
+      });
+    });
+  }
+
+  /** Preview data from a specific array node within a flat layout. */
+  previewArrayData(
+    layoutNodeId: string,
+    arrayPath: string[],
+    rowLimit: number,
+  ): Promise<Uint8Array> {
+    const id = this.nextId++;
+    return new Promise<Uint8Array>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ type: 'previewArrayData', id, layoutNodeId, arrayPath, rowLimit });
+    });
+  }
+
+  /** Preview data from a specific layout node, returning Arrow IPC bytes. */
+  previewData(nodeId: string, rowLimit: number): Promise<Uint8Array> {
+    const id = this.nextId++;
+    return new Promise<Uint8Array>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ type: 'previewData', id, nodeId, rowLimit });
+    });
+  }
+
+  terminate(): void {
+    this.worker.terminate();
+  }
+}
diff --git a/vortex-web/src/workers/vortex.worker.ts b/vortex-web/src/workers/vortex.worker.ts
new file mode 100644
index 00000000000..e296b5732f9
--- /dev/null
+++ b/vortex-web/src/workers/vortex.worker.ts
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+/// <reference lib="webworker" />
+
+import init, { open_vortex_file, type VortexFileHandle } from '../wasm/pkg/vortex_web_wasm.js';
+
+let initialized = false;
+let fileHandle: VortexFileHandle | null = null;
+
+self.onmessage = async (e: MessageEvent) => {
+  const { type, id } = e.data;
+  try {
+    if (!initialized) {
+      await init();
+      initialized = true;
+    }
+
+    if (type === 'open') {
+      // Free previous handle if any.
+      if (fileHandle) {
+        fileHandle.free();
+        fileHandle = null;
+      }
+      fileHandle = await open_vortex_file(e.data.file);
+      const result = {
+        rowCount: Number(fileHandle.row_count),
+        dtype: fileHandle.dtype,
+        layoutTree: JSON.parse(fileHandle.layout_tree()),
+        segments: JSON.parse(fileHandle.segment_map()),
+        fileStructure: JSON.parse(fileHandle.file_structure()),
+      };
+      self.postMessage({ type: 'result', id, data: result });
+    } else if (type === 'fetchEncodingTree') {
+      if (!fileHandle) throw new Error('No file open');
+      const json = await fileHandle.fetch_encoding_tree(e.data.nodeId);
+      self.postMessage({ type: 'result', id, data: JSON.parse(json) });
+    } else if (type === 'fetchArrayBuffer') {
+      if (!fileHandle) throw new Error('No file open');
+      const buf: Uint8Array = await fileHandle.fetch_array_buffer(
+        e.data.layoutNodeId,
+        e.data.arrayPath,
+        e.data.bufferIndex,
+      );
+      self.postMessage({ type: 'result', id, data: buf }, [buf.buffer]);
+    } else if (type === 'previewArrayData') {
+      if (!fileHandle) throw new Error('No file open');
+      const ipcBytes: Uint8Array = await fileHandle.preview_array_data(
+        e.data.layoutNodeId,
+        e.data.arrayPath,
+        e.data.rowLimit,
+      );
+      self.postMessage({ type: 'result', id, data: ipcBytes }, [ipcBytes.buffer]);
+    } else if (type === 'previewData') {
+      if (!fileHandle) throw new Error('No file open');
+      const ipcBytes: Uint8Array = await fileHandle.preview_data(e.data.nodeId, e.data.rowLimit);
+      self.postMessage({ type: 'result', id, data: ipcBytes }, [ipcBytes.buffer]);
+    }
+  } catch (err) {
+    self.postMessage({ type: 'error', id, error: String(err) });
+  }
+};
diff --git a/vortex-web/tsconfig.app.json b/vortex-web/tsconfig.app.json
new file mode 100644
index 00000000000..4d4a56c741e
--- /dev/null
+++ b/vortex-web/tsconfig.app.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsBuildInfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}
diff --git a/vortex-web/tsconfig.json b/vortex-web/tsconfig.json
new file mode 100644
index 00000000000..1ffef600d95
--- /dev/null
+++ b/vortex-web/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/vortex-web/tsconfig.node.json b/vortex-web/tsconfig.node.json
new file mode 100644
index 00000000000..843c8a88dbe
--- /dev/null
+++ b/vortex-web/tsconfig.node.json
@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsBuildInfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts", "eslint.config.ts"]
+}
diff --git a/vortex-web/vite.config.ts b/vortex-web/vite.config.ts
new file mode 100644
index 00000000000..4c7d941bdc4
--- /dev/null
+++ b/vortex-web/vite.config.ts
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+});
diff --git a/vortex/Cargo.toml b/vortex/Cargo.toml
index d8dc89882b0..f042f568c11 100644
--- a/vortex/Cargo.toml
+++ b/vortex/Cargo.toml
@@ -44,6 +44,7 @@ vortex-scan = { workspace = true }
 vortex-sequence = { workspace = true }
 vortex-session = { 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 }
@@ -55,12 +56,15 @@ divan = { workspace = true }
 fastlanes = { workspace = true }
 mimalloc = { workspace = true }
 parquet = { workspace = true }
+paste = { workspace = true }
 rand = { workspace = true }
+rand_distr = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 vortex = { path = ".", features = ["tokio"] }
+vortex-tensor = { workspace = true }
 
 [features]
 default = ["files", "zstd"]
@@ -73,6 +77,7 @@ pretty = ["vortex-array/table-display"]
 serde = ["vortex-array/serde", "vortex-buffer/serde", "vortex-mask/serde"]
 # This feature enabled unstable encodings for which we don't guarantee stability.
 unstable_encodings = [
+    "dep:vortex-tensor",
     "vortex-btrblocks/unstable_encodings",
     "vortex-file?/unstable_encodings",
     "vortex-zstd?/unstable_encodings",
diff --git a/vortex/benches/common_encoding_tree_throughput.rs b/vortex/benches/common_encoding_tree_throughput.rs
index d1ec4170736..077fda0a536 100644
--- a/vortex/benches/common_encoding_tree_throughput.rs
+++ b/vortex/benches/common_encoding_tree_throughput.rs
@@ -11,9 +11,8 @@ use divan::Bencher;
 #[cfg(not(codspeed))]
 use divan::counter::BytesCount;
 use mimalloc::MiMalloc;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
-use vortex::array::Array;
 use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::ToCanonical;
@@ -22,20 +21,27 @@ use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::TemporalArray;
 use vortex::array::arrays::VarBinArray;
 use vortex::array::arrays::VarBinViewArray;
+use vortex::array::arrays::varbin::VarBinArrayExt;
 use vortex::array::builtins::ArrayBuiltins;
-use vortex::array::vtable::ValidityHelper;
 use vortex::dtype::DType;
 use vortex::dtype::PType;
+use vortex::encodings::alp::ALP;
+use vortex::encodings::alp::ALPArrayExt;
+use vortex::encodings::alp::ALPArraySlotsExt;
 use vortex::encodings::alp::alp_encode;
-use vortex::encodings::datetime_parts::DateTimePartsArray;
+use vortex::encodings::datetime_parts::DateTimeParts;
 use vortex::encodings::datetime_parts::split_temporal;
-use vortex::encodings::fastlanes::FoRArray;
-use vortex::encodings::fsst::FSSTArray;
+use vortex::encodings::fastlanes::BitPacked;
+use vortex::encodings::fastlanes::FoR;
+use vortex::encodings::fastlanes::FoRArrayExt;
+use vortex::encodings::fsst::FSST;
+use vortex::encodings::fsst::FSSTArrayExt;
 use vortex::encodings::fsst::fsst_compress;
 use vortex::encodings::fsst::fsst_train_compressor;
-use vortex::encodings::runend::RunEndArray;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::runend::RunEndArrayExt;
+use vortex::error::VortexExpect;
 use vortex::extension::datetime::TimeUnit;
-use vortex_fastlanes::BitPackedArray;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
@@ -44,7 +50,7 @@ fn main() {
     divan::main();
 }
 
-const NUM_VALUES: u64 = 1_000_000;
+const NUM_VALUES: u64 = 100_000;
 
 // Helper function to conditionally add counter based on codspeed cfg
 fn with_byte_counter<'a, 'b>(bencher: Bencher<'a, 'b>, bytes: u64) -> Bencher<'a, 'b> {
@@ -69,12 +75,14 @@ mod setup {
         let uint_array =
             PrimitiveArray::from_iter((0..NUM_VALUES).map(|_| rng.random_range(42u32..256)));
         let int_array = uint_array
-            .to_array()
+            .clone()
+            .into_array()
             .cast(PType::I32.into())
             .unwrap()
             .to_primitive();
         let float_array = uint_array
-            .to_array()
+            .clone()
+            .into_array()
             .cast(PType::F64.into())
             .unwrap()
             .to_primitive();
@@ -84,10 +92,10 @@ mod setup {
     /// Create FoR <- BitPacked encoding tree for u64
     pub fn for_bp_u64() -> ArrayRef {
         let (uint_array, ..) = setup_primitive_arrays();
-        let compressed = FoRArray::encode(uint_array).unwrap();
+        let compressed = FoR::encode(uint_array).unwrap();
         let inner = compressed.encoded();
-        let bp = BitPackedArray::encode(inner, 8).unwrap();
-        FoRArray::try_new(bp.into_array(), compressed.reference_scalar().clone())
+        let bp = BitPacked::encode(inner, 8).unwrap();
+        FoR::try_new(bp.into_array(), compressed.reference_scalar().clone())
             .unwrap()
             .into_array()
     }
@@ -98,16 +106,16 @@ mod setup {
         let alp_compressed = alp_encode(&float_array, None).unwrap();
 
         // Manually construct ALP <- FoR <- BitPacked tree
-        let for_array = FoRArray::encode(alp_compressed.encoded().to_primitive()).unwrap();
+        let for_array = FoR::encode(alp_compressed.encoded().to_primitive()).unwrap();
         let inner = for_array.encoded();
-        let bp = BitPackedArray::encode(inner, 8).unwrap();
+        let bp = BitPacked::encode(inner, 8).unwrap();
         let for_with_bp =
-            FoRArray::try_new(bp.into_array(), for_array.reference_scalar().clone()).unwrap();
+            FoR::try_new(bp.into_array(), for_array.reference_scalar().clone()).unwrap();
 
-        vortex::encodings::alp::ALPArray::try_new(
+        ALP::try_new(
             for_with_bp.into_array(),
             alp_compressed.exponents(),
-            alp_compressed.patches().cloned(),
+            alp_compressed.patches(),
         )
         .unwrap()
         .into_array()
@@ -135,7 +143,7 @@ mod setup {
         let codes_prim = PrimitiveArray::from_iter(codes);
 
         // Compress codes with BitPacked (6 bits should be enough for ~50 unique values)
-        let codes_bp = BitPackedArray::encode(codes_prim.as_ref(), 6)
+        let codes_bp = BitPacked::encode(&codes_prim.into_array(), 6)
             .unwrap()
             .into_array();
 
@@ -166,25 +174,25 @@ mod setup {
         }
 
         let prim_array = PrimitiveArray::from_iter(values);
-        let runend = RunEndArray::encode(prim_array.into_array()).unwrap();
+        let runend = RunEnd::encode(prim_array.into_array()).unwrap();
 
         // Compress the ends with FoR <- BitPacked
         let ends_prim = runend.ends().to_primitive();
-        let ends_for = FoRArray::encode(ends_prim).unwrap();
+        let ends_for = FoR::encode(ends_prim).unwrap();
         let ends_inner = ends_for.encoded();
-        let ends_bp = BitPackedArray::encode(ends_inner, 8).unwrap();
+        let ends_bp = BitPacked::encode(ends_inner, 8).unwrap();
         let compressed_ends =
-            FoRArray::try_new(ends_bp.into_array(), ends_for.reference_scalar().clone())
+            FoR::try_new(ends_bp.into_array(), ends_for.reference_scalar().clone())
                 .unwrap()
                 .into_array();
 
         // Compress the values with BitPacked
         let values_prim = runend.values().to_primitive();
-        let compressed_values = BitPackedArray::encode(values_prim.as_ref(), 8)
+        let compressed_values = BitPacked::encode(&values_prim.into_array(), 8)
             .unwrap()
             .into_array();
 
-        RunEndArray::try_new(compressed_ends, compressed_values)
+        RunEnd::try_new(compressed_ends, compressed_values)
             .unwrap()
             .into_array()
     }
@@ -207,7 +215,12 @@ mod setup {
         // Train and compress unique values with FSST
         let unique_varbinview = VarBinViewArray::from_iter_str(unique_strings);
         let fsst_compressor = fsst_train_compressor(&unique_varbinview);
-        let fsst_values = fsst_compress(&unique_varbinview, &fsst_compressor);
+        let fsst_values = fsst_compress(
+            &unique_varbinview,
+            unique_varbinview.len(),
+            unique_varbinview.dtype(),
+            &fsst_compressor,
+        );
 
         // Create codes array (random indices into unique values)
         let codes: Vec<u32> = (0..NUM_VALUES)
@@ -239,24 +252,31 @@ mod setup {
         // Train and compress unique values with FSST
         let unique_varbinview = VarBinViewArray::from_iter_str(unique_strings);
         let fsst_compressor = fsst_train_compressor(&unique_varbinview);
-        let fsst = fsst_compress(&unique_varbinview, &fsst_compressor);
+        let fsst = fsst_compress(
+            &unique_varbinview,
+            unique_varbinview.len(),
+            unique_varbinview.dtype(),
+            &fsst_compressor,
+        );
 
         // Compress the VarBin offsets with BitPacked
         let codes = fsst.codes();
         let offsets_prim = codes.offsets().to_primitive();
-        let offsets_bp = BitPackedArray::encode(offsets_prim.as_ref(), 20).unwrap();
+        let offsets_bp = BitPacked::encode(&offsets_prim.into_array(), 20).unwrap();
 
         // Rebuild VarBin with compressed offsets
         let compressed_codes = VarBinArray::try_new(
             offsets_bp.into_array(),
             codes.bytes().clone(),
             codes.dtype().clone(),
-            codes.validity().clone(),
+            codes
+                .validity()
+                .vortex_expect("FSST code validity should be derivable"),
         )
         .unwrap();
 
         // Rebuild FSST with compressed codes
-        let compressed_fsst = FSSTArray::try_new(
+        let compressed_fsst = FSST::try_new(
             fsst.dtype().clone(),
             fsst.symbols().clone(),
             fsst.symbol_lengths().clone(),
@@ -295,20 +315,20 @@ mod setup {
 
         // Compress days with FoR <- BitPacked
         let days_prim = parts.days.to_primitive();
-        let days_for = FoRArray::encode(days_prim).unwrap();
+        let days_for = FoR::encode(days_prim).unwrap();
         let days_inner = days_for.encoded();
-        let days_bp = BitPackedArray::encode(days_inner, 16).unwrap();
+        let days_bp = BitPacked::encode(days_inner, 16).unwrap();
         let compressed_days =
-            FoRArray::try_new(days_bp.into_array(), days_for.reference_scalar().clone())
+            FoR::try_new(days_bp.into_array(), days_for.reference_scalar().clone())
                 .unwrap()
                 .into_array();
 
         // Compress seconds with FoR <- BitPacked
         let seconds_prim = parts.seconds.to_primitive();
-        let seconds_for = FoRArray::encode(seconds_prim).unwrap();
+        let seconds_for = FoR::encode(seconds_prim).unwrap();
         let seconds_inner = seconds_for.encoded();
-        let seconds_bp = BitPackedArray::encode(seconds_inner, 17).unwrap();
-        let compressed_seconds = FoRArray::try_new(
+        let seconds_bp = BitPacked::encode(seconds_inner, 17).unwrap();
+        let compressed_seconds = FoR::try_new(
             seconds_bp.into_array(),
             seconds_for.reference_scalar().clone(),
         )
@@ -317,17 +337,17 @@ mod setup {
 
         // Compress subseconds with FoR <- BitPacked
         let subseconds_prim = parts.subseconds.to_primitive();
-        let subseconds_for = FoRArray::encode(subseconds_prim).unwrap();
+        let subseconds_for = FoR::encode(subseconds_prim).unwrap();
         let subseconds_inner = subseconds_for.encoded();
-        let subseconds_bp = BitPackedArray::encode(subseconds_inner, 20).unwrap();
-        let compressed_subseconds = FoRArray::try_new(
+        let subseconds_bp = BitPacked::encode(subseconds_inner, 20).unwrap();
+        let compressed_subseconds = FoR::try_new(
             subseconds_bp.into_array(),
             subseconds_for.reference_scalar().clone(),
         )
         .unwrap()
         .into_array();
 
-        DateTimePartsArray::try_new(
+        DateTimeParts::try_new(
             DType::Extension(temporal_array.ext_dtype()),
             compressed_days,
             compressed_seconds,
diff --git a/vortex/benches/pipeline.rs b/vortex/benches/pipeline.rs
index d34e89cc27d..d6c668e0607 100644
--- a/vortex/benches/pipeline.rs
+++ b/vortex/benches/pipeline.rs
@@ -116,7 +116,7 @@
 
 use divan::Bencher;
 use fastlanes::BitPacking;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_alp::ALPFloat;
diff --git a/vortex/benches/single_encoding_throughput.rs b/vortex/benches/single_encoding_throughput.rs
index f13e2d019c7..091b9a6747f 100644
--- a/vortex/benches/single_encoding_throughput.rs
+++ b/vortex/benches/single_encoding_throughput.rs
@@ -2,13 +2,16 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::cast_possible_truncation)]
 #![allow(unexpected_cfgs)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 #[cfg(not(codspeed))]
 use divan::counter::BytesCount;
 use mimalloc::MiMalloc;
-use rand::Rng;
+use rand::RngExt;
 use rand::SeedableRng;
 use rand::prelude::IndexedRandom;
 use rand::rngs::StdRng;
@@ -18,27 +21,38 @@ use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::VarBinViewArray;
 use vortex::array::builders::dict::dict_encode;
 use vortex::array::builtins::ArrayBuiltins;
+use vortex::array::dtype::Nullability;
+use vortex::array::session::ArraySession;
 use vortex::dtype::PType;
 use vortex::encodings::alp::RDEncoder;
 use vortex::encodings::alp::alp_encode;
-use vortex::encodings::fastlanes::DeltaArray;
-use vortex::encodings::fastlanes::FoRArray;
+use vortex::encodings::fastlanes::Delta;
+use vortex::encodings::fastlanes::DeltaData;
+use vortex::encodings::fastlanes::FoR;
 use vortex::encodings::fastlanes::delta_compress;
 use vortex::encodings::fsst::fsst_compress;
 use vortex::encodings::fsst::fsst_train_compressor;
-use vortex::encodings::pco::PcoArray;
-use vortex::encodings::runend::RunEndArray;
+use vortex::encodings::pco::Pco;
+use vortex::encodings::runend::RunEnd;
+use vortex::encodings::sequence::sequence_encode;
 use vortex::encodings::zigzag::zigzag_encode;
-use vortex::encodings::zstd::ZstdArray;
+use vortex::encodings::zstd::Zstd;
+use vortex::encodings::zstd::ZstdData;
+use vortex_array::VortexSessionExecute;
+use vortex_sequence::Sequence;
+use vortex_session::VortexSession;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 fn main() {
     divan::main();
 }
 
-const NUM_VALUES: u64 = 1_000_000;
+const NUM_VALUES: u64 = 100_000;
 
 // Helper function to conditionally add counter based on codspeed cfg
 fn with_byte_counter<'a, 'b>(bencher: Bencher<'a, 'b>, bytes: u64) -> Bencher<'a, 'b> {
@@ -57,12 +71,14 @@ fn setup_primitive_arrays() -> (PrimitiveArray, PrimitiveArray, PrimitiveArray)
     let uint_array =
         PrimitiveArray::from_iter((0..NUM_VALUES).map(|_| rng.random_range(42u32..256)));
     let int_array = uint_array
-        .to_array()
+        .clone()
+        .into_array()
         .cast(PType::I32.into())
         .unwrap()
         .to_primitive();
     let float_array = uint_array
-        .to_array()
+        .clone()
+        .into_array()
         .cast(PType::F64.into())
         .unwrap()
         .to_primitive();
@@ -104,7 +120,9 @@ fn bench_bitpacked_decompress_u32(bencher: Bencher) {
 
     let (uint_array, ..) = setup_primitive_arrays();
     let bit_width = 8;
-    let compressed = bitpack_encode(&uint_array, bit_width, None).unwrap();
+    let compressed = bitpack_encode(&uint_array, bit_width, None)
+        .unwrap()
+        .into_array();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -117,13 +135,13 @@ fn bench_runend_compress_u32(bencher: Bencher) {
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| uint_array.clone())
-        .bench_values(|a| RunEndArray::encode(a.into_array()).unwrap());
+        .bench_values(|a| RunEnd::encode(a.into_array()).unwrap());
 }
 
 #[divan::bench(name = "runend_decompress_u32")]
 fn bench_runend_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
-    let compressed = RunEndArray::encode(uint_array.into_array()).unwrap();
+    let compressed = RunEnd::encode(uint_array.into_array()).unwrap();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -137,18 +155,18 @@ fn bench_delta_compress_u32(bencher: Bencher) {
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &uint_array)
         .bench_refs(|a| {
-            let (bases, deltas) = delta_compress(a).unwrap();
-            DeltaArray::try_from_delta_compress_parts(bases.into_array(), deltas.into_array())
-                .unwrap()
+            let (_bases, _deltas) = delta_compress(a, &mut SESSION.create_execution_ctx()).unwrap();
+            DeltaData::try_new(0).unwrap()
         });
 }
 
 #[divan::bench(name = "delta_decompress_u32")]
 fn bench_delta_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
-    let (bases, deltas) = delta_compress(&uint_array).unwrap();
-    let compressed =
-        DeltaArray::try_from_delta_compress_parts(bases.into_array(), deltas.into_array()).unwrap();
+    let (bases, deltas) = delta_compress(&uint_array, &mut SESSION.create_execution_ctx()).unwrap();
+    let compressed = Delta::try_new(bases.into_array(), deltas.into_array(), 0, uint_array.len())
+        .unwrap()
+        .into_array();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -161,13 +179,13 @@ fn bench_for_compress_i32(bencher: Bencher) {
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| int_array.clone())
-        .bench_values(|a| FoRArray::encode(a).unwrap());
+        .bench_values(|a| FoR::encode(a).unwrap());
 }
 
 #[divan::bench(name = "for_decompress_i32")]
 fn bench_for_decompress_i32(bencher: Bencher) {
     let (_, int_array, _) = setup_primitive_arrays();
-    let compressed = FoRArray::encode(int_array).unwrap();
+    let compressed = FoR::encode(int_array).unwrap();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -180,13 +198,13 @@ fn bench_dict_compress_u32(bencher: Bencher) {
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &uint_array)
-        .bench_refs(|a| dict_encode(a.as_ref()).unwrap());
+        .bench_refs(|a| dict_encode(&a.clone().into_array()).unwrap());
 }
 
 #[divan::bench(name = "dict_decompress_u32")]
 fn bench_dict_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
-    let compressed = dict_encode(uint_array.as_ref()).unwrap();
+    let compressed = dict_encode(&uint_array.into_array()).unwrap();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -205,7 +223,29 @@ fn bench_zigzag_compress_i32(bencher: Bencher) {
 #[divan::bench(name = "zigzag_decompress_i32")]
 fn bench_zigzag_decompress_i32(bencher: Bencher) {
     let (_, int_array, _) = setup_primitive_arrays();
-    let compressed = zigzag_encode(int_array).unwrap();
+    let compressed = zigzag_encode(int_array).unwrap().into_array();
+
+    with_byte_counter(bencher, NUM_VALUES * 4)
+        .with_inputs(|| &compressed)
+        .bench_refs(|a| a.to_canonical());
+}
+
+#[expect(clippy::cast_possible_truncation)]
+#[divan::bench(name = "sequence_compress_u32")]
+fn bench_sequence_compress_u32(bencher: Bencher) {
+    let seq_array = PrimitiveArray::from_iter(0..NUM_VALUES as u32);
+
+    with_byte_counter(bencher, NUM_VALUES * 4)
+        .with_inputs(|| seq_array.clone())
+        .bench_values(|a| sequence_encode(&a).unwrap().unwrap());
+}
+
+#[expect(clippy::cast_possible_truncation)]
+#[divan::bench(name = "sequence_decompress_u32")]
+fn bench_sequence_decompress_u32(bencher: Bencher) {
+    let compressed = Sequence::try_new_typed(0, 1, Nullability::NonNullable, NUM_VALUES as usize)
+        .unwrap()
+        .into_array();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -260,13 +300,13 @@ fn bench_pcodec_compress_f64(bencher: Bencher) {
 
     with_byte_counter(bencher, NUM_VALUES * 8)
         .with_inputs(|| &float_array)
-        .bench_refs(|a| PcoArray::from_primitive(a, 3, 0).unwrap());
+        .bench_refs(|a| Pco::from_primitive(a, 3, 0).unwrap());
 }
 
 #[divan::bench(name = "pcodec_decompress_f64")]
 fn bench_pcodec_decompress_f64(bencher: Bencher) {
     let (_, _, float_array) = setup_primitive_arrays();
-    let compressed = PcoArray::from_primitive(&float_array, 3, 0).unwrap();
+    let compressed = Pco::from_primitive(&float_array, 3, 0).unwrap();
 
     with_byte_counter(bencher, NUM_VALUES * 8)
         .with_inputs(|| &compressed)
@@ -281,14 +321,22 @@ fn bench_zstd_compress_u32(bencher: Bencher) {
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| array.clone())
-        .bench_values(|a| ZstdArray::from_array(a, 3, 8192).unwrap());
+        .bench_values(|a| ZstdData::from_array(a, 3, 8192).unwrap());
 }
 
 #[cfg(feature = "zstd")]
 #[divan::bench(name = "zstd_decompress_u32")]
 fn bench_zstd_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
-    let compressed = ZstdArray::from_array(uint_array.into_array(), 3, 8192).unwrap();
+    let dtype = uint_array.dtype().clone();
+    let validity = uint_array.validity().unwrap();
+    let compressed = Zstd::try_new(
+        dtype,
+        ZstdData::from_array(uint_array.into_array(), 3, 8192).unwrap(),
+        validity,
+    )
+    .unwrap()
+    .into_array();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| &compressed)
@@ -298,18 +346,20 @@ fn bench_zstd_decompress_u32(bencher: Bencher) {
 // String compression benchmarks
 #[divan::bench(name = "dict_compress_string")]
 fn bench_dict_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let nbytes = varbinview_arr.nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
         .with_inputs(|| &varbinview_arr)
-        .bench_refs(|a| dict_encode(a.as_ref()).unwrap());
+        .bench_refs(|a| dict_encode(&a.clone().into_array()).unwrap());
 }
 
 #[divan::bench(name = "dict_decompress_string")]
 fn bench_dict_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
-    let dict = dict_encode(varbinview_arr.as_ref()).unwrap();
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
+    let dict = dict_encode(&varbinview_arr.clone().into_array()).unwrap();
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
@@ -319,20 +369,27 @@ fn bench_dict_decompress_string(bencher: Bencher) {
 
 #[divan::bench(name = "fsst_compress_string")]
 fn bench_fsst_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let fsst_compressor = fsst_train_compressor(&varbinview_arr);
     let nbytes = varbinview_arr.nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
         .with_inputs(|| &varbinview_arr)
-        .bench_refs(|a| fsst_compress(*a, &fsst_compressor));
+        .bench_refs(|a| fsst_compress(*a, a.len(), a.dtype(), &fsst_compressor));
 }
 
 #[divan::bench(name = "fsst_decompress_string")]
 fn bench_fsst_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let fsst_compressor = fsst_train_compressor(&varbinview_arr);
-    let fsst_array = fsst_compress(&varbinview_arr, &fsst_compressor);
+    let fsst_array = fsst_compress(
+        &varbinview_arr,
+        varbinview_arr.len(),
+        varbinview_arr.dtype(),
+        &fsst_compressor,
+    );
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
@@ -343,23 +400,168 @@ fn bench_fsst_decompress_string(bencher: Bencher) {
 #[cfg(feature = "zstd")]
 #[divan::bench(name = "zstd_compress_string")]
 fn bench_zstd_compress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let nbytes = varbinview_arr.nbytes() as u64;
     let array = varbinview_arr.into_array();
 
     with_byte_counter(bencher, nbytes)
         .with_inputs(|| array.clone())
-        .bench_values(|a| ZstdArray::from_array(a, 3, 8192).unwrap());
+        .bench_values(|a| ZstdData::from_array(a, 3, 8192).unwrap());
 }
 
 #[cfg(feature = "zstd")]
 #[divan::bench(name = "zstd_decompress_string")]
 fn bench_zstd_decompress_string(bencher: Bencher) {
-    let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(1_000_000, 0.00005));
-    let compressed = ZstdArray::from_array(varbinview_arr.clone().into_array(), 3, 8192).unwrap();
+    let varbinview_arr =
+        VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
+    let dtype = varbinview_arr.dtype().clone();
+    let validity = varbinview_arr.validity().unwrap();
+    let compressed = Zstd::try_new(
+        dtype,
+        ZstdData::from_array(varbinview_arr.clone().into_array(), 3, 8192).unwrap(),
+        validity,
+    )
+    .unwrap()
+    .into_array();
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
         .with_inputs(|| &compressed)
         .bench_refs(|a| a.to_canonical());
 }
+
+// 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::ApproxOptions;
+    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: Some(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(&ApproxOptions::Exact, 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_compress_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())
+                        .bench_refs(|a| {
+                            let mut ctx = SESSION.create_execution_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, &mut 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)
+                        .bench_refs(|a| {
+                            let mut ctx = SESSION.create_execution_ctx();
+                            a.clone()
+                                .into_array()
+                                .execute::<ExtensionArray>(&mut 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/compression_showcase.rs b/vortex/examples/compression_showcase.rs
index e9bb8b24da7..7560cc377c8 100644
--- a/vortex/examples/compression_showcase.rs
+++ b/vortex/examples/compression_showcase.rs
@@ -8,7 +8,7 @@
 //!
 //! Run with: cargo run --example compression_showcase
 
-use vortex::array::Array;
+use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::StructArray;
@@ -57,13 +57,13 @@ fn compress_sequential_data() -> Result<(), Box<dyn std::error::Error>> {
     // Create sequential data (e.g., timestamps, IDs)
     let sequential: PrimitiveArray = (1000..11000).map(|i| i as u64).collect();
 
-    let uncompressed_size = estimate_size(sequential.as_ref());
+    let uncompressed_size = estimate_size(&sequential.clone().into_array());
     println!("  Original sequential data (10,000 values):");
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     // Compress using default strategy
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(sequential.as_ref())?;
+    let compressed = compressor.compress(&sequential.into_array())?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -86,12 +86,12 @@ fn compress_repetitive_data() -> Result<(), Box<dyn std::error::Error>> {
     }
     let array: PrimitiveArray = repetitive.into_iter().collect();
 
-    let uncompressed_size = estimate_size(array.as_ref());
+    let uncompressed_size = estimate_size(&array.clone().into_array());
     println!("  Repetitive data (100 values, each repeated 100 times):");
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(array.as_ref())?;
+    let compressed = compressor.compress(&array.into_array())?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -118,12 +118,12 @@ fn compress_string_data() -> Result<(), Box<dyn std::error::Error>> {
 
     let array = VarBinArray::from_iter(strings, DType::Utf8(Nullability::NonNullable));
 
-    let uncompressed_size = estimate_size(array.as_ref());
+    let uncompressed_size = estimate_size(&array.clone().into_array());
     println!("  Categorical string data (10,000 strings, 4 categories):");
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(array.as_ref())?;
+    let compressed = compressor.compress(&array.into_array())?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -146,7 +146,7 @@ fn compress_float_data() -> Result<(), Box<dyn std::error::Error>> {
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(array.as_ref())?;
+    let compressed = compressor.compress(&array)?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -167,12 +167,12 @@ fn compress_sparse_data() -> Result<(), Box<dyn std::error::Error>> {
     }
     let array: PrimitiveArray = sparse.into_iter().collect();
 
-    let uncompressed_size = estimate_size(array.as_ref());
+    let uncompressed_size = estimate_size(&array.clone().into_array());
     println!("  Sparse data (10,000 values, 99% zeros):");
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(array.as_ref())?;
+    let compressed = compressor.compress(&array.into_array())?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -217,12 +217,12 @@ fn compress_structured_data() -> Result<(), Box<dyn std::error::Error>> {
         Validity::NonNullable,
     )?;
 
-    let uncompressed_size = estimate_size(struct_array.as_ref());
+    let uncompressed_size = estimate_size(&struct_array.clone().into_array());
     println!("  Structured data (5,000 records, 3 columns):");
     println!("    Uncompressed size: ~{} bytes", uncompressed_size);
 
     let compressor = BtrBlocksCompressor::default();
-    let compressed = compressor.compress(struct_array.as_ref())?;
+    let compressed = compressor.compress(&struct_array.into_array())?;
 
     let compressed_size = compressed.nbytes();
     let ratio = uncompressed_size as f64 / compressed_size as f64;
@@ -237,6 +237,6 @@ fn compress_structured_data() -> Result<(), Box<dyn std::error::Error>> {
 
 /// Estimate the size of an array in bytes (approximation)
 #[allow(clippy::cast_possible_truncation)]
-fn estimate_size(array: &dyn Array) -> usize {
+fn estimate_size(array: &ArrayRef) -> usize {
     array.nbytes() as usize
 }
diff --git a/vortex/examples/tracing_vortex.rs b/vortex/examples/tracing_vortex.rs
index aa456a44f5f..8d7dd6b2701 100644
--- a/vortex/examples/tracing_vortex.rs
+++ b/vortex/examples/tracing_vortex.rs
@@ -37,11 +37,12 @@ use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::StructArray;
 use vortex::array::arrays::VarBinArray;
+use vortex::array::stream::ArrayStreamExt;
 use vortex::array::validity::Validity;
+use vortex::compressor::BtrBlocksCompressorBuilder;
 use vortex::dtype::DType;
 use vortex::dtype::Nullability;
 use vortex::file::WriteStrategyBuilder;
-use vortex_array::stream::ArrayStreamExt;
 use vortex_file::OpenOptionsSessionExt;
 use vortex_file::WriteOptionsSessionExt;
 use vortex_session::VortexSession;
@@ -197,7 +198,7 @@ impl VortexLayer {
         let handle = WriterHandle::spawn(session, rx, output_dir, batch_size);
         (
             Self {
-                sender: signal.clone(),
+                sender: Arc::clone(&signal),
             },
             handle,
             ShutdownSignal { inner: signal },
@@ -388,12 +389,12 @@ async fn write_batch_to_vortex(
     // Use compact encodings (Pco + Zstd) for the telemetry files.
     let write_opts = session.write_options().with_strategy(
         WriteStrategyBuilder::default()
-            .with_compact_encodings()
+            .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
             .build(),
     );
 
     write_opts
-        .write(&mut file, struct_array.to_array_stream())
+        .write(&mut file, struct_array.into_array().to_array_stream())
         .await?;
 
     println!(
diff --git a/vortex/public-api.lock b/vortex/public-api.lock
index a823449de25..7be026902db 100644
--- a/vortex/public-api.lock
+++ b/vortex/public-api.lock
@@ -1,5 +1,7 @@
 pub mod vortex
 
+pub use vortex::aggregate_fn
+
 pub use vortex::compute
 
 pub use vortex::expr
@@ -20,11 +22,9 @@ pub use vortex::compressor::BtrBlocksCompressor
 
 pub use vortex::compressor::BtrBlocksCompressorBuilder
 
-pub use vortex::compressor::FloatCode
-
-pub use vortex::compressor::IntCode
+pub use vortex::compressor::Scheme
 
-pub use vortex::compressor::StringCode
+pub use vortex::compressor::SchemeId
 
 pub mod vortex::dtype
 
diff --git a/vortex/src/lib.rs b/vortex/src/lib.rs
index b5b374d9861..9053dbc7505 100644
--- a/vortex/src/lib.rs
+++ b/vortex/src/lib.rs
@@ -5,6 +5,8 @@
 #![doc = include_str!(concat!("../", env!("CARGO_PKG_README")))]
 
 // vortex::compute is deprecated and will be ported over to expressions.
+pub use vortex_array::aggregate_fn;
+use vortex_array::aggregate_fn::session::AggregateFnSession;
 pub use vortex_array::compute;
 use vortex_array::dtype::session::DTypeSession;
 // vortex::expr is in the process of having its dependencies inverted, and will eventually be
@@ -34,9 +36,8 @@ pub mod buffer {
 pub mod compressor {
     pub use vortex_btrblocks::BtrBlocksCompressor;
     pub use vortex_btrblocks::BtrBlocksCompressorBuilder;
-    pub use vortex_btrblocks::FloatCode;
-    pub use vortex_btrblocks::IntCode;
-    pub use vortex_btrblocks::StringCode;
+    pub use vortex_btrblocks::Scheme;
+    pub use vortex_btrblocks::SchemeId;
 }
 
 pub mod dtype {
@@ -158,17 +159,17 @@ pub trait VortexSessionDefault {
 }
 
 impl VortexSessionDefault for VortexSession {
-    #[allow(unused_mut)]
     fn default() -> VortexSession {
-        let mut session = VortexSession::empty()
+        let session = VortexSession::empty()
             .with::<DTypeSession>()
             .with::<ArraySession>()
             .with::<LayoutSession>()
             .with::<ScalarFnSession>()
+            .with::<AggregateFnSession>()
             .with::<RuntimeSession>();
 
         #[cfg(feature = "files")]
-        file::register_default_encodings(&mut session);
+        file::register_default_encodings(&session);
 
         session
     }
@@ -183,7 +184,8 @@ mod test {
 
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
+    use vortex_array::LEGACY_SESSION;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
     use vortex_array::dtype::FieldNames;
@@ -193,7 +195,7 @@ mod test {
     use vortex_array::expr::select;
     use vortex_array::stream::ArrayStreamExt;
     use vortex_array::validity::Validity;
-    use vortex_array::vtable::ValidityHelper;
+    use vortex_btrblocks::BtrBlocksCompressorBuilder;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_file::OpenOptionsSessionExt;
@@ -211,11 +213,10 @@ mod test {
 
         use arrow_array::RecordBatchReader;
         use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
-        use vortex::array::Array;
         use vortex::array::arrays::ChunkedArray;
+        use vortex::array::arrow::FromArrowArray;
         use vortex::dtype::DType;
         use vortex::dtype::arrow::FromArrowType;
-        use vortex_array::arrow::FromArrowArray;
 
         let reader = ParquetRecordBatchReaderBuilder::try_new(File::open(
             "../docs/_static/example.parquet",
@@ -245,11 +246,11 @@ mod test {
         let array = PrimitiveArray::new(buffer![42u64; 100_000], Validity::NonNullable);
 
         // You can compress an array in-memory with the BtrBlocks compressor
-        let compressed = BtrBlocksCompressor::default().compress(array.as_ref())?;
+        let compressed = BtrBlocksCompressor::default().compress(&array.clone().into_array())?;
         println!(
             "BtrBlocks size: {} / {}",
             compressed.nbytes(),
-            array.nbytes()
+            array.into_array().nbytes()
         );
         // [compress]
 
@@ -270,7 +271,7 @@ mod test {
             .write_options()
             .write(
                 &mut tokio::fs::File::create(&path).await?,
-                array.to_array_stream(),
+                array.into_array().to_array_stream(),
             )
             .await?;
 
@@ -309,12 +310,12 @@ mod test {
             .write_options()
             .with_strategy(
                 WriteStrategyBuilder::default()
-                    .with_compact_encodings()
+                    .with_btrblocks_builder(BtrBlocksCompressorBuilder::default().with_compact())
                     .build(),
             )
             .write(
                 &mut tokio::fs::File::create(&path).await?,
-                array.to_array_stream(),
+                array.clone().into_array().to_array_stream(),
             )
             .await?;
 
@@ -329,8 +330,15 @@ mod test {
             .await?;
 
         assert_eq!(recovered_array.len(), array.len());
-        let recovered_primitive = recovered_array.to_primitive();
-        assert_eq!(recovered_primitive.validity(), array.validity());
+
+        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_eq!(
             recovered_primitive.to_buffer::<u64>(),
             array.to_buffer::<u64>()
@@ -364,7 +372,7 @@ mod test {
             .write_options()
             .write(
                 &mut tokio::fs::File::create(&path).await?,
-                array.to_array_stream(),
+                array.into_array().to_array_stream(),
             )
             .await?;
 
diff --git a/wasm-test/Cargo.toml b/wasm-test/Cargo.toml
index b6494bf0e2c..100c15970b0 100644
--- a/wasm-test/Cargo.toml
+++ b/wasm-test/Cargo.toml
@@ -9,8 +9,10 @@ publish = false
 edition = "2024"
 rust-version = "1.86"
 
-#[lib]
-#crate-type = ["cdylib"]
-
 [dependencies]
 vortex = { path = "../vortex", default-features = false }
+
+[profile.ci]
+inherits = "dev"
+debug = "line-tables-only"
+incremental = false
diff --git a/wasm-test/src/main.rs b/wasm-test/src/main.rs
index 8be0ac82570..67617c37955 100644
--- a/wasm-test/src/main.rs
+++ b/wasm-test/src/main.rs
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex::array::IntoArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::validity::Validity;
-use vortex::array::Array;
 use vortex::buffer::buffer;
 use vortex::compressor::BtrBlocksCompressor;
 
@@ -11,7 +11,7 @@ use vortex::compressor::BtrBlocksCompressor;
 
 pub fn main() {
     // Extremely simple test of compression/decompression and a few compute functions.
-    let array = PrimitiveArray::new(buffer![1i32; 1024], Validity::AllValid).to_array();
+    let array = PrimitiveArray::new(buffer![1i32; 1024], Validity::AllValid).into_array();
 
     let compressed = BtrBlocksCompressor::default().compress(&array).unwrap();
     println!("Compressed size: {}", compressed.len());